pax_global_header00006660000000000000000000000064144602117400014511gustar00rootroot0000000000000052 comment=b17054b92338d22db46ea0e2c63037b3e50190da gtkada-24.0.0/000077500000000000000000000000001446021174000130275ustar00rootroot00000000000000gtkada-24.0.0/.cvsignore000066400000000000000000000000571446021174000150310ustar00rootroot00000000000000Makefile config.cache config.log config.status gtkada-24.0.0/.gitattributes000066400000000000000000000003251446021174000157220ustar00rootroot00000000000000src/generated/* no-precommit-check src/misc_generated.c no-precommit-check # Too much work to clean up contrib/binding.py no-precommit-check gtkada-24.0.0/.github/000077500000000000000000000000001446021174000143675ustar00rootroot00000000000000gtkada-24.0.0/.github/workflows/000077500000000000000000000000001446021174000164245ustar00rootroot00000000000000gtkada-24.0.0/.github/workflows/gnat-ce.yml000066400000000000000000000064721446021174000204760ustar00rootroot00000000000000# Build with GNAT Community compiler on: [push, pull_request, workflow_dispatch] # Manual launch name: GNAT CE Build jobs: build: name: Do # intentionly short strategy: fail-fast: false matrix: # Build debug and production build_type: ['Debug', 'Production'] os: [macos-latest, ubuntu-latest, windows-latest] runs-on: ${{ matrix.os }} steps: - name: Install Gtk (Linux only) if: ${{ runner.os == 'Linux' }} run: | sudo apt-get install -y pkg-config libgtk-3-dev - name: Install Gtk (Windows only) if: ${{ runner.os == 'Windows' }} uses: msys2/setup-msys2@v2 with: path-type: inherit update: true install: >- mingw64/mingw-w64-x86_64-gtk3 mingw64/mingw-w64-x86_64-pkg-config mingw64/mingw-w64-x86_64-winpthreads-git msys/make - name: Set up Homebrew (Mac OS X only) if: ${{ runner.os == 'macOS' }} uses: Homebrew/actions/setup-homebrew@master - name: Install Gtk (Mac OS X only) if: ${{ runner.os == 'macOS' }} run: | brew install --verbose gtk+3 brew install --verbose pkg-config - name: Get GtkAda uses: actions/checkout@v3 - uses: actions/cache@v3 with: path: ./cached_gnat key: ${{ runner.os }}-gnat-ce-2020 restore-keys: ${{ runner.os }}-gnat-ce-2020 - name: Get GNAT Community 2020 toolchain uses: ada-actions/toolchain@ce2020 with: distrib: community install_dir: ./cached_gnat - name: Build GtkAda (Windows only) if: ${{ runner.os == 'Windows' }} shell: msys2 {0} run: | # To find libpthread.dll on msys2: export LIBRARY_PATH=/mingw64/x86_64-w64-mingw32/lib/ ./configure --disable-static-pic --disable-static --with-GL=no --enable-build=${{ matrix.build_type }} --prefix=$PWD/prefix make all install - name: Build GtkAda (non-Windows) if: ${{ runner.os != 'Windows' }} run: | ./configure --disable-static-pic --disable-static --with-GL=no --enable-build=${{ matrix.build_type }} --prefix=$PWD/prefix make all install - name: Archive binaries shell: bash run: | NAME=gtkada-`basename $GITHUB_REF`-${{ runner.os }} tar czf ${NAME}.tar.gz -C prefix . if [ '${{ matrix.build_type }}' = 'Debug' ]; then mv ${NAME}.tar.gz ${NAME}-dbg.tar.gz fi - name: Keep artifacts uses: actions/upload-artifact@v3 with: name: ${{ runner.os }}-${{ matrix.debug }} path: '*.tar.gz' - name: AWS S3 upload if: ${{ github.event_name != 'pull_request' && (github.ref == 'refs/heads/master' || github.ref == 'refs/heads/edge' || github.ref == 'refs/heads/gtk-3.24') }} env: AWS_ACCESS_KEY_ID: ${{secrets.GHA_CACHE_ACCESS_KEY_ID}} AWS_SECRET_ACCESS_KEY: ${{secrets.GHA_CACHE_SECRET}} AWS_DEFAULT_REGION: eu-west-1 run: | aws s3 cp . s3://adacore-gha-tray-eu-west-1/gtkada/ --recursive --exclude "*" --include "*.tar.gz" --sse=AES256 aws s3 ls s3://adacore-gha-tray-eu-west-1/gtkada/ gtkada-24.0.0/.github/workflows/native.yml000066400000000000000000000025021446021174000204340ustar00rootroot00000000000000# Build GtkAda using native compiler and libs on: push: branches: - master - gtk-3.22.30 pull_request: branches: - master - gtk-3.22.30 name: Native (FSF) Build jobs: ubuntu: runs-on: ubuntu-latest name: Native on Ubuntu steps: - name: Get GtkAda uses: actions/checkout@v3 - name: Install packages run: | sudo apt-get -qq update sudo apt-get install -y cmake g++ gnat gprbuild pkg-config libgtk-3-dev make - name: Build GtkAda run: | ./configure --disable-static-pic --disable-static --with-GL=no --prefix=$PWD/prefix make all install windows: runs-on: windows-latest name: Native on Windows defaults: run: shell: msys2 {0} steps: - name: Get GtkAda uses: actions/checkout@v3 - name: Install packages uses: msys2/setup-msys2@v2 with: update: true install: >- mingw64/mingw-w64-x86_64-gtk3 mingw64/mingw-w64-x86_64-gprbuild mingw64/mingw-w64-x86_64-gcc-ada mingw64/mingw-w64-x86_64-pkg-config msys/make - name: Build GtkAda run: | ./configure --disable-static-pic --disable-static --with-GL=no --prefix=$PWD/prefix make all install gtkada-24.0.0/.gitignore000066400000000000000000000015451446021174000150240ustar00rootroot00000000000000*.ali *.exe *.o *.orig *.pyc b__conftest.ad? auto.cgpr autom4te.cache/ /Makefile docs/gtkada_rm/doc_obj/ docs/gtkada_ug/_build src/Makefile src/gnome/Makefile src/gtkextra/Makefile src/opengl/Makefile src/tools/Makefile src/generated/tmp.ada testgtk/Makefile po/Makefile b~*.ad* config.log config.status gtk_shared.gpr contrib/generated/*.ad? contrib/generated/tmp.ada src/Makefile.common src/gtkada-intl.adb src/gtkextra/obj src/lib src/obj src/gnome/obj/libgnomeada-* src/opengl/obj/libgtkada_gl-* src/tools/gate src/tools/obj testgtk.exe testgtk/obj testgtk/opengl/view_gl.adb testgtk/testgtk testgtk/test_graph testgtk/test_rtree testgtk/testcairo testgtk/application testgtk/try.png docs/gtkada_rm/gtkada_rm/ docs/gtkada_rm/html/static/index.html docs/gtkada_ug/gtkada_ug.html docs/gtkada_ug/gtkada_ug.info docs/gtkada_ug/gtkada_ug.ps docs/gtkada_ug/gtkada_ug.txt gtkada-24.0.0/.gitlab-ci.yml000066400000000000000000000005051446021174000154630ustar00rootroot00000000000000stages: - build build: services: - image:gtk-deps - cpu:8 - mem:16 stage: build interruptible: true rules: - if: $CI_PIPELINE_SOURCE == 'merge_request_event' - if: $CI_PIPELINE_SOURCE == 'pipeline' script: - generic_anod_ci - . /tmp/ci_env.sh # Build - anod build gtkada gtkada-24.0.0/.gitreview000066400000000000000000000001371446021174000150360ustar00rootroot00000000000000[gerrit] host = git.adacore.com project = gtkada defaultbranch = master defaultremote = origin gtkada-24.0.0/ANNOUNCE000066400000000000000000000004411446021174000141570ustar00rootroot00000000000000GtkAda 2.10.1 release --------------------- GtkAda is an Ada graphical toolkit based on Gtk+. It allows you to develop graphical applications in Ada using Gtk+. The primary download site is http://libre.act-europe.fr/GtkAda This version is suitable for use with Gtk+ 2.10.0 and above. gtkada-24.0.0/AUTHORS000066400000000000000000000003711446021174000141000ustar00rootroot00000000000000AUTHORS ======= The authors of GtkAda are Emmanuel Briot Joel Brobecker Arnaud Charlet Nicolas Setton GtkAda is developed and maintained by AdaCore (sales@adacore.com) gtkada-24.0.0/COPYING.RUNTIME000066400000000000000000000064601446021174000152120ustar00rootroot00000000000000GCC RUNTIME LIBRARY EXCEPTION Version 3.1, 31 March 2009 Copyright (c) 2009 Free Software Foundation, Inc. Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. This GCC Runtime Library Exception ("Exception") is an additional permission under section 7 of the GNU General Public License, version 3 ("GPLv3"). It applies to a given file (the "Runtime Library") that bears a notice placed by the copyright holder of the file stating that the file is governed by GPLv3 along with this Exception. When you use GCC to compile a program, GCC may combine portions of certain GCC header files and runtime libraries with the compiled program. The purpose of this Exception is to allow compilation of non-GPL (including proprietary) programs to use, in this way, the header files and runtime libraries covered by this Exception. 0. Definitions. A file is an "Independent Module" if it either requires the Runtime Library for execution after a Compilation Process, or makes use of an interface provided by the Runtime Library, but is not otherwise based on the Runtime Library. "GCC" means a version of the GNU Compiler Collection, with or without modifications, governed by version 3 (or a specified later version) of the GNU General Public License (GPL) with the option of using any subsequent versions published by the FSF. "GPL-compatible Software" is software whose conditions of propagation, modification and use would permit combination with GCC in accord with the license of GCC. "Target Code" refers to output from any compiler for a real or virtual target processor architecture, in executable form or suitable for input to an assembler, loader, linker and/or execution phase. Notwithstanding that, Target Code does not include data in any format that is used as a compiler intermediate representation, or used for producing a compiler intermediate representation. The "Compilation Process" transforms code entirely represented in non-intermediate languages designed for human-written code, and/or in Java Virtual Machine byte code, into Target Code. Thus, for example, use of source code generators and preprocessors need not be considered part of the Compilation Process, since the Compilation Process can be understood as starting with the output of the generators or preprocessors. A Compilation Process is "Eligible" if it is done using GCC, alone or with other GPL-compatible software, or if it is done without using any work based on GCC. For example, using non-GPL-compatible Software to optimize any GCC intermediate representations would not qualify as an Eligible Compilation Process. 1. Grant of Additional Permission. You have permission to propagate a work of Target Code formed by combining the Runtime Library with Independent Modules, even if such propagation would otherwise violate the terms of GPLv3, provided that all Target Code was generated by Eligible Compilation Processes. You may then convey such a combination under terms of your choice, consistent with the licensing of the Independent Modules. 2. No Weakening of GCC Copyleft. The availability of this Exception does not imply any general presumption that third-party software is unaffected by the copyleft requirements of the license of GCC. gtkada-24.0.0/COPYING3000066400000000000000000001045131446021174000141510ustar00rootroot00000000000000 GNU GENERAL PUBLIC LICENSE Version 3, 29 June 2007 Copyright (C) 2007 Free Software Foundation, Inc. Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. Preamble The GNU General Public License is a free, copyleft license for software and other kinds of works. The licenses for most software and other practical works are designed to take away your freedom to share and change the works. By contrast, the GNU General Public License is intended to guarantee your freedom to share and change all versions of a program--to make sure it remains free software for all its users. We, the Free Software Foundation, use the GNU General Public License for most of our software; it applies also to any other work released this way by its authors. You can apply it to your programs, too. When we speak of free software, we are referring to freedom, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for them if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs, and that you know you can do these things. To protect your rights, we need to prevent others from denying you these rights or asking you to surrender the rights. Therefore, you have certain responsibilities if you distribute copies of the software, or if you modify it: responsibilities to respect the freedom of others. For example, if you distribute copies of such a program, whether gratis or for a fee, you must pass on to the recipients the same freedoms that you received. You must make sure that they, too, receive or can get the source code. And you must show them these terms so they know their rights. Developers that use the GNU GPL protect your rights with two steps: (1) assert copyright on the software, and (2) offer you this License giving you legal permission to copy, distribute and/or modify it. For the developers' and authors' protection, the GPL clearly explains that there is no warranty for this free software. For both users' and authors' sake, the GPL requires that modified versions be marked as changed, so that their problems will not be attributed erroneously to authors of previous versions. Some devices are designed to deny users access to install or run modified versions of the software inside them, although the manufacturer can do so. This is fundamentally incompatible with the aim of protecting users' freedom to change the software. The systematic pattern of such abuse occurs in the area of products for individuals to use, which is precisely where it is most unacceptable. Therefore, we have designed this version of the GPL to prohibit the practice for those products. If such problems arise substantially in other domains, we stand ready to extend this provision to those domains in future versions of the GPL, as needed to protect the freedom of users. Finally, every program is threatened constantly by software patents. States should not allow patents to restrict development and use of software on general-purpose computers, but in those that do, we wish to avoid the special danger that patents applied to a free program could make it effectively proprietary. To prevent this, the GPL assures that patents cannot be used to render the program non-free. The precise terms and conditions for copying, distribution and modification follow. TERMS AND CONDITIONS 0. Definitions. "This License" refers to version 3 of the GNU General Public License. "Copyright" also means copyright-like laws that apply to other kinds of works, such as semiconductor masks. "The Program" refers to any copyrightable work licensed under this License. Each licensee is addressed as "you". "Licensees" and "recipients" may be individuals or organizations. To "modify" a work means to copy from or adapt all or part of the work in a fashion requiring copyright permission, other than the making of an exact copy. The resulting work is called a "modified version" of the earlier work or a work "based on" the earlier work. A "covered work" means either the unmodified Program or a work based on the Program. To "propagate" a work means to do anything with it that, without permission, would make you directly or secondarily liable for infringement under applicable copyright law, except executing it on a computer or modifying a private copy. Propagation includes copying, distribution (with or without modification), making available to the public, and in some countries other activities as well. To "convey" a work means any kind of propagation that enables other parties to make or receive copies. Mere interaction with a user through a computer network, with no transfer of a copy, is not conveying. An interactive user interface displays "Appropriate Legal Notices" to the extent that it includes a convenient and prominently visible feature that (1) displays an appropriate copyright notice, and (2) tells the user that there is no warranty for the work (except to the extent that warranties are provided), that licensees may convey the work under this License, and how to view a copy of this License. If the interface presents a list of user commands or options, such as a menu, a prominent item in the list meets this criterion. 1. Source Code. The "source code" for a work means the preferred form of the work for making modifications to it. "Object code" means any non-source form of a work. A "Standard Interface" means an interface that either is an official standard defined by a recognized standards body, or, in the case of interfaces specified for a particular programming language, one that is widely used among developers working in that language. The "System Libraries" of an executable work include anything, other than the work as a whole, that (a) is included in the normal form of packaging a Major Component, but which is not part of that Major Component, and (b) serves only to enable use of the work with that Major Component, or to implement a Standard Interface for which an implementation is available to the public in source code form. A "Major Component", in this context, means a major essential component (kernel, window system, and so on) of the specific operating system (if any) on which the executable work runs, or a compiler used to produce the work, or an object code interpreter used to run it. The "Corresponding Source" for a work in object code form means all the source code needed to generate, install, and (for an executable work) run the object code and to modify the work, including scripts to control those activities. However, it does not include the work's System Libraries, or general-purpose tools or generally available free programs which are used unmodified in performing those activities but which are not part of the work. For example, Corresponding Source includes interface definition files associated with source files for the work, and the source code for shared libraries and dynamically linked subprograms that the work is specifically designed to require, such as by intimate data communication or control flow between those subprograms and other parts of the work. The Corresponding Source need not include anything that users can regenerate automatically from other parts of the Corresponding Source. The Corresponding Source for a work in source code form is that same work. 2. Basic Permissions. All rights granted under this License are granted for the term of copyright on the Program, and are irrevocable provided the stated conditions are met. This License explicitly affirms your unlimited permission to run the unmodified Program. The output from running a covered work is covered by this License only if the output, given its content, constitutes a covered work. This License acknowledges your rights of fair use or other equivalent, as provided by copyright law. You may make, run and propagate covered works that you do not convey, without conditions so long as your license otherwise remains in force. You may convey covered works to others for the sole purpose of having them make modifications exclusively for you, or provide you with facilities for running those works, provided that you comply with the terms of this License in conveying all material for which you do not control copyright. Those thus making or running the covered works for you must do so exclusively on your behalf, under your direction and control, on terms that prohibit them from making any copies of your copyrighted material outside their relationship with you. Conveying under any other circumstances is permitted solely under the conditions stated below. Sublicensing is not allowed; section 10 makes it unnecessary. 3. Protecting Users' Legal Rights From Anti-Circumvention Law. No covered work shall be deemed part of an effective technological measure under any applicable law fulfilling obligations under article 11 of the WIPO copyright treaty adopted on 20 December 1996, or similar laws prohibiting or restricting circumvention of such measures. When you convey a covered work, you waive any legal power to forbid circumvention of technological measures to the extent such circumvention is effected by exercising rights under this License with respect to the covered work, and you disclaim any intention to limit operation or modification of the work as a means of enforcing, against the work's users, your or third parties' legal rights to forbid circumvention of technological measures. 4. Conveying Verbatim Copies. You may convey verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice; keep intact all notices stating that this License and any non-permissive terms added in accord with section 7 apply to the code; keep intact all notices of the absence of any warranty; and give all recipients a copy of this License along with the Program. You may charge any price or no price for each copy that you convey, and you may offer support or warranty protection for a fee. 5. Conveying Modified Source Versions. You may convey a work based on the Program, or the modifications to produce it from the Program, in the form of source code under the terms of section 4, provided that you also meet all of these conditions: a) The work must carry prominent notices stating that you modified it, and giving a relevant date. b) The work must carry prominent notices stating that it is released under this License and any conditions added under section 7. This requirement modifies the requirement in section 4 to "keep intact all notices". c) You must license the entire work, as a whole, under this License to anyone who comes into possession of a copy. This License will therefore apply, along with any applicable section 7 additional terms, to the whole of the work, and all its parts, regardless of how they are packaged. This License gives no permission to license the work in any other way, but it does not invalidate such permission if you have separately received it. d) If the work has interactive user interfaces, each must display Appropriate Legal Notices; however, if the Program has interactive interfaces that do not display Appropriate Legal Notices, your work need not make them do so. A compilation of a covered work with other separate and independent works, which are not by their nature extensions of the covered work, and which are not combined with it such as to form a larger program, in or on a volume of a storage or distribution medium, is called an "aggregate" if the compilation and its resulting copyright are not used to limit the access or legal rights of the compilation's users beyond what the individual works permit. Inclusion of a covered work in an aggregate does not cause this License to apply to the other parts of the aggregate. 6. Conveying Non-Source Forms. You may convey a covered work in object code form under the terms of sections 4 and 5, provided that you also convey the machine-readable Corresponding Source under the terms of this License, in one of these ways: a) Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by the Corresponding Source fixed on a durable physical medium customarily used for software interchange. b) Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by a written offer, valid for at least three years and valid for as long as you offer spare parts or customer support for that product model, to give anyone who possesses the object code either (1) a copy of the Corresponding Source for all the software in the product that is covered by this License, on a durable physical medium customarily used for software interchange, for a price no more than your reasonable cost of physically performing this conveying of source, or (2) access to copy the Corresponding Source from a network server at no charge. c) Convey individual copies of the object code with a copy of the written offer to provide the Corresponding Source. This alternative is allowed only occasionally and noncommercially, and only if you received the object code with such an offer, in accord with subsection 6b. d) Convey the object code by offering access from a designated place (gratis or for a charge), and offer equivalent access to the Corresponding Source in the same way through the same place at no further charge. You need not require recipients to copy the Corresponding Source along with the object code. If the place to copy the object code is a network server, the Corresponding Source may be on a different server (operated by you or a third party) that supports equivalent copying facilities, provided you maintain clear directions next to the object code saying where to find the Corresponding Source. Regardless of what server hosts the Corresponding Source, you remain obligated to ensure that it is available for as long as needed to satisfy these requirements. e) Convey the object code using peer-to-peer transmission, provided you inform other peers where the object code and Corresponding Source of the work are being offered to the general public at no charge under subsection 6d. A separable portion of the object code, whose source code is excluded from the Corresponding Source as a System Library, need not be included in conveying the object code work. A "User Product" is either (1) a "consumer product", which means any tangible personal property which is normally used for personal, family, or household purposes, or (2) anything designed or sold for incorporation into a dwelling. In determining whether a product is a consumer product, doubtful cases shall be resolved in favor of coverage. For a particular product received by a particular user, "normally used" refers to a typical or common use of that class of product, regardless of the status of the particular user or of the way in which the particular user actually uses, or expects or is expected to use, the product. A product is a consumer product regardless of whether the product has substantial commercial, industrial or non-consumer uses, unless such uses represent the only significant mode of use of the product. "Installation Information" for a User Product means any methods, procedures, authorization keys, or other information required to install and execute modified versions of a covered work in that User Product from a modified version of its Corresponding Source. The information must suffice to ensure that the continued functioning of the modified object code is in no case prevented or interfered with solely because modification has been made. If you convey an object code work under this section in, or with, or specifically for use in, a User Product, and the conveying occurs as part of a transaction in which the right of possession and use of the User Product is transferred to the recipient in perpetuity or for a fixed term (regardless of how the transaction is characterized), the Corresponding Source conveyed under this section must be accompanied by the Installation Information. But this requirement does not apply if neither you nor any third party retains the ability to install modified object code on the User Product (for example, the work has been installed in ROM). The requirement to provide Installation Information does not include a requirement to continue to provide support service, warranty, or updates for a work that has been modified or installed by the recipient, or for the User Product in which it has been modified or installed. Access to a network may be denied when the modification itself materially and adversely affects the operation of the network or violates the rules and protocols for communication across the network. Corresponding Source conveyed, and Installation Information provided, in accord with this section must be in a format that is publicly documented (and with an implementation available to the public in source code form), and must require no special password or key for unpacking, reading or copying. 7. Additional Terms. "Additional permissions" are terms that supplement the terms of this License by making exceptions from one or more of its conditions. Additional permissions that are applicable to the entire Program shall be treated as though they were included in this License, to the extent that they are valid under applicable law. If additional permissions apply only to part of the Program, that part may be used separately under those permissions, but the entire Program remains governed by this License without regard to the additional permissions. When you convey a copy of a covered work, you may at your option remove any additional permissions from that copy, or from any part of it. (Additional permissions may be written to require their own removal in certain cases when you modify the work.) You may place additional permissions on material, added by you to a covered work, for which you have or can give appropriate copyright permission. Notwithstanding any other provision of this License, for material you add to a covered work, you may (if authorized by the copyright holders of that material) supplement the terms of this License with terms: a) Disclaiming warranty or limiting liability differently from the terms of sections 15 and 16 of this License; or b) Requiring preservation of specified reasonable legal notices or author attributions in that material or in the Appropriate Legal Notices displayed by works containing it; or c) Prohibiting misrepresentation of the origin of that material, or requiring that modified versions of such material be marked in reasonable ways as different from the original version; or d) Limiting the use for publicity purposes of names of licensors or authors of the material; or e) Declining to grant rights under trademark law for use of some trade names, trademarks, or service marks; or f) Requiring indemnification of licensors and authors of that material by anyone who conveys the material (or modified versions of it) with contractual assumptions of liability to the recipient, for any liability that these contractual assumptions directly impose on those licensors and authors. All other non-permissive additional terms are considered "further restrictions" within the meaning of section 10. If the Program as you received it, or any part of it, contains a notice stating that it is governed by this License along with a term that is a further restriction, you may remove that term. If a license document contains a further restriction but permits relicensing or conveying under this License, you may add to a covered work material governed by the terms of that license document, provided that the further restriction does not survive such relicensing or conveying. If you add terms to a covered work in accord with this section, you must place, in the relevant source files, a statement of the additional terms that apply to those files, or a notice indicating where to find the applicable terms. Additional terms, permissive or non-permissive, may be stated in the form of a separately written license, or stated as exceptions; the above requirements apply either way. 8. Termination. You may not propagate or modify a covered work except as expressly provided under this License. Any attempt otherwise to propagate or modify it is void, and will automatically terminate your rights under this License (including any patent licenses granted under the third paragraph of section 11). However, if you cease all violation of this License, then your license from a particular copyright holder is reinstated (a) provisionally, unless and until the copyright holder explicitly and finally terminates your license, and (b) permanently, if the copyright holder fails to notify you of the violation by some reasonable means prior to 60 days after the cessation. Moreover, your license from a particular copyright holder is reinstated permanently if the copyright holder notifies you of the violation by some reasonable means, this is the first time you have received notice of violation of this License (for any work) from that copyright holder, and you cure the violation prior to 30 days after your receipt of the notice. Termination of your rights under this section does not terminate the licenses of parties who have received copies or rights from you under this License. If your rights have been terminated and not permanently reinstated, you do not qualify to receive new licenses for the same material under section 10. 9. Acceptance Not Required for Having Copies. You are not required to accept this License in order to receive or run a copy of the Program. Ancillary propagation of a covered work occurring solely as a consequence of using peer-to-peer transmission to receive a copy likewise does not require acceptance. However, nothing other than this License grants you permission to propagate or modify any covered work. These actions infringe copyright if you do not accept this License. Therefore, by modifying or propagating a covered work, you indicate your acceptance of this License to do so. 10. Automatic Licensing of Downstream Recipients. Each time you convey a covered work, the recipient automatically receives a license from the original licensors, to run, modify and propagate that work, subject to this License. You are not responsible for enforcing compliance by third parties with this License. An "entity transaction" is a transaction transferring control of an organization, or substantially all assets of one, or subdividing an organization, or merging organizations. If propagation of a covered work results from an entity transaction, each party to that transaction who receives a copy of the work also receives whatever licenses to the work the party's predecessor in interest had or could give under the previous paragraph, plus a right to possession of the Corresponding Source of the work from the predecessor in interest, if the predecessor has it or can get it with reasonable efforts. You may not impose any further restrictions on the exercise of the rights granted or affirmed under this License. For example, you may not impose a license fee, royalty, or other charge for exercise of rights granted under this License, and you may not initiate litigation (including a cross-claim or counterclaim in a lawsuit) alleging that any patent claim is infringed by making, using, selling, offering for sale, or importing the Program or any portion of it. 11. Patents. A "contributor" is a copyright holder who authorizes use under this License of the Program or a work on which the Program is based. The work thus licensed is called the contributor's "contributor version". A contributor's "essential patent claims" are all patent claims owned or controlled by the contributor, whether already acquired or hereafter acquired, that would be infringed by some manner, permitted by this License, of making, using, or selling its contributor version, but do not include claims that would be infringed only as a consequence of further modification of the contributor version. For purposes of this definition, "control" includes the right to grant patent sublicenses in a manner consistent with the requirements of this License. Each contributor grants you a non-exclusive, worldwide, royalty-free patent license under the contributor's essential patent claims, to make, use, sell, offer for sale, import and otherwise run, modify and propagate the contents of its contributor version. In the following three paragraphs, a "patent license" is any express agreement or commitment, however denominated, not to enforce a patent (such as an express permission to practice a patent or covenant not to sue for patent infringement). To "grant" such a patent license to a party means to make such an agreement or commitment not to enforce a patent against the party. If you convey a covered work, knowingly relying on a patent license, and the Corresponding Source of the work is not available for anyone to copy, free of charge and under the terms of this License, through a publicly available network server or other readily accessible means, then you must either (1) cause the Corresponding Source to be so available, or (2) arrange to deprive yourself of the benefit of the patent license for this particular work, or (3) arrange, in a manner consistent with the requirements of this License, to extend the patent license to downstream recipients. "Knowingly relying" means you have actual knowledge that, but for the patent license, your conveying the covered work in a country, or your recipient's use of the covered work in a country, would infringe one or more identifiable patents in that country that you have reason to believe are valid. If, pursuant to or in connection with a single transaction or arrangement, you convey, or propagate by procuring conveyance of, a covered work, and grant a patent license to some of the parties receiving the covered work authorizing them to use, propagate, modify or convey a specific copy of the covered work, then the patent license you grant is automatically extended to all recipients of the covered work and works based on it. A patent license is "discriminatory" if it does not include within the scope of its coverage, prohibits the exercise of, or is conditioned on the non-exercise of one or more of the rights that are specifically granted under this License. You may not convey a covered work if you are a party to an arrangement with a third party that is in the business of distributing software, under which you make payment to the third party based on the extent of your activity of conveying the work, and under which the third party grants, to any of the parties who would receive the covered work from you, a discriminatory patent license (a) in connection with copies of the covered work conveyed by you (or copies made from those copies), or (b) primarily for and in connection with specific products or compilations that contain the covered work, unless you entered into that arrangement, or that patent license was granted, prior to 28 March 2007. Nothing in this License shall be construed as excluding or limiting any implied license or other defenses to infringement that may otherwise be available to you under applicable patent law. 12. No Surrender of Others' Freedom. If conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot convey a covered work so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not convey it at all. For example, if you agree to terms that obligate you to collect a royalty for further conveying from those to whom you convey the Program, the only way you could satisfy both those terms and this License would be to refrain entirely from conveying the Program. 13. Use with the GNU Affero General Public License. Notwithstanding any other provision of this License, you have permission to link or combine any covered work with a work licensed under version 3 of the GNU Affero General Public License into a single combined work, and to convey the resulting work. The terms of this License will continue to apply to the part which is the covered work, but the special requirements of the GNU Affero General Public License, section 13, concerning interaction through a network will apply to the combination as such. 14. Revised Versions of this License. The Free Software Foundation may publish revised and/or new versions of the GNU General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. Each version is given a distinguishing version number. If the Program specifies that a certain numbered version of the GNU General Public License "or any later version" applies to it, you have the option of following the terms and conditions either of that numbered version or of any later version published by the Free Software Foundation. If the Program does not specify a version number of the GNU General Public License, you may choose any version ever published by the Free Software Foundation. If the Program specifies that a proxy can decide which future versions of the GNU General Public License can be used, that proxy's public statement of acceptance of a version permanently authorizes you to choose that version for the Program. Later license versions may give you additional or different permissions. However, no additional obligations are imposed on any author or copyright holder as a result of your choosing to follow a later version. 15. Disclaimer of Warranty. THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 16. Limitation of Liability. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. 17. Interpretation of Sections 15 and 16. If the disclaimer of warranty and limitation of liability provided above cannot be given local legal effect according to their terms, reviewing courts shall apply local law that most closely approximates an absolute waiver of all civil liability in connection with the Program, unless a warranty or assumption of liability accompanies a copy of the Program in return for a fee. END OF TERMS AND CONDITIONS How to Apply These Terms to Your New Programs If you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms. To do so, attach the following notices to the program. It is safest to attach them to the start of each source file to most effectively state the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found. Copyright (C) This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see . Also add information on how to contact you by electronic and paper mail. If the program does terminal interaction, make it output a short notice like this when it starts in an interactive mode: Copyright (C) This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'. This is free software, and you are welcome to redistribute it under certain conditions; type `show c' for details. The hypothetical commands `show w' and `show c' should show the appropriate parts of the General Public License. Of course, your program's commands might be different; for a GUI interface, you would use an "about box". You should also get your employer (if you work as a programmer) or school, if any, to sign a "copyright disclaimer" for the program, if necessary. For more information on this, and how to apply and follow the GNU GPL, see . The GNU General Public License does not permit incorporating your program into proprietary programs. If your program is a subroutine library, you may consider it more useful to permit linking proprietary applications with the library. If this is what you want to do, use the GNU Lesser General Public License instead of this License. But first, please read . gtkada-24.0.0/INSTALL000066400000000000000000000022541446021174000140630ustar00rootroot00000000000000Installing and compiling your programs ====================================== If you have a previous version of GtkAda on your system, we recommend that you move/remove it using e.g. the following command: $ mv /include/gtkada is the prefix you used to configure GtkAda the first time. The default prefix is /usr/local. If you don't have the rights to move these files, then you should at least make sure that your ADA_INCLUDE_PATH and your ADA_OBJECTS_PATH don't include this directory before building GtkAda. To install GtkAda, you will first need to install GNAT in order to compile it. On Unix systems, you'll then just need to run the following command once GNAT is installed and available in your PATH: $ sudo env "PATH=$PATH" ./doinstall On Windows, just run the Gtkada installer and follow the displayed instructions. Note that you might have to be root to install GtkAda on your system. On Unix systems, you'll need to run the /bin/gtkada-env.sh script to setup your environment for Gtkada. Then, to compile your application, simply add on top of your project file: with "gtkada"; And compile with GPRbuild. gtkada-24.0.0/Makefile.in000066400000000000000000000114201446021174000150720ustar00rootroot00000000000000SHELL=/bin/sh .SUFFIXES: .PHONY: clean-generic mostlyclean-generic \ clean distclean mostlyclean maintainer-clean \ install src tests docs generate tools doc_dir = docs PYTHON = python # This variable can be overridden with "-d" to get progress output GPRBUILD_OPTIONS= GPRINSTALL_OPTIONS= TARGET=@TARGET@ ifeq ($(TARGET),) GPRBUILD=@GPRBUILD@ $(GPRBUILD_OPTIONS) GPRINSTALL=@GPRINSTALL@ $(GPRINSTALL_OPTIONS) else GPRBUILD=@GPRBUILD@ --target=${TARGET} $(GPRBUILD_OPTIONS) GPRINSTALL=@GPRINSTALL@ --target=${TARGET} $(GPRINSTALL_OPTIONS) endif # Number of parallel compilation PROCESSORS = 0 # Location (under $prefix) where the project files should be copied PRJDIR=lib/gnat GPRBUILD_FULL = ${GPRBUILD} -j${PROCESSORS} -m -p ${GPRBUILD_SWITCHES} GPRINSTALL_FULL = ${GPRINSTALL} -p -f --project-subdir=$(PRJDIR) \ --build-var=GTKADA_BUILD,LIBRARY_TYPE --install-name=gtkada \ --prefix=${DESTDIR}$(prefix) -XGTK_PREFIX=${prefix} GETTEXT_INTL=@GETTEXT_INTL@ HAVE_GETTEXT=@HAVE_GETTEXT@ BUILD_SHARED=@BUILD_SHARED@ BUILD_STATIC=@BUILD_STATIC@ BUILD_STATIC_PIC=@BUILD_STATIC_PIC@ TARNAME=@PACKAGE_TARNAME@ VERSION=@PACKAGE_VERSION@ DESTDIR= prefix=@prefix@ exec_prefix=@exec_prefix@ libdir=@libdir@ datadir=@datadir@ datarootdir=@datarootdir@ exampledir=${datadir}/examples/gtkada/testgtk all: ifeq (${BUILD_STATIC}, yes) all tools tests: static install: install/static endif ifeq (${BUILD_STATIC_PIC}, yes) all tools tests: build_library_type/static-pic install: install/static-pic LIBRARY_TYPE_FOR_TOOLS=static-pic endif ifeq (${BUILD_SHARED},yes) all tools tests: relocatable install: install/relocatable LIBRARY_TYPE_FOR_TOOLS=relocatable endif ifeq (${BUILD_STATIC}, yes) LIBRARY_TYPE_FOR_TOOLS=static endif all: tools tests static: build_library_type/static relocatable: build_library_type/relocatable tools: @echo "====== Building tools =====" ${GPRBUILD_FULL} -XLIBRARY_TYPE=$(LIBRARY_TYPE_FOR_TOOLS) -Psrc/tools/tools.gpr build_library_type/%: src/gtkada-intl.adb @echo "====== Building $(@F) libraries =====" ${GPRBUILD_FULL} -XLIBRARY_TYPE=$(@F) -Psrc/gtkada.gpr src/gtkada-intl.adb: src/gtkada-intl.gpb Makefile gnatprep -DGETTEXT_INTL=$(GETTEXT_INTL) -DHAVE_GETTEXT=$(HAVE_GETTEXT) src/gtkada-intl.gpb $@ tests: @echo "====== Building tests =====" cd testgtk; ${GPRBUILD_FULL} -XLIBRARY_TYPE=$(LIBRARY_TYPE_FOR_TOOLS) -Ptestgtk.gpr -aP ../src install/%: force ${GPRINSTALL_FULL} -XLIBRARY_TYPE=$(@F) --build-name=$(@F) \ --sources-subdir=include/gtkada/gtkada.$(@F) \ --lib-subdir=lib/gtkada/gtkada.$(@F) \ -Psrc/gtkada.gpr install-clean: ifneq (,$(wildcard $(prefix)/lib/gnat/manifests/gtkada)) -$(GPRINSTALL) --uninstall -f --prefix=$(prefix) \ --project-subdir=lib/gnat gtkada endif install: install-clean ${GPRINSTALL_FULL} -XLIBRARY_TYPE=$(LIBRARY_TYPE_FOR_TOOLS) \ --mode=usage -Psrc/tools/tools.gpr cd testgtk; ${GPRINSTALL_FULL} -XLIBRARY_TYPE=$(LIBRARY_TYPE_FOR_TOOLS) \ --mode=usage --exec-subdir=${DESTDIR}${exampledir} \ -Ptestgtk.gpr -aP ../src ifneq ($(OS),Windows_NT) ln -s ${libdir} ${DESTDIR}${datadir}/examples/gtkada --force endif @echo '-----------------------------------------------------------------------' @echo '-- GtkAda has now been installed. --' @echo '-- To use the library, you may need to update LD_LIBRARY_PATH --' @echo '-- or to run ldconfig. You may also need to update GPR_PROJECT_PATH --' @echo '-- to include --' @echo '-- ${prefix}/lib/gnat' @echo '-----------------------------------------------------------------------' docs: $(MAKE) -C docs # Generate the binding automatically, through a python script generate: ${RM} src/generated/*.ad? ${PYTHON} contrib/binding.py \ --gir-file=contrib/GLib-2.0.gir \ --gir-file=contrib/GObject-2.0.gir \ --gir-file=contrib/Gtk-3.0.gir \ --gir-file=contrib/Gdk-3.0.gir \ --gir-file=contrib/Pango-1.0.gir \ --gir-file=contrib/Gio-2.0.gir \ --xml-file=contrib/binding.xml \ --ada-output=src/generated/tmp.ada \ --c-output=src/misc_generated.c cd src/generated; gnatchop -gnat05 -q -w tmp.ada clean-generic: -${RM} core -${RM} .\#* mostlyclean-generic: clean-generic -${RM} Makefile src/config.h gtkada_shared.gpr -${RM} testgtk/opengl/view_gl.adb clean/%: force -gprclean -r -q -XLIBRARY_TYPE=$(@F) -Psrc/tools/tools.gpr -gprclean -r -q -XLIBRARY_TYPE=$(@F) -Ptestgtk/testgtk.gpr -gprclean -r -q -XLIBRARY_TYPE=$(@F) -Psrc/gtkada.gpr clean: clean-generic clean/static clean/static-pic clean/relocatable distclean: clean mostlyclean-generic -${RM} config.cache config.log config.status -$(MAKE) -C $(doc_dir) distclean -$(MAKE) -C po distclean mostlyclean: mostlyclean-generic maintainer-clean: mostlyclean-generic -${RM} config.cache config.log config.status -${RM} configure force: gtkada-24.0.0/README.md000066400000000000000000000036671446021174000143220ustar00rootroot00000000000000GtkAda - An Ada graphical toolkit based on GTK ============================================== [![GNAT CE Build](https://github.com/AdaCore/gtkada/actions/workflows/gnat-ce.yml/badge.svg)](https://github.com/AdaCore/gtkada/actions/workflows/gnat-ce.yml) [![Alire crate](https://img.shields.io/endpoint?url=https://alire.ada.dev/badges/gtkada.json)](https://alire.ada.dev/crates/gtkada.html) [![Debian package](https://img.shields.io/debian/v/libgtkada)](https://packages.debian.org/search?keywords=libgtkada) [![Fedora package](https://img.shields.io/fedora/v/GtkAda)](https://src.fedoraproject.org/rpms/GtkAda) [![Ubuntu package](https://img.shields.io/ubuntu/v/libgtkada)](https://packages.ubuntu.com/search?keywords=libgtkada) [![AUR version](https://img.shields.io/aur/version/gtkada)](https://aur.archlinux.org/packages/gtkada/) Installation ------------ See the file `INSTALL`. General Information ------------------- * The home page for GtkAda is https://github.com/AdaCore/gtkada * The home page for GTK is http://www.gtk.org This package is an Ada graphical library for the Gimp Toolkit, which means this is a set of packages to allow you to easily create some graphical interfaces under X11 and Win32, using Ada as the programming language. This library has been tested using Gtk+ 3.14.15 on the following systems: - GNU Linux/x86 - GNU Linux/x86-64 - Solaris/sparc - Windows 7, 8.1 and 10 License ------- All files are provided under terms of the GNU General Public License version 3. For details, see the "COPYING3" file. Documentation ------------- The GtkAda User's Guide can be found: - HTML version: in `docs/gtkada_ug/_build/html/index.html` - PDF version: in `docs/gtkada_ug/_build/latex/GtkAda.pdf` The GtkAda Reference Manual can be found: - HTML version: in `gtkada_rm/gtkada_rm/index.html` Patches ------- We are very happy to receive and look at patches. Please use github's Pull Requests feature to contribute those. gtkada-24.0.0/aclocal.m4000066400000000000000000000256051446021174000146770ustar00rootroot00000000000000# generated automatically by aclocal 1.16.1 -*- Autoconf -*- # Copyright (C) 1996-2018 Free Software Foundation, Inc. # This file is free software; the Free Software Foundation # gives unlimited permission to copy and/or distribute it, # with or without modifications, as long as this notice is preserved. # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY, to the extent permitted by law; without # even the implied warranty of MERCHANTABILITY or FITNESS FOR A # PARTICULAR PURPOSE. m4_ifndef([AC_CONFIG_MACRO_DIRS], [m4_defun([_AM_CONFIG_MACRO_DIRS], [])m4_defun([AC_CONFIG_MACRO_DIRS], [_AM_CONFIG_MACRO_DIRS($@)])]) dnl pkg.m4 - Macros to locate and utilise pkg-config. -*- Autoconf -*- dnl serial 11 (pkg-config-0.29.1) dnl dnl Copyright © 2004 Scott James Remnant . dnl Copyright © 2012-2015 Dan Nicholson dnl dnl This program is free software; you can redistribute it and/or modify dnl it under the terms of the GNU General Public License as published by dnl the Free Software Foundation; either version 2 of the License, or dnl (at your option) any later version. dnl dnl This program is distributed in the hope that it will be useful, but dnl WITHOUT ANY WARRANTY; without even the implied warranty of dnl MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU dnl General Public License for more details. dnl dnl You should have received a copy of the GNU General Public License dnl along with this program; if not, write to the Free Software dnl Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA dnl 02111-1307, USA. dnl dnl As a special exception to the GNU General Public License, if you dnl distribute this file as part of a program that contains a dnl configuration script generated by Autoconf, you may include it under dnl the same distribution terms that you use for the rest of that dnl program. dnl PKG_PREREQ(MIN-VERSION) dnl ----------------------- dnl Since: 0.29 dnl dnl Verify that the version of the pkg-config macros are at least dnl MIN-VERSION. Unlike PKG_PROG_PKG_CONFIG, which checks the user's dnl installed version of pkg-config, this checks the developer's version dnl of pkg.m4 when generating configure. dnl dnl To ensure that this macro is defined, also add: dnl m4_ifndef([PKG_PREREQ], dnl [m4_fatal([must install pkg-config 0.29 or later before running autoconf/autogen])]) dnl dnl See the "Since" comment for each macro you use to see what version dnl of the macros you require. m4_defun([PKG_PREREQ], [m4_define([PKG_MACROS_VERSION], [0.29.1]) m4_if(m4_version_compare(PKG_MACROS_VERSION, [$1]), -1, [m4_fatal([pkg.m4 version $1 or higher is required but ]PKG_MACROS_VERSION[ found])]) ])dnl PKG_PREREQ dnl PKG_PROG_PKG_CONFIG([MIN-VERSION]) dnl ---------------------------------- dnl Since: 0.16 dnl dnl Search for the pkg-config tool and set the PKG_CONFIG variable to dnl first found in the path. Checks that the version of pkg-config found dnl is at least MIN-VERSION. If MIN-VERSION is not specified, 0.9.0 is dnl used since that's the first version where most current features of dnl pkg-config existed. AC_DEFUN([PKG_PROG_PKG_CONFIG], [m4_pattern_forbid([^_?PKG_[A-Z_]+$]) m4_pattern_allow([^PKG_CONFIG(_(PATH|LIBDIR|SYSROOT_DIR|ALLOW_SYSTEM_(CFLAGS|LIBS)))?$]) m4_pattern_allow([^PKG_CONFIG_(DISABLE_UNINSTALLED|TOP_BUILD_DIR|DEBUG_SPEW)$]) AC_ARG_VAR([PKG_CONFIG], [path to pkg-config utility]) AC_ARG_VAR([PKG_CONFIG_PATH], [directories to add to pkg-config's search path]) AC_ARG_VAR([PKG_CONFIG_LIBDIR], [path overriding pkg-config's built-in search path]) if test "x$ac_cv_env_PKG_CONFIG_set" != "xset"; then AC_PATH_TOOL([PKG_CONFIG], [pkg-config]) fi if test -n "$PKG_CONFIG"; then _pkg_min_version=m4_default([$1], [0.9.0]) AC_MSG_CHECKING([pkg-config is at least version $_pkg_min_version]) if $PKG_CONFIG --atleast-pkgconfig-version $_pkg_min_version; then AC_MSG_RESULT([yes]) else AC_MSG_RESULT([no]) PKG_CONFIG="" fi fi[]dnl ])dnl PKG_PROG_PKG_CONFIG dnl PKG_CHECK_EXISTS(MODULES, [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND]) dnl ------------------------------------------------------------------- dnl Since: 0.18 dnl dnl Check to see whether a particular set of modules exists. Similar to dnl PKG_CHECK_MODULES(), but does not set variables or print errors. dnl dnl Please remember that m4 expands AC_REQUIRE([PKG_PROG_PKG_CONFIG]) dnl only at the first occurence in configure.ac, so if the first place dnl it's called might be skipped (such as if it is within an "if", you dnl have to call PKG_CHECK_EXISTS manually AC_DEFUN([PKG_CHECK_EXISTS], [AC_REQUIRE([PKG_PROG_PKG_CONFIG])dnl if test -n "$PKG_CONFIG" && \ AC_RUN_LOG([$PKG_CONFIG --exists --print-errors "$1"]); then m4_default([$2], [:]) m4_ifvaln([$3], [else $3])dnl fi]) dnl _PKG_CONFIG([VARIABLE], [COMMAND], [MODULES]) dnl --------------------------------------------- dnl Internal wrapper calling pkg-config via PKG_CONFIG and setting dnl pkg_failed based on the result. m4_define([_PKG_CONFIG], [if test -n "$$1"; then pkg_cv_[]$1="$$1" elif test -n "$PKG_CONFIG"; then PKG_CHECK_EXISTS([$3], [pkg_cv_[]$1=`$PKG_CONFIG --[]$2 "$3" 2>/dev/null` test "x$?" != "x0" && pkg_failed=yes ], [pkg_failed=yes]) else pkg_failed=untried fi[]dnl ])dnl _PKG_CONFIG dnl _PKG_SHORT_ERRORS_SUPPORTED dnl --------------------------- dnl Internal check to see if pkg-config supports short errors. AC_DEFUN([_PKG_SHORT_ERRORS_SUPPORTED], [AC_REQUIRE([PKG_PROG_PKG_CONFIG]) if $PKG_CONFIG --atleast-pkgconfig-version 0.20; then _pkg_short_errors_supported=yes else _pkg_short_errors_supported=no fi[]dnl ])dnl _PKG_SHORT_ERRORS_SUPPORTED dnl PKG_CHECK_MODULES(VARIABLE-PREFIX, MODULES, [ACTION-IF-FOUND], dnl [ACTION-IF-NOT-FOUND]) dnl -------------------------------------------------------------- dnl Since: 0.4.0 dnl dnl Note that if there is a possibility the first call to dnl PKG_CHECK_MODULES might not happen, you should be sure to include an dnl explicit call to PKG_PROG_PKG_CONFIG in your configure.ac AC_DEFUN([PKG_CHECK_MODULES], [AC_REQUIRE([PKG_PROG_PKG_CONFIG])dnl AC_ARG_VAR([$1][_CFLAGS], [C compiler flags for $1, overriding pkg-config])dnl AC_ARG_VAR([$1][_LIBS], [linker flags for $1, overriding pkg-config])dnl pkg_failed=no AC_MSG_CHECKING([for $1]) _PKG_CONFIG([$1][_CFLAGS], [cflags], [$2]) _PKG_CONFIG([$1][_LIBS], [libs], [$2]) m4_define([_PKG_TEXT], [Alternatively, you may set the environment variables $1[]_CFLAGS and $1[]_LIBS to avoid the need to call pkg-config. See the pkg-config man page for more details.]) if test $pkg_failed = yes; then AC_MSG_RESULT([no]) _PKG_SHORT_ERRORS_SUPPORTED if test $_pkg_short_errors_supported = yes; then $1[]_PKG_ERRORS=`$PKG_CONFIG --short-errors --print-errors --cflags --libs "$2" 2>&1` else $1[]_PKG_ERRORS=`$PKG_CONFIG --print-errors --cflags --libs "$2" 2>&1` fi # Put the nasty error message in config.log where it belongs echo "$$1[]_PKG_ERRORS" >&AS_MESSAGE_LOG_FD m4_default([$4], [AC_MSG_ERROR( [Package requirements ($2) were not met: $$1_PKG_ERRORS Consider adjusting the PKG_CONFIG_PATH environment variable if you installed software in a non-standard prefix. _PKG_TEXT])[]dnl ]) elif test $pkg_failed = untried; then AC_MSG_RESULT([no]) m4_default([$4], [AC_MSG_FAILURE( [The pkg-config script could not be found or is too old. Make sure it is in your PATH or set the PKG_CONFIG environment variable to the full path to pkg-config. _PKG_TEXT To get pkg-config, see .])[]dnl ]) else $1[]_CFLAGS=$pkg_cv_[]$1[]_CFLAGS $1[]_LIBS=$pkg_cv_[]$1[]_LIBS AC_MSG_RESULT([yes]) $3 fi[]dnl ])dnl PKG_CHECK_MODULES dnl PKG_CHECK_MODULES_STATIC(VARIABLE-PREFIX, MODULES, [ACTION-IF-FOUND], dnl [ACTION-IF-NOT-FOUND]) dnl --------------------------------------------------------------------- dnl Since: 0.29 dnl dnl Checks for existence of MODULES and gathers its build flags with dnl static libraries enabled. Sets VARIABLE-PREFIX_CFLAGS from --cflags dnl and VARIABLE-PREFIX_LIBS from --libs. dnl dnl Note that if there is a possibility the first call to dnl PKG_CHECK_MODULES_STATIC might not happen, you should be sure to dnl include an explicit call to PKG_PROG_PKG_CONFIG in your dnl configure.ac. AC_DEFUN([PKG_CHECK_MODULES_STATIC], [AC_REQUIRE([PKG_PROG_PKG_CONFIG])dnl _save_PKG_CONFIG=$PKG_CONFIG PKG_CONFIG="$PKG_CONFIG --static" PKG_CHECK_MODULES($@) PKG_CONFIG=$_save_PKG_CONFIG[]dnl ])dnl PKG_CHECK_MODULES_STATIC dnl PKG_INSTALLDIR([DIRECTORY]) dnl ------------------------- dnl Since: 0.27 dnl dnl Substitutes the variable pkgconfigdir as the location where a module dnl should install pkg-config .pc files. By default the directory is dnl $libdir/pkgconfig, but the default can be changed by passing dnl DIRECTORY. The user can override through the --with-pkgconfigdir dnl parameter. AC_DEFUN([PKG_INSTALLDIR], [m4_pushdef([pkg_default], [m4_default([$1], ['${libdir}/pkgconfig'])]) m4_pushdef([pkg_description], [pkg-config installation directory @<:@]pkg_default[@:>@]) AC_ARG_WITH([pkgconfigdir], [AS_HELP_STRING([--with-pkgconfigdir], pkg_description)],, [with_pkgconfigdir=]pkg_default) AC_SUBST([pkgconfigdir], [$with_pkgconfigdir]) m4_popdef([pkg_default]) m4_popdef([pkg_description]) ])dnl PKG_INSTALLDIR dnl PKG_NOARCH_INSTALLDIR([DIRECTORY]) dnl -------------------------------- dnl Since: 0.27 dnl dnl Substitutes the variable noarch_pkgconfigdir as the location where a dnl module should install arch-independent pkg-config .pc files. By dnl default the directory is $datadir/pkgconfig, but the default can be dnl changed by passing DIRECTORY. The user can override through the dnl --with-noarch-pkgconfigdir parameter. AC_DEFUN([PKG_NOARCH_INSTALLDIR], [m4_pushdef([pkg_default], [m4_default([$1], ['${datadir}/pkgconfig'])]) m4_pushdef([pkg_description], [pkg-config arch-independent installation directory @<:@]pkg_default[@:>@]) AC_ARG_WITH([noarch-pkgconfigdir], [AS_HELP_STRING([--with-noarch-pkgconfigdir], pkg_description)],, [with_noarch_pkgconfigdir=]pkg_default) AC_SUBST([noarch_pkgconfigdir], [$with_noarch_pkgconfigdir]) m4_popdef([pkg_default]) m4_popdef([pkg_description]) ])dnl PKG_NOARCH_INSTALLDIR dnl PKG_CHECK_VAR(VARIABLE, MODULE, CONFIG-VARIABLE, dnl [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND]) dnl ------------------------------------------- dnl Since: 0.28 dnl dnl Retrieves the value of the pkg-config variable for the given module. AC_DEFUN([PKG_CHECK_VAR], [AC_REQUIRE([PKG_PROG_PKG_CONFIG])dnl AC_ARG_VAR([$1], [value of $3 for $2, overriding pkg-config])dnl _PKG_CONFIG([$1], [variable="][$3]["], [$2]) AS_VAR_COPY([$1], [pkg_cv_][$1]) AS_VAR_IF([$1], [""], [$5], [$4])dnl ])dnl PKG_CHECK_VAR m4_include([m4/add_os_specific_flags.m4]) m4_include([m4/check_build_type.m4]) m4_include([m4/gnu_gettext.m4]) m4_include([m4/gtk-3.0.m4]) m4_include([m4/path_gnat.m4]) m4_include([m4/path_gtk.m4]) m4_include([m4/to_gpr.m4]) gtkada-24.0.0/config.guess000077500000000000000000001263731446021174000153630ustar00rootroot00000000000000#! /bin/sh # Attempt to guess a canonical system name. # Copyright 1992-2018 Free Software Foundation, Inc. timestamp='2018-02-24' # This file is free software; you can redistribute it and/or modify it # under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 3 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, but # WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU # General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, see . # # As a special exception to the GNU General Public License, if you # distribute this file as part of a program that contains a # configuration script generated by Autoconf, you may include it under # the same distribution terms that you use for the rest of that # program. This Exception is an additional permission under section 7 # of the GNU General Public License, version 3 ("GPLv3"). # # Originally written by Per Bothner; maintained since 2000 by Ben Elliston. # # You can get the latest version of this script from: # https://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.guess # # Please send patches to . me=`echo "$0" | sed -e 's,.*/,,'` usage="\ Usage: $0 [OPTION] Output the configuration name of the system \`$me' is run on. Options: -h, --help print this help, then exit -t, --time-stamp print date of last modification, then exit -v, --version print version number, then exit Report bugs and patches to ." version="\ GNU config.guess ($timestamp) Originally written by Per Bothner. Copyright 1992-2018 Free Software Foundation, Inc. This is free software; see the source for copying conditions. There is NO warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE." help=" Try \`$me --help' for more information." # Parse command line while test $# -gt 0 ; do case $1 in --time-stamp | --time* | -t ) echo "$timestamp" ; exit ;; --version | -v ) echo "$version" ; exit ;; --help | --h* | -h ) echo "$usage"; exit ;; -- ) # Stop option processing shift; break ;; - ) # Use stdin as input. break ;; -* ) echo "$me: invalid option $1$help" >&2 exit 1 ;; * ) break ;; esac done if test $# != 0; then echo "$me: too many arguments$help" >&2 exit 1 fi trap 'exit 1' 1 2 15 # CC_FOR_BUILD -- compiler used by this script. Note that the use of a # compiler to aid in system detection is discouraged as it requires # temporary files to be created and, as you can see below, it is a # headache to deal with in a portable fashion. # Historically, `CC_FOR_BUILD' used to be named `HOST_CC'. We still # use `HOST_CC' if defined, but it is deprecated. # Portable tmp directory creation inspired by the Autoconf team. set_cc_for_build=' trap "exitcode=\$?; (rm -f \$tmpfiles 2>/dev/null; rmdir \$tmp 2>/dev/null) && exit \$exitcode" 0 ; trap "rm -f \$tmpfiles 2>/dev/null; rmdir \$tmp 2>/dev/null; exit 1" 1 2 13 15 ; : ${TMPDIR=/tmp} ; { tmp=`(umask 077 && mktemp -d "$TMPDIR/cgXXXXXX") 2>/dev/null` && test -n "$tmp" && test -d "$tmp" ; } || { test -n "$RANDOM" && tmp=$TMPDIR/cg$$-$RANDOM && (umask 077 && mkdir $tmp) ; } || { tmp=$TMPDIR/cg-$$ && (umask 077 && mkdir $tmp) && echo "Warning: creating insecure temp directory" >&2 ; } || { echo "$me: cannot create a temporary directory in $TMPDIR" >&2 ; exit 1 ; } ; dummy=$tmp/dummy ; tmpfiles="$dummy.c $dummy.o $dummy.rel $dummy" ; case $CC_FOR_BUILD,$HOST_CC,$CC in ,,) echo "int x;" > "$dummy.c" ; for c in cc gcc c89 c99 ; do if ($c -c -o "$dummy.o" "$dummy.c") >/dev/null 2>&1 ; then CC_FOR_BUILD="$c"; break ; fi ; done ; if test x"$CC_FOR_BUILD" = x ; then CC_FOR_BUILD=no_compiler_found ; fi ;; ,,*) CC_FOR_BUILD=$CC ;; ,*,*) CC_FOR_BUILD=$HOST_CC ;; esac ; set_cc_for_build= ;' # This is needed to find uname on a Pyramid OSx when run in the BSD universe. # (ghazi@noc.rutgers.edu 1994-08-24) if (test -f /.attbin/uname) >/dev/null 2>&1 ; then PATH=$PATH:/.attbin ; export PATH fi UNAME_MACHINE=`(uname -m) 2>/dev/null` || UNAME_MACHINE=unknown UNAME_RELEASE=`(uname -r) 2>/dev/null` || UNAME_RELEASE=unknown UNAME_SYSTEM=`(uname -s) 2>/dev/null` || UNAME_SYSTEM=unknown UNAME_VERSION=`(uname -v) 2>/dev/null` || UNAME_VERSION=unknown case "$UNAME_SYSTEM" in Linux|GNU|GNU/*) # If the system lacks a compiler, then just pick glibc. # We could probably try harder. LIBC=gnu eval "$set_cc_for_build" cat <<-EOF > "$dummy.c" #include #if defined(__UCLIBC__) LIBC=uclibc #elif defined(__dietlibc__) LIBC=dietlibc #else LIBC=gnu #endif EOF eval "`$CC_FOR_BUILD -E "$dummy.c" 2>/dev/null | grep '^LIBC' | sed 's, ,,g'`" # If ldd exists, use it to detect musl libc. if command -v ldd >/dev/null && \ ldd --version 2>&1 | grep -q ^musl then LIBC=musl fi ;; esac # Note: order is significant - the case branches are not exclusive. case "$UNAME_MACHINE:$UNAME_SYSTEM:$UNAME_RELEASE:$UNAME_VERSION" in *:NetBSD:*:*) # NetBSD (nbsd) targets should (where applicable) match one or # more of the tuples: *-*-netbsdelf*, *-*-netbsdaout*, # *-*-netbsdecoff* and *-*-netbsd*. For targets that recently # switched to ELF, *-*-netbsd* would select the old # object file format. This provides both forward # compatibility and a consistent mechanism for selecting the # object file format. # # Note: NetBSD doesn't particularly care about the vendor # portion of the name. We always set it to "unknown". sysctl="sysctl -n hw.machine_arch" UNAME_MACHINE_ARCH=`(uname -p 2>/dev/null || \ "/sbin/$sysctl" 2>/dev/null || \ "/usr/sbin/$sysctl" 2>/dev/null || \ echo unknown)` case "$UNAME_MACHINE_ARCH" in armeb) machine=armeb-unknown ;; arm*) machine=arm-unknown ;; sh3el) machine=shl-unknown ;; sh3eb) machine=sh-unknown ;; sh5el) machine=sh5le-unknown ;; earmv*) arch=`echo "$UNAME_MACHINE_ARCH" | sed -e 's,^e\(armv[0-9]\).*$,\1,'` endian=`echo "$UNAME_MACHINE_ARCH" | sed -ne 's,^.*\(eb\)$,\1,p'` machine="${arch}${endian}"-unknown ;; *) machine="$UNAME_MACHINE_ARCH"-unknown ;; esac # The Operating System including object format, if it has switched # to ELF recently (or will in the future) and ABI. case "$UNAME_MACHINE_ARCH" in earm*) os=netbsdelf ;; arm*|i386|m68k|ns32k|sh3*|sparc|vax) eval "$set_cc_for_build" if echo __ELF__ | $CC_FOR_BUILD -E - 2>/dev/null \ | grep -q __ELF__ then # Once all utilities can be ECOFF (netbsdecoff) or a.out (netbsdaout). # Return netbsd for either. FIX? os=netbsd else os=netbsdelf fi ;; *) os=netbsd ;; esac # Determine ABI tags. case "$UNAME_MACHINE_ARCH" in earm*) expr='s/^earmv[0-9]/-eabi/;s/eb$//' abi=`echo "$UNAME_MACHINE_ARCH" | sed -e "$expr"` ;; esac # The OS release # Debian GNU/NetBSD machines have a different userland, and # thus, need a distinct triplet. However, they do not need # kernel version information, so it can be replaced with a # suitable tag, in the style of linux-gnu. case "$UNAME_VERSION" in Debian*) release='-gnu' ;; *) release=`echo "$UNAME_RELEASE" | sed -e 's/[-_].*//' | cut -d. -f1,2` ;; esac # Since CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM: # contains redundant information, the shorter form: # CPU_TYPE-MANUFACTURER-OPERATING_SYSTEM is used. echo "$machine-${os}${release}${abi}" exit ;; *:Bitrig:*:*) UNAME_MACHINE_ARCH=`arch | sed 's/Bitrig.//'` echo "$UNAME_MACHINE_ARCH"-unknown-bitrig"$UNAME_RELEASE" exit ;; *:OpenBSD:*:*) UNAME_MACHINE_ARCH=`arch | sed 's/OpenBSD.//'` echo "$UNAME_MACHINE_ARCH"-unknown-openbsd"$UNAME_RELEASE" exit ;; *:LibertyBSD:*:*) UNAME_MACHINE_ARCH=`arch | sed 's/^.*BSD\.//'` echo "$UNAME_MACHINE_ARCH"-unknown-libertybsd"$UNAME_RELEASE" exit ;; *:MidnightBSD:*:*) echo "$UNAME_MACHINE"-unknown-midnightbsd"$UNAME_RELEASE" exit ;; *:ekkoBSD:*:*) echo "$UNAME_MACHINE"-unknown-ekkobsd"$UNAME_RELEASE" exit ;; *:SolidBSD:*:*) echo "$UNAME_MACHINE"-unknown-solidbsd"$UNAME_RELEASE" exit ;; macppc:MirBSD:*:*) echo powerpc-unknown-mirbsd"$UNAME_RELEASE" exit ;; *:MirBSD:*:*) echo "$UNAME_MACHINE"-unknown-mirbsd"$UNAME_RELEASE" exit ;; *:Sortix:*:*) echo "$UNAME_MACHINE"-unknown-sortix exit ;; *:Redox:*:*) echo "$UNAME_MACHINE"-unknown-redox exit ;; mips:OSF1:*.*) echo mips-dec-osf1 exit ;; alpha:OSF1:*:*) case $UNAME_RELEASE in *4.0) UNAME_RELEASE=`/usr/sbin/sizer -v | awk '{print $3}'` ;; *5.*) UNAME_RELEASE=`/usr/sbin/sizer -v | awk '{print $4}'` ;; esac # According to Compaq, /usr/sbin/psrinfo has been available on # OSF/1 and Tru64 systems produced since 1995. I hope that # covers most systems running today. This code pipes the CPU # types through head -n 1, so we only detect the type of CPU 0. ALPHA_CPU_TYPE=`/usr/sbin/psrinfo -v | sed -n -e 's/^ The alpha \(.*\) processor.*$/\1/p' | head -n 1` case "$ALPHA_CPU_TYPE" in "EV4 (21064)") UNAME_MACHINE=alpha ;; "EV4.5 (21064)") UNAME_MACHINE=alpha ;; "LCA4 (21066/21068)") UNAME_MACHINE=alpha ;; "EV5 (21164)") UNAME_MACHINE=alphaev5 ;; "EV5.6 (21164A)") UNAME_MACHINE=alphaev56 ;; "EV5.6 (21164PC)") UNAME_MACHINE=alphapca56 ;; "EV5.7 (21164PC)") UNAME_MACHINE=alphapca57 ;; "EV6 (21264)") UNAME_MACHINE=alphaev6 ;; "EV6.7 (21264A)") UNAME_MACHINE=alphaev67 ;; "EV6.8CB (21264C)") UNAME_MACHINE=alphaev68 ;; "EV6.8AL (21264B)") UNAME_MACHINE=alphaev68 ;; "EV6.8CX (21264D)") UNAME_MACHINE=alphaev68 ;; "EV6.9A (21264/EV69A)") UNAME_MACHINE=alphaev69 ;; "EV7 (21364)") UNAME_MACHINE=alphaev7 ;; "EV7.9 (21364A)") UNAME_MACHINE=alphaev79 ;; esac # A Pn.n version is a patched version. # A Vn.n version is a released version. # A Tn.n version is a released field test version. # A Xn.n version is an unreleased experimental baselevel. # 1.2 uses "1.2" for uname -r. echo "$UNAME_MACHINE"-dec-osf"`echo "$UNAME_RELEASE" | sed -e 's/^[PVTX]//' | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz`" # Reset EXIT trap before exiting to avoid spurious non-zero exit code. exitcode=$? trap '' 0 exit $exitcode ;; Amiga*:UNIX_System_V:4.0:*) echo m68k-unknown-sysv4 exit ;; *:[Aa]miga[Oo][Ss]:*:*) echo "$UNAME_MACHINE"-unknown-amigaos exit ;; *:[Mm]orph[Oo][Ss]:*:*) echo "$UNAME_MACHINE"-unknown-morphos exit ;; *:OS/390:*:*) echo i370-ibm-openedition exit ;; *:z/VM:*:*) echo s390-ibm-zvmoe exit ;; *:OS400:*:*) echo powerpc-ibm-os400 exit ;; arm:RISC*:1.[012]*:*|arm:riscix:1.[012]*:*) echo arm-acorn-riscix"$UNAME_RELEASE" exit ;; arm*:riscos:*:*|arm*:RISCOS:*:*) echo arm-unknown-riscos exit ;; SR2?01:HI-UX/MPP:*:* | SR8000:HI-UX/MPP:*:*) echo hppa1.1-hitachi-hiuxmpp exit ;; Pyramid*:OSx*:*:* | MIS*:OSx*:*:* | MIS*:SMP_DC-OSx*:*:*) # akee@wpdis03.wpafb.af.mil (Earle F. Ake) contributed MIS and NILE. if test "`(/bin/universe) 2>/dev/null`" = att ; then echo pyramid-pyramid-sysv3 else echo pyramid-pyramid-bsd fi exit ;; NILE*:*:*:dcosx) echo pyramid-pyramid-svr4 exit ;; DRS?6000:unix:4.0:6*) echo sparc-icl-nx6 exit ;; DRS?6000:UNIX_SV:4.2*:7* | DRS?6000:isis:4.2*:7*) case `/usr/bin/uname -p` in sparc) echo sparc-icl-nx7; exit ;; esac ;; s390x:SunOS:*:*) echo "$UNAME_MACHINE"-ibm-solaris2"`echo "$UNAME_RELEASE" | sed -e 's/[^.]*//'`" exit ;; sun4H:SunOS:5.*:*) echo sparc-hal-solaris2"`echo "$UNAME_RELEASE"|sed -e 's/[^.]*//'`" exit ;; sun4*:SunOS:5.*:* | tadpole*:SunOS:5.*:*) echo sparc-sun-solaris2"`echo "$UNAME_RELEASE" | sed -e 's/[^.]*//'`" exit ;; i86pc:AuroraUX:5.*:* | i86xen:AuroraUX:5.*:*) echo i386-pc-auroraux"$UNAME_RELEASE" exit ;; i86pc:SunOS:5.*:* | i86xen:SunOS:5.*:*) eval "$set_cc_for_build" SUN_ARCH=i386 # If there is a compiler, see if it is configured for 64-bit objects. # Note that the Sun cc does not turn __LP64__ into 1 like gcc does. # This test works for both compilers. if [ "$CC_FOR_BUILD" != no_compiler_found ]; then if (echo '#ifdef __amd64'; echo IS_64BIT_ARCH; echo '#endif') | \ (CCOPTS="" $CC_FOR_BUILD -E - 2>/dev/null) | \ grep IS_64BIT_ARCH >/dev/null then SUN_ARCH=x86_64 fi fi echo "$SUN_ARCH"-pc-solaris2"`echo "$UNAME_RELEASE"|sed -e 's/[^.]*//'`" exit ;; sun4*:SunOS:6*:*) # According to config.sub, this is the proper way to canonicalize # SunOS6. Hard to guess exactly what SunOS6 will be like, but # it's likely to be more like Solaris than SunOS4. echo sparc-sun-solaris3"`echo "$UNAME_RELEASE"|sed -e 's/[^.]*//'`" exit ;; sun4*:SunOS:*:*) case "`/usr/bin/arch -k`" in Series*|S4*) UNAME_RELEASE=`uname -v` ;; esac # Japanese Language versions have a version number like `4.1.3-JL'. echo sparc-sun-sunos"`echo "$UNAME_RELEASE"|sed -e 's/-/_/'`" exit ;; sun3*:SunOS:*:*) echo m68k-sun-sunos"$UNAME_RELEASE" exit ;; sun*:*:4.2BSD:*) UNAME_RELEASE=`(sed 1q /etc/motd | awk '{print substr($5,1,3)}') 2>/dev/null` test "x$UNAME_RELEASE" = x && UNAME_RELEASE=3 case "`/bin/arch`" in sun3) echo m68k-sun-sunos"$UNAME_RELEASE" ;; sun4) echo sparc-sun-sunos"$UNAME_RELEASE" ;; esac exit ;; aushp:SunOS:*:*) echo sparc-auspex-sunos"$UNAME_RELEASE" exit ;; # The situation for MiNT is a little confusing. The machine name # can be virtually everything (everything which is not # "atarist" or "atariste" at least should have a processor # > m68000). The system name ranges from "MiNT" over "FreeMiNT" # to the lowercase version "mint" (or "freemint"). Finally # the system name "TOS" denotes a system which is actually not # MiNT. But MiNT is downward compatible to TOS, so this should # be no problem. atarist[e]:*MiNT:*:* | atarist[e]:*mint:*:* | atarist[e]:*TOS:*:*) echo m68k-atari-mint"$UNAME_RELEASE" exit ;; atari*:*MiNT:*:* | atari*:*mint:*:* | atarist[e]:*TOS:*:*) echo m68k-atari-mint"$UNAME_RELEASE" exit ;; *falcon*:*MiNT:*:* | *falcon*:*mint:*:* | *falcon*:*TOS:*:*) echo m68k-atari-mint"$UNAME_RELEASE" exit ;; milan*:*MiNT:*:* | milan*:*mint:*:* | *milan*:*TOS:*:*) echo m68k-milan-mint"$UNAME_RELEASE" exit ;; hades*:*MiNT:*:* | hades*:*mint:*:* | *hades*:*TOS:*:*) echo m68k-hades-mint"$UNAME_RELEASE" exit ;; *:*MiNT:*:* | *:*mint:*:* | *:*TOS:*:*) echo m68k-unknown-mint"$UNAME_RELEASE" exit ;; m68k:machten:*:*) echo m68k-apple-machten"$UNAME_RELEASE" exit ;; powerpc:machten:*:*) echo powerpc-apple-machten"$UNAME_RELEASE" exit ;; RISC*:Mach:*:*) echo mips-dec-mach_bsd4.3 exit ;; RISC*:ULTRIX:*:*) echo mips-dec-ultrix"$UNAME_RELEASE" exit ;; VAX*:ULTRIX*:*:*) echo vax-dec-ultrix"$UNAME_RELEASE" exit ;; 2020:CLIX:*:* | 2430:CLIX:*:*) echo clipper-intergraph-clix"$UNAME_RELEASE" exit ;; mips:*:*:UMIPS | mips:*:*:RISCos) eval "$set_cc_for_build" sed 's/^ //' << EOF > "$dummy.c" #ifdef __cplusplus #include /* for printf() prototype */ int main (int argc, char *argv[]) { #else int main (argc, argv) int argc; char *argv[]; { #endif #if defined (host_mips) && defined (MIPSEB) #if defined (SYSTYPE_SYSV) printf ("mips-mips-riscos%ssysv\\n", argv[1]); exit (0); #endif #if defined (SYSTYPE_SVR4) printf ("mips-mips-riscos%ssvr4\\n", argv[1]); exit (0); #endif #if defined (SYSTYPE_BSD43) || defined(SYSTYPE_BSD) printf ("mips-mips-riscos%sbsd\\n", argv[1]); exit (0); #endif #endif exit (-1); } EOF $CC_FOR_BUILD -o "$dummy" "$dummy.c" && dummyarg=`echo "$UNAME_RELEASE" | sed -n 's/\([0-9]*\).*/\1/p'` && SYSTEM_NAME=`"$dummy" "$dummyarg"` && { echo "$SYSTEM_NAME"; exit; } echo mips-mips-riscos"$UNAME_RELEASE" exit ;; Motorola:PowerMAX_OS:*:*) echo powerpc-motorola-powermax exit ;; Motorola:*:4.3:PL8-*) echo powerpc-harris-powermax exit ;; Night_Hawk:*:*:PowerMAX_OS | Synergy:PowerMAX_OS:*:*) echo powerpc-harris-powermax exit ;; Night_Hawk:Power_UNIX:*:*) echo powerpc-harris-powerunix exit ;; m88k:CX/UX:7*:*) echo m88k-harris-cxux7 exit ;; m88k:*:4*:R4*) echo m88k-motorola-sysv4 exit ;; m88k:*:3*:R3*) echo m88k-motorola-sysv3 exit ;; AViiON:dgux:*:*) # DG/UX returns AViiON for all architectures UNAME_PROCESSOR=`/usr/bin/uname -p` if [ "$UNAME_PROCESSOR" = mc88100 ] || [ "$UNAME_PROCESSOR" = mc88110 ] then if [ "$TARGET_BINARY_INTERFACE"x = m88kdguxelfx ] || \ [ "$TARGET_BINARY_INTERFACE"x = x ] then echo m88k-dg-dgux"$UNAME_RELEASE" else echo m88k-dg-dguxbcs"$UNAME_RELEASE" fi else echo i586-dg-dgux"$UNAME_RELEASE" fi exit ;; M88*:DolphinOS:*:*) # DolphinOS (SVR3) echo m88k-dolphin-sysv3 exit ;; M88*:*:R3*:*) # Delta 88k system running SVR3 echo m88k-motorola-sysv3 exit ;; XD88*:*:*:*) # Tektronix XD88 system running UTekV (SVR3) echo m88k-tektronix-sysv3 exit ;; Tek43[0-9][0-9]:UTek:*:*) # Tektronix 4300 system running UTek (BSD) echo m68k-tektronix-bsd exit ;; *:IRIX*:*:*) echo mips-sgi-irix"`echo "$UNAME_RELEASE"|sed -e 's/-/_/g'`" exit ;; ????????:AIX?:[12].1:2) # AIX 2.2.1 or AIX 2.1.1 is RT/PC AIX. echo romp-ibm-aix # uname -m gives an 8 hex-code CPU id exit ;; # Note that: echo "'`uname -s`'" gives 'AIX ' i*86:AIX:*:*) echo i386-ibm-aix exit ;; ia64:AIX:*:*) if [ -x /usr/bin/oslevel ] ; then IBM_REV=`/usr/bin/oslevel` else IBM_REV="$UNAME_VERSION.$UNAME_RELEASE" fi echo "$UNAME_MACHINE"-ibm-aix"$IBM_REV" exit ;; *:AIX:2:3) if grep bos325 /usr/include/stdio.h >/dev/null 2>&1; then eval "$set_cc_for_build" sed 's/^ //' << EOF > "$dummy.c" #include main() { if (!__power_pc()) exit(1); puts("powerpc-ibm-aix3.2.5"); exit(0); } EOF if $CC_FOR_BUILD -o "$dummy" "$dummy.c" && SYSTEM_NAME=`"$dummy"` then echo "$SYSTEM_NAME" else echo rs6000-ibm-aix3.2.5 fi elif grep bos324 /usr/include/stdio.h >/dev/null 2>&1; then echo rs6000-ibm-aix3.2.4 else echo rs6000-ibm-aix3.2 fi exit ;; *:AIX:*:[4567]) IBM_CPU_ID=`/usr/sbin/lsdev -C -c processor -S available | sed 1q | awk '{ print $1 }'` if /usr/sbin/lsattr -El "$IBM_CPU_ID" | grep ' POWER' >/dev/null 2>&1; then IBM_ARCH=rs6000 else IBM_ARCH=powerpc fi if [ -x /usr/bin/lslpp ] ; then IBM_REV=`/usr/bin/lslpp -Lqc bos.rte.libc | awk -F: '{ print $3 }' | sed s/[0-9]*$/0/` else IBM_REV="$UNAME_VERSION.$UNAME_RELEASE" fi echo "$IBM_ARCH"-ibm-aix"$IBM_REV" exit ;; *:AIX:*:*) echo rs6000-ibm-aix exit ;; ibmrt:4.4BSD:*|romp-ibm:4.4BSD:*) echo romp-ibm-bsd4.4 exit ;; ibmrt:*BSD:*|romp-ibm:BSD:*) # covers RT/PC BSD and echo romp-ibm-bsd"$UNAME_RELEASE" # 4.3 with uname added to exit ;; # report: romp-ibm BSD 4.3 *:BOSX:*:*) echo rs6000-bull-bosx exit ;; DPX/2?00:B.O.S.:*:*) echo m68k-bull-sysv3 exit ;; 9000/[34]??:4.3bsd:1.*:*) echo m68k-hp-bsd exit ;; hp300:4.4BSD:*:* | 9000/[34]??:4.3bsd:2.*:*) echo m68k-hp-bsd4.4 exit ;; 9000/[34678]??:HP-UX:*:*) HPUX_REV=`echo "$UNAME_RELEASE"|sed -e 's/[^.]*.[0B]*//'` case "$UNAME_MACHINE" in 9000/31?) HP_ARCH=m68000 ;; 9000/[34]??) HP_ARCH=m68k ;; 9000/[678][0-9][0-9]) if [ -x /usr/bin/getconf ]; then sc_cpu_version=`/usr/bin/getconf SC_CPU_VERSION 2>/dev/null` sc_kernel_bits=`/usr/bin/getconf SC_KERNEL_BITS 2>/dev/null` case "$sc_cpu_version" in 523) HP_ARCH=hppa1.0 ;; # CPU_PA_RISC1_0 528) HP_ARCH=hppa1.1 ;; # CPU_PA_RISC1_1 532) # CPU_PA_RISC2_0 case "$sc_kernel_bits" in 32) HP_ARCH=hppa2.0n ;; 64) HP_ARCH=hppa2.0w ;; '') HP_ARCH=hppa2.0 ;; # HP-UX 10.20 esac ;; esac fi if [ "$HP_ARCH" = "" ]; then eval "$set_cc_for_build" sed 's/^ //' << EOF > "$dummy.c" #define _HPUX_SOURCE #include #include int main () { #if defined(_SC_KERNEL_BITS) long bits = sysconf(_SC_KERNEL_BITS); #endif long cpu = sysconf (_SC_CPU_VERSION); switch (cpu) { case CPU_PA_RISC1_0: puts ("hppa1.0"); break; case CPU_PA_RISC1_1: puts ("hppa1.1"); break; case CPU_PA_RISC2_0: #if defined(_SC_KERNEL_BITS) switch (bits) { case 64: puts ("hppa2.0w"); break; case 32: puts ("hppa2.0n"); break; default: puts ("hppa2.0"); break; } break; #else /* !defined(_SC_KERNEL_BITS) */ puts ("hppa2.0"); break; #endif default: puts ("hppa1.0"); break; } exit (0); } EOF (CCOPTS="" $CC_FOR_BUILD -o "$dummy" "$dummy.c" 2>/dev/null) && HP_ARCH=`"$dummy"` test -z "$HP_ARCH" && HP_ARCH=hppa fi ;; esac if [ "$HP_ARCH" = hppa2.0w ] then eval "$set_cc_for_build" # hppa2.0w-hp-hpux* has a 64-bit kernel and a compiler generating # 32-bit code. hppa64-hp-hpux* has the same kernel and a compiler # generating 64-bit code. GNU and HP use different nomenclature: # # $ CC_FOR_BUILD=cc ./config.guess # => hppa2.0w-hp-hpux11.23 # $ CC_FOR_BUILD="cc +DA2.0w" ./config.guess # => hppa64-hp-hpux11.23 if echo __LP64__ | (CCOPTS="" $CC_FOR_BUILD -E - 2>/dev/null) | grep -q __LP64__ then HP_ARCH=hppa2.0w else HP_ARCH=hppa64 fi fi echo "$HP_ARCH"-hp-hpux"$HPUX_REV" exit ;; ia64:HP-UX:*:*) HPUX_REV=`echo "$UNAME_RELEASE"|sed -e 's/[^.]*.[0B]*//'` echo ia64-hp-hpux"$HPUX_REV" exit ;; 3050*:HI-UX:*:*) eval "$set_cc_for_build" sed 's/^ //' << EOF > "$dummy.c" #include int main () { long cpu = sysconf (_SC_CPU_VERSION); /* The order matters, because CPU_IS_HP_MC68K erroneously returns true for CPU_PA_RISC1_0. CPU_IS_PA_RISC returns correct results, however. */ if (CPU_IS_PA_RISC (cpu)) { switch (cpu) { case CPU_PA_RISC1_0: puts ("hppa1.0-hitachi-hiuxwe2"); break; case CPU_PA_RISC1_1: puts ("hppa1.1-hitachi-hiuxwe2"); break; case CPU_PA_RISC2_0: puts ("hppa2.0-hitachi-hiuxwe2"); break; default: puts ("hppa-hitachi-hiuxwe2"); break; } } else if (CPU_IS_HP_MC68K (cpu)) puts ("m68k-hitachi-hiuxwe2"); else puts ("unknown-hitachi-hiuxwe2"); exit (0); } EOF $CC_FOR_BUILD -o "$dummy" "$dummy.c" && SYSTEM_NAME=`"$dummy"` && { echo "$SYSTEM_NAME"; exit; } echo unknown-hitachi-hiuxwe2 exit ;; 9000/7??:4.3bsd:*:* | 9000/8?[79]:4.3bsd:*:*) echo hppa1.1-hp-bsd exit ;; 9000/8??:4.3bsd:*:*) echo hppa1.0-hp-bsd exit ;; *9??*:MPE/iX:*:* | *3000*:MPE/iX:*:*) echo hppa1.0-hp-mpeix exit ;; hp7??:OSF1:*:* | hp8?[79]:OSF1:*:*) echo hppa1.1-hp-osf exit ;; hp8??:OSF1:*:*) echo hppa1.0-hp-osf exit ;; i*86:OSF1:*:*) if [ -x /usr/sbin/sysversion ] ; then echo "$UNAME_MACHINE"-unknown-osf1mk else echo "$UNAME_MACHINE"-unknown-osf1 fi exit ;; parisc*:Lites*:*:*) echo hppa1.1-hp-lites exit ;; C1*:ConvexOS:*:* | convex:ConvexOS:C1*:*) echo c1-convex-bsd exit ;; C2*:ConvexOS:*:* | convex:ConvexOS:C2*:*) if getsysinfo -f scalar_acc then echo c32-convex-bsd else echo c2-convex-bsd fi exit ;; C34*:ConvexOS:*:* | convex:ConvexOS:C34*:*) echo c34-convex-bsd exit ;; C38*:ConvexOS:*:* | convex:ConvexOS:C38*:*) echo c38-convex-bsd exit ;; C4*:ConvexOS:*:* | convex:ConvexOS:C4*:*) echo c4-convex-bsd exit ;; CRAY*Y-MP:*:*:*) echo ymp-cray-unicos"$UNAME_RELEASE" | sed -e 's/\.[^.]*$/.X/' exit ;; CRAY*[A-Z]90:*:*:*) echo "$UNAME_MACHINE"-cray-unicos"$UNAME_RELEASE" \ | sed -e 's/CRAY.*\([A-Z]90\)/\1/' \ -e y/ABCDEFGHIJKLMNOPQRSTUVWXYZ/abcdefghijklmnopqrstuvwxyz/ \ -e 's/\.[^.]*$/.X/' exit ;; CRAY*TS:*:*:*) echo t90-cray-unicos"$UNAME_RELEASE" | sed -e 's/\.[^.]*$/.X/' exit ;; CRAY*T3E:*:*:*) echo alphaev5-cray-unicosmk"$UNAME_RELEASE" | sed -e 's/\.[^.]*$/.X/' exit ;; CRAY*SV1:*:*:*) echo sv1-cray-unicos"$UNAME_RELEASE" | sed -e 's/\.[^.]*$/.X/' exit ;; *:UNICOS/mp:*:*) echo craynv-cray-unicosmp"$UNAME_RELEASE" | sed -e 's/\.[^.]*$/.X/' exit ;; F30[01]:UNIX_System_V:*:* | F700:UNIX_System_V:*:*) FUJITSU_PROC=`uname -m | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz` FUJITSU_SYS=`uname -p | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz | sed -e 's/\///'` FUJITSU_REL=`echo "$UNAME_RELEASE" | sed -e 's/ /_/'` echo "${FUJITSU_PROC}-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}" exit ;; 5000:UNIX_System_V:4.*:*) FUJITSU_SYS=`uname -p | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz | sed -e 's/\///'` FUJITSU_REL=`echo "$UNAME_RELEASE" | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz | sed -e 's/ /_/'` echo "sparc-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}" exit ;; i*86:BSD/386:*:* | i*86:BSD/OS:*:* | *:Ascend\ Embedded/OS:*:*) echo "$UNAME_MACHINE"-pc-bsdi"$UNAME_RELEASE" exit ;; sparc*:BSD/OS:*:*) echo sparc-unknown-bsdi"$UNAME_RELEASE" exit ;; *:BSD/OS:*:*) echo "$UNAME_MACHINE"-unknown-bsdi"$UNAME_RELEASE" exit ;; *:FreeBSD:*:*) UNAME_PROCESSOR=`/usr/bin/uname -p` case "$UNAME_PROCESSOR" in amd64) UNAME_PROCESSOR=x86_64 ;; i386) UNAME_PROCESSOR=i586 ;; esac echo "$UNAME_PROCESSOR"-unknown-freebsd"`echo "$UNAME_RELEASE"|sed -e 's/[-(].*//'`" exit ;; i*:CYGWIN*:*) echo "$UNAME_MACHINE"-pc-cygwin exit ;; *:MINGW64*:*) echo "$UNAME_MACHINE"-pc-mingw64 exit ;; *:MINGW*:*) echo "$UNAME_MACHINE"-pc-mingw32 exit ;; *:MSYS*:*) echo "$UNAME_MACHINE"-pc-msys exit ;; i*:PW*:*) echo "$UNAME_MACHINE"-pc-pw32 exit ;; *:Interix*:*) case "$UNAME_MACHINE" in x86) echo i586-pc-interix"$UNAME_RELEASE" exit ;; authenticamd | genuineintel | EM64T) echo x86_64-unknown-interix"$UNAME_RELEASE" exit ;; IA64) echo ia64-unknown-interix"$UNAME_RELEASE" exit ;; esac ;; i*:UWIN*:*) echo "$UNAME_MACHINE"-pc-uwin exit ;; amd64:CYGWIN*:*:* | x86_64:CYGWIN*:*:*) echo x86_64-unknown-cygwin exit ;; prep*:SunOS:5.*:*) echo powerpcle-unknown-solaris2"`echo "$UNAME_RELEASE"|sed -e 's/[^.]*//'`" exit ;; *:GNU:*:*) # the GNU system echo "`echo "$UNAME_MACHINE"|sed -e 's,[-/].*$,,'`-unknown-$LIBC`echo "$UNAME_RELEASE"|sed -e 's,/.*$,,'`" exit ;; *:GNU/*:*:*) # other systems with GNU libc and userland echo "$UNAME_MACHINE-unknown-`echo "$UNAME_SYSTEM" | sed 's,^[^/]*/,,' | tr "[:upper:]" "[:lower:]"``echo "$UNAME_RELEASE"|sed -e 's/[-(].*//'`-$LIBC" exit ;; i*86:Minix:*:*) echo "$UNAME_MACHINE"-pc-minix exit ;; aarch64:Linux:*:*) echo "$UNAME_MACHINE"-unknown-linux-"$LIBC" exit ;; aarch64_be:Linux:*:*) UNAME_MACHINE=aarch64_be echo "$UNAME_MACHINE"-unknown-linux-"$LIBC" exit ;; alpha:Linux:*:*) case `sed -n '/^cpu model/s/^.*: \(.*\)/\1/p' < /proc/cpuinfo` in EV5) UNAME_MACHINE=alphaev5 ;; EV56) UNAME_MACHINE=alphaev56 ;; PCA56) UNAME_MACHINE=alphapca56 ;; PCA57) UNAME_MACHINE=alphapca56 ;; EV6) UNAME_MACHINE=alphaev6 ;; EV67) UNAME_MACHINE=alphaev67 ;; EV68*) UNAME_MACHINE=alphaev68 ;; esac objdump --private-headers /bin/sh | grep -q ld.so.1 if test "$?" = 0 ; then LIBC=gnulibc1 ; fi echo "$UNAME_MACHINE"-unknown-linux-"$LIBC" exit ;; arc:Linux:*:* | arceb:Linux:*:*) echo "$UNAME_MACHINE"-unknown-linux-"$LIBC" exit ;; arm*:Linux:*:*) eval "$set_cc_for_build" if echo __ARM_EABI__ | $CC_FOR_BUILD -E - 2>/dev/null \ | grep -q __ARM_EABI__ then echo "$UNAME_MACHINE"-unknown-linux-"$LIBC" else if echo __ARM_PCS_VFP | $CC_FOR_BUILD -E - 2>/dev/null \ | grep -q __ARM_PCS_VFP then echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"eabi else echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"eabihf fi fi exit ;; avr32*:Linux:*:*) echo "$UNAME_MACHINE"-unknown-linux-"$LIBC" exit ;; cris:Linux:*:*) echo "$UNAME_MACHINE"-axis-linux-"$LIBC" exit ;; crisv32:Linux:*:*) echo "$UNAME_MACHINE"-axis-linux-"$LIBC" exit ;; e2k:Linux:*:*) echo "$UNAME_MACHINE"-unknown-linux-"$LIBC" exit ;; frv:Linux:*:*) echo "$UNAME_MACHINE"-unknown-linux-"$LIBC" exit ;; hexagon:Linux:*:*) echo "$UNAME_MACHINE"-unknown-linux-"$LIBC" exit ;; i*86:Linux:*:*) echo "$UNAME_MACHINE"-pc-linux-"$LIBC" exit ;; ia64:Linux:*:*) echo "$UNAME_MACHINE"-unknown-linux-"$LIBC" exit ;; k1om:Linux:*:*) echo "$UNAME_MACHINE"-unknown-linux-"$LIBC" exit ;; m32r*:Linux:*:*) echo "$UNAME_MACHINE"-unknown-linux-"$LIBC" exit ;; m68*:Linux:*:*) echo "$UNAME_MACHINE"-unknown-linux-"$LIBC" exit ;; mips:Linux:*:* | mips64:Linux:*:*) eval "$set_cc_for_build" sed 's/^ //' << EOF > "$dummy.c" #undef CPU #undef ${UNAME_MACHINE} #undef ${UNAME_MACHINE}el #if defined(__MIPSEL__) || defined(__MIPSEL) || defined(_MIPSEL) || defined(MIPSEL) CPU=${UNAME_MACHINE}el #else #if defined(__MIPSEB__) || defined(__MIPSEB) || defined(_MIPSEB) || defined(MIPSEB) CPU=${UNAME_MACHINE} #else CPU= #endif #endif EOF eval "`$CC_FOR_BUILD -E "$dummy.c" 2>/dev/null | grep '^CPU'`" test "x$CPU" != x && { echo "$CPU-unknown-linux-$LIBC"; exit; } ;; mips64el:Linux:*:*) echo "$UNAME_MACHINE"-unknown-linux-"$LIBC" exit ;; openrisc*:Linux:*:*) echo or1k-unknown-linux-"$LIBC" exit ;; or32:Linux:*:* | or1k*:Linux:*:*) echo "$UNAME_MACHINE"-unknown-linux-"$LIBC" exit ;; padre:Linux:*:*) echo sparc-unknown-linux-"$LIBC" exit ;; parisc64:Linux:*:* | hppa64:Linux:*:*) echo hppa64-unknown-linux-"$LIBC" exit ;; parisc:Linux:*:* | hppa:Linux:*:*) # Look for CPU level case `grep '^cpu[^a-z]*:' /proc/cpuinfo 2>/dev/null | cut -d' ' -f2` in PA7*) echo hppa1.1-unknown-linux-"$LIBC" ;; PA8*) echo hppa2.0-unknown-linux-"$LIBC" ;; *) echo hppa-unknown-linux-"$LIBC" ;; esac exit ;; ppc64:Linux:*:*) echo powerpc64-unknown-linux-"$LIBC" exit ;; ppc:Linux:*:*) echo powerpc-unknown-linux-"$LIBC" exit ;; ppc64le:Linux:*:*) echo powerpc64le-unknown-linux-"$LIBC" exit ;; ppcle:Linux:*:*) echo powerpcle-unknown-linux-"$LIBC" exit ;; riscv32:Linux:*:* | riscv64:Linux:*:*) echo "$UNAME_MACHINE"-unknown-linux-"$LIBC" exit ;; s390:Linux:*:* | s390x:Linux:*:*) echo "$UNAME_MACHINE"-ibm-linux-"$LIBC" exit ;; sh64*:Linux:*:*) echo "$UNAME_MACHINE"-unknown-linux-"$LIBC" exit ;; sh*:Linux:*:*) echo "$UNAME_MACHINE"-unknown-linux-"$LIBC" exit ;; sparc:Linux:*:* | sparc64:Linux:*:*) echo "$UNAME_MACHINE"-unknown-linux-"$LIBC" exit ;; tile*:Linux:*:*) echo "$UNAME_MACHINE"-unknown-linux-"$LIBC" exit ;; vax:Linux:*:*) echo "$UNAME_MACHINE"-dec-linux-"$LIBC" exit ;; x86_64:Linux:*:*) if objdump -f /bin/sh | grep -q elf32-x86-64; then echo "$UNAME_MACHINE"-pc-linux-"$LIBC"x32 else echo "$UNAME_MACHINE"-pc-linux-"$LIBC" fi exit ;; xtensa*:Linux:*:*) echo "$UNAME_MACHINE"-unknown-linux-"$LIBC" exit ;; i*86:DYNIX/ptx:4*:*) # ptx 4.0 does uname -s correctly, with DYNIX/ptx in there. # earlier versions are messed up and put the nodename in both # sysname and nodename. echo i386-sequent-sysv4 exit ;; i*86:UNIX_SV:4.2MP:2.*) # Unixware is an offshoot of SVR4, but it has its own version # number series starting with 2... # I am not positive that other SVR4 systems won't match this, # I just have to hope. -- rms. # Use sysv4.2uw... so that sysv4* matches it. echo "$UNAME_MACHINE"-pc-sysv4.2uw"$UNAME_VERSION" exit ;; i*86:OS/2:*:*) # If we were able to find `uname', then EMX Unix compatibility # is probably installed. echo "$UNAME_MACHINE"-pc-os2-emx exit ;; i*86:XTS-300:*:STOP) echo "$UNAME_MACHINE"-unknown-stop exit ;; i*86:atheos:*:*) echo "$UNAME_MACHINE"-unknown-atheos exit ;; i*86:syllable:*:*) echo "$UNAME_MACHINE"-pc-syllable exit ;; i*86:LynxOS:2.*:* | i*86:LynxOS:3.[01]*:* | i*86:LynxOS:4.[02]*:*) echo i386-unknown-lynxos"$UNAME_RELEASE" exit ;; i*86:*DOS:*:*) echo "$UNAME_MACHINE"-pc-msdosdjgpp exit ;; i*86:*:4.*:*) UNAME_REL=`echo "$UNAME_RELEASE" | sed 's/\/MP$//'` if grep Novell /usr/include/link.h >/dev/null 2>/dev/null; then echo "$UNAME_MACHINE"-univel-sysv"$UNAME_REL" else echo "$UNAME_MACHINE"-pc-sysv"$UNAME_REL" fi exit ;; i*86:*:5:[678]*) # UnixWare 7.x, OpenUNIX and OpenServer 6. case `/bin/uname -X | grep "^Machine"` in *486*) UNAME_MACHINE=i486 ;; *Pentium) UNAME_MACHINE=i586 ;; *Pent*|*Celeron) UNAME_MACHINE=i686 ;; esac echo "$UNAME_MACHINE-unknown-sysv${UNAME_RELEASE}${UNAME_SYSTEM}{$UNAME_VERSION}" exit ;; i*86:*:3.2:*) if test -f /usr/options/cb.name; then UNAME_REL=`sed -n 's/.*Version //p' /dev/null >/dev/null ; then UNAME_REL=`(/bin/uname -X|grep Release|sed -e 's/.*= //')` (/bin/uname -X|grep i80486 >/dev/null) && UNAME_MACHINE=i486 (/bin/uname -X|grep '^Machine.*Pentium' >/dev/null) \ && UNAME_MACHINE=i586 (/bin/uname -X|grep '^Machine.*Pent *II' >/dev/null) \ && UNAME_MACHINE=i686 (/bin/uname -X|grep '^Machine.*Pentium Pro' >/dev/null) \ && UNAME_MACHINE=i686 echo "$UNAME_MACHINE"-pc-sco"$UNAME_REL" else echo "$UNAME_MACHINE"-pc-sysv32 fi exit ;; pc:*:*:*) # Left here for compatibility: # uname -m prints for DJGPP always 'pc', but it prints nothing about # the processor, so we play safe by assuming i586. # Note: whatever this is, it MUST be the same as what config.sub # prints for the "djgpp" host, or else GDB configure will decide that # this is a cross-build. echo i586-pc-msdosdjgpp exit ;; Intel:Mach:3*:*) echo i386-pc-mach3 exit ;; paragon:*:*:*) echo i860-intel-osf1 exit ;; i860:*:4.*:*) # i860-SVR4 if grep Stardent /usr/include/sys/uadmin.h >/dev/null 2>&1 ; then echo i860-stardent-sysv"$UNAME_RELEASE" # Stardent Vistra i860-SVR4 else # Add other i860-SVR4 vendors below as they are discovered. echo i860-unknown-sysv"$UNAME_RELEASE" # Unknown i860-SVR4 fi exit ;; mini*:CTIX:SYS*5:*) # "miniframe" echo m68010-convergent-sysv exit ;; mc68k:UNIX:SYSTEM5:3.51m) echo m68k-convergent-sysv exit ;; M680?0:D-NIX:5.3:*) echo m68k-diab-dnix exit ;; M68*:*:R3V[5678]*:*) test -r /sysV68 && { echo 'm68k-motorola-sysv'; exit; } ;; 3[345]??:*:4.0:3.0 | 3[34]??A:*:4.0:3.0 | 3[34]??,*:*:4.0:3.0 | 3[34]??/*:*:4.0:3.0 | 4400:*:4.0:3.0 | 4850:*:4.0:3.0 | SKA40:*:4.0:3.0 | SDS2:*:4.0:3.0 | SHG2:*:4.0:3.0 | S7501*:*:4.0:3.0) OS_REL='' test -r /etc/.relid \ && OS_REL=.`sed -n 's/[^ ]* [^ ]* \([0-9][0-9]\).*/\1/p' < /etc/.relid` /bin/uname -p 2>/dev/null | grep 86 >/dev/null \ && { echo i486-ncr-sysv4.3"$OS_REL"; exit; } /bin/uname -p 2>/dev/null | /bin/grep entium >/dev/null \ && { echo i586-ncr-sysv4.3"$OS_REL"; exit; } ;; 3[34]??:*:4.0:* | 3[34]??,*:*:4.0:*) /bin/uname -p 2>/dev/null | grep 86 >/dev/null \ && { echo i486-ncr-sysv4; exit; } ;; NCR*:*:4.2:* | MPRAS*:*:4.2:*) OS_REL='.3' test -r /etc/.relid \ && OS_REL=.`sed -n 's/[^ ]* [^ ]* \([0-9][0-9]\).*/\1/p' < /etc/.relid` /bin/uname -p 2>/dev/null | grep 86 >/dev/null \ && { echo i486-ncr-sysv4.3"$OS_REL"; exit; } /bin/uname -p 2>/dev/null | /bin/grep entium >/dev/null \ && { echo i586-ncr-sysv4.3"$OS_REL"; exit; } /bin/uname -p 2>/dev/null | /bin/grep pteron >/dev/null \ && { echo i586-ncr-sysv4.3"$OS_REL"; exit; } ;; m68*:LynxOS:2.*:* | m68*:LynxOS:3.0*:*) echo m68k-unknown-lynxos"$UNAME_RELEASE" exit ;; mc68030:UNIX_System_V:4.*:*) echo m68k-atari-sysv4 exit ;; TSUNAMI:LynxOS:2.*:*) echo sparc-unknown-lynxos"$UNAME_RELEASE" exit ;; rs6000:LynxOS:2.*:*) echo rs6000-unknown-lynxos"$UNAME_RELEASE" exit ;; PowerPC:LynxOS:2.*:* | PowerPC:LynxOS:3.[01]*:* | PowerPC:LynxOS:4.[02]*:*) echo powerpc-unknown-lynxos"$UNAME_RELEASE" exit ;; SM[BE]S:UNIX_SV:*:*) echo mips-dde-sysv"$UNAME_RELEASE" exit ;; RM*:ReliantUNIX-*:*:*) echo mips-sni-sysv4 exit ;; RM*:SINIX-*:*:*) echo mips-sni-sysv4 exit ;; *:SINIX-*:*:*) if uname -p 2>/dev/null >/dev/null ; then UNAME_MACHINE=`(uname -p) 2>/dev/null` echo "$UNAME_MACHINE"-sni-sysv4 else echo ns32k-sni-sysv fi exit ;; PENTIUM:*:4.0*:*) # Unisys `ClearPath HMP IX 4000' SVR4/MP effort # says echo i586-unisys-sysv4 exit ;; *:UNIX_System_V:4*:FTX*) # From Gerald Hewes . # How about differentiating between stratus architectures? -djm echo hppa1.1-stratus-sysv4 exit ;; *:*:*:FTX*) # From seanf@swdc.stratus.com. echo i860-stratus-sysv4 exit ;; i*86:VOS:*:*) # From Paul.Green@stratus.com. echo "$UNAME_MACHINE"-stratus-vos exit ;; *:VOS:*:*) # From Paul.Green@stratus.com. echo hppa1.1-stratus-vos exit ;; mc68*:A/UX:*:*) echo m68k-apple-aux"$UNAME_RELEASE" exit ;; news*:NEWS-OS:6*:*) echo mips-sony-newsos6 exit ;; R[34]000:*System_V*:*:* | R4000:UNIX_SYSV:*:* | R*000:UNIX_SV:*:*) if [ -d /usr/nec ]; then echo mips-nec-sysv"$UNAME_RELEASE" else echo mips-unknown-sysv"$UNAME_RELEASE" fi exit ;; BeBox:BeOS:*:*) # BeOS running on hardware made by Be, PPC only. echo powerpc-be-beos exit ;; BeMac:BeOS:*:*) # BeOS running on Mac or Mac clone, PPC only. echo powerpc-apple-beos exit ;; BePC:BeOS:*:*) # BeOS running on Intel PC compatible. echo i586-pc-beos exit ;; BePC:Haiku:*:*) # Haiku running on Intel PC compatible. echo i586-pc-haiku exit ;; x86_64:Haiku:*:*) echo x86_64-unknown-haiku exit ;; SX-4:SUPER-UX:*:*) echo sx4-nec-superux"$UNAME_RELEASE" exit ;; SX-5:SUPER-UX:*:*) echo sx5-nec-superux"$UNAME_RELEASE" exit ;; SX-6:SUPER-UX:*:*) echo sx6-nec-superux"$UNAME_RELEASE" exit ;; SX-7:SUPER-UX:*:*) echo sx7-nec-superux"$UNAME_RELEASE" exit ;; SX-8:SUPER-UX:*:*) echo sx8-nec-superux"$UNAME_RELEASE" exit ;; SX-8R:SUPER-UX:*:*) echo sx8r-nec-superux"$UNAME_RELEASE" exit ;; SX-ACE:SUPER-UX:*:*) echo sxace-nec-superux"$UNAME_RELEASE" exit ;; Power*:Rhapsody:*:*) echo powerpc-apple-rhapsody"$UNAME_RELEASE" exit ;; *:Rhapsody:*:*) echo "$UNAME_MACHINE"-apple-rhapsody"$UNAME_RELEASE" exit ;; *:Darwin:*:*) UNAME_PROCESSOR=`uname -p` || UNAME_PROCESSOR=unknown eval "$set_cc_for_build" if test "$UNAME_PROCESSOR" = unknown ; then UNAME_PROCESSOR=powerpc fi if test "`echo "$UNAME_RELEASE" | sed -e 's/\..*//'`" -le 10 ; then if [ "$CC_FOR_BUILD" != no_compiler_found ]; then if (echo '#ifdef __LP64__'; echo IS_64BIT_ARCH; echo '#endif') | \ (CCOPTS="" $CC_FOR_BUILD -E - 2>/dev/null) | \ grep IS_64BIT_ARCH >/dev/null then case $UNAME_PROCESSOR in i386) UNAME_PROCESSOR=x86_64 ;; powerpc) UNAME_PROCESSOR=powerpc64 ;; esac fi # On 10.4-10.6 one might compile for PowerPC via gcc -arch ppc if (echo '#ifdef __POWERPC__'; echo IS_PPC; echo '#endif') | \ (CCOPTS="" $CC_FOR_BUILD -E - 2>/dev/null) | \ grep IS_PPC >/dev/null then UNAME_PROCESSOR=powerpc fi fi elif test "$UNAME_PROCESSOR" = i386 ; then # Avoid executing cc on OS X 10.9, as it ships with a stub # that puts up a graphical alert prompting to install # developer tools. Any system running Mac OS X 10.7 or # later (Darwin 11 and later) is required to have a 64-bit # processor. This is not true of the ARM version of Darwin # that Apple uses in portable devices. UNAME_PROCESSOR=x86_64 fi echo "$UNAME_PROCESSOR"-apple-darwin"$UNAME_RELEASE" exit ;; *:procnto*:*:* | *:QNX:[0123456789]*:*) UNAME_PROCESSOR=`uname -p` if test "$UNAME_PROCESSOR" = x86; then UNAME_PROCESSOR=i386 UNAME_MACHINE=pc fi echo "$UNAME_PROCESSOR"-"$UNAME_MACHINE"-nto-qnx"$UNAME_RELEASE" exit ;; *:QNX:*:4*) echo i386-pc-qnx exit ;; NEO-*:NONSTOP_KERNEL:*:*) echo neo-tandem-nsk"$UNAME_RELEASE" exit ;; NSE-*:NONSTOP_KERNEL:*:*) echo nse-tandem-nsk"$UNAME_RELEASE" exit ;; NSR-*:NONSTOP_KERNEL:*:*) echo nsr-tandem-nsk"$UNAME_RELEASE" exit ;; NSV-*:NONSTOP_KERNEL:*:*) echo nsv-tandem-nsk"$UNAME_RELEASE" exit ;; NSX-*:NONSTOP_KERNEL:*:*) echo nsx-tandem-nsk"$UNAME_RELEASE" exit ;; *:NonStop-UX:*:*) echo mips-compaq-nonstopux exit ;; BS2000:POSIX*:*:*) echo bs2000-siemens-sysv exit ;; DS/*:UNIX_System_V:*:*) echo "$UNAME_MACHINE"-"$UNAME_SYSTEM"-"$UNAME_RELEASE" exit ;; *:Plan9:*:*) # "uname -m" is not consistent, so use $cputype instead. 386 # is converted to i386 for consistency with other x86 # operating systems. if test "$cputype" = 386; then UNAME_MACHINE=i386 else UNAME_MACHINE="$cputype" fi echo "$UNAME_MACHINE"-unknown-plan9 exit ;; *:TOPS-10:*:*) echo pdp10-unknown-tops10 exit ;; *:TENEX:*:*) echo pdp10-unknown-tenex exit ;; KS10:TOPS-20:*:* | KL10:TOPS-20:*:* | TYPE4:TOPS-20:*:*) echo pdp10-dec-tops20 exit ;; XKL-1:TOPS-20:*:* | TYPE5:TOPS-20:*:*) echo pdp10-xkl-tops20 exit ;; *:TOPS-20:*:*) echo pdp10-unknown-tops20 exit ;; *:ITS:*:*) echo pdp10-unknown-its exit ;; SEI:*:*:SEIUX) echo mips-sei-seiux"$UNAME_RELEASE" exit ;; *:DragonFly:*:*) echo "$UNAME_MACHINE"-unknown-dragonfly"`echo "$UNAME_RELEASE"|sed -e 's/[-(].*//'`" exit ;; *:*VMS:*:*) UNAME_MACHINE=`(uname -p) 2>/dev/null` case "$UNAME_MACHINE" in A*) echo alpha-dec-vms ; exit ;; I*) echo ia64-dec-vms ; exit ;; V*) echo vax-dec-vms ; exit ;; esac ;; *:XENIX:*:SysV) echo i386-pc-xenix exit ;; i*86:skyos:*:*) echo "$UNAME_MACHINE"-pc-skyos"`echo "$UNAME_RELEASE" | sed -e 's/ .*$//'`" exit ;; i*86:rdos:*:*) echo "$UNAME_MACHINE"-pc-rdos exit ;; i*86:AROS:*:*) echo "$UNAME_MACHINE"-pc-aros exit ;; x86_64:VMkernel:*:*) echo "$UNAME_MACHINE"-unknown-esx exit ;; amd64:Isilon\ OneFS:*:*) echo x86_64-unknown-onefs exit ;; esac echo "$0: unable to guess system type" >&2 case "$UNAME_MACHINE:$UNAME_SYSTEM" in mips:Linux | mips64:Linux) # If we got here on MIPS GNU/Linux, output extra information. cat >&2 <&2 </dev/null || echo unknown` uname -r = `(uname -r) 2>/dev/null || echo unknown` uname -s = `(uname -s) 2>/dev/null || echo unknown` uname -v = `(uname -v) 2>/dev/null || echo unknown` /usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null` /bin/uname -X = `(/bin/uname -X) 2>/dev/null` hostinfo = `(hostinfo) 2>/dev/null` /bin/universe = `(/bin/universe) 2>/dev/null` /usr/bin/arch -k = `(/usr/bin/arch -k) 2>/dev/null` /bin/arch = `(/bin/arch) 2>/dev/null` /usr/bin/oslevel = `(/usr/bin/oslevel) 2>/dev/null` /usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null` UNAME_MACHINE = "$UNAME_MACHINE" UNAME_RELEASE = "$UNAME_RELEASE" UNAME_SYSTEM = "$UNAME_SYSTEM" UNAME_VERSION = "$UNAME_VERSION" EOF exit 1 # Local variables: # eval: (add-hook 'write-file-functions 'time-stamp) # time-stamp-start: "timestamp='" # time-stamp-format: "%:y-%02m-%02d" # time-stamp-end: "'" # End: gtkada-24.0.0/config.sub000077500000000000000000001064501446021174000150200ustar00rootroot00000000000000#! /bin/sh # Configuration validation subroutine script. # Copyright 1992-2018 Free Software Foundation, Inc. timestamp='2018-02-22' # This file is free software; you can redistribute it and/or modify it # under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 3 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, but # WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU # General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, see . # # As a special exception to the GNU General Public License, if you # distribute this file as part of a program that contains a # configuration script generated by Autoconf, you may include it under # the same distribution terms that you use for the rest of that # program. This Exception is an additional permission under section 7 # of the GNU General Public License, version 3 ("GPLv3"). # Please send patches to . # # Configuration subroutine to validate and canonicalize a configuration type. # Supply the specified configuration type as an argument. # If it is invalid, we print an error message on stderr and exit with code 1. # Otherwise, we print the canonical config type on stdout and succeed. # You can get the latest version of this script from: # https://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.sub # This file is supposed to be the same for all GNU packages # and recognize all the CPU types, system types and aliases # that are meaningful with *any* GNU software. # Each package is responsible for reporting which valid configurations # it does not support. The user should be able to distinguish # a failure to support a valid configuration from a meaningless # configuration. # The goal of this file is to map all the various variations of a given # machine specification into a single specification in the form: # CPU_TYPE-MANUFACTURER-OPERATING_SYSTEM # or in some cases, the newer four-part form: # CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM # It is wrong to echo any other type of specification. me=`echo "$0" | sed -e 's,.*/,,'` usage="\ Usage: $0 [OPTION] CPU-MFR-OPSYS or ALIAS Canonicalize a configuration name. Options: -h, --help print this help, then exit -t, --time-stamp print date of last modification, then exit -v, --version print version number, then exit Report bugs and patches to ." version="\ GNU config.sub ($timestamp) Copyright 1992-2018 Free Software Foundation, Inc. This is free software; see the source for copying conditions. There is NO warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE." help=" Try \`$me --help' for more information." # Parse command line while test $# -gt 0 ; do case $1 in --time-stamp | --time* | -t ) echo "$timestamp" ; exit ;; --version | -v ) echo "$version" ; exit ;; --help | --h* | -h ) echo "$usage"; exit ;; -- ) # Stop option processing shift; break ;; - ) # Use stdin as input. break ;; -* ) echo "$me: invalid option $1$help" exit 1 ;; *local*) # First pass through any local machine types. echo "$1" exit ;; * ) break ;; esac done case $# in 0) echo "$me: missing argument$help" >&2 exit 1;; 1) ;; *) echo "$me: too many arguments$help" >&2 exit 1;; esac # Separate what the user gave into CPU-COMPANY and OS or KERNEL-OS (if any). # Here we must recognize all the valid KERNEL-OS combinations. maybe_os=`echo "$1" | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\2/'` case $maybe_os in nto-qnx* | linux-gnu* | linux-android* | linux-dietlibc | linux-newlib* | \ linux-musl* | linux-uclibc* | uclinux-uclibc* | uclinux-gnu* | kfreebsd*-gnu* | \ knetbsd*-gnu* | netbsd*-gnu* | netbsd*-eabi* | \ kopensolaris*-gnu* | cloudabi*-eabi* | \ storm-chaos* | os2-emx* | rtmk-nova*) os=-$maybe_os basic_machine=`echo "$1" | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\1/'` ;; android-linux) os=-linux-android basic_machine=`echo "$1" | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\1/'`-unknown ;; *) basic_machine=`echo "$1" | sed 's/-[^-]*$//'` if [ "$basic_machine" != "$1" ] then os=`echo "$1" | sed 's/.*-/-/'` else os=; fi ;; esac ### Let's recognize common machines as not being operating systems so ### that things like config.sub decstation-3100 work. We also ### recognize some manufacturers as not being operating systems, so we ### can provide default operating systems below. case $os in -sun*os*) # Prevent following clause from handling this invalid input. ;; -dec* | -mips* | -sequent* | -encore* | -pc532* | -sgi* | -sony* | \ -att* | -7300* | -3300* | -delta* | -motorola* | -sun[234]* | \ -unicom* | -ibm* | -next | -hp | -isi* | -apollo | -altos* | \ -convergent* | -ncr* | -news | -32* | -3600* | -3100* | -hitachi* |\ -c[123]* | -convex* | -sun | -crds | -omron* | -dg | -ultra | -tti* | \ -harris | -dolphin | -highlevel | -gould | -cbm | -ns | -masscomp | \ -apple | -axis | -knuth | -cray | -microblaze*) os= basic_machine=$1 ;; -bluegene*) os=-cnk ;; -sim | -cisco | -oki | -wec | -winbond) os= basic_machine=$1 ;; -scout) ;; -wrs) os=-vxworks basic_machine=$1 ;; -chorusos*) os=-chorusos basic_machine=$1 ;; -chorusrdb) os=-chorusrdb basic_machine=$1 ;; -hiux*) os=-hiuxwe2 ;; -sco6) os=-sco5v6 basic_machine=`echo "$1" | sed -e 's/86-.*/86-pc/'` ;; -sco5) os=-sco3.2v5 basic_machine=`echo "$1" | sed -e 's/86-.*/86-pc/'` ;; -sco4) os=-sco3.2v4 basic_machine=`echo "$1" | sed -e 's/86-.*/86-pc/'` ;; -sco3.2.[4-9]*) os=`echo $os | sed -e 's/sco3.2./sco3.2v/'` basic_machine=`echo "$1" | sed -e 's/86-.*/86-pc/'` ;; -sco3.2v[4-9]*) # Don't forget version if it is 3.2v4 or newer. basic_machine=`echo "$1" | sed -e 's/86-.*/86-pc/'` ;; -sco5v6*) # Don't forget version if it is 3.2v4 or newer. basic_machine=`echo "$1" | sed -e 's/86-.*/86-pc/'` ;; -sco*) os=-sco3.2v2 basic_machine=`echo "$1" | sed -e 's/86-.*/86-pc/'` ;; -udk*) basic_machine=`echo "$1" | sed -e 's/86-.*/86-pc/'` ;; -isc) os=-isc2.2 basic_machine=`echo "$1" | sed -e 's/86-.*/86-pc/'` ;; -clix*) basic_machine=clipper-intergraph ;; -isc*) basic_machine=`echo "$1" | sed -e 's/86-.*/86-pc/'` ;; -lynx*178) os=-lynxos178 ;; -lynx*5) os=-lynxos5 ;; -lynx*) os=-lynxos ;; -ptx*) basic_machine=`echo "$1" | sed -e 's/86-.*/86-sequent/'` ;; -psos*) os=-psos ;; -mint | -mint[0-9]*) basic_machine=m68k-atari os=-mint ;; esac # Decode aliases for certain CPU-COMPANY combinations. case $basic_machine in # Recognize the basic CPU types without company name. # Some are omitted here because they have special meanings below. 1750a | 580 \ | a29k \ | aarch64 | aarch64_be \ | alpha | alphaev[4-8] | alphaev56 | alphaev6[78] | alphapca5[67] \ | alpha64 | alpha64ev[4-8] | alpha64ev56 | alpha64ev6[78] | alpha64pca5[67] \ | am33_2.0 \ | arc | arceb \ | arm | arm[bl]e | arme[lb] | armv[2-8] | armv[3-8][lb] | armv7[arm] \ | avr | avr32 \ | ba \ | be32 | be64 \ | bfin \ | c4x | c8051 | clipper \ | d10v | d30v | dlx | dsp16xx \ | e2k | epiphany \ | fido | fr30 | frv | ft32 \ | h8300 | h8500 | hppa | hppa1.[01] | hppa2.0 | hppa2.0[nw] | hppa64 \ | hexagon \ | i370 | i860 | i960 | ia16 | ia64 \ | ip2k | iq2000 \ | k1om \ | le32 | le64 \ | lm32 \ | m32c | m32r | m32rle | m68000 | m68k | m88k \ | maxq | mb | microblaze | microblazeel | mcore | mep | metag \ | mips | mipsbe | mipseb | mipsel | mipsle \ | mips16 \ | mips64 | mips64el \ | mips64octeon | mips64octeonel \ | mips64orion | mips64orionel \ | mips64r5900 | mips64r5900el \ | mips64vr | mips64vrel \ | mips64vr4100 | mips64vr4100el \ | mips64vr4300 | mips64vr4300el \ | mips64vr5000 | mips64vr5000el \ | mips64vr5900 | mips64vr5900el \ | mipsisa32 | mipsisa32el \ | mipsisa32r2 | mipsisa32r2el \ | mipsisa32r6 | mipsisa32r6el \ | mipsisa64 | mipsisa64el \ | mipsisa64r2 | mipsisa64r2el \ | mipsisa64r6 | mipsisa64r6el \ | mipsisa64sb1 | mipsisa64sb1el \ | mipsisa64sr71k | mipsisa64sr71kel \ | mipsr5900 | mipsr5900el \ | mipstx39 | mipstx39el \ | mn10200 | mn10300 \ | moxie \ | mt \ | msp430 \ | nds32 | nds32le | nds32be \ | nios | nios2 | nios2eb | nios2el \ | ns16k | ns32k \ | open8 | or1k | or1knd | or32 \ | pdp10 | pj | pjl \ | powerpc | powerpc64 | powerpc64le | powerpcle \ | pru \ | pyramid \ | riscv32 | riscv64 \ | rl78 | rx \ | score \ | sh | sh[1234] | sh[24]a | sh[24]aeb | sh[23]e | sh[234]eb | sheb | shbe | shle | sh[1234]le | sh3ele \ | sh64 | sh64le \ | sparc | sparc64 | sparc64b | sparc64v | sparc86x | sparclet | sparclite \ | sparcv8 | sparcv9 | sparcv9b | sparcv9v \ | spu \ | tahoe | tic4x | tic54x | tic55x | tic6x | tic80 | tron \ | ubicom32 \ | v850 | v850e | v850e1 | v850e2 | v850es | v850e2v3 \ | visium \ | wasm32 \ | x86 | xc16x | xstormy16 | xtensa \ | z8k | z80) basic_machine=$basic_machine-unknown ;; c54x) basic_machine=tic54x-unknown ;; c55x) basic_machine=tic55x-unknown ;; c6x) basic_machine=tic6x-unknown ;; leon|leon[3-9]) basic_machine=sparc-$basic_machine ;; m6811 | m68hc11 | m6812 | m68hc12 | m68hcs12x | nvptx | picochip) basic_machine=$basic_machine-unknown os=-none ;; m88110 | m680[12346]0 | m683?2 | m68360 | m5200 | v70 | w65) ;; ms1) basic_machine=mt-unknown ;; strongarm | thumb | xscale) basic_machine=arm-unknown ;; xgate) basic_machine=$basic_machine-unknown os=-none ;; xscaleeb) basic_machine=armeb-unknown ;; xscaleel) basic_machine=armel-unknown ;; # We use `pc' rather than `unknown' # because (1) that's what they normally are, and # (2) the word "unknown" tends to confuse beginning users. i*86 | x86_64) basic_machine=$basic_machine-pc ;; # Object if more than one company name word. *-*-*) echo Invalid configuration \`"$1"\': machine \`"$basic_machine"\' not recognized 1>&2 exit 1 ;; # Recognize the basic CPU types with company name. 580-* \ | a29k-* \ | aarch64-* | aarch64_be-* \ | alpha-* | alphaev[4-8]-* | alphaev56-* | alphaev6[78]-* \ | alpha64-* | alpha64ev[4-8]-* | alpha64ev56-* | alpha64ev6[78]-* \ | alphapca5[67]-* | alpha64pca5[67]-* | arc-* | arceb-* \ | arm-* | armbe-* | armle-* | armeb-* | armv*-* \ | avr-* | avr32-* \ | ba-* \ | be32-* | be64-* \ | bfin-* | bs2000-* \ | c[123]* | c30-* | [cjt]90-* | c4x-* \ | c8051-* | clipper-* | craynv-* | cydra-* \ | d10v-* | d30v-* | dlx-* \ | e2k-* | elxsi-* \ | f30[01]-* | f700-* | fido-* | fr30-* | frv-* | fx80-* \ | h8300-* | h8500-* \ | hppa-* | hppa1.[01]-* | hppa2.0-* | hppa2.0[nw]-* | hppa64-* \ | hexagon-* \ | i*86-* | i860-* | i960-* | ia16-* | ia64-* \ | ip2k-* | iq2000-* \ | k1om-* \ | le32-* | le64-* \ | lm32-* \ | m32c-* | m32r-* | m32rle-* \ | m68000-* | m680[012346]0-* | m68360-* | m683?2-* | m68k-* \ | m88110-* | m88k-* | maxq-* | mcore-* | metag-* \ | microblaze-* | microblazeel-* \ | mips-* | mipsbe-* | mipseb-* | mipsel-* | mipsle-* \ | mips16-* \ | mips64-* | mips64el-* \ | mips64octeon-* | mips64octeonel-* \ | mips64orion-* | mips64orionel-* \ | mips64r5900-* | mips64r5900el-* \ | mips64vr-* | mips64vrel-* \ | mips64vr4100-* | mips64vr4100el-* \ | mips64vr4300-* | mips64vr4300el-* \ | mips64vr5000-* | mips64vr5000el-* \ | mips64vr5900-* | mips64vr5900el-* \ | mipsisa32-* | mipsisa32el-* \ | mipsisa32r2-* | mipsisa32r2el-* \ | mipsisa32r6-* | mipsisa32r6el-* \ | mipsisa64-* | mipsisa64el-* \ | mipsisa64r2-* | mipsisa64r2el-* \ | mipsisa64r6-* | mipsisa64r6el-* \ | mipsisa64sb1-* | mipsisa64sb1el-* \ | mipsisa64sr71k-* | mipsisa64sr71kel-* \ | mipsr5900-* | mipsr5900el-* \ | mipstx39-* | mipstx39el-* \ | mmix-* \ | mt-* \ | msp430-* \ | nds32-* | nds32le-* | nds32be-* \ | nios-* | nios2-* | nios2eb-* | nios2el-* \ | none-* | np1-* | ns16k-* | ns32k-* \ | open8-* \ | or1k*-* \ | orion-* \ | pdp10-* | pdp11-* | pj-* | pjl-* | pn-* | power-* \ | powerpc-* | powerpc64-* | powerpc64le-* | powerpcle-* \ | pru-* \ | pyramid-* \ | riscv32-* | riscv64-* \ | rl78-* | romp-* | rs6000-* | rx-* \ | sh-* | sh[1234]-* | sh[24]a-* | sh[24]aeb-* | sh[23]e-* | sh[34]eb-* | sheb-* | shbe-* \ | shle-* | sh[1234]le-* | sh3ele-* | sh64-* | sh64le-* \ | sparc-* | sparc64-* | sparc64b-* | sparc64v-* | sparc86x-* | sparclet-* \ | sparclite-* \ | sparcv8-* | sparcv9-* | sparcv9b-* | sparcv9v-* | sv1-* | sx*-* \ | tahoe-* \ | tic30-* | tic4x-* | tic54x-* | tic55x-* | tic6x-* | tic80-* \ | tile*-* \ | tron-* \ | ubicom32-* \ | v850-* | v850e-* | v850e1-* | v850es-* | v850e2-* | v850e2v3-* \ | vax-* \ | visium-* \ | wasm32-* \ | we32k-* \ | x86-* | x86_64-* | xc16x-* | xps100-* \ | xstormy16-* | xtensa*-* \ | ymp-* \ | z8k-* | z80-*) ;; # Recognize the basic CPU types without company name, with glob match. xtensa*) basic_machine=$basic_machine-unknown ;; # Recognize the various machine names and aliases which stand # for a CPU type and a company and sometimes even an OS. 386bsd) basic_machine=i386-pc os=-bsd ;; 3b1 | 7300 | 7300-att | att-7300 | pc7300 | safari | unixpc) basic_machine=m68000-att ;; 3b*) basic_machine=we32k-att ;; a29khif) basic_machine=a29k-amd os=-udi ;; abacus) basic_machine=abacus-unknown ;; adobe68k) basic_machine=m68010-adobe os=-scout ;; alliant | fx80) basic_machine=fx80-alliant ;; altos | altos3068) basic_machine=m68k-altos ;; am29k) basic_machine=a29k-none os=-bsd ;; amd64) basic_machine=x86_64-pc ;; amd64-*) basic_machine=x86_64-`echo "$basic_machine" | sed 's/^[^-]*-//'` ;; amdahl) basic_machine=580-amdahl os=-sysv ;; amiga | amiga-*) basic_machine=m68k-unknown ;; amigaos | amigados) basic_machine=m68k-unknown os=-amigaos ;; amigaunix | amix) basic_machine=m68k-unknown os=-sysv4 ;; apollo68) basic_machine=m68k-apollo os=-sysv ;; apollo68bsd) basic_machine=m68k-apollo os=-bsd ;; aros) basic_machine=i386-pc os=-aros ;; asmjs) basic_machine=asmjs-unknown ;; aux) basic_machine=m68k-apple os=-aux ;; balance) basic_machine=ns32k-sequent os=-dynix ;; blackfin) basic_machine=bfin-unknown os=-linux ;; blackfin-*) basic_machine=bfin-`echo "$basic_machine" | sed 's/^[^-]*-//'` os=-linux ;; bluegene*) basic_machine=powerpc-ibm os=-cnk ;; c54x-*) basic_machine=tic54x-`echo "$basic_machine" | sed 's/^[^-]*-//'` ;; c55x-*) basic_machine=tic55x-`echo "$basic_machine" | sed 's/^[^-]*-//'` ;; c6x-*) basic_machine=tic6x-`echo "$basic_machine" | sed 's/^[^-]*-//'` ;; c90) basic_machine=c90-cray os=-unicos ;; cegcc) basic_machine=arm-unknown os=-cegcc ;; convex-c1) basic_machine=c1-convex os=-bsd ;; convex-c2) basic_machine=c2-convex os=-bsd ;; convex-c32) basic_machine=c32-convex os=-bsd ;; convex-c34) basic_machine=c34-convex os=-bsd ;; convex-c38) basic_machine=c38-convex os=-bsd ;; cray | j90) basic_machine=j90-cray os=-unicos ;; craynv) basic_machine=craynv-cray os=-unicosmp ;; cr16 | cr16-*) basic_machine=cr16-unknown os=-elf ;; crds | unos) basic_machine=m68k-crds ;; crisv32 | crisv32-* | etraxfs*) basic_machine=crisv32-axis ;; cris | cris-* | etrax*) basic_machine=cris-axis ;; crx) basic_machine=crx-unknown os=-elf ;; da30 | da30-*) basic_machine=m68k-da30 ;; decstation | decstation-3100 | pmax | pmax-* | pmin | dec3100 | decstatn) basic_machine=mips-dec ;; decsystem10* | dec10*) basic_machine=pdp10-dec os=-tops10 ;; decsystem20* | dec20*) basic_machine=pdp10-dec os=-tops20 ;; delta | 3300 | motorola-3300 | motorola-delta \ | 3300-motorola | delta-motorola) basic_machine=m68k-motorola ;; delta88) basic_machine=m88k-motorola os=-sysv3 ;; dicos) basic_machine=i686-pc os=-dicos ;; djgpp) basic_machine=i586-pc os=-msdosdjgpp ;; dpx20 | dpx20-*) basic_machine=rs6000-bull os=-bosx ;; dpx2*) basic_machine=m68k-bull os=-sysv3 ;; e500v[12]) basic_machine=powerpc-unknown os=$os"spe" ;; e500v[12]-*) basic_machine=powerpc-`echo "$basic_machine" | sed 's/^[^-]*-//'` os=$os"spe" ;; ebmon29k) basic_machine=a29k-amd os=-ebmon ;; elxsi) basic_machine=elxsi-elxsi os=-bsd ;; encore | umax | mmax) basic_machine=ns32k-encore ;; es1800 | OSE68k | ose68k | ose | OSE) basic_machine=m68k-ericsson os=-ose ;; fx2800) basic_machine=i860-alliant ;; genix) basic_machine=ns32k-ns ;; gmicro) basic_machine=tron-gmicro os=-sysv ;; go32) basic_machine=i386-pc os=-go32 ;; h3050r* | hiux*) basic_machine=hppa1.1-hitachi os=-hiuxwe2 ;; h8300hms) basic_machine=h8300-hitachi os=-hms ;; h8300xray) basic_machine=h8300-hitachi os=-xray ;; h8500hms) basic_machine=h8500-hitachi os=-hms ;; harris) basic_machine=m88k-harris os=-sysv3 ;; hp300-*) basic_machine=m68k-hp ;; hp300bsd) basic_machine=m68k-hp os=-bsd ;; hp300hpux) basic_machine=m68k-hp os=-hpux ;; hp3k9[0-9][0-9] | hp9[0-9][0-9]) basic_machine=hppa1.0-hp ;; hp9k2[0-9][0-9] | hp9k31[0-9]) basic_machine=m68000-hp ;; hp9k3[2-9][0-9]) basic_machine=m68k-hp ;; hp9k6[0-9][0-9] | hp6[0-9][0-9]) basic_machine=hppa1.0-hp ;; hp9k7[0-79][0-9] | hp7[0-79][0-9]) basic_machine=hppa1.1-hp ;; hp9k78[0-9] | hp78[0-9]) # FIXME: really hppa2.0-hp basic_machine=hppa1.1-hp ;; hp9k8[67]1 | hp8[67]1 | hp9k80[24] | hp80[24] | hp9k8[78]9 | hp8[78]9 | hp9k893 | hp893) # FIXME: really hppa2.0-hp basic_machine=hppa1.1-hp ;; hp9k8[0-9][13679] | hp8[0-9][13679]) basic_machine=hppa1.1-hp ;; hp9k8[0-9][0-9] | hp8[0-9][0-9]) basic_machine=hppa1.0-hp ;; hppaosf) basic_machine=hppa1.1-hp os=-osf ;; hppro) basic_machine=hppa1.1-hp os=-proelf ;; i370-ibm* | ibm*) basic_machine=i370-ibm ;; i*86v32) basic_machine=`echo "$1" | sed -e 's/86.*/86-pc/'` os=-sysv32 ;; i*86v4*) basic_machine=`echo "$1" | sed -e 's/86.*/86-pc/'` os=-sysv4 ;; i*86v) basic_machine=`echo "$1" | sed -e 's/86.*/86-pc/'` os=-sysv ;; i*86sol2) basic_machine=`echo "$1" | sed -e 's/86.*/86-pc/'` os=-solaris2 ;; i386mach) basic_machine=i386-mach os=-mach ;; vsta) basic_machine=i386-unknown os=-vsta ;; iris | iris4d) basic_machine=mips-sgi case $os in -irix*) ;; *) os=-irix4 ;; esac ;; isi68 | isi) basic_machine=m68k-isi os=-sysv ;; leon-*|leon[3-9]-*) basic_machine=sparc-`echo "$basic_machine" | sed 's/-.*//'` ;; m68knommu) basic_machine=m68k-unknown os=-linux ;; m68knommu-*) basic_machine=m68k-`echo "$basic_machine" | sed 's/^[^-]*-//'` os=-linux ;; magnum | m3230) basic_machine=mips-mips os=-sysv ;; merlin) basic_machine=ns32k-utek os=-sysv ;; microblaze*) basic_machine=microblaze-xilinx ;; mingw64) basic_machine=x86_64-pc os=-mingw64 ;; mingw32) basic_machine=i686-pc os=-mingw32 ;; mingw32ce) basic_machine=arm-unknown os=-mingw32ce ;; miniframe) basic_machine=m68000-convergent ;; *mint | -mint[0-9]* | *MiNT | *MiNT[0-9]*) basic_machine=m68k-atari os=-mint ;; mips3*-*) basic_machine=`echo "$basic_machine" | sed -e 's/mips3/mips64/'` ;; mips3*) basic_machine=`echo "$basic_machine" | sed -e 's/mips3/mips64/'`-unknown ;; monitor) basic_machine=m68k-rom68k os=-coff ;; morphos) basic_machine=powerpc-unknown os=-morphos ;; moxiebox) basic_machine=moxie-unknown os=-moxiebox ;; msdos) basic_machine=i386-pc os=-msdos ;; ms1-*) basic_machine=`echo "$basic_machine" | sed -e 's/ms1-/mt-/'` ;; msys) basic_machine=i686-pc os=-msys ;; mvs) basic_machine=i370-ibm os=-mvs ;; nacl) basic_machine=le32-unknown os=-nacl ;; ncr3000) basic_machine=i486-ncr os=-sysv4 ;; netbsd386) basic_machine=i386-unknown os=-netbsd ;; netwinder) basic_machine=armv4l-rebel os=-linux ;; news | news700 | news800 | news900) basic_machine=m68k-sony os=-newsos ;; news1000) basic_machine=m68030-sony os=-newsos ;; news-3600 | risc-news) basic_machine=mips-sony os=-newsos ;; necv70) basic_machine=v70-nec os=-sysv ;; next | m*-next) basic_machine=m68k-next case $os in -nextstep* ) ;; -ns2*) os=-nextstep2 ;; *) os=-nextstep3 ;; esac ;; nh3000) basic_machine=m68k-harris os=-cxux ;; nh[45]000) basic_machine=m88k-harris os=-cxux ;; nindy960) basic_machine=i960-intel os=-nindy ;; mon960) basic_machine=i960-intel os=-mon960 ;; nonstopux) basic_machine=mips-compaq os=-nonstopux ;; np1) basic_machine=np1-gould ;; neo-tandem) basic_machine=neo-tandem ;; nse-tandem) basic_machine=nse-tandem ;; nsr-tandem) basic_machine=nsr-tandem ;; nsv-tandem) basic_machine=nsv-tandem ;; nsx-tandem) basic_machine=nsx-tandem ;; op50n-* | op60c-*) basic_machine=hppa1.1-oki os=-proelf ;; openrisc | openrisc-*) basic_machine=or32-unknown ;; os400) basic_machine=powerpc-ibm os=-os400 ;; OSE68000 | ose68000) basic_machine=m68000-ericsson os=-ose ;; os68k) basic_machine=m68k-none os=-os68k ;; pa-hitachi) basic_machine=hppa1.1-hitachi os=-hiuxwe2 ;; paragon) basic_machine=i860-intel os=-osf ;; parisc) basic_machine=hppa-unknown os=-linux ;; parisc-*) basic_machine=hppa-`echo "$basic_machine" | sed 's/^[^-]*-//'` os=-linux ;; pbd) basic_machine=sparc-tti ;; pbb) basic_machine=m68k-tti ;; pc532 | pc532-*) basic_machine=ns32k-pc532 ;; pc98) basic_machine=i386-pc ;; pc98-*) basic_machine=i386-`echo "$basic_machine" | sed 's/^[^-]*-//'` ;; pentium | p5 | k5 | k6 | nexgen | viac3) basic_machine=i586-pc ;; pentiumpro | p6 | 6x86 | athlon | athlon_*) basic_machine=i686-pc ;; pentiumii | pentium2 | pentiumiii | pentium3) basic_machine=i686-pc ;; pentium4) basic_machine=i786-pc ;; pentium-* | p5-* | k5-* | k6-* | nexgen-* | viac3-*) basic_machine=i586-`echo "$basic_machine" | sed 's/^[^-]*-//'` ;; pentiumpro-* | p6-* | 6x86-* | athlon-*) basic_machine=i686-`echo "$basic_machine" | sed 's/^[^-]*-//'` ;; pentiumii-* | pentium2-* | pentiumiii-* | pentium3-*) basic_machine=i686-`echo "$basic_machine" | sed 's/^[^-]*-//'` ;; pentium4-*) basic_machine=i786-`echo "$basic_machine" | sed 's/^[^-]*-//'` ;; pn) basic_machine=pn-gould ;; power) basic_machine=power-ibm ;; ppc | ppcbe) basic_machine=powerpc-unknown ;; ppc-* | ppcbe-*) basic_machine=powerpc-`echo "$basic_machine" | sed 's/^[^-]*-//'` ;; ppcle | powerpclittle) basic_machine=powerpcle-unknown ;; ppcle-* | powerpclittle-*) basic_machine=powerpcle-`echo "$basic_machine" | sed 's/^[^-]*-//'` ;; ppc64) basic_machine=powerpc64-unknown ;; ppc64-*) basic_machine=powerpc64-`echo "$basic_machine" | sed 's/^[^-]*-//'` ;; ppc64le | powerpc64little) basic_machine=powerpc64le-unknown ;; ppc64le-* | powerpc64little-*) basic_machine=powerpc64le-`echo "$basic_machine" | sed 's/^[^-]*-//'` ;; ps2) basic_machine=i386-ibm ;; pw32) basic_machine=i586-unknown os=-pw32 ;; rdos | rdos64) basic_machine=x86_64-pc os=-rdos ;; rdos32) basic_machine=i386-pc os=-rdos ;; rom68k) basic_machine=m68k-rom68k os=-coff ;; rm[46]00) basic_machine=mips-siemens ;; rtpc | rtpc-*) basic_machine=romp-ibm ;; s390 | s390-*) basic_machine=s390-ibm ;; s390x | s390x-*) basic_machine=s390x-ibm ;; sa29200) basic_machine=a29k-amd os=-udi ;; sb1) basic_machine=mipsisa64sb1-unknown ;; sb1el) basic_machine=mipsisa64sb1el-unknown ;; sde) basic_machine=mipsisa32-sde os=-elf ;; sei) basic_machine=mips-sei os=-seiux ;; sequent) basic_machine=i386-sequent ;; sh5el) basic_machine=sh5le-unknown ;; simso-wrs) basic_machine=sparclite-wrs os=-vxworks ;; sps7) basic_machine=m68k-bull os=-sysv2 ;; spur) basic_machine=spur-unknown ;; st2000) basic_machine=m68k-tandem ;; stratus) basic_machine=i860-stratus os=-sysv4 ;; strongarm-* | thumb-*) basic_machine=arm-`echo "$basic_machine" | sed 's/^[^-]*-//'` ;; sun2) basic_machine=m68000-sun ;; sun2os3) basic_machine=m68000-sun os=-sunos3 ;; sun2os4) basic_machine=m68000-sun os=-sunos4 ;; sun3os3) basic_machine=m68k-sun os=-sunos3 ;; sun3os4) basic_machine=m68k-sun os=-sunos4 ;; sun4os3) basic_machine=sparc-sun os=-sunos3 ;; sun4os4) basic_machine=sparc-sun os=-sunos4 ;; sun4sol2) basic_machine=sparc-sun os=-solaris2 ;; sun3 | sun3-*) basic_machine=m68k-sun ;; sun4) basic_machine=sparc-sun ;; sun386 | sun386i | roadrunner) basic_machine=i386-sun ;; sv1) basic_machine=sv1-cray os=-unicos ;; symmetry) basic_machine=i386-sequent os=-dynix ;; t3e) basic_machine=alphaev5-cray os=-unicos ;; t90) basic_machine=t90-cray os=-unicos ;; tile*) basic_machine=$basic_machine-unknown os=-linux-gnu ;; tx39) basic_machine=mipstx39-unknown ;; tx39el) basic_machine=mipstx39el-unknown ;; toad1) basic_machine=pdp10-xkl os=-tops20 ;; tower | tower-32) basic_machine=m68k-ncr ;; tpf) basic_machine=s390x-ibm os=-tpf ;; udi29k) basic_machine=a29k-amd os=-udi ;; ultra3) basic_machine=a29k-nyu os=-sym1 ;; v810 | necv810) basic_machine=v810-nec os=-none ;; vaxv) basic_machine=vax-dec os=-sysv ;; vms) basic_machine=vax-dec os=-vms ;; vpp*|vx|vx-*) basic_machine=f301-fujitsu ;; vxworks960) basic_machine=i960-wrs os=-vxworks ;; vxworks68) basic_machine=m68k-wrs os=-vxworks ;; vxworks29k) basic_machine=a29k-wrs os=-vxworks ;; w65*) basic_machine=w65-wdc os=-none ;; w89k-*) basic_machine=hppa1.1-winbond os=-proelf ;; x64) basic_machine=x86_64-pc ;; xbox) basic_machine=i686-pc os=-mingw32 ;; xps | xps100) basic_machine=xps100-honeywell ;; xscale-* | xscalee[bl]-*) basic_machine=`echo "$basic_machine" | sed 's/^xscale/arm/'` ;; ymp) basic_machine=ymp-cray os=-unicos ;; none) basic_machine=none-none os=-none ;; # Here we handle the default manufacturer of certain CPU types. It is in # some cases the only manufacturer, in others, it is the most popular. w89k) basic_machine=hppa1.1-winbond ;; op50n) basic_machine=hppa1.1-oki ;; op60c) basic_machine=hppa1.1-oki ;; romp) basic_machine=romp-ibm ;; mmix) basic_machine=mmix-knuth ;; rs6000) basic_machine=rs6000-ibm ;; vax) basic_machine=vax-dec ;; pdp11) basic_machine=pdp11-dec ;; we32k) basic_machine=we32k-att ;; sh[1234] | sh[24]a | sh[24]aeb | sh[34]eb | sh[1234]le | sh[23]ele) basic_machine=sh-unknown ;; cydra) basic_machine=cydra-cydrome ;; orion) basic_machine=orion-highlevel ;; orion105) basic_machine=clipper-highlevel ;; mac | mpw | mac-mpw) basic_machine=m68k-apple ;; pmac | pmac-mpw) basic_machine=powerpc-apple ;; *-unknown) # Make sure to match an already-canonicalized machine name. ;; *) echo Invalid configuration \`"$1"\': machine \`"$basic_machine"\' not recognized 1>&2 exit 1 ;; esac # Here we canonicalize certain aliases for manufacturers. case $basic_machine in *-digital*) basic_machine=`echo "$basic_machine" | sed 's/digital.*/dec/'` ;; *-commodore*) basic_machine=`echo "$basic_machine" | sed 's/commodore.*/cbm/'` ;; *) ;; esac # Decode manufacturer-specific aliases for certain operating systems. if [ x"$os" != x"" ] then case $os in # First match some system type aliases that might get confused # with valid system types. # -solaris* is a basic system type, with this one exception. -auroraux) os=-auroraux ;; -solaris1 | -solaris1.*) os=`echo $os | sed -e 's|solaris1|sunos4|'` ;; -solaris) os=-solaris2 ;; -unixware*) os=-sysv4.2uw ;; -gnu/linux*) os=`echo $os | sed -e 's|gnu/linux|linux-gnu|'` ;; # es1800 is here to avoid being matched by es* (a different OS) -es1800*) os=-ose ;; # Now accept the basic system types. # The portable systems comes first. # Each alternative MUST end in a * to match a version number. # -sysv* is not here because it comes later, after sysvr4. -gnu* | -bsd* | -mach* | -minix* | -genix* | -ultrix* | -irix* \ | -*vms* | -sco* | -esix* | -isc* | -aix* | -cnk* | -sunos | -sunos[34]*\ | -hpux* | -unos* | -osf* | -luna* | -dgux* | -auroraux* | -solaris* \ | -sym* | -kopensolaris* | -plan9* \ | -amigaos* | -amigados* | -msdos* | -newsos* | -unicos* | -aof* \ | -aos* | -aros* | -cloudabi* | -sortix* \ | -nindy* | -vxsim* | -vxworks* | -ebmon* | -hms* | -mvs* \ | -clix* | -riscos* | -uniplus* | -iris* | -rtu* | -xenix* \ | -hiux* | -knetbsd* | -mirbsd* | -netbsd* \ | -bitrig* | -openbsd* | -solidbsd* | -libertybsd* \ | -ekkobsd* | -kfreebsd* | -freebsd* | -riscix* | -lynxos* \ | -bosx* | -nextstep* | -cxux* | -aout* | -elf* | -oabi* \ | -ptx* | -coff* | -ecoff* | -winnt* | -domain* | -vsta* \ | -udi* | -eabi* | -lites* | -ieee* | -go32* | -aux* \ | -chorusos* | -chorusrdb* | -cegcc* | -glidix* \ | -cygwin* | -msys* | -pe* | -psos* | -moss* | -proelf* | -rtems* \ | -midipix* | -mingw32* | -mingw64* | -linux-gnu* | -linux-android* \ | -linux-newlib* | -linux-musl* | -linux-uclibc* \ | -uxpv* | -beos* | -mpeix* | -udk* | -moxiebox* \ | -interix* | -uwin* | -mks* | -rhapsody* | -darwin* \ | -openstep* | -oskit* | -conix* | -pw32* | -nonstopux* \ | -storm-chaos* | -tops10* | -tenex* | -tops20* | -its* \ | -os2* | -vos* | -palmos* | -uclinux* | -nucleus* \ | -morphos* | -superux* | -rtmk* | -windiss* \ | -powermax* | -dnix* | -nx6 | -nx7 | -sei* | -dragonfly* \ | -skyos* | -haiku* | -rdos* | -toppers* | -drops* | -es* \ | -onefs* | -tirtos* | -phoenix* | -fuchsia* | -redox* | -bme* \ | -midnightbsd*) # Remember, each alternative MUST END IN *, to match a version number. ;; -qnx*) case $basic_machine in x86-* | i*86-*) ;; *) os=-nto$os ;; esac ;; -nto-qnx*) ;; -nto*) os=`echo $os | sed -e 's|nto|nto-qnx|'` ;; -sim | -xray | -os68k* | -v88r* \ | -windows* | -osx | -abug | -netware* | -os9* \ | -macos* | -mpw* | -magic* | -mmixware* | -mon960* | -lnews*) ;; -mac*) os=`echo "$os" | sed -e 's|mac|macos|'` ;; -linux-dietlibc) os=-linux-dietlibc ;; -linux*) os=`echo $os | sed -e 's|linux|linux-gnu|'` ;; -sunos5*) os=`echo "$os" | sed -e 's|sunos5|solaris2|'` ;; -sunos6*) os=`echo "$os" | sed -e 's|sunos6|solaris3|'` ;; -opened*) os=-openedition ;; -os400*) os=-os400 ;; -wince*) os=-wince ;; -utek*) os=-bsd ;; -dynix*) os=-bsd ;; -acis*) os=-aos ;; -atheos*) os=-atheos ;; -syllable*) os=-syllable ;; -386bsd) os=-bsd ;; -ctix* | -uts*) os=-sysv ;; -nova*) os=-rtmk-nova ;; -ns2) os=-nextstep2 ;; -nsk*) os=-nsk ;; # Preserve the version number of sinix5. -sinix5.*) os=`echo $os | sed -e 's|sinix|sysv|'` ;; -sinix*) os=-sysv4 ;; -tpf*) os=-tpf ;; -triton*) os=-sysv3 ;; -oss*) os=-sysv3 ;; -svr4*) os=-sysv4 ;; -svr3) os=-sysv3 ;; -sysvr4) os=-sysv4 ;; # This must come after -sysvr4. -sysv*) ;; -ose*) os=-ose ;; -*mint | -mint[0-9]* | -*MiNT | -MiNT[0-9]*) os=-mint ;; -zvmoe) os=-zvmoe ;; -dicos*) os=-dicos ;; -pikeos*) # Until real need of OS specific support for # particular features comes up, bare metal # configurations are quite functional. case $basic_machine in arm*) os=-eabi ;; *) os=-elf ;; esac ;; -nacl*) ;; -ios) ;; -none) ;; *) # Get rid of the `-' at the beginning of $os. os=`echo $os | sed 's/[^-]*-//'` echo Invalid configuration \`"$1"\': system \`"$os"\' not recognized 1>&2 exit 1 ;; esac else # Here we handle the default operating systems that come with various machines. # The value should be what the vendor currently ships out the door with their # machine or put another way, the most popular os provided with the machine. # Note that if you're going to try to match "-MANUFACTURER" here (say, # "-sun"), then you have to tell the case statement up towards the top # that MANUFACTURER isn't an operating system. Otherwise, code above # will signal an error saying that MANUFACTURER isn't an operating # system, and we'll never get to this point. case $basic_machine in score-*) os=-elf ;; spu-*) os=-elf ;; *-acorn) os=-riscix1.2 ;; arm*-rebel) os=-linux ;; arm*-semi) os=-aout ;; c4x-* | tic4x-*) os=-coff ;; c8051-*) os=-elf ;; hexagon-*) os=-elf ;; tic54x-*) os=-coff ;; tic55x-*) os=-coff ;; tic6x-*) os=-coff ;; # This must come before the *-dec entry. pdp10-*) os=-tops20 ;; pdp11-*) os=-none ;; *-dec | vax-*) os=-ultrix4.2 ;; m68*-apollo) os=-domain ;; i386-sun) os=-sunos4.0.2 ;; m68000-sun) os=-sunos3 ;; m68*-cisco) os=-aout ;; mep-*) os=-elf ;; mips*-cisco) os=-elf ;; mips*-*) os=-elf ;; or32-*) os=-coff ;; *-tti) # must be before sparc entry or we get the wrong os. os=-sysv3 ;; sparc-* | *-sun) os=-sunos4.1.1 ;; pru-*) os=-elf ;; *-be) os=-beos ;; *-ibm) os=-aix ;; *-knuth) os=-mmixware ;; *-wec) os=-proelf ;; *-winbond) os=-proelf ;; *-oki) os=-proelf ;; *-hp) os=-hpux ;; *-hitachi) os=-hiux ;; i860-* | *-att | *-ncr | *-altos | *-motorola | *-convergent) os=-sysv ;; *-cbm) os=-amigaos ;; *-dg) os=-dgux ;; *-dolphin) os=-sysv3 ;; m68k-ccur) os=-rtu ;; m88k-omron*) os=-luna ;; *-next) os=-nextstep ;; *-sequent) os=-ptx ;; *-crds) os=-unos ;; *-ns) os=-genix ;; i370-*) os=-mvs ;; *-gould) os=-sysv ;; *-highlevel) os=-bsd ;; *-encore) os=-bsd ;; *-sgi) os=-irix ;; *-siemens) os=-sysv4 ;; *-masscomp) os=-rtu ;; f30[01]-fujitsu | f700-fujitsu) os=-uxpv ;; *-rom68k) os=-coff ;; *-*bug) os=-coff ;; *-apple) os=-macos ;; *-atari*) os=-mint ;; *) os=-none ;; esac fi # Here we handle the case where we know the os, and the CPU type, but not the # manufacturer. We pick the logical manufacturer. vendor=unknown case $basic_machine in *-unknown) case $os in -riscix*) vendor=acorn ;; -sunos*) vendor=sun ;; -cnk*|-aix*) vendor=ibm ;; -beos*) vendor=be ;; -hpux*) vendor=hp ;; -mpeix*) vendor=hp ;; -hiux*) vendor=hitachi ;; -unos*) vendor=crds ;; -dgux*) vendor=dg ;; -luna*) vendor=omron ;; -genix*) vendor=ns ;; -mvs* | -opened*) vendor=ibm ;; -os400*) vendor=ibm ;; -ptx*) vendor=sequent ;; -tpf*) vendor=ibm ;; -vxsim* | -vxworks* | -windiss*) vendor=wrs ;; -aux*) vendor=apple ;; -hms*) vendor=hitachi ;; -mpw* | -macos*) vendor=apple ;; -*mint | -mint[0-9]* | -*MiNT | -MiNT[0-9]*) vendor=atari ;; -vos*) vendor=stratus ;; esac basic_machine=`echo "$basic_machine" | sed "s/unknown/$vendor/"` ;; esac echo "$basic_machine$os" exit # Local variables: # eval: (add-hook 'write-file-functions 'time-stamp) # time-stamp-start: "timestamp='" # time-stamp-format: "%:y-%02m-%02d" # time-stamp-end: "'" # End: gtkada-24.0.0/configure000077500000000000000000004762241446021174000147550ustar00rootroot00000000000000#! /bin/sh # Guess values for system-dependent variables and create Makefiles. # Generated by GNU Autoconf 2.69 for gtkada 18.0w. # # Report bugs to . # # # Copyright (C) 1992-1996, 1998-2012 Free Software Foundation, Inc. # # # This configure script is free software; the Free Software Foundation # gives unlimited permission to copy, distribute and modify it. ## -------------------- ## ## M4sh Initialization. ## ## -------------------- ## # Be more Bourne compatible DUALCASE=1; export DUALCASE # for MKS sh if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then : emulate sh NULLCMD=: # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which # is contrary to our usage. Disable this feature. alias -g '${1+"$@"}'='"$@"' setopt NO_GLOB_SUBST else case `(set -o) 2>/dev/null` in #( *posix*) : set -o posix ;; #( *) : ;; esac fi as_nl=' ' export as_nl # Printing a long string crashes Solaris 7 /usr/bin/printf. as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo # Prefer a ksh shell builtin over an external printf program on Solaris, # but without wasting forks for bash or zsh. if test -z "$BASH_VERSION$ZSH_VERSION" \ && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then as_echo='print -r --' as_echo_n='print -rn --' elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then as_echo='printf %s\n' as_echo_n='printf %s' else if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"' as_echo_n='/usr/ucb/echo -n' else as_echo_body='eval expr "X$1" : "X\\(.*\\)"' as_echo_n_body='eval arg=$1; case $arg in #( *"$as_nl"*) expr "X$arg" : "X\\(.*\\)$as_nl"; arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;; esac; expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl" ' export as_echo_n_body as_echo_n='sh -c $as_echo_n_body as_echo' fi export as_echo_body as_echo='sh -c $as_echo_body as_echo' fi # The user is always right. if test "${PATH_SEPARATOR+set}" != set; then PATH_SEPARATOR=: (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && { (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 || PATH_SEPARATOR=';' } fi # IFS # We need space, tab and new line, in precisely that order. Quoting is # there to prevent editors from complaining about space-tab. # (If _AS_PATH_WALK were called with IFS unset, it would disable word # splitting by setting IFS to empty value.) IFS=" "" $as_nl" # Find who we are. Look in the path if we contain no directory separator. as_myself= case $0 in #(( *[\\/]* ) as_myself=$0 ;; *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break done IFS=$as_save_IFS ;; esac # We did not find ourselves, most probably we were run as `sh COMMAND' # in which case we are not to be found in the path. if test "x$as_myself" = x; then as_myself=$0 fi if test ! -f "$as_myself"; then $as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2 exit 1 fi # Unset variables that we do not need and which cause bugs (e.g. in # pre-3.0 UWIN ksh). But do not cause bugs in bash 2.01; the "|| exit 1" # suppresses any "Segmentation fault" message there. '((' could # trigger a bug in pdksh 5.2.14. for as_var in BASH_ENV ENV MAIL MAILPATH do eval test x\${$as_var+set} = xset \ && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || : done PS1='$ ' PS2='> ' PS4='+ ' # NLS nuisances. LC_ALL=C export LC_ALL LANGUAGE=C export LANGUAGE # CDPATH. (unset CDPATH) >/dev/null 2>&1 && unset CDPATH # Use a proper internal environment variable to ensure we don't fall # into an infinite loop, continuously re-executing ourselves. if test x"${_as_can_reexec}" != xno && test "x$CONFIG_SHELL" != x; then _as_can_reexec=no; export _as_can_reexec; # We cannot yet assume a decent shell, so we have to provide a # neutralization value for shells without unset; and this also # works around shells that cannot unset nonexistent variables. # Preserve -v and -x to the replacement shell. BASH_ENV=/dev/null ENV=/dev/null (unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV case $- in # (((( *v*x* | *x*v* ) as_opts=-vx ;; *v* ) as_opts=-v ;; *x* ) as_opts=-x ;; * ) as_opts= ;; esac exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"} # Admittedly, this is quite paranoid, since all the known shells bail # out after a failed `exec'. $as_echo "$0: could not re-execute with $CONFIG_SHELL" >&2 as_fn_exit 255 fi # We don't want this to propagate to other subprocesses. { _as_can_reexec=; unset _as_can_reexec;} if test "x$CONFIG_SHELL" = x; then as_bourne_compatible="if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then : emulate sh NULLCMD=: # Pre-4.2 versions of Zsh do word splitting on \${1+\"\$@\"}, which # is contrary to our usage. Disable this feature. alias -g '\${1+\"\$@\"}'='\"\$@\"' setopt NO_GLOB_SUBST else case \`(set -o) 2>/dev/null\` in #( *posix*) : set -o posix ;; #( *) : ;; esac fi " as_required="as_fn_return () { (exit \$1); } as_fn_success () { as_fn_return 0; } as_fn_failure () { as_fn_return 1; } as_fn_ret_success () { return 0; } as_fn_ret_failure () { return 1; } exitcode=0 as_fn_success || { exitcode=1; echo as_fn_success failed.; } as_fn_failure && { exitcode=1; echo as_fn_failure succeeded.; } as_fn_ret_success || { exitcode=1; echo as_fn_ret_success failed.; } as_fn_ret_failure && { exitcode=1; echo as_fn_ret_failure succeeded.; } if ( set x; as_fn_ret_success y && test x = \"\$1\" ); then : else exitcode=1; echo positional parameters were not saved. fi test x\$exitcode = x0 || exit 1 test -x / || exit 1" as_suggested=" as_lineno_1=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_1a=\$LINENO as_lineno_2=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_2a=\$LINENO eval 'test \"x\$as_lineno_1'\$as_run'\" != \"x\$as_lineno_2'\$as_run'\" && test \"x\`expr \$as_lineno_1'\$as_run' + 1\`\" = \"x\$as_lineno_2'\$as_run'\"' || exit 1" if (eval "$as_required") 2>/dev/null; then : as_have_required=yes else as_have_required=no fi if test x$as_have_required = xyes && (eval "$as_suggested") 2>/dev/null; then : else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR as_found=false for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. as_found=: case $as_dir in #( /*) for as_base in sh bash ksh sh5; do # Try only shells that exist, to save several forks. as_shell=$as_dir/$as_base if { test -f "$as_shell" || test -f "$as_shell.exe"; } && { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$as_shell"; } 2>/dev/null; then : CONFIG_SHELL=$as_shell as_have_required=yes if { $as_echo "$as_bourne_compatible""$as_suggested" | as_run=a "$as_shell"; } 2>/dev/null; then : break 2 fi fi done;; esac as_found=false done $as_found || { if { test -f "$SHELL" || test -f "$SHELL.exe"; } && { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$SHELL"; } 2>/dev/null; then : CONFIG_SHELL=$SHELL as_have_required=yes fi; } IFS=$as_save_IFS if test "x$CONFIG_SHELL" != x; then : export CONFIG_SHELL # We cannot yet assume a decent shell, so we have to provide a # neutralization value for shells without unset; and this also # works around shells that cannot unset nonexistent variables. # Preserve -v and -x to the replacement shell. BASH_ENV=/dev/null ENV=/dev/null (unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV case $- in # (((( *v*x* | *x*v* ) as_opts=-vx ;; *v* ) as_opts=-v ;; *x* ) as_opts=-x ;; * ) as_opts= ;; esac exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"} # Admittedly, this is quite paranoid, since all the known shells bail # out after a failed `exec'. $as_echo "$0: could not re-execute with $CONFIG_SHELL" >&2 exit 255 fi if test x$as_have_required = xno; then : $as_echo "$0: This script requires a shell more modern than all" $as_echo "$0: the shells that I found on your system." if test x${ZSH_VERSION+set} = xset ; then $as_echo "$0: In particular, zsh $ZSH_VERSION has bugs and should" $as_echo "$0: be upgraded to zsh 4.3.4 or later." else $as_echo "$0: Please tell bug-autoconf@gnu.org and report@adacore.com $0: about your system, including any error possibly output $0: before this message. Then install a modern shell, or $0: manually run the script under such a shell if you do $0: have one." fi exit 1 fi fi fi SHELL=${CONFIG_SHELL-/bin/sh} export SHELL # Unset more variables known to interfere with behavior of common tools. CLICOLOR_FORCE= GREP_OPTIONS= unset CLICOLOR_FORCE GREP_OPTIONS ## --------------------- ## ## M4sh Shell Functions. ## ## --------------------- ## # as_fn_unset VAR # --------------- # Portably unset VAR. as_fn_unset () { { eval $1=; unset $1;} } as_unset=as_fn_unset # as_fn_set_status STATUS # ----------------------- # Set $? to STATUS, without forking. as_fn_set_status () { return $1 } # as_fn_set_status # as_fn_exit STATUS # ----------------- # Exit the shell with STATUS, even in a "trap 0" or "set -e" context. as_fn_exit () { set +e as_fn_set_status $1 exit $1 } # as_fn_exit # as_fn_mkdir_p # ------------- # Create "$as_dir" as a directory, including parents if necessary. as_fn_mkdir_p () { case $as_dir in #( -*) as_dir=./$as_dir;; esac test -d "$as_dir" || eval $as_mkdir_p || { as_dirs= while :; do case $as_dir in #( *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'( *) as_qdir=$as_dir;; esac as_dirs="'$as_qdir' $as_dirs" as_dir=`$as_dirname -- "$as_dir" || $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ X"$as_dir" : 'X\(//\)[^/]' \| \ X"$as_dir" : 'X\(//\)$' \| \ X"$as_dir" : 'X\(/\)' \| . 2>/dev/null || $as_echo X"$as_dir" | sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/ q } /^X\(\/\/\)[^/].*/{ s//\1/ q } /^X\(\/\/\)$/{ s//\1/ q } /^X\(\/\).*/{ s//\1/ q } s/.*/./; q'` test -d "$as_dir" && break done test -z "$as_dirs" || eval "mkdir $as_dirs" } || test -d "$as_dir" || as_fn_error $? "cannot create directory $as_dir" } # as_fn_mkdir_p # as_fn_executable_p FILE # ----------------------- # Test if FILE is an executable regular file. as_fn_executable_p () { test -f "$1" && test -x "$1" } # as_fn_executable_p # as_fn_append VAR VALUE # ---------------------- # Append the text in VALUE to the end of the definition contained in VAR. Take # advantage of any shell optimizations that allow amortized linear growth over # repeated appends, instead of the typical quadratic growth present in naive # implementations. if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then : eval 'as_fn_append () { eval $1+=\$2 }' else as_fn_append () { eval $1=\$$1\$2 } fi # as_fn_append # as_fn_arith ARG... # ------------------ # Perform arithmetic evaluation on the ARGs, and store the result in the # global $as_val. Take advantage of shells that can avoid forks. The arguments # must be portable across $(()) and expr. if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then : eval 'as_fn_arith () { as_val=$(( $* )) }' else as_fn_arith () { as_val=`expr "$@" || test $? -eq 1` } fi # as_fn_arith # as_fn_error STATUS ERROR [LINENO LOG_FD] # ---------------------------------------- # Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are # provided, also output the error to LOG_FD, referencing LINENO. Then exit the # script with STATUS, using 1 if that was 0. as_fn_error () { as_status=$1; test $as_status -eq 0 && as_status=1 if test "$4"; then as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack $as_echo "$as_me:${as_lineno-$LINENO}: error: $2" >&$4 fi $as_echo "$as_me: error: $2" >&2 as_fn_exit $as_status } # as_fn_error if expr a : '\(a\)' >/dev/null 2>&1 && test "X`expr 00001 : '.*\(...\)'`" = X001; then as_expr=expr else as_expr=false fi if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then as_basename=basename else as_basename=false fi if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then as_dirname=dirname else as_dirname=false fi as_me=`$as_basename -- "$0" || $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \ X"$0" : 'X\(//\)$' \| \ X"$0" : 'X\(/\)' \| . 2>/dev/null || $as_echo X/"$0" | sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/ q } /^X\/\(\/\/\)$/{ s//\1/ q } /^X\/\(\/\).*/{ s//\1/ q } s/.*/./; q'` # Avoid depending upon Character Ranges. as_cr_letters='abcdefghijklmnopqrstuvwxyz' as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ' as_cr_Letters=$as_cr_letters$as_cr_LETTERS as_cr_digits='0123456789' as_cr_alnum=$as_cr_Letters$as_cr_digits as_lineno_1=$LINENO as_lineno_1a=$LINENO as_lineno_2=$LINENO as_lineno_2a=$LINENO eval 'test "x$as_lineno_1'$as_run'" != "x$as_lineno_2'$as_run'" && test "x`expr $as_lineno_1'$as_run' + 1`" = "x$as_lineno_2'$as_run'"' || { # Blame Lee E. McMahon (1931-1989) for sed's syntax. :-) sed -n ' p /[$]LINENO/= ' <$as_myself | sed ' s/[$]LINENO.*/&-/ t lineno b :lineno N :loop s/[$]LINENO\([^'$as_cr_alnum'_].*\n\)\(.*\)/\2\1\2/ t loop s/-\n.*// ' >$as_me.lineno && chmod +x "$as_me.lineno" || { $as_echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2; as_fn_exit 1; } # If we had to re-execute with $CONFIG_SHELL, we're ensured to have # already done that, so ensure we don't try to do so again and fall # in an infinite loop. This has already happened in practice. _as_can_reexec=no; export _as_can_reexec # Don't try to exec as it changes $[0], causing all sort of problems # (the dirname of $[0] is not the place where we might find the # original and so on. Autoconf is especially sensitive to this). . "./$as_me.lineno" # Exit status is that of the last command. exit } ECHO_C= ECHO_N= ECHO_T= case `echo -n x` in #((((( -n*) case `echo 'xy\c'` in *c*) ECHO_T=' ';; # ECHO_T is single tab character. xy) ECHO_C='\c';; *) echo `echo ksh88 bug on AIX 6.1` > /dev/null ECHO_T=' ';; esac;; *) ECHO_N='-n';; esac rm -f conf$$ conf$$.exe conf$$.file if test -d conf$$.dir; then rm -f conf$$.dir/conf$$.file else rm -f conf$$.dir mkdir conf$$.dir 2>/dev/null fi if (echo >conf$$.file) 2>/dev/null; then if ln -s conf$$.file conf$$ 2>/dev/null; then as_ln_s='ln -s' # ... but there are two gotchas: # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail. # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable. # In both cases, we have to default to `cp -pR'. ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe || as_ln_s='cp -pR' elif ln conf$$.file conf$$ 2>/dev/null; then as_ln_s=ln else as_ln_s='cp -pR' fi else as_ln_s='cp -pR' fi rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file rmdir conf$$.dir 2>/dev/null if mkdir -p . 2>/dev/null; then as_mkdir_p='mkdir -p "$as_dir"' else test -d ./-p && rmdir ./-p as_mkdir_p=false fi as_test_x='test -x' as_executable_p=as_fn_executable_p # Sed expression to map a string onto a valid CPP name. as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'" # Sed expression to map a string onto a valid variable name. as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'" test -n "$DJDIR" || exec 7<&0 &1 # Name of the host. # hostname on some systems (SVR3.2, old GNU/Linux) returns a bogus exit status, # so uname gets run too. ac_hostname=`(hostname || uname -n) 2>/dev/null | sed 1q` # # Initializations. # ac_default_prefix=/usr/local ac_clean_files= ac_config_libobj_dir=. LIBOBJS= cross_compiling=no subdirs= MFLAGS= MAKEFLAGS= # Identity of this package. PACKAGE_NAME='gtkada' PACKAGE_TARNAME='gtkada' PACKAGE_VERSION='18.0w' PACKAGE_STRING='gtkada 18.0w' PACKAGE_BUGREPORT='report@adacore.com' PACKAGE_URL='' ac_subst_vars='LTLIBOBJS LIBOBJS GTK_LIBS_GPR FONTCONFIG_LIBS FONTCONFIG_CFLAGS GMODULE_LIBS GMODULE_CFLAGS GTK_CFLAGS_GPR GTK_PREFIX GTK_LIBS GTK_CFLAGS HAVE_GETTEXT GETTEXT_INTL USE_NLS BUILD_TYPE GPRINSTALL GPRBUILD ac_ct_OBJC OBJCFLAGS OBJC OBJEXT EXEEXT ac_ct_CC CPPFLAGS LDFLAGS CFLAGS CC NEED_OBJECTIVE_C TARGET_LFLAGS SO_OPTS SO_EXT BUILD_SHARED BUILD_STATIC_PIC BUILD_STATIC OS_SPECIFIC_LINK_OPTIONS DEFAULT_LIBRARY_TYPE TARGET PKG_CONFIG_LIBDIR PKG_CONFIG_PATH PKG_CONFIG target_os target_vendor target_cpu target host_os host_vendor host_cpu host build_os build_vendor build_cpu build target_alias host_alias build_alias LIBS ECHO_T ECHO_N ECHO_C DEFS mandir localedir libdir psdir pdfdir dvidir htmldir infodir docdir oldincludedir includedir runstatedir localstatedir sharedstatedir sysconfdir datadir datarootdir libexecdir sbindir bindir program_transform_name prefix exec_prefix PACKAGE_URL PACKAGE_BUGREPORT PACKAGE_STRING PACKAGE_VERSION PACKAGE_TARNAME PACKAGE_NAME PATH_SEPARATOR SHELL' ac_subst_files='' ac_user_opts=' enable_option_checking enable_static enable_static_pic enable_shared enable_build enable_nls enable_gtktest ' ac_precious_vars='build_alias host_alias target_alias PKG_CONFIG PKG_CONFIG_PATH PKG_CONFIG_LIBDIR CC CFLAGS LDFLAGS LIBS CPPFLAGS OBJC OBJCFLAGS GTK_CFLAGS GTK_LIBS GMODULE_CFLAGS GMODULE_LIBS FONTCONFIG_CFLAGS FONTCONFIG_LIBS' # Initialize some variables set by options. ac_init_help= ac_init_version=false ac_unrecognized_opts= ac_unrecognized_sep= # The variables have the same names as the options, with # dashes changed to underlines. cache_file=/dev/null exec_prefix=NONE no_create= no_recursion= prefix=NONE program_prefix=NONE program_suffix=NONE program_transform_name=s,x,x, silent= site= srcdir= verbose= x_includes=NONE x_libraries=NONE # Installation directory options. # These are left unexpanded so users can "make install exec_prefix=/foo" # and all the variables that are supposed to be based on exec_prefix # by default will actually change. # Use braces instead of parens because sh, perl, etc. also accept them. # (The list follows the same order as the GNU Coding Standards.) bindir='${exec_prefix}/bin' sbindir='${exec_prefix}/sbin' libexecdir='${exec_prefix}/libexec' datarootdir='${prefix}/share' datadir='${datarootdir}' sysconfdir='${prefix}/etc' sharedstatedir='${prefix}/com' localstatedir='${prefix}/var' runstatedir='${localstatedir}/run' includedir='${prefix}/include' oldincludedir='/usr/include' docdir='${datarootdir}/doc/${PACKAGE_TARNAME}' infodir='${datarootdir}/info' htmldir='${docdir}' dvidir='${docdir}' pdfdir='${docdir}' psdir='${docdir}' libdir='${exec_prefix}/lib' localedir='${datarootdir}/locale' mandir='${datarootdir}/man' ac_prev= ac_dashdash= for ac_option do # If the previous option needs an argument, assign it. if test -n "$ac_prev"; then eval $ac_prev=\$ac_option ac_prev= continue fi case $ac_option in *=?*) ac_optarg=`expr "X$ac_option" : '[^=]*=\(.*\)'` ;; *=) ac_optarg= ;; *) ac_optarg=yes ;; esac # Accept the important Cygnus configure options, so we can diagnose typos. case $ac_dashdash$ac_option in --) ac_dashdash=yes ;; -bindir | --bindir | --bindi | --bind | --bin | --bi) ac_prev=bindir ;; -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*) bindir=$ac_optarg ;; -build | --build | --buil | --bui | --bu) ac_prev=build_alias ;; -build=* | --build=* | --buil=* | --bui=* | --bu=*) build_alias=$ac_optarg ;; -cache-file | --cache-file | --cache-fil | --cache-fi \ | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c) ac_prev=cache_file ;; -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \ | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*) cache_file=$ac_optarg ;; --config-cache | -C) cache_file=config.cache ;; -datadir | --datadir | --datadi | --datad) ac_prev=datadir ;; -datadir=* | --datadir=* | --datadi=* | --datad=*) datadir=$ac_optarg ;; -datarootdir | --datarootdir | --datarootdi | --datarootd | --dataroot \ | --dataroo | --dataro | --datar) ac_prev=datarootdir ;; -datarootdir=* | --datarootdir=* | --datarootdi=* | --datarootd=* \ | --dataroot=* | --dataroo=* | --dataro=* | --datar=*) datarootdir=$ac_optarg ;; -disable-* | --disable-*) ac_useropt=`expr "x$ac_option" : 'x-*disable-\(.*\)'` # Reject names that are not valid shell variable names. expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null && as_fn_error $? "invalid feature name: $ac_useropt" ac_useropt_orig=$ac_useropt ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'` case $ac_user_opts in *" "enable_$ac_useropt" "*) ;; *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--disable-$ac_useropt_orig" ac_unrecognized_sep=', ';; esac eval enable_$ac_useropt=no ;; -docdir | --docdir | --docdi | --doc | --do) ac_prev=docdir ;; -docdir=* | --docdir=* | --docdi=* | --doc=* | --do=*) docdir=$ac_optarg ;; -dvidir | --dvidir | --dvidi | --dvid | --dvi | --dv) ac_prev=dvidir ;; -dvidir=* | --dvidir=* | --dvidi=* | --dvid=* | --dvi=* | --dv=*) dvidir=$ac_optarg ;; -enable-* | --enable-*) ac_useropt=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'` # Reject names that are not valid shell variable names. expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null && as_fn_error $? "invalid feature name: $ac_useropt" ac_useropt_orig=$ac_useropt ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'` case $ac_user_opts in *" "enable_$ac_useropt" "*) ;; *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--enable-$ac_useropt_orig" ac_unrecognized_sep=', ';; esac eval enable_$ac_useropt=\$ac_optarg ;; -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \ | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \ | --exec | --exe | --ex) ac_prev=exec_prefix ;; -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \ | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \ | --exec=* | --exe=* | --ex=*) exec_prefix=$ac_optarg ;; -gas | --gas | --ga | --g) # Obsolete; use --with-gas. with_gas=yes ;; -help | --help | --hel | --he | -h) ac_init_help=long ;; -help=r* | --help=r* | --hel=r* | --he=r* | -hr*) ac_init_help=recursive ;; -help=s* | --help=s* | --hel=s* | --he=s* | -hs*) ac_init_help=short ;; -host | --host | --hos | --ho) ac_prev=host_alias ;; -host=* | --host=* | --hos=* | --ho=*) host_alias=$ac_optarg ;; -htmldir | --htmldir | --htmldi | --htmld | --html | --htm | --ht) ac_prev=htmldir ;; -htmldir=* | --htmldir=* | --htmldi=* | --htmld=* | --html=* | --htm=* \ | --ht=*) htmldir=$ac_optarg ;; -includedir | --includedir | --includedi | --included | --include \ | --includ | --inclu | --incl | --inc) ac_prev=includedir ;; -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \ | --includ=* | --inclu=* | --incl=* | --inc=*) includedir=$ac_optarg ;; -infodir | --infodir | --infodi | --infod | --info | --inf) ac_prev=infodir ;; -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*) infodir=$ac_optarg ;; -libdir | --libdir | --libdi | --libd) ac_prev=libdir ;; -libdir=* | --libdir=* | --libdi=* | --libd=*) libdir=$ac_optarg ;; -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \ | --libexe | --libex | --libe) ac_prev=libexecdir ;; -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \ | --libexe=* | --libex=* | --libe=*) libexecdir=$ac_optarg ;; -localedir | --localedir | --localedi | --localed | --locale) ac_prev=localedir ;; -localedir=* | --localedir=* | --localedi=* | --localed=* | --locale=*) localedir=$ac_optarg ;; -localstatedir | --localstatedir | --localstatedi | --localstated \ | --localstate | --localstat | --localsta | --localst | --locals) ac_prev=localstatedir ;; -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \ | --localstate=* | --localstat=* | --localsta=* | --localst=* | --locals=*) localstatedir=$ac_optarg ;; -mandir | --mandir | --mandi | --mand | --man | --ma | --m) ac_prev=mandir ;; -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*) mandir=$ac_optarg ;; -nfp | --nfp | --nf) # Obsolete; use --without-fp. with_fp=no ;; -no-create | --no-create | --no-creat | --no-crea | --no-cre \ | --no-cr | --no-c | -n) no_create=yes ;; -no-recursion | --no-recursion | --no-recursio | --no-recursi \ | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r) no_recursion=yes ;; -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \ | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \ | --oldin | --oldi | --old | --ol | --o) ac_prev=oldincludedir ;; -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \ | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \ | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*) oldincludedir=$ac_optarg ;; -prefix | --prefix | --prefi | --pref | --pre | --pr | --p) ac_prev=prefix ;; -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*) prefix=$ac_optarg ;; -program-prefix | --program-prefix | --program-prefi | --program-pref \ | --program-pre | --program-pr | --program-p) ac_prev=program_prefix ;; -program-prefix=* | --program-prefix=* | --program-prefi=* \ | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*) program_prefix=$ac_optarg ;; -program-suffix | --program-suffix | --program-suffi | --program-suff \ | --program-suf | --program-su | --program-s) ac_prev=program_suffix ;; -program-suffix=* | --program-suffix=* | --program-suffi=* \ | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*) program_suffix=$ac_optarg ;; -program-transform-name | --program-transform-name \ | --program-transform-nam | --program-transform-na \ | --program-transform-n | --program-transform- \ | --program-transform | --program-transfor \ | --program-transfo | --program-transf \ | --program-trans | --program-tran \ | --progr-tra | --program-tr | --program-t) ac_prev=program_transform_name ;; -program-transform-name=* | --program-transform-name=* \ | --program-transform-nam=* | --program-transform-na=* \ | --program-transform-n=* | --program-transform-=* \ | --program-transform=* | --program-transfor=* \ | --program-transfo=* | --program-transf=* \ | --program-trans=* | --program-tran=* \ | --progr-tra=* | --program-tr=* | --program-t=*) program_transform_name=$ac_optarg ;; -pdfdir | --pdfdir | --pdfdi | --pdfd | --pdf | --pd) ac_prev=pdfdir ;; -pdfdir=* | --pdfdir=* | --pdfdi=* | --pdfd=* | --pdf=* | --pd=*) pdfdir=$ac_optarg ;; -psdir | --psdir | --psdi | --psd | --ps) ac_prev=psdir ;; -psdir=* | --psdir=* | --psdi=* | --psd=* | --ps=*) psdir=$ac_optarg ;; -q | -quiet | --quiet | --quie | --qui | --qu | --q \ | -silent | --silent | --silen | --sile | --sil) silent=yes ;; -runstatedir | --runstatedir | --runstatedi | --runstated \ | --runstate | --runstat | --runsta | --runst | --runs \ | --run | --ru | --r) ac_prev=runstatedir ;; -runstatedir=* | --runstatedir=* | --runstatedi=* | --runstated=* \ | --runstate=* | --runstat=* | --runsta=* | --runst=* | --runs=* \ | --run=* | --ru=* | --r=*) runstatedir=$ac_optarg ;; -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb) ac_prev=sbindir ;; -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \ | --sbi=* | --sb=*) sbindir=$ac_optarg ;; -sharedstatedir | --sharedstatedir | --sharedstatedi \ | --sharedstated | --sharedstate | --sharedstat | --sharedsta \ | --sharedst | --shareds | --shared | --share | --shar \ | --sha | --sh) ac_prev=sharedstatedir ;; -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \ | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \ | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \ | --sha=* | --sh=*) sharedstatedir=$ac_optarg ;; -site | --site | --sit) ac_prev=site ;; -site=* | --site=* | --sit=*) site=$ac_optarg ;; -srcdir | --srcdir | --srcdi | --srcd | --src | --sr) ac_prev=srcdir ;; -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*) srcdir=$ac_optarg ;; -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \ | --syscon | --sysco | --sysc | --sys | --sy) ac_prev=sysconfdir ;; -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \ | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*) sysconfdir=$ac_optarg ;; -target | --target | --targe | --targ | --tar | --ta | --t) ac_prev=target_alias ;; -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*) target_alias=$ac_optarg ;; -v | -verbose | --verbose | --verbos | --verbo | --verb) verbose=yes ;; -version | --version | --versio | --versi | --vers | -V) ac_init_version=: ;; -with-* | --with-*) ac_useropt=`expr "x$ac_option" : 'x-*with-\([^=]*\)'` # Reject names that are not valid shell variable names. expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null && as_fn_error $? "invalid package name: $ac_useropt" ac_useropt_orig=$ac_useropt ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'` case $ac_user_opts in *" "with_$ac_useropt" "*) ;; *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--with-$ac_useropt_orig" ac_unrecognized_sep=', ';; esac eval with_$ac_useropt=\$ac_optarg ;; -without-* | --without-*) ac_useropt=`expr "x$ac_option" : 'x-*without-\(.*\)'` # Reject names that are not valid shell variable names. expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null && as_fn_error $? "invalid package name: $ac_useropt" ac_useropt_orig=$ac_useropt ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'` case $ac_user_opts in *" "with_$ac_useropt" "*) ;; *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--without-$ac_useropt_orig" ac_unrecognized_sep=', ';; esac eval with_$ac_useropt=no ;; --x) # Obsolete; use --with-x. with_x=yes ;; -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \ | --x-incl | --x-inc | --x-in | --x-i) ac_prev=x_includes ;; -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \ | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*) x_includes=$ac_optarg ;; -x-libraries | --x-libraries | --x-librarie | --x-librari \ | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l) ac_prev=x_libraries ;; -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \ | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*) x_libraries=$ac_optarg ;; -*) as_fn_error $? "unrecognized option: \`$ac_option' Try \`$0 --help' for more information" ;; *=*) ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='` # Reject names that are not valid shell variable names. case $ac_envvar in #( '' | [0-9]* | *[!_$as_cr_alnum]* ) as_fn_error $? "invalid variable name: \`$ac_envvar'" ;; esac eval $ac_envvar=\$ac_optarg export $ac_envvar ;; *) # FIXME: should be removed in autoconf 3.0. $as_echo "$as_me: WARNING: you should use --build, --host, --target" >&2 expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null && $as_echo "$as_me: WARNING: invalid host type: $ac_option" >&2 : "${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}" ;; esac done if test -n "$ac_prev"; then ac_option=--`echo $ac_prev | sed 's/_/-/g'` as_fn_error $? "missing argument to $ac_option" fi if test -n "$ac_unrecognized_opts"; then case $enable_option_checking in no) ;; fatal) as_fn_error $? "unrecognized options: $ac_unrecognized_opts" ;; *) $as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2 ;; esac fi # Check all directory arguments for consistency. for ac_var in exec_prefix prefix bindir sbindir libexecdir datarootdir \ datadir sysconfdir sharedstatedir localstatedir includedir \ oldincludedir docdir infodir htmldir dvidir pdfdir psdir \ libdir localedir mandir runstatedir do eval ac_val=\$$ac_var # Remove trailing slashes. case $ac_val in */ ) ac_val=`expr "X$ac_val" : 'X\(.*[^/]\)' \| "X$ac_val" : 'X\(.*\)'` eval $ac_var=\$ac_val;; esac # Be sure to have absolute directory names. case $ac_val in [\\/$]* | ?:[\\/]* ) continue;; NONE | '' ) case $ac_var in *prefix ) continue;; esac;; esac as_fn_error $? "expected an absolute directory name for --$ac_var: $ac_val" done # There might be people who depend on the old broken behavior: `$host' # used to hold the argument of --host etc. # FIXME: To remove some day. build=$build_alias host=$host_alias target=$target_alias # FIXME: To remove some day. if test "x$host_alias" != x; then if test "x$build_alias" = x; then cross_compiling=maybe elif test "x$build_alias" != "x$host_alias"; then cross_compiling=yes fi fi ac_tool_prefix= test -n "$host_alias" && ac_tool_prefix=$host_alias- test "$silent" = yes && exec 6>/dev/null ac_pwd=`pwd` && test -n "$ac_pwd" && ac_ls_di=`ls -di .` && ac_pwd_ls_di=`cd "$ac_pwd" && ls -di .` || as_fn_error $? "working directory cannot be determined" test "X$ac_ls_di" = "X$ac_pwd_ls_di" || as_fn_error $? "pwd does not report name of working directory" # Find the source files, if location was not specified. if test -z "$srcdir"; then ac_srcdir_defaulted=yes # Try the directory containing this script, then the parent directory. ac_confdir=`$as_dirname -- "$as_myself" || $as_expr X"$as_myself" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ X"$as_myself" : 'X\(//\)[^/]' \| \ X"$as_myself" : 'X\(//\)$' \| \ X"$as_myself" : 'X\(/\)' \| . 2>/dev/null || $as_echo X"$as_myself" | sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/ q } /^X\(\/\/\)[^/].*/{ s//\1/ q } /^X\(\/\/\)$/{ s//\1/ q } /^X\(\/\).*/{ s//\1/ q } s/.*/./; q'` srcdir=$ac_confdir if test ! -r "$srcdir/$ac_unique_file"; then srcdir=.. fi else ac_srcdir_defaulted=no fi if test ! -r "$srcdir/$ac_unique_file"; then test "$ac_srcdir_defaulted" = yes && srcdir="$ac_confdir or .." as_fn_error $? "cannot find sources ($ac_unique_file) in $srcdir" fi ac_msg="sources are in $srcdir, but \`cd $srcdir' does not work" ac_abs_confdir=`( cd "$srcdir" && test -r "./$ac_unique_file" || as_fn_error $? "$ac_msg" pwd)` # When building in place, set srcdir=. if test "$ac_abs_confdir" = "$ac_pwd"; then srcdir=. fi # Remove unnecessary trailing slashes from srcdir. # Double slashes in file names in object file debugging info # mess up M-x gdb in Emacs. case $srcdir in */) srcdir=`expr "X$srcdir" : 'X\(.*[^/]\)' \| "X$srcdir" : 'X\(.*\)'`;; esac for ac_var in $ac_precious_vars; do eval ac_env_${ac_var}_set=\${${ac_var}+set} eval ac_env_${ac_var}_value=\$${ac_var} eval ac_cv_env_${ac_var}_set=\${${ac_var}+set} eval ac_cv_env_${ac_var}_value=\$${ac_var} done # # Report the --help message. # if test "$ac_init_help" = "long"; then # Omit some internal or obsolete options to make the list less imposing. # This message is too long to be a string in the A/UX 3.1 sh. cat <<_ACEOF \`configure' configures gtkada 18.0w to adapt to many kinds of systems. Usage: $0 [OPTION]... [VAR=VALUE]... To assign environment variables (e.g., CC, CFLAGS...), specify them as VAR=VALUE. See below for descriptions of some of the useful variables. Defaults for the options are specified in brackets. Configuration: -h, --help display this help and exit --help=short display options specific to this package --help=recursive display the short help of all the included packages -V, --version display version information and exit -q, --quiet, --silent do not print \`checking ...' messages --cache-file=FILE cache test results in FILE [disabled] -C, --config-cache alias for \`--cache-file=config.cache' -n, --no-create do not create output files --srcdir=DIR find the sources in DIR [configure dir or \`..'] Installation directories: --prefix=PREFIX install architecture-independent files in PREFIX [$ac_default_prefix] --exec-prefix=EPREFIX install architecture-dependent files in EPREFIX [PREFIX] By default, \`make install' will install all the files in \`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc. You can specify an installation prefix other than \`$ac_default_prefix' using \`--prefix', for instance \`--prefix=\$HOME'. For better control, use the options below. Fine tuning of the installation directories: --bindir=DIR user executables [EPREFIX/bin] --sbindir=DIR system admin executables [EPREFIX/sbin] --libexecdir=DIR program executables [EPREFIX/libexec] --sysconfdir=DIR read-only single-machine data [PREFIX/etc] --sharedstatedir=DIR modifiable architecture-independent data [PREFIX/com] --localstatedir=DIR modifiable single-machine data [PREFIX/var] --runstatedir=DIR modifiable per-process data [LOCALSTATEDIR/run] --libdir=DIR object code libraries [EPREFIX/lib] --includedir=DIR C header files [PREFIX/include] --oldincludedir=DIR C header files for non-gcc [/usr/include] --datarootdir=DIR read-only arch.-independent data root [PREFIX/share] --datadir=DIR read-only architecture-independent data [DATAROOTDIR] --infodir=DIR info documentation [DATAROOTDIR/info] --localedir=DIR locale-dependent data [DATAROOTDIR/locale] --mandir=DIR man documentation [DATAROOTDIR/man] --docdir=DIR documentation root [DATAROOTDIR/doc/gtkada] --htmldir=DIR html documentation [DOCDIR] --dvidir=DIR dvi documentation [DOCDIR] --pdfdir=DIR pdf documentation [DOCDIR] --psdir=DIR ps documentation [DOCDIR] _ACEOF cat <<\_ACEOF System types: --build=BUILD configure for building on BUILD [guessed] --host=HOST cross-compile to build programs to run on HOST [BUILD] --target=TARGET configure for building compilers for TARGET [HOST] _ACEOF fi if test -n "$ac_init_help"; then case $ac_init_help in short | recursive ) echo "Configuration of gtkada 18.0w:";; esac cat <<\_ACEOF Optional Features: --disable-option-checking ignore unrecognized --enable/--with options --disable-FEATURE do not include FEATURE (same as --enable-FEATURE=no) --enable-FEATURE[=ARG] include FEATURE [ARG=yes] --disable-static Disable building of static libraries. --enable-static Build static libraries (default). --disable-static-pic Disable building of static PIC libraries. --enable-static-pic Build static PIC libraries (default). --disable-shared Disable building of shared libraries (default is to build them if supported on the target) --enable-shared Build shared libraries if supported on the target and make them preselected in project files (static libraries are preselected by default --enable-build= Default build type for the library (Debug, Production) --disable-nls do not use Native Language Support --disable-gtktest do not try to compile and run a test GTK+ program Some influential environment variables: PKG_CONFIG path to pkg-config utility PKG_CONFIG_PATH directories to add to pkg-config's search path PKG_CONFIG_LIBDIR path overriding pkg-config's built-in search path CC C compiler command CFLAGS C compiler flags LDFLAGS linker flags, e.g. -L if you have libraries in a nonstandard directory LIBS libraries to pass to the linker, e.g. -l CPPFLAGS (Objective) C/C++ preprocessor flags, e.g. -I if you have headers in a nonstandard directory OBJC Objective C compiler command OBJCFLAGS Objective C compiler flags GTK_CFLAGS C compiler flags for GTK, overriding pkg-config GTK_LIBS linker flags for GTK, overriding pkg-config GMODULE_CFLAGS C compiler flags for GMODULE, overriding pkg-config GMODULE_LIBS linker flags for GMODULE, overriding pkg-config FONTCONFIG_CFLAGS C compiler flags for FONTCONFIG, overriding pkg-config FONTCONFIG_LIBS linker flags for FONTCONFIG, overriding pkg-config Use these variables to override the choices made by `configure' or to help it to find libraries and programs with nonstandard names/locations. Report bugs to . _ACEOF ac_status=$? fi if test "$ac_init_help" = "recursive"; then # If there are subdirs, report their specific --help. for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue test -d "$ac_dir" || { cd "$srcdir" && ac_pwd=`pwd` && srcdir=. && test -d "$ac_dir"; } || continue ac_builddir=. case "$ac_dir" in .) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;; *) ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'` # A ".." for each directory in $ac_dir_suffix. ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'` case $ac_top_builddir_sub in "") ac_top_builddir_sub=. ac_top_build_prefix= ;; *) ac_top_build_prefix=$ac_top_builddir_sub/ ;; esac ;; esac ac_abs_top_builddir=$ac_pwd ac_abs_builddir=$ac_pwd$ac_dir_suffix # for backward compatibility: ac_top_builddir=$ac_top_build_prefix case $srcdir in .) # We are building in place. ac_srcdir=. ac_top_srcdir=$ac_top_builddir_sub ac_abs_top_srcdir=$ac_pwd ;; [\\/]* | ?:[\\/]* ) # Absolute name. ac_srcdir=$srcdir$ac_dir_suffix; ac_top_srcdir=$srcdir ac_abs_top_srcdir=$srcdir ;; *) # Relative name. ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix ac_top_srcdir=$ac_top_build_prefix$srcdir ac_abs_top_srcdir=$ac_pwd/$srcdir ;; esac ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix cd "$ac_dir" || { ac_status=$?; continue; } # Check for guested configure. if test -f "$ac_srcdir/configure.gnu"; then echo && $SHELL "$ac_srcdir/configure.gnu" --help=recursive elif test -f "$ac_srcdir/configure"; then echo && $SHELL "$ac_srcdir/configure" --help=recursive else $as_echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2 fi || ac_status=$? cd "$ac_pwd" || { ac_status=$?; break; } done fi test -n "$ac_init_help" && exit $ac_status if $ac_init_version; then cat <<\_ACEOF gtkada configure 18.0w generated by GNU Autoconf 2.69 Copyright (C) 2012 Free Software Foundation, Inc. This configure script is free software; the Free Software Foundation gives unlimited permission to copy, distribute and modify it. _ACEOF exit fi ## ------------------------ ## ## Autoconf initialization. ## ## ------------------------ ## # ac_fn_c_try_compile LINENO # -------------------------- # Try to compile conftest.$ac_ext, and return whether this succeeded. ac_fn_c_try_compile () { as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack rm -f conftest.$ac_objext if { { ac_try="$ac_compile" case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" $as_echo "$ac_try_echo"; } >&5 (eval "$ac_compile") 2>conftest.err ac_status=$? if test -s conftest.err; then grep -v '^ *+' conftest.err >conftest.er1 cat conftest.er1 >&5 mv -f conftest.er1 conftest.err fi $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } && { test -z "$ac_c_werror_flag" || test ! -s conftest.err } && test -s conftest.$ac_objext; then : ac_retval=0 else $as_echo "$as_me: failed program was:" >&5 sed 's/^/| /' conftest.$ac_ext >&5 ac_retval=1 fi eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno as_fn_set_status $ac_retval } # ac_fn_c_try_compile # ac_fn_objc_try_compile LINENO # ----------------------------- # Try to compile conftest.$ac_ext, and return whether this succeeded. ac_fn_objc_try_compile () { as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack rm -f conftest.$ac_objext if { { ac_try="$ac_compile" case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" $as_echo "$ac_try_echo"; } >&5 (eval "$ac_compile") 2>conftest.err ac_status=$? if test -s conftest.err; then grep -v '^ *+' conftest.err >conftest.er1 cat conftest.er1 >&5 mv -f conftest.er1 conftest.err fi $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } && { test -z "$ac_objc_werror_flag" || test ! -s conftest.err } && test -s conftest.$ac_objext; then : ac_retval=0 else $as_echo "$as_me: failed program was:" >&5 sed 's/^/| /' conftest.$ac_ext >&5 ac_retval=1 fi eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno as_fn_set_status $ac_retval } # ac_fn_objc_try_compile # ac_fn_c_try_link LINENO # ----------------------- # Try to link conftest.$ac_ext, and return whether this succeeded. ac_fn_c_try_link () { as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack rm -f conftest.$ac_objext conftest$ac_exeext if { { ac_try="$ac_link" case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" $as_echo "$ac_try_echo"; } >&5 (eval "$ac_link") 2>conftest.err ac_status=$? if test -s conftest.err; then grep -v '^ *+' conftest.err >conftest.er1 cat conftest.er1 >&5 mv -f conftest.er1 conftest.err fi $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } && { test -z "$ac_c_werror_flag" || test ! -s conftest.err } && test -s conftest$ac_exeext && { test "$cross_compiling" = yes || test -x conftest$ac_exeext }; then : ac_retval=0 else $as_echo "$as_me: failed program was:" >&5 sed 's/^/| /' conftest.$ac_ext >&5 ac_retval=1 fi # Delete the IPA/IPO (Inter Procedural Analysis/Optimization) information # created by the PGI compiler (conftest_ipa8_conftest.oo), as it would # interfere with the next link command; also delete a directory that is # left behind by Apple's compiler. We do this before executing the actions. rm -rf conftest.dSYM conftest_ipa8_conftest.oo eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno as_fn_set_status $ac_retval } # ac_fn_c_try_link # ac_fn_c_try_run LINENO # ---------------------- # Try to link conftest.$ac_ext, and return whether this succeeded. Assumes # that executables *can* be run. ac_fn_c_try_run () { as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack if { { ac_try="$ac_link" case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" $as_echo "$ac_try_echo"; } >&5 (eval "$ac_link") 2>&5 ac_status=$? $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } && { ac_try='./conftest$ac_exeext' { { case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" $as_echo "$ac_try_echo"; } >&5 (eval "$ac_try") 2>&5 ac_status=$? $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; }; }; then : ac_retval=0 else $as_echo "$as_me: program exited with status $ac_status" >&5 $as_echo "$as_me: failed program was:" >&5 sed 's/^/| /' conftest.$ac_ext >&5 ac_retval=$ac_status fi rm -rf conftest.dSYM conftest_ipa8_conftest.oo eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno as_fn_set_status $ac_retval } # ac_fn_c_try_run cat >config.log <<_ACEOF This file contains any messages produced by compilers while running configure, to aid debugging if configure makes a mistake. It was created by gtkada $as_me 18.0w, which was generated by GNU Autoconf 2.69. Invocation command line was $ $0 $@ _ACEOF exec 5>>config.log { cat <<_ASUNAME ## --------- ## ## Platform. ## ## --------- ## hostname = `(hostname || uname -n) 2>/dev/null | sed 1q` uname -m = `(uname -m) 2>/dev/null || echo unknown` uname -r = `(uname -r) 2>/dev/null || echo unknown` uname -s = `(uname -s) 2>/dev/null || echo unknown` uname -v = `(uname -v) 2>/dev/null || echo unknown` /usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown` /bin/uname -X = `(/bin/uname -X) 2>/dev/null || echo unknown` /bin/arch = `(/bin/arch) 2>/dev/null || echo unknown` /usr/bin/arch -k = `(/usr/bin/arch -k) 2>/dev/null || echo unknown` /usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown` /usr/bin/hostinfo = `(/usr/bin/hostinfo) 2>/dev/null || echo unknown` /bin/machine = `(/bin/machine) 2>/dev/null || echo unknown` /usr/bin/oslevel = `(/usr/bin/oslevel) 2>/dev/null || echo unknown` /bin/universe = `(/bin/universe) 2>/dev/null || echo unknown` _ASUNAME as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. $as_echo "PATH: $as_dir" done IFS=$as_save_IFS } >&5 cat >&5 <<_ACEOF ## ----------- ## ## Core tests. ## ## ----------- ## _ACEOF # Keep a trace of the command line. # Strip out --no-create and --no-recursion so they do not pile up. # Strip out --silent because we don't want to record it for future runs. # Also quote any args containing shell meta-characters. # Make two passes to allow for proper duplicate-argument suppression. ac_configure_args= ac_configure_args0= ac_configure_args1= ac_must_keep_next=false for ac_pass in 1 2 do for ac_arg do case $ac_arg in -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;; -q | -quiet | --quiet | --quie | --qui | --qu | --q \ | -silent | --silent | --silen | --sile | --sil) continue ;; *\'*) ac_arg=`$as_echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;; esac case $ac_pass in 1) as_fn_append ac_configure_args0 " '$ac_arg'" ;; 2) as_fn_append ac_configure_args1 " '$ac_arg'" if test $ac_must_keep_next = true; then ac_must_keep_next=false # Got value, back to normal. else case $ac_arg in *=* | --config-cache | -C | -disable-* | --disable-* \ | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \ | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \ | -with-* | --with-* | -without-* | --without-* | --x) case "$ac_configure_args0 " in "$ac_configure_args1"*" '$ac_arg' "* ) continue ;; esac ;; -* ) ac_must_keep_next=true ;; esac fi as_fn_append ac_configure_args " '$ac_arg'" ;; esac done done { ac_configure_args0=; unset ac_configure_args0;} { ac_configure_args1=; unset ac_configure_args1;} # When interrupted or exit'd, cleanup temporary files, and complete # config.log. We remove comments because anyway the quotes in there # would cause problems or look ugly. # WARNING: Use '\'' to represent an apostrophe within the trap. # WARNING: Do not start the trap code with a newline, due to a FreeBSD 4.0 bug. trap 'exit_status=$? # Save into config.log some information that might help in debugging. { echo $as_echo "## ---------------- ## ## Cache variables. ## ## ---------------- ##" echo # The following way of writing the cache mishandles newlines in values, ( for ac_var in `(set) 2>&1 | sed -n '\''s/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'\''`; do eval ac_val=\$$ac_var case $ac_val in #( *${as_nl}*) case $ac_var in #( *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5 $as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;; esac case $ac_var in #( _ | IFS | as_nl) ;; #( BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #( *) { eval $ac_var=; unset $ac_var;} ;; esac ;; esac done (set) 2>&1 | case $as_nl`(ac_space='\'' '\''; set) 2>&1` in #( *${as_nl}ac_space=\ *) sed -n \ "s/'\''/'\''\\\\'\'''\''/g; s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\''\\2'\''/p" ;; #( *) sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p" ;; esac | sort ) echo $as_echo "## ----------------- ## ## Output variables. ## ## ----------------- ##" echo for ac_var in $ac_subst_vars do eval ac_val=\$$ac_var case $ac_val in *\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;; esac $as_echo "$ac_var='\''$ac_val'\''" done | sort echo if test -n "$ac_subst_files"; then $as_echo "## ------------------- ## ## File substitutions. ## ## ------------------- ##" echo for ac_var in $ac_subst_files do eval ac_val=\$$ac_var case $ac_val in *\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;; esac $as_echo "$ac_var='\''$ac_val'\''" done | sort echo fi if test -s confdefs.h; then $as_echo "## ----------- ## ## confdefs.h. ## ## ----------- ##" echo cat confdefs.h echo fi test "$ac_signal" != 0 && $as_echo "$as_me: caught signal $ac_signal" $as_echo "$as_me: exit $exit_status" } >&5 rm -f core *.core core.conftest.* && rm -f -r conftest* confdefs* conf$$* $ac_clean_files && exit $exit_status ' 0 for ac_signal in 1 2 13 15; do trap 'ac_signal='$ac_signal'; as_fn_exit 1' $ac_signal done ac_signal=0 # confdefs.h avoids OS command line length limits that DEFS can exceed. rm -f -r conftest* confdefs.h $as_echo "/* confdefs.h */" > confdefs.h # Predefined preprocessor variables. cat >>confdefs.h <<_ACEOF #define PACKAGE_NAME "$PACKAGE_NAME" _ACEOF cat >>confdefs.h <<_ACEOF #define PACKAGE_TARNAME "$PACKAGE_TARNAME" _ACEOF cat >>confdefs.h <<_ACEOF #define PACKAGE_VERSION "$PACKAGE_VERSION" _ACEOF cat >>confdefs.h <<_ACEOF #define PACKAGE_STRING "$PACKAGE_STRING" _ACEOF cat >>confdefs.h <<_ACEOF #define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT" _ACEOF cat >>confdefs.h <<_ACEOF #define PACKAGE_URL "$PACKAGE_URL" _ACEOF # Let the site file select an alternate cache file if it wants to. # Prefer an explicitly selected file to automatically selected ones. ac_site_file1=NONE ac_site_file2=NONE if test -n "$CONFIG_SITE"; then # We do not want a PATH search for config.site. case $CONFIG_SITE in #(( -*) ac_site_file1=./$CONFIG_SITE;; */*) ac_site_file1=$CONFIG_SITE;; *) ac_site_file1=./$CONFIG_SITE;; esac elif test "x$prefix" != xNONE; then ac_site_file1=$prefix/share/config.site ac_site_file2=$prefix/etc/config.site else ac_site_file1=$ac_default_prefix/share/config.site ac_site_file2=$ac_default_prefix/etc/config.site fi for ac_site_file in "$ac_site_file1" "$ac_site_file2" do test "x$ac_site_file" = xNONE && continue if test /dev/null != "$ac_site_file" && test -r "$ac_site_file"; then { $as_echo "$as_me:${as_lineno-$LINENO}: loading site script $ac_site_file" >&5 $as_echo "$as_me: loading site script $ac_site_file" >&6;} sed 's/^/| /' "$ac_site_file" >&5 . "$ac_site_file" \ || { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} as_fn_error $? "failed to load site script $ac_site_file See \`config.log' for more details" "$LINENO" 5; } fi done if test -r "$cache_file"; then # Some versions of bash will fail to source /dev/null (special files # actually), so we avoid doing that. DJGPP emulates it as a regular file. if test /dev/null != "$cache_file" && test -f "$cache_file"; then { $as_echo "$as_me:${as_lineno-$LINENO}: loading cache $cache_file" >&5 $as_echo "$as_me: loading cache $cache_file" >&6;} case $cache_file in [\\/]* | ?:[\\/]* ) . "$cache_file";; *) . "./$cache_file";; esac fi else { $as_echo "$as_me:${as_lineno-$LINENO}: creating cache $cache_file" >&5 $as_echo "$as_me: creating cache $cache_file" >&6;} >$cache_file fi # Check that the precious variables saved in the cache have kept the same # value. ac_cache_corrupted=false for ac_var in $ac_precious_vars; do eval ac_old_set=\$ac_cv_env_${ac_var}_set eval ac_new_set=\$ac_env_${ac_var}_set eval ac_old_val=\$ac_cv_env_${ac_var}_value eval ac_new_val=\$ac_env_${ac_var}_value case $ac_old_set,$ac_new_set in set,) { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5 $as_echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;} ac_cache_corrupted=: ;; ,set) { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was not set in the previous run" >&5 $as_echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;} ac_cache_corrupted=: ;; ,);; *) if test "x$ac_old_val" != "x$ac_new_val"; then # differences in whitespace do not lead to failure. ac_old_val_w=`echo x $ac_old_val` ac_new_val_w=`echo x $ac_new_val` if test "$ac_old_val_w" != "$ac_new_val_w"; then { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' has changed since the previous run:" >&5 $as_echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;} ac_cache_corrupted=: else { $as_echo "$as_me:${as_lineno-$LINENO}: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&5 $as_echo "$as_me: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&2;} eval $ac_var=\$ac_old_val fi { $as_echo "$as_me:${as_lineno-$LINENO}: former value: \`$ac_old_val'" >&5 $as_echo "$as_me: former value: \`$ac_old_val'" >&2;} { $as_echo "$as_me:${as_lineno-$LINENO}: current value: \`$ac_new_val'" >&5 $as_echo "$as_me: current value: \`$ac_new_val'" >&2;} fi;; esac # Pass precious variables to config.status. if test "$ac_new_set" = set; then case $ac_new_val in *\'*) ac_arg=$ac_var=`$as_echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;; *) ac_arg=$ac_var=$ac_new_val ;; esac case " $ac_configure_args " in *" '$ac_arg' "*) ;; # Avoid dups. Use of quotes ensures accuracy. *) as_fn_append ac_configure_args " '$ac_arg'" ;; esac fi done if $ac_cache_corrupted; then { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} { $as_echo "$as_me:${as_lineno-$LINENO}: error: changes in the environment can compromise the build" >&5 $as_echo "$as_me: error: changes in the environment can compromise the build" >&2;} as_fn_error $? "run \`make distclean' and/or \`rm $cache_file' and start over" "$LINENO" 5 fi ## -------------------- ## ## Main body of script. ## ## -------------------- ## ac_ext=c ac_cpp='$CPP $CPPFLAGS' ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' ac_compiler_gnu=$ac_cv_c_compiler_gnu ac_aux_dir= for ac_dir in "$srcdir" "$srcdir/.." "$srcdir/../.."; do if test -f "$ac_dir/install-sh"; then ac_aux_dir=$ac_dir ac_install_sh="$ac_aux_dir/install-sh -c" break elif test -f "$ac_dir/install.sh"; then ac_aux_dir=$ac_dir ac_install_sh="$ac_aux_dir/install.sh -c" break elif test -f "$ac_dir/shtool"; then ac_aux_dir=$ac_dir ac_install_sh="$ac_aux_dir/shtool install -c" break fi done if test -z "$ac_aux_dir"; then as_fn_error $? "cannot find install-sh, install.sh, or shtool in \"$srcdir\" \"$srcdir/..\" \"$srcdir/../..\"" "$LINENO" 5 fi # These three variables are undocumented and unsupported, # and are intended to be withdrawn in a future Autoconf release. # They can cause serious problems if a builder's source tree is in a directory # whose full name contains unusual characters. ac_config_guess="$SHELL $ac_aux_dir/config.guess" # Please don't use this var. ac_config_sub="$SHELL $ac_aux_dir/config.sub" # Please don't use this var. ac_configure="$SHELL $ac_aux_dir/configure" # Please don't use this var. # Make sure we can run config.sub. $SHELL "$ac_aux_dir/config.sub" sun4 >/dev/null 2>&1 || as_fn_error $? "cannot run $SHELL $ac_aux_dir/config.sub" "$LINENO" 5 { $as_echo "$as_me:${as_lineno-$LINENO}: checking build system type" >&5 $as_echo_n "checking build system type... " >&6; } if ${ac_cv_build+:} false; then : $as_echo_n "(cached) " >&6 else ac_build_alias=$build_alias test "x$ac_build_alias" = x && ac_build_alias=`$SHELL "$ac_aux_dir/config.guess"` test "x$ac_build_alias" = x && as_fn_error $? "cannot guess build type; you must specify one" "$LINENO" 5 ac_cv_build=`$SHELL "$ac_aux_dir/config.sub" $ac_build_alias` || as_fn_error $? "$SHELL $ac_aux_dir/config.sub $ac_build_alias failed" "$LINENO" 5 fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_build" >&5 $as_echo "$ac_cv_build" >&6; } case $ac_cv_build in *-*-*) ;; *) as_fn_error $? "invalid value of canonical build" "$LINENO" 5;; esac build=$ac_cv_build ac_save_IFS=$IFS; IFS='-' set x $ac_cv_build shift build_cpu=$1 build_vendor=$2 shift; shift # Remember, the first character of IFS is used to create $*, # except with old shells: build_os=$* IFS=$ac_save_IFS case $build_os in *\ *) build_os=`echo "$build_os" | sed 's/ /-/g'`;; esac { $as_echo "$as_me:${as_lineno-$LINENO}: checking host system type" >&5 $as_echo_n "checking host system type... " >&6; } if ${ac_cv_host+:} false; then : $as_echo_n "(cached) " >&6 else if test "x$host_alias" = x; then ac_cv_host=$ac_cv_build else ac_cv_host=`$SHELL "$ac_aux_dir/config.sub" $host_alias` || as_fn_error $? "$SHELL $ac_aux_dir/config.sub $host_alias failed" "$LINENO" 5 fi fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_host" >&5 $as_echo "$ac_cv_host" >&6; } case $ac_cv_host in *-*-*) ;; *) as_fn_error $? "invalid value of canonical host" "$LINENO" 5;; esac host=$ac_cv_host ac_save_IFS=$IFS; IFS='-' set x $ac_cv_host shift host_cpu=$1 host_vendor=$2 shift; shift # Remember, the first character of IFS is used to create $*, # except with old shells: host_os=$* IFS=$ac_save_IFS case $host_os in *\ *) host_os=`echo "$host_os" | sed 's/ /-/g'`;; esac { $as_echo "$as_me:${as_lineno-$LINENO}: checking target system type" >&5 $as_echo_n "checking target system type... " >&6; } if ${ac_cv_target+:} false; then : $as_echo_n "(cached) " >&6 else if test "x$target_alias" = x; then ac_cv_target=$ac_cv_host else ac_cv_target=`$SHELL "$ac_aux_dir/config.sub" $target_alias` || as_fn_error $? "$SHELL $ac_aux_dir/config.sub $target_alias failed" "$LINENO" 5 fi fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_target" >&5 $as_echo "$ac_cv_target" >&6; } case $ac_cv_target in *-*-*) ;; *) as_fn_error $? "invalid value of canonical target" "$LINENO" 5;; esac target=$ac_cv_target ac_save_IFS=$IFS; IFS='-' set x $ac_cv_target shift target_cpu=$1 target_vendor=$2 shift; shift # Remember, the first character of IFS is used to create $*, # except with old shells: target_os=$* IFS=$ac_save_IFS case $target_os in *\ *) target_os=`echo "$target_os" | sed 's/ /-/g'`;; esac # The aliases save the names the user supplied, while $host etc. # will get canonicalized. test -n "$target_alias" && test "$program_prefix$program_suffix$program_transform_name" = \ NONENONEs,x,x, && program_prefix=${target_alias}- if test "x$ac_cv_env_PKG_CONFIG_set" != "xset"; then if test -n "$ac_tool_prefix"; then # Extract the first word of "${ac_tool_prefix}pkg-config", so it can be a program name with args. set dummy ${ac_tool_prefix}pkg-config; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if ${ac_cv_path_PKG_CONFIG+:} false; then : $as_echo_n "(cached) " >&6 else case $PKG_CONFIG in [\\/]* | ?:[\\/]*) ac_cv_path_PKG_CONFIG="$PKG_CONFIG" # Let the user override the test with a path. ;; *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_path_PKG_CONFIG="$as_dir/$ac_word$ac_exec_ext" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS ;; esac fi PKG_CONFIG=$ac_cv_path_PKG_CONFIG if test -n "$PKG_CONFIG"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PKG_CONFIG" >&5 $as_echo "$PKG_CONFIG" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi fi if test -z "$ac_cv_path_PKG_CONFIG"; then ac_pt_PKG_CONFIG=$PKG_CONFIG # Extract the first word of "pkg-config", so it can be a program name with args. set dummy pkg-config; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if ${ac_cv_path_ac_pt_PKG_CONFIG+:} false; then : $as_echo_n "(cached) " >&6 else case $ac_pt_PKG_CONFIG in [\\/]* | ?:[\\/]*) ac_cv_path_ac_pt_PKG_CONFIG="$ac_pt_PKG_CONFIG" # Let the user override the test with a path. ;; *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_path_ac_pt_PKG_CONFIG="$as_dir/$ac_word$ac_exec_ext" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS ;; esac fi ac_pt_PKG_CONFIG=$ac_cv_path_ac_pt_PKG_CONFIG if test -n "$ac_pt_PKG_CONFIG"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_pt_PKG_CONFIG" >&5 $as_echo "$ac_pt_PKG_CONFIG" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi if test "x$ac_pt_PKG_CONFIG" = x; then PKG_CONFIG="" else case $cross_compiling:$ac_tool_warned in yes:) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac PKG_CONFIG=$ac_pt_PKG_CONFIG fi else PKG_CONFIG="$ac_cv_path_PKG_CONFIG" fi fi if test -n "$PKG_CONFIG"; then _pkg_min_version=0.9.0 { $as_echo "$as_me:${as_lineno-$LINENO}: checking pkg-config is at least version $_pkg_min_version" >&5 $as_echo_n "checking pkg-config is at least version $_pkg_min_version... " >&6; } if $PKG_CONFIG --atleast-pkgconfig-version $_pkg_min_version; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 $as_echo "yes" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } PKG_CONFIG="" fi fi TARGET="" if test x$host != x$target ; then TARGET=${target} fi SO_EXT=.so SO_OPTS=-Wl,-soname, TARGET_LFLAGS= DEFAULT_LIBRARY_TYPE=static NEED_OBJECTIVE_C=no # Check whether --enable-static was given. if test "${enable_static+set}" = set; then : enableval=$enable_static; BUILD_STATIC=$enableval if test $enableval = no; then DEFAULT_LIBRARY_TYPE=relocatable fi else BUILD_STATIC=yes fi # Check whether --enable-static_pic was given. if test "${enable_static_pic+set}" = set; then : enableval=$enable_static_pic; BUILD_STATIC_PIC=$enableval if test $enableval = yes; then DEFAULT_LIBRARY_TYPE=static-pic fi else BUILD_STATIC_PIC=yes fi # Check whether --enable-shared was given. if test "${enable_shared+set}" = set; then : enableval=$enable_shared; CAN_BUILD_SHARED=$enableval if test $enableval = yes; then DEFAULT_LIBRARY_TYPE=relocatable fi else CAN_BUILD_SHARED=yes fi BUILD_SHARED=$CAN_BUILD_SHARED case $build_os in aix*) BUILD_SHARED=no OS_SPECIFIC_LINK_OPTIONS=-Wl,-bexpall,-berok TARGET_LFLAGS=-Wl,-bbigtoc SO_OPTS="-o " ;; hp*) SO_EXT=.sl SO_OPTS=-Wl,+h, BUILD_SHARED=no ;; *sysv4uw* | *sysv5uw*) SO_OPTS=-Wl,-h, BUILD_SHARED=no ;; *solaris*) SO_OPTS=-Wl,-h, ;; *irix*) ;; *osf*) OS_SPECIFIC_LINK_OPTIONS=-Wl,-expect_unresolved,\* ;; *mingw*) if test x$CAN_BUILD_SHARED = xyes ; then BUILD_SHARED=yes fi SO_EXT=.dll ac_tmp_GNATDIR=`which gcc | sed 's,/gcc$,,'` ac_GNATDIR=`cygpath --mixed $ac_tmp_GNATDIR` count=`cd $ac_GNATDIR; ls libgnat-*.dll | wc -l` if test $count -gt 1 ; then echo "Too many libgnat.dll, in $ac_GNATDIR" echo Found: `cd $ac_GNATDIR; ls libgnat-*.dll` exit 1 fi ac_GNATLIB=`cd $ac_GNATDIR; ls libgnat-*.dll | sed 's,lib,,;s,.dll,,'` OS_SPECIFIC_LINK_OPTIONS=-Wl,-L$ac_GNATDIR,-l$ac_GNATLIB ;; *darwin*) SO_EXT=.dylib NEED_OBJECTIVE_C=yes if test x$CAN_BUILD_SHARED = xyes ; then BUILD_SHARED=yes fi SO_OPTS="-Wl,-undefined,dynamic_lookup -dynamiclib -Wl,-dylib_install_name," LDFLAGS="-Wl,-framework,Cocoa" TARGET_LFLAGS="-Wl,-framework,Cocoa" ;; # ??? The following case has been introduced because of an elaboration # problem with the GtkAda dynamic library and GPS (see E511-010). This # is a workaround, and shall be removed as soon as the bug is fixed. *linux*) case $build_cpu in *ia64*) BUILD_SHARED=no ;; esac ;; esac if test x$BUILD_SHARED = xno ; then if test x$BUILD_STATIC_PIC = xno ; then DEFAULT_LIBRARY_TYPE=static fi fi # checking for local tools ac_ext=c ac_cpp='$CPP $CPPFLAGS' ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' ac_compiler_gnu=$ac_cv_c_compiler_gnu if test -n "$ac_tool_prefix"; then # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args. set dummy ${ac_tool_prefix}gcc; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if ${ac_cv_prog_CC+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$CC"; then ac_cv_prog_CC="$CC" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_CC="${ac_tool_prefix}gcc" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi CC=$ac_cv_prog_CC if test -n "$CC"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5 $as_echo "$CC" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi fi if test -z "$ac_cv_prog_CC"; then ac_ct_CC=$CC # Extract the first word of "gcc", so it can be a program name with args. set dummy gcc; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if ${ac_cv_prog_ac_ct_CC+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$ac_ct_CC"; then ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_CC="gcc" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi ac_ct_CC=$ac_cv_prog_ac_ct_CC if test -n "$ac_ct_CC"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5 $as_echo "$ac_ct_CC" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi if test "x$ac_ct_CC" = x; then CC="" else case $cross_compiling:$ac_tool_warned in yes:) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac CC=$ac_ct_CC fi else CC="$ac_cv_prog_CC" fi if test -z "$CC"; then if test -n "$ac_tool_prefix"; then # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args. set dummy ${ac_tool_prefix}cc; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if ${ac_cv_prog_CC+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$CC"; then ac_cv_prog_CC="$CC" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_CC="${ac_tool_prefix}cc" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi CC=$ac_cv_prog_CC if test -n "$CC"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5 $as_echo "$CC" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi fi fi if test -z "$CC"; then # Extract the first word of "cc", so it can be a program name with args. set dummy cc; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if ${ac_cv_prog_CC+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$CC"; then ac_cv_prog_CC="$CC" # Let the user override the test. else ac_prog_rejected=no as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then ac_prog_rejected=yes continue fi ac_cv_prog_CC="cc" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS if test $ac_prog_rejected = yes; then # We found a bogon in the path, so make sure we never use it. set dummy $ac_cv_prog_CC shift if test $# != 0; then # We chose a different compiler from the bogus one. # However, it has the same basename, so the bogon will be chosen # first if we set CC to just the basename; use the full file name. shift ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@" fi fi fi fi CC=$ac_cv_prog_CC if test -n "$CC"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5 $as_echo "$CC" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi fi if test -z "$CC"; then if test -n "$ac_tool_prefix"; then for ac_prog in cl.exe do # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args. set dummy $ac_tool_prefix$ac_prog; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if ${ac_cv_prog_CC+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$CC"; then ac_cv_prog_CC="$CC" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_CC="$ac_tool_prefix$ac_prog" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi CC=$ac_cv_prog_CC if test -n "$CC"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5 $as_echo "$CC" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi test -n "$CC" && break done fi if test -z "$CC"; then ac_ct_CC=$CC for ac_prog in cl.exe do # Extract the first word of "$ac_prog", so it can be a program name with args. set dummy $ac_prog; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if ${ac_cv_prog_ac_ct_CC+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$ac_ct_CC"; then ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_CC="$ac_prog" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi ac_ct_CC=$ac_cv_prog_ac_ct_CC if test -n "$ac_ct_CC"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5 $as_echo "$ac_ct_CC" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi test -n "$ac_ct_CC" && break done if test "x$ac_ct_CC" = x; then CC="" else case $cross_compiling:$ac_tool_warned in yes:) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac CC=$ac_ct_CC fi fi fi test -z "$CC" && { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} as_fn_error $? "no acceptable C compiler found in \$PATH See \`config.log' for more details" "$LINENO" 5; } # Provide some information about the compiler. $as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler version" >&5 set X $ac_compile ac_compiler=$2 for ac_option in --version -v -V -qversion; do { { ac_try="$ac_compiler $ac_option >&5" case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" $as_echo "$ac_try_echo"; } >&5 (eval "$ac_compiler $ac_option >&5") 2>conftest.err ac_status=$? if test -s conftest.err; then sed '10a\ ... rest of stderr output deleted ... 10q' conftest.err >conftest.er1 cat conftest.er1 >&5 fi rm -f conftest.er1 conftest.err $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } done cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main () { ; return 0; } _ACEOF ac_clean_files_save=$ac_clean_files ac_clean_files="$ac_clean_files a.out a.out.dSYM a.exe b.out" # Try to create an executable without -o first, disregard a.out. # It will help us diagnose broken compilers, and finding out an intuition # of exeext. { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the C compiler works" >&5 $as_echo_n "checking whether the C compiler works... " >&6; } ac_link_default=`$as_echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'` # The possible output files: ac_files="a.out conftest.exe conftest a.exe a_out.exe b.out conftest.*" ac_rmfiles= for ac_file in $ac_files do case $ac_file in *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;; * ) ac_rmfiles="$ac_rmfiles $ac_file";; esac done rm -f $ac_rmfiles if { { ac_try="$ac_link_default" case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" $as_echo "$ac_try_echo"; } >&5 (eval "$ac_link_default") 2>&5 ac_status=$? $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; }; then : # Autoconf-2.13 could set the ac_cv_exeext variable to `no'. # So ignore a value of `no', otherwise this would lead to `EXEEXT = no' # in a Makefile. We should not override ac_cv_exeext if it was cached, # so that the user can short-circuit this test for compilers unknown to # Autoconf. for ac_file in $ac_files '' do test -f "$ac_file" || continue case $ac_file in *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;; [ab].out ) # We found the default executable, but exeext='' is most # certainly right. break;; *.* ) if test "${ac_cv_exeext+set}" = set && test "$ac_cv_exeext" != no; then :; else ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'` fi # We set ac_cv_exeext here because the later test for it is not # safe: cross compilers may not add the suffix if given an `-o' # argument, so we may need to know it at that point already. # Even if this section looks crufty: it has the advantage of # actually working. break;; * ) break;; esac done test "$ac_cv_exeext" = no && ac_cv_exeext= else ac_file='' fi if test -z "$ac_file"; then : { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } $as_echo "$as_me: failed program was:" >&5 sed 's/^/| /' conftest.$ac_ext >&5 { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} as_fn_error 77 "C compiler cannot create executables See \`config.log' for more details" "$LINENO" 5; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 $as_echo "yes" >&6; } fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler default output file name" >&5 $as_echo_n "checking for C compiler default output file name... " >&6; } { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_file" >&5 $as_echo "$ac_file" >&6; } ac_exeext=$ac_cv_exeext rm -f -r a.out a.out.dSYM a.exe conftest$ac_cv_exeext b.out ac_clean_files=$ac_clean_files_save { $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of executables" >&5 $as_echo_n "checking for suffix of executables... " >&6; } if { { ac_try="$ac_link" case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" $as_echo "$ac_try_echo"; } >&5 (eval "$ac_link") 2>&5 ac_status=$? $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; }; then : # If both `conftest.exe' and `conftest' are `present' (well, observable) # catch `conftest.exe'. For instance with Cygwin, `ls conftest' will # work properly (i.e., refer to `conftest.exe'), while it won't with # `rm'. for ac_file in conftest.exe conftest conftest.*; do test -f "$ac_file" || continue case $ac_file in *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;; *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'` break;; * ) break;; esac done else { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} as_fn_error $? "cannot compute suffix of executables: cannot compile and link See \`config.log' for more details" "$LINENO" 5; } fi rm -f conftest conftest$ac_cv_exeext { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_exeext" >&5 $as_echo "$ac_cv_exeext" >&6; } rm -f conftest.$ac_ext EXEEXT=$ac_cv_exeext ac_exeext=$EXEEXT cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include int main () { FILE *f = fopen ("conftest.out", "w"); return ferror (f) || fclose (f) != 0; ; return 0; } _ACEOF ac_clean_files="$ac_clean_files conftest.out" # Check that the compiler produces executables we can run. If not, either # the compiler is broken, or we cross compile. { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are cross compiling" >&5 $as_echo_n "checking whether we are cross compiling... " >&6; } if test "$cross_compiling" != yes; then { { ac_try="$ac_link" case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" $as_echo "$ac_try_echo"; } >&5 (eval "$ac_link") 2>&5 ac_status=$? $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } if { ac_try='./conftest$ac_cv_exeext' { { case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" $as_echo "$ac_try_echo"; } >&5 (eval "$ac_try") 2>&5 ac_status=$? $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; }; }; then cross_compiling=no else if test "$cross_compiling" = maybe; then cross_compiling=yes else { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} as_fn_error $? "cannot run C compiled programs. If you meant to cross compile, use \`--host'. See \`config.log' for more details" "$LINENO" 5; } fi fi fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $cross_compiling" >&5 $as_echo "$cross_compiling" >&6; } rm -f conftest.$ac_ext conftest$ac_cv_exeext conftest.out ac_clean_files=$ac_clean_files_save { $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of object files" >&5 $as_echo_n "checking for suffix of object files... " >&6; } if ${ac_cv_objext+:} false; then : $as_echo_n "(cached) " >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main () { ; return 0; } _ACEOF rm -f conftest.o conftest.obj if { { ac_try="$ac_compile" case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" $as_echo "$ac_try_echo"; } >&5 (eval "$ac_compile") 2>&5 ac_status=$? $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; }; then : for ac_file in conftest.o conftest.obj conftest.*; do test -f "$ac_file" || continue; case $ac_file in *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM ) ;; *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'` break;; esac done else $as_echo "$as_me: failed program was:" >&5 sed 's/^/| /' conftest.$ac_ext >&5 { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} as_fn_error $? "cannot compute suffix of object files: cannot compile See \`config.log' for more details" "$LINENO" 5; } fi rm -f conftest.$ac_cv_objext conftest.$ac_ext fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_objext" >&5 $as_echo "$ac_cv_objext" >&6; } OBJEXT=$ac_cv_objext ac_objext=$OBJEXT { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C compiler" >&5 $as_echo_n "checking whether we are using the GNU C compiler... " >&6; } if ${ac_cv_c_compiler_gnu+:} false; then : $as_echo_n "(cached) " >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main () { #ifndef __GNUC__ choke me #endif ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : ac_compiler_gnu=yes else ac_compiler_gnu=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext ac_cv_c_compiler_gnu=$ac_compiler_gnu fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_compiler_gnu" >&5 $as_echo "$ac_cv_c_compiler_gnu" >&6; } if test $ac_compiler_gnu = yes; then GCC=yes else GCC= fi ac_test_CFLAGS=${CFLAGS+set} ac_save_CFLAGS=$CFLAGS { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CC accepts -g" >&5 $as_echo_n "checking whether $CC accepts -g... " >&6; } if ${ac_cv_prog_cc_g+:} false; then : $as_echo_n "(cached) " >&6 else ac_save_c_werror_flag=$ac_c_werror_flag ac_c_werror_flag=yes ac_cv_prog_cc_g=no CFLAGS="-g" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main () { ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : ac_cv_prog_cc_g=yes else CFLAGS="" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main () { ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : else ac_c_werror_flag=$ac_save_c_werror_flag CFLAGS="-g" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main () { ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : ac_cv_prog_cc_g=yes fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext ac_c_werror_flag=$ac_save_c_werror_flag fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_g" >&5 $as_echo "$ac_cv_prog_cc_g" >&6; } if test "$ac_test_CFLAGS" = set; then CFLAGS=$ac_save_CFLAGS elif test $ac_cv_prog_cc_g = yes; then if test "$GCC" = yes; then CFLAGS="-g -O2" else CFLAGS="-g" fi else if test "$GCC" = yes; then CFLAGS="-O2" else CFLAGS= fi fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $CC option to accept ISO C89" >&5 $as_echo_n "checking for $CC option to accept ISO C89... " >&6; } if ${ac_cv_prog_cc_c89+:} false; then : $as_echo_n "(cached) " >&6 else ac_cv_prog_cc_c89=no ac_save_CC=$CC cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include #include struct stat; /* Most of the following tests are stolen from RCS 5.7's src/conf.sh. */ struct buf { int x; }; FILE * (*rcsopen) (struct buf *, struct stat *, int); static char *e (p, i) char **p; int i; { return p[i]; } static char *f (char * (*g) (char **, int), char **p, ...) { char *s; va_list v; va_start (v,p); s = g (p, va_arg (v,int)); va_end (v); return s; } /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default. It has function prototypes and stuff, but not '\xHH' hex character constants. These don't provoke an error unfortunately, instead are silently treated as 'x'. The following induces an error, until -std is added to get proper ANSI mode. Curiously '\x00'!='x' always comes out true, for an array size at least. It's necessary to write '\x00'==0 to get something that's true only with -std. */ int osf4_cc_array ['\x00' == 0 ? 1 : -1]; /* IBM C 6 for AIX is almost-ANSI by default, but it replaces macro parameters inside strings and character constants. */ #define FOO(x) 'x' int xlc6_cc_array[FOO(a) == 'x' ? 1 : -1]; int test (int i, double x); struct s1 {int (*f) (int a);}; struct s2 {int (*f) (double a);}; int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int); int argc; char **argv; int main () { return f (e, argv, 0) != argv[0] || f (e, argv, 1) != argv[1]; ; return 0; } _ACEOF for ac_arg in '' -qlanglvl=extc89 -qlanglvl=ansi -std \ -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__" do CC="$ac_save_CC $ac_arg" if ac_fn_c_try_compile "$LINENO"; then : ac_cv_prog_cc_c89=$ac_arg fi rm -f core conftest.err conftest.$ac_objext test "x$ac_cv_prog_cc_c89" != "xno" && break done rm -f conftest.$ac_ext CC=$ac_save_CC fi # AC_CACHE_VAL case "x$ac_cv_prog_cc_c89" in x) { $as_echo "$as_me:${as_lineno-$LINENO}: result: none needed" >&5 $as_echo "none needed" >&6; } ;; xno) { $as_echo "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5 $as_echo "unsupported" >&6; } ;; *) CC="$CC $ac_cv_prog_cc_c89" { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c89" >&5 $as_echo "$ac_cv_prog_cc_c89" >&6; } ;; esac if test "x$ac_cv_prog_cc_c89" != xno; then : fi ac_ext=c ac_cpp='$CPP $CPPFLAGS' ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' ac_compiler_gnu=$ac_cv_c_compiler_gnu case $build_os in *darwin*) ac_ext=m ac_cpp='$OBJCPP $CPPFLAGS' ac_compile='$OBJC -c $OBJCFLAGS $CPPFLAGS conftest.$ac_ext >&5' ac_link='$OBJC -o conftest$ac_exeext $OBJCFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' ac_compiler_gnu=$ac_cv_objc_compiler_gnu if test -n "$ac_tool_prefix"; then for ac_prog in clang gcc CC do # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args. set dummy $ac_tool_prefix$ac_prog; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if ${ac_cv_prog_OBJC+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$OBJC"; then ac_cv_prog_OBJC="$OBJC" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_OBJC="$ac_tool_prefix$ac_prog" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi OBJC=$ac_cv_prog_OBJC if test -n "$OBJC"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OBJC" >&5 $as_echo "$OBJC" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi test -n "$OBJC" && break done fi if test -z "$OBJC"; then ac_ct_OBJC=$OBJC for ac_prog in clang gcc CC do # Extract the first word of "$ac_prog", so it can be a program name with args. set dummy $ac_prog; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if ${ac_cv_prog_ac_ct_OBJC+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$ac_ct_OBJC"; then ac_cv_prog_ac_ct_OBJC="$ac_ct_OBJC" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_OBJC="$ac_prog" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi ac_ct_OBJC=$ac_cv_prog_ac_ct_OBJC if test -n "$ac_ct_OBJC"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OBJC" >&5 $as_echo "$ac_ct_OBJC" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi test -n "$ac_ct_OBJC" && break done if test "x$ac_ct_OBJC" = x; then OBJC="gcc" else case $cross_compiling:$ac_tool_warned in yes:) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac OBJC=$ac_ct_OBJC fi fi # Provide some information about the compiler. $as_echo "$as_me:${as_lineno-$LINENO}: checking for Objective C compiler version" >&5 set X $ac_compile ac_compiler=$2 for ac_option in --version -v -V -qversion; do { { ac_try="$ac_compiler $ac_option >&5" case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" $as_echo "$ac_try_echo"; } >&5 (eval "$ac_compiler $ac_option >&5") 2>conftest.err ac_status=$? if test -s conftest.err; then sed '10a\ ... rest of stderr output deleted ... 10q' conftest.err >conftest.er1 cat conftest.er1 >&5 fi rm -f conftest.er1 conftest.err $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } done { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU Objective C compiler" >&5 $as_echo_n "checking whether we are using the GNU Objective C compiler... " >&6; } if ${ac_cv_objc_compiler_gnu+:} false; then : $as_echo_n "(cached) " >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main () { #ifndef __GNUC__ choke me #endif ; return 0; } _ACEOF if ac_fn_objc_try_compile "$LINENO"; then : ac_compiler_gnu=yes else ac_compiler_gnu=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext ac_cv_objc_compiler_gnu=$ac_compiler_gnu fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_objc_compiler_gnu" >&5 $as_echo "$ac_cv_objc_compiler_gnu" >&6; } if test $ac_compiler_gnu = yes; then GOBJC=yes else GOBJC= fi ac_test_OBJCFLAGS=${OBJCFLAGS+set} ac_save_OBJCFLAGS=$OBJCFLAGS { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $OBJC accepts -g" >&5 $as_echo_n "checking whether $OBJC accepts -g... " >&6; } if ${ac_cv_prog_objc_g+:} false; then : $as_echo_n "(cached) " >&6 else ac_save_objc_werror_flag=$ac_objc_werror_flag ac_objc_werror_flag=yes ac_cv_prog_objc_g=no OBJCFLAGS="-g" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main () { ; return 0; } _ACEOF if ac_fn_objc_try_compile "$LINENO"; then : ac_cv_prog_objc_g=yes else OBJCFLAGS="" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main () { ; return 0; } _ACEOF if ac_fn_objc_try_compile "$LINENO"; then : else ac_objc_werror_flag=$ac_save_objc_werror_flag OBJCFLAGS="-g" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main () { ; return 0; } _ACEOF if ac_fn_objc_try_compile "$LINENO"; then : ac_cv_prog_objc_g=yes fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext ac_objc_werror_flag=$ac_save_objc_werror_flag fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_objc_g" >&5 $as_echo "$ac_cv_prog_objc_g" >&6; } if test "$ac_test_OBJCFLAGS" = set; then OBJCFLAGS=$ac_save_OBJCFLAGS elif test $ac_cv_prog_objc_g = yes; then if test "$GOBJC" = yes; then OBJCFLAGS="-g -O2" else OBJCFLAGS="-g" fi else if test "$GOBJC" = yes; then OBJCFLAGS="-O2" else OBJCFLAGS= fi fi ac_ext=c ac_cpp='$CPP $CPPFLAGS' ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' ac_compiler_gnu=$ac_cv_c_compiler_gnu ;; *) OBJC=""; ;; esac # Extract the first word of "gprbuild", so it can be a program name with args. set dummy gprbuild; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if ${ac_cv_path_GPRBUILD+:} false; then : $as_echo_n "(cached) " >&6 else case $GPRBUILD in [\\/]* | ?:[\\/]*) ac_cv_path_GPRBUILD="$GPRBUILD" # Let the user override the test with a path. ;; *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_path_GPRBUILD="$as_dir/$ac_word$ac_exec_ext" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS test -z "$ac_cv_path_GPRBUILD" && ac_cv_path_GPRBUILD="no" ;; esac fi GPRBUILD=$ac_cv_path_GPRBUILD if test -n "$GPRBUILD"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $GPRBUILD" >&5 $as_echo "$GPRBUILD" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi # Extract the first word of "gprinstall", so it can be a program name with args. set dummy gprinstall; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if ${ac_cv_path_GPRINSTALL+:} false; then : $as_echo_n "(cached) " >&6 else case $GPRINSTALL in [\\/]* | ?:[\\/]*) ac_cv_path_GPRINSTALL="$GPRINSTALL" # Let the user override the test with a path. ;; *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_path_GPRINSTALL="$as_dir/$ac_word$ac_exec_ext" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS test -z "$ac_cv_path_GPRINSTALL" && ac_cv_path_GPRINSTALL="no" ;; esac fi GPRINSTALL=$ac_cv_path_GPRINSTALL if test -n "$GPRINSTALL"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $GPRINSTALL" >&5 $as_echo "$GPRINSTALL" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi if test x$GPRBUILD = xno ; then as_fn_error $? "I could not find gprbuild. See the file 'INSTALL' for more details." "$LINENO" 5 fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking that your gnat compiler works with a simple example" >&5 $as_echo_n "checking that your gnat compiler works with a simple example... " >&6; } rm -f conftest.adb cat << EOF > conftest.adb with Ada.Text_IO; procedure Conftest is Conftest_Ok : Ada.Text_IO.File_Type; begin Ada.Text_IO.Create (File => Conftest_Ok, Name => "$conftest_ok"); Ada.Text_IO.Close (Conftest_Ok); end Conftest; EOF cat < conftest.gpr project Conftest is for Main use ("conftest.adb"); for Source_Files use ("conftest.adb"); end Conftest; EOF $GPRBUILD -q -P conftest.gpr > /dev/null rm -f auto.cgpr b__conftest.* if ( test ! -x conftest ) then { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } as_fn_error $? "$GPRBUILD test failed at compile time! Check your configuration." "$LINENO" 5 fi ./conftest if ( test ! -f $conftest_ok ) then { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } as_fn_error $? "$GPRBUILD test failed at run time! Check your configuration." "$LINENO" 5 fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 $as_echo "yes" >&6; } # Check whether --enable-build was given. if test "${enable_build+set}" = set; then : enableval=$enable_build; BUILD_TYPE=$enableval else BUILD_TYPE=Production fi # are we in devel mode ? # Gettext stuff ALL_LINGUAS="en" { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether NLS is requested" >&5 $as_echo_n "checking whether NLS is requested... " >&6; } # Check whether --enable-nls was given. if test "${enable_nls+set}" = set; then : enableval=$enable_nls; USE_NLS=$enableval else USE_NLS=yes fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $USE_NLS" >&5 $as_echo "$USE_NLS" >&6; } GETTEXT_INTL="False" HAVE_GETTEXT="False" if test "$USE_NLS" = "yes"; then $as_echo "#define ENABLE_NLS 1" >>confdefs.h nls_cv_header_intl= nls_cv_header_libgt= { $as_echo "$as_me:${as_lineno-$LINENO}: checking for gettext in libc" >&5 $as_echo_n "checking for gettext in libc... " >&6; } if ${gt_cv_func_gettext_libc+:} false; then : $as_echo_n "(cached) " >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ extern int gettext(char*); int main () { return (int) gettext ("") ; return 0; } _ACEOF if ac_fn_c_try_link "$LINENO"; then : gt_cv_func_gettext_libc=yes else gt_cv_func_gettext_libc=no fi rm -f core conftest.err conftest.$ac_objext \ conftest$ac_exeext conftest.$ac_ext fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $gt_cv_func_gettext_libc" >&5 $as_echo "$gt_cv_func_gettext_libc" >&6; } if test "$gt_cv_func_gettext_libc" != "yes"; then { $as_echo "$as_me:${as_lineno-$LINENO}: checking for bindtextdomain in -lintl" >&5 $as_echo_n "checking for bindtextdomain in -lintl... " >&6; } if ${ac_cv_lib_intl_bindtextdomain+:} false; then : $as_echo_n "(cached) " >&6 else ac_check_lib_save_LIBS=$LIBS LIBS="-lintl $LIBS" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ /* Override any GCC internal prototype to avoid an error. Use char because int might match the return type of a GCC builtin and then its argument prototype would still apply. */ #ifdef __cplusplus extern "C" #endif char bindtextdomain (); int main () { return bindtextdomain (); ; return 0; } _ACEOF if ac_fn_c_try_link "$LINENO"; then : ac_cv_lib_intl_bindtextdomain=yes else ac_cv_lib_intl_bindtextdomain=no fi rm -f core conftest.err conftest.$ac_objext \ conftest$ac_exeext conftest.$ac_ext LIBS=$ac_check_lib_save_LIBS fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_intl_bindtextdomain" >&5 $as_echo "$ac_cv_lib_intl_bindtextdomain" >&6; } if test "x$ac_cv_lib_intl_bindtextdomain" = xyes; then : { $as_echo "$as_me:${as_lineno-$LINENO}: checking for gettext in libintl" >&5 $as_echo_n "checking for gettext in libintl... " >&6; } if ${gt_cv_func_gettext_libintl+:} false; then : $as_echo_n "(cached) " >&6 else { $as_echo "$as_me:${as_lineno-$LINENO}: checking for gettext in -lintl" >&5 $as_echo_n "checking for gettext in -lintl... " >&6; } if ${ac_cv_lib_intl_gettext+:} false; then : $as_echo_n "(cached) " >&6 else ac_check_lib_save_LIBS=$LIBS LIBS="-lintl $LIBS" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ /* Override any GCC internal prototype to avoid an error. Use char because int might match the return type of a GCC builtin and then its argument prototype would still apply. */ #ifdef __cplusplus extern "C" #endif char gettext (); int main () { return gettext (); ; return 0; } _ACEOF if ac_fn_c_try_link "$LINENO"; then : ac_cv_lib_intl_gettext=yes else ac_cv_lib_intl_gettext=no fi rm -f core conftest.err conftest.$ac_objext \ conftest$ac_exeext conftest.$ac_ext LIBS=$ac_check_lib_save_LIBS fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_intl_gettext" >&5 $as_echo "$ac_cv_lib_intl_gettext" >&6; } if test "x$ac_cv_lib_intl_gettext" = xyes; then : gt_cv_func_gettext_libintl=yes else gt_cv_func_gettext_libintl=no fi fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $gt_cv_func_gettext_libintl" >&5 $as_echo "$gt_cv_func_gettext_libintl" >&6; } fi if test "$gt_cv_func_gettext_libintl" = "yes"; then GETTEXT_INTL="True" fi fi if test "$gt_cv_func_gettext_libc" = "yes" \ || test "$gt_cv_func_gettext_libintl" = "yes"; then HAVE_GETTEXT="True" fi fi # checking for gtk: # 1. PKG_CHECK_MODULES: check for pkg-config modules, this provides useful # diagnostic when some error occured. # 2. AM_PATH_GTK: check for low level binary interface of the libraries and # create necessary variables to substitute into .gpr files. pkg_failed=no { $as_echo "$as_me:${as_lineno-$LINENO}: checking for GTK" >&5 $as_echo_n "checking for GTK... " >&6; } if test -n "$GTK_CFLAGS"; then pkg_cv_GTK_CFLAGS="$GTK_CFLAGS" elif test -n "$PKG_CONFIG"; then if test -n "$PKG_CONFIG" && \ { { $as_echo "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"gtk+-3.0\""; } >&5 ($PKG_CONFIG --exists --print-errors "gtk+-3.0") 2>&5 ac_status=$? $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; }; then pkg_cv_GTK_CFLAGS=`$PKG_CONFIG --cflags "gtk+-3.0" 2>/dev/null` test "x$?" != "x0" && pkg_failed=yes else pkg_failed=yes fi else pkg_failed=untried fi if test -n "$GTK_LIBS"; then pkg_cv_GTK_LIBS="$GTK_LIBS" elif test -n "$PKG_CONFIG"; then if test -n "$PKG_CONFIG" && \ { { $as_echo "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"gtk+-3.0\""; } >&5 ($PKG_CONFIG --exists --print-errors "gtk+-3.0") 2>&5 ac_status=$? $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; }; then pkg_cv_GTK_LIBS=`$PKG_CONFIG --libs "gtk+-3.0" 2>/dev/null` test "x$?" != "x0" && pkg_failed=yes else pkg_failed=yes fi else pkg_failed=untried fi if test $pkg_failed = yes; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } if $PKG_CONFIG --atleast-pkgconfig-version 0.20; then _pkg_short_errors_supported=yes else _pkg_short_errors_supported=no fi if test $_pkg_short_errors_supported = yes; then GTK_PKG_ERRORS=`$PKG_CONFIG --short-errors --print-errors --cflags --libs "gtk+-3.0" 2>&1` else GTK_PKG_ERRORS=`$PKG_CONFIG --print-errors --cflags --libs "gtk+-3.0" 2>&1` fi # Put the nasty error message in config.log where it belongs echo "$GTK_PKG_ERRORS" >&5 as_fn_error $? "Package requirements (gtk+-3.0) were not met: $GTK_PKG_ERRORS Consider adjusting the PKG_CONFIG_PATH environment variable if you installed software in a non-standard prefix. Alternatively, you may set the environment variables GTK_CFLAGS and GTK_LIBS to avoid the need to call pkg-config. See the pkg-config man page for more details." "$LINENO" 5 elif test $pkg_failed = untried; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} as_fn_error $? "The pkg-config script could not be found or is too old. Make sure it is in your PATH or set the PKG_CONFIG environment variable to the full path to pkg-config. Alternatively, you may set the environment variables GTK_CFLAGS and GTK_LIBS to avoid the need to call pkg-config. See the pkg-config man page for more details. To get pkg-config, see . See \`config.log' for more details" "$LINENO" 5; } else GTK_CFLAGS=$pkg_cv_GTK_CFLAGS GTK_LIBS=$pkg_cv_GTK_LIBS { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 $as_echo "yes" >&6; } fi # Check whether --enable-gtktest was given. if test "${enable_gtktest+set}" = set; then : enableval=$enable_gtktest; else enable_gtktest=yes fi min_gtk_version=3.24.24 pkg_config_args="gtk+-3.0 >= $min_gtk_version" for module in . do case "$module" in gthread) pkg_config_args="$pkg_config_args gthread-2.0" ;; esac done no_gtk="" if test "x$ac_cv_env_PKG_CONFIG_set" != "xset"; then if test -n "$ac_tool_prefix"; then # Extract the first word of "${ac_tool_prefix}pkg-config", so it can be a program name with args. set dummy ${ac_tool_prefix}pkg-config; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if ${ac_cv_path_PKG_CONFIG+:} false; then : $as_echo_n "(cached) " >&6 else case $PKG_CONFIG in [\\/]* | ?:[\\/]*) ac_cv_path_PKG_CONFIG="$PKG_CONFIG" # Let the user override the test with a path. ;; *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_path_PKG_CONFIG="$as_dir/$ac_word$ac_exec_ext" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS ;; esac fi PKG_CONFIG=$ac_cv_path_PKG_CONFIG if test -n "$PKG_CONFIG"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PKG_CONFIG" >&5 $as_echo "$PKG_CONFIG" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi fi if test -z "$ac_cv_path_PKG_CONFIG"; then ac_pt_PKG_CONFIG=$PKG_CONFIG # Extract the first word of "pkg-config", so it can be a program name with args. set dummy pkg-config; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if ${ac_cv_path_ac_pt_PKG_CONFIG+:} false; then : $as_echo_n "(cached) " >&6 else case $ac_pt_PKG_CONFIG in [\\/]* | ?:[\\/]*) ac_cv_path_ac_pt_PKG_CONFIG="$ac_pt_PKG_CONFIG" # Let the user override the test with a path. ;; *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_path_ac_pt_PKG_CONFIG="$as_dir/$ac_word$ac_exec_ext" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS ;; esac fi ac_pt_PKG_CONFIG=$ac_cv_path_ac_pt_PKG_CONFIG if test -n "$ac_pt_PKG_CONFIG"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_pt_PKG_CONFIG" >&5 $as_echo "$ac_pt_PKG_CONFIG" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi if test "x$ac_pt_PKG_CONFIG" = x; then PKG_CONFIG="" else case $cross_compiling:$ac_tool_warned in yes:) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac PKG_CONFIG=$ac_pt_PKG_CONFIG fi else PKG_CONFIG="$ac_cv_path_PKG_CONFIG" fi fi if test -n "$PKG_CONFIG"; then _pkg_min_version=0.16 { $as_echo "$as_me:${as_lineno-$LINENO}: checking pkg-config is at least version $_pkg_min_version" >&5 $as_echo_n "checking pkg-config is at least version $_pkg_min_version... " >&6; } if $PKG_CONFIG --atleast-pkgconfig-version $_pkg_min_version; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 $as_echo "yes" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } PKG_CONFIG="" fi fi if test -z "$PKG_CONFIG"; then no_gtk=yes fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking for GTK+ - version >= $min_gtk_version" >&5 $as_echo_n "checking for GTK+ - version >= $min_gtk_version... " >&6; } if test -n "$PKG_CONFIG"; then ## don't try to run the test against uninstalled libtool libs if $PKG_CONFIG --uninstalled $pkg_config_args; then echo "Will use uninstalled version of GTK+ found in PKG_CONFIG_PATH" enable_gtktest=no fi if $PKG_CONFIG $pkg_config_args; then : else no_gtk=yes fi fi if test x"$no_gtk" = x ; then GTK_CFLAGS=`$PKG_CONFIG $pkg_config_args --cflags` GTK_LIBS=`$PKG_CONFIG $pkg_config_args --libs` gtk_config_major_version=`$PKG_CONFIG --modversion gtk+-3.0 | \ sed 's/\([0-9]*\).\([0-9]*\).\([0-9]*\)/\1/'` gtk_config_minor_version=`$PKG_CONFIG --modversion gtk+-3.0 | \ sed 's/\([0-9]*\).\([0-9]*\).\([0-9]*\)/\2/'` gtk_config_micro_version=`$PKG_CONFIG --modversion gtk+-3.0 | \ sed 's/\([0-9]*\).\([0-9]*\).\([0-9]*\)/\3/'` if test "x$enable_gtktest" = "xyes" ; then ac_save_CFLAGS="$CFLAGS" ac_save_LIBS="$LIBS" CFLAGS="$CFLAGS $GTK_CFLAGS" LIBS="$GTK_LIBS $LIBS" rm -f conf.gtktest if test "$cross_compiling" = yes; then : echo $ac_n "cross compiling; assumed OK... $ac_c" else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include #include #include int main () { unsigned int major, minor, micro; fclose (fopen ("conf.gtktest", "w")); if (sscanf("$min_gtk_version", "%u.%u.%u", &major, &minor, µ) != 3) { printf("%s, bad version string\n", "$min_gtk_version"); exit(1); } if ((gtk_major_version != $gtk_config_major_version) || (gtk_minor_version != $gtk_config_minor_version) || (gtk_micro_version != $gtk_config_micro_version)) { printf("\n*** 'pkg-config --modversion gtk+-3.0' returned %d.%d.%d, but GTK+ (%d.%d.%d)\n", $gtk_config_major_version, $gtk_config_minor_version, $gtk_config_micro_version, gtk_major_version, gtk_minor_version, gtk_micro_version); printf ("*** was found! If pkg-config was correct, then it is best\n"); printf ("*** to remove the old version of GTK+. You may also be able to fix the error\n"); printf("*** by modifying your LD_LIBRARY_PATH enviroment variable, or by editing\n"); printf("*** /etc/ld.so.conf. Make sure you have run ldconfig if that is\n"); printf("*** required on your system.\n"); printf("*** If pkg-config was wrong, set the environment variable PKG_CONFIG_PATH\n"); printf("*** to point to the correct configuration files\n"); } else if ((gtk_major_version != GTK_MAJOR_VERSION) || (gtk_minor_version != GTK_MINOR_VERSION) || (gtk_micro_version != GTK_MICRO_VERSION)) { printf("*** GTK+ header files (version %d.%d.%d) do not match\n", GTK_MAJOR_VERSION, GTK_MINOR_VERSION, GTK_MICRO_VERSION); printf("*** library (version %d.%d.%d)\n", gtk_major_version, gtk_minor_version, gtk_micro_version); } else { if ((gtk_major_version > major) || ((gtk_major_version == major) && (gtk_minor_version > minor)) || ((gtk_major_version == major) && (gtk_minor_version == minor) && (gtk_micro_version >= micro))) { return 0; } else { printf("\n*** An old version of GTK+ (%u.%u.%u) was found.\n", gtk_major_version, gtk_minor_version, gtk_micro_version); printf("*** You need a version of GTK+ newer than %u.%u.%u. The latest version of\n", major, minor, micro); printf("*** GTK+ is always available from ftp://ftp.gtk.org.\n"); printf("***\n"); printf("*** If you have already installed a sufficiently new version, this error\n"); printf("*** probably means that the wrong copy of the pkg-config shell script is\n"); printf("*** being found. The easiest way to fix this is to remove the old version\n"); printf("*** of GTK+, but you can also set the PKG_CONFIG environment to point to the\n"); printf("*** correct copy of pkg-config. (In this case, you will have to\n"); printf("*** modify your LD_LIBRARY_PATH enviroment variable, or edit /etc/ld.so.conf\n"); printf("*** so that the correct libraries are found at run-time))\n"); } } return 1; } _ACEOF if ac_fn_c_try_run "$LINENO"; then : else no_gtk=yes fi rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \ conftest.$ac_objext conftest.beam conftest.$ac_ext fi CFLAGS="$ac_save_CFLAGS" LIBS="$ac_save_LIBS" fi fi if test "x$no_gtk" = x ; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes (version $gtk_config_major_version.$gtk_config_minor_version.$gtk_config_micro_version)" >&5 $as_echo "yes (version $gtk_config_major_version.$gtk_config_minor_version.$gtk_config_micro_version)" >&6; } : else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } if test -z "$PKG_CONFIG"; then echo "*** A new enough version of pkg-config was not found." echo "*** See http://pkgconfig.sourceforge.net" else if test -f conf.gtktest ; then : else echo "*** Could not run GTK+ test program, checking why..." ac_save_CFLAGS="$CFLAGS" ac_save_LIBS="$LIBS" CFLAGS="$CFLAGS $GTK_CFLAGS" LIBS="$LIBS $GTK_LIBS" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include #include int main () { return ((gtk_major_version) || (gtk_minor_version) || (gtk_micro_version)); ; return 0; } _ACEOF if ac_fn_c_try_link "$LINENO"; then : echo "*** The test program compiled, but did not run. This usually means" echo "*** that the run-time linker is not finding GTK+ or finding the wrong" echo "*** version of GTK+. If it is not finding GTK+, you'll need to set your" echo "*** LD_LIBRARY_PATH environment variable, or edit /etc/ld.so.conf to point" echo "*** to the installed location Also, make sure you have run ldconfig if that" echo "*** is required on your system" echo "***" echo "*** If you have an old version installed, it is best to remove it, although" echo "*** you may also be able to get things to work by modifying LD_LIBRARY_PATH" else echo "*** The test program failed to compile or link. See the file config.log for the" echo "*** exact error that occurred. This usually means GTK+ is incorrectly installed." fi rm -f core conftest.err conftest.$ac_objext \ conftest$ac_exeext conftest.$ac_ext CFLAGS="$ac_save_CFLAGS" LIBS="$ac_save_LIBS" fi fi GTK_CFLAGS="" GTK_LIBS="" : fi rm -f conf.gtktest GTK_PREFIX=`$PKG_CONFIG gtk+-3.0 --variable=prefix` value=$GTK_CFLAGS # Special handling on darwin for gcc 4.5 and 4.7 case "$build_os" in *darwin*) value=`echo $value | sed -e "s/-framework \([^ ]*\)/-Wl,-framework -Wl,\1/g"` esac output=GTK_CFLAGS_GPR result="" for v in $value; do if test "$result" != ""; then result="$result, " fi result="$result\"$v\"" done GTK_CFLAGS_GPR=$result pkg_failed=no { $as_echo "$as_me:${as_lineno-$LINENO}: checking for GMODULE" >&5 $as_echo_n "checking for GMODULE... " >&6; } if test -n "$GMODULE_CFLAGS"; then pkg_cv_GMODULE_CFLAGS="$GMODULE_CFLAGS" elif test -n "$PKG_CONFIG"; then if test -n "$PKG_CONFIG" && \ { { $as_echo "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"\"gmodule-2.0\"\""; } >&5 ($PKG_CONFIG --exists --print-errors ""gmodule-2.0"") 2>&5 ac_status=$? $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; }; then pkg_cv_GMODULE_CFLAGS=`$PKG_CONFIG --cflags ""gmodule-2.0"" 2>/dev/null` test "x$?" != "x0" && pkg_failed=yes else pkg_failed=yes fi else pkg_failed=untried fi if test -n "$GMODULE_LIBS"; then pkg_cv_GMODULE_LIBS="$GMODULE_LIBS" elif test -n "$PKG_CONFIG"; then if test -n "$PKG_CONFIG" && \ { { $as_echo "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"\"gmodule-2.0\"\""; } >&5 ($PKG_CONFIG --exists --print-errors ""gmodule-2.0"") 2>&5 ac_status=$? $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; }; then pkg_cv_GMODULE_LIBS=`$PKG_CONFIG --libs ""gmodule-2.0"" 2>/dev/null` test "x$?" != "x0" && pkg_failed=yes else pkg_failed=yes fi else pkg_failed=untried fi if test $pkg_failed = yes; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } if $PKG_CONFIG --atleast-pkgconfig-version 0.20; then _pkg_short_errors_supported=yes else _pkg_short_errors_supported=no fi if test $_pkg_short_errors_supported = yes; then GMODULE_PKG_ERRORS=`$PKG_CONFIG --short-errors --print-errors --cflags --libs ""gmodule-2.0"" 2>&1` else GMODULE_PKG_ERRORS=`$PKG_CONFIG --print-errors --cflags --libs ""gmodule-2.0"" 2>&1` fi # Put the nasty error message in config.log where it belongs echo "$GMODULE_PKG_ERRORS" >&5 as_fn_error $? "Package requirements (\"gmodule-2.0\") were not met: $GMODULE_PKG_ERRORS Consider adjusting the PKG_CONFIG_PATH environment variable if you installed software in a non-standard prefix. Alternatively, you may set the environment variables GMODULE_CFLAGS and GMODULE_LIBS to avoid the need to call pkg-config. See the pkg-config man page for more details." "$LINENO" 5 elif test $pkg_failed = untried; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} as_fn_error $? "The pkg-config script could not be found or is too old. Make sure it is in your PATH or set the PKG_CONFIG environment variable to the full path to pkg-config. Alternatively, you may set the environment variables GMODULE_CFLAGS and GMODULE_LIBS to avoid the need to call pkg-config. See the pkg-config man page for more details. To get pkg-config, see . See \`config.log' for more details" "$LINENO" 5; } else GMODULE_CFLAGS=$pkg_cv_GMODULE_CFLAGS GMODULE_LIBS=$pkg_cv_GMODULE_LIBS { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 $as_echo "yes" >&6; } fi pkg_failed=no { $as_echo "$as_me:${as_lineno-$LINENO}: checking for FONTCONFIG" >&5 $as_echo_n "checking for FONTCONFIG... " >&6; } if test -n "$FONTCONFIG_CFLAGS"; then pkg_cv_FONTCONFIG_CFLAGS="$FONTCONFIG_CFLAGS" elif test -n "$PKG_CONFIG"; then if test -n "$PKG_CONFIG" && \ { { $as_echo "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"\"fontconfig\"\""; } >&5 ($PKG_CONFIG --exists --print-errors ""fontconfig"") 2>&5 ac_status=$? $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; }; then pkg_cv_FONTCONFIG_CFLAGS=`$PKG_CONFIG --cflags ""fontconfig"" 2>/dev/null` test "x$?" != "x0" && pkg_failed=yes else pkg_failed=yes fi else pkg_failed=untried fi if test -n "$FONTCONFIG_LIBS"; then pkg_cv_FONTCONFIG_LIBS="$FONTCONFIG_LIBS" elif test -n "$PKG_CONFIG"; then if test -n "$PKG_CONFIG" && \ { { $as_echo "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"\"fontconfig\"\""; } >&5 ($PKG_CONFIG --exists --print-errors ""fontconfig"") 2>&5 ac_status=$? $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; }; then pkg_cv_FONTCONFIG_LIBS=`$PKG_CONFIG --libs ""fontconfig"" 2>/dev/null` test "x$?" != "x0" && pkg_failed=yes else pkg_failed=yes fi else pkg_failed=untried fi if test $pkg_failed = yes; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } if $PKG_CONFIG --atleast-pkgconfig-version 0.20; then _pkg_short_errors_supported=yes else _pkg_short_errors_supported=no fi if test $_pkg_short_errors_supported = yes; then FONTCONFIG_PKG_ERRORS=`$PKG_CONFIG --short-errors --print-errors --cflags --libs ""fontconfig"" 2>&1` else FONTCONFIG_PKG_ERRORS=`$PKG_CONFIG --print-errors --cflags --libs ""fontconfig"" 2>&1` fi # Put the nasty error message in config.log where it belongs echo "$FONTCONFIG_PKG_ERRORS" >&5 as_fn_error $? "Package requirements (\"fontconfig\") were not met: $FONTCONFIG_PKG_ERRORS Consider adjusting the PKG_CONFIG_PATH environment variable if you installed software in a non-standard prefix. Alternatively, you may set the environment variables FONTCONFIG_CFLAGS and FONTCONFIG_LIBS to avoid the need to call pkg-config. See the pkg-config man page for more details." "$LINENO" 5 elif test $pkg_failed = untried; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} as_fn_error $? "The pkg-config script could not be found or is too old. Make sure it is in your PATH or set the PKG_CONFIG environment variable to the full path to pkg-config. Alternatively, you may set the environment variables FONTCONFIG_CFLAGS and FONTCONFIG_LIBS to avoid the need to call pkg-config. See the pkg-config man page for more details. To get pkg-config, see . See \`config.log' for more details" "$LINENO" 5; } else FONTCONFIG_CFLAGS=$pkg_cv_FONTCONFIG_CFLAGS FONTCONFIG_LIBS=$pkg_cv_FONTCONFIG_LIBS { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 $as_echo "yes" >&6; } fi GTK_LIBS="$GTK_LIBS $GMODULE_LIBS $FONTCONFIG_LIBS" case $build_os in *mingw*) GTK_LIBS="-L../../lib -L../../bin $GTK_LIBS";; esac value=$GTK_LIBS # Special handling on darwin for gcc 4.5 and 4.7 case "$build_os" in *darwin*) value=`echo $value | sed -e "s/-framework \([^ ]*\)/-Wl,-framework -Wl,\1/g"` esac output=GTK_LIBS_GPR result="" for v in $value; do if test "$result" != ""; then result="$result, " fi result="$result\"$v\"" done GTK_LIBS_GPR=$result # Ignore user's choice of libdir, as well as configure's own default, # because we want GtkAda to always install in /lib (backward compatibility) libdir='${prefix}/lib' ac_config_files="$ac_config_files Makefile gtkada_shared.gpr po/Makefile docs/gtkada_rm/html/static/index.html" cat >confcache <<\_ACEOF # This file is a shell script that caches the results of configure # tests run on this system so they can be shared between configure # scripts and configure runs, see configure's option --config-cache. # It is not useful on other systems. If it contains results you don't # want to keep, you may remove or edit it. # # config.status only pays attention to the cache file if you give it # the --recheck option to rerun configure. # # `ac_cv_env_foo' variables (set or unset) will be overridden when # loading this file, other *unset* `ac_cv_foo' will be assigned the # following values. _ACEOF # The following way of writing the cache mishandles newlines in values, # but we know of no workaround that is simple, portable, and efficient. # So, we kill variables containing newlines. # Ultrix sh set writes to stderr and can't be redirected directly, # and sets the high bit in the cache file unless we assign to the vars. ( for ac_var in `(set) 2>&1 | sed -n 's/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'`; do eval ac_val=\$$ac_var case $ac_val in #( *${as_nl}*) case $ac_var in #( *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5 $as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;; esac case $ac_var in #( _ | IFS | as_nl) ;; #( BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #( *) { eval $ac_var=; unset $ac_var;} ;; esac ;; esac done (set) 2>&1 | case $as_nl`(ac_space=' '; set) 2>&1` in #( *${as_nl}ac_space=\ *) # `set' does not quote correctly, so add quotes: double-quote # substitution turns \\\\ into \\, and sed turns \\ into \. sed -n \ "s/'/'\\\\''/g; s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p" ;; #( *) # `set' quotes correctly as required by POSIX, so do not add quotes. sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p" ;; esac | sort ) | sed ' /^ac_cv_env_/b end t clear :clear s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/ t end s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/ :end' >>confcache if diff "$cache_file" confcache >/dev/null 2>&1; then :; else if test -w "$cache_file"; then if test "x$cache_file" != "x/dev/null"; then { $as_echo "$as_me:${as_lineno-$LINENO}: updating cache $cache_file" >&5 $as_echo "$as_me: updating cache $cache_file" >&6;} if test ! -f "$cache_file" || test -h "$cache_file"; then cat confcache >"$cache_file" else case $cache_file in #( */* | ?:*) mv -f confcache "$cache_file"$$ && mv -f "$cache_file"$$ "$cache_file" ;; #( *) mv -f confcache "$cache_file" ;; esac fi fi else { $as_echo "$as_me:${as_lineno-$LINENO}: not updating unwritable cache $cache_file" >&5 $as_echo "$as_me: not updating unwritable cache $cache_file" >&6;} fi fi rm -f confcache test "x$prefix" = xNONE && prefix=$ac_default_prefix # Let make expand exec_prefix. test "x$exec_prefix" = xNONE && exec_prefix='${prefix}' # Transform confdefs.h into DEFS. # Protect against shell expansion while executing Makefile rules. # Protect against Makefile macro expansion. # # If the first sed substitution is executed (which looks for macros that # take arguments), then branch to the quote section. Otherwise, # look for a macro that doesn't take arguments. ac_script=' :mline /\\$/{ N s,\\\n,, b mline } t clear :clear s/^[ ]*#[ ]*define[ ][ ]*\([^ (][^ (]*([^)]*)\)[ ]*\(.*\)/-D\1=\2/g t quote s/^[ ]*#[ ]*define[ ][ ]*\([^ ][^ ]*\)[ ]*\(.*\)/-D\1=\2/g t quote b any :quote s/[ `~#$^&*(){}\\|;'\''"<>?]/\\&/g s/\[/\\&/g s/\]/\\&/g s/\$/$$/g H :any ${ g s/^\n// s/\n/ /g p } ' DEFS=`sed -n "$ac_script" confdefs.h` ac_libobjs= ac_ltlibobjs= U= for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue # 1. Remove the extension, and $U if already installed. ac_script='s/\$U\././;s/\.o$//;s/\.obj$//' ac_i=`$as_echo "$ac_i" | sed "$ac_script"` # 2. Prepend LIBOBJDIR. When used with automake>=1.10 LIBOBJDIR # will be set to the directory where LIBOBJS objects are built. as_fn_append ac_libobjs " \${LIBOBJDIR}$ac_i\$U.$ac_objext" as_fn_append ac_ltlibobjs " \${LIBOBJDIR}$ac_i"'$U.lo' done LIBOBJS=$ac_libobjs LTLIBOBJS=$ac_ltlibobjs : "${CONFIG_STATUS=./config.status}" ac_write_fail=0 ac_clean_files_save=$ac_clean_files ac_clean_files="$ac_clean_files $CONFIG_STATUS" { $as_echo "$as_me:${as_lineno-$LINENO}: creating $CONFIG_STATUS" >&5 $as_echo "$as_me: creating $CONFIG_STATUS" >&6;} as_write_fail=0 cat >$CONFIG_STATUS <<_ASEOF || as_write_fail=1 #! $SHELL # Generated by $as_me. # Run this file to recreate the current configuration. # Compiler output produced by configure, useful for debugging # configure, is in config.log if it exists. debug=false ac_cs_recheck=false ac_cs_silent=false SHELL=\${CONFIG_SHELL-$SHELL} export SHELL _ASEOF cat >>$CONFIG_STATUS <<\_ASEOF || as_write_fail=1 ## -------------------- ## ## M4sh Initialization. ## ## -------------------- ## # Be more Bourne compatible DUALCASE=1; export DUALCASE # for MKS sh if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then : emulate sh NULLCMD=: # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which # is contrary to our usage. Disable this feature. alias -g '${1+"$@"}'='"$@"' setopt NO_GLOB_SUBST else case `(set -o) 2>/dev/null` in #( *posix*) : set -o posix ;; #( *) : ;; esac fi as_nl=' ' export as_nl # Printing a long string crashes Solaris 7 /usr/bin/printf. as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo # Prefer a ksh shell builtin over an external printf program on Solaris, # but without wasting forks for bash or zsh. if test -z "$BASH_VERSION$ZSH_VERSION" \ && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then as_echo='print -r --' as_echo_n='print -rn --' elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then as_echo='printf %s\n' as_echo_n='printf %s' else if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"' as_echo_n='/usr/ucb/echo -n' else as_echo_body='eval expr "X$1" : "X\\(.*\\)"' as_echo_n_body='eval arg=$1; case $arg in #( *"$as_nl"*) expr "X$arg" : "X\\(.*\\)$as_nl"; arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;; esac; expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl" ' export as_echo_n_body as_echo_n='sh -c $as_echo_n_body as_echo' fi export as_echo_body as_echo='sh -c $as_echo_body as_echo' fi # The user is always right. if test "${PATH_SEPARATOR+set}" != set; then PATH_SEPARATOR=: (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && { (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 || PATH_SEPARATOR=';' } fi # IFS # We need space, tab and new line, in precisely that order. Quoting is # there to prevent editors from complaining about space-tab. # (If _AS_PATH_WALK were called with IFS unset, it would disable word # splitting by setting IFS to empty value.) IFS=" "" $as_nl" # Find who we are. Look in the path if we contain no directory separator. as_myself= case $0 in #(( *[\\/]* ) as_myself=$0 ;; *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break done IFS=$as_save_IFS ;; esac # We did not find ourselves, most probably we were run as `sh COMMAND' # in which case we are not to be found in the path. if test "x$as_myself" = x; then as_myself=$0 fi if test ! -f "$as_myself"; then $as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2 exit 1 fi # Unset variables that we do not need and which cause bugs (e.g. in # pre-3.0 UWIN ksh). But do not cause bugs in bash 2.01; the "|| exit 1" # suppresses any "Segmentation fault" message there. '((' could # trigger a bug in pdksh 5.2.14. for as_var in BASH_ENV ENV MAIL MAILPATH do eval test x\${$as_var+set} = xset \ && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || : done PS1='$ ' PS2='> ' PS4='+ ' # NLS nuisances. LC_ALL=C export LC_ALL LANGUAGE=C export LANGUAGE # CDPATH. (unset CDPATH) >/dev/null 2>&1 && unset CDPATH # as_fn_error STATUS ERROR [LINENO LOG_FD] # ---------------------------------------- # Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are # provided, also output the error to LOG_FD, referencing LINENO. Then exit the # script with STATUS, using 1 if that was 0. as_fn_error () { as_status=$1; test $as_status -eq 0 && as_status=1 if test "$4"; then as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack $as_echo "$as_me:${as_lineno-$LINENO}: error: $2" >&$4 fi $as_echo "$as_me: error: $2" >&2 as_fn_exit $as_status } # as_fn_error # as_fn_set_status STATUS # ----------------------- # Set $? to STATUS, without forking. as_fn_set_status () { return $1 } # as_fn_set_status # as_fn_exit STATUS # ----------------- # Exit the shell with STATUS, even in a "trap 0" or "set -e" context. as_fn_exit () { set +e as_fn_set_status $1 exit $1 } # as_fn_exit # as_fn_unset VAR # --------------- # Portably unset VAR. as_fn_unset () { { eval $1=; unset $1;} } as_unset=as_fn_unset # as_fn_append VAR VALUE # ---------------------- # Append the text in VALUE to the end of the definition contained in VAR. Take # advantage of any shell optimizations that allow amortized linear growth over # repeated appends, instead of the typical quadratic growth present in naive # implementations. if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then : eval 'as_fn_append () { eval $1+=\$2 }' else as_fn_append () { eval $1=\$$1\$2 } fi # as_fn_append # as_fn_arith ARG... # ------------------ # Perform arithmetic evaluation on the ARGs, and store the result in the # global $as_val. Take advantage of shells that can avoid forks. The arguments # must be portable across $(()) and expr. if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then : eval 'as_fn_arith () { as_val=$(( $* )) }' else as_fn_arith () { as_val=`expr "$@" || test $? -eq 1` } fi # as_fn_arith if expr a : '\(a\)' >/dev/null 2>&1 && test "X`expr 00001 : '.*\(...\)'`" = X001; then as_expr=expr else as_expr=false fi if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then as_basename=basename else as_basename=false fi if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then as_dirname=dirname else as_dirname=false fi as_me=`$as_basename -- "$0" || $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \ X"$0" : 'X\(//\)$' \| \ X"$0" : 'X\(/\)' \| . 2>/dev/null || $as_echo X/"$0" | sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/ q } /^X\/\(\/\/\)$/{ s//\1/ q } /^X\/\(\/\).*/{ s//\1/ q } s/.*/./; q'` # Avoid depending upon Character Ranges. as_cr_letters='abcdefghijklmnopqrstuvwxyz' as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ' as_cr_Letters=$as_cr_letters$as_cr_LETTERS as_cr_digits='0123456789' as_cr_alnum=$as_cr_Letters$as_cr_digits ECHO_C= ECHO_N= ECHO_T= case `echo -n x` in #((((( -n*) case `echo 'xy\c'` in *c*) ECHO_T=' ';; # ECHO_T is single tab character. xy) ECHO_C='\c';; *) echo `echo ksh88 bug on AIX 6.1` > /dev/null ECHO_T=' ';; esac;; *) ECHO_N='-n';; esac rm -f conf$$ conf$$.exe conf$$.file if test -d conf$$.dir; then rm -f conf$$.dir/conf$$.file else rm -f conf$$.dir mkdir conf$$.dir 2>/dev/null fi if (echo >conf$$.file) 2>/dev/null; then if ln -s conf$$.file conf$$ 2>/dev/null; then as_ln_s='ln -s' # ... but there are two gotchas: # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail. # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable. # In both cases, we have to default to `cp -pR'. ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe || as_ln_s='cp -pR' elif ln conf$$.file conf$$ 2>/dev/null; then as_ln_s=ln else as_ln_s='cp -pR' fi else as_ln_s='cp -pR' fi rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file rmdir conf$$.dir 2>/dev/null # as_fn_mkdir_p # ------------- # Create "$as_dir" as a directory, including parents if necessary. as_fn_mkdir_p () { case $as_dir in #( -*) as_dir=./$as_dir;; esac test -d "$as_dir" || eval $as_mkdir_p || { as_dirs= while :; do case $as_dir in #( *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'( *) as_qdir=$as_dir;; esac as_dirs="'$as_qdir' $as_dirs" as_dir=`$as_dirname -- "$as_dir" || $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ X"$as_dir" : 'X\(//\)[^/]' \| \ X"$as_dir" : 'X\(//\)$' \| \ X"$as_dir" : 'X\(/\)' \| . 2>/dev/null || $as_echo X"$as_dir" | sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/ q } /^X\(\/\/\)[^/].*/{ s//\1/ q } /^X\(\/\/\)$/{ s//\1/ q } /^X\(\/\).*/{ s//\1/ q } s/.*/./; q'` test -d "$as_dir" && break done test -z "$as_dirs" || eval "mkdir $as_dirs" } || test -d "$as_dir" || as_fn_error $? "cannot create directory $as_dir" } # as_fn_mkdir_p if mkdir -p . 2>/dev/null; then as_mkdir_p='mkdir -p "$as_dir"' else test -d ./-p && rmdir ./-p as_mkdir_p=false fi # as_fn_executable_p FILE # ----------------------- # Test if FILE is an executable regular file. as_fn_executable_p () { test -f "$1" && test -x "$1" } # as_fn_executable_p as_test_x='test -x' as_executable_p=as_fn_executable_p # Sed expression to map a string onto a valid CPP name. as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'" # Sed expression to map a string onto a valid variable name. as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'" exec 6>&1 ## ----------------------------------- ## ## Main body of $CONFIG_STATUS script. ## ## ----------------------------------- ## _ASEOF test $as_write_fail = 0 && chmod +x $CONFIG_STATUS || ac_write_fail=1 cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 # Save the log message, to keep $0 and so on meaningful, and to # report actual input values of CONFIG_FILES etc. instead of their # values after options handling. ac_log=" This file was extended by gtkada $as_me 18.0w, which was generated by GNU Autoconf 2.69. Invocation command line was CONFIG_FILES = $CONFIG_FILES CONFIG_HEADERS = $CONFIG_HEADERS CONFIG_LINKS = $CONFIG_LINKS CONFIG_COMMANDS = $CONFIG_COMMANDS $ $0 $@ on `(hostname || uname -n) 2>/dev/null | sed 1q` " _ACEOF case $ac_config_files in *" "*) set x $ac_config_files; shift; ac_config_files=$*;; esac cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 # Files that config.status was made for. config_files="$ac_config_files" _ACEOF cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 ac_cs_usage="\ \`$as_me' instantiates files and other configuration actions from templates according to the current configuration. Unless the files and actions are specified as TAGs, all are instantiated by default. Usage: $0 [OPTION]... [TAG]... -h, --help print this help, then exit -V, --version print version number and configuration settings, then exit --config print configuration, then exit -q, --quiet, --silent do not print progress messages -d, --debug don't remove temporary files --recheck update $as_me by reconfiguring in the same conditions --file=FILE[:TEMPLATE] instantiate the configuration file FILE Configuration files: $config_files Report bugs to ." _ACEOF cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 ac_cs_config="`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`" ac_cs_version="\\ gtkada config.status 18.0w configured by $0, generated by GNU Autoconf 2.69, with options \\"\$ac_cs_config\\" Copyright (C) 2012 Free Software Foundation, Inc. This config.status script is free software; the Free Software Foundation gives unlimited permission to copy, distribute and modify it." ac_pwd='$ac_pwd' srcdir='$srcdir' test -n "\$AWK" || AWK=awk _ACEOF cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 # The default lists apply if the user does not specify any file. ac_need_defaults=: while test $# != 0 do case $1 in --*=?*) ac_option=`expr "X$1" : 'X\([^=]*\)='` ac_optarg=`expr "X$1" : 'X[^=]*=\(.*\)'` ac_shift=: ;; --*=) ac_option=`expr "X$1" : 'X\([^=]*\)='` ac_optarg= ac_shift=: ;; *) ac_option=$1 ac_optarg=$2 ac_shift=shift ;; esac case $ac_option in # Handling of the options. -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r) ac_cs_recheck=: ;; --version | --versio | --versi | --vers | --ver | --ve | --v | -V ) $as_echo "$ac_cs_version"; exit ;; --config | --confi | --conf | --con | --co | --c ) $as_echo "$ac_cs_config"; exit ;; --debug | --debu | --deb | --de | --d | -d ) debug=: ;; --file | --fil | --fi | --f ) $ac_shift case $ac_optarg in *\'*) ac_optarg=`$as_echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;; '') as_fn_error $? "missing file argument" ;; esac as_fn_append CONFIG_FILES " '$ac_optarg'" ac_need_defaults=false;; --he | --h | --help | --hel | -h ) $as_echo "$ac_cs_usage"; exit ;; -q | -quiet | --quiet | --quie | --qui | --qu | --q \ | -silent | --silent | --silen | --sile | --sil | --si | --s) ac_cs_silent=: ;; # This is an error. -*) as_fn_error $? "unrecognized option: \`$1' Try \`$0 --help' for more information." ;; *) as_fn_append ac_config_targets " $1" ac_need_defaults=false ;; esac shift done ac_configure_extra_args= if $ac_cs_silent; then exec 6>/dev/null ac_configure_extra_args="$ac_configure_extra_args --silent" fi _ACEOF cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 if \$ac_cs_recheck; then set X $SHELL '$0' $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion shift \$as_echo "running CONFIG_SHELL=$SHELL \$*" >&6 CONFIG_SHELL='$SHELL' export CONFIG_SHELL exec "\$@" fi _ACEOF cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 exec 5>>config.log { echo sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX ## Running $as_me. ## _ASBOX $as_echo "$ac_log" } >&5 _ACEOF cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 _ACEOF cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 # Handling of arguments. for ac_config_target in $ac_config_targets do case $ac_config_target in "Makefile") CONFIG_FILES="$CONFIG_FILES Makefile" ;; "gtkada_shared.gpr") CONFIG_FILES="$CONFIG_FILES gtkada_shared.gpr" ;; "po/Makefile") CONFIG_FILES="$CONFIG_FILES po/Makefile" ;; "docs/gtkada_rm/html/static/index.html") CONFIG_FILES="$CONFIG_FILES docs/gtkada_rm/html/static/index.html" ;; *) as_fn_error $? "invalid argument: \`$ac_config_target'" "$LINENO" 5;; esac done # If the user did not use the arguments to specify the items to instantiate, # then the envvar interface is used. Set only those that are not. # We use the long form for the default assignment because of an extremely # bizarre bug on SunOS 4.1.3. if $ac_need_defaults; then test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files fi # Have a temporary directory for convenience. Make it in the build tree # simply because there is no reason against having it here, and in addition, # creating and moving files from /tmp can sometimes cause problems. # Hook for its removal unless debugging. # Note that there is a small window in which the directory will not be cleaned: # after its creation but before its name has been assigned to `$tmp'. $debug || { tmp= ac_tmp= trap 'exit_status=$? : "${ac_tmp:=$tmp}" { test ! -d "$ac_tmp" || rm -fr "$ac_tmp"; } && exit $exit_status ' 0 trap 'as_fn_exit 1' 1 2 13 15 } # Create a (secure) tmp directory for tmp files. { tmp=`(umask 077 && mktemp -d "./confXXXXXX") 2>/dev/null` && test -d "$tmp" } || { tmp=./conf$$-$RANDOM (umask 077 && mkdir "$tmp") } || as_fn_error $? "cannot create a temporary directory in ." "$LINENO" 5 ac_tmp=$tmp # Set up the scripts for CONFIG_FILES section. # No need to generate them if there are no CONFIG_FILES. # This happens for instance with `./config.status config.h'. if test -n "$CONFIG_FILES"; then ac_cr=`echo X | tr X '\015'` # On cygwin, bash can eat \r inside `` if the user requested igncr. # But we know of no other shell where ac_cr would be empty at this # point, so we can use a bashism as a fallback. if test "x$ac_cr" = x; then eval ac_cr=\$\'\\r\' fi ac_cs_awk_cr=`$AWK 'BEGIN { print "a\rb" }' /dev/null` if test "$ac_cs_awk_cr" = "a${ac_cr}b"; then ac_cs_awk_cr='\\r' else ac_cs_awk_cr=$ac_cr fi echo 'BEGIN {' >"$ac_tmp/subs1.awk" && _ACEOF { echo "cat >conf$$subs.awk <<_ACEOF" && echo "$ac_subst_vars" | sed 's/.*/&!$&$ac_delim/' && echo "_ACEOF" } >conf$$subs.sh || as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5 ac_delim_num=`echo "$ac_subst_vars" | grep -c '^'` ac_delim='%!_!# ' for ac_last_try in false false false false false :; do . ./conf$$subs.sh || as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5 ac_delim_n=`sed -n "s/.*$ac_delim\$/X/p" conf$$subs.awk | grep -c X` if test $ac_delim_n = $ac_delim_num; then break elif $ac_last_try; then as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5 else ac_delim="$ac_delim!$ac_delim _$ac_delim!! " fi done rm -f conf$$subs.sh cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 cat >>"\$ac_tmp/subs1.awk" <<\\_ACAWK && _ACEOF sed -n ' h s/^/S["/; s/!.*/"]=/ p g s/^[^!]*!// :repl t repl s/'"$ac_delim"'$// t delim :nl h s/\(.\{148\}\)..*/\1/ t more1 s/["\\]/\\&/g; s/^/"/; s/$/\\n"\\/ p n b repl :more1 s/["\\]/\\&/g; s/^/"/; s/$/"\\/ p g s/.\{148\}// t nl :delim h s/\(.\{148\}\)..*/\1/ t more2 s/["\\]/\\&/g; s/^/"/; s/$/"/ p b :more2 s/["\\]/\\&/g; s/^/"/; s/$/"\\/ p g s/.\{148\}// t delim ' >$CONFIG_STATUS || ac_write_fail=1 rm -f conf$$subs.awk cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 _ACAWK cat >>"\$ac_tmp/subs1.awk" <<_ACAWK && for (key in S) S_is_set[key] = 1 FS = "" } { line = $ 0 nfields = split(line, field, "@") substed = 0 len = length(field[1]) for (i = 2; i < nfields; i++) { key = field[i] keylen = length(key) if (S_is_set[key]) { value = S[key] line = substr(line, 1, len) "" value "" substr(line, len + keylen + 3) len += length(value) + length(field[++i]) substed = 1 } else len += 1 + keylen } print line } _ACAWK _ACEOF cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 if sed "s/$ac_cr//" < /dev/null > /dev/null 2>&1; then sed "s/$ac_cr\$//; s/$ac_cr/$ac_cs_awk_cr/g" else cat fi < "$ac_tmp/subs1.awk" > "$ac_tmp/subs.awk" \ || as_fn_error $? "could not setup config files machinery" "$LINENO" 5 _ACEOF # VPATH may cause trouble with some makes, so we remove sole $(srcdir), # ${srcdir} and @srcdir@ entries from VPATH if srcdir is ".", strip leading and # trailing colons and then remove the whole line if VPATH becomes empty # (actually we leave an empty line to preserve line numbers). if test "x$srcdir" = x.; then ac_vpsub='/^[ ]*VPATH[ ]*=[ ]*/{ h s/// s/^/:/ s/[ ]*$/:/ s/:\$(srcdir):/:/g s/:\${srcdir}:/:/g s/:@srcdir@:/:/g s/^:*// s/:*$// x s/\(=[ ]*\).*/\1/ G s/\n// s/^[^=]*=[ ]*$// }' fi cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 fi # test -n "$CONFIG_FILES" eval set X " :F $CONFIG_FILES " shift for ac_tag do case $ac_tag in :[FHLC]) ac_mode=$ac_tag; continue;; esac case $ac_mode$ac_tag in :[FHL]*:*);; :L* | :C*:*) as_fn_error $? "invalid tag \`$ac_tag'" "$LINENO" 5;; :[FH]-) ac_tag=-:-;; :[FH]*) ac_tag=$ac_tag:$ac_tag.in;; esac ac_save_IFS=$IFS IFS=: set x $ac_tag IFS=$ac_save_IFS shift ac_file=$1 shift case $ac_mode in :L) ac_source=$1;; :[FH]) ac_file_inputs= for ac_f do case $ac_f in -) ac_f="$ac_tmp/stdin";; *) # Look for the file first in the build tree, then in the source tree # (if the path is not absolute). The absolute path cannot be DOS-style, # because $ac_f cannot contain `:'. test -f "$ac_f" || case $ac_f in [\\/$]*) false;; *) test -f "$srcdir/$ac_f" && ac_f="$srcdir/$ac_f";; esac || as_fn_error 1 "cannot find input file: \`$ac_f'" "$LINENO" 5;; esac case $ac_f in *\'*) ac_f=`$as_echo "$ac_f" | sed "s/'/'\\\\\\\\''/g"`;; esac as_fn_append ac_file_inputs " '$ac_f'" done # Let's still pretend it is `configure' which instantiates (i.e., don't # use $as_me), people would be surprised to read: # /* config.h. Generated by config.status. */ configure_input='Generated from '` $as_echo "$*" | sed 's|^[^:]*/||;s|:[^:]*/|, |g' `' by configure.' if test x"$ac_file" != x-; then configure_input="$ac_file. $configure_input" { $as_echo "$as_me:${as_lineno-$LINENO}: creating $ac_file" >&5 $as_echo "$as_me: creating $ac_file" >&6;} fi # Neutralize special characters interpreted by sed in replacement strings. case $configure_input in #( *\&* | *\|* | *\\* ) ac_sed_conf_input=`$as_echo "$configure_input" | sed 's/[\\\\&|]/\\\\&/g'`;; #( *) ac_sed_conf_input=$configure_input;; esac case $ac_tag in *:-:* | *:-) cat >"$ac_tmp/stdin" \ || as_fn_error $? "could not create $ac_file" "$LINENO" 5 ;; esac ;; esac ac_dir=`$as_dirname -- "$ac_file" || $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ X"$ac_file" : 'X\(//\)[^/]' \| \ X"$ac_file" : 'X\(//\)$' \| \ X"$ac_file" : 'X\(/\)' \| . 2>/dev/null || $as_echo X"$ac_file" | sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/ q } /^X\(\/\/\)[^/].*/{ s//\1/ q } /^X\(\/\/\)$/{ s//\1/ q } /^X\(\/\).*/{ s//\1/ q } s/.*/./; q'` as_dir="$ac_dir"; as_fn_mkdir_p ac_builddir=. case "$ac_dir" in .) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;; *) ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'` # A ".." for each directory in $ac_dir_suffix. ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'` case $ac_top_builddir_sub in "") ac_top_builddir_sub=. ac_top_build_prefix= ;; *) ac_top_build_prefix=$ac_top_builddir_sub/ ;; esac ;; esac ac_abs_top_builddir=$ac_pwd ac_abs_builddir=$ac_pwd$ac_dir_suffix # for backward compatibility: ac_top_builddir=$ac_top_build_prefix case $srcdir in .) # We are building in place. ac_srcdir=. ac_top_srcdir=$ac_top_builddir_sub ac_abs_top_srcdir=$ac_pwd ;; [\\/]* | ?:[\\/]* ) # Absolute name. ac_srcdir=$srcdir$ac_dir_suffix; ac_top_srcdir=$srcdir ac_abs_top_srcdir=$srcdir ;; *) # Relative name. ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix ac_top_srcdir=$ac_top_build_prefix$srcdir ac_abs_top_srcdir=$ac_pwd/$srcdir ;; esac ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix case $ac_mode in :F) # # CONFIG_FILE # _ACEOF cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 # If the template does not know about datarootdir, expand it. # FIXME: This hack should be removed a few years after 2.60. ac_datarootdir_hack=; ac_datarootdir_seen= ac_sed_dataroot=' /datarootdir/ { p q } /@datadir@/p /@docdir@/p /@infodir@/p /@localedir@/p /@mandir@/p' case `eval "sed -n \"\$ac_sed_dataroot\" $ac_file_inputs"` in *datarootdir*) ac_datarootdir_seen=yes;; *@datadir@*|*@docdir@*|*@infodir@*|*@localedir@*|*@mandir@*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&5 $as_echo "$as_me: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&2;} _ACEOF cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 ac_datarootdir_hack=' s&@datadir@&$datadir&g s&@docdir@&$docdir&g s&@infodir@&$infodir&g s&@localedir@&$localedir&g s&@mandir@&$mandir&g s&\\\${datarootdir}&$datarootdir&g' ;; esac _ACEOF # Neutralize VPATH when `$srcdir' = `.'. # Shell code in configure.ac might set extrasub. # FIXME: do we really want to maintain this feature? cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 ac_sed_extra="$ac_vpsub $extrasub _ACEOF cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 :t /@[a-zA-Z_][a-zA-Z_0-9]*@/!b s|@configure_input@|$ac_sed_conf_input|;t t s&@top_builddir@&$ac_top_builddir_sub&;t t s&@top_build_prefix@&$ac_top_build_prefix&;t t s&@srcdir@&$ac_srcdir&;t t s&@abs_srcdir@&$ac_abs_srcdir&;t t s&@top_srcdir@&$ac_top_srcdir&;t t s&@abs_top_srcdir@&$ac_abs_top_srcdir&;t t s&@builddir@&$ac_builddir&;t t s&@abs_builddir@&$ac_abs_builddir&;t t s&@abs_top_builddir@&$ac_abs_top_builddir&;t t $ac_datarootdir_hack " eval sed \"\$ac_sed_extra\" "$ac_file_inputs" | $AWK -f "$ac_tmp/subs.awk" \ >$ac_tmp/out || as_fn_error $? "could not create $ac_file" "$LINENO" 5 test -z "$ac_datarootdir_hack$ac_datarootdir_seen" && { ac_out=`sed -n '/\${datarootdir}/p' "$ac_tmp/out"`; test -n "$ac_out"; } && { ac_out=`sed -n '/^[ ]*datarootdir[ ]*:*=/p' \ "$ac_tmp/out"`; test -z "$ac_out"; } && { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file contains a reference to the variable \`datarootdir' which seems to be undefined. Please make sure it is defined" >&5 $as_echo "$as_me: WARNING: $ac_file contains a reference to the variable \`datarootdir' which seems to be undefined. Please make sure it is defined" >&2;} rm -f "$ac_tmp/stdin" case $ac_file in -) cat "$ac_tmp/out" && rm -f "$ac_tmp/out";; *) rm -f "$ac_file" && mv "$ac_tmp/out" "$ac_file";; esac \ || as_fn_error $? "could not create $ac_file" "$LINENO" 5 ;; esac done # for ac_tag as_fn_exit 0 _ACEOF ac_clean_files=$ac_clean_files_save test $ac_write_fail = 0 || as_fn_error $? "write failure creating $CONFIG_STATUS" "$LINENO" 5 # configure is writing to config.log, and then calls config.status. # config.status does its own redirection, appending to config.log. # Unfortunately, on DOS this fails, as config.log is still kept open # by configure, so config.status won't be able to write to it; its # output is simply discarded. So we exec the FD to /dev/null, # effectively closing config.log, so it can be properly (re)opened and # appended to by config.status. When coming back to configure, we # need to make the FD available again. if test "$no_create" != yes; then ac_cs_success=: ac_config_status_args= test "$silent" = yes && ac_config_status_args="$ac_config_status_args --quiet" exec 5>/dev/null $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false exec 5>>config.log # Use ||, not &&, to avoid exiting from the if with $? = 1, which # would make configure fail if this is the last instruction. $ac_cs_success || as_fn_exit 1 fi if test -n "$ac_unrecognized_opts" && test "$enable_option_checking" != no; then { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: unrecognized options: $ac_unrecognized_opts" >&5 $as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2;} fi { $as_echo "$as_me:${as_lineno-$LINENO}: --------- Summary for Gtkada $PACKAGE_VERSION -----------------" >&5 $as_echo "$as_me: --------- Summary for Gtkada $PACKAGE_VERSION -----------------" >&6;} { $as_echo "$as_me:${as_lineno-$LINENO}: Shared libraries: $CAN_BUILD_SHARED (default: $DEFAULT_LIBRARY_TYPE)" >&5 $as_echo "$as_me: Shared libraries: $CAN_BUILD_SHARED (default: $DEFAULT_LIBRARY_TYPE)" >&6;} { $as_echo "$as_me:${as_lineno-$LINENO}: --------------------------------------------" >&5 $as_echo "$as_me: --------------------------------------------" >&6;} gtkada-24.0.0/configure.ac000066400000000000000000000024721446021174000153220ustar00rootroot00000000000000AC_INIT(gtkada,18.0w,report@adacore.com,gtkada) AC_CONFIG_MACRO_DIR([m4]) AC_CANONICAL_TARGET PKG_PROG_PKG_CONFIG TARGET="" if test x$host != x$target ; then TARGET=${target} fi AC_SUBST(TARGET) AM_ADD_OS_SPECIFIC_FLAGS # checking for local tools AC_PROG_CC case $build_os in *darwin*) AC_PROG_OBJC(clang gcc CC) ;; *) OBJC=""; AC_SUBST(OBJC) ;; esac AM_PATH_GNAT CHECK_BUILD_TYPE # are we in devel mode ? # Gettext stuff ALL_LINGUAS="en" AM_GNU_GETTEXT([external]) # checking for gtk: # 1. PKG_CHECK_MODULES: check for pkg-config modules, this provides useful # diagnostic when some error occured. # 2. AM_PATH_GTK: check for low level binary interface of the libraries and # create necessary variables to substitute into .gpr files. PKG_CHECK_MODULES([GTK], [gtk+-3.0]) AM_PATH_GTK # Ignore user's choice of libdir, as well as configure's own default, # because we want GtkAda to always install in /lib (backward compatibility) libdir='${prefix}/lib' AC_OUTPUT(Makefile gtkada_shared.gpr po/Makefile docs/gtkada_rm/html/static/index.html) AC_MSG_NOTICE([--------- Summary for Gtkada $PACKAGE_VERSION -----------------]) AC_MSG_NOTICE(AC_HELP_STRING( [Shared libraries:],[$CAN_BUILD_SHARED (default: $DEFAULT_LIBRARY_TYPE)])) AC_MSG_NOTICE([--------------------------------------------]) gtkada-24.0.0/contrib/000077500000000000000000000000001446021174000144675ustar00rootroot00000000000000gtkada-24.0.0/contrib/GLib-2.0.gir000066400000000000000000101250461446021174000163150ustar00rootroot00000000000000 Integer representing a day of the month; between 1 and 31. #G_DATE_BAD_DAY represents an invalid day of the month. Integer representing a year; #G_DATE_BAD_YEAR is the invalid value. The year must be 1 or higher; negative (BC) years are not allowed. The year is represented with four digits. A type which is used to hold a process identification. On UNIX, processes are identified by a process id (an integer), while Windows uses process handles (which are pointers). GPid is used in GLib only for descendant processes spawned with the g_spawn functions. A GQuark is a non-zero integer which uniquely identifies a particular string. A GQuark value of zero is associated to %NULL. A C representable type name for #G_TYPE_STRV. Simply a replacement for time_t. It has been deprecated since it is not equivalent to time_t on 64-bit platforms with a 64-bit time_t. Unrelated to #GTimer. Note that #GTime is defined to always be a 32-bit integer, unlike time_t which may be 64-bit on some systems. Therefore, #GTime will overflow in the year 2038, and you cannot use the address of a #GTime variable as argument to the UNIX time() function. Instead, do the following: |[<!-- language="C" --> time_t ttime; GTime gtime; time (&ttime); gtime = (GTime)ttime; ]| A value representing an interval of time, in microseconds. A good size for a buffer to be passed into g_ascii_dtostr(). It is guaranteed to be enough for all output of that function on systems with 64bit IEEE-compatible doubles. The typical usage would be something like: |[<!-- language="C" --> char buf[G_ASCII_DTOSTR_BUF_SIZE]; fprintf (out, "value=%s\n", g_ascii_dtostr (buf, sizeof (buf), value)); ]| Contains the public fields of a GArray. a pointer to the element data. The data may be moved as elements are added to the #GArray. the number of elements in the #GArray not including the possible terminating zero element. Adds @len elements onto the end of the array. the #GArray a #GArray a pointer to the elements to append to the end of the array the number of elements to append Frees the memory allocated for the #GArray. If @free_segment is %TRUE it frees the memory block holding the elements as well and also each element if @array has a @element_free_func set. Pass %FALSE if you want to free the #GArray wrapper but preserve the underlying array for use elsewhere. If the reference count of @array is greater than one, the #GArray wrapper is preserved but the size of @array will be set to zero. If array elements contain dynamically-allocated memory, they should be freed separately. the element data if @free_segment is %FALSE, otherwise %NULL. The element data should be freed using g_free(). a #GArray if %TRUE the actual element data is freed as well Gets the size of the elements in @array. Size of each element, in bytes A #GArray Inserts @len elements into a #GArray at the given index. the #GArray a #GArray the index to place the elements at a pointer to the elements to insert the number of elements to insert Creates a new #GArray with a reference count of 1. the new #GArray %TRUE if the array should have an extra element at the end which is set to 0 %TRUE if #GArray elements should be automatically cleared to 0 when they are allocated the size of each element in bytes Adds @len elements onto the start of the array. This operation is slower than g_array_append_vals() since the existing elements in the array have to be moved to make space for the new elements. the #GArray a #GArray a pointer to the elements to prepend to the start of the array the number of elements to prepend Atomically increments the reference count of @array by one. This function is MT-safe and may be called from any thread. The passed in #GArray A #GArray Removes the element at the given index from a #GArray. The following elements are moved down one place. the #GArray a #GArray the index of the element to remove Removes the element at the given index from a #GArray. The last element in the array is used to fill in the space, so this function does not preserve the order of the #GArray. But it is faster than g_array_remove_index(). the #GArray a @GArray the index of the element to remove Removes the given number of elements starting at the given index from a #GArray. The following elements are moved to close the gap. the #GArray a @GArray the index of the first element to remove the number of elements to remove Sets a function to clear an element of @array. The @clear_func will be called when an element in the array data segment is removed and when the array is freed and data segment is deallocated as well. Note that in contrast with other uses of #GDestroyNotify functions, @clear_func is expected to clear the contents of the array element it is given, but not free the element itself. A #GArray a function to clear an element of @array Sets the size of the array, expanding it if necessary. If the array was created with @clear_ set to %TRUE, the new elements are set to 0. the #GArray a #GArray the new size of the #GArray Creates a new #GArray with @reserved_size elements preallocated and a reference count of 1. This avoids frequent reallocation, if you are going to add many elements to the array. Note however that the size of the array is still 0. the new #GArray %TRUE if the array should have an extra element at the end with all bits cleared %TRUE if all bits in the array should be cleared to 0 on allocation size of each element in the array number of elements preallocated Sorts a #GArray using @compare_func which should be a qsort()-style comparison function (returns less than zero for first arg is less than second arg, zero for equal, greater zero if first arg is greater than second arg). This is guaranteed to be a stable sort since version 2.32. a #GArray comparison function Like g_array_sort(), but the comparison function receives an extra user data argument. This is guaranteed to be a stable sort since version 2.32. There used to be a comment here about making the sort stable by using the addresses of the elements in the comparison function. This did not actually work, so any such code should be removed. a #GArray comparison function data to pass to @compare_func Atomically decrements the reference count of @array by one. If the reference count drops to 0, all memory allocated by the array is released. This function is MT-safe and may be called from any thread. A #GArray The GAsyncQueue struct is an opaque data structure which represents an asynchronous queue. It should only be accessed through the g_async_queue_* functions. Returns the length of the queue. Actually this function returns the number of data items in the queue minus the number of waiting threads, so a negative value means waiting threads, and a positive value means available entries in the @queue. A return value of 0 could mean n entries in the queue and n threads waiting. This can happen due to locking of the queue or due to scheduling. the length of the @queue a #GAsyncQueue. Returns the length of the queue. Actually this function returns the number of data items in the queue minus the number of waiting threads, so a negative value means waiting threads, and a positive value means available entries in the @queue. A return value of 0 could mean n entries in the queue and n threads waiting. This can happen due to locking of the queue or due to scheduling. This function must be called while holding the @queue's lock. the length of the @queue. a #GAsyncQueue Acquires the @queue's lock. If another thread is already holding the lock, this call will block until the lock becomes available. Call g_async_queue_unlock() to drop the lock again. While holding the lock, you can only call the g_async_queue_*_unlocked() functions on @queue. Otherwise, deadlock may occur. a #GAsyncQueue Pops data from the @queue. If @queue is empty, this function blocks until data becomes available. data from the queue a #GAsyncQueue Pops data from the @queue. If @queue is empty, this function blocks until data becomes available. This function must be called while holding the @queue's lock. data from the queue. a #GAsyncQueue Pushes the @data into the @queue. @data must not be %NULL. a #GAsyncQueue @data to push into the @queue Inserts @data into @queue using @func to determine the new position. This function requires that the @queue is sorted before pushing on new elements, see g_async_queue_sort(). This function will lock @queue before it sorts the queue and unlock it when it is finished. For an example of @func see g_async_queue_sort(). a #GAsyncQueue the @data to push into the @queue the #GCompareDataFunc is used to sort @queue user data passed to @func. Inserts @data into @queue using @func to determine the new position. The sort function @func is passed two elements of the @queue. It should return 0 if they are equal, a negative value if the first element should be higher in the @queue or a positive value if the first element should be lower in the @queue than the second element. This function requires that the @queue is sorted before pushing on new elements, see g_async_queue_sort(). This function must be called while holding the @queue's lock. For an example of @func see g_async_queue_sort(). a #GAsyncQueue the @data to push into the @queue the #GCompareDataFunc is used to sort @queue user data passed to @func. Pushes the @data into the @queue. @data must not be %NULL. This function must be called while holding the @queue's lock. a #GAsyncQueue @data to push into the @queue Increases the reference count of the asynchronous @queue by 1. You do not need to hold the lock to call this function. the @queue that was passed in (since 2.6) a #GAsyncQueue Increases the reference count of the asynchronous @queue by 1. Reference counting is done atomically. so g_async_queue_ref() can be used regardless of the @queue's lock. a #GAsyncQueue Sorts @queue using @func. The sort function @func is passed two elements of the @queue. It should return 0 if they are equal, a negative value if the first element should be higher in the @queue or a positive value if the first element should be lower in the @queue than the second element. This function will lock @queue before it sorts the queue and unlock it when it is finished. If you were sorting a list of priority numbers to make sure the lowest priority would be at the top of the queue, you could use: |[<!-- language="C" --> gint32 id1; gint32 id2; id1 = GPOINTER_TO_INT (element1); id2 = GPOINTER_TO_INT (element2); return (id1 > id2 ? +1 : id1 == id2 ? 0 : -1); ]| a #GAsyncQueue the #GCompareDataFunc is used to sort @queue user data passed to @func Sorts @queue using @func. The sort function @func is passed two elements of the @queue. It should return 0 if they are equal, a negative value if the first element should be higher in the @queue or a positive value if the first element should be lower in the @queue than the second element. This function must be called while holding the @queue's lock. a #GAsyncQueue the #GCompareDataFunc is used to sort @queue user data passed to @func Pops data from the @queue. If the queue is empty, blocks until @end_time or until data becomes available. If no data is received before @end_time, %NULL is returned. To easily calculate @end_time, a combination of g_get_current_time() and g_time_val_add() can be used. use g_async_queue_timeout_pop(). data from the queue or %NULL, when no data is received before @end_time. a #GAsyncQueue a #GTimeVal, determining the final time Pops data from the @queue. If the queue is empty, blocks until @end_time or until data becomes available. If no data is received before @end_time, %NULL is returned. To easily calculate @end_time, a combination of g_get_current_time() and g_time_val_add() can be used. This function must be called while holding the @queue's lock. use g_async_queue_timeout_pop_unlocked(). data from the queue or %NULL, when no data is received before @end_time. a #GAsyncQueue a #GTimeVal, determining the final time Pops data from the @queue. If the queue is empty, blocks for @timeout microseconds, or until data becomes available. If no data is received before the timeout, %NULL is returned. data from the queue or %NULL, when no data is received before the timeout. a #GAsyncQueue the number of microseconds to wait Pops data from the @queue. If the queue is empty, blocks for @timeout microseconds, or until data becomes available. If no data is received before the timeout, %NULL is returned. This function must be called while holding the @queue's lock. data from the queue or %NULL, when no data is received before the timeout. a #GAsyncQueue the number of microseconds to wait Tries to pop data from the @queue. If no data is available, %NULL is returned. data from the queue or %NULL, when no data is available immediately. a #GAsyncQueue Tries to pop data from the @queue. If no data is available, %NULL is returned. This function must be called while holding the @queue's lock. data from the queue or %NULL, when no data is available immediately. a #GAsyncQueue Releases the queue's lock. Calling this function when you have not acquired the with g_async_queue_lock() leads to undefined behaviour. a #GAsyncQueue Decreases the reference count of the asynchronous @queue by 1. If the reference count went to 0, the @queue will be destroyed and the memory allocated will be freed. So you are not allowed to use the @queue afterwards, as it might have disappeared. You do not need to hold the lock to call this function. a #GAsyncQueue. Decreases the reference count of the asynchronous @queue by 1 and releases the lock. This function must be called while holding the @queue's lock. If the reference count went to 0, the @queue will be destroyed and the memory allocated will be freed. Reference counting is done atomically. so g_async_queue_unref() can be used regardless of the @queue's lock. a #GAsyncQueue Creates a new asynchronous queue. a new #GAsyncQueue. Free with g_async_queue_unref() Creates a new asynchronous queue and sets up a destroy notify function that is used to free any remaining queue items when the queue is destroyed after the final unref. a new #GAsyncQueue. Free with g_async_queue_unref() function to free queue elements Specifies one of the possible types of byte order. See #G_BYTE_ORDER. The `GBookmarkFile` structure contains only private data and should not be directly accessed. Adds the application with @name and @exec to the list of applications that have registered a bookmark for @uri into @bookmark. Every bookmark inside a #GBookmarkFile must have at least an application registered. Each application must provide a name, a command line useful for launching the bookmark, the number of times the bookmark has been registered by the application and the last time the application registered this bookmark. If @name is %NULL, the name of the application will be the same returned by g_get_application_name(); if @exec is %NULL, the command line will be a composition of the program name as returned by g_get_prgname() and the "\%u" modifier, which will be expanded to the bookmark's URI. This function will automatically take care of updating the registrations count and timestamping in case an application with the same @name had already registered a bookmark for @uri inside @bookmark. If no bookmark for @uri is found, one is created. a #GBookmarkFile a valid URI the name of the application registering the bookmark or %NULL command line to be used to launch the bookmark or %NULL Adds @group to the list of groups to which the bookmark for @uri belongs to. If no bookmark for @uri is found then it is created. a #GBookmarkFile a valid URI the group name to be added Frees a #GBookmarkFile. a #GBookmarkFile Gets the time the bookmark for @uri was added to @bookmark In the event the URI cannot be found, -1 is returned and @error is set to #G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND. a timestamp a #GBookmarkFile a valid URI Gets the registration informations of @app_name for the bookmark for @uri. See g_bookmark_file_set_app_info() for more informations about the returned data. The string returned in @app_exec must be freed. In the event the URI cannot be found, %FALSE is returned and @error is set to #G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND. In the event that no application with name @app_name has registered a bookmark for @uri, %FALSE is returned and error is set to #G_BOOKMARK_FILE_ERROR_APP_NOT_REGISTERED. In the event that unquoting the command line fails, an error of the #G_SHELL_ERROR domain is set and %FALSE is returned. %TRUE on success. a #GBookmarkFile a valid URI an application's name return location for the command line of the application, or %NULL return location for the registration count, or %NULL return location for the last registration time, or %NULL Retrieves the names of the applications that have registered the bookmark for @uri. In the event the URI cannot be found, %NULL is returned and @error is set to #G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND. a newly allocated %NULL-terminated array of strings. Use g_strfreev() to free it. a #GBookmarkFile a valid URI return location of the length of the returned list, or %NULL Retrieves the description of the bookmark for @uri. In the event the URI cannot be found, %NULL is returned and @error is set to #G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND. a newly allocated string or %NULL if the specified URI cannot be found. a #GBookmarkFile a valid URI Retrieves the list of group names of the bookmark for @uri. In the event the URI cannot be found, %NULL is returned and @error is set to #G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND. The returned array is %NULL terminated, so @length may optionally be %NULL. a newly allocated %NULL-terminated array of group names. Use g_strfreev() to free it. a #GBookmarkFile a valid URI return location for the length of the returned string, or %NULL Gets the icon of the bookmark for @uri. In the event the URI cannot be found, %FALSE is returned and @error is set to #G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND. %TRUE if the icon for the bookmark for the URI was found. You should free the returned strings. a #GBookmarkFile a valid URI return location for the icon's location or %NULL return location for the icon's MIME type or %NULL Gets whether the private flag of the bookmark for @uri is set. In the event the URI cannot be found, %FALSE is returned and @error is set to #G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND. In the event that the private flag cannot be found, %FALSE is returned and @error is set to #G_BOOKMARK_FILE_ERROR_INVALID_VALUE. %TRUE if the private flag is set, %FALSE otherwise. a #GBookmarkFile a valid URI Retrieves the MIME type of the resource pointed by @uri. In the event the URI cannot be found, %NULL is returned and @error is set to #G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND. In the event that the MIME type cannot be found, %NULL is returned and @error is set to #G_BOOKMARK_FILE_ERROR_INVALID_VALUE. a newly allocated string or %NULL if the specified URI cannot be found. a #GBookmarkFile a valid URI Gets the time when the bookmark for @uri was last modified. In the event the URI cannot be found, -1 is returned and @error is set to #G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND. a timestamp a #GBookmarkFile a valid URI Gets the number of bookmarks inside @bookmark. the number of bookmarks a #GBookmarkFile Returns the title of the bookmark for @uri. If @uri is %NULL, the title of @bookmark is returned. In the event the URI cannot be found, %NULL is returned and @error is set to #G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND. a newly allocated string or %NULL if the specified URI cannot be found. a #GBookmarkFile a valid URI or %NULL Returns all URIs of the bookmarks in the bookmark file @bookmark. The array of returned URIs will be %NULL-terminated, so @length may optionally be %NULL. a newly allocated %NULL-terminated array of strings. Use g_strfreev() to free it. a #GBookmarkFile return location for the number of returned URIs, or %NULL Gets the time the bookmark for @uri was last visited. In the event the URI cannot be found, -1 is returned and @error is set to #G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND. a timestamp. a #GBookmarkFile a valid URI Checks whether the bookmark for @uri inside @bookmark has been registered by application @name. In the event the URI cannot be found, %FALSE is returned and @error is set to #G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND. %TRUE if the application @name was found a #GBookmarkFile a valid URI the name of the application Checks whether @group appears in the list of groups to which the bookmark for @uri belongs to. In the event the URI cannot be found, %FALSE is returned and @error is set to #G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND. %TRUE if @group was found. a #GBookmarkFile a valid URI the group name to be searched Looks whether the desktop bookmark has an item with its URI set to @uri. %TRUE if @uri is inside @bookmark, %FALSE otherwise a #GBookmarkFile a valid URI Loads a bookmark file from memory into an empty #GBookmarkFile structure. If the object cannot be created then @error is set to a #GBookmarkFileError. %TRUE if a desktop bookmark could be loaded. an empty #GBookmarkFile struct desktop bookmarks loaded in memory the length of @data in bytes This function looks for a desktop bookmark file named @file in the paths returned from g_get_user_data_dir() and g_get_system_data_dirs(), loads the file into @bookmark and returns the file's full path in @full_path. If the file could not be loaded then an %error is set to either a #GFileError or #GBookmarkFileError. %TRUE if a key file could be loaded, %FALSE otherwise a #GBookmarkFile a relative path to a filename to open and parse return location for a string containing the full path of the file, or %NULL Loads a desktop bookmark file into an empty #GBookmarkFile structure. If the file could not be loaded then @error is set to either a #GFileError or #GBookmarkFileError. %TRUE if a desktop bookmark file could be loaded an empty #GBookmarkFile struct the path of a filename to load, in the GLib file name encoding Changes the URI of a bookmark item from @old_uri to @new_uri. Any existing bookmark for @new_uri will be overwritten. If @new_uri is %NULL, then the bookmark is removed. In the event the URI cannot be found, %FALSE is returned and @error is set to #G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND. %TRUE if the URI was successfully changed a #GBookmarkFile a valid URI a valid URI, or %NULL Removes application registered with @name from the list of applications that have registered a bookmark for @uri inside @bookmark. In the event the URI cannot be found, %FALSE is returned and @error is set to #G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND. In the event that no application with name @app_name has registered a bookmark for @uri, %FALSE is returned and error is set to #G_BOOKMARK_FILE_ERROR_APP_NOT_REGISTERED. %TRUE if the application was successfully removed. a #GBookmarkFile a valid URI the name of the application Removes @group from the list of groups to which the bookmark for @uri belongs to. In the event the URI cannot be found, %FALSE is returned and @error is set to #G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND. In the event no group was defined, %FALSE is returned and @error is set to #G_BOOKMARK_FILE_ERROR_INVALID_VALUE. %TRUE if @group was successfully removed. a #GBookmarkFile a valid URI the group name to be removed Removes the bookmark for @uri from the bookmark file @bookmark. %TRUE if the bookmark was removed successfully. a #GBookmarkFile a valid URI Sets the time the bookmark for @uri was added into @bookmark. If no bookmark for @uri is found then it is created. a #GBookmarkFile a valid URI a timestamp or -1 to use the current time Sets the meta-data of application @name inside the list of applications that have registered a bookmark for @uri inside @bookmark. You should rarely use this function; use g_bookmark_file_add_application() and g_bookmark_file_remove_application() instead. @name can be any UTF-8 encoded string used to identify an application. @exec can have one of these two modifiers: "\%f", which will be expanded as the local file name retrieved from the bookmark's URI; "\%u", which will be expanded as the bookmark's URI. The expansion is done automatically when retrieving the stored command line using the g_bookmark_file_get_app_info() function. @count is the number of times the application has registered the bookmark; if is < 0, the current registration count will be increased by one, if is 0, the application with @name will be removed from the list of registered applications. @stamp is the Unix time of the last registration; if it is -1, the current time will be used. If you try to remove an application by setting its registration count to zero, and no bookmark for @uri is found, %FALSE is returned and @error is set to #G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND; similarly, in the event that no application @name has registered a bookmark for @uri, %FALSE is returned and error is set to #G_BOOKMARK_FILE_ERROR_APP_NOT_REGISTERED. Otherwise, if no bookmark for @uri is found, one is created. %TRUE if the application's meta-data was successfully changed. a #GBookmarkFile a valid URI an application's name an application's command line the number of registrations done for this application the time of the last registration for this application Sets @description as the description of the bookmark for @uri. If @uri is %NULL, the description of @bookmark is set. If a bookmark for @uri cannot be found then it is created. a #GBookmarkFile a valid URI or %NULL a string Sets a list of group names for the item with URI @uri. Each previously set group name list is removed. If @uri cannot be found then an item for it is created. a #GBookmarkFile an item's URI an array of group names, or %NULL to remove all groups number of group name values in @groups Sets the icon for the bookmark for @uri. If @href is %NULL, unsets the currently set icon. @href can either be a full URL for the icon file or the icon name following the Icon Naming specification. If no bookmark for @uri is found one is created. a #GBookmarkFile a valid URI the URI of the icon for the bookmark, or %NULL the MIME type of the icon for the bookmark Sets the private flag of the bookmark for @uri. If a bookmark for @uri cannot be found then it is created. a #GBookmarkFile a valid URI %TRUE if the bookmark should be marked as private Sets @mime_type as the MIME type of the bookmark for @uri. If a bookmark for @uri cannot be found then it is created. a #GBookmarkFile a valid URI a MIME type Sets the last time the bookmark for @uri was last modified. If no bookmark for @uri is found then it is created. The "modified" time should only be set when the bookmark's meta-data was actually changed. Every function of #GBookmarkFile that modifies a bookmark also changes the modification time, except for g_bookmark_file_set_visited(). a #GBookmarkFile a valid URI a timestamp or -1 to use the current time Sets @title as the title of the bookmark for @uri inside the bookmark file @bookmark. If @uri is %NULL, the title of @bookmark is set. If a bookmark for @uri cannot be found then it is created. a #GBookmarkFile a valid URI or %NULL a UTF-8 encoded string Sets the time the bookmark for @uri was last visited. If no bookmark for @uri is found then it is created. The "visited" time should only be set if the bookmark was launched, either using the command line retrieved by g_bookmark_file_get_app_info() or by the default application for the bookmark's MIME type, retrieved using g_bookmark_file_get_mime_type(). Changing the "visited" time does not affect the "modified" time. a #GBookmarkFile a valid URI a timestamp or -1 to use the current time This function outputs @bookmark as a string. a newly allocated string holding the contents of the #GBookmarkFile a #GBookmarkFile return location for the length of the returned string, or %NULL This function outputs @bookmark into a file. The write process is guaranteed to be atomic by using g_file_set_contents() internally. %TRUE if the file was successfully written. a #GBookmarkFile path of the output file Creates a new empty #GBookmarkFile object. Use g_bookmark_file_load_from_file(), g_bookmark_file_load_from_data() or g_bookmark_file_load_from_data_dirs() to read an existing bookmark file. an empty #GBookmarkFile Error codes returned by bookmark file parsing. URI was ill-formed a requested field was not found a requested application did not register a bookmark a requested URI was not found document was ill formed the text being parsed was in an unknown encoding an error occurred while writing requested file was not found Contains the public fields of a GByteArray. a pointer to the element data. The data may be moved as elements are added to the #GByteArray the number of elements in the #GByteArray Adds the given bytes to the end of the #GByteArray. The array will grow in size automatically if necessary. the #GByteArray a #GByteArray the byte data to be added the number of bytes to add Frees the memory allocated by the #GByteArray. If @free_segment is %TRUE it frees the actual byte data. If the reference count of @array is greater than one, the #GByteArray wrapper is preserved but the size of @array will be set to zero. the element data if @free_segment is %FALSE, otherwise %NULL. The element data should be freed using g_free(). a #GByteArray if %TRUE the actual byte data is freed as well Transfers the data from the #GByteArray into a new immutable #GBytes. The #GByteArray is freed unless the reference count of @array is greater than one, the #GByteArray wrapper is preserved but the size of @array will be set to zero. This is identical to using g_bytes_new_take() and g_byte_array_free() together. a new immutable #GBytes representing same byte data that was in the array a #GByteArray Creates a new #GByteArray with a reference count of 1. the new #GByteArray Create byte array containing the data. The data will be owned by the array and will be freed with g_free(), i.e. it could be allocated using g_strdup(). a new #GByteArray byte data for the array length of @data Adds the given data to the start of the #GByteArray. The array will grow in size automatically if necessary. the #GByteArray a #GByteArray the byte data to be added the number of bytes to add Atomically increments the reference count of @array by one. This function is thread-safe and may be called from any thread. The passed in #GByteArray A #GByteArray Removes the byte at the given index from a #GByteArray. The following bytes are moved down one place. the #GByteArray a #GByteArray the index of the byte to remove Removes the byte at the given index from a #GByteArray. The last element in the array is used to fill in the space, so this function does not preserve the order of the #GByteArray. But it is faster than g_byte_array_remove_index(). the #GByteArray a #GByteArray the index of the byte to remove Removes the given number of bytes starting at the given index from a #GByteArray. The following elements are moved to close the gap. the #GByteArray a @GByteArray the index of the first byte to remove the number of bytes to remove Sets the size of the #GByteArray, expanding it if necessary. the #GByteArray a #GByteArray the new size of the #GByteArray Creates a new #GByteArray with @reserved_size bytes preallocated. This avoids frequent reallocation, if you are going to add many bytes to the array. Note however that the size of the array is still 0. the new #GByteArray number of bytes preallocated Sorts a byte array, using @compare_func which should be a qsort()-style comparison function (returns less than zero for first arg is less than second arg, zero for equal, greater than zero if first arg is greater than second arg). If two array elements compare equal, their order in the sorted array is undefined. If you want equal elements to keep their order (i.e. you want a stable sort) you can write a comparison function that, if two elements would otherwise compare equal, compares them by their addresses. a #GByteArray comparison function Like g_byte_array_sort(), but the comparison function takes an extra user data argument. a #GByteArray comparison function data to pass to @compare_func Atomically decrements the reference count of @array by one. If the reference count drops to 0, all memory allocated by the array is released. This function is thread-safe and may be called from any thread. A #GByteArray A simple refcounted data type representing an immutable sequence of zero or more bytes from an unspecified origin. The purpose of a #GBytes is to keep the memory region that it holds alive for as long as anyone holds a reference to the bytes. When the last reference count is dropped, the memory is released. Multiple unrelated callers can use byte data in the #GBytes without coordinating their activities, resting assured that the byte data will not change or move while they hold a reference. A #GBytes can come from many different origins that may have different procedures for freeing the memory region. Examples are memory from g_malloc(), from memory slices, from a #GMappedFile or memory from other allocators. #GBytes work well as keys in #GHashTable. Use g_bytes_equal() and g_bytes_hash() as parameters to g_hash_table_new() or g_hash_table_new_full(). #GBytes can also be used as keys in a #GTree by passing the g_bytes_compare() function to g_tree_new(). The data pointed to by this bytes must not be modified. For a mutable array of bytes see #GByteArray. Use g_bytes_unref_to_array() to create a mutable array for a #GBytes sequence. To create an immutable #GBytes from a mutable #GByteArray, use the g_byte_array_free_to_bytes() function. Creates a new #GBytes from @data. @data is copied. If @size is 0, @data may be %NULL. a new #GBytes the data to be used for the bytes the size of @data Creates a new #GBytes from static data. @data must be static (ie: never modified or freed). It may be %NULL if @size is 0. a new #GBytes the data to be used for the bytes the size of @data Creates a new #GBytes from @data. After this call, @data belongs to the bytes and may no longer be modified by the caller. g_free() will be called on @data when the bytes is no longer in use. Because of this @data must have been created by a call to g_malloc(), g_malloc0() or g_realloc() or by one of the many functions that wrap these calls (such as g_new(), g_strdup(), etc). For creating #GBytes with memory from other allocators, see g_bytes_new_with_free_func(). @data may be %NULL if @size is 0. a new #GBytes the data to be used for the bytes the size of @data Creates a #GBytes from @data. When the last reference is dropped, @free_func will be called with the @user_data argument. @data must not be modified after this call is made until @free_func has been called to indicate that the bytes is no longer in use. @data may be %NULL if @size is 0. a new #GBytes the data to be used for the bytes the size of @data the function to call to release the data data to pass to @free_func Compares the two #GBytes values. This function can be used to sort GBytes instances in lexographical order. a negative value if bytes2 is lesser, a positive value if bytes2 is greater, and zero if bytes2 is equal to bytes1 a pointer to a #GBytes a pointer to a #GBytes to compare with @bytes1 Compares the two #GBytes values being pointed to and returns %TRUE if they are equal. This function can be passed to g_hash_table_new() as the @key_equal_func parameter, when using non-%NULL #GBytes pointers as keys in a #GHashTable. %TRUE if the two keys match. a pointer to a #GBytes a pointer to a #GBytes to compare with @bytes1 Get the byte data in the #GBytes. This data should not be modified. This function will always return the same pointer for a given #GBytes. %NULL may be returned if @size is 0. This is not guaranteed, as the #GBytes may represent an empty string with @data non-%NULL and @size as 0. %NULL will not be returned if @size is non-zero. a pointer to the byte data, or %NULL a #GBytes location to return size of byte data Get the size of the byte data in the #GBytes. This function will always return the same value for a given #GBytes. the size a #GBytes Creates an integer hash code for the byte data in the #GBytes. This function can be passed to g_hash_table_new() as the @key_hash_func parameter, when using non-%NULL #GBytes pointers as keys in a #GHashTable. a hash value corresponding to the key. a pointer to a #GBytes key Creates a #GBytes which is a subsection of another #GBytes. The @offset + @length may not be longer than the size of @bytes. A reference to @bytes will be held by the newly created #GBytes until the byte data is no longer needed. a new #GBytes a #GBytes offset which subsection starts at length of subsection Increase the reference count on @bytes. the #GBytes a #GBytes Releases a reference on @bytes. This may result in the bytes being freed. a #GBytes Unreferences the bytes, and returns a new mutable #GByteArray containing the same byte data. As an optimization, the byte data is transferred to the array without copying if this was the last reference to bytes and bytes was created with g_bytes_new(), g_bytes_new_take() or g_byte_array_free_to_bytes(). In all other cases the data is copied. a new mutable #GByteArray containing the same byte data a #GBytes Unreferences the bytes, and returns a pointer the same byte data contents. As an optimization, the byte data is returned without copying if this was the last reference to bytes and bytes was created with g_bytes_new(), g_bytes_new_take() or g_byte_array_free_to_bytes(). In all other cases the data is copied. a pointer to the same byte data, which should be freed with g_free() a #GBytes location to place the length of the returned data The set of uppercase ASCII alphabet characters. Used for specifying valid identifier characters in #GScannerConfig. The set of ASCII digits. Used for specifying valid identifier characters in #GScannerConfig. The set of lowercase ASCII alphabet characters. Used for specifying valid identifier characters in #GScannerConfig. An opaque structure representing a checksumming operation. To create a new GChecksum, use g_checksum_new(). To free a GChecksum, use g_checksum_free(). Creates a new #GChecksum, using the checksum algorithm @checksum_type. If the @checksum_type is not known, %NULL is returned. A #GChecksum can be used to compute the checksum, or digest, of an arbitrary binary blob, using different hashing algorithms. A #GChecksum works by feeding a binary blob through g_checksum_update() until there is data to be checked; the digest can then be extracted using g_checksum_get_string(), which will return the checksum as a hexadecimal string; or g_checksum_get_digest(), which will return a vector of raw bytes. Once either g_checksum_get_string() or g_checksum_get_digest() have been called on a #GChecksum, the checksum will be closed and it won't be possible to call g_checksum_update() on it anymore. the newly created #GChecksum, or %NULL. Use g_checksum_free() to free the memory allocated by it. the desired type of checksum Copies a #GChecksum. If @checksum has been closed, by calling g_checksum_get_string() or g_checksum_get_digest(), the copied checksum will be closed as well. the copy of the passed #GChecksum. Use g_checksum_free() when finished using it. the #GChecksum to copy Frees the memory allocated for @checksum. a #GChecksum Gets the digest from @checksum as a raw binary vector and places it into @buffer. The size of the digest depends on the type of checksum. Once this function has been called, the #GChecksum is closed and can no longer be updated with g_checksum_update(). a #GChecksum output buffer an inout parameter. The caller initializes it to the size of @buffer. After the call it contains the length of the digest. Gets the digest as an hexadecimal string. Once this function has been called the #GChecksum can no longer be updated with g_checksum_update(). The hexadecimal characters will be lower case. the hexadecimal representation of the checksum. The returned string is owned by the checksum and should not be modified or freed. a #GChecksum Resets the state of the @checksum back to its initial state. the #GChecksum to reset Feeds @data into an existing #GChecksum. The checksum must still be open, that is g_checksum_get_string() or g_checksum_get_digest() must not have been called on @checksum. a #GChecksum buffer used to compute the checksum size of the buffer, or -1 if it is a null-terminated string. Gets the length in bytes of digests of type @checksum_type the checksum length, or -1 if @checksum_type is not supported. a #GChecksumType The hashing algorithm to be used by #GChecksum when performing the digest of some data. Note that the #GChecksumType enumeration may be extended at a later date to include new hashing algorithm types. Use the MD5 hashing algorithm Use the SHA-1 hashing algorithm Use the SHA-256 hashing algorithm Use the SHA-512 hashing algorithm Prototype of a #GChildWatchSource callback, called when a child process has exited. To interpret @status, see the documentation for g_spawn_check_exit_status(). the process id of the child process Status information about the child process, encoded in a platform-specific manner user data passed to g_child_watch_add() Specifies the type of a comparison function used to compare two values. The function should return a negative integer if the first value comes before the second, 0 if they are equal, or a positive integer if the first value comes after the second. negative value if @a < @b; zero if @a = @b; positive value if @a > @b a value a value to compare with user data Specifies the type of a comparison function used to compare two values. The function should return a negative integer if the first value comes before the second, 0 if they are equal, or a positive integer if the first value comes after the second. negative value if @a < @b; zero if @a = @b; positive value if @a > @b a value a value to compare with The #GCond struct is an opaque data structure that represents a condition. Threads can block on a #GCond if they find a certain condition to be false. If other threads change the state of this condition they signal the #GCond, and that causes the waiting threads to be woken up. Consider the following example of a shared variable. One or more threads can wait for data to be published to the variable and when another thread publishes the data, it can signal one of the waiting threads to wake up to collect the data. Here is an example for using GCond to block a thread until a condition is satisfied: |[<!-- language="C" --> gpointer current_data = NULL; GMutex data_mutex; GCond data_cond; void push_data (gpointer data) { g_mutex_lock (&data_mutex); current_data = data; g_cond_signal (&data_cond); g_mutex_unlock (&data_mutex); } gpointer pop_data (void) { gpointer data; g_mutex_lock (&data_mutex); while (!current_data) g_cond_wait (&data_cond, &data_mutex); data = current_data; current_data = NULL; g_mutex_unlock (&data_mutex); return data; } ]| Whenever a thread calls pop_data() now, it will wait until current_data is non-%NULL, i.e. until some other thread has called push_data(). The example shows that use of a condition variable must always be paired with a mutex. Without the use of a mutex, there would be a race between the check of @current_data by the while loop in pop_data() and waiting. Specifically, another thread could set @current_data after the check, and signal the cond (with nobody waiting on it) before the first thread goes to sleep. #GCond is specifically useful for its ability to release the mutex and go to sleep atomically. It is also important to use the g_cond_wait() and g_cond_wait_until() functions only inside a loop which checks for the condition to be true. See g_cond_wait() for an explanation of why the condition may not be true even after it returns. If a #GCond is allocated in static storage then it can be used without initialisation. Otherwise, you should call g_cond_init() on it and g_cond_clear() when done. A #GCond should only be accessed via the g_cond_ functions. If threads are waiting for @cond, all of them are unblocked. If no threads are waiting for @cond, this function has no effect. It is good practice to lock the same mutex as the waiting threads while calling this function, though not required. a #GCond Frees the resources allocated to a #GCond with g_cond_init(). This function should not be used with a #GCond that has been statically allocated. Calling g_cond_clear() for a #GCond on which threads are blocking leads to undefined behaviour. an initialised #GCond Initialises a #GCond so that it can be used. This function is useful to initialise a #GCond that has been allocated as part of a larger structure. It is not necessary to initialise a #GCond that has been statically allocated. To undo the effect of g_cond_init() when a #GCond is no longer needed, use g_cond_clear(). Calling g_cond_init() on an already-initialised #GCond leads to undefined behaviour. an uninitialized #GCond If threads are waiting for @cond, at least one of them is unblocked. If no threads are waiting for @cond, this function has no effect. It is good practice to hold the same lock as the waiting thread while calling this function, though not required. a #GCond Atomically releases @mutex and waits until @cond is signalled. When this function returns, @mutex is locked again and owned by the calling thread. When using condition variables, it is possible that a spurious wakeup may occur (ie: g_cond_wait() returns even though g_cond_signal() was not called). It's also possible that a stolen wakeup may occur. This is when g_cond_signal() is called, but another thread acquires @mutex before this thread and modifies the state of the program in such a way that when g_cond_wait() is able to return, the expected condition is no longer met. For this reason, g_cond_wait() must always be used in a loop. See the documentation for #GCond for a complete example. a #GCond a #GMutex that is currently locked Waits until either @cond is signalled or @end_time has passed. As with g_cond_wait() it is possible that a spurious or stolen wakeup could occur. For that reason, waiting on a condition variable should always be in a loop, based on an explicitly-checked predicate. %TRUE is returned if the condition variable was signalled (or in the case of a spurious wakeup). %FALSE is returned if @end_time has passed. The following code shows how to correctly perform a timed wait on a condition variable (extending the example presented in the documentation for #GCond): |[<!-- language="C" --> gpointer pop_data_timed (void) { gint64 end_time; gpointer data; g_mutex_lock (&data_mutex); end_time = g_get_monotonic_time () + 5 * G_TIME_SPAN_SECOND; while (!current_data) if (!g_cond_wait_until (&data_cond, &data_mutex, end_time)) { // timeout has passed. g_mutex_unlock (&data_mutex); return NULL; } // there is data for us data = current_data; current_data = NULL; g_mutex_unlock (&data_mutex); return data; } ]| Notice that the end time is calculated once, before entering the loop and reused. This is the motivation behind the use of absolute time on this API -- if a relative time of 5 seconds were passed directly to the call and a spurious wakeup occurred, the program would have to start over waiting again (which would lead to a total wait time of more than 5 seconds). %TRUE on a signal, %FALSE on a timeout a #GCond a #GMutex that is currently locked the monotonic time to wait until Error codes returned by character set conversion routines. Conversion between the requested character sets is not supported. Invalid byte sequence in conversion input. Conversion failed for some reason. Partial character sequence at end of input. URI is invalid. Pathname is not an absolute path. No memory available. Since: 2.40 A function of this signature is used to copy the node data when doing a deep-copy of a tree. A pointer to the copy A pointer to the data which should be copied Additional data A bitmask that restricts the possible flags passed to g_datalist_set_flags(). Passing a flags value where flags & ~G_DATALIST_FLAGS_MASK != 0 is an error. Represents an invalid #GDateDay. Represents an invalid Julian day number. Represents an invalid year. The directory separator character. This is '/' on UNIX machines and '\' under Windows. The directory separator as a string. This is "/" on UNIX machines and "\" under Windows. The #GData struct is an opaque data structure to represent a [Keyed Data List][glib-Keyed-Data-Lists]. It should only be accessed via the following functions. Specifies the type of function passed to g_dataset_foreach(). It is called with each #GQuark id and associated data element, together with the @user_data parameter supplied to g_dataset_foreach(). the #GQuark id to identifying the data element. the data element. user data passed to g_dataset_foreach(). Represents a day between January 1, Year 1 and a few thousand years in the future. None of its members should be accessed directly. If the #GDate-struct is obtained from g_date_new(), it will be safe to mutate but invalid and thus not safe for calendrical computations. If it's declared on the stack, it will contain garbage so must be initialized with g_date_clear(). g_date_clear() makes the date invalid but sane. An invalid date doesn't represent a day, it's "empty." A date becomes valid after you set it to a Julian day or you set a day, month, and year. the Julian representation of the date this bit is set if @julian_days is valid this is set if @day, @month and @year are valid the day of the day-month-year representation of the date, as a number between 1 and 31 the day of the day-month-year representation of the date, as a number between 1 and 12 the day of the day-month-year representation of the date Allocates a #GDate and initializes it to a sane state. The new date will be cleared (as if you'd called g_date_clear()) but invalid (it won't represent an existing day). Free the return value with g_date_free(). a newly-allocated #GDate Like g_date_new(), but also sets the value of the date. Assuming the day-month-year triplet you pass in represents an existing day, the returned date will be valid. a newly-allocated #GDate initialized with @day, @month, and @year day of the month month of the year year Like g_date_new(), but also sets the value of the date. Assuming the Julian day number you pass in is valid (greater than 0, less than an unreasonably large number), the returned date will be valid. a newly-allocated #GDate initialized with @julian_day days since January 1, Year 1 Increments a date some number of days. To move forward by weeks, add weeks*7 days. The date must be valid. a #GDate to increment number of days to move the date forward Increments a date by some number of months. If the day of the month is greater than 28, this routine may change the day of the month (because the destination month may not have the current day in it). The date must be valid. a #GDate to increment number of months to move forward Increments a date by some number of years. If the date is February 29, and the destination year is not a leap year, the date will be changed to February 28. The date must be valid. a #GDate to increment number of years to move forward If @date is prior to @min_date, sets @date equal to @min_date. If @date falls after @max_date, sets @date equal to @max_date. Otherwise, @date is unchanged. Either of @min_date and @max_date may be %NULL. All non-%NULL dates must be valid. a #GDate to clamp minimum accepted value for @date maximum accepted value for @date Initializes one or more #GDate structs to a sane but invalid state. The cleared dates will not represent an existing date, but will not contain garbage. Useful to init a date declared on the stack. Validity can be tested with g_date_valid(). pointer to one or more dates to clear number of dates to clear qsort()-style comparison function for dates. Both dates must be valid. 0 for equal, less than zero if @lhs is less than @rhs, greater than zero if @lhs is greater than @rhs first date to compare second date to compare Computes the number of days between two dates. If @date2 is prior to @date1, the returned value is negative. Both dates must be valid. the number of days between @date1 and @date2 the first date the second date Frees a #GDate returned from g_date_new(). a #GDate to free Returns the day of the month. The date must be valid. day of the month a #GDate to extract the day of the month from Returns the day of the year, where Jan 1 is the first day of the year. The date must be valid. day of the year a #GDate to extract day of year from Returns the week of the year, where weeks are interpreted according to ISO 8601. ISO 8601 week number of the year. a valid #GDate Returns the Julian day or "serial number" of the #GDate. The Julian day is simply the number of days since January 1, Year 1; i.e., January 1, Year 1 is Julian day 1; January 2, Year 1 is Julian day 2, etc. The date must be valid. Julian day a #GDate to extract the Julian day from Returns the week of the year, where weeks are understood to start on Monday. If the date is before the first Monday of the year, return 0. The date must be valid. week of the year a #GDate Returns the month of the year. The date must be valid. month of the year as a #GDateMonth a #GDate to get the month from Returns the week of the year during which this date falls, if weeks are understood to being on Sunday. The date must be valid. Can return 0 if the day is before the first Sunday of the year. week number a #GDate Returns the day of the week for a #GDate. The date must be valid. day of the week as a #GDateWeekday. a #GDate Returns the year of a #GDate. The date must be valid. year in which the date falls a #GDate Returns %TRUE if the date is on the first of a month. The date must be valid. %TRUE if the date is the first of the month a #GDate to check Returns %TRUE if the date is the last day of the month. The date must be valid. %TRUE if the date is the last day of the month a #GDate to check Checks if @date1 is less than or equal to @date2, and swap the values if this is not the case. the first date the second date Sets the day of the month for a #GDate. If the resulting day-month-year triplet is invalid, the date will be invalid. a #GDate day to set Sets the value of a #GDate from a day, month, and year. The day-month-year triplet must be valid; if you aren't sure it is, call g_date_valid_dmy() to check before you set it. a #GDate day month year Sets the value of a #GDate from a Julian day number. a #GDate Julian day number (days since January 1, Year 1) Sets the month of the year for a #GDate. If the resulting day-month-year triplet is invalid, the date will be invalid. a #GDate month to set Parses a user-inputted string @str, and try to figure out what date it represents, taking the [current locale][setlocale] into account. If the string is successfully parsed, the date will be valid after the call. Otherwise, it will be invalid. You should check using g_date_valid() to see whether the parsing succeeded. This function is not appropriate for file formats and the like; it isn't very precise, and its exact behavior varies with the locale. It's intended to be a heuristic routine that guesses what the user means by a given string (and it does work pretty well in that capacity). a #GDate to fill in string to parse Sets the value of a date from a #GTime value. The time to date conversion is done using the user's current timezone. Use g_date_set_time_t() instead. a #GDate. #GTime value to set. Sets the value of a date to the date corresponding to a time specified as a time_t. The time to date conversion is done using the user's current timezone. To set the value of a date to the current day, you could write: |[<!-- language="C" --> g_date_set_time_t (date, time (NULL)); ]| a #GDate time_t value to set Sets the value of a date from a #GTimeVal value. Note that the @tv_usec member is ignored, because #GDate can't make use of the additional precision. The time to date conversion is done using the user's current timezone. a #GDate #GTimeVal value to set Sets the year for a #GDate. If the resulting day-month-year triplet is invalid, the date will be invalid. a #GDate year to set Moves a date some number of days into the past. To move by weeks, just move by weeks*7 days. The date must be valid. a #GDate to decrement number of days to move Moves a date some number of months into the past. If the current day of the month doesn't exist in the destination month, the day of the month may change. The date must be valid. a #GDate to decrement number of months to move Moves a date some number of years into the past. If the current day doesn't exist in the destination year (i.e. it's February 29 and you move to a non-leap-year) then the day is changed to February 29. The date must be valid. a #GDate to decrement number of years to move Fills in the date-related bits of a struct tm using the @date value. Initializes the non-date parts with something sane but meaningless. a #GDate to set the struct tm from struct tm to fill Returns %TRUE if the #GDate represents an existing day. The date must not contain garbage; it should have been initialized with g_date_clear() if it wasn't allocated by one of the g_date_new() variants. Whether the date is valid a #GDate to check Returns the number of days in a month, taking leap years into account. number of days in @month during the @year month year Returns the number of weeks in the year, where weeks are taken to start on Monday. Will be 52 or 53. The date must be valid. (Years always have 52 7-day periods, plus 1 or 2 extra days depending on whether it's a leap year. This function is basically telling you how many Mondays are in the year, i.e. there are 53 Mondays if one of the extra days happens to be a Monday.) number of Mondays in the year a year Returns the number of weeks in the year, where weeks are taken to start on Sunday. Will be 52 or 53. The date must be valid. (Years always have 52 7-day periods, plus 1 or 2 extra days depending on whether it's a leap year. This function is basically telling you how many Sundays are in the year, i.e. there are 53 Sundays if one of the extra days happens to be a Sunday.) the number of weeks in @year year to count weeks in Returns %TRUE if the year is a leap year. For the purposes of this function, leap year is every year divisible by 4 unless that year is divisible by 100. If it is divisible by 100 it would be a leap year only if that year is also divisible by 400. %TRUE if the year is a leap year year to check Generates a printed representation of the date, in a [locale][setlocale]-specific way. Works just like the platform's C library strftime() function, but only accepts date-related formats; time-related formats give undefined results. Date must be valid. Unlike strftime() (which uses the locale encoding), works on a UTF-8 format string and stores a UTF-8 result. This function does not provide any conversion specifiers in addition to those implemented by the platform's C library. For example, don't expect that using g_date_strftime() would make the \%F provided by the C99 strftime() work on Windows where the C library only complies to C89. number of characters written to the buffer, or 0 the buffer was too small destination buffer buffer size format string valid #GDate Returns %TRUE if the day of the month is valid (a day is valid if it's between 1 and 31 inclusive). %TRUE if the day is valid day to check Returns %TRUE if the day-month-year triplet forms a valid, existing day in the range of days #GDate understands (Year 1 or later, no more than a few thousand years in the future). %TRUE if the date is a valid one day month year Returns %TRUE if the Julian day is valid. Anything greater than zero is basically a valid Julian, though there is a 32-bit limit. %TRUE if the Julian day is valid Julian day to check Returns %TRUE if the month value is valid. The 12 #GDateMonth enumeration values are the only valid months. %TRUE if the month is valid month Returns %TRUE if the weekday is valid. The seven #GDateWeekday enumeration values are the only valid weekdays. %TRUE if the weekday is valid weekday Returns %TRUE if the year is valid. Any year greater than 0 is valid, though there is a 16-bit limit to what #GDate will understand. %TRUE if the year is valid year This enumeration isn't used in the API, but may be useful if you need to mark a number as a day, month, or year. a day a month a year Enumeration representing a month; values are #G_DATE_JANUARY, #G_DATE_FEBRUARY, etc. #G_DATE_BAD_MONTH is the invalid value. invalid value January February March April May June July August September October November December `GDateTime` is an opaque structure whose members cannot be accessed directly. Creates a new #GDateTime corresponding to the given date and time in the time zone @tz. The @year must be between 1 and 9999, @month between 1 and 12 and @day between 1 and 28, 29, 30 or 31 depending on the month and the year. @hour must be between 0 and 23 and @minute must be between 0 and 59. @seconds must be at least 0.0 and must be strictly less than 60.0. It will be rounded down to the nearest microsecond. If the given time is not representable in the given time zone (for example, 02:30 on March 14th 2010 in Toronto, due to daylight savings time) then the time will be rounded up to the nearest existing time (in this case, 03:00). If this matters to you then you should verify the return value for containing the same as the numbers you gave. In the case that the given time is ambiguous in the given time zone (for example, 01:30 on November 7th 2010 in Toronto, due to daylight savings time) then the time falling within standard (ie: non-daylight) time is taken. It not considered a programmer error for the values to this function to be out of range, but in the case that they are, the function will return %NULL. You should release the return value by calling g_date_time_unref() when you are done with it. a new #GDateTime, or %NULL a #GTimeZone the year component of the date the month component of the date the day component of the date the hour component of the date the minute component of the date the number of seconds past the minute Creates a #GDateTime corresponding to the given #GTimeVal @tv in the local time zone. The time contained in a #GTimeVal is always stored in the form of seconds elapsed since 1970-01-01 00:00:00 UTC, regardless of the local time offset. This call can fail (returning %NULL) if @tv represents a time outside of the supported range of #GDateTime. You should release the return value by calling g_date_time_unref() when you are done with it. a new #GDateTime, or %NULL a #GTimeVal Creates a #GDateTime corresponding to the given #GTimeVal @tv in UTC. The time contained in a #GTimeVal is always stored in the form of seconds elapsed since 1970-01-01 00:00:00 UTC. This call can fail (returning %NULL) if @tv represents a time outside of the supported range of #GDateTime. You should release the return value by calling g_date_time_unref() when you are done with it. a new #GDateTime, or %NULL a #GTimeVal Creates a #GDateTime corresponding to the given Unix time @t in the local time zone. Unix time is the number of seconds that have elapsed since 1970-01-01 00:00:00 UTC, regardless of the local time offset. This call can fail (returning %NULL) if @t represents a time outside of the supported range of #GDateTime. You should release the return value by calling g_date_time_unref() when you are done with it. a new #GDateTime, or %NULL the Unix time Creates a #GDateTime corresponding to the given Unix time @t in UTC. Unix time is the number of seconds that have elapsed since 1970-01-01 00:00:00 UTC. This call can fail (returning %NULL) if @t represents a time outside of the supported range of #GDateTime. You should release the return value by calling g_date_time_unref() when you are done with it. a new #GDateTime, or %NULL the Unix time Creates a new #GDateTime corresponding to the given date and time in the local time zone. This call is equivalent to calling g_date_time_new() with the time zone returned by g_time_zone_new_local(). a #GDateTime, or %NULL the year component of the date the month component of the date the day component of the date the hour component of the date the minute component of the date the number of seconds past the minute Creates a #GDateTime corresponding to this exact instant in the given time zone @tz. The time is as accurate as the system allows, to a maximum accuracy of 1 microsecond. This function will always succeed unless the system clock is set to truly insane values (or unless GLib is still being used after the year 9999). You should release the return value by calling g_date_time_unref() when you are done with it. a new #GDateTime, or %NULL a #GTimeZone Creates a #GDateTime corresponding to this exact instant in the local time zone. This is equivalent to calling g_date_time_new_now() with the time zone returned by g_time_zone_new_local(). a new #GDateTime, or %NULL Creates a #GDateTime corresponding to this exact instant in UTC. This is equivalent to calling g_date_time_new_now() with the time zone returned by g_time_zone_new_utc(). a new #GDateTime, or %NULL Creates a new #GDateTime corresponding to the given date and time in UTC. This call is equivalent to calling g_date_time_new() with the time zone returned by g_time_zone_new_utc(). a #GDateTime, or %NULL the year component of the date the month component of the date the day component of the date the hour component of the date the minute component of the date the number of seconds past the minute Creates a copy of @datetime and adds the specified timespan to the copy. the newly created #GDateTime which should be freed with g_date_time_unref(). a #GDateTime a #GTimeSpan Creates a copy of @datetime and adds the specified number of days to the copy. Add negative values to subtract days. the newly created #GDateTime which should be freed with g_date_time_unref(). a #GDateTime the number of days Creates a new #GDateTime adding the specified values to the current date and time in @datetime. Add negative values to subtract. the newly created #GDateTime that should be freed with g_date_time_unref(). a #GDateTime the number of years to add the number of months to add the number of days to add the number of hours to add the number of minutes to add the number of seconds to add Creates a copy of @datetime and adds the specified number of hours. Add negative values to subtract hours. the newly created #GDateTime which should be freed with g_date_time_unref(). a #GDateTime the number of hours to add Creates a copy of @datetime adding the specified number of minutes. Add negative values to subtract minutes. the newly created #GDateTime which should be freed with g_date_time_unref(). a #GDateTime the number of minutes to add Creates a copy of @datetime and adds the specified number of months to the copy. Add negative values to subtract months. the newly created #GDateTime which should be freed with g_date_time_unref(). a #GDateTime the number of months Creates a copy of @datetime and adds the specified number of seconds. Add negative values to subtract seconds. the newly created #GDateTime which should be freed with g_date_time_unref(). a #GDateTime the number of seconds to add Creates a copy of @datetime and adds the specified number of weeks to the copy. Add negative values to subtract weeks. the newly created #GDateTime which should be freed with g_date_time_unref(). a #GDateTime the number of weeks Creates a copy of @datetime and adds the specified number of years to the copy. Add negative values to subtract years. the newly created #GDateTime which should be freed with g_date_time_unref(). a #GDateTime the number of years Calculates the difference in time between @end and @begin. The #GTimeSpan that is returned is effectively @end - @begin (ie: positive if the first parameter is larger). the difference between the two #GDateTime, as a time span expressed in microseconds. a #GDateTime a #GDateTime Creates a newly allocated string representing the requested @format. The format strings understood by this function are a subset of the strftime() format language as specified by C99. The \%D, \%U and \%W conversions are not supported, nor is the 'E' modifier. The GNU extensions \%k, \%l, \%s and \%P are supported, however, as are the '0', '_' and '-' modifiers. In contrast to strftime(), this function always produces a UTF-8 string, regardless of the current locale. Note that the rendering of many formats is locale-dependent and may not match the strftime() output exactly. The following format specifiers are supported: - \%a: the abbreviated weekday name according to the current locale - \%A: the full weekday name according to the current locale - \%b: the abbreviated month name according to the current locale - \%B: the full month name according to the current locale - \%c: the preferred date and time rpresentation for the current locale - \%C: the century number (year/100) as a 2-digit integer (00-99) - \%d: the day of the month as a decimal number (range 01 to 31) - \%e: the day of the month as a decimal number (range 1 to 31) - \%F: equivalent to `%Y-%m-%d` (the ISO 8601 date format) - \%g: the last two digits of the ISO 8601 week-based year as a decimal number (00-99). This works well with \%V and \%u. - \%G: the ISO 8601 week-based year as a decimal number. This works well with \%V and \%u. - \%h: equivalent to \%b - \%H: the hour as a decimal number using a 24-hour clock (range 00 to 23) - \%I: the hour as a decimal number using a 12-hour clock (range 01 to 12) - \%j: the day of the year as a decimal number (range 001 to 366) - \%k: the hour (24-hour clock) as a decimal number (range 0 to 23); single digits are preceded by a blank - \%l: the hour (12-hour clock) as a decimal number (range 1 to 12); single digits are preceded by a blank - \%m: the month as a decimal number (range 01 to 12) - \%M: the minute as a decimal number (range 00 to 59) - \%p: either "AM" or "PM" according to the given time value, or the corresponding strings for the current locale. Noon is treated as "PM" and midnight as "AM". - \%P: like \%p but lowercase: "am" or "pm" or a corresponding string for the current locale - \%r: the time in a.m. or p.m. notation - \%R: the time in 24-hour notation (\%H:\%M) - \%s: the number of seconds since the Epoch, that is, since 1970-01-01 00:00:00 UTC - \%S: the second as a decimal number (range 00 to 60) - \%t: a tab character - \%T: the time in 24-hour notation with seconds (\%H:\%M:\%S) - \%u: the ISO 8601 standard day of the week as a decimal, range 1 to 7, Monday being 1. This works well with \%G and \%V. - \%V: the ISO 8601 standard week number of the current year as a decimal number, range 01 to 53, where week 1 is the first week that has at least 4 days in the new year. See g_date_time_get_week_of_year(). This works well with \%G and \%u. - \%w: the day of the week as a decimal, range 0 to 6, Sunday being 0. This is not the ISO 8601 standard format -- use \%u instead. - \%x: the preferred date representation for the current locale without the time - \%X: the preferred time representation for the current locale without the date - \%y: the year as a decimal number without the century - \%Y: the year as a decimal number including the century - \%z: the time zone as an offset from UTC (+hhmm) - \%:z: the time zone as an offset from UTC (+hh:mm). This is a gnulib strftime() extension. Since: 2.38 - \%::z: the time zone as an offset from UTC (+hh:mm:ss). This is a gnulib strftime() extension. Since: 2.38 - \%:::z: the time zone as an offset from UTC, with : to necessary precision (e.g., -04, +05:30). This is a gnulib strftime() extension. Since: 2.38 - \%Z: the time zone or name or abbreviation - \%\%: a literal \% character Some conversion specifications can be modified by preceding the conversion specifier by one or more modifier characters. The following modifiers are supported for many of the numeric conversions: - O: Use alternative numeric symbols, if the current locale supports those. - _: Pad a numeric result with spaces. This overrides the default padding for the specifier. - -: Do not pad a numeric result. This overrides the default padding for the specifier. - 0: Pad a numeric result with zeros. This overrides the default padding for the specifier. a newly allocated string formatted to the requested format or %NULL in the case that there was an error. The string should be freed with g_free(). A #GDateTime a valid UTF-8 string, containing the format for the #GDateTime Retrieves the day of the month represented by @datetime in the gregorian calendar. the day of the month a #GDateTime Retrieves the ISO 8601 day of the week on which @datetime falls (1 is Monday, 2 is Tuesday... 7 is Sunday). the day of the week a #GDateTime Retrieves the day of the year represented by @datetime in the Gregorian calendar. the day of the year a #GDateTime Retrieves the hour of the day represented by @datetime the hour of the day a #GDateTime Retrieves the microsecond of the date represented by @datetime the microsecond of the second a #GDateTime Retrieves the minute of the hour represented by @datetime the minute of the hour a #GDateTime Retrieves the month of the year represented by @datetime in the Gregorian calendar. the month represented by @datetime a #GDateTime Retrieves the second of the minute represented by @datetime the second represented by @datetime a #GDateTime Retrieves the number of seconds since the start of the last minute, including the fractional part. the number of seconds a #GDateTime Determines the time zone abbreviation to be used at the time and in the time zone of @datetime. For example, in Toronto this is currently "EST" during the winter months and "EDT" during the summer months when daylight savings time is in effect. the time zone abbreviation. The returned string is owned by the #GDateTime and it should not be modified or freed a #GDateTime Determines the offset to UTC in effect at the time and in the time zone of @datetime. The offset is the number of microseconds that you add to UTC time to arrive at local time for the time zone (ie: negative numbers for time zones west of GMT, positive numbers for east). If @datetime represents UTC time, then the offset is always zero. the number of microseconds that should be added to UTC to get the local time a #GDateTime Returns the ISO 8601 week-numbering year in which the week containing @datetime falls. This function, taken together with g_date_time_get_week_of_year() and g_date_time_get_day_of_week() can be used to determine the full ISO week date on which @datetime falls. This is usually equal to the normal Gregorian year (as returned by g_date_time_get_year()), except as detailed below: For Thursday, the week-numbering year is always equal to the usual calendar year. For other days, the number is such that every day within a complete week (Monday to Sunday) is contained within the same week-numbering year. For Monday, Tuesday and Wednesday occurring near the end of the year, this may mean that the week-numbering year is one greater than the calendar year (so that these days have the same week-numbering year as the Thursday occurring early in the next year). For Friday, Saturaday and Sunday occurring near the start of the year, this may mean that the week-numbering year is one less than the calendar year (so that these days have the same week-numbering year as the Thursday occurring late in the previous year). An equivalent description is that the week-numbering year is equal to the calendar year containing the majority of the days in the current week (Monday to Sunday). Note that January 1 0001 in the proleptic Gregorian calendar is a Monday, so this function never returns 0. the ISO 8601 week-numbering year for @datetime a #GDateTime Returns the ISO 8601 week number for the week containing @datetime. The ISO 8601 week number is the same for every day of the week (from Moday through Sunday). That can produce some unusual results (described below). The first week of the year is week 1. This is the week that contains the first Thursday of the year. Equivalently, this is the first week that has more than 4 of its days falling within the calendar year. The value 0 is never returned by this function. Days contained within a year but occurring before the first ISO 8601 week of that year are considered as being contained in the last week of the previous year. Similarly, the final days of a calendar year may be considered as being part of the first ISO 8601 week of the next year if 4 or more days of that week are contained within the new year. the ISO 8601 week number for @datetime. a #GDateTime Retrieves the year represented by @datetime in the Gregorian calendar. the year represented by @datetime A #GDateTime Retrieves the Gregorian day, month, and year of a given #GDateTime. a #GDateTime. the return location for the gregorian year, or %NULL. the return location for the month of the year, or %NULL. the return location for the day of the month, or %NULL. Determines if daylight savings time is in effect at the time and in the time zone of @datetime. %TRUE if daylight savings time is in effect a #GDateTime Atomically increments the reference count of @datetime by one. the #GDateTime with the reference count increased a #GDateTime Creates a new #GDateTime corresponding to the same instant in time as @datetime, but in the local time zone. This call is equivalent to calling g_date_time_to_timezone() with the time zone returned by g_time_zone_new_local(). the newly created #GDateTime a #GDateTime Stores the instant in time that @datetime represents into @tv. The time contained in a #GTimeVal is always stored in the form of seconds elapsed since 1970-01-01 00:00:00 UTC, regardless of the time zone associated with @datetime. On systems where 'long' is 32bit (ie: all 32bit systems and all Windows systems), a #GTimeVal is incapable of storing the entire range of values that #GDateTime is capable of expressing. On those systems, this function returns %FALSE to indicate that the time is out of range. On systems where 'long' is 64bit, this function never fails. %TRUE if successful, else %FALSE a #GDateTime a #GTimeVal to modify Create a new #GDateTime corresponding to the same instant in time as @datetime, but in the time zone @tz. This call can fail in the case that the time goes out of bounds. For example, converting 0001-01-01 00:00:00 UTC to a time zone west of Greenwich will fail (due to the year 0 being out of range). You should release the return value by calling g_date_time_unref() when you are done with it. a new #GDateTime, or %NULL a #GDateTime the new #GTimeZone Gives the Unix time corresponding to @datetime, rounding down to the nearest second. Unix time is the number of seconds that have elapsed since 1970-01-01 00:00:00 UTC, regardless of the time zone associated with @datetime. the Unix time corresponding to @datetime a #GDateTime Creates a new #GDateTime corresponding to the same instant in time as @datetime, but in UTC. This call is equivalent to calling g_date_time_to_timezone() with the time zone returned by g_time_zone_new_utc(). the newly created #GDateTime a #GDateTime Atomically decrements the reference count of @datetime by one. When the reference count reaches zero, the resources allocated by @datetime are freed a #GDateTime A comparison function for #GDateTimes that is suitable as a #GCompareFunc. Both #GDateTimes must be non-%NULL. -1, 0 or 1 if @dt1 is less than, equal to or greater than @dt2. first #GDateTime to compare second #GDateTime to compare Checks to see if @dt1 and @dt2 are equal. Equal here means that they represent the same moment after converting them to the same time zone. %TRUE if @dt1 and @dt2 are equal a #GDateTime a #GDateTime Hashes @datetime into a #guint, suitable for use within #GHashTable. a #guint containing the hash a #GDateTime Enumeration representing a day of the week; #G_DATE_MONDAY, #G_DATE_TUESDAY, etc. #G_DATE_BAD_WEEKDAY is an invalid weekday. invalid value Monday Tuesday Wednesday Thursday Friday Saturday Sunday Associates a string with a bit flag. Used in g_parse_debug_string(). the string the flag Specifies the type of function which is called when a data element is destroyed. It is passed the pointer to the data element and should free any memory and resources allocated for it. the data element. An opaque structure representing an opened directory. Closes the directory and deallocates all related resources. a #GDir* created by g_dir_open() Retrieves the name of another entry in the directory, or %NULL. The order of entries returned from this function is not defined, and may vary by file system or other operating-system dependent factors. %NULL may also be returned in case of errors. On Unix, you can check `errno` to find out if %NULL was returned because of an error. On Unix, the '.' and '..' entries are omitted, and the returned name is in the on-disk encoding. On Windows, as is true of all GLib functions which operate on filenames, the returned name is in UTF-8. The entry's name or %NULL if there are no more entries. The return value is owned by GLib and must not be modified or freed. a #GDir* created by g_dir_open() Resets the given directory. The next call to g_dir_read_name() will return the first entry again. a #GDir* created by g_dir_open() Creates a subdirectory in the preferred directory for temporary files (as returned by g_get_tmp_dir()). @tmpl should be a string in the GLib file name encoding containing a sequence of six 'X' characters, as the parameter to g_mkstemp(). However, unlike these functions, the template should only be a basename, no directory components are allowed. If template is %NULL, a default template is used. Note that in contrast to g_mkdtemp() (and mkdtemp()) @tmpl is not modified, and might thus be a read-only literal string. The actual name used. This string should be freed with g_free() when not needed any longer and is is in the GLib file name encoding. In case of errors, %NULL is returned and @error will be set. Template for directory name, as in g_mkdtemp(), basename only, or %NULL for a default template Opens a directory for reading. The names of the files in the directory can then be retrieved using g_dir_read_name(). Note that the ordering is not defined. a newly allocated #GDir on success, %NULL on failure. If non-%NULL, you must free the result with g_dir_close() when you are finished with it. the path to the directory you are interested in. On Unix in the on-disk encoding. On Windows in UTF-8 Currently must be set to 0. Reserved for future use. The #GFloatIEEE754 and #GDoubleIEEE754 unions are used to access the sign, mantissa and exponent of IEEE floats and doubles. These unions are defined as appropriate for a given platform. IEEE floats and doubles are supported (used for storage) by at least Intel, PPC and Sparc. the double value The type of functions that are used to 'duplicate' an object. What this means depends on the context, it could just be incrementing the reference count, if @data is a ref-counted object. a duplicate of data the data to duplicate user data that was specified in g_datalist_id_dup_data() The base of natural logarithms. Specifies the type of a function used to test two values for equality. The function should return %TRUE if both values are equal and %FALSE otherwise. %TRUE if @a = @b; %FALSE otherwise a value a value to compare with The `GError` structure contains information about an error that has occurred. error domain, e.g. #G_FILE_ERROR error code, e.g. %G_FILE_ERROR_NOENT human-readable informative error message Creates a new #GError with the given @domain and @code, and a message formatted with @format. a new #GError error domain error code printf()-style format for error message parameters for message format Creates a new #GError; unlike g_error_new(), @message is not a printf()-style format string. Use this function if @message contains text you don't have control over, that could include printf() escape sequences. a new #GError error domain error code error message Creates a new #GError with the given @domain and @code, and a message formatted with @format. a new #GError error domain error code printf()-style format for error message #va_list of parameters for the message format Makes a copy of @error. a new #GError a #GError Frees a #GError and associated resources. a #GError Returns %TRUE if @error matches @domain and @code, %FALSE otherwise. In particular, when @error is %NULL, %FALSE will be returned. If @domain contains a `FAILED` (or otherwise generic) error code, you should generally not check for it explicitly, but should instead treat any not-explicitly-recognized error code as being equilalent to the `FAILED` code. This way, if the domain is extended in the future to provide a more specific error code for a certain case, your code will still work. whether @error has @domain and @code a #GError or %NULL an error domain an error code The possible errors, used in the @v_error field of #GTokenValue, when the token is a %G_TOKEN_ERROR. unknown error unexpected end of file unterminated string constant unterminated comment non-digit character in a number digit beyond radix in a number non-decimal floating point number malformed floating point number Values corresponding to @errno codes returned from file operations on UNIX. Unlike @errno codes, GFileError values are available on all systems, even Windows. The exact meaning of each code depends on what sort of file operation you were performing; the UNIX documentation gives more details. The following error code descriptions come from the GNU C Library manual, and are under the copyright of that manual. It's not very portable to make detailed assumptions about exactly which errors will be returned from a given operation. Some errors don't occur on some systems, etc., sometimes there are subtle differences in when a system will report a given error, etc. Operation not permitted; only the owner of the file (or other resource) or processes with special privileges can perform the operation. File is a directory; you cannot open a directory for writing, or create or remove hard links to it. Permission denied; the file permissions do not allow the attempted operation. Filename too long. No such file or directory. This is a "file doesn't exist" error for ordinary files that are referenced in contexts where they are expected to already exist. A file that isn't a directory was specified when a directory is required. No such device or address. The system tried to use the device represented by a file you specified, and it couldn't find the device. This can mean that the device file was installed incorrectly, or that the physical device is missing or not correctly attached to the computer. The underlying file system of the specified file does not support memory mapping. The directory containing the new link can't be modified because it's on a read-only file system. Text file busy. You passed in a pointer to bad memory. (GLib won't reliably return this, don't pass in pointers to bad memory.) Too many levels of symbolic links were encountered in looking up a file name. This often indicates a cycle of symbolic links. No space left on device; write operation on a file failed because the disk is full. No memory available. The system cannot allocate more virtual memory because its capacity is full. The current process has too many files open and can't open any more. Duplicate descriptors do count toward this limit. There are too many distinct file openings in the entire system. Bad file descriptor; for example, I/O on a descriptor that has been closed or reading from a descriptor open only for writing (or vice versa). Invalid argument. This is used to indicate various kinds of problems with passing the wrong argument to a library function. Broken pipe; there is no process reading from the other end of a pipe. Every library function that returns this error code also generates a 'SIGPIPE' signal; this signal terminates the program if not handled or blocked. Thus, your program will never actually see this code unless it has handled or blocked 'SIGPIPE'. Resource temporarily unavailable; the call might work if you try again later. Interrupted function call; an asynchronous signal occurred and prevented completion of the call. When this happens, you should try the call again. Input/output error; usually used for physical read or write errors. i.e. the disk or other physical device hardware is returning errors. Operation not permitted; only the owner of the file (or other resource) or processes with special privileges can perform the operation. Function not implemented; this indicates that the system is missing some functionality. Does not correspond to a UNIX error code; this is the standard "failed for unspecified reason" error code present in all #GError error code enumerations. Returned if no specific code applies. A test to perform on a file using g_file_test(). %TRUE if the file is a regular file (not a directory). Note that this test will also return %TRUE if the tested file is a symlink to a regular file. %TRUE if the file is a symlink. %TRUE if the file is a directory. %TRUE if the file is executable. %TRUE if the file exists. It may or may not be a regular file. The #GFloatIEEE754 and #GDoubleIEEE754 unions are used to access the sign, mantissa and exponent of IEEE floats and doubles. These unions are defined as appropriate for a given platform. IEEE floats and doubles are supported (used for storage) by at least Intel, PPC and Sparc. the double value Flags to modify the format of the string returned by g_format_size_full(). behave the same as g_format_size() include the exact number of bytes as part of the returned string. For example, "45.6 kB (45,612 bytes)". use IEC (base 1024) units with "KiB"-style suffixes. IEC units should only be used for reporting things with a strong "power of 2" basis, like RAM sizes or RAID stripe sizes. Network and storage sizes should be reported in the normal SI units. Declares a type of function which takes an arbitrary data pointer argument and has no return value. It is not currently used in GLib or GTK+. a data pointer Specifies the type of functions passed to g_list_foreach() and g_slist_foreach(). the element's data user data passed to g_list_foreach() or g_slist_foreach() This is the platform dependent conversion specifier for scanning and printing values of type #gint16. It is a string literal, but doesn't include the percent-sign, such that you can add precision and length modifiers between percent-sign and conversion specifier. |[<!-- language="C" --> gint16 in; gint32 out; sscanf ("42", "%" G_GINT16_FORMAT, &in) out = in * 1000; g_print ("%" G_GINT32_FORMAT, out); ]| The platform dependent length modifier for conversion specifiers for scanning and printing values of type #gint16 or #guint16. It is a string literal, but doesn't include the percent-sign, such that you can add precision and length modifiers between percent-sign and conversion specifier and append a conversion specifier. The following example prints "0x7b"; |[<!-- language="C" --> gint16 value = 123; g_print ("%#" G_GINT16_MODIFIER "x", value); ]| This is the platform dependent conversion specifier for scanning and printing values of type #gint32. See also #G_GINT16_FORMAT. The platform dependent length modifier for conversion specifiers for scanning and printing values of type #gint32 or #guint32. It is a string literal. See also #G_GINT16_MODIFIER. This is the platform dependent conversion specifier for scanning and printing values of type #gint64. See also #G_GINT16_FORMAT. Some platforms do not support scanning and printing 64-bit integers, even though the types are supported. On such platforms %G_GINT64_FORMAT is not defined. Note that scanf() may not support 64-bit integers, even if %G_GINT64_FORMAT is defined. Due to its weak error handling, scanf() is not recommended for parsing anyway; consider using g_ascii_strtoull() instead. The platform dependent length modifier for conversion specifiers for scanning and printing values of type #gint64 or #guint64. It is a string literal. Some platforms do not support printing 64-bit integers, even though the types are supported. On such platforms %G_GINT64_MODIFIER is not defined. This is the platform dependent conversion specifier for scanning and printing values of type #gintptr. The platform dependent length modifier for conversion specifiers for scanning and printing values of type #gintptr or #guintptr. It is a string literal. Expands to "" on all modern compilers, and to __FUNCTION__ on gcc version 2.x. Don't use it. Use G_STRFUNC() instead Expands to "" on all modern compilers, and to __PRETTY_FUNCTION__ on gcc version 2.x. Don't use it. Use G_STRFUNC() instead This is the platform dependent conversion specifier for scanning and printing values of type #gsize. See also #G_GINT16_FORMAT. The platform dependent length modifier for conversion specifiers for scanning and printing values of type #gsize or #gssize. It is a string literal. This is the platform dependent conversion specifier for scanning and printing values of type #gssize. See also #G_GINT16_FORMAT. This is the platform dependent conversion specifier for scanning and printing values of type #guint16. See also #G_GINT16_FORMAT This is the platform dependent conversion specifier for scanning and printing values of type #guint32. See also #G_GINT16_FORMAT. This is the platform dependent conversion specifier for scanning and printing values of type #guint64. See also #G_GINT16_FORMAT. Some platforms do not support scanning and printing 64-bit integers, even though the types are supported. On such platforms %G_GUINT64_FORMAT is not defined. Note that scanf() may not support 64-bit integers, even if %G_GINT64_FORMAT is defined. Due to its weak error handling, scanf() is not recommended for parsing anyway; consider using g_ascii_strtoull() instead. This is the platform dependent conversion specifier for scanning and printing values of type #guintptr. Specifies the type of the function passed to g_hash_table_foreach(). It is called with each key/value pair, together with the @user_data parameter which is passed to g_hash_table_foreach(). a key the value corresponding to the key user data passed to g_hash_table_foreach() The position of the first bit which is not reserved for internal use be the #GHook implementation, i.e. `1 << G_HOOK_FLAG_USER_SHIFT` is the first bit which can be used for application-defined flags. Specifies the type of the function passed to g_hash_table_foreach_remove(). It is called with each key/value pair, together with the @user_data parameter passed to g_hash_table_foreach_remove(). It should return %TRUE if the key/value pair should be removed from the #GHashTable. %TRUE if the key/value pair should be removed from the #GHashTable a key the value associated with the key user data passed to g_hash_table_remove() Specifies the type of the hash function which is passed to g_hash_table_new() when a #GHashTable is created. The function is passed a key and should return a #guint hash value. The functions g_direct_hash(), g_int_hash() and g_str_hash() provide hash functions which can be used when the key is a #gpointer, #gint*, and #gchar* respectively. g_direct_hash() is also the appropriate hash function for keys of the form `GINT_TO_POINTER (n)` (or similar macros). <!-- FIXME: Need more here. --> A good hash functions should produce hash values that are evenly distributed over a fairly large range. The modulus is taken with the hash table size (a prime number) to find the 'bucket' to place each key into. The function should also be very fast, since it is called for each key lookup. Note that the hash functions provided by GLib have these qualities, but are not particularly robust against manufactured keys that cause hash collisions. Therefore, you should consider choosing a more secure hash function when using a GHashTable with keys that originate in untrusted data (such as HTTP requests). Using g_str_hash() in that situation might make your application vulerable to [Algorithmic Complexity Attacks](https://lwn.net/Articles/474912/). The key to choosing a good hash is unpredictability. Even cryptographic hashes are very easy to find collisions for when the remainder is taken modulo a somewhat predictable prime number. There must be an element of randomness that an attacker is unable to guess. the hash value corresponding to the key a key The #GHashTable struct is an opaque data structure to represent a [Hash Table][glib-Hash-Tables]. It should only be accessed via the following functions. This is a convenience function for using a #GHashTable as a set. It is equivalent to calling g_hash_table_replace() with @key as both the key and the value. When a hash table only ever contains keys that have themselves as the corresponding value it is able to be stored more efficiently. See the discussion in the section description. %TRUE if the key did not exist yet a #GHashTable a key to insert Checks if @key is in @hash_table. a #GHashTable a key to check Destroys all keys and values in the #GHashTable and decrements its reference count by 1. If keys and/or values are dynamically allocated, you should either free them first or create the #GHashTable with destroy notifiers using g_hash_table_new_full(). In the latter case the destroy functions you supplied will be called on all keys and values during the destruction phase. a #GHashTable Calls the given function for key/value pairs in the #GHashTable until @predicate returns %TRUE. The function is passed the key and value of each pair, and the given @user_data parameter. The hash table may not be modified while iterating over it (you can't add/remove items). Note, that hash tables are really only optimized for forward lookups, i.e. g_hash_table_lookup(). So code that frequently issues g_hash_table_find() or g_hash_table_foreach() (e.g. in the order of once per every entry in a hash table) should probably be reworked to use additional or different data structures for reverse lookups (keep in mind that an O(n) find/foreach operation issued for all n values in a hash table ends up needing O(n*n) operations). The value of the first key/value pair is returned, for which @predicate evaluates to %TRUE. If no pair with the requested property is found, %NULL is returned. a #GHashTable function to test the key/value pairs for a certain property user data to pass to the function Calls the given function for each of the key/value pairs in the #GHashTable. The function is passed the key and value of each pair, and the given @user_data parameter. The hash table may not be modified while iterating over it (you can't add/remove items). To remove all items matching a predicate, use g_hash_table_foreach_remove(). See g_hash_table_find() for performance caveats for linear order searches in contrast to g_hash_table_lookup(). a #GHashTable the function to call for each key/value pair user data to pass to the function Calls the given function for each key/value pair in the #GHashTable. If the function returns %TRUE, then the key/value pair is removed from the #GHashTable. If you supplied key or value destroy functions when creating the #GHashTable, they are used to free the memory allocated for the removed keys and values. See #GHashTableIter for an alternative way to loop over the key/value pairs in the hash table. the number of key/value pairs removed a #GHashTable the function to call for each key/value pair user data to pass to the function Calls the given function for each key/value pair in the #GHashTable. If the function returns %TRUE, then the key/value pair is removed from the #GHashTable, but no key or value destroy functions are called. See #GHashTableIter for an alternative way to loop over the key/value pairs in the hash table. the number of key/value pairs removed. a #GHashTable the function to call for each key/value pair user data to pass to the function Retrieves every key inside @hash_table. The returned data is valid until changes to the hash release those keys. a #GList containing all the keys inside the hash table. The content of the list is owned by the hash table and should not be modified or freed. Use g_list_free() when done using the list. a #GHashTable Retrieves every key inside @hash_table, as an array. The returned array is %NULL-terminated but may contain %NULL as a key. Use @length to determine the true length if it's possible that %NULL was used as the value for a key. Note: in the common case of a string-keyed #GHashTable, the return value of this function can be conveniently cast to (gchar **). You should always free the return result with g_free(). In the above-mentioned case of a string-keyed hash table, it may be appropriate to use g_strfreev() if you call g_hash_table_steal_all() first to transfer ownership of the keys. a %NULL-terminated array containing each key from the table. a #GHashTable the length of the returned array Retrieves every value inside @hash_table. The returned data is valid until @hash_table is modified. a #GList containing all the values inside the hash table. The content of the list is owned by the hash table and should not be modified or freed. Use g_list_free() when done using the list. a #GHashTable Inserts a new key and value into a #GHashTable. If the key already exists in the #GHashTable its current value is replaced with the new value. If you supplied a @value_destroy_func when creating the #GHashTable, the old value is freed using that function. If you supplied a @key_destroy_func when creating the #GHashTable, the passed key is freed using that function. %TRUE if the key did not exist yet a #GHashTable a key to insert the value to associate with the key Looks up a key in a #GHashTable. Note that this function cannot distinguish between a key that is not present and one which is present and has the value %NULL. If you need this distinction, use g_hash_table_lookup_extended(). the associated value, or %NULL if the key is not found a #GHashTable the key to look up Looks up a key in the #GHashTable, returning the original key and the associated value and a #gboolean which is %TRUE if the key was found. This is useful if you need to free the memory allocated for the original key, for example before calling g_hash_table_remove(). You can actually pass %NULL for @lookup_key to test whether the %NULL key exists, provided the hash and equal functions of @hash_table are %NULL-safe. %TRUE if the key was found in the #GHashTable a #GHashTable the key to look up return location for the original key, or %NULL return location for the value associated with the key, or %NULL Creates a new #GHashTable with a reference count of 1. Hash values returned by @hash_func are used to determine where keys are stored within the #GHashTable data structure. The g_direct_hash(), g_int_hash(), g_int64_hash(), g_double_hash() and g_str_hash() functions are provided for some common types of keys. If @hash_func is %NULL, g_direct_hash() is used. @key_equal_func is used when looking up keys in the #GHashTable. The g_direct_equal(), g_int_equal(), g_int64_equal(), g_double_equal() and g_str_equal() functions are provided for the most common types of keys. If @key_equal_func is %NULL, keys are compared directly in a similar fashion to g_direct_equal(), but without the overhead of a function call. a new #GHashTable a function to create a hash value from a key a function to check two keys for equality Creates a new #GHashTable like g_hash_table_new() with a reference count of 1 and allows to specify functions to free the memory allocated for the key and value that get called when removing the entry from the #GHashTable. a new #GHashTable a function to create a hash value from a key a function to check two keys for equality a function to free the memory allocated for the key used when removing the entry from the #GHashTable, or %NULL if you don't want to supply such a function. a function to free the memory allocated for the value used when removing the entry from the #GHashTable, or %NULL if you don't want to supply such a function. Atomically increments the reference count of @hash_table by one. This function is MT-safe and may be called from any thread. the passed in #GHashTable a valid #GHashTable Removes a key and its associated value from a #GHashTable. If the #GHashTable was created using g_hash_table_new_full(), the key and value are freed using the supplied destroy functions, otherwise you have to make sure that any dynamically allocated values are freed yourself. %TRUE if the key was found and removed from the #GHashTable a #GHashTable the key to remove Removes all keys and their associated values from a #GHashTable. If the #GHashTable was created using g_hash_table_new_full(), the keys and values are freed using the supplied destroy functions, otherwise you have to make sure that any dynamically allocated values are freed yourself. a #GHashTable Inserts a new key and value into a #GHashTable similar to g_hash_table_insert(). The difference is that if the key already exists in the #GHashTable, it gets replaced by the new key. If you supplied a @value_destroy_func when creating the #GHashTable, the old value is freed using that function. If you supplied a @key_destroy_func when creating the #GHashTable, the old key is freed using that function. %TRUE of the key did not exist yet a #GHashTable a key to insert the value to associate with the key Returns the number of elements contained in the #GHashTable. the number of key/value pairs in the #GHashTable. a #GHashTable Removes a key and its associated value from a #GHashTable without calling the key and value destroy functions. %TRUE if the key was found and removed from the #GHashTable a #GHashTable the key to remove Removes all keys and their associated values from a #GHashTable without calling the key and value destroy functions. a #GHashTable Atomically decrements the reference count of @hash_table by one. If the reference count drops to 0, all keys and values will be destroyed, and all memory allocated by the hash table is released. This function is MT-safe and may be called from any thread. a valid #GHashTable A GHashTableIter structure represents an iterator that can be used to iterate over the elements of a #GHashTable. GHashTableIter structures are typically allocated on the stack and then initialized with g_hash_table_iter_init(). Returns the #GHashTable associated with @iter. the #GHashTable associated with @iter. an initialized #GHashTableIter Initializes a key/value pair iterator and associates it with @hash_table. Modifying the hash table after calling this function invalidates the returned iterator. |[<!-- language="C" --> GHashTableIter iter; gpointer key, value; g_hash_table_iter_init (&iter, hash_table); while (g_hash_table_iter_next (&iter, &key, &value)) { // do something with key and value } ]| an uninitialized #GHashTableIter a #GHashTable Advances @iter and retrieves the key and/or value that are now pointed to as a result of this advancement. If %FALSE is returned, @key and @value are not set, and the iterator becomes invalid. %FALSE if the end of the #GHashTable has been reached. an initialized #GHashTableIter a location to store the key, or %NULL a location to store the value, or %NULL Removes the key/value pair currently pointed to by the iterator from its associated #GHashTable. Can only be called after g_hash_table_iter_next() returned %TRUE, and cannot be called more than once for the same key/value pair. If the #GHashTable was created using g_hash_table_new_full(), the key and value are freed using the supplied destroy functions, otherwise you have to make sure that any dynamically allocated values are freed yourself. It is safe to continue iterating the #GHashTable afterward: |[<!-- language="C" --> while (g_hash_table_iter_next (&iter, &key, &value)) { if (condition) g_hash_table_iter_remove (&iter); } ]| an initialized #GHashTableIter Replaces the value currently pointed to by the iterator from its associated #GHashTable. Can only be called after g_hash_table_iter_next() returned %TRUE. If you supplied a @value_destroy_func when creating the #GHashTable, the old value is freed using that function. an initialized #GHashTableIter the value to replace with Removes the key/value pair currently pointed to by the iterator from its associated #GHashTable, without calling the key and value destroy functions. Can only be called after g_hash_table_iter_next() returned %TRUE, and cannot be called more than once for the same key/value pair. an initialized #GHashTableIter An opaque structure representing a HMAC operation. To create a new GHmac, use g_hmac_new(). To free a GHmac, use g_hmac_unref(). Copies a #GHmac. If @hmac has been closed, by calling g_hmac_get_string() or g_hmac_get_digest(), the copied HMAC will be closed as well. the copy of the passed #GHmac. Use g_hmac_unref() when finished using it. the #GHmac to copy Gets the digest from @checksum as a raw binary array and places it into @buffer. The size of the digest depends on the type of checksum. Once this function has been called, the #GHmac is closed and can no longer be updated with g_checksum_update(). a #GHmac output buffer an inout parameter. The caller initializes it to the size of @buffer. After the call it contains the length of the digest Gets the HMAC as an hexadecimal string. Once this function has been called the #GHmac can no longer be updated with g_hmac_update(). The hexadecimal characters will be lower case. the hexadecimal representation of the HMAC. The returned string is owned by the HMAC and should not be modified or freed. a #GHmac Atomically increments the reference count of @hmac by one. This function is MT-safe and may be called from any thread. the passed in #GHmac. a valid #GHmac Atomically decrements the reference count of @hmac by one. If the reference count drops to 0, all keys and values will be destroyed, and all memory allocated by the hash table is released. This function is MT-safe and may be called from any thread. Frees the memory allocated for @hmac. a #GHmac Feeds @data into an existing #GHmac. The HMAC must still be open, that is g_hmac_get_string() or g_hmac_get_digest() must not have been called on @hmac. a #GHmac buffer used to compute the checksum size of the buffer, or -1 if it is a nul-terminated string Creates a new #GHmac, using the digest algorithm @digest_type. If the @digest_type is not known, %NULL is returned. A #GHmac can be used to compute the HMAC of a key and an arbitrary binary blob, using different hashing algorithms. A #GHmac works by feeding a binary blob through g_hmac_update() until the data is complete; the digest can then be extracted using g_hmac_get_string(), which will return the checksum as a hexadecimal string; or g_hmac_get_digest(), which will return a array of raw bytes. Once either g_hmac_get_string() or g_hmac_get_digest() have been called on a #GHmac, the HMAC will be closed and it won't be possible to call g_hmac_update() on it anymore. Support for digests of type %G_CHECKSUM_SHA512 has been added in GLib 2.42. the newly created #GHmac, or %NULL. Use g_hmac_unref() to free the memory allocated by it. the desired type of digest the key for the HMAC the length of the keys The #GHook struct represents a single hook function in a #GHookList. data which is passed to func when this hook is invoked pointer to the next hook in the list pointer to the previous hook in the list the reference count of this hook the id of this hook, which is unique within its list flags which are set for this hook. See #GHookFlagMask for predefined flags the function to call when this hook is invoked. The possible signatures for this function are #GHookFunc and #GHookCheckFunc the default @finalize_hook function of a #GHookList calls this member of the hook that is being finalized Compares the ids of two #GHook elements, returning a negative value if the second id is greater than the first. a value <= 0 if the id of @sibling is >= the id of @new_hook a #GHook a #GHook to compare with @new_hook Allocates space for a #GHook and initializes it. a new #GHook a #GHookList Destroys a #GHook, given its ID. %TRUE if the #GHook was found in the #GHookList and destroyed a #GHookList a hook ID Removes one #GHook from a #GHookList, marking it inactive and calling g_hook_unref() on it. a #GHookList the #GHook to remove Finds a #GHook in a #GHookList using the given function to test for a match. the found #GHook or %NULL if no matching #GHook is found a #GHookList %TRUE if #GHook elements which have been destroyed should be skipped the function to call for each #GHook, which should return %TRUE when the #GHook has been found the data to pass to @func Finds a #GHook in a #GHookList with the given data. the #GHook with the given @data or %NULL if no matching #GHook is found a #GHookList %TRUE if #GHook elements which have been destroyed should be skipped the data to find Finds a #GHook in a #GHookList with the given function. the #GHook with the given @func or %NULL if no matching #GHook is found a #GHookList %TRUE if #GHook elements which have been destroyed should be skipped the function to find Finds a #GHook in a #GHookList with the given function and data. the #GHook with the given @func and @data or %NULL if no matching #GHook is found a #GHookList %TRUE if #GHook elements which have been destroyed should be skipped the function to find the data to find Returns the first #GHook in a #GHookList which has not been destroyed. The reference count for the #GHook is incremented, so you must call g_hook_unref() to restore it when no longer needed. (Or call g_hook_next_valid() if you are stepping through the #GHookList.) the first valid #GHook, or %NULL if none are valid a #GHookList %TRUE if hooks which are currently running (e.g. in another thread) are considered valid. If set to %FALSE, these are skipped Calls the #GHookList @finalize_hook function if it exists, and frees the memory allocated for the #GHook. a #GHookList the #GHook to free Returns the #GHook with the given id, or %NULL if it is not found. the #GHook with the given id, or %NULL if it is not found a #GHookList a hook id Inserts a #GHook into a #GHookList, before a given #GHook. a #GHookList the #GHook to insert the new #GHook before the #GHook to insert Inserts a #GHook into a #GHookList, sorted by the given function. a #GHookList the #GHook to insert the comparison function used to sort the #GHook elements Returns the next #GHook in a #GHookList which has not been destroyed. The reference count for the #GHook is incremented, so you must call g_hook_unref() to restore it when no longer needed. (Or continue to call g_hook_next_valid() until %NULL is returned.) the next valid #GHook, or %NULL if none are valid a #GHookList the current #GHook %TRUE if hooks which are currently running (e.g. in another thread) are considered valid. If set to %FALSE, these are skipped Prepends a #GHook on the start of a #GHookList. a #GHookList the #GHook to add to the start of @hook_list Increments the reference count for a #GHook. the @hook that was passed in (since 2.6) a #GHookList the #GHook to increment the reference count of Decrements the reference count of a #GHook. If the reference count falls to 0, the #GHook is removed from the #GHookList and g_hook_free() is called to free it. a #GHookList the #GHook to unref Defines the type of a hook function that can be invoked by g_hook_list_invoke_check(). %FALSE if the #GHook should be destroyed the data field of the #GHook is passed to the hook function here Defines the type of function used by g_hook_list_marshal_check(). %FALSE if @hook should be destroyed a #GHook user data Defines the type of function used to compare #GHook elements in g_hook_insert_sorted(). a value <= 0 if @new_hook should be before @sibling the #GHook being inserted the #GHook to compare with @new_hook Defines the type of function to be called when a hook in a list of hooks gets finalized. a #GHookList the hook in @hook_list that gets finalized Defines the type of the function passed to g_hook_find(). %TRUE if the required #GHook has been found a #GHook user data passed to g_hook_find_func() Flags used internally in the #GHook implementation. set if the hook has not been destroyed set if the hook is currently being run A mask covering all bits reserved for hook flags; see %G_HOOK_FLAG_USER_SHIFT Defines the type of a hook function that can be invoked by g_hook_list_invoke(). the data field of the #GHook is passed to the hook function here The #GHookList struct represents a list of hook functions. the next free #GHook id the size of the #GHookList elements, in bytes 1 if the #GHookList has been initialized the first #GHook element in the list unused the function to call to finalize a #GHook element. The default behaviour is to call the hooks @destroy function unused Removes all the #GHook elements from a #GHookList. a #GHookList Initializes a #GHookList. This must be called before the #GHookList is used. a #GHookList the size of each element in the #GHookList, typically `sizeof (GHook)`. Calls all of the #GHook functions in a #GHookList. a #GHookList %TRUE if functions which are already running (e.g. in another thread) can be called. If set to %FALSE, these are skipped Calls all of the #GHook functions in a #GHookList. Any function which returns %FALSE is removed from the #GHookList. a #GHookList %TRUE if functions which are already running (e.g. in another thread) can be called. If set to %FALSE, these are skipped Calls a function on each valid #GHook. a #GHookList %TRUE if hooks which are currently running (e.g. in another thread) are considered valid. If set to %FALSE, these are skipped the function to call for each #GHook data to pass to @marshaller Calls a function on each valid #GHook and destroys it if the function returns %FALSE. a #GHookList %TRUE if hooks which are currently running (e.g. in another thread) are considered valid. If set to %FALSE, these are skipped the function to call for each #GHook data to pass to @marshaller Defines the type of function used by g_hook_list_marshal(). a #GHook user data The GIConv struct wraps an iconv() conversion descriptor. It contains private data and should only be accessed using the following functions. Same as the standard UNIX routine iconv(), but may be implemented via libiconv on UNIX flavors that lack a native implementation. GLib provides g_convert() and g_locale_to_utf8() which are likely more convenient than the raw iconv wrappers. count of non-reversible conversions, or -1 on error conversion descriptor from g_iconv_open() bytes to convert inout parameter, bytes remaining to convert in @inbuf converted output bytes inout parameter, bytes available to fill in @outbuf Same as the standard UNIX routine iconv_close(), but may be implemented via libiconv on UNIX flavors that lack a native implementation. Should be called to clean up the conversion descriptor from g_iconv_open() when you are done converting things. GLib provides g_convert() and g_locale_to_utf8() which are likely more convenient than the raw iconv wrappers. -1 on error, 0 on success a conversion descriptor from g_iconv_open() Same as the standard UNIX routine iconv_open(), but may be implemented via libiconv on UNIX flavors that lack a native implementation. GLib provides g_convert() and g_locale_to_utf8() which are likely more convenient than the raw iconv wrappers. a "conversion descriptor", or (GIConv)-1 if opening the converter failed. destination codeset source codeset The bias by which exponents in double-precision floats are offset. The bias by which exponents in single-precision floats are offset. A data structure representing an IO Channel. The fields should be considered private and should only be accessed with the following functions. Open a file @filename as a #GIOChannel using mode @mode. This channel will be closed when the last reference to it is dropped, so there is no need to call g_io_channel_close() (though doing so will not cause problems, as long as no attempt is made to access the channel after it is closed). A #GIOChannel on success, %NULL on failure. A string containing the name of a file One of "r", "w", "a", "r+", "w+", "a+". These have the same meaning as in fopen() Creates a new #GIOChannel given a file descriptor. On UNIX systems this works for plain files, pipes, and sockets. The returned #GIOChannel has a reference count of 1. The default encoding for #GIOChannel is UTF-8. If your application is reading output from a command using via pipe, you may need to set the encoding to the encoding of the current locale (see g_get_charset()) with the g_io_channel_set_encoding() function. If you want to read raw binary data without interpretation, then call the g_io_channel_set_encoding() function with %NULL for the encoding argument. This function is available in GLib on Windows, too, but you should avoid using it on Windows. The domain of file descriptors and sockets overlap. There is no way for GLib to know which one you mean in case the argument you pass to this function happens to be both a valid file descriptor and socket. If that happens a warning is issued, and GLib assumes that it is the file descriptor you mean. a new #GIOChannel. a file descriptor. Close an IO channel. Any pending data to be written will be flushed, ignoring errors. The channel will not be freed until the last reference is dropped using g_io_channel_unref(). Use g_io_channel_shutdown() instead. A #GIOChannel Flushes the write buffer for the GIOChannel. the status of the operation: One of #G_IO_STATUS_NORMAL, #G_IO_STATUS_AGAIN, or #G_IO_STATUS_ERROR. a #GIOChannel This function returns a #GIOCondition depending on whether there is data to be read/space to write data in the internal buffers in the #GIOChannel. Only the flags %G_IO_IN and %G_IO_OUT may be set. A #GIOCondition A #GIOChannel Gets the buffer size. the size of the buffer. a #GIOChannel Returns whether @channel is buffered. %TRUE if the @channel is buffered. a #GIOChannel Returns whether the file/socket/whatever associated with @channel will be closed when @channel receives its final unref and is destroyed. The default value of this is %TRUE for channels created by g_io_channel_new_file (), and %FALSE for all other channels. Whether the channel will be closed on the final unref of the GIOChannel data structure. a #GIOChannel. Gets the encoding for the input/output of the channel. The internal encoding is always UTF-8. The encoding %NULL makes the channel safe for binary data. A string containing the encoding, this string is owned by GLib and must not be freed. a #GIOChannel Gets the current flags for a #GIOChannel, including read-only flags such as %G_IO_FLAG_IS_READABLE. The values of the flags %G_IO_FLAG_IS_READABLE and %G_IO_FLAG_IS_WRITABLE are cached for internal use by the channel when it is created. If they should change at some later point (e.g. partial shutdown of a socket with the UNIX shutdown() function), the user should immediately call g_io_channel_get_flags() to update the internal values of these flags. the flags which are set on the channel a #GIOChannel This returns the string that #GIOChannel uses to determine where in the file a line break occurs. A value of %NULL indicates autodetection. The line termination string. This value is owned by GLib and must not be freed. a #GIOChannel a location to return the length of the line terminator Initializes a #GIOChannel struct. This is called by each of the above functions when creating a #GIOChannel, and so is not often needed by the application programmer (unless you are creating a new type of #GIOChannel). a #GIOChannel Reads data from a #GIOChannel. Use g_io_channel_read_chars() instead. %G_IO_ERROR_NONE if the operation was successful. a #GIOChannel a buffer to read the data into (which should be at least count bytes long) the number of bytes to read from the #GIOChannel returns the number of bytes actually read Replacement for g_io_channel_read() with the new API. the status of the operation. a #GIOChannel a buffer to read data into the size of the buffer. Note that the buffer may not be complelely filled even if there is data in the buffer if the remaining data is not a complete character. The number of bytes read. This may be zero even on success if count < 6 and the channel's encoding is non-%NULL. This indicates that the next UTF-8 character is too wide for the buffer. Reads a line, including the terminating character(s), from a #GIOChannel into a newly-allocated string. @str_return will contain allocated memory if the return is %G_IO_STATUS_NORMAL. the status of the operation. a #GIOChannel The line read from the #GIOChannel, including the line terminator. This data should be freed with g_free() when no longer needed. This is a nul-terminated string. If a @length of zero is returned, this will be %NULL instead. location to store length of the read data, or %NULL location to store position of line terminator, or %NULL Reads a line from a #GIOChannel, using a #GString as a buffer. the status of the operation. a #GIOChannel a #GString into which the line will be written. If @buffer already contains data, the old data will be overwritten. location to store position of line terminator, or %NULL Reads all the remaining data from the file. %G_IO_STATUS_NORMAL on success. This function never returns %G_IO_STATUS_EOF. a #GIOChannel Location to store a pointer to a string holding the remaining data in the #GIOChannel. This data should be freed with g_free() when no longer needed. This data is terminated by an extra nul character, but there may be other nuls in the intervening data. location to store length of the data Reads a Unicode character from @channel. This function cannot be called on a channel with %NULL encoding. a #GIOStatus a #GIOChannel a location to return a character Increments the reference count of a #GIOChannel. the @channel that was passed in (since 2.6) a #GIOChannel Sets the current position in the #GIOChannel, similar to the standard library function fseek(). Use g_io_channel_seek_position() instead. %G_IO_ERROR_NONE if the operation was successful. a #GIOChannel an offset, in bytes, which is added to the position specified by @type the position in the file, which can be %G_SEEK_CUR (the current position), %G_SEEK_SET (the start of the file), or %G_SEEK_END (the end of the file) Replacement for g_io_channel_seek() with the new API. the status of the operation. a #GIOChannel The offset in bytes from the position specified by @type a #GSeekType. The type %G_SEEK_CUR is only allowed in those cases where a call to g_io_channel_set_encoding () is allowed. See the documentation for g_io_channel_set_encoding () for details. Sets the buffer size. a #GIOChannel the size of the buffer, or 0 to let GLib pick a good size The buffering state can only be set if the channel's encoding is %NULL. For any other encoding, the channel must be buffered. A buffered channel can only be set unbuffered if the channel's internal buffers have been flushed. Newly created channels or channels which have returned %G_IO_STATUS_EOF not require such a flush. For write-only channels, a call to g_io_channel_flush () is sufficient. For all other channels, the buffers may be flushed by a call to g_io_channel_seek_position (). This includes the possibility of seeking with seek type %G_SEEK_CUR and an offset of zero. Note that this means that socket-based channels cannot be set unbuffered once they have had data read from them. On unbuffered channels, it is safe to mix read and write calls from the new and old APIs, if this is necessary for maintaining old code. The default state of the channel is buffered. a #GIOChannel whether to set the channel buffered or unbuffered Setting this flag to %TRUE for a channel you have already closed can cause problems. a #GIOChannel Whether to close the channel on the final unref of the GIOChannel data structure. The default value of this is %TRUE for channels created by g_io_channel_new_file (), and %FALSE for all other channels. Sets the encoding for the input/output of the channel. The internal encoding is always UTF-8. The default encoding for the external file is UTF-8. The encoding %NULL is safe to use with binary data. The encoding can only be set if one of the following conditions is true: - The channel was just created, and has not been written to or read from yet. - The channel is write-only. - The channel is a file, and the file pointer was just repositioned by a call to g_io_channel_seek_position(). (This flushes all the internal buffers.) - The current encoding is %NULL or UTF-8. - One of the (new API) read functions has just returned %G_IO_STATUS_EOF (or, in the case of g_io_channel_read_to_end(), %G_IO_STATUS_NORMAL). - One of the functions g_io_channel_read_chars() or g_io_channel_read_unichar() has returned %G_IO_STATUS_AGAIN or %G_IO_STATUS_ERROR. This may be useful in the case of %G_CONVERT_ERROR_ILLEGAL_SEQUENCE. Returning one of these statuses from g_io_channel_read_line(), g_io_channel_read_line_string(), or g_io_channel_read_to_end() does not guarantee that the encoding can be changed. Channels which do not meet one of the above conditions cannot call g_io_channel_seek_position() with an offset of %G_SEEK_CUR, and, if they are "seekable", cannot call g_io_channel_write_chars() after calling one of the API "read" functions. %G_IO_STATUS_NORMAL if the encoding was successfully set a #GIOChannel the encoding type Sets the (writeable) flags in @channel to (@flags & %G_IO_FLAG_SET_MASK). the status of the operation. a #GIOChannel the flags to set on the IO channel This sets the string that #GIOChannel uses to determine where in the file a line break occurs. a #GIOChannel The line termination string. Use %NULL for autodetect. Autodetection breaks on "\n", "\r\n", "\r", "\0", and the Unicode paragraph separator. Autodetection should not be used for anything other than file-based channels. The length of the termination string. If -1 is passed, the string is assumed to be nul-terminated. This option allows termination strings with embedded nuls. Close an IO channel. Any pending data to be written will be flushed if @flush is %TRUE. The channel will not be freed until the last reference is dropped using g_io_channel_unref(). the status of the operation. a #GIOChannel if %TRUE, flush pending Returns the file descriptor of the #GIOChannel. On Windows this function returns the file descriptor or socket of the #GIOChannel. the file descriptor of the #GIOChannel. a #GIOChannel, created with g_io_channel_unix_new(). Decrements the reference count of a #GIOChannel. a #GIOChannel Writes data to a #GIOChannel. Use g_io_channel_write_chars() instead. %G_IO_ERROR_NONE if the operation was successful. a #GIOChannel the buffer containing the data to write the number of bytes to write the number of bytes actually written Replacement for g_io_channel_write() with the new API. On seekable channels with encodings other than %NULL or UTF-8, generic mixing of reading and writing is not allowed. A call to g_io_channel_write_chars () may only be made on a channel from which data has been read in the cases described in the documentation for g_io_channel_set_encoding (). the status of the operation. a #GIOChannel a buffer to write data from the size of the buffer. If -1, the buffer is taken to be a nul-terminated string. The number of bytes written. This can be nonzero even if the return value is not %G_IO_STATUS_NORMAL. If the return value is %G_IO_STATUS_NORMAL and the channel is blocking, this will always be equal to @count if @count >= 0. Writes a Unicode character to @channel. This function cannot be called on a channel with %NULL encoding. a #GIOStatus a #GIOChannel a character Converts an `errno` error number to a #GIOChannelError. a #GIOChannelError error number, e.g. %G_IO_CHANNEL_ERROR_INVAL. an `errno` error number, e.g. `EINVAL` Error codes returned by #GIOChannel operations. File too large. Invalid argument. IO error. File is a directory. No space left on device. No such device or address. Value too large for defined datatype. Broken pipe. Some other error. A bitwise combination representing a condition to watch for on an event source. There is data to read. Data can be written (without blocking). There is urgent data to read. Error condition. Hung up (the connection has been broken, usually for pipes and sockets). Invalid request. The file descriptor is not open. #GIOError is only used by the deprecated functions g_io_channel_read(), g_io_channel_write(), and g_io_channel_seek(). no error an EAGAIN error occurred an EINVAL error occurred another error occurred Specifies properties of a #GIOChannel. Some of the flags can only be read with g_io_channel_get_flags(), but not changed with g_io_channel_set_flags(). turns on append mode, corresponds to %O_APPEND (see the documentation of the UNIX open() syscall) turns on nonblocking mode, corresponds to %O_NONBLOCK/%O_NDELAY (see the documentation of the UNIX open() syscall) indicates that the io channel is readable. This flag cannot be changed. indicates that the io channel is writable. This flag cannot be changed. a misspelled version of @G_IO_FLAG_IS_WRITABLE that existed before the spelling was fixed in GLib 2.30. It is kept here for compatibility reasons. Deprecated since 2.30 indicates that the io channel is seekable, i.e. that g_io_channel_seek_position() can be used on it. This flag cannot be changed. the mask that specifies all the valid flags. the mask of the flags that are returned from g_io_channel_get_flags() the mask of the flags that the user can modify with g_io_channel_set_flags() Specifies the type of function passed to g_io_add_watch() or g_io_add_watch_full(), which is called when the requested condition on a #GIOChannel is satisfied. the function should return %FALSE if the event source should be removed the #GIOChannel event source the condition which has been satisfied user data set in g_io_add_watch() or g_io_add_watch_full() A table of functions used to handle different types of #GIOChannel in a generic way. Stati returned by most of the #GIOFuncs functions. An error occurred. Success. End of file. Resource temporarily unavailable. The name of the main group of a desktop entry file, as defined in the [Desktop Entry Specification](http://freedesktop.org/Standards/desktop-entry-spec). Consult the specification for more details about the meanings of the keys below. A key under #G_KEY_FILE_DESKTOP_GROUP, whose value is a list of strings giving the categories in which the desktop entry should be shown in a menu. A key under #G_KEY_FILE_DESKTOP_GROUP, whose value is a localized string giving the tooltip for the desktop entry. A key under #G_KEY_FILE_DESKTOP_GROUP, whose value is a string giving the command line to execute. It is only valid for desktop entries with the `Application` type. A key under #G_KEY_FILE_DESKTOP_GROUP, whose value is a localized string giving the generic name of the desktop entry. A key under #G_KEY_FILE_DESKTOP_GROUP, whose value is a boolean stating whether the desktop entry has been deleted by the user. A key under #G_KEY_FILE_DESKTOP_GROUP, whose value is a localized string giving the name of the icon to be displayed for the desktop entry. A key under #G_KEY_FILE_DESKTOP_GROUP, whose value is a list of strings giving the MIME types supported by this desktop entry. A key under #G_KEY_FILE_DESKTOP_GROUP, whose value is a localized string giving the specific name of the desktop entry. A key under #G_KEY_FILE_DESKTOP_GROUP, whose value is a list of strings identifying the environments that should not display the desktop entry. A key under #G_KEY_FILE_DESKTOP_GROUP, whose value is a boolean stating whether the desktop entry should be shown in menus. A key under #G_KEY_FILE_DESKTOP_GROUP, whose value is a list of strings identifying the environments that should display the desktop entry. A key under #G_KEY_FILE_DESKTOP_GROUP, whose value is a string containing the working directory to run the program in. It is only valid for desktop entries with the `Application` type. A key under #G_KEY_FILE_DESKTOP_GROUP, whose value is a boolean stating whether the application supports the [Startup Notification Protocol Specification](http://www.freedesktop.org/Standards/startup-notification-spec). A key under #G_KEY_FILE_DESKTOP_GROUP, whose value is string identifying the WM class or name hint of a window that the application will create, which can be used to emulate Startup Notification with older applications. A key under #G_KEY_FILE_DESKTOP_GROUP, whose value is a boolean stating whether the program should be run in a terminal window. It is only valid for desktop entries with the `Application` type. A key under #G_KEY_FILE_DESKTOP_GROUP, whose value is a string giving the file name of a binary on disk used to determine if the program is actually installed. It is only valid for desktop entries with the `Application` type. A key under #G_KEY_FILE_DESKTOP_GROUP, whose value is a string giving the type of the desktop entry. Usually #G_KEY_FILE_DESKTOP_TYPE_APPLICATION, #G_KEY_FILE_DESKTOP_TYPE_LINK, or #G_KEY_FILE_DESKTOP_TYPE_DIRECTORY. A key under #G_KEY_FILE_DESKTOP_GROUP, whose value is a string giving the URL to access. It is only valid for desktop entries with the `Link` type. A key under #G_KEY_FILE_DESKTOP_GROUP, whose value is a string giving the version of the Desktop Entry Specification used for the desktop entry file. The value of the #G_KEY_FILE_DESKTOP_KEY_TYPE, key for desktop entries representing applications. The value of the #G_KEY_FILE_DESKTOP_KEY_TYPE, key for desktop entries representing directories. The value of the #G_KEY_FILE_DESKTOP_KEY_TYPE, key for desktop entries representing links to documents. The GKeyFile struct contains only private data and should not be accessed directly. Creates a new empty #GKeyFile object. Use g_key_file_load_from_file(), g_key_file_load_from_data(), g_key_file_load_from_dirs() or g_key_file_load_from_data_dirs() to read an existing key file. an empty #GKeyFile. Clears all keys and groups from @key_file, and decreases the reference count by 1. If the reference count reaches zero, frees the key file and all its allocated memory. a #GKeyFile Returns the value associated with @key under @group_name as a boolean. If @key cannot be found then %FALSE is returned and @error is set to #G_KEY_FILE_ERROR_KEY_NOT_FOUND. Likewise, if the value associated with @key cannot be interpreted as a boolean then %FALSE is returned and @error is set to #G_KEY_FILE_ERROR_INVALID_VALUE. the value associated with the key as a boolean, or %FALSE if the key was not found or could not be parsed. a #GKeyFile a group name a key Returns the values associated with @key under @group_name as booleans. If @key cannot be found then %NULL is returned and @error is set to #G_KEY_FILE_ERROR_KEY_NOT_FOUND. Likewise, if the values associated with @key cannot be interpreted as booleans then %NULL is returned and @error is set to #G_KEY_FILE_ERROR_INVALID_VALUE. the values associated with the key as a list of booleans, or %NULL if the key was not found or could not be parsed. The returned list of booleans should be freed with g_free() when no longer needed. a #GKeyFile a group name a key the number of booleans returned Retrieves a comment above @key from @group_name. If @key is %NULL then @comment will be read from above @group_name. If both @key and @group_name are %NULL, then @comment will be read from above the first group in the file. a comment that should be freed with g_free() a #GKeyFile a group name, or %NULL a key Returns the value associated with @key under @group_name as a double. If @group_name is %NULL, the start_group is used. If @key cannot be found then 0.0 is returned and @error is set to #G_KEY_FILE_ERROR_KEY_NOT_FOUND. Likewise, if the value associated with @key cannot be interpreted as a double then 0.0 is returned and @error is set to #G_KEY_FILE_ERROR_INVALID_VALUE. the value associated with the key as a double, or 0.0 if the key was not found or could not be parsed. a #GKeyFile a group name a key Returns the values associated with @key under @group_name as doubles. If @key cannot be found then %NULL is returned and @error is set to #G_KEY_FILE_ERROR_KEY_NOT_FOUND. Likewise, if the values associated with @key cannot be interpreted as doubles then %NULL is returned and @error is set to #G_KEY_FILE_ERROR_INVALID_VALUE. the values associated with the key as a list of doubles, or %NULL if the key was not found or could not be parsed. The returned list of doubles should be freed with g_free() when no longer needed. a #GKeyFile a group name a key the number of doubles returned Returns all groups in the key file loaded with @key_file. The array of returned groups will be %NULL-terminated, so @length may optionally be %NULL. a newly-allocated %NULL-terminated array of strings. Use g_strfreev() to free it. a #GKeyFile return location for the number of returned groups, or %NULL Returns the value associated with @key under @group_name as a signed 64-bit integer. This is similar to g_key_file_get_integer() but can return 64-bit results without truncation. the value associated with the key as a signed 64-bit integer, or 0 if the key was not found or could not be parsed. a non-%NULL #GKeyFile a non-%NULL group name a non-%NULL key Returns the value associated with @key under @group_name as an integer. If @key cannot be found then 0 is returned and @error is set to #G_KEY_FILE_ERROR_KEY_NOT_FOUND. Likewise, if the value associated with @key cannot be interpreted as an integer then 0 is returned and @error is set to #G_KEY_FILE_ERROR_INVALID_VALUE. the value associated with the key as an integer, or 0 if the key was not found or could not be parsed. a #GKeyFile a group name a key Returns the values associated with @key under @group_name as integers. If @key cannot be found then %NULL is returned and @error is set to #G_KEY_FILE_ERROR_KEY_NOT_FOUND. Likewise, if the values associated with @key cannot be interpreted as integers then %NULL is returned and @error is set to #G_KEY_FILE_ERROR_INVALID_VALUE. the values associated with the key as a list of integers, or %NULL if the key was not found or could not be parsed. The returned list of integers should be freed with g_free() when no longer needed. a #GKeyFile a group name a key the number of integers returned Returns all keys for the group name @group_name. The array of returned keys will be %NULL-terminated, so @length may optionally be %NULL. In the event that the @group_name cannot be found, %NULL is returned and @error is set to #G_KEY_FILE_ERROR_GROUP_NOT_FOUND. a newly-allocated %NULL-terminated array of strings. Use g_strfreev() to free it. a #GKeyFile a group name return location for the number of keys returned, or %NULL Returns the value associated with @key under @group_name translated in the given @locale if available. If @locale is %NULL then the current locale is assumed. If @key cannot be found then %NULL is returned and @error is set to #G_KEY_FILE_ERROR_KEY_NOT_FOUND. If the value associated with @key cannot be interpreted or no suitable translation can be found then the untranslated value is returned. a newly allocated string or %NULL if the specified key cannot be found. a #GKeyFile a group name a key a locale identifier or %NULL Returns the values associated with @key under @group_name translated in the given @locale if available. If @locale is %NULL then the current locale is assumed. If @key cannot be found then %NULL is returned and @error is set to #G_KEY_FILE_ERROR_KEY_NOT_FOUND. If the values associated with @key cannot be interpreted or no suitable translations can be found then the untranslated values are returned. The returned array is %NULL-terminated, so @length may optionally be %NULL. a newly allocated %NULL-terminated string array or %NULL if the key isn't found. The string array should be freed with g_strfreev(). a #GKeyFile a group name a key a locale identifier or %NULL return location for the number of returned strings or %NULL Returns the name of the start group of the file. The start group of the key file. a #GKeyFile Returns the string value associated with @key under @group_name. Unlike g_key_file_get_value(), this function handles escape sequences like \s. In the event the key cannot be found, %NULL is returned and @error is set to #G_KEY_FILE_ERROR_KEY_NOT_FOUND. In the event that the @group_name cannot be found, %NULL is returned and @error is set to #G_KEY_FILE_ERROR_GROUP_NOT_FOUND. a newly allocated string or %NULL if the specified key cannot be found. a #GKeyFile a group name a key Returns the values associated with @key under @group_name. In the event the key cannot be found, %NULL is returned and @error is set to #G_KEY_FILE_ERROR_KEY_NOT_FOUND. In the event that the @group_name cannot be found, %NULL is returned and @error is set to #G_KEY_FILE_ERROR_GROUP_NOT_FOUND. a %NULL-terminated string array or %NULL if the specified key cannot be found. The array should be freed with g_strfreev(). a #GKeyFile a group name a key return location for the number of returned strings, or %NULL Returns the value associated with @key under @group_name as an unsigned 64-bit integer. This is similar to g_key_file_get_integer() but can return large positive results without truncation. the value associated with the key as an unsigned 64-bit integer, or 0 if the key was not found or could not be parsed. a non-%NULL #GKeyFile a non-%NULL group name a non-%NULL key Returns the raw value associated with @key under @group_name. Use g_key_file_get_string() to retrieve an unescaped UTF-8 string. In the event the key cannot be found, %NULL is returned and @error is set to #G_KEY_FILE_ERROR_KEY_NOT_FOUND. In the event that the @group_name cannot be found, %NULL is returned and @error is set to #G_KEY_FILE_ERROR_GROUP_NOT_FOUND. a newly allocated string or %NULL if the specified key cannot be found. a #GKeyFile a group name a key Looks whether the key file has the group @group_name. %TRUE if @group_name is a part of @key_file, %FALSE otherwise. a #GKeyFile a group name Looks whether the key file has the key @key in the group @group_name. Note that this function does not follow the rules for #GError strictly; the return value both carries meaning and signals an error. To use this function, you must pass a #GError pointer in @error, and check whether it is not %NULL to see if an error occurred. Language bindings should use g_key_file_get_value() to test whether or not a key exists. %TRUE if @key is a part of @group_name, %FALSE otherwise a #GKeyFile a group name a key name Loads a key file from memory into an empty #GKeyFile structure. If the object cannot be created then %error is set to a #GKeyFileError. %TRUE if a key file could be loaded, %FALSE otherwise an empty #GKeyFile struct key file loaded in memory the length of @data in bytes (or (gsize)-1 if data is nul-terminated) flags from #GKeyFileFlags This function looks for a key file named @file in the paths returned from g_get_user_data_dir() and g_get_system_data_dirs(), loads the file into @key_file and returns the file's full path in @full_path. If the file could not be loaded then an %error is set to either a #GFileError or #GKeyFileError. %TRUE if a key file could be loaded, %FALSE othewise an empty #GKeyFile struct a relative path to a filename to open and parse return location for a string containing the full path of the file, or %NULL flags from #GKeyFileFlags This function looks for a key file named @file in the paths specified in @search_dirs, loads the file into @key_file and returns the file's full path in @full_path. If the file could not be loaded then an %error is set to either a #GFileError or #GKeyFileError. %TRUE if a key file could be loaded, %FALSE otherwise an empty #GKeyFile struct a relative path to a filename to open and parse %NULL-terminated array of directories to search return location for a string containing the full path of the file, or %NULL flags from #GKeyFileFlags Loads a key file into an empty #GKeyFile structure. If the file could not be loaded then @error is set to either a #GFileError or #GKeyFileError. %TRUE if a key file could be loaded, %FALSE otherwise an empty #GKeyFile struct the path of a filename to load, in the GLib filename encoding flags from #GKeyFileFlags Increases the reference count of @key_file. the same @key_file. a #GKeyFile Removes a comment above @key from @group_name. If @key is %NULL then @comment will be removed above @group_name. If both @key and @group_name are %NULL, then @comment will be removed above the first group in the file. %TRUE if the comment was removed, %FALSE otherwise a #GKeyFile a group name, or %NULL a key Removes the specified group, @group_name, from the key file. %TRUE if the group was removed, %FALSE otherwise a #GKeyFile a group name Removes @key in @group_name from the key file. %TRUE if the key was removed, %FALSE otherwise a #GKeyFile a group name a key name to remove Writes the contents of @key_file to @filename using g_file_set_contents(). This function can fail for any of the reasons that g_file_set_contents() may fail. %TRUE if successful, else %FALSE with @error set a #GKeyFile the name of the file to write to Associates a new boolean value with @key under @group_name. If @key cannot be found then it is created. a #GKeyFile a group name a key %TRUE or %FALSE Associates a list of boolean values with @key under @group_name. If @key cannot be found then it is created. If @group_name is %NULL, the start_group is used. a #GKeyFile a group name a key an array of boolean values length of @list Places a comment above @key from @group_name. If @key is %NULL then @comment will be written above @group_name. If both @key and @group_name are %NULL, then @comment will be written above the first group in the file. %TRUE if the comment was written, %FALSE otherwise a #GKeyFile a group name, or %NULL a key a comment Associates a new double value with @key under @group_name. If @key cannot be found then it is created. a #GKeyFile a group name a key an double value Associates a list of double values with @key under @group_name. If @key cannot be found then it is created. a #GKeyFile a group name a key an array of double values number of double values in @list Associates a new integer value with @key under @group_name. If @key cannot be found then it is created. a #GKeyFile a group name a key an integer value Associates a new integer value with @key under @group_name. If @key cannot be found then it is created. a #GKeyFile a group name a key an integer value Associates a list of integer values with @key under @group_name. If @key cannot be found then it is created. a #GKeyFile a group name a key an array of integer values number of integer values in @list Sets the character which is used to separate values in lists. Typically ';' or ',' are used as separators. The default list separator is ';'. a #GKeyFile the separator Associates a string value for @key and @locale under @group_name. If the translation for @key cannot be found then it is created. a #GKeyFile a group name a key a locale identifier a string Associates a list of string values for @key and @locale under @group_name. If the translation for @key cannot be found then it is created. a #GKeyFile a group name a key a locale identifier a %NULL-terminated array of locale string values the length of @list Associates a new string value with @key under @group_name. If @key cannot be found then it is created. If @group_name cannot be found then it is created. Unlike g_key_file_set_value(), this function handles characters that need escaping, such as newlines. a #GKeyFile a group name a key a string Associates a list of string values for @key under @group_name. If @key cannot be found then it is created. If @group_name cannot be found then it is created. a #GKeyFile a group name a key an array of string values number of string values in @list Associates a new integer value with @key under @group_name. If @key cannot be found then it is created. a #GKeyFile a group name a key an integer value Associates a new value with @key under @group_name. If @key cannot be found then it is created. If @group_name cannot be found then it is created. To set an UTF-8 string which may contain characters that need escaping (such as newlines or spaces), use g_key_file_set_string(). a #GKeyFile a group name a key a string This function outputs @key_file as a string. Note that this function never reports an error, so it is safe to pass %NULL as @error. a newly allocated string holding the contents of the #GKeyFile a #GKeyFile return location for the length of the returned string, or %NULL Decreases the reference count of @key_file by 1. If the reference count reaches zero, frees the key file and all its allocated memory. a #GKeyFile Error codes returned by key file parsing. the text being parsed was in an unknown encoding document was ill-formed the file was not found a requested key was not found a requested group was not found a value could not be parsed Flags which influence the parsing. No flags, default behaviour Use this flag if you plan to write the (possibly modified) contents of the key file back to a file; otherwise all comments will be lost when the key file is written back. Use this flag if you plan to write the (possibly modified) contents of the key file back to a file; otherwise only the translations for the current language will be written back. Specifies one of the possible types of byte order. See #G_BYTE_ORDER. The natural logarithm of 10. The natural logarithm of 2. Multiplying the base 2 exponent by this number yields the base 10 exponent. Defines the log domain. For applications, this is typically left as the default %NULL (or "") domain. Libraries should define this so that any messages which they log can be differentiated from messages from other libraries and application code. But be careful not to define it in any public header files. For example, GTK+ uses this in its Makefile.am: |[ INCLUDES = -DG_LOG_DOMAIN=\"Gtk\" ]| GLib log levels that are considered fatal by default. Log levels below 1<<G_LOG_LEVEL_USER_SHIFT are used by GLib. Higher bits can be used for user-defined log levels. The #GList struct is used for each element in a doubly-linked list. holds the element's data, which can be a pointer to any kind of data, or any integer value using the [Type Conversion Macros][glib-Type-Conversion-Macros] contains the link to the next element in the list contains the link to the previous element in the list Allocates space for one #GList element. It is called by g_list_append(), g_list_prepend(), g_list_insert() and g_list_insert_sorted() and so is rarely used on its own. a pointer to the newly-allocated #GList element Adds a new element on to the end of the list. Note that the return value is the new start of the list, if @list was empty; make sure you store the new value. g_list_append() has to traverse the entire list to find the end, which is inefficient when adding multiple elements. A common idiom to avoid the inefficiency is to use g_list_prepend() and reverse the list with g_list_reverse() when all elements have been added. |[<!-- language="C" --> // Notice that these are initialized to the empty list. GList *string_list = NULL, *number_list = NULL; // This is a list of strings. string_list = g_list_append (string_list, "first"); string_list = g_list_append (string_list, "second"); // This is a list of integers. number_list = g_list_append (number_list, GINT_TO_POINTER (27)); number_list = g_list_append (number_list, GINT_TO_POINTER (14)); ]| either @list or the new start of the #GList if @list was %NULL a pointer to a #GList the data for the new element Adds the second #GList onto the end of the first #GList. Note that the elements of the second #GList are not copied. They are used directly. This function is for example used to move an element in the list. The following example moves an element to the top of the list: |[<!-- language="C" --> list = g_list_remove_link (list, llink); list = g_list_concat (llink, list); ]| the start of the new #GList, which equals @list1 if not %NULL a #GList, this must point to the top of the list the #GList to add to the end of the first #GList, this must point to the top of the list Copies a #GList. Note that this is a "shallow" copy. If the list elements consist of pointers to data, the pointers are copied but the actual data is not. See g_list_copy_deep() if you need to copy the data as well. the start of the new list that holds the same data as @list a #GList, this must point to the top of the list Makes a full (deep) copy of a #GList. In contrast with g_list_copy(), this function uses @func to make a copy of each list element, in addition to copying the list container itself. @func, as a #GCopyFunc, takes two arguments, the data to be copied and a @user_data pointer. It's safe to pass %NULL as user_data, if the copy function takes only one argument. For instance, if @list holds a list of GObjects, you can do: |[<!-- language="C" --> another_list = g_list_copy_deep (list, (GCopyFunc) g_object_ref, NULL); ]| And, to entirely free the new list, you could do: |[<!-- language="C" --> g_list_free_full (another_list, g_object_unref); ]| the start of the new list that holds a full copy of @list, use g_list_free_full() to free it a #GList, this must point to the top of the list a copy function used to copy every element in the list user data passed to the copy function @func, or %NULL Removes the node link_ from the list and frees it. Compare this to g_list_remove_link() which removes the node without freeing it. the (possibly changed) start of the #GList a #GList, this must point to the top of the list node to delete from @list Finds the element in a #GList which contains the given data. the found #GList element, or %NULL if it is not found a #GList, this must point to the top of the list the element data to find Finds an element in a #GList, using a supplied function to find the desired element. It iterates over the list, calling the given function which should return 0 when the desired element is found. The function takes two #gconstpointer arguments, the #GList element's data as the first argument and the given user data. the found #GList element, or %NULL if it is not found a #GList, this must point to the top of the list user data passed to the function the function to call for each element. It should return 0 when the desired element is found Gets the first element in a #GList. the first element in the #GList, or %NULL if the #GList has no elements any #GList element Calls a function for each element of a #GList. a #GList, this must point to the top of the list the function to call with each element's data user data to pass to the function Frees all of the memory used by a #GList. The freed elements are returned to the slice allocator. If list elements contain dynamically-allocated memory, you should either use g_list_free_full() or free them manually first. a #GList Frees one #GList element. It is usually used after g_list_remove_link(). a #GList element Convenience method, which frees all the memory used by a #GList, and calls @free_func on every element's data. a pointer to a #GList the function to be called to free each element's data Gets the position of the element containing the given data (starting from 0). the index of the element containing the data, or -1 if the data is not found a #GList, this must point to the top of the list the data to find Inserts a new element into the list at the given position. the (possibly changed) start of the #GList a pointer to a #GList, this must point to the top of the list the data for the new element the position to insert the element. If this is negative, or is larger than the number of elements in the list, the new element is added on to the end of the list. Inserts a new element into the list before the given position. the (possibly changed) start of the #GList a pointer to a #GList, this must point to the top of the list the list element before which the new element is inserted or %NULL to insert at the end of the list the data for the new element Inserts a new element into the list, using the given comparison function to determine its position. If you are adding many new elements to a list, and the number of new elements is much larger than the length of the list, use g_list_prepend() to add the new items and sort the list afterwards with g_list_sort(). the (possibly changed) start of the #GList a pointer to a #GList, this must point to the top of the already sorted list the data for the new element the function to compare elements in the list. It should return a number > 0 if the first parameter comes after the second parameter in the sort order. Inserts a new element into the list, using the given comparison function to determine its position. If you are adding many new elements to a list, and the number of new elements is much larger than the length of the list, use g_list_prepend() to add the new items and sort the list afterwards with g_list_sort(). the (possibly changed) start of the #GList a pointer to a #GList, this must point to the top of the already sorted list the data for the new element the function to compare elements in the list. It should return a number > 0 if the first parameter comes after the second parameter in the sort order. user data to pass to comparison function Gets the last element in a #GList. the last element in the #GList, or %NULL if the #GList has no elements any #GList element Gets the number of elements in a #GList. This function iterates over the whole list to count its elements. Use a #GQueue instead of a GList if you regularly need the number of items. the number of elements in the #GList a #GList, this must point to the top of the list Gets the element at the given position in a #GList. the element, or %NULL if the position is off the end of the #GList a #GList, this must point to the top of the list the position of the element, counting from 0 Gets the data of the element at the given position. the element's data, or %NULL if the position is off the end of the #GList a #GList, this must point to the top of the list the position of the element Gets the element @n places before @list. the element, or %NULL if the position is off the end of the #GList a #GList the position of the element, counting from 0 Gets the position of the given element in the #GList (starting from 0). the position of the element in the #GList, or -1 if the element is not found a #GList, this must point to the top of the list an element in the #GList Prepends a new element on to the start of the list. Note that the return value is the new start of the list, which will have changed, so make sure you store the new value. |[<!-- language="C" --> // Notice that it is initialized to the empty list. GList *list = NULL; list = g_list_prepend (list, "last"); list = g_list_prepend (list, "first"); ]| Do not use this function to prepend a new element to a different element than the start of the list. Use g_list_insert_before() instead. a pointer to the newly prepended element, which is the new start of the #GList a pointer to a #GList, this must point to the top of the list the data for the new element Removes an element from a #GList. If two elements contain the same data, only the first is removed. If none of the elements contain the data, the #GList is unchanged. the (possibly changed) start of the #GList a #GList, this must point to the top of the list the data of the element to remove Removes all list nodes with data equal to @data. Returns the new head of the list. Contrast with g_list_remove() which removes only the first node matching the given data. the (possibly changed) start of the #GList a #GList, this must point to the top of the list data to remove Removes an element from a #GList, without freeing the element. The removed element's prev and next links are set to %NULL, so that it becomes a self-contained list with one element. This function is for example used to move an element in the list (see the example for g_list_concat()) or to remove an element in the list before freeing its data: |[<!-- language="C" --> list = g_list_remove_link (list, llink); free_some_data_that_may_access_the_list_again (llink->data); g_list_free (llink); ]| the (possibly changed) start of the #GList a #GList, this must point to the top of the list an element in the #GList Reverses a #GList. It simply switches the next and prev pointers of each element. the start of the reversed #GList a #GList, this must point to the top of the list Sorts a #GList using the given comparison function. The algorithm used is a stable sort. the (possibly changed) start of the #GList a #GList, this must point to the top of the list the comparison function used to sort the #GList. This function is passed the data from 2 elements of the #GList and should return 0 if they are equal, a negative value if the first element comes before the second, or a positive value if the first element comes after the second. Like g_list_sort(), but the comparison function accepts a user data argument. the (possibly changed) start of the #GList a #GList, this must point to the top of the list comparison function user data to pass to comparison function Specifies the prototype of log handler functions. The default log handler, g_log_default_handler(), automatically appends a new-line character to @message when printing it. It is advised that any custom log handler functions behave similarly, so that logging calls in user code do not need modifying to add a new-line character to the message if the log handler is changed. the log domain of the message the log level of the message (including the fatal and recursion flags) the message to process user data, set in g_log_set_handler() Flags specifying the level of log messages. It is possible to change how GLib treats messages of the various levels using g_log_set_handler() and g_log_set_fatal_mask(). internal flag internal flag log level for errors, see g_error(). This level is also used for messages produced by g_assert(). log level for critical messages, see g_critical(). This level is also used for messages produced by g_return_if_fail() and g_return_val_if_fail(). log level for warnings, see g_warning() log level for messages, see g_message() log level for informational messages, see g_info() log level for debug messages, see g_debug() a mask including all log levels The major version number of the GLib library. Like #glib_major_version, but from the headers used at application compile time, rather than from the library linked against at application run time. The maximum value which can be held in a #gint16. The maximum value which can be held in a #gint32. The maximum value which can be held in a #gint64. The maximum value which can be held in a #gint8. The maximum value which can be held in a #guint16. The maximum value which can be held in a #guint32. The maximum value which can be held in a #guint64. The maximum value which can be held in a #guint8. The micro version number of the GLib library. Like #gtk_micro_version, but from the headers used at application compile time, rather than from the library linked against at application run time. The minimum value which can be held in a #gint16. The minimum value which can be held in a #gint32. The minimum value which can be held in a #gint64. The minimum value which can be held in a #gint8. The minor version number of the GLib library. Like #gtk_minor_version, but from the headers used at application compile time, rather than from the library linked against at application run time. The `GMainContext` struct is an opaque data type representing a set of sources to be handled in a main loop. Creates a new #GMainContext structure. the new #GMainContext Tries to become the owner of the specified context. If some other thread is the owner of the context, returns %FALSE immediately. Ownership is properly recursive: the owner can require ownership again and will release ownership when g_main_context_release() is called as many times as g_main_context_acquire(). You must be the owner of a context before you can call g_main_context_prepare(), g_main_context_query(), g_main_context_check(), g_main_context_dispatch(). %TRUE if the operation succeeded, and this thread is now the owner of @context. a #GMainContext Adds a file descriptor to the set of file descriptors polled for this context. This will very seldom be used directly. Instead a typical event source will use g_source_add_unix_fd() instead. a #GMainContext (or %NULL for the default context) a #GPollFD structure holding information about a file descriptor to watch. the priority for this file descriptor which should be the same as the priority used for g_source_attach() to ensure that the file descriptor is polled whenever the results may be needed. Passes the results of polling back to the main loop. You must have successfully acquired the context with g_main_context_acquire() before you may call this function. %TRUE if some sources are ready to be dispatched. a #GMainContext the maximum numerical priority of sources to check array of #GPollFD's that was passed to the last call to g_main_context_query() return value of g_main_context_query() Dispatches all pending sources. You must have successfully acquired the context with g_main_context_acquire() before you may call this function. a #GMainContext Finds a source with the given source functions and user data. If multiple sources exist with the same source function and user data, the first one found will be returned. the source, if one was found, otherwise %NULL a #GMainContext (if %NULL, the default context will be used). the @source_funcs passed to g_source_new(). the user data from the callback. Finds a #GSource given a pair of context and ID. It is a programmer error to attempt to lookup a non-existent source. More specifically: source IDs can be reissued after a source has been destroyed and therefore it is never valid to use this function with a source ID which may have already been removed. An example is when scheduling an idle to run in another thread with g_idle_add(): the idle may already have run and been removed by the time this function is called on its (now invalid) source ID. This source ID may have been reissued, leading to the operation being performed against the wrong source. the #GSource a #GMainContext (if %NULL, the default context will be used) the source ID, as returned by g_source_get_id(). Finds a source with the given user data for the callback. If multiple sources exist with the same user data, the first one found will be returned. the source, if one was found, otherwise %NULL a #GMainContext the user_data for the callback. Gets the poll function set by g_main_context_set_poll_func(). the poll function a #GMainContext Invokes a function in such a way that @context is owned during the invocation of @function. If @context is %NULL then the global default main context — as returned by g_main_context_default() — is used. If @context is owned by the current thread, @function is called directly. Otherwise, if @context is the thread-default main context of the current thread and g_main_context_acquire() succeeds, then @function is called and g_main_context_release() is called afterwards. In any other case, an idle source is created to call @function and that source is attached to @context (presumably to be run in another thread). The idle source is attached with #G_PRIORITY_DEFAULT priority. If you want a different priority, use g_main_context_invoke_full(). Note that, as with normal idle functions, @function should probably return %FALSE. If it returns %TRUE, it will be continuously run in a loop (and may prevent this call from returning). a #GMainContext, or %NULL function to call data to pass to @function Invokes a function in such a way that @context is owned during the invocation of @function. This function is the same as g_main_context_invoke() except that it lets you specify the priority incase @function ends up being scheduled as an idle and also lets you give a #GDestroyNotify for @data. @notify should not assume that it is called from any particular thread or with any particular context acquired. a #GMainContext, or %NULL the priority at which to run @function function to call data to pass to @function a function to call when @data is no longer in use, or %NULL. Determines whether this thread holds the (recursive) ownership of this #GMainContext. This is useful to know before waiting on another thread that may be blocking to get ownership of @context. %TRUE if current thread is owner of @context. a #GMainContext Runs a single iteration for the given main loop. This involves checking to see if any event sources are ready to be processed, then if no events sources are ready and @may_block is %TRUE, waiting for a source to become ready, then dispatching the highest priority events sources that are ready. Otherwise, if @may_block is %FALSE sources are not waited to become ready, only those highest priority events sources will be dispatched (if any), that are ready at this given moment without further waiting. Note that even when @may_block is %TRUE, it is still possible for g_main_context_iteration() to return %FALSE, since the wait may be interrupted for other reasons than an event source becoming ready. %TRUE if events were dispatched. a #GMainContext (if %NULL, the default context will be used) whether the call may block. Checks if any sources have pending events for the given context. %TRUE if events are pending. a #GMainContext (if %NULL, the default context will be used) Pops @context off the thread-default context stack (verifying that it was on the top of the stack). a #GMainContext object, or %NULL Prepares to poll sources within a main loop. The resulting information for polling is determined by calling g_main_context_query (). You must have successfully acquired the context with g_main_context_acquire() before you may call this function. %TRUE if some source is ready to be dispatched prior to polling. a #GMainContext location to store priority of highest priority source already ready. Acquires @context and sets it as the thread-default context for the current thread. This will cause certain asynchronous operations (such as most [gio][gio]-based I/O) which are started in this thread to run under @context and deliver their results to its main loop, rather than running under the global default context in the main thread. Note that calling this function changes the context returned by g_main_context_get_thread_default(), not the one returned by g_main_context_default(), so it does not affect the context used by functions like g_idle_add(). Normally you would call this function shortly after creating a new thread, passing it a #GMainContext which will be run by a #GMainLoop in that thread, to set a new default context for all async operations in that thread. (In this case, you don't need to ever call g_main_context_pop_thread_default().) In some cases however, you may want to schedule a single operation in a non-default context, or temporarily use a non-default context in the main thread. In that case, you can wrap the call to the asynchronous operation inside a g_main_context_push_thread_default() / g_main_context_pop_thread_default() pair, but it is up to you to ensure that no other asynchronous operations accidentally get started while the non-default context is active. Beware that libraries that predate this function may not correctly handle being used from a thread with a thread-default context. Eg, see g_file_supports_thread_contexts(). a #GMainContext, or %NULL for the global default context Determines information necessary to poll this main loop. You must have successfully acquired the context with g_main_context_acquire() before you may call this function. the number of records actually stored in @fds, or, if more than @n_fds records need to be stored, the number of records that need to be stored. a #GMainContext maximum priority source to check location to store timeout to be used in polling location to store #GPollFD records that need to be polled. length of @fds. Increases the reference count on a #GMainContext object by one. the @context that was passed in (since 2.6) a #GMainContext Releases ownership of a context previously acquired by this thread with g_main_context_acquire(). If the context was acquired multiple times, the ownership will be released only when g_main_context_release() is called as many times as it was acquired. a #GMainContext Removes file descriptor from the set of file descriptors to be polled for a particular context. a #GMainContext a #GPollFD descriptor previously added with g_main_context_add_poll() Sets the function to use to handle polling of file descriptors. It will be used instead of the poll() system call (or GLib's replacement function, which is used where poll() isn't available). This function could possibly be used to integrate the GLib event loop with an external event loop. a #GMainContext the function to call to poll all file descriptors Decreases the reference count on a #GMainContext object by one. If the result is zero, free the context and free all associated memory. a #GMainContext Tries to become the owner of the specified context, as with g_main_context_acquire(). But if another thread is the owner, atomically drop @mutex and wait on @cond until that owner releases ownership or until @cond is signaled, then try again (once) to become the owner. %TRUE if the operation succeeded, and this thread is now the owner of @context. a #GMainContext a condition variable a mutex, currently held If @context is currently blocking in g_main_context_iteration() waiting for a source to become ready, cause it to stop blocking and return. Otherwise, cause the next invocation of g_main_context_iteration() to return without blocking. This API is useful for low-level control over #GMainContext; for example, integrating it with main loop implementations such as #GMainLoop. Another related use for this function is when implementing a main loop with a termination condition, computed from multiple threads: |[<!-- language="C" --> #define NUM_TASKS 10 static volatile gint tasks_remaining = NUM_TASKS; ... while (g_atomic_int_get (&tasks_remaining) != 0) g_main_context_iteration (NULL, TRUE); ]| Then in a thread: |[<!-- language="C" --> perform_work(); if (g_atomic_int_dec_and_test (&tasks_remaining)) g_main_context_wakeup (NULL); ]| a #GMainContext Returns the global default main context. This is the main context used for main loop functions when a main loop is not explicitly specified, and corresponds to the "main" main loop. See also g_main_context_get_thread_default(). the global default main context. Gets the thread-default #GMainContext for this thread. Asynchronous operations that want to be able to be run in contexts other than the default one should call this method or g_main_context_ref_thread_default() to get a #GMainContext to add their #GSources to. (Note that even in single-threaded programs applications may sometimes want to temporarily push a non-default context, so it is not safe to assume that this will always return %NULL if you are running in the default thread.) If you need to hold a reference on the context, use g_main_context_ref_thread_default() instead. the thread-default #GMainContext, or %NULL if the thread-default context is the global default context. Gets the thread-default #GMainContext for this thread, as with g_main_context_get_thread_default(), but also adds a reference to it with g_main_context_ref(). In addition, unlike g_main_context_get_thread_default(), if the thread-default context is the global default context, this will return that #GMainContext (with a ref added to it) rather than returning %NULL. the thread-default #GMainContext. Unref with g_main_context_unref() when you are done with it. The `GMainLoop` struct is an opaque data type representing the main event loop of a GLib or GTK+ application. Creates a new #GMainLoop structure. a new #GMainLoop. a #GMainContext (if %NULL, the default context will be used). set to %TRUE to indicate that the loop is running. This is not very important since calling g_main_loop_run() will set this to %TRUE anyway. Returns the #GMainContext of @loop. the #GMainContext of @loop a #GMainLoop. Checks to see if the main loop is currently being run via g_main_loop_run(). %TRUE if the mainloop is currently being run. a #GMainLoop. Stops a #GMainLoop from running. Any calls to g_main_loop_run() for the loop will return. Note that sources that have already been dispatched when g_main_loop_quit() is called will still be executed. a #GMainLoop Increases the reference count on a #GMainLoop object by one. @loop a #GMainLoop Runs a main loop until g_main_loop_quit() is called on the loop. If this is called for the thread of the loop's #GMainContext, it will process events from the loop, otherwise it will simply wait. a #GMainLoop Decreases the reference count on a #GMainLoop object by one. If the result is zero, free the loop and free all associated memory. a #GMainLoop The #GMappedFile represents a file mapping created with g_mapped_file_new(). It has only private members and should not be accessed directly. Maps a file into memory. On UNIX, this is using the mmap() function. If @writable is %TRUE, the mapped buffer may be modified, otherwise it is an error to modify the mapped buffer. Modifications to the buffer are not visible to other processes mapping the same file, and are not written back to the file. Note that modifications of the underlying file might affect the contents of the #GMappedFile. Therefore, mapping should only be used if the file will not be modified, or if all modifications of the file are done atomically (e.g. using g_file_set_contents()). If @filename is the name of an empty, regular file, the function will successfully return an empty #GMappedFile. In other cases of size 0 (e.g. device files such as /dev/null), @error will be set to the #GFileError value #G_FILE_ERROR_INVAL. a newly allocated #GMappedFile which must be unref'd with g_mapped_file_unref(), or %NULL if the mapping failed. The path of the file to load, in the GLib filename encoding whether the mapping should be writable Maps a file into memory. On UNIX, this is using the mmap() function. If @writable is %TRUE, the mapped buffer may be modified, otherwise it is an error to modify the mapped buffer. Modifications to the buffer are not visible to other processes mapping the same file, and are not written back to the file. Note that modifications of the underlying file might affect the contents of the #GMappedFile. Therefore, mapping should only be used if the file will not be modified, or if all modifications of the file are done atomically (e.g. using g_file_set_contents()). a newly allocated #GMappedFile which must be unref'd with g_mapped_file_unref(), or %NULL if the mapping failed. The file descriptor of the file to load whether the mapping should be writable This call existed before #GMappedFile had refcounting and is currently exactly the same as g_mapped_file_unref(). Use g_mapped_file_unref() instead. a #GMappedFile Creates a new #GBytes which references the data mapped from @file. The mapped contents of the file must not be modified after creating this bytes object, because a #GBytes should be immutable. A newly allocated #GBytes referencing data from @file a #GMappedFile Returns the contents of a #GMappedFile. Note that the contents may not be zero-terminated, even if the #GMappedFile is backed by a text file. If the file is empty then %NULL is returned. the contents of @file, or %NULL. a #GMappedFile Returns the length of the contents of a #GMappedFile. the length of the contents of @file. a #GMappedFile Increments the reference count of @file by one. It is safe to call this function from any thread. the passed in #GMappedFile. a #GMappedFile Decrements the reference count of @file by one. If the reference count drops to 0, unmaps the buffer of @file and frees it. It is safe to call this function from any thread. Since 2.22 a #GMappedFile A mixed enumerated type and flags field. You must specify one type (string, strdup, boolean, tristate). Additionally, you may optionally bitwise OR the type with the flag %G_MARKUP_COLLECT_OPTIONAL. It is likely that this enum will be extended in the future to support other types. used to terminate the list of attributes to collect collect the string pointer directly from the attribute_values[] array. Expects a parameter of type (const char **). If %G_MARKUP_COLLECT_OPTIONAL is specified and the attribute isn't present then the pointer will be set to %NULL as with %G_MARKUP_COLLECT_STRING, but expects a parameter of type (char **) and g_strdup()s the returned pointer. The pointer must be freed with g_free() expects a parameter of type (gboolean *) and parses the attribute value as a boolean. Sets %FALSE if the attribute isn't present. Valid boolean values consist of (case-insensitive) "false", "f", "no", "n", "0" and "true", "t", "yes", "y", "1" as with %G_MARKUP_COLLECT_BOOLEAN, but in the case of a missing attribute a value is set that compares equal to neither %FALSE nor %TRUE G_MARKUP_COLLECT_OPTIONAL is implied can be bitwise ORed with the other fields. If present, allows the attribute not to appear. A default value is set depending on what value type is used Error codes returned by markup parsing. text being parsed was not valid UTF-8 document contained nothing, or only whitespace document was ill-formed error should be set by #GMarkupParser functions; element wasn't known error should be set by #GMarkupParser functions; attribute wasn't known error should be set by #GMarkupParser functions; content was invalid error should be set by #GMarkupParser functions; a required attribute was missing A parse context is used to parse a stream of bytes that you expect to contain marked-up text. See g_markup_parse_context_new(), #GMarkupParser, and so on for more details. Creates a new parse context. A parse context is used to parse marked-up documents. You can feed any number of documents into a context, as long as no errors occur; once an error occurs, the parse context can't continue to parse text (you have to free it and create a new parse context). a new #GMarkupParseContext a #GMarkupParser one or more #GMarkupParseFlags user data to pass to #GMarkupParser functions user data destroy notifier called when the parse context is freed Signals to the #GMarkupParseContext that all data has been fed into the parse context with g_markup_parse_context_parse(). This function reports an error if the document isn't complete, for example if elements are still open. %TRUE on success, %FALSE if an error was set a #GMarkupParseContext Frees a #GMarkupParseContext. This function can't be called from inside one of the #GMarkupParser functions or while a subparser is pushed. a #GMarkupParseContext Retrieves the name of the currently open element. If called from the start_element or end_element handlers this will give the element_name as passed to those functions. For the parent elements, see g_markup_parse_context_get_element_stack(). the name of the currently open element, or %NULL a #GMarkupParseContext Retrieves the element stack from the internal state of the parser. The returned #GSList is a list of strings where the first item is the currently open tag (as would be returned by g_markup_parse_context_get_element()) and the next item is its immediate parent. This function is intended to be used in the start_element and end_element handlers where g_markup_parse_context_get_element() would merely return the name of the element that is being processed. the element stack, which must not be modified a #GMarkupParseContext Retrieves the current line number and the number of the character on that line. Intended for use in error messages; there are no strict semantics for what constitutes the "current" line number other than "the best number we could come up with for error messages." a #GMarkupParseContext return location for a line number, or %NULL return location for a char-on-line number, or %NULL Returns the user_data associated with @context. This will either be the user_data that was provided to g_markup_parse_context_new() or to the most recent call of g_markup_parse_context_push(). the provided user_data. The returned data belongs to the markup context and will be freed when g_markup_parse_context_free() is called. a #GMarkupParseContext Feed some data to the #GMarkupParseContext. The data need not be valid UTF-8; an error will be signaled if it's invalid. The data need not be an entire document; you can feed a document into the parser incrementally, via multiple calls to this function. Typically, as you receive data from a network connection or file, you feed each received chunk of data into this function, aborting the process if an error occurs. Once an error is reported, no further data may be fed to the #GMarkupParseContext; all errors are fatal. %FALSE if an error occurred, %TRUE on success a #GMarkupParseContext chunk of text to parse length of @text in bytes Completes the process of a temporary sub-parser redirection. This function exists to collect the user_data allocated by a matching call to g_markup_parse_context_push(). It must be called in the end_element handler corresponding to the start_element handler during which g_markup_parse_context_push() was called. You must not call this function from the error callback -- the @user_data is provided directly to the callback in that case. This function is not intended to be directly called by users interested in invoking subparsers. Instead, it is intended to be used by the subparsers themselves to implement a higher-level interface. the user data passed to g_markup_parse_context_push() a #GMarkupParseContext Temporarily redirects markup data to a sub-parser. This function may only be called from the start_element handler of a #GMarkupParser. It must be matched with a corresponding call to g_markup_parse_context_pop() in the matching end_element handler (except in the case that the parser aborts due to an error). All tags, text and other data between the matching tags is redirected to the subparser given by @parser. @user_data is used as the user_data for that parser. @user_data is also passed to the error callback in the event that an error occurs. This includes errors that occur in subparsers of the subparser. The end tag matching the start tag for which this call was made is handled by the previous parser (which is given its own user_data) which is why g_markup_parse_context_pop() is provided to allow "one last access" to the @user_data provided to this function. In the case of error, the @user_data provided here is passed directly to the error callback of the subparser and g_markup_parse_context_pop() should not be called. In either case, if @user_data was allocated then it ought to be freed from both of these locations. This function is not intended to be directly called by users interested in invoking subparsers. Instead, it is intended to be used by the subparsers themselves to implement a higher-level interface. As an example, see the following implementation of a simple parser that counts the number of tags encountered. |[<!-- language="C" --> typedef struct { gint tag_count; } CounterData; static void counter_start_element (GMarkupParseContext *context, const gchar *element_name, const gchar **attribute_names, const gchar **attribute_values, gpointer user_data, GError **error) { CounterData *data = user_data; data->tag_count++; } static void counter_error (GMarkupParseContext *context, GError *error, gpointer user_data) { CounterData *data = user_data; g_slice_free (CounterData, data); } static GMarkupParser counter_subparser = { counter_start_element, NULL, NULL, NULL, counter_error }; ]| In order to allow this parser to be easily used as a subparser, the following interface is provided: |[<!-- language="C" --> void start_counting (GMarkupParseContext *context) { CounterData *data = g_slice_new (CounterData); data->tag_count = 0; g_markup_parse_context_push (context, &counter_subparser, data); } gint end_counting (GMarkupParseContext *context) { CounterData *data = g_markup_parse_context_pop (context); int result; result = data->tag_count; g_slice_free (CounterData, data); return result; } ]| The subparser would then be used as follows: |[<!-- language="C" --> static void start_element (context, element_name, ...) { if (strcmp (element_name, "count-these") == 0) start_counting (context); // else, handle other tags... } static void end_element (context, element_name, ...) { if (strcmp (element_name, "count-these") == 0) g_print ("Counted %d tags\n", end_counting (context)); // else, handle other tags... } ]| a #GMarkupParseContext a #GMarkupParser user data to pass to #GMarkupParser functions Increases the reference count of @context. the same @context a #GMarkupParseContext Decreases the reference count of @context. When its reference count drops to 0, it is freed. a #GMarkupParseContext Flags that affect the behaviour of the parser. flag you should not use When this flag is set, CDATA marked sections are not passed literally to the @passthrough function of the parser. Instead, the content of the section (without the `<![CDATA[` and `]]>`) is passed to the @text function. This flag was added in GLib 2.12 Normally errors caught by GMarkup itself have line/column information prefixed to them to let the caller know the location of the error. When this flag is set the location information is also prefixed to errors generated by the #GMarkupParser implementation functions Ignore (don't report) qualified attributes and tags, along with their contents. A qualified attribute or tag is one that contains ':' in its name (ie: is in another namespace). Since: 2.40. Any of the fields in #GMarkupParser can be %NULL, in which case they will be ignored. Except for the @error function, any of these callbacks can set an error; in particular the %G_MARKUP_ERROR_UNKNOWN_ELEMENT, %G_MARKUP_ERROR_UNKNOWN_ATTRIBUTE, and %G_MARKUP_ERROR_INVALID_CONTENT errors are intended to be set from these callbacks. If you set an error from a callback, g_markup_parse_context_parse() will report that error back to its caller. A GMatchInfo is an opaque struct used to return information about matches. Returns a new string containing the text in @string_to_expand with references and escape sequences expanded. References refer to the last match done with @string against @regex and have the same syntax used by g_regex_replace(). The @string_to_expand must be UTF-8 encoded even if #G_REGEX_RAW was passed to g_regex_new(). The backreferences are extracted from the string passed to the match function, so you cannot call this function after freeing the string. @match_info may be %NULL in which case @string_to_expand must not contain references. For instance "foo\n" does not refer to an actual pattern and '\n' merely will be replaced with \n character, while to expand "\0" (whole match) one needs the result of a match. Use g_regex_check_replacement() to find out whether @string_to_expand contains references. the expanded string, or %NULL if an error occurred a #GMatchInfo or %NULL the string to expand Retrieves the text matching the @match_num'th capturing parentheses. 0 is the full text of the match, 1 is the first paren set, 2 the second, and so on. If @match_num is a valid sub pattern but it didn't match anything (e.g. sub pattern 1, matching "b" against "(a)?b") then an empty string is returned. If the match was obtained using the DFA algorithm, that is using g_regex_match_all() or g_regex_match_all_full(), the retrieved string is not that of a set of parentheses but that of a matched substring. Substrings are matched in reverse order of length, so 0 is the longest match. The string is fetched from the string passed to the match function, so you cannot call this function after freeing the string. The matched substring, or %NULL if an error occurred. You have to free the string yourself #GMatchInfo structure number of the sub expression Bundles up pointers to each of the matching substrings from a match and stores them in an array of gchar pointers. The first element in the returned array is the match number 0, i.e. the entire matched text. If a sub pattern didn't match anything (e.g. sub pattern 1, matching "b" against "(a)?b") then an empty string is inserted. If the last match was obtained using the DFA algorithm, that is using g_regex_match_all() or g_regex_match_all_full(), the retrieved strings are not that matched by sets of parentheses but that of the matched substring. Substrings are matched in reverse order of length, so the first one is the longest match. The strings are fetched from the string passed to the match function, so you cannot call this function after freeing the string. a %NULL-terminated array of gchar * pointers. It must be freed using g_strfreev(). If the previous match failed %NULL is returned a #GMatchInfo structure Retrieves the text matching the capturing parentheses named @name. If @name is a valid sub pattern name but it didn't match anything (e.g. sub pattern "X", matching "b" against "(?P<X>a)?b") then an empty string is returned. The string is fetched from the string passed to the match function, so you cannot call this function after freeing the string. The matched substring, or %NULL if an error occurred. You have to free the string yourself #GMatchInfo structure name of the subexpression Retrieves the position in bytes of the capturing parentheses named @name. If @name is a valid sub pattern name but it didn't match anything (e.g. sub pattern "X", matching "b" against "(?P<X>a)?b") then @start_pos and @end_pos are set to -1 and %TRUE is returned. %TRUE if the position was fetched, %FALSE otherwise. If the position cannot be fetched, @start_pos and @end_pos are left unchanged. #GMatchInfo structure name of the subexpression pointer to location where to store the start position, or %NULL pointer to location where to store the end position, or %NULL Retrieves the position in bytes of the @match_num'th capturing parentheses. 0 is the full text of the match, 1 is the first paren set, 2 the second, and so on. If @match_num is a valid sub pattern but it didn't match anything (e.g. sub pattern 1, matching "b" against "(a)?b") then @start_pos and @end_pos are set to -1 and %TRUE is returned. If the match was obtained using the DFA algorithm, that is using g_regex_match_all() or g_regex_match_all_full(), the retrieved position is not that of a set of parentheses but that of a matched substring. Substrings are matched in reverse order of length, so 0 is the longest match. %TRUE if the position was fetched, %FALSE otherwise. If the position cannot be fetched, @start_pos and @end_pos are left unchanged #GMatchInfo structure number of the sub expression pointer to location where to store the start position, or %NULL pointer to location where to store the end position, or %NULL If @match_info is not %NULL, calls g_match_info_unref(); otherwise does nothing. a #GMatchInfo, or %NULL Retrieves the number of matched substrings (including substring 0, that is the whole matched text), so 1 is returned if the pattern has no substrings in it and 0 is returned if the match failed. If the last match was obtained using the DFA algorithm, that is using g_regex_match_all() or g_regex_match_all_full(), the retrieved count is not that of the number of capturing parentheses but that of the number of matched substrings. Number of matched substrings, or -1 if an error occurred a #GMatchInfo structure Returns #GRegex object used in @match_info. It belongs to Glib and must not be freed. Use g_regex_ref() if you need to keep it after you free @match_info object. #GRegex object used in @match_info a #GMatchInfo Returns the string searched with @match_info. This is the string passed to g_regex_match() or g_regex_replace() so you may not free it before calling this function. the string searched with @match_info a #GMatchInfo Usually if the string passed to g_regex_match*() matches as far as it goes, but is too short to match the entire pattern, %FALSE is returned. There are circumstances where it might be helpful to distinguish this case from other cases in which there is no match. Consider, for example, an application where a human is required to type in data for a field with specific formatting requirements. An example might be a date in the form ddmmmyy, defined by the pattern "^\d?\d(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)\d\d$". If the application sees the user’s keystrokes one by one, and can check that what has been typed so far is potentially valid, it is able to raise an error as soon as a mistake is made. GRegex supports the concept of partial matching by means of the #G_REGEX_MATCH_PARTIAL_SOFT and #G_REGEX_MATCH_PARTIAL_HARD flags. When they are used, the return code for g_regex_match() or g_regex_match_full() is, as usual, %TRUE for a complete match, %FALSE otherwise. But, when these functions return %FALSE, you can check if the match was partial calling g_match_info_is_partial_match(). The difference between #G_REGEX_MATCH_PARTIAL_SOFT and #G_REGEX_MATCH_PARTIAL_HARD is that when a partial match is encountered with #G_REGEX_MATCH_PARTIAL_SOFT, matching continues to search for a possible complete match, while with #G_REGEX_MATCH_PARTIAL_HARD matching stops at the partial match. When both #G_REGEX_MATCH_PARTIAL_SOFT and #G_REGEX_MATCH_PARTIAL_HARD are set, the latter takes precedence. There were formerly some restrictions on the pattern for partial matching. The restrictions no longer apply. See pcrepartial(3) for more information on partial matching. %TRUE if the match was partial, %FALSE otherwise a #GMatchInfo structure Returns whether the previous match operation succeeded. %TRUE if the previous match operation succeeded, %FALSE otherwise a #GMatchInfo structure Scans for the next match using the same parameters of the previous call to g_regex_match_full() or g_regex_match() that returned @match_info. The match is done on the string passed to the match function, so you cannot free it before calling this function. %TRUE is the string matched, %FALSE otherwise a #GMatchInfo structure Increases reference count of @match_info by 1. @match_info a #GMatchInfo Decreases reference count of @match_info by 1. When reference count drops to zero, it frees all the memory associated with the match_info structure. a #GMatchInfo A set of functions used to perform memory allocation. The same #GMemVTable must be used for all allocations in the same program; a call to g_mem_set_vtable(), if it exists, should be prior to any use of GLib. The #GMutex struct is an opaque data structure to represent a mutex (mutual exclusion). It can be used to protect data against shared access. Take for example the following function: |[<!-- language="C" --> int give_me_next_number (void) { static int current_number = 0; // now do a very complicated calculation to calculate the new // number, this might for example be a random number generator current_number = calc_next_number (current_number); return current_number; } ]| It is easy to see that this won't work in a multi-threaded application. There current_number must be protected against shared access. A #GMutex can be used as a solution to this problem: |[<!-- language="C" --> int give_me_next_number (void) { static GMutex mutex; static int current_number = 0; int ret_val; g_mutex_lock (&mutex); ret_val = current_number = calc_next_number (current_number); g_mutex_unlock (&mutex); return ret_val; } ]| Notice that the #GMutex is not initialised to any particular value. Its placement in static storage ensures that it will be initialised to all-zeros, which is appropriate. If a #GMutex is placed in other contexts (eg: embedded in a struct) then it must be explicitly initialised using g_mutex_init(). A #GMutex should only be accessed via g_mutex_ functions. Frees the resources allocated to a mutex with g_mutex_init(). This function should not be used with a #GMutex that has been statically allocated. Calling g_mutex_clear() on a locked mutex leads to undefined behaviour. Sine: 2.32 an initialized #GMutex Initializes a #GMutex so that it can be used. This function is useful to initialize a mutex that has been allocated on the stack, or as part of a larger structure. It is not necessary to initialize a mutex that has been statically allocated. |[<!-- language="C" --> typedef struct { GMutex m; ... } Blob; Blob *b; b = g_new (Blob, 1); g_mutex_init (&b->m); ]| To undo the effect of g_mutex_init() when a mutex is no longer needed, use g_mutex_clear(). Calling g_mutex_init() on an already initialized #GMutex leads to undefined behaviour. an uninitialized #GMutex Locks @mutex. If @mutex is already locked by another thread, the current thread will block until @mutex is unlocked by the other thread. #GMutex is neither guaranteed to be recursive nor to be non-recursive. As such, calling g_mutex_lock() on a #GMutex that has already been locked by the same thread results in undefined behaviour (including but not limited to deadlocks). a #GMutex Tries to lock @mutex. If @mutex is already locked by another thread, it immediately returns %FALSE. Otherwise it locks @mutex and returns %TRUE. #GMutex is neither guaranteed to be recursive nor to be non-recursive. As such, calling g_mutex_lock() on a #GMutex that has already been locked by the same thread results in undefined behaviour (including but not limited to deadlocks or arbitrary return values). %TRUE if @mutex could be locked a #GMutex Unlocks @mutex. If another thread is blocked in a g_mutex_lock() call for @mutex, it will become unblocked and can lock @mutex itself. Calling g_mutex_unlock() on a mutex that is not locked by the current thread leads to undefined behaviour. a #GMutex The #GNode struct represents one node in a [n-ary tree][glib-N-ary-Trees]. contains the actual data of the node. points to the node's next sibling (a sibling is another #GNode with the same parent). points to the node's previous sibling. points to the parent of the #GNode, or is %NULL if the #GNode is the root of the tree. points to the first child of the #GNode. The other children are accessed by using the @next pointer of each child. Gets the position of the first child of a #GNode which contains the given data. the index of the child of @node which contains @data, or -1 if the data is not found a #GNode the data to find Gets the position of a #GNode with respect to its siblings. @child must be a child of @node. The first child is numbered 0, the second 1, and so on. the position of @child with respect to its siblings a #GNode a child of @node Calls a function for each of the children of a #GNode. Note that it doesn't descend beneath the child nodes. a #GNode which types of children are to be visited, one of %G_TRAVERSE_ALL, %G_TRAVERSE_LEAVES and %G_TRAVERSE_NON_LEAVES the function to call for each visited node user data to pass to the function Recursively copies a #GNode (but does not deep-copy the data inside the nodes, see g_node_copy_deep() if you need that). a new #GNode containing the same data pointers a #GNode Recursively copies a #GNode and its data. a new #GNode containing copies of the data in @node. a #GNode the function which is called to copy the data inside each node, or %NULL to use the original data. data to pass to @copy_func Gets the depth of a #GNode. If @node is %NULL the depth is 0. The root node has a depth of 1. For the children of the root node the depth is 2. And so on. the depth of the #GNode a #GNode Removes @root and its children from the tree, freeing any memory allocated. the root of the tree/subtree to destroy Finds a #GNode in a tree. the found #GNode, or %NULL if the data is not found the root #GNode of the tree to search the order in which nodes are visited - %G_IN_ORDER, %G_PRE_ORDER, %G_POST_ORDER, or %G_LEVEL_ORDER which types of children are to be searched, one of %G_TRAVERSE_ALL, %G_TRAVERSE_LEAVES and %G_TRAVERSE_NON_LEAVES the data to find Finds the first child of a #GNode with the given data. the found child #GNode, or %NULL if the data is not found a #GNode which types of children are to be searched, one of %G_TRAVERSE_ALL, %G_TRAVERSE_LEAVES and %G_TRAVERSE_NON_LEAVES the data to find Gets the first sibling of a #GNode. This could possibly be the node itself. the first sibling of @node a #GNode Gets the root of a tree. the root of the tree a #GNode Inserts a #GNode beneath the parent at the given position. the inserted #GNode the #GNode to place @node under the position to place @node at, with respect to its siblings If position is -1, @node is inserted as the last child of @parent the #GNode to insert Inserts a #GNode beneath the parent after the given sibling. the inserted #GNode the #GNode to place @node under the sibling #GNode to place @node after. If sibling is %NULL, the node is inserted as the first child of @parent. the #GNode to insert Inserts a #GNode beneath the parent before the given sibling. the inserted #GNode the #GNode to place @node under the sibling #GNode to place @node before. If sibling is %NULL, the node is inserted as the last child of @parent. the #GNode to insert Returns %TRUE if @node is an ancestor of @descendant. This is true if node is the parent of @descendant, or if node is the grandparent of @descendant etc. %TRUE if @node is an ancestor of @descendant a #GNode a #GNode Gets the last child of a #GNode. the last child of @node, or %NULL if @node has no children a #GNode (must not be %NULL) Gets the last sibling of a #GNode. This could possibly be the node itself. the last sibling of @node a #GNode Gets the maximum height of all branches beneath a #GNode. This is the maximum distance from the #GNode to all leaf nodes. If @root is %NULL, 0 is returned. If @root has no children, 1 is returned. If @root has children, 2 is returned. And so on. the maximum height of the tree beneath @root a #GNode Gets the number of children of a #GNode. the number of children of @node a #GNode Gets the number of nodes in a tree. the number of nodes in the tree a #GNode which types of children are to be counted, one of %G_TRAVERSE_ALL, %G_TRAVERSE_LEAVES and %G_TRAVERSE_NON_LEAVES Gets a child of a #GNode, using the given index. The first child is at index 0. If the index is too big, %NULL is returned. the child of @node at index @n a #GNode the index of the desired child Inserts a #GNode as the first child of the given parent. the inserted #GNode the #GNode to place the new #GNode under the #GNode to insert Reverses the order of the children of a #GNode. (It doesn't change the order of the grandchildren.) a #GNode. Traverses a tree starting at the given root #GNode. It calls the given function for each node visited. The traversal can be halted at any point by returning %TRUE from @func. the root #GNode of the tree to traverse the order in which nodes are visited - %G_IN_ORDER, %G_PRE_ORDER, %G_POST_ORDER, or %G_LEVEL_ORDER. which types of children are to be visited, one of %G_TRAVERSE_ALL, %G_TRAVERSE_LEAVES and %G_TRAVERSE_NON_LEAVES the maximum depth of the traversal. Nodes below this depth will not be visited. If max_depth is -1 all nodes in the tree are visited. If depth is 1, only the root is visited. If depth is 2, the root and its children are visited. And so on. the function to call for each visited #GNode user data to pass to the function Unlinks a #GNode from a tree, resulting in two separate trees. the #GNode to unlink, which becomes the root of a new tree Creates a new #GNode containing the given data. Used to create the first node in a tree. a new #GNode the data of the new node Specifies the type of function passed to g_node_children_foreach(). The function is called with each child node, together with the user data passed to g_node_children_foreach(). a #GNode. user data passed to g_node_children_foreach(). Specifies the type of function passed to g_node_traverse(). The function is called with each of the nodes visited, together with the user data passed to g_node_traverse(). If the function returns %TRUE, then the traversal is stopped. %TRUE to stop the traversal. a #GNode. user data passed to g_node_traverse(). Defines how a Unicode string is transformed in a canonical form, standardizing such issues as whether a character with an accent is represented as a base character and combining accent or as a single precomposed character. Unicode strings should generally be normalized before comparing them. standardize differences that do not affect the text content, such as the above-mentioned accent representation another name for %G_NORMALIZE_DEFAULT like %G_NORMALIZE_DEFAULT, but with composed forms rather than a maximally decomposed form another name for %G_NORMALIZE_DEFAULT_COMPOSE beyond %G_NORMALIZE_DEFAULT also standardize the "compatibility" characters in Unicode, such as SUPERSCRIPT THREE to the standard forms (in this case DIGIT THREE). Formatting information may be lost but for most text operations such characters should be considered the same another name for %G_NORMALIZE_ALL like %G_NORMALIZE_ALL, but with composed forms rather than a maximally decomposed form another name for %G_NORMALIZE_ALL_COMPOSE If a long option in the main group has this name, it is not treated as a regular option. Instead it collects all non-option arguments which would otherwise be left in `argv`. The option must be of type %G_OPTION_ARG_CALLBACK, %G_OPTION_ARG_STRING_ARRAY or %G_OPTION_ARG_FILENAME_ARRAY. Using #G_OPTION_REMAINING instead of simply scanning `argv` for leftover arguments has the advantage that GOption takes care of necessary encoding conversions for strings or filenames. A #GOnce struct controls a one-time initialization function. Any one-time initialization function must have its own unique #GOnce struct. the status of the #GOnce the value returned by the call to the function, if @status is %G_ONCE_STATUS_READY Function to be called when starting a critical initialization section. The argument @location must point to a static 0-initialized variable that will be set to a value other than 0 at the end of the initialization section. In combination with g_once_init_leave() and the unique address @value_location, it can be ensured that an initialization section will be executed only once during a program's life time, and that concurrent threads are blocked until initialization completed. To be used in constructs like this: |[<!-- language="C" --> static gsize initialization_value = 0; if (g_once_init_enter (&initialization_value)) { gsize setup_value = 42; // initialization code here g_once_init_leave (&initialization_value, setup_value); } // use initialization_value here ]| %TRUE if the initialization section should be entered, %FALSE and blocks otherwise location of a static initializable variable containing 0 Counterpart to g_once_init_enter(). Expects a location of a static 0-initialized initialization variable, and an initialization value other than 0. Sets the variable to the initialization value, and releases concurrent threads blocking in g_once_init_enter() on this initialization variable. location of a static initializable variable containing 0 new non-0 value for *@value_location The possible statuses of a one-time initialization function controlled by a #GOnce struct. the function has not been called yet. the function call is currently in progress. the function has been called. The #GOptionArg enum values determine which type of extra argument the options expect to find. If an option expects an extra argument, it can be specified in several ways; with a short option: `-x arg`, with a long option: `--name arg` or combined in a single argument: `--name=arg`. No extra argument. This is useful for simple flags. The option takes a string argument. The option takes an integer argument. The option provides a callback to parse the extra argument. The option takes a filename as argument. The option takes a string argument, multiple uses of the option are collected into an array of strings. The option takes a filename as argument, multiple uses of the option are collected into an array of strings. The option takes a double argument. The argument can be formatted either for the user's locale or for the "C" locale. Since 2.12 The option takes a 64-bit integer. Like %G_OPTION_ARG_INT but for larger numbers. The number can be in decimal base, or in hexadecimal (when prefixed with `0x`, for example, `0xffffffff`). Since 2.12 The type of function to be passed as callback for %G_OPTION_ARG_CALLBACK options. %TRUE if the option was successfully parsed, %FALSE if an error occurred, in which case @error should be set with g_set_error() The name of the option being parsed. This will be either a single dash followed by a single letter (for a short name) or two dashes followed by a long option name. The value to be parsed. User data added to the #GOptionGroup containing the option when it was created with g_option_group_new() A `GOptionContext` struct defines which options are accepted by the commandline option parser. The struct has only private fields and should not be directly accessed. Adds a #GOptionGroup to the @context, so that parsing with @context will recognize the options in the group. Note that the group will be freed together with the context when g_option_context_free() is called, so you must not free the group yourself after adding it to a context. a #GOptionContext the group to add A convenience function which creates a main group if it doesn't exist, adds the @entries to it and sets the translation domain. a #GOptionContext a %NULL-terminated array of #GOptionEntrys a translation domain to use for translating the `--help` output for the options in @entries with gettext(), or %NULL Frees context and all the groups which have been added to it. Please note that parsed arguments need to be freed separately (see #GOptionEntry). a #GOptionContext Returns the description. See g_option_context_set_description(). the description a #GOptionContext Returns a formatted, translated help text for the given context. To obtain the text produced by `--help`, call `g_option_context_get_help (context, TRUE, NULL)`. To obtain the text produced by `--help-all`, call `g_option_context_get_help (context, FALSE, NULL)`. To obtain the help text for an option group, call `g_option_context_get_help (context, FALSE, group)`. A newly allocated string containing the help text a #GOptionContext if %TRUE, only include the main group the #GOptionGroup to create help for, or %NULL Returns whether automatic `--help` generation is turned on for @context. See g_option_context_set_help_enabled(). %TRUE if automatic help generation is turned on. a #GOptionContext Returns whether unknown options are ignored or not. See g_option_context_set_ignore_unknown_options(). %TRUE if unknown options are ignored. a #GOptionContext Returns a pointer to the main group of @context. the main group of @context, or %NULL if @context doesn't have a main group. Note that group belongs to @context and should not be modified or freed. a #GOptionContext Returns the summary. See g_option_context_set_summary(). the summary a #GOptionContext Parses the command line arguments, recognizing options which have been added to @context. A side-effect of calling this function is that g_set_prgname() will be called. If the parsing is successful, any parsed arguments are removed from the array and @argc and @argv are updated accordingly. A '--' option is stripped from @argv unless there are unparsed options before and after it, or some of the options after it start with '-'. In case of an error, @argc and @argv are left unmodified. If automatic `--help` support is enabled (see g_option_context_set_help_enabled()), and the @argv array contains one of the recognized help options, this function will produce help output to stdout and call `exit (0)`. Note that function depends on the [current locale][setlocale] for automatic character set conversion of string and filename arguments. %TRUE if the parsing was successful, %FALSE if an error occurred a #GOptionContext a pointer to the number of command line arguments a pointer to the array of command line arguments Parses the command line arguments. This function is similar to g_option_context_parse() except that it respects the normal memory rules when dealing with a strv instead of assuming that the passed-in array is the argv of the main function. In particular, strings that are removed from the arguments list will be freed using g_free(). On Windows, the strings are expected to be in UTF-8. This is in contrast to g_option_context_parse() which expects them to be in the system codepage, which is how they are passed as @argv to main(). See g_win32_get_command_line() for a solution. This function is useful if you are trying to use #GOptionContext with #GApplication. %TRUE if the parsing was successful, %FALSE if an error occurred a #GOptionContext a pointer to the command line arguments (which must be in UTF-8 on Windows) Adds a string to be displayed in `--help` output after the list of options. This text often includes a bug reporting address. Note that the summary is translated (see g_option_context_set_translate_func()). a #GOptionContext a string to be shown in `--help` output after the list of options, or %NULL Enables or disables automatic generation of `--help` output. By default, g_option_context_parse() recognizes `--help`, `-h`, `-?`, `--help-all` and `--help-groupname` and creates suitable output to stdout. a #GOptionContext %TRUE to enable `--help`, %FALSE to disable it Sets whether to ignore unknown options or not. If an argument is ignored, it is left in the @argv array after parsing. By default, g_option_context_parse() treats unknown options as error. This setting does not affect non-option arguments (i.e. arguments which don't start with a dash). But note that GOption cannot reliably determine whether a non-option belongs to a preceding unknown option. a #GOptionContext %TRUE to ignore unknown options, %FALSE to produce an error when unknown options are met Sets a #GOptionGroup as main group of the @context. This has the same effect as calling g_option_context_add_group(), the only difference is that the options in the main group are treated differently when generating `--help` output. a #GOptionContext the group to set as main group Adds a string to be displayed in `--help` output before the list of options. This is typically a summary of the program functionality. Note that the summary is translated (see g_option_context_set_translate_func() and g_option_context_set_translation_domain()). a #GOptionContext a string to be shown in `--help` output before the list of options, or %NULL Sets the function which is used to translate the contexts user-visible strings, for `--help` output. If @func is %NULL, strings are not translated. Note that option groups have their own translation functions, this function only affects the @parameter_string (see g_option_context_new()), the summary (see g_option_context_set_summary()) and the description (see g_option_context_set_description()). If you are using gettext(), you only need to set the translation domain, see g_option_context_set_translation_domain(). a #GOptionContext the #GTranslateFunc, or %NULL user data to pass to @func, or %NULL a function which gets called to free @data, or %NULL A convenience function to use gettext() for translating user-visible strings. a #GOptionContext the domain to use Creates a new option context. The @parameter_string can serve multiple purposes. It can be used to add descriptions for "rest" arguments, which are not parsed by the #GOptionContext, typically something like "FILES" or "FILE1 FILE2...". If you are using #G_OPTION_REMAINING for collecting "rest" arguments, GLib handles this automatically by using the @arg_description of the corresponding #GOptionEntry in the usage summary. Another usage is to give a short summary of the program functionality, like " - frob the strings", which will be displayed in the same line as the usage. For a longer description of the program functionality that should be displayed as a paragraph below the usage line, use g_option_context_set_summary(). Note that the @parameter_string is translated using the function set with g_option_context_set_translate_func(), so it should normally be passed untranslated. a newly created #GOptionContext, which must be freed with g_option_context_free() after use. a string which is displayed in the first line of `--help` output, after the usage summary `programname [OPTION...]` A GOptionEntry struct defines a single option. To have an effect, they must be added to a #GOptionGroup with g_option_context_add_main_entries() or g_option_group_add_entries(). The long name of an option can be used to specify it in a commandline as `--long_name`. Every option must have a long name. To resolve conflicts if multiple option groups contain the same long name, it is also possible to specify the option as `--groupname-long_name`. If an option has a short name, it can be specified `-short_name` in a commandline. @short_name must be a printable ASCII character different from '-', or zero if the option has no short name. Flags from #GOptionFlags The type of the option, as a #GOptionArg If the @arg type is %G_OPTION_ARG_CALLBACK, then @arg_data must point to a #GOptionArgFunc callback function, which will be called to handle the extra argument. Otherwise, @arg_data is a pointer to a location to store the value, the required type of the location depends on the @arg type: - %G_OPTION_ARG_NONE: %gboolean - %G_OPTION_ARG_STRING: %gchar* - %G_OPTION_ARG_INT: %gint - %G_OPTION_ARG_FILENAME: %gchar* - %G_OPTION_ARG_STRING_ARRAY: %gchar** - %G_OPTION_ARG_FILENAME_ARRAY: %gchar** - %G_OPTION_ARG_DOUBLE: %gdouble If @arg type is %G_OPTION_ARG_STRING or %G_OPTION_ARG_FILENAME, the location will contain a newly allocated string if the option was given. That string needs to be freed by the callee using g_free(). Likewise if @arg type is %G_OPTION_ARG_STRING_ARRAY or %G_OPTION_ARG_FILENAME_ARRAY, the data should be freed using g_strfreev(). the description for the option in `--help` output. The @description is translated using the @translate_func of the group, see g_option_group_set_translation_domain(). The placeholder to use for the extra argument parsed by the option in `--help` output. The @arg_description is translated using the @translate_func of the group, see g_option_group_set_translation_domain(). Error codes returned by option parsing. An option was not known to the parser. This error will only be reported, if the parser hasn't been instructed to ignore unknown options, see g_option_context_set_ignore_unknown_options(). A value couldn't be parsed. A #GOptionArgFunc callback failed. The type of function to be used as callback when a parse error occurs. The active #GOptionContext The group to which the function belongs User data added to the #GOptionGroup containing the option when it was created with g_option_group_new() Flags which modify individual options. No flags. Since: 2.42. The option doesn't appear in `--help` output. The option appears in the main section of the `--help` output, even if it is defined in a group. For options of the %G_OPTION_ARG_NONE kind, this flag indicates that the sense of the option is reversed. For options of the %G_OPTION_ARG_CALLBACK kind, this flag indicates that the callback does not take any argument (like a %G_OPTION_ARG_NONE option). Since 2.8 For options of the %G_OPTION_ARG_CALLBACK kind, this flag indicates that the argument should be passed to the callback in the GLib filename encoding rather than UTF-8. Since 2.8 For options of the %G_OPTION_ARG_CALLBACK kind, this flag indicates that the argument supply is optional. If no argument is given then data of %GOptionParseFunc will be set to NULL. Since 2.8 This flag turns off the automatic conflict resolution which prefixes long option names with `groupname-` if there is a conflict. This option should only be used in situations where aliasing is necessary to model some legacy commandline interface. It is not safe to use this option, unless all option groups are under your direct control. Since 2.8. A `GOptionGroup` struct defines the options in a single group. The struct has only private fields and should not be directly accessed. All options in a group share the same translation function. Libraries which need to parse commandline options are expected to provide a function for getting a `GOptionGroup` holding their options, which the application can then add to its #GOptionContext. Adds the options specified in @entries to @group. a #GOptionGroup a %NULL-terminated array of #GOptionEntrys Frees a #GOptionGroup. Note that you must not free groups which have been added to a #GOptionContext. a #GOptionGroup Associates a function with @group which will be called from g_option_context_parse() when an error occurs. Note that the user data to be passed to @error_func can be specified when constructing the group with g_option_group_new(). a #GOptionGroup a function to call when an error occurs Associates two functions with @group which will be called from g_option_context_parse() before the first option is parsed and after the last option has been parsed, respectively. Note that the user data to be passed to @pre_parse_func and @post_parse_func can be specified when constructing the group with g_option_group_new(). a #GOptionGroup a function to call before parsing, or %NULL a function to call after parsing, or %NULL Sets the function which is used to translate user-visible strings, for `--help` output. Different groups can use different #GTranslateFuncs. If @func is %NULL, strings are not translated. If you are using gettext(), you only need to set the translation domain, see g_option_group_set_translation_domain(). a #GOptionGroup the #GTranslateFunc, or %NULL user data to pass to @func, or %NULL a function which gets called to free @data, or %NULL A convenience function to use gettext() for translating user-visible strings. a #GOptionGroup the domain to use Creates a new #GOptionGroup. a newly created option group. It should be added to a #GOptionContext or freed with g_option_group_free(). the name for the option group, this is used to provide help for the options in this group with `--help-`@name a description for this group to be shown in `--help`. This string is translated using the translation domain or translation function of the group a description for the `--help-`@name option. This string is translated using the translation domain or translation function of the group user data that will be passed to the pre- and post-parse hooks, the error hook and to callbacks of %G_OPTION_ARG_CALLBACK options, or %NULL a function that will be called to free @user_data, or %NULL The type of function that can be called before and after parsing. %TRUE if the function completed successfully, %FALSE if an error occurred, in which case @error should be set with g_set_error() The active #GOptionContext The group to which the function belongs User data added to the #GOptionGroup containing the option when it was created with g_option_group_new() Specifies one of the possible types of byte order (currently unused). See #G_BYTE_ORDER. The value of pi (ratio of circle's circumference to its diameter). Pi divided by 2. Pi divided by 4. A format specifier that can be used in printf()-style format strings when printing the @fd member of a #GPollFD. Use this for default priority event sources. In GLib this priority is used when adding timeout functions with g_timeout_add(). In GDK this priority is used for events from the X server. Use this for default priority idle functions. In GLib this priority is used when adding idle functions with g_idle_add(). Use this for high priority event sources. It is not used within GLib or GTK+. Use this for high priority idle functions. GTK+ uses #G_PRIORITY_HIGH_IDLE + 10 for resizing operations, and #G_PRIORITY_HIGH_IDLE + 20 for redrawing operations. (This is done to ensure that any pending resizes are processed before any pending redraws, so that widgets are not redrawn twice unnecessarily.) Use this for very low priority background tasks. It is not used within GLib or GTK+. A GPatternSpec struct is the 'compiled' form of a pattern. This structure is opaque and its fields cannot be accessed directly. Compares two compiled pattern specs and returns whether they will match the same set of strings. Whether the compiled patterns are equal a #GPatternSpec another #GPatternSpec Frees the memory allocated for the #GPatternSpec. a #GPatternSpec Compiles a pattern to a #GPatternSpec. a newly-allocated #GPatternSpec a zero-terminated UTF-8 encoded string Represents a file descriptor, which events to poll for, and which events occurred. the file descriptor to poll (or a HANDLE on Win32) a bitwise combination from #GIOCondition, specifying which events should be polled for. Typically for reading from a file descriptor you would use %G_IO_IN | %G_IO_HUP | %G_IO_ERR, and for writing you would use %G_IO_OUT | %G_IO_ERR. a bitwise combination of flags from #GIOCondition, returned from the poll() function to indicate which events occurred. Specifies the type of function passed to g_main_context_set_poll_func(). The semantics of the function should match those of the poll() system call. the number of #GPollFD elements which have events or errors reported, or -1 if an error occurred. an array of #GPollFD elements the number of elements in @ufds the maximum time to wait for an event of the file descriptors. A negative value indicates an infinite timeout. Specifies the type of the print handler functions. These are called with the complete formatted string to output. the message to output The #GPrivate struct is an opaque data structure to represent a thread-local data key. It is approximately equivalent to the pthread_setspecific()/pthread_getspecific() APIs on POSIX and to TlsSetValue()/TlsGetValue() on Windows. If you don't already know why you might want this functionality, then you probably don't need it. #GPrivate is a very limited resource (as far as 128 per program, shared between all libraries). It is also not possible to destroy a #GPrivate after it has been used. As such, it is only ever acceptable to use #GPrivate in static scope, and even then sparingly so. See G_PRIVATE_INIT() for a couple of examples. The #GPrivate structure should be considered opaque. It should only be accessed via the g_private_ functions. Returns the current value of the thread local variable @key. If the value has not yet been set in this thread, %NULL is returned. Values are never copied between threads (when a new thread is created, for example). the thread-local value a #GPrivate Sets the thread local variable @key to have the value @value in the current thread. This function differs from g_private_set() in the following way: if the previous value was non-%NULL then the #GDestroyNotify handler for @key is run on it. a #GPrivate the new value Sets the thread local variable @key to have the value @value in the current thread. This function differs from g_private_replace() in the following way: the #GDestroyNotify for @key is not called on the old value. a #GPrivate the new value Contains the public fields of a pointer array. points to the array of pointers, which may be moved when the array grows number of pointers in the array Adds a pointer to the end of the pointer array. The array will grow in size automatically if necessary. a #GPtrArray the pointer to add Calls a function for each element of a #GPtrArray. a #GPtrArray the function to call for each array element user data to pass to the function Frees the memory allocated for the #GPtrArray. If @free_seg is %TRUE it frees the memory block holding the elements as well. Pass %FALSE if you want to free the #GPtrArray wrapper but preserve the underlying array for use elsewhere. If the reference count of @array is greater than one, the #GPtrArray wrapper is preserved but the size of @array will be set to zero. If array contents point to dynamically-allocated memory, they should be freed separately if @free_seg is %TRUE and no #GDestroyNotify function has been set for @array. the pointer array if @free_seg is %FALSE, otherwise %NULL. The pointer array should be freed using g_free(). a #GPtrArray if %TRUE the actual pointer array is freed as well Inserts an element into the pointer array at the given index. The array will grow in size automatically if necessary. a #GPtrArray the index to place the new element at, or -1 to append the pointer to add. Creates a new #GPtrArray with a reference count of 1. the new #GPtrArray Creates a new #GPtrArray with @reserved_size pointers preallocated and a reference count of 1. This avoids frequent reallocation, if you are going to add many pointers to the array. Note however that the size of the array is still 0. It also set @element_free_func for freeing each element when the array is destroyed either via g_ptr_array_unref(), when g_ptr_array_free() is called with @free_segment set to %TRUE or when removing elements. A new #GPtrArray number of pointers preallocated A function to free elements with destroy @array or %NULL Creates a new #GPtrArray with a reference count of 1 and use @element_free_func for freeing each element when the array is destroyed either via g_ptr_array_unref(), when g_ptr_array_free() is called with @free_segment set to %TRUE or when removing elements. A new #GPtrArray A function to free elements with destroy @array or %NULL Atomically increments the reference count of @array by one. This function is thread-safe and may be called from any thread. The passed in #GPtrArray a #GPtrArray Removes the first occurrence of the given pointer from the pointer array. The following elements are moved down one place. If @array has a non-%NULL #GDestroyNotify function it is called for the removed element. It returns %TRUE if the pointer was removed, or %FALSE if the pointer was not found. %TRUE if the pointer is removed, %FALSE if the pointer is not found in the array a #GPtrArray the pointer to remove Removes the first occurrence of the given pointer from the pointer array. The last element in the array is used to fill in the space, so this function does not preserve the order of the array. But it is faster than g_ptr_array_remove(). If @array has a non-%NULL #GDestroyNotify function it is called for the removed element. It returns %TRUE if the pointer was removed, or %FALSE if the pointer was not found. %TRUE if the pointer was found in the array a #GPtrArray the pointer to remove Removes the pointer at the given index from the pointer array. The following elements are moved down one place. If @array has a non-%NULL #GDestroyNotify function it is called for the removed element. the pointer which was removed a #GPtrArray the index of the pointer to remove Removes the pointer at the given index from the pointer array. The last element in the array is used to fill in the space, so this function does not preserve the order of the array. But it is faster than g_ptr_array_remove_index(). If @array has a non-%NULL #GDestroyNotify function it is called for the removed element. the pointer which was removed a #GPtrArray the index of the pointer to remove Removes the given number of pointers starting at the given index from a #GPtrArray. The following elements are moved to close the gap. If @array has a non-%NULL #GDestroyNotify function it is called for the removed elements. the @array a @GPtrArray the index of the first pointer to remove the number of pointers to remove Sets a function for freeing each element when @array is destroyed either via g_ptr_array_unref(), when g_ptr_array_free() is called with @free_segment set to %TRUE or when removing elements. A #GPtrArray A function to free elements with destroy @array or %NULL Sets the size of the array. When making the array larger, newly-added elements will be set to %NULL. When making it smaller, if @array has a non-%NULL #GDestroyNotify function then it will be called for the removed elements. a #GPtrArray the new length of the pointer array Creates a new #GPtrArray with @reserved_size pointers preallocated and a reference count of 1. This avoids frequent reallocation, if you are going to add many pointers to the array. Note however that the size of the array is still 0. the new #GPtrArray number of pointers preallocated Sorts the array, using @compare_func which should be a qsort()-style comparison function (returns less than zero for first arg is less than second arg, zero for equal, greater than zero if irst arg is greater than second arg). Note that the comparison function for g_ptr_array_sort() doesn't take the pointers from the array as arguments, it takes pointers to the pointers in the array. This is guaranteed to be a stable sort since version 2.32. a #GPtrArray comparison function Like g_ptr_array_sort(), but the comparison function has an extra user data argument. Note that the comparison function for g_ptr_array_sort_with_data() doesn't take the pointers from the array as arguments, it takes pointers to the pointers in the array. This is guaranteed to be a stable sort since version 2.32. a #GPtrArray comparison function data to pass to @compare_func Atomically decrements the reference count of @array by one. If the reference count drops to 0, the effect is the same as calling g_ptr_array_free() with @free_segment set to %TRUE. This function is MT-safe and may be called from any thread. A #GPtrArray Contains the public fields of a [Queue][glib-Double-ended-Queues]. a pointer to the first element of the queue a pointer to the last element of the queue the number of elements in the queue Removes all the elements in @queue. If queue elements contain dynamically-allocated memory, they should be freed first. a #GQueue Copies a @queue. Note that is a shallow copy. If the elements in the queue consist of pointers to data, the pointers are copied, but the actual data is not. a copy of @queue a #GQueue Removes @link_ from @queue and frees it. @link_ must be part of @queue. a #GQueue a #GList link that must be part of @queue Finds the first link in @queue which contains @data. the first link in @queue which contains @data a #GQueue data to find Finds an element in a #GQueue, using a supplied function to find the desired element. It iterates over the queue, calling the given function which should return 0 when the desired element is found. The function takes two gconstpointer arguments, the #GQueue element's data as the first argument and the given user data as the second argument. the found link, or %NULL if it wasn't found a #GQueue user data passed to @func a #GCompareFunc to call for each element. It should return 0 when the desired element is found Calls @func for each element in the queue passing @user_data to the function. a #GQueue the function to call for each element's data user data to pass to @func Frees the memory allocated for the #GQueue. Only call this function if @queue was created with g_queue_new(). If queue elements contain dynamically-allocated memory, they should be freed first. If queue elements contain dynamically-allocated memory, you should either use g_queue_free_full() or free them manually first. a #GQueue Convenience method, which frees all the memory used by a #GQueue, and calls the specified destroy function on every element's data. a pointer to a #GQueue the function to be called to free each element's data Returns the number of items in @queue. the number of items in @queue a #GQueue Returns the position of the first element in @queue which contains @data. the position of the first element in @queue which contains @data, or -1 if no element in @queue contains @data a #GQueue the data to find A statically-allocated #GQueue must be initialized with this function before it can be used. Alternatively you can initialize it with #G_QUEUE_INIT. It is not necessary to initialize queues created with g_queue_new(). an uninitialized #GQueue Inserts @data into @queue after @sibling @sibling must be part of @queue a #GQueue a #GList link that must be part of @queue the data to insert Inserts @data into @queue before @sibling. @sibling must be part of @queue. a #GQueue a #GList link that must be part of @queue the data to insert Inserts @data into @queue using @func to determine the new position. a #GQueue the data to insert the #GCompareDataFunc used to compare elements in the queue. It is called with two elements of the @queue and @user_data. It should return 0 if the elements are equal, a negative value if the first element comes before the second, and a positive value if the second element comes before the first. user data passed to @func Returns %TRUE if the queue is empty. %TRUE if the queue is empty a #GQueue. Returns the position of @link_ in @queue. the position of @link_, or -1 if the link is not part of @queue a #GQueue a #GList link Returns the first element of the queue. the data of the first element in the queue, or %NULL if the queue is empty a #GQueue Returns the first link in @queue. the first link in @queue, or %NULL if @queue is empty a #GQueue Returns the @n'th element of @queue. the data for the @n'th element of @queue, or %NULL if @n is off the end of @queue a #GQueue the position of the element Returns the link at the given position the link at the @n'th position, or %NULL if @n is off the end of the list a #GQueue the position of the link Returns the last element of the queue. the data of the last element in the queue, or %NULL if the queue is empty a #GQueue Returns the last link in @queue. the last link in @queue, or %NULL if @queue is empty a #GQueue Removes the first element of the queue and returns its data. the data of the first element in the queue, or %NULL if the queue is empty a #GQueue Removes and returns the first element of the queue. the #GList element at the head of the queue, or %NULL if the queue is empty a #GQueue Removes the @n'th element of @queue and returns its data. the element's data, or %NULL if @n is off the end of @queue a #GQueue the position of the element Removes and returns the link at the given position. the @n'th link, or %NULL if @n is off the end of @queue a #GQueue the link's position Removes the last element of the queue and returns its data. the data of the last element in the queue, or %NULL if the queue is empty a #GQueue Removes and returns the last element of the queue. the #GList element at the tail of the queue, or %NULL if the queue is empty a #GQueue Adds a new element at the head of the queue. a #GQueue. the data for the new element. Adds a new element at the head of the queue. a #GQueue a single #GList element, not a list with more than one element Inserts a new element into @queue at the given position. a #GQueue the data for the new element the position to insert the new element. If @n is negative or larger than the number of elements in the @queue, the element is added to the end of the queue. Inserts @link into @queue at the given position. a #GQueue the position to insert the link. If this is negative or larger than the number of elements in @queue, the link is added to the end of @queue. the link to add to @queue Adds a new element at the tail of the queue. a #GQueue the data for the new element Adds a new element at the tail of the queue. a #GQueue a single #GList element, not a list with more than one element Removes the first element in @queue that contains @data. %TRUE if @data was found and removed from @queue a #GQueue the data to remove Remove all elements whose data equals @data from @queue. the number of elements removed from @queue a #GQueue the data to remove Reverses the order of the items in @queue. a #GQueue Sorts @queue using @compare_func. a #GQueue the #GCompareDataFunc used to sort @queue. This function is passed two elements of the queue and should return 0 if they are equal, a negative value if the first comes before the second, and a positive value if the second comes before the first. user data passed to @compare_func Unlinks @link_ so that it will no longer be part of @queue. The link is not freed. @link_ must be part of @queue. a #GQueue a #GList link that must be part of @queue Creates a new #GQueue. a newly allocated #GQueue The GRWLock struct is an opaque data structure to represent a reader-writer lock. It is similar to a #GMutex in that it allows multiple threads to coordinate access to a shared resource. The difference to a mutex is that a reader-writer lock discriminates between read-only ('reader') and full ('writer') access. While only one thread at a time is allowed write access (by holding the 'writer' lock via g_rw_lock_writer_lock()), multiple threads can gain simultaneous read-only access (by holding the 'reader' lock via g_rw_lock_reader_lock()). Here is an example for an array with access functions: |[<!-- language="C" --> GRWLock lock; GPtrArray *array; gpointer my_array_get (guint index) { gpointer retval = NULL; if (!array) return NULL; g_rw_lock_reader_lock (&lock); if (index < array->len) retval = g_ptr_array_index (array, index); g_rw_lock_reader_unlock (&lock); return retval; } void my_array_set (guint index, gpointer data) { g_rw_lock_writer_lock (&lock); if (!array) array = g_ptr_array_new (); if (index >= array->len) g_ptr_array_set_size (array, index+1); g_ptr_array_index (array, index) = data; g_rw_lock_writer_unlock (&lock); } ]| This example shows an array which can be accessed by many readers (the my_array_get() function) simultaneously, whereas the writers (the my_array_set() function) will only be allowed one at a time and only if no readers currently access the array. This is because of the potentially dangerous resizing of the array. Using these functions is fully multi-thread safe now. If a #GRWLock is allocated in static storage then it can be used without initialisation. Otherwise, you should call g_rw_lock_init() on it and g_rw_lock_clear() when done. A GRWLock should only be accessed with the g_rw_lock_ functions. Frees the resources allocated to a lock with g_rw_lock_init(). This function should not be used with a #GRWLock that has been statically allocated. Calling g_rw_lock_clear() when any thread holds the lock leads to undefined behaviour. Sine: 2.32 an initialized #GRWLock Initializes a #GRWLock so that it can be used. This function is useful to initialize a lock that has been allocated on the stack, or as part of a larger structure. It is not necessary to initialise a reader-writer lock that has been statically allocated. |[<!-- language="C" --> typedef struct { GRWLock l; ... } Blob; Blob *b; b = g_new (Blob, 1); g_rw_lock_init (&b->l); ]| To undo the effect of g_rw_lock_init() when a lock is no longer needed, use g_rw_lock_clear(). Calling g_rw_lock_init() on an already initialized #GRWLock leads to undefined behaviour. an uninitialized #GRWLock Obtain a read lock on @rw_lock. If another thread currently holds the write lock on @rw_lock or blocks waiting for it, the current thread will block. Read locks can be taken recursively. It is implementation-defined how many threads are allowed to hold read locks on the same lock simultaneously. a #GRWLock Tries to obtain a read lock on @rw_lock and returns %TRUE if the read lock was successfully obtained. Otherwise it returns %FALSE. %TRUE if @rw_lock could be locked a #GRWLock Release a read lock on @rw_lock. Calling g_rw_lock_reader_unlock() on a lock that is not held by the current thread leads to undefined behaviour. a #GRWLock Obtain a write lock on @rw_lock. If any thread already holds a read or write lock on @rw_lock, the current thread will block until all other threads have dropped their locks on @rw_lock. a #GRWLock Tries to obtain a write lock on @rw_lock. If any other thread holds a read or write lock on @rw_lock, it immediately returns %FALSE. Otherwise it locks @rw_lock and returns %TRUE. %TRUE if @rw_lock could be locked a #GRWLock Release a write lock on @rw_lock. Calling g_rw_lock_writer_unlock() on a lock that is not held by the current thread leads to undefined behaviour. a #GRWLock The GRand struct is an opaque data structure. It should only be accessed through the g_rand_* functions. Copies a #GRand into a new one with the same exact state as before. This way you can take a snapshot of the random number generator for replaying later. the new #GRand a #GRand Returns the next random #gdouble from @rand_ equally distributed over the range [0..1). a random number a #GRand Returns the next random #gdouble from @rand_ equally distributed over the range [@begin..@end). a random number a #GRand lower closed bound of the interval upper open bound of the interval Frees the memory allocated for the #GRand. a #GRand Returns the next random #guint32 from @rand_ equally distributed over the range [0..2^32-1]. a random number a #GRand Returns the next random #gint32 from @rand_ equally distributed over the range [@begin..@end-1]. a random number a #GRand lower closed bound of the interval upper open bound of the interval Sets the seed for the random number generator #GRand to @seed. a #GRand a value to reinitialize the random number generator Initializes the random number generator by an array of longs. Array can be of arbitrary size, though only the first 624 values are taken. This function is useful if you have many low entropy seeds, or if you require more then 32 bits of actual entropy for your application. a #GRand array to initialize with length of array Creates a new random number generator initialized with a seed taken either from `/dev/urandom` (if existing) or from the current time (as a fallback). On Windows, the seed is taken from rand_s(). the new #GRand Creates a new random number generator initialized with @seed. the new #GRand a value to initialize the random number generator Creates a new random number generator initialized with @seed. the new #GRand an array of seeds to initialize the random number generator an array of seeds to initialize the random number generator The GRecMutex struct is an opaque data structure to represent a recursive mutex. It is similar to a #GMutex with the difference that it is possible to lock a GRecMutex multiple times in the same thread without deadlock. When doing so, care has to be taken to unlock the recursive mutex as often as it has been locked. If a #GRecMutex is allocated in static storage then it can be used without initialisation. Otherwise, you should call g_rec_mutex_init() on it and g_rec_mutex_clear() when done. A GRecMutex should only be accessed with the g_rec_mutex_ functions. Frees the resources allocated to a recursive mutex with g_rec_mutex_init(). This function should not be used with a #GRecMutex that has been statically allocated. Calling g_rec_mutex_clear() on a locked recursive mutex leads to undefined behaviour. Sine: 2.32 an initialized #GRecMutex Initializes a #GRecMutex so that it can be used. This function is useful to initialize a recursive mutex that has been allocated on the stack, or as part of a larger structure. It is not necessary to initialise a recursive mutex that has been statically allocated. |[<!-- language="C" --> typedef struct { GRecMutex m; ... } Blob; Blob *b; b = g_new (Blob, 1); g_rec_mutex_init (&b->m); ]| Calling g_rec_mutex_init() on an already initialized #GRecMutex leads to undefined behaviour. To undo the effect of g_rec_mutex_init() when a recursive mutex is no longer needed, use g_rec_mutex_clear(). an uninitialized #GRecMutex Locks @rec_mutex. If @rec_mutex is already locked by another thread, the current thread will block until @rec_mutex is unlocked by the other thread. If @rec_mutex is already locked by the current thread, the 'lock count' of @rec_mutex is increased. The mutex will only become available again when it is unlocked as many times as it has been locked. a #GRecMutex Tries to lock @rec_mutex. If @rec_mutex is already locked by another thread, it immediately returns %FALSE. Otherwise it locks @rec_mutex and returns %TRUE. %TRUE if @rec_mutex could be locked a #GRecMutex Unlocks @rec_mutex. If another thread is blocked in a g_rec_mutex_lock() call for @rec_mutex, it will become unblocked and can lock @rec_mutex itself. Calling g_rec_mutex_unlock() on a recursive mutex that is not locked by the current thread leads to undefined behaviour. a #GRecMutex The g_regex_*() functions implement regular expression pattern matching using syntax and semantics similar to Perl regular expression. Some functions accept a @start_position argument, setting it differs from just passing over a shortened string and setting #G_REGEX_MATCH_NOTBOL in the case of a pattern that begins with any kind of lookbehind assertion. For example, consider the pattern "\Biss\B" which finds occurrences of "iss" in the middle of words. ("\B" matches only if the current position in the subject is not a word boundary.) When applied to the string "Mississipi" from the fourth byte, namely "issipi", it does not match, because "\B" is always false at the start of the subject, which is deemed to be a word boundary. However, if the entire string is passed , but with @start_position set to 4, it finds the second occurrence of "iss" because it is able to look behind the starting point to discover that it is preceded by a letter. Note that, unless you set the #G_REGEX_RAW flag, all the strings passed to these functions must be encoded in UTF-8. The lengths and the positions inside the strings are in bytes and not in characters, so, for instance, "\xc3\xa0" (i.e. "&agrave;") is two bytes long but it is treated as a single character. If you set #G_REGEX_RAW the strings can be non-valid UTF-8 strings and a byte is treated as a character, so "\xc3\xa0" is two bytes and two characters long. When matching a pattern, "\n" matches only against a "\n" character in the string, and "\r" matches only a "\r" character. To match any newline sequence use "\R". This particular group matches either the two-character sequence CR + LF ("\r\n"), or one of the single characters LF (linefeed, U+000A, "\n"), VT vertical tab, U+000B, "\v"), FF (formfeed, U+000C, "\f"), CR (carriage return, U+000D, "\r"), NEL (next line, U+0085), LS (line separator, U+2028), or PS (paragraph separator, U+2029). The behaviour of the dot, circumflex, and dollar metacharacters are affected by newline characters, the default is to recognize any newline character (the same characters recognized by "\R"). This can be changed with #G_REGEX_NEWLINE_CR, #G_REGEX_NEWLINE_LF and #G_REGEX_NEWLINE_CRLF compile options, and with #G_REGEX_MATCH_NEWLINE_ANY, #G_REGEX_MATCH_NEWLINE_CR, #G_REGEX_MATCH_NEWLINE_LF and #G_REGEX_MATCH_NEWLINE_CRLF match options. These settings are also relevant when compiling a pattern if #G_REGEX_EXTENDED is set, and an unescaped "#" outside a character class is encountered. This indicates a comment that lasts until after the next newline. When setting the %G_REGEX_JAVASCRIPT_COMPAT flag, pattern syntax and pattern matching is changed to be compatible with the way that regular expressions work in JavaScript. More precisely, a lonely ']' character in the pattern is a syntax error; the '\x' escape only allows 0 to 2 hexadecimal digits, and you must use the '\u' escape sequence with 4 hex digits to specify a unicode codepoint instead of '\x' or 'x{....}'. If '\x' or '\u' are not followed by the specified number of hex digits, they match 'x' and 'u' literally; also '\U' always matches 'U' instead of being an error in the pattern. Finally, pattern matching is modified so that back references to an unset subpattern group produces a match with the empty string instead of an error. See pcreapi(3) for more information. Creating and manipulating the same #GRegex structure from different threads is not a problem as #GRegex does not modify its internal state between creation and destruction, on the other hand #GMatchInfo is not threadsafe. The regular expressions low-level functionalities are obtained through the excellent [PCRE](http://www.pcre.org/) library written by Philip Hazel. Compiles the regular expression to an internal form, and does the initial setup of the #GRegex structure. a #GRegex structure. Call g_regex_unref() when you are done with it the regular expression compile options for the regular expression, or 0 match options for the regular expression, or 0 Returns the number of capturing subpatterns in the pattern. the number of capturing subpatterns a #GRegex Returns the compile options that @regex was created with. flags from #GRegexCompileFlags a #GRegex Checks whether the pattern contains explicit CR or LF references. %TRUE if the pattern contains explicit CR or LF references a #GRegex structure Returns the match options that @regex was created with. flags from #GRegexMatchFlags a #GRegex Returns the number of the highest back reference in the pattern, or 0 if the pattern does not contain back references. the number of the highest back reference a #GRegex Gets the number of characters in the longest lookbehind assertion in the pattern. This information is useful when doing multi-segment matching using the partial matching facilities. the number of characters in the longest lookbehind assertion. a #GRegex structure Gets the pattern string associated with @regex, i.e. a copy of the string passed to g_regex_new(). the pattern of @regex a #GRegex structure Retrieves the number of the subexpression named @name. The number of the subexpression or -1 if @name does not exists #GRegex structure name of the subexpression Scans for a match in string for the pattern in @regex. The @match_options are combined with the match options specified when the @regex structure was created, letting you have more flexibility in reusing #GRegex structures. A #GMatchInfo structure, used to get information on the match, is stored in @match_info if not %NULL. Note that if @match_info is not %NULL then it is created even if the function returns %FALSE, i.e. you must free it regardless if regular expression actually matched. To retrieve all the non-overlapping matches of the pattern in string you can use g_match_info_next(). |[<!-- language="C" --> static void print_uppercase_words (const gchar *string) { // Print all uppercase-only words. GRegex *regex; GMatchInfo *match_info; regex = g_regex_new ("[A-Z]+", 0, 0, NULL); g_regex_match (regex, string, 0, &match_info); while (g_match_info_matches (match_info)) { gchar *word = g_match_info_fetch (match_info, 0); g_print ("Found: %s\n", word); g_free (word); g_match_info_next (match_info, NULL); } g_match_info_free (match_info); g_regex_unref (regex); } ]| @string is not copied and is used in #GMatchInfo internally. If you use any #GMatchInfo method (except g_match_info_free()) after freeing or modifying @string then the behaviour is undefined. %TRUE is the string matched, %FALSE otherwise a #GRegex structure from g_regex_new() the string to scan for matches match options pointer to location where to store the #GMatchInfo, or %NULL if you do not need it Using the standard algorithm for regular expression matching only the longest match in the string is retrieved. This function uses a different algorithm so it can retrieve all the possible matches. For more documentation see g_regex_match_all_full(). A #GMatchInfo structure, used to get information on the match, is stored in @match_info if not %NULL. Note that if @match_info is not %NULL then it is created even if the function returns %FALSE, i.e. you must free it regardless if regular expression actually matched. @string is not copied and is used in #GMatchInfo internally. If you use any #GMatchInfo method (except g_match_info_free()) after freeing or modifying @string then the behaviour is undefined. %TRUE is the string matched, %FALSE otherwise a #GRegex structure from g_regex_new() the string to scan for matches match options pointer to location where to store the #GMatchInfo, or %NULL if you do not need it Using the standard algorithm for regular expression matching only the longest match in the string is retrieved, it is not possible to obtain all the available matches. For instance matching "<a> <b> <c>" against the pattern "<.*>" you get "<a> <b> <c>". This function uses a different algorithm (called DFA, i.e. deterministic finite automaton), so it can retrieve all the possible matches, all starting at the same point in the string. For instance matching "<a> <b> <c>" against the pattern "<.*>;" you would obtain three matches: "<a> <b> <c>", "<a> <b>" and "<a>". The number of matched strings is retrieved using g_match_info_get_match_count(). To obtain the matched strings and their position you can use, respectively, g_match_info_fetch() and g_match_info_fetch_pos(). Note that the strings are returned in reverse order of length; that is, the longest matching string is given first. Note that the DFA algorithm is slower than the standard one and it is not able to capture substrings, so backreferences do not work. Setting @start_position differs from just passing over a shortened string and setting #G_REGEX_MATCH_NOTBOL in the case of a pattern that begins with any kind of lookbehind assertion, such as "\b". A #GMatchInfo structure, used to get information on the match, is stored in @match_info if not %NULL. Note that if @match_info is not %NULL then it is created even if the function returns %FALSE, i.e. you must free it regardless if regular expression actually matched. @string is not copied and is used in #GMatchInfo internally. If you use any #GMatchInfo method (except g_match_info_free()) after freeing or modifying @string then the behaviour is undefined. %TRUE is the string matched, %FALSE otherwise a #GRegex structure from g_regex_new() the string to scan for matches the length of @string, or -1 if @string is nul-terminated starting index of the string to match match options pointer to location where to store the #GMatchInfo, or %NULL if you do not need it Scans for a match in string for the pattern in @regex. The @match_options are combined with the match options specified when the @regex structure was created, letting you have more flexibility in reusing #GRegex structures. Setting @start_position differs from just passing over a shortened string and setting #G_REGEX_MATCH_NOTBOL in the case of a pattern that begins with any kind of lookbehind assertion, such as "\b". A #GMatchInfo structure, used to get information on the match, is stored in @match_info if not %NULL. Note that if @match_info is not %NULL then it is created even if the function returns %FALSE, i.e. you must free it regardless if regular expression actually matched. @string is not copied and is used in #GMatchInfo internally. If you use any #GMatchInfo method (except g_match_info_free()) after freeing or modifying @string then the behaviour is undefined. To retrieve all the non-overlapping matches of the pattern in string you can use g_match_info_next(). |[<!-- language="C" --> static void print_uppercase_words (const gchar *string) { // Print all uppercase-only words. GRegex *regex; GMatchInfo *match_info; GError *error = NULL; regex = g_regex_new ("[A-Z]+", 0, 0, NULL); g_regex_match_full (regex, string, -1, 0, 0, &match_info, &error); while (g_match_info_matches (match_info)) { gchar *word = g_match_info_fetch (match_info, 0); g_print ("Found: %s\n", word); g_free (word); g_match_info_next (match_info, &error); } g_match_info_free (match_info); g_regex_unref (regex); if (error != NULL) { g_printerr ("Error while matching: %s\n", error->message); g_error_free (error); } } ]| %TRUE is the string matched, %FALSE otherwise a #GRegex structure from g_regex_new() the string to scan for matches the length of @string, or -1 if @string is nul-terminated starting index of the string to match match options pointer to location where to store the #GMatchInfo, or %NULL if you do not need it Increases reference count of @regex by 1. @regex a #GRegex Replaces all occurrences of the pattern in @regex with the replacement text. Backreferences of the form '\number' or '\g<number>' in the replacement text are interpolated by the number-th captured subexpression of the match, '\g<name>' refers to the captured subexpression with the given name. '\0' refers to the complete match, but '\0' followed by a number is the octal representation of a character. To include a literal '\' in the replacement, write '\\'. There are also escapes that changes the case of the following text: - \l: Convert to lower case the next character - \u: Convert to upper case the next character - \L: Convert to lower case till \E - \U: Convert to upper case till \E - \E: End case modification If you do not need to use backreferences use g_regex_replace_literal(). The @replacement string must be UTF-8 encoded even if #G_REGEX_RAW was passed to g_regex_new(). If you want to use not UTF-8 encoded stings you can use g_regex_replace_literal(). Setting @start_position differs from just passing over a shortened string and setting #G_REGEX_MATCH_NOTBOL in the case of a pattern that begins with any kind of lookbehind assertion, such as "\b". a newly allocated string containing the replacements a #GRegex structure the string to perform matches against the length of @string, or -1 if @string is nul-terminated starting index of the string to match text to replace each match with options for the match Replaces occurrences of the pattern in regex with the output of @eval for that occurrence. Setting @start_position differs from just passing over a shortened string and setting #G_REGEX_MATCH_NOTBOL in the case of a pattern that begins with any kind of lookbehind assertion, such as "\b". The following example uses g_regex_replace_eval() to replace multiple strings at once: |[<!-- language="C" --> static gboolean eval_cb (const GMatchInfo *info, GString *res, gpointer data) { gchar *match; gchar *r; match = g_match_info_fetch (info, 0); r = g_hash_table_lookup ((GHashTable *)data, match); g_string_append (res, r); g_free (match); return FALSE; } ... GRegex *reg; GHashTable *h; gchar *res; h = g_hash_table_new (g_str_hash, g_str_equal); g_hash_table_insert (h, "1", "ONE"); g_hash_table_insert (h, "2", "TWO"); g_hash_table_insert (h, "3", "THREE"); g_hash_table_insert (h, "4", "FOUR"); reg = g_regex_new ("1|2|3|4", 0, 0, NULL); res = g_regex_replace_eval (reg, text, -1, 0, 0, eval_cb, h, NULL); g_hash_table_destroy (h); ... ]| a newly allocated string containing the replacements a #GRegex structure from g_regex_new() string to perform matches against the length of @string, or -1 if @string is nul-terminated starting index of the string to match options for the match a function to call for each match user data to pass to the function Replaces all occurrences of the pattern in @regex with the replacement text. @replacement is replaced literally, to include backreferences use g_regex_replace(). Setting @start_position differs from just passing over a shortened string and setting #G_REGEX_MATCH_NOTBOL in the case of a pattern that begins with any kind of lookbehind assertion, such as "\b". a newly allocated string containing the replacements a #GRegex structure the string to perform matches against the length of @string, or -1 if @string is nul-terminated starting index of the string to match text to replace each match with options for the match Breaks the string on the pattern, and returns an array of the tokens. If the pattern contains capturing parentheses, then the text for each of the substrings will also be returned. If the pattern does not match anywhere in the string, then the whole string is returned as the first token. As a special case, the result of splitting the empty string "" is an empty vector, not a vector containing a single string. The reason for this special case is that being able to represent a empty vector is typically more useful than consistent handling of empty elements. If you do need to represent empty elements, you'll need to check for the empty string before calling this function. A pattern that can match empty strings splits @string into separate characters wherever it matches the empty string between characters. For example splitting "ab c" using as a separator "\s*", you will get "a", "b" and "c". a %NULL-terminated gchar ** array. Free it using g_strfreev() a #GRegex structure the string to split with the pattern match time option flags Breaks the string on the pattern, and returns an array of the tokens. If the pattern contains capturing parentheses, then the text for each of the substrings will also be returned. If the pattern does not match anywhere in the string, then the whole string is returned as the first token. As a special case, the result of splitting the empty string "" is an empty vector, not a vector containing a single string. The reason for this special case is that being able to represent a empty vector is typically more useful than consistent handling of empty elements. If you do need to represent empty elements, you'll need to check for the empty string before calling this function. A pattern that can match empty strings splits @string into separate characters wherever it matches the empty string between characters. For example splitting "ab c" using as a separator "\s*", you will get "a", "b" and "c". Setting @start_position differs from just passing over a shortened string and setting #G_REGEX_MATCH_NOTBOL in the case of a pattern that begins with any kind of lookbehind assertion, such as "\b". a %NULL-terminated gchar ** array. Free it using g_strfreev() a #GRegex structure the string to split with the pattern the length of @string, or -1 if @string is nul-terminated starting index of the string to match match time option flags the maximum number of tokens to split @string into. If this is less than 1, the string is split completely Decreases reference count of @regex by 1. When reference count drops to zero, it frees all the memory associated with the regex structure. a #GRegex Checks whether @replacement is a valid replacement string (see g_regex_replace()), i.e. that all escape sequences in it are valid. If @has_references is not %NULL then @replacement is checked for pattern references. For instance, replacement text 'foo\n' does not contain references and may be evaluated without information about actual match, but '\0\1' (whole match followed by first subpattern) requires valid #GMatchInfo object. whether @replacement is a valid replacement string the replacement string location to store information about references in @replacement or %NULL Escapes the nul characters in @string to "\x00". It can be used to compile a regex with embedded nul characters. For completeness, @length can be -1 for a nul-terminated string. In this case the output string will be of course equal to @string. a newly-allocated escaped string the string to escape the length of @string Escapes the special characters used for regular expressions in @string, for instance "a.b*c" becomes "a\.b\*c". This function is useful to dynamically generate regular expressions. @string can contain nul characters that are replaced with "\0", in this case remember to specify the correct length of @string in @length. a newly-allocated escaped string the string to escape the length of @string, or -1 if @string is nul-terminated Scans for a match in @string for @pattern. This function is equivalent to g_regex_match() but it does not require to compile the pattern with g_regex_new(), avoiding some lines of code when you need just to do a match without extracting substrings, capture counts, and so on. If this function is to be called on the same @pattern more than once, it's more efficient to compile the pattern once with g_regex_new() and then use g_regex_match(). %TRUE if the string matched, %FALSE otherwise the regular expression the string to scan for matches compile options for the regular expression, or 0 match options, or 0 Breaks the string on the pattern, and returns an array of the tokens. If the pattern contains capturing parentheses, then the text for each of the substrings will also be returned. If the pattern does not match anywhere in the string, then the whole string is returned as the first token. This function is equivalent to g_regex_split() but it does not require to compile the pattern with g_regex_new(), avoiding some lines of code when you need just to do a split without extracting substrings, capture counts, and so on. If this function is to be called on the same @pattern more than once, it's more efficient to compile the pattern once with g_regex_new() and then use g_regex_split(). As a special case, the result of splitting the empty string "" is an empty vector, not a vector containing a single string. The reason for this special case is that being able to represent a empty vector is typically more useful than consistent handling of empty elements. If you do need to represent empty elements, you'll need to check for the empty string before calling this function. A pattern that can match empty strings splits @string into separate characters wherever it matches the empty string between characters. For example splitting "ab c" using as a separator "\s*", you will get "a", "b" and "c". a %NULL-terminated array of strings. Free it using g_strfreev() the regular expression the string to scan for matches compile options for the regular expression, or 0 match options, or 0 Flags specifying compile-time options. Letters in the pattern match both upper- and lowercase letters. This option can be changed within a pattern by a "(?i)" option setting. By default, GRegex treats the strings as consisting of a single line of characters (even if it actually contains newlines). The "start of line" metacharacter ("^") matches only at the start of the string, while the "end of line" metacharacter ("$") matches only at the end of the string, or before a terminating newline (unless #G_REGEX_DOLLAR_ENDONLY is set). When #G_REGEX_MULTILINE is set, the "start of line" and "end of line" constructs match immediately following or immediately before any newline in the string, respectively, as well as at the very start and end. This can be changed within a pattern by a "(?m)" option setting. A dot metacharater (".") in the pattern matches all characters, including newlines. Without it, newlines are excluded. This option can be changed within a pattern by a ("?s") option setting. Whitespace data characters in the pattern are totally ignored except when escaped or inside a character class. Whitespace does not include the VT character (code 11). In addition, characters between an unescaped "#" outside a character class and the next newline character, inclusive, are also ignored. This can be changed within a pattern by a "(?x)" option setting. The pattern is forced to be "anchored", that is, it is constrained to match only at the first matching point in the string that is being searched. This effect can also be achieved by appropriate constructs in the pattern itself such as the "^" metacharater. A dollar metacharacter ("$") in the pattern matches only at the end of the string. Without this option, a dollar also matches immediately before the final character if it is a newline (but not before any other newlines). This option is ignored if #G_REGEX_MULTILINE is set. Inverts the "greediness" of the quantifiers so that they are not greedy by default, but become greedy if followed by "?". It can also be set by a "(?U)" option setting within the pattern. Usually strings must be valid UTF-8 strings, using this flag they are considered as a raw sequence of bytes. Disables the use of numbered capturing parentheses in the pattern. Any opening parenthesis that is not followed by "?" behaves as if it were followed by "?:" but named parentheses can still be used for capturing (and they acquire numbers in the usual way). Optimize the regular expression. If the pattern will be used many times, then it may be worth the effort to optimize it to improve the speed of matches. Limits an unanchored pattern to match before (or at) the first newline. Since: 2.34 Names used to identify capturing subpatterns need not be unique. This can be helpful for certain types of pattern when it is known that only one instance of the named subpattern can ever be matched. Usually any newline character or character sequence is recognized. If this option is set, the only recognized newline character is '\r'. Usually any newline character or character sequence is recognized. If this option is set, the only recognized newline character is '\n'. Usually any newline character or character sequence is recognized. If this option is set, the only recognized newline character sequence is '\r\n'. Usually any newline character or character sequence is recognized. If this option is set, the only recognized newline character sequences are '\r', '\n', and '\r\n'. Since: 2.34 Usually any newline character or character sequence is recognised. If this option is set, then "\R" only recognizes the newline characters '\r', '\n' and '\r\n'. Since: 2.34 Changes behaviour so that it is compatible with JavaScript rather than PCRE. Since: 2.34 Error codes returned by regular expressions functions. Compilation of the regular expression failed. Optimization of the regular expression failed. Replacement failed due to an ill-formed replacement string. The match process failed. Internal error of the regular expression engine. Since 2.16 "\\" at end of pattern. Since 2.16 "\\c" at end of pattern. Since 2.16 Unrecognized character follows "\\". Since 2.16 Numbers out of order in "{}" quantifier. Since 2.16 Number too big in "{}" quantifier. Since 2.16 Missing terminating "]" for character class. Since 2.16 Invalid escape sequence in character class. Since 2.16 Range out of order in character class. Since 2.16 Nothing to repeat. Since 2.16 Unrecognized character after "(?", "(?&lt;" or "(?P". Since 2.16 POSIX named classes are supported only within a class. Since 2.16 Missing terminating ")" or ")" without opening "(". Since 2.16 Reference to non-existent subpattern. Since 2.16 Missing terminating ")" after comment. Since 2.16 Regular expression too large. Since 2.16 Failed to get memory. Since 2.16 Lookbehind assertion is not fixed length. Since 2.16 Malformed number or name after "(?(". Since 2.16 Conditional group contains more than two branches. Since 2.16 Assertion expected after "(?(". Since 2.16 Unknown POSIX class name. Since 2.16 POSIX collating elements are not supported. Since 2.16 Character value in "\\x{...}" sequence is too large. Since 2.16 Invalid condition "(?(0)". Since 2.16 \\C not allowed in lookbehind assertion. Since 2.16 Recursive call could loop indefinitely. Since 2.16 Missing terminator in subpattern name. Since 2.16 Two named subpatterns have the same name. Since 2.16 Malformed "\\P" or "\\p" sequence. Since 2.16 Unknown property name after "\\P" or "\\p". Since 2.16 Subpattern name is too long (maximum 32 characters). Since 2.16 Too many named subpatterns (maximum 10,000). Since 2.16 Octal value is greater than "\\377". Since 2.16 "DEFINE" group contains more than one branch. Since 2.16 Repeating a "DEFINE" group is not allowed. This error is never raised. Since: 2.16 Deprecated: 2.34 Inconsistent newline options. Since 2.16 "\\g" is not followed by a braced, angle-bracketed, or quoted name or number, or by a plain number. Since: 2.16 relative reference must not be zero. Since: 2.34 the backtracing control verb used does not allow an argument. Since: 2.34 unknown backtracing control verb. Since: 2.34 number is too big in escape sequence. Since: 2.34 Missing subpattern name. Since: 2.34 Missing digit. Since 2.34 In JavaScript compatibility mode, "[" is an invalid data character. Since: 2.34 different names for subpatterns of the same number are not allowed. Since: 2.34 the backtracing control verb requires an argument. Since: 2.34 "\\c" must be followed by an ASCII character. Since: 2.34 "\\k" is not followed by a braced, angle-bracketed, or quoted name. Since: 2.34 "\\N" is not supported in a class. Since: 2.34 too many forward references. Since: 2.34 the name is too long in "(*MARK)", "(*PRUNE)", "(*SKIP)", or "(*THEN)". Since: 2.34 the character value in the \\u sequence is too large. Since: 2.34 Specifies the type of the function passed to g_regex_replace_eval(). It is called for each occurrence of the pattern in the string passed to g_regex_replace_eval(), and it should append the replacement to @result. %FALSE to continue the replacement process, %TRUE to stop it the #GMatchInfo generated by the match. Use g_match_info_get_regex() and g_match_info_get_string() if you need the #GRegex or the matched string. a #GString containing the new string user data passed to g_regex_replace_eval() Flags specifying match-time options. The pattern is forced to be "anchored", that is, it is constrained to match only at the first matching point in the string that is being searched. This effect can also be achieved by appropriate constructs in the pattern itself such as the "^" metacharater. Specifies that first character of the string is not the beginning of a line, so the circumflex metacharacter should not match before it. Setting this without #G_REGEX_MULTILINE (at compile time) causes circumflex never to match. This option affects only the behaviour of the circumflex metacharacter, it does not affect "\A". Specifies that the end of the subject string is not the end of a line, so the dollar metacharacter should not match it nor (except in multiline mode) a newline immediately before it. Setting this without #G_REGEX_MULTILINE (at compile time) causes dollar never to match. This option affects only the behaviour of the dollar metacharacter, it does not affect "\Z" or "\z". An empty string is not considered to be a valid match if this option is set. If there are alternatives in the pattern, they are tried. If all the alternatives match the empty string, the entire match fails. For example, if the pattern "a?b?" is applied to a string not beginning with "a" or "b", it matches the empty string at the start of the string. With this flag set, this match is not valid, so GRegex searches further into the string for occurrences of "a" or "b". Turns on the partial matching feature, for more documentation on partial matching see g_match_info_is_partial_match(). Overrides the newline definition set when creating a new #GRegex, setting the '\r' character as line terminator. Overrides the newline definition set when creating a new #GRegex, setting the '\n' character as line terminator. Overrides the newline definition set when creating a new #GRegex, setting the '\r\n' characters sequence as line terminator. Overrides the newline definition set when creating a new #GRegex, any Unicode newline sequence is recognised as a newline. These are '\r', '\n' and '\rn', and the single characters U+000B LINE TABULATION, U+000C FORM FEED (FF), U+0085 NEXT LINE (NEL), U+2028 LINE SEPARATOR and U+2029 PARAGRAPH SEPARATOR. Overrides the newline definition set when creating a new #GRegex; any '\r', '\n', or '\r\n' character sequence is recognized as a newline. Since: 2.34 Overrides the newline definition for "\R" set when creating a new #GRegex; only '\r', '\n', or '\r\n' character sequences are recognized as a newline by "\R". Since: 2.34 Overrides the newline definition for "\R" set when creating a new #GRegex; any Unicode newline character or character sequence are recognized as a newline by "\R". These are '\r', '\n' and '\rn', and the single characters U+000B LINE TABULATION, U+000C FORM FEED (FF), U+0085 NEXT LINE (NEL), U+2028 LINE SEPARATOR and U+2029 PARAGRAPH SEPARATOR. Since: 2.34 An alias for #G_REGEX_MATCH_PARTIAL. Since: 2.34 Turns on the partial matching feature. In contrast to to #G_REGEX_MATCH_PARTIAL_SOFT, this stops matching as soon as a partial match is found, without continuing to search for a possible complete match. See g_match_info_is_partial_match() for more information. Since: 2.34 Like #G_REGEX_MATCH_NOTEMPTY, but only applied to the start of the matched string. For anchored patterns this can only happen for pattern containing "\K". Since: 2.34 The search path separator character. This is ':' on UNIX machines and ';' under Windows. The search path separator as a string. This is ":" on UNIX machines and ";" under Windows. The #GSList struct is used for each element in the singly-linked list. holds the element's data, which can be a pointer to any kind of data, or any integer value using the [Type Conversion Macros][glib-Type-Conversion-Macros] contains the link to the next element in the list. Allocates space for one #GSList element. It is called by the g_slist_append(), g_slist_prepend(), g_slist_insert() and g_slist_insert_sorted() functions and so is rarely used on its own. a pointer to the newly-allocated #GSList element. Adds a new element on to the end of the list. The return value is the new start of the list, which may have changed, so make sure you store the new value. Note that g_slist_append() has to traverse the entire list to find the end, which is inefficient when adding multiple elements. A common idiom to avoid the inefficiency is to prepend the elements and reverse the list when all elements have been added. |[<!-- language="C" --> // Notice that these are initialized to the empty list. GSList *list = NULL, *number_list = NULL; // This is a list of strings. list = g_slist_append (list, "first"); list = g_slist_append (list, "second"); // This is a list of integers. number_list = g_slist_append (number_list, GINT_TO_POINTER (27)); number_list = g_slist_append (number_list, GINT_TO_POINTER (14)); ]| the new start of the #GSList a #GSList the data for the new element Adds the second #GSList onto the end of the first #GSList. Note that the elements of the second #GSList are not copied. They are used directly. the start of the new #GSList a #GSList the #GSList to add to the end of the first #GSList Copies a #GSList. Note that this is a "shallow" copy. If the list elements consist of pointers to data, the pointers are copied but the actual data isn't. See g_slist_copy_deep() if you need to copy the data as well. a copy of @list a #GSList Makes a full (deep) copy of a #GSList. In contrast with g_slist_copy(), this function uses @func to make a copy of each list element, in addition to copying the list container itself. @func, as a #GCopyFunc, takes two arguments, the data to be copied and a user pointer. It's safe to pass #NULL as user_data, if the copy function takes only one argument. For instance, if @list holds a list of GObjects, you can do: |[<!-- language="C" --> another_list = g_slist_copy_deep (list, (GCopyFunc) g_object_ref, NULL); ]| And, to entirely free the new list, you could do: |[<!-- language="C" --> g_slist_free_full (another_list, g_object_unref); ]| a full copy of @list, use #g_slist_free_full to free it a #GSList a copy function used to copy every element in the list user data passed to the copy function @func, or #NULL Removes the node link_ from the list and frees it. Compare this to g_slist_remove_link() which removes the node without freeing it. Removing arbitrary nodes from a singly-linked list requires time that is proportional to the length of the list (ie. O(n)). If you find yourself using g_slist_delete_link() frequently, you should consider a different data structure, such as the doubly-linked #GList. the new head of @list a #GSList node to delete Finds the element in a #GSList which contains the given data. the found #GSList element, or %NULL if it is not found a #GSList the element data to find Finds an element in a #GSList, using a supplied function to find the desired element. It iterates over the list, calling the given function which should return 0 when the desired element is found. The function takes two #gconstpointer arguments, the #GSList element's data as the first argument and the given user data. the found #GSList element, or %NULL if it is not found a #GSList user data passed to the function the function to call for each element. It should return 0 when the desired element is found Calls a function for each element of a #GSList. a #GSList the function to call with each element's data user data to pass to the function Frees all of the memory used by a #GSList. The freed elements are returned to the slice allocator. If list elements contain dynamically-allocated memory, you should either use g_slist_free_full() or free them manually first. a #GSList Frees one #GSList element. It is usually used after g_slist_remove_link(). a #GSList element Convenience method, which frees all the memory used by a #GSList, and calls the specified destroy function on every element's data. a pointer to a #GSList the function to be called to free each element's data Gets the position of the element containing the given data (starting from 0). the index of the element containing the data, or -1 if the data is not found a #GSList the data to find Inserts a new element into the list at the given position. the new start of the #GSList a #GSList the data for the new element the position to insert the element. If this is negative, or is larger than the number of elements in the list, the new element is added on to the end of the list. Inserts a node before @sibling containing @data. the new head of the list. a #GSList node to insert @data before data to put in the newly-inserted node Inserts a new element into the list, using the given comparison function to determine its position. the new start of the #GSList a #GSList the data for the new element the function to compare elements in the list. It should return a number > 0 if the first parameter comes after the second parameter in the sort order. Inserts a new element into the list, using the given comparison function to determine its position. the new start of the #GSList a #GSList the data for the new element the function to compare elements in the list. It should return a number > 0 if the first parameter comes after the second parameter in the sort order. data to pass to comparison function Gets the last element in a #GSList. This function iterates over the whole list. the last element in the #GSList, or %NULL if the #GSList has no elements a #GSList Gets the number of elements in a #GSList. This function iterates over the whole list to count its elements. the number of elements in the #GSList a #GSList Gets the element at the given position in a #GSList. the element, or %NULL if the position is off the end of the #GSList a #GSList the position of the element, counting from 0 Gets the data of the element at the given position. the element's data, or %NULL if the position is off the end of the #GSList a #GSList the position of the element Gets the position of the given element in the #GSList (starting from 0). the position of the element in the #GSList, or -1 if the element is not found a #GSList an element in the #GSList Adds a new element on to the start of the list. The return value is the new start of the list, which may have changed, so make sure you store the new value. |[<!-- language="C" --> // Notice that it is initialized to the empty list. GSList *list = NULL; list = g_slist_prepend (list, "last"); list = g_slist_prepend (list, "first"); ]| the new start of the #GSList a #GSList the data for the new element Removes an element from a #GSList. If two elements contain the same data, only the first is removed. If none of the elements contain the data, the #GSList is unchanged. the new start of the #GSList a #GSList the data of the element to remove Removes all list nodes with data equal to @data. Returns the new head of the list. Contrast with g_slist_remove() which removes only the first node matching the given data. new head of @list a #GSList data to remove Removes an element from a #GSList, without freeing the element. The removed element's next link is set to %NULL, so that it becomes a self-contained list with one element. Removing arbitrary nodes from a singly-linked list requires time that is proportional to the length of the list (ie. O(n)). If you find yourself using g_slist_remove_link() frequently, you should consider a different data structure, such as the doubly-linked #GList. the new start of the #GSList, without the element a #GSList an element in the #GSList Reverses a #GSList. the start of the reversed #GSList a #GSList Sorts a #GSList using the given comparison function. the start of the sorted #GSList a #GSList the comparison function used to sort the #GSList. This function is passed the data from 2 elements of the #GSList and should return 0 if they are equal, a negative value if the first element comes before the second, or a positive value if the first element comes after the second. Like g_slist_sort(), but the sort function accepts a user data argument. new head of the list a #GSList comparison function data to pass to comparison function Use this macro as the return value of a #GSourceFunc to leave the #GSource in the main loop. Use this macro as the return value of a #GSourceFunc to remove the #GSource from the main loop. The square root of two. The standard delimiters, used in g_strdelimit(). The data structure representing a lexical scanner. You should set @input_name after creating the scanner, since it is used by the default message handler when displaying warnings and errors. If you are scanning a file, the filename would be a good choice. The @user_data and @max_parse_errors fields are not used. If you need to associate extra data with the scanner you can place them here. If you want to use your own message handler you can set the @msg_handler field. The type of the message handler function is declared by #GScannerMsgFunc. unused unused g_scanner_error() increments this field name of input stream, featured by the default message handler quarked data link into the scanner configuration token parsed by the last g_scanner_get_next_token() value of the last token from g_scanner_get_next_token() line number of the last token from g_scanner_get_next_token() char number of the last token from g_scanner_get_next_token() token parsed by the last g_scanner_peek_next_token() value of the last token from g_scanner_peek_next_token() line number of the last token from g_scanner_peek_next_token() char number of the last token from g_scanner_peek_next_token() handler function for _warn and _error Returns the current line in the input stream (counting from 1). This is the line of the last token parsed via g_scanner_get_next_token(). the current line a #GScanner Returns the current position in the current line (counting from 0). This is the position of the last token parsed via g_scanner_get_next_token(). the current position on the line a #GScanner Gets the current token type. This is simply the @token field in the #GScanner structure. the current token type a #GScanner Gets the current token value. This is simply the @value field in the #GScanner structure. the current token value a #GScanner Frees all memory used by the #GScanner. a #GScanner Returns %TRUE if the scanner has reached the end of the file or text buffer. %TRUE if the scanner has reached the end of the file or text buffer a #GScanner Outputs an error message, via the #GScanner message handler. a #GScanner the message format. See the printf() documentation the parameters to insert into the format string Parses the next token just like g_scanner_peek_next_token() and also removes it from the input stream. The token data is placed in the @token, @value, @line, and @position fields of the #GScanner structure. the type of the token a #GScanner Prepares to scan a file. a #GScanner a file descriptor Prepares to scan a text buffer. a #GScanner the text buffer to scan the length of the text buffer Looks up a symbol in the current scope and return its value. If the symbol is not bound in the current scope, %NULL is returned. the value of @symbol in the current scope, or %NULL if @symbol is not bound in the current scope a #GScanner the symbol to look up Parses the next token, without removing it from the input stream. The token data is placed in the @next_token, @next_value, @next_line, and @next_position fields of the #GScanner structure. Note that, while the token is not removed from the input stream (i.e. the next call to g_scanner_get_next_token() will return the same token), it will not be reevaluated. This can lead to surprising results when changing scope or the scanner configuration after peeking the next token. Getting the next token after switching the scope or configuration will return whatever was peeked before, regardless of any symbols that may have been added or removed in the new scope. the type of the token a #GScanner Adds a symbol to the given scope. a #GScanner the scope id the symbol to add the value of the symbol Calls the given function for each of the symbol/value pairs in the given scope of the #GScanner. The function is passed the symbol and value of each pair, and the given @user_data parameter. a #GScanner the scope id the function to call for each symbol/value pair user data to pass to the function Looks up a symbol in a scope and return its value. If the symbol is not bound in the scope, %NULL is returned. the value of @symbol in the given scope, or %NULL if @symbol is not bound in the given scope. a #GScanner the scope id the symbol to look up Removes a symbol from a scope. a #GScanner the scope id the symbol to remove Sets the current scope. the old scope id a #GScanner the new scope id Rewinds the filedescriptor to the current buffer position and blows the file read ahead buffer. This is useful for third party uses of the scanners filedescriptor, which hooks onto the current scanning position. a #GScanner Outputs a message through the scanner's msg_handler, resulting from an unexpected token in the input stream. Note that you should not call g_scanner_peek_next_token() followed by g_scanner_unexp_token() without an intermediate call to g_scanner_get_next_token(), as g_scanner_unexp_token() evaluates the scanner's current token (not the peeked token) to construct part of the message. a #GScanner the expected token a string describing how the scanner's user refers to identifiers (%NULL defaults to "identifier"). This is used if @expected_token is %G_TOKEN_IDENTIFIER or %G_TOKEN_IDENTIFIER_NULL. a string describing how the scanner's user refers to symbols (%NULL defaults to "symbol"). This is used if @expected_token is %G_TOKEN_SYMBOL or any token value greater than %G_TOKEN_LAST. the name of the symbol, if the scanner's current token is a symbol. a message string to output at the end of the warning/error, or %NULL. if %TRUE it is output as an error. If %FALSE it is output as a warning. Outputs a warning message, via the #GScanner message handler. a #GScanner the message format. See the printf() documentation the parameters to insert into the format string Creates a new #GScanner. The @config_templ structure specifies the initial settings of the scanner, which are copied into the #GScanner @config field. If you pass %NULL then the default settings are used. the new #GScanner the initial scanner settings Specifies the #GScanner parser configuration. Most settings can be changed during the parsing phase and will affect the lexical parsing of the next unpeeked token. specifies which characters should be skipped by the scanner (the default is the whitespace characters: space, tab, carriage-return and line-feed). specifies the characters which can start identifiers (the default is #G_CSET_a_2_z, "_", and #G_CSET_A_2_Z). specifies the characters which can be used in identifiers, after the first character (the default is #G_CSET_a_2_z, "_0123456789", #G_CSET_A_2_Z, #G_CSET_LATINS, #G_CSET_LATINC). specifies the characters at the start and end of single-line comments. The default is "#\n" which means that single-line comments start with a '#' and continue until a '\n' (end of line). specifies if symbols are case sensitive (the default is %FALSE). specifies if multi-line comments are skipped and not returned as tokens (the default is %TRUE). specifies if single-line comments are skipped and not returned as tokens (the default is %TRUE). specifies if multi-line comments are recognized (the default is %TRUE). specifies if identifiers are recognized (the default is %TRUE). specifies if single-character identifiers are recognized (the default is %FALSE). specifies if %NULL is reported as %G_TOKEN_IDENTIFIER_NULL (the default is %FALSE). specifies if symbols are recognized (the default is %TRUE). specifies if binary numbers are recognized (the default is %FALSE). specifies if octal numbers are recognized (the default is %TRUE). specifies if floating point numbers are recognized (the default is %TRUE). specifies if hexadecimal numbers are recognized (the default is %TRUE). specifies if '$' is recognized as a prefix for hexadecimal numbers (the default is %FALSE). specifies if strings can be enclosed in single quotes (the default is %TRUE). specifies if strings can be enclosed in double quotes (the default is %TRUE). specifies if binary, octal and hexadecimal numbers are reported as #G_TOKEN_INT (the default is %TRUE). specifies if all numbers are reported as %G_TOKEN_FLOAT (the default is %FALSE). specifies if identifiers are reported as strings (the default is %FALSE). specifies if characters are reported by setting `token = ch` or as %G_TOKEN_CHAR (the default is %TRUE). specifies if symbols are reported by setting `token = v_symbol` or as %G_TOKEN_SYMBOL (the default is %FALSE). specifies if a symbol is searched for in the default scope in addition to the current scope (the default is %FALSE). use value.v_int64 rather than v_int Specifies the type of the message handler function. a #GScanner the message %TRUE if the message signals an error, %FALSE if it signals a warning. An enumeration specifying the base position for a g_io_channel_seek_position() operation. the current position in the file. the start of the file. the end of the file. The #GSequence struct is an opaque data type representing a [sequence][glib-Sequences] data type. Adds a new item to the end of @seq. an iterator pointing to the new item a #GSequence the data for the new item Calls @func for each item in the sequence passing @user_data to the function. a #GSequence the function to call for each item in @seq user data passed to @func Frees the memory allocated for @seq. If @seq has a data destroy function associated with it, that function is called on all items in @seq. a #GSequence Returns the begin iterator for @seq. the begin iterator for @seq. a #GSequence Returns the end iterator for @seg the end iterator for @seq a #GSequence Returns the iterator at position @pos. If @pos is negative or larger than the number of items in @seq, the end iterator is returned. The #GSequenceIter at position @pos a #GSequence a position in @seq, or -1 for the end Returns the length of @seq the length of @seq a #GSequence Inserts @data into @sequence using @func to determine the new position. The sequence must already be sorted according to @cmp_func; otherwise the new position of @data is undefined. @cmp_func is called with two items of the @seq and @user_data. It should return 0 if the items are equal, a negative value if the first item comes before the second, and a positive value if the second item comes before the first. a #GSequenceIter pointing to the new item. a #GSequence the data to insert the function used to compare items in the sequence user data passed to @cmp_func. Like g_sequence_insert_sorted(), but uses a #GSequenceIterCompareFunc instead of a #GCompareDataFunc as the compare function. @iter_cmp is called with two iterators pointing into @seq. It should return 0 if the iterators are equal, a negative value if the first iterator comes before the second, and a positive value if the second iterator comes before the first. It is called with two iterators pointing into @seq. It should return 0 if the iterators are equal, a negative value if the first iterator comes before the second, and a positive value if the second iterator comes before the first. a #GSequenceIter pointing to the new item a #GSequence data for the new item the function used to compare iterators in the sequence user data passed to @cmp_func Returns an iterator pointing to the position of the first item found equal to @data according to @cmp_func and @cmp_data. If more than one item is equal, it is not guaranteed that it is the first which is returned. In that case, you can use g_sequence_iter_next() and g_sequence_iter_prev() to get others. @cmp_func is called with two items of the @seq and @user_data. It should return 0 if the items are equal, a negative value if the first item comes before the second, and a positive value if the second item comes before the first. This function will fail if the data contained in the sequence is unsorted. Use g_sequence_insert_sorted() or g_sequence_insert_sorted_iter() to add data to your sequence or, if you want to add a large amount of data, call g_sequence_sort() after doing unsorted insertions. an #GSequenceIter pointing to the position of the first item found equal to @data according to @cmp_func and @cmp_data, or %NULL if no such item exists a #GSequence data to lookup the function used to compare items in the sequence user data passed to @cmp_func Like g_sequence_lookup(), but uses a #GSequenceIterCompareFunc instead of a #GCompareDataFunc as the compare function. @iter_cmp is called with two iterators pointing into @seq. It should return 0 if the iterators are equal, a negative value if the first iterator comes before the second, and a positive value if the second iterator comes before the first. This function will fail if the data contained in the sequence is unsorted. Use g_sequence_insert_sorted() or g_sequence_insert_sorted_iter() to add data to your sequence or, if you want to add a large amount of data, call g_sequence_sort() after doing unsorted insertions. an #GSequenceIter pointing to the position of the first item found equal to @data according to @cmp_func and @cmp_data, or %NULL if no such item exists a #GSequence data to lookup the function used to compare iterators in the sequence user data passed to @iter_cmp Adds a new item to the front of @seq an iterator pointing to the new item a #GSequence the data for the new item Returns an iterator pointing to the position where @data would be inserted according to @cmp_func and @cmp_data. @cmp_func is called with two items of the @seq and @user_data. It should return 0 if the items are equal, a negative value if the first item comes before the second, and a positive value if the second item comes before the first. If you are simply searching for an existing element of the sequence, consider using g_sequence_lookup(). This function will fail if the data contained in the sequence is unsorted. Use g_sequence_insert_sorted() or g_sequence_insert_sorted_iter() to add data to your sequence or, if you want to add a large amount of data, call g_sequence_sort() after doing unsorted insertions. an #GSequenceIter pointing to the position where @data would have been inserted according to @cmp_func and @cmp_data a #GSequence data for the new item the function used to compare items in the sequence user data passed to @cmp_func Like g_sequence_search(), but uses a #GSequenceIterCompareFunc instead of a #GCompareDataFunc as the compare function. @iter_cmp is called with two iterators pointing into @seq. It should return 0 if the iterators are equal, a negative value if the first iterator comes before the second, and a positive value if the second iterator comes before the first. If you are simply searching for an existing element of the sequence, consider using g_sequence_lookup_iter(). This function will fail if the data contained in the sequence is unsorted. Use g_sequence_insert_sorted() or g_sequence_insert_sorted_iter() to add data to your sequence or, if you want to add a large amount of data, call g_sequence_sort() after doing unsorted insertions. a #GSequenceIter pointing to the position in @seq where @data would have been inserted according to @iter_cmp and @cmp_data a #GSequence data for the new item the function used to compare iterators in the sequence user data passed to @iter_cmp Sorts @seq using @cmp_func. @cmp_func is passed two items of @seq and should return 0 if they are equal, a negative value if the first comes before the second, and a positive value if the second comes before the first. a #GSequence the function used to sort the sequence user data passed to @cmp_func Like g_sequence_sort(), but uses a #GSequenceIterCompareFunc instead of a GCompareDataFunc as the compare function @cmp_func is called with two iterators pointing into @seq. It should return 0 if the iterators are equal, a negative value if the first iterator comes before the second, and a positive value if the second iterator comes before the first. a #GSequence the function used to compare iterators in the sequence user data passed to @cmp_func Calls @func for each item in the range (@begin, @end) passing @user_data to the function. a #GSequenceIter a #GSequenceIter a #GFunc user data passed to @func Returns the data that @iter points to. the data that @iter points to a #GSequenceIter Inserts a new item just before the item pointed to by @iter. an iterator pointing to the new item a #GSequenceIter the data for the new item Moves the item pointed to by @src to the position indicated by @dest. After calling this function @dest will point to the position immediately after @src. It is allowed for @src and @dest to point into different sequences. a #GSequenceIter pointing to the item to move a #GSequenceIter pointing to the position to which the item is moved Inserts the (@begin, @end) range at the destination pointed to by ptr. The @begin and @end iters must point into the same sequence. It is allowed for @dest to point to a different sequence than the one pointed into by @begin and @end. If @dest is NULL, the range indicated by @begin and @end is removed from the sequence. If @dest iter points to a place within the (@begin, @end) range, the range does not move. a #GSequenceIter a #GSequenceIter a #GSequenceIter Creates a new GSequence. The @data_destroy function, if non-%NULL will be called on all items when the sequence is destroyed and on items that are removed from the sequence. a new #GSequence a #GDestroyNotify function, or %NULL Finds an iterator somewhere in the range (@begin, @end). This iterator will be close to the middle of the range, but is not guaranteed to be exactly in the middle. The @begin and @end iterators must both point to the same sequence and @begin must come before or be equal to @end in the sequence. a #GSequenceIter pointing somewhere in the (@begin, @end) range a #GSequenceIter a #GSequenceIter Removes the item pointed to by @iter. It is an error to pass the end iterator to this function. If the sequence has a data destroy function associated with it, this function is called on the data for the removed item. a #GSequenceIter Removes all items in the (@begin, @end) range. If the sequence has a data destroy function associated with it, this function is called on the data for the removed items. a #GSequenceIter a #GSequenceIter Changes the data for the item pointed to by @iter to be @data. If the sequence has a data destroy function associated with it, that function is called on the existing data that @iter pointed to. a #GSequenceIter new data for the item Moves the data pointed to a new position as indicated by @cmp_func. This function should be called for items in a sequence already sorted according to @cmp_func whenever some aspect of an item changes so that @cmp_func may return different values for that item. @cmp_func is called with two items of the @seq and @user_data. It should return 0 if the items are equal, a negative value if the first item comes before the second, and a positive value if the second item comes before the first. A #GSequenceIter the function used to compare items in the sequence user data passed to @cmp_func. Like g_sequence_sort_changed(), but uses a #GSequenceIterCompareFunc instead of a #GCompareDataFunc as the compare function. @iter_cmp is called with two iterators pointing into @seq. It should return 0 if the iterators are equal, a negative value if the first iterator comes before the second, and a positive value if the second iterator comes before the first. a #GSequenceIter the function used to compare iterators in the sequence user data passed to @cmp_func Swaps the items pointed to by @a and @b. It is allowed for @a and @b to point into difference sequences. a #GSequenceIter a #GSequenceIter The #GSequenceIter struct is an opaque data type representing an iterator pointing into a #GSequence. Returns a negative number if @a comes before @b, 0 if they are equal, and a positive number if @a comes after @b. The @a and @b iterators must point into the same sequence. a negative number if @a comes before @b, 0 if they are equal, and a positive number if @a comes after @b a #GSequenceIter a #GSequenceIter Returns the position of @iter the position of @iter a #GSequenceIter Returns the #GSequence that @iter points into. the #GSequence that @iter points into a #GSequenceIter Returns whether @iter is the begin iterator whether @iter is the begin iterator a #GSequenceIter Returns whether @iter is the end iterator Whether @iter is the end iterator a #GSequenceIter Returns the #GSequenceIter which is @delta positions away from @iter. If @iter is closer than -@delta positions to the beginning of the sequence, the begin iterator is returned. If @iter is closer than @delta positions to the end of the sequence, the end iterator is returned. a #GSequenceIter which is @delta positions away from @iter a #GSequenceIter A positive or negative number indicating how many positions away from @iter the returned #GSequenceIter will be Returns an iterator pointing to the next position after @iter. If @iter is the end iterator, the end iterator is returned. a #GSequenceIter pointing to the next position after @iter a #GSequenceIter Returns an iterator pointing to the previous position before @iter. If @iter is the begin iterator, the begin iterator is returned. a #GSequenceIter pointing to the previous position before @iter a #GSequenceIter A #GSequenceIterCompareFunc is a function used to compare iterators. It must return zero if the iterators compare equal, a negative value if @a comes before @b, and a positive value if @b comes before @a. zero if the iterators are equal, a negative value if @a comes before @b, and a positive value if @b comes before @a. a #GSequenceIter a #GSequenceIter user data Error codes returned by shell functions. Mismatched or otherwise mangled quoting. String to be parsed was empty. Some other error. The `GSource` struct is an opaque data type representing an event source. Creates a new #GSource structure. The size is specified to allow creating structures derived from #GSource that contain additional data. The size passed in must be at least `sizeof (GSource)`. The source will not initially be associated with any #GMainContext and must be added to one with g_source_attach() before it will be executed. the newly-created #GSource. structure containing functions that implement the sources behavior. size of the #GSource structure to create. Adds @child_source to @source as a "polled" source; when @source is added to a #GMainContext, @child_source will be automatically added with the same priority, when @child_source is triggered, it will cause @source to dispatch (in addition to calling its own callback), and when @source is destroyed, it will destroy @child_source as well. (@source will also still be dispatched if its own prepare/check functions indicate that it is ready.) If you don't need @child_source to do anything on its own when it triggers, you can call g_source_set_dummy_callback() on it to set a callback that does nothing (except return %TRUE if appropriate). @source will hold a reference on @child_source while @child_source is attached to it. This API is only intended to be used by implementations of #GSource. Do not call this API on a #GSource that you did not create. a #GSource a second #GSource that @source should "poll" Adds a file descriptor to the set of file descriptors polled for this source. This is usually combined with g_source_new() to add an event source. The event source's check function will typically test the @revents field in the #GPollFD struct and return %TRUE if events need to be processed. This API is only intended to be used by implementations of #GSource. Do not call this API on a #GSource that you did not create. Using this API forces the linear scanning of event sources on each main loop iteration. Newly-written event sources should try to use g_source_add_unix_fd() instead of this API. a #GSource a #GPollFD structure holding information about a file descriptor to watch. Monitors @fd for the IO events in @events. The tag returned by this function can be used to remove or modify the monitoring of the fd using g_source_remove_unix_fd() or g_source_modify_unix_fd(). It is not necessary to remove the fd before destroying the source; it will be cleaned up automatically. This API is only intended to be used by implementations of #GSource. Do not call this API on a #GSource that you did not create. As the name suggests, this function is not available on Windows. an opaque tag a #GSource the fd to monitor an event mask Adds a #GSource to a @context so that it will be executed within that context. Remove it by calling g_source_destroy(). the ID (greater than 0) for the source within the #GMainContext. a #GSource a #GMainContext (if %NULL, the default context will be used) Removes a source from its #GMainContext, if any, and mark it as destroyed. The source cannot be subsequently added to another context. It is safe to call this on sources which have already been removed from their context. a #GSource Checks whether a source is allowed to be called recursively. see g_source_set_can_recurse(). whether recursion is allowed. a #GSource Gets the #GMainContext with which the source is associated. You can call this on a source that has been destroyed, provided that the #GMainContext it was attached to still exists (in which case it will return that #GMainContext). In particular, you can always call this function on the source returned from g_main_current_source(). But calling this function on a source whose #GMainContext has been destroyed is an error. the #GMainContext with which the source is associated, or %NULL if the context has not yet been added to a source. a #GSource This function ignores @source and is otherwise the same as g_get_current_time(). use g_source_get_time() instead a #GSource #GTimeVal structure in which to store current time. Returns the numeric ID for a particular source. The ID of a source is a positive integer which is unique within a particular main loop context. The reverse mapping from ID to source is done by g_main_context_find_source_by_id(). the ID (greater than 0) for the source a #GSource Gets a name for the source, used in debugging and profiling. The name may be #NULL if it has never been set with g_source_set_name(). the name of the source a #GSource Gets the priority of a source. the priority of the source a #GSource Gets the "ready time" of @source, as set by g_source_set_ready_time(). Any time before the current monotonic time (including 0) is an indication that the source will fire immediately. the monotonic ready time, -1 for "never" a #GSource Gets the time to be used when checking this source. The advantage of calling this function over calling g_get_monotonic_time() directly is that when checking multiple sources, GLib can cache a single value instead of having to repeatedly get the system monotonic time. The time here is the system monotonic time, if available, or some other reasonable alternative otherwise. See g_get_monotonic_time(). the monotonic time in microseconds a #GSource Returns whether @source has been destroyed. This is important when you operate upon your objects from within idle handlers, but may have freed the object before the dispatch of your idle handler. |[<!-- language="C" --> static gboolean idle_callback (gpointer data) { SomeWidget *self = data; GDK_THREADS_ENTER (); // do stuff with self self->idle_id = 0; GDK_THREADS_LEAVE (); return G_SOURCE_REMOVE; } static void some_widget_do_stuff_later (SomeWidget *self) { self->idle_id = g_idle_add (idle_callback, self); } static void some_widget_finalize (GObject *object) { SomeWidget *self = SOME_WIDGET (object); if (self->idle_id) g_source_remove (self->idle_id); G_OBJECT_CLASS (parent_class)->finalize (object); } ]| This will fail in a multi-threaded application if the widget is destroyed before the idle handler fires due to the use after free in the callback. A solution, to this particular problem, is to check to if the source has already been destroy within the callback. |[<!-- language="C" --> static gboolean idle_callback (gpointer data) { SomeWidget *self = data; GDK_THREADS_ENTER (); if (!g_source_is_destroyed (g_main_current_source ())) { // do stuff with self } GDK_THREADS_LEAVE (); return FALSE; } ]| %TRUE if the source has been destroyed a #GSource Updates the event mask to watch for the fd identified by @tag. @tag is the tag returned from g_source_add_unix_fd(). If you want to remove a fd, don't set its event mask to zero. Instead, call g_source_remove_unix_fd(). This API is only intended to be used by implementations of #GSource. Do not call this API on a #GSource that you did not create. As the name suggests, this function is not available on Windows. a #GSource the tag from g_source_add_unix_fd() the new event mask to watch Queries the events reported for the fd corresponding to @tag on @source during the last poll. The return value of this function is only defined when the function is called from the check or dispatch functions for @source. This API is only intended to be used by implementations of #GSource. Do not call this API on a #GSource that you did not create. As the name suggests, this function is not available on Windows. the conditions reported on the fd a #GSource the tag from g_source_add_unix_fd() Increases the reference count on a source by one. @source a #GSource Detaches @child_source from @source and destroys it. This API is only intended to be used by implementations of #GSource. Do not call this API on a #GSource that you did not create. a #GSource a #GSource previously passed to g_source_add_child_source(). Removes a file descriptor from the set of file descriptors polled for this source. This API is only intended to be used by implementations of #GSource. Do not call this API on a #GSource that you did not create. a #GSource a #GPollFD structure previously passed to g_source_add_poll(). Reverses the effect of a previous call to g_source_add_unix_fd(). You only need to call this if you want to remove an fd from being watched while keeping the same source around. In the normal case you will just want to destroy the source. This API is only intended to be used by implementations of #GSource. Do not call this API on a #GSource that you did not create. As the name suggests, this function is not available on Windows. a #GSource the tag from g_source_add_unix_fd() Sets the callback function for a source. The callback for a source is called from the source's dispatch function. The exact type of @func depends on the type of source; ie. you should not count on @func being called with @data as its first parameter. Typically, you won't use this function. Instead use functions specific to the type of source you are using. the source a callback function the data to pass to callback function a function to call when @data is no longer in use, or %NULL. Sets the callback function storing the data as a refcounted callback "object". This is used internally. Note that calling g_source_set_callback_indirect() assumes an initial reference count on @callback_data, and thus @callback_funcs->unref will eventually be called once more than @callback_funcs->ref. the source pointer to callback data "object" functions for reference counting @callback_data and getting the callback and data Sets whether a source can be called recursively. If @can_recurse is %TRUE, then while the source is being dispatched then this source will be processed normally. Otherwise, all processing of this source is blocked until the dispatch function returns. a #GSource whether recursion is allowed for this source Sets the source functions (can be used to override default implementations) of an unattached source. a #GSource the new #GSourceFuncs Sets a name for the source, used in debugging and profiling. The name defaults to #NULL. The source name should describe in a human-readable way what the source does. For example, "X11 event queue" or "GTK+ repaint idle handler" or whatever it is. It is permitted to call this function multiple times, but is not recommended due to the potential performance impact. For example, one could change the name in the "check" function of a #GSourceFuncs to include details like the event type in the source name. Use caution if changing the name while another thread may be accessing it with g_source_get_name(); that function does not copy the value, and changing the value will free it while the other thread may be attempting to use it. a #GSource debug name for the source Sets the priority of a source. While the main loop is being run, a source will be dispatched if it is ready to be dispatched and no sources at a higher (numerically smaller) priority are ready to be dispatched. A child source always has the same priority as its parent. It is not permitted to change the priority of a source once it has been added as a child of another source. a #GSource the new priority. Sets a #GSource to be dispatched when the given monotonic time is reached (or passed). If the monotonic time is in the past (as it always will be if @ready_time is 0) then the source will be dispatched immediately. If @ready_time is -1 then the source is never woken up on the basis of the passage of time. Dispatching the source does not reset the ready time. You should do so yourself, from the source dispatch function. Note that if you have a pair of sources where the ready time of one suggests that it will be delivered first but the priority for the other suggests that it would be delivered first, and the ready time for both sources is reached during the same main context iteration then the order of dispatch is undefined. This API is only intended to be used by implementations of #GSource. Do not call this API on a #GSource that you did not create. a #GSource the monotonic time at which the source will be ready, 0 for "immediately", -1 for "never" Decreases the reference count of a source by one. If the resulting reference count is zero the source and associated memory will be destroyed. a #GSource Removes the source with the given id from the default main context. The id of a #GSource is given by g_source_get_id(), or will be returned by the functions g_source_attach(), g_idle_add(), g_idle_add_full(), g_timeout_add(), g_timeout_add_full(), g_child_watch_add(), g_child_watch_add_full(), g_io_add_watch(), and g_io_add_watch_full(). See also g_source_destroy(). You must use g_source_destroy() for sources added to a non-default main context. It is a programmer error to attempt to remove a non-existent source. More specifically: source IDs can be reissued after a source has been destroyed and therefore it is never valid to use this function with a source ID which may have already been removed. An example is when scheduling an idle to run in another thread with g_idle_add(): the idle may already have run and been removed by the time this function is called on its (now invalid) source ID. This source ID may have been reissued, leading to the operation being performed against the wrong source. For historical reasons, this function always returns %TRUE the ID of the source to remove. Removes a source from the default main loop context given the source functions and user data. If multiple sources exist with the same source functions and user data, only one will be destroyed. %TRUE if a source was found and removed. The @source_funcs passed to g_source_new() the user data for the callback Removes a source from the default main loop context given the user data for the callback. If multiple sources exist with the same user data, only one will be destroyed. %TRUE if a source was found and removed. the user_data for the callback. Sets the name of a source using its ID. This is a convenience utility to set source names from the return value of g_idle_add(), g_timeout_add(), etc. It is a programmer error to attempt to set the name of a non-existent source. More specifically: source IDs can be reissued after a source has been destroyed and therefore it is never valid to use this function with a source ID which may have already been removed. An example is when scheduling an idle to run in another thread with g_idle_add(): the idle may already have run and been removed by the time this function is called on its (now invalid) source ID. This source ID may have been reissued, leading to the operation being performed against the wrong source. a #GSource ID debug name for the source The `GSourceCallbackFuncs` struct contains functions for managing callback objects. This is just a placeholder for #GClosureMarshal, which cannot be used here for dependency reasons. Specifies the type of function passed to g_timeout_add(), g_timeout_add_full(), g_idle_add(), and g_idle_add_full(). %FALSE if the source should be removed. #G_SOURCE_CONTINUE and #G_SOURCE_REMOVE are more memorable names for the return value. data passed to the function, set when the source was created with one of the above functions The `GSourceFuncs` struct contains a table of functions used to handle event sources in a generic manner. For idle sources, the prepare and check functions always return %TRUE to indicate that the source is always ready to be processed. The prepare function also returns a timeout value of 0 to ensure that the poll() call doesn't block (since that would be time wasted which could have been spent running the idle function). For timeout sources, the prepare and check functions both return %TRUE if the timeout interval has expired. The prepare function also returns a timeout value to ensure that the poll() call doesn't block too long and miss the next timeout. For file descriptor sources, the prepare function typically returns %FALSE, since it must wait until poll() has been called before it knows whether any events need to be processed. It sets the returned timeout to -1 to indicate that it doesn't mind how long the poll() call blocks. In the check function, it tests the results of the poll() call to see if the required condition has been met, and returns %TRUE if so. Specifies the type of the setup function passed to g_spawn_async(), g_spawn_sync() and g_spawn_async_with_pipes(), which can, in very limited ways, be used to affect the child's execution. On POSIX platforms, the function is called in the child after GLib has performed all the setup it plans to perform, but before calling exec(). Actions taken in this function will only affect the child, not the parent. On Windows, the function is called in the parent. Its usefulness on Windows is thus questionable. In many cases executing the child setup function in the parent can have ill effects, and you should be very careful when porting software to Windows that uses child setup functions. However, even on POSIX, you are extremely limited in what you can safely do from a #GSpawnChildSetupFunc, because any mutexes that were held by other threads in the parent process at the time of the fork() will still be locked in the child process, and they will never be unlocked (since the threads that held them don't exist in the child). POSIX allows only async-signal-safe functions (see signal(7)) to be called in the child between fork() and exec(), which drastically limits the usefulness of child setup functions. In particular, it is not safe to call any function which may call malloc(), which includes POSIX functions such as setenv(). If you need to set up the child environment differently from the parent, you should use g_get_environ(), g_environ_setenv(), and g_environ_unsetenv(), and then pass the complete environment list to the `g_spawn...` function. user data to pass to the function. Error codes returned by spawning processes. Fork failed due to lack of memory. Read or select on pipes failed. Changing to working directory failed. execv() returned `EACCES` execv() returned `EPERM` execv() returned `E2BIG` deprecated alias for %G_SPAWN_ERROR_TOO_BIG execv() returned `ENOEXEC` execv() returned `ENAMETOOLONG` execv() returned `ENOENT` execv() returned `ENOMEM` execv() returned `ENOTDIR` execv() returned `ELOOP` execv() returned `ETXTBUSY` execv() returned `EIO` execv() returned `ENFILE` execv() returned `EMFILE` execv() returned `EINVAL` execv() returned `EISDIR` execv() returned `ELIBBAD` Some other fatal failure, `error->message` should explain. Flags passed to g_spawn_sync(), g_spawn_async() and g_spawn_async_with_pipes(). no flags, default behaviour the parent's open file descriptors will be inherited by the child; otherwise all descriptors except stdin, stdout and stderr will be closed before calling exec() in the child. the child will not be automatically reaped; you must use g_child_watch_add() yourself (or call waitpid() or handle `SIGCHLD` yourself), or the child will become a zombie. `argv[0]` need not be an absolute path, it will be looked for in the user's `PATH`. the child's standard output will be discarded, instead of going to the same location as the parent's standard output. the child's standard error will be discarded. the child will inherit the parent's standard input (by default, the child's standard input is attached to `/dev/null`). the first element of `argv` is the file to execute, while the remaining elements are the actual argument vector to pass to the file. Normally g_spawn_async_with_pipes() uses `argv[0]` as the file to execute, and passes all of `argv` to the child. if `argv[0]` is not an abolute path, it will be looked for in the `PATH` from the passed child environment. Since: 2.34 create all pipes with the `O_CLOEXEC` flag set. Since: 2.40 A type corresponding to the appropriate struct type for the stat() system call, depending on the platform and/or compiler being used. See g_stat() for more information. The GString struct contains the public fields of a GString. points to the character data. It may move as text is added. The @str field is null-terminated and so can be used as an ordinary C string. contains the length of the string, not including the terminating nul byte. the number of bytes that can be stored in the string before it needs to be reallocated. May be larger than @len. Adds a string onto the end of a #GString, expanding it if necessary. @string a #GString the string to append onto the end of @string Adds a byte onto the end of a #GString, expanding it if necessary. @string a #GString the byte to append onto the end of @string Appends @len bytes of @val to @string. Because @len is provided, @val may contain embedded nuls and need not be nul-terminated. Since this function does not stop at nul bytes, it is the caller's responsibility to ensure that @val has at least @len addressable bytes. @string a #GString bytes to append number of bytes of @val to use Appends a formatted string onto the end of a #GString. This function is similar to g_string_printf() except that the text is appended to the #GString. a #GString the string format. See the printf() documentation the parameters to insert into the format string Converts a Unicode character into UTF-8, and appends it to the string. @string a #GString a Unicode character Appends @unescaped to @string, escaped any characters that are reserved in URIs using URI-style escape sequences. @string a #GString a string a string of reserved characters allowed to be used, or %NULL set %TRUE if the escaped string may include UTF8 characters Appends a formatted string onto the end of a #GString. This function is similar to g_string_append_printf() except that the arguments to the format string are passed as a va_list. a #GString the string format. See the printf() documentation the list of arguments to insert in the output Converts all uppercase ASCII letters to lowercase ASCII letters. passed-in @string pointer, with all the uppercase characters converted to lowercase in place, with semantics that exactly match g_ascii_tolower(). a GString Converts all lowercase ASCII letters to uppercase ASCII letters. passed-in @string pointer, with all the lowercase characters converted to uppercase in place, with semantics that exactly match g_ascii_toupper(). a GString Copies the bytes from a string into a #GString, destroying any previous contents. It is rather like the standard strcpy() function, except that you do not have to worry about having enough space to copy the string. @string the destination #GString. Its current contents are destroyed. the string to copy into @string Converts a #GString to lowercase. This function uses the locale-specific tolower() function, which is almost never the right thing. Use g_string_ascii_down() or g_utf8_strdown() instead. the #GString a #GString Compares two strings for equality, returning %TRUE if they are equal. For use with #GHashTable. %TRUE if the strings are the same length and contain the same bytes a #GString another #GString Removes @len bytes from a #GString, starting at position @pos. The rest of the #GString is shifted down to fill the gap. @string a #GString the position of the content to remove the number of bytes to remove, or -1 to remove all following bytes Frees the memory allocated for the #GString. If @free_segment is %TRUE it also frees the character data. If it's %FALSE, the caller gains ownership of the buffer and must free it after use with g_free(). the character data of @string (i.e. %NULL if @free_segment is %TRUE) a #GString if %TRUE, the actual character data is freed as well Transfers ownership of the contents of @string to a newly allocated #GBytes. The #GString structure itself is deallocated, and it is therefore invalid to use @string after invoking this function. Note that while #GString ensures that its buffer always has a trailing nul character (not reflected in its "len"), the returned #GBytes does not include this extra nul; i.e. it has length exactly equal to the "len" member. A newly allocated #GBytes containing contents of @string; @string itself is freed a #GString Creates a hash code for @str; for use with #GHashTable. hash code for @str a string to hash Inserts a copy of a string into a #GString, expanding it if necessary. @string a #GString the position to insert the copy of the string the string to insert Inserts a byte into a #GString, expanding it if necessary. @string a #GString the position to insert the byte the byte to insert Inserts @len bytes of @val into @string at @pos. Because @len is provided, @val may contain embedded nuls and need not be nul-terminated. If @pos is -1, bytes are inserted at the end of the string. Since this function does not stop at nul bytes, it is the caller's responsibility to ensure that @val has at least @len addressable bytes. @string a #GString position in @string where insertion should happen, or -1 for at the end bytes to insert number of bytes of @val to insert Converts a Unicode character into UTF-8, and insert it into the string at the given position. @string a #GString the position at which to insert character, or -1 to append at the end of the string a Unicode character Overwrites part of a string, lengthening it if necessary. @string a #GString the position at which to start overwriting the string that will overwrite the @string starting at @pos Overwrites part of a string, lengthening it if necessary. This function will work with embedded nuls. @string a #GString the position at which to start overwriting the string that will overwrite the @string starting at @pos the number of bytes to write from @val Adds a string on to the start of a #GString, expanding it if necessary. @string a #GString the string to prepend on the start of @string Adds a byte onto the start of a #GString, expanding it if necessary. @string a #GString the byte to prepend on the start of the #GString Prepends @len bytes of @val to @string. Because @len is provided, @val may contain embedded nuls and need not be nul-terminated. Since this function does not stop at nul bytes, it is the caller's responsibility to ensure that @val has at least @len addressable bytes. @string a #GString bytes to prepend number of bytes in @val to prepend Converts a Unicode character into UTF-8, and prepends it to the string. @string a #GString a Unicode character Writes a formatted string into a #GString. This is similar to the standard sprintf() function, except that the #GString buffer automatically expands to contain the results. The previous contents of the #GString are destroyed. a #GString the string format. See the printf() documentation the parameters to insert into the format string Sets the length of a #GString. If the length is less than the current length, the string will be truncated. If the length is greater than the current length, the contents of the newly added area are undefined. (However, as always, string->str[string->len] will be a nul byte.) @string a #GString the new length Cuts off the end of the GString, leaving the first @len bytes. @string a #GString the new size of @string Converts a #GString to uppercase. This function uses the locale-specific toupper() function, which is almost never the right thing. Use g_string_ascii_up() or g_utf8_strup() instead. @string a #GString Writes a formatted string into a #GString. This function is similar to g_string_printf() except that the arguments to the format string are passed as a va_list. a #GString the string format. See the printf() documentation the parameters to insert into the format string An opaque data structure representing String Chunks. It should only be accessed by using the following functions. Frees all strings contained within the #GStringChunk. After calling g_string_chunk_clear() it is not safe to access any of the strings which were contained within it. a #GStringChunk Frees all memory allocated by the #GStringChunk. After calling g_string_chunk_free() it is not safe to access any of the strings which were contained within it. a #GStringChunk Adds a copy of @string to the #GStringChunk. It returns a pointer to the new copy of the string in the #GStringChunk. The characters in the string can be changed, if necessary, though you should not change anything after the end of the string. Unlike g_string_chunk_insert_const(), this function does not check for duplicates. Also strings added with g_string_chunk_insert() will not be searched by g_string_chunk_insert_const() when looking for duplicates. a pointer to the copy of @string within the #GStringChunk a #GStringChunk the string to add Adds a copy of @string to the #GStringChunk, unless the same string has already been added to the #GStringChunk with g_string_chunk_insert_const(). This function is useful if you need to copy a large number of strings but do not want to waste space storing duplicates. But you must remember that there may be several pointers to the same string, and so any changes made to the strings should be done very carefully. Note that g_string_chunk_insert_const() will not return a pointer to a string added with g_string_chunk_insert(), even if they do match. a pointer to the new or existing copy of @string within the #GStringChunk a #GStringChunk the string to add Adds a copy of the first @len bytes of @string to the #GStringChunk. The copy is nul-terminated. Since this function does not stop at nul bytes, it is the caller's responsibility to ensure that @string has at least @len addressable bytes. The characters in the returned string can be changed, if necessary, though you should not change anything after the end of the string. a pointer to the copy of @string within the #GStringChunk a #GStringChunk bytes to insert number of bytes of @string to insert, or -1 to insert a nul-terminated string Creates a new #GStringChunk. a new #GStringChunk the default size of the blocks of memory which are allocated to store the strings. If a particular string is larger than this default size, a larger block of memory will be allocated for it. Evaluates to a time span of one day. Evaluates to a time span of one hour. Evaluates to a time span of one millisecond. Evaluates to a time span of one minute. Evaluates to a time span of one second. An opaque structure representing a test case. The type used for test case functions that take an extra pointer argument. the data provided when registering the test The type of file to return the filename for, when used with g_test_build_filename(). These two options correspond rather directly to the 'dist' and 'built' terminology that automake uses and are explicitly used to distinguish between the 'srcdir' and 'builddir' being separate. All files in your project should either be dist (in the `DIST_EXTRA` or `dist_schema_DATA` sense, in which case they will always be in the srcdir) or built (in the `BUILT_SOURCES` sense, in which case they will always be in the builddir). Note: as a general rule of automake, files that are generated only as part of the build-from-git process (but then are distributed with the tarball) always go in srcdir (even if doing a srcdir != builddir build from git) and are considered as distributed files. a file that was included in the distribution tarball a file that was built on the compiling machine The type used for functions that operate on test fixtures. This is used for the fixture setup and teardown functions as well as for the testcases themselves. @user_data is a pointer to the data that was given when registering the test case. @fixture will be a pointer to the area of memory allocated by the test framework, of the size requested. If the requested size was zero then @fixture will be equal to @user_data. the test fixture the data provided when registering the test The type used for test case functions. Internal function for gtester to free test log messages, no ABI guarantees provided. Internal function for gtester to retrieve test log messages, no ABI guarantees provided. Internal function for gtester to decode test log messages, no ABI guarantees provided. Internal function for gtester to decode test log messages, no ABI guarantees provided. Specifies the prototype of fatal log handler functions. %TRUE if the program should abort, %FALSE otherwise the log domain of the message the log level of the message (including the fatal and recursion flags) the message to process user data, set in g_test_log_set_fatal_handler() Internal function for gtester to free test log messages, no ABI guarantees provided. Flags to pass to g_test_trap_subprocess() to control input and output. Note that in contrast with g_test_trap_fork(), the default is to not show stdout and stderr. If this flag is given, the child process will inherit the parent's stdin. Otherwise, the child's stdin is redirected to `/dev/null`. If this flag is given, the child process will inherit the parent's stdout. Otherwise, the child's stdout will not be visible, but it will be captured to allow later tests with g_test_trap_assert_stdout(). If this flag is given, the child process will inherit the parent's stderr. Otherwise, the child's stderr will not be visible, but it will be captured to allow later tests with g_test_trap_assert_stderr(). An opaque structure representing a test suite. Adds @test_case to @suite. a #GTestSuite a #GTestCase Adds @nestedsuite to @suite. a #GTestSuite another #GTestSuite Test traps are guards around forked tests. These flags determine what traps to set. #GTestTrapFlags is used only with g_test_trap_fork(), which is deprecated. g_test_trap_subprocess() uses #GTestTrapSubprocessFlags. Redirect stdout of the test child to `/dev/null` so it cannot be observed on the console during test runs. The actual output is still captured though to allow later tests with g_test_trap_assert_stdout(). Redirect stderr of the test child to `/dev/null` so it cannot be observed on the console during test runs. The actual output is still captured though to allow later tests with g_test_trap_assert_stderr(). If this flag is given, stdin of the child process is shared with stdin of its parent process. It is redirected to `/dev/null` otherwise. The #GThread struct represents a running thread. This struct is returned by g_thread_new() or g_thread_try_new(). You can obtain the #GThread struct representing the current thread by calling g_thread_self(). GThread is refcounted, see g_thread_ref() and g_thread_unref(). The thread represented by it holds a reference while it is running, and g_thread_join() consumes the reference that it is given, so it is normally not necessary to manage GThread references explicitly. The structure is opaque -- none of its fields may be directly accessed. This function creates a new thread. The new thread starts by invoking @func with the argument data. The thread will run until @func returns or until g_thread_exit() is called from the new thread. The return value of @func becomes the return value of the thread, which can be obtained with g_thread_join(). The @name can be useful for discriminating threads in a debugger. It is not used for other purposes and does not have to be unique. Some systems restrict the length of @name to 16 bytes. If the thread can not be created the program aborts. See g_thread_try_new() if you want to attempt to deal with failures. To free the struct returned by this function, use g_thread_unref(). Note that g_thread_join() implicitly unrefs the #GThread as well. the new #GThread an (optional) name for the new thread a function to execute in the new thread an argument to supply to the new thread This function is the same as g_thread_new() except that it allows for the possibility of failure. If a thread can not be created (due to resource limits), @error is set and %NULL is returned. the new #GThread, or %NULL if an error occurred an (optional) name for the new thread a function to execute in the new thread an argument to supply to the new thread Waits until @thread finishes, i.e. the function @func, as given to g_thread_new(), returns or g_thread_exit() is called. If @thread has already terminated, then g_thread_join() returns immediately. Any thread can wait for any other thread by calling g_thread_join(), not just its 'creator'. Calling g_thread_join() from multiple threads for the same @thread leads to undefined behaviour. The value returned by @func or given to g_thread_exit() is returned by this function. g_thread_join() consumes the reference to the passed-in @thread. This will usually cause the #GThread struct and associated resources to be freed. Use g_thread_ref() to obtain an extra reference if you want to keep the GThread alive beyond the g_thread_join() call. the return value of the thread a #GThread Increase the reference count on @thread. a new reference to @thread a #GThread Decrease the reference count on @thread, possibly freeing all resources associated with it. Note that each thread holds a reference to its #GThread while it is running, so it is safe to drop your own reference to it if you don't need it anymore. a #GThread Terminates the current thread. If another thread is waiting for us using g_thread_join() then the waiting thread will be woken up and get @retval as the return value of g_thread_join(). Calling g_thread_exit() with a parameter @retval is equivalent to returning @retval from the function @func, as given to g_thread_new(). You must only call g_thread_exit() from a thread that you created yourself with g_thread_new() or related APIs. You must not call this function from a thread created with another threading library or or from within a #GThreadPool. the return value of this thread This functions returns the #GThread corresponding to the current thread. Note that this function does not increase the reference count of the returned struct. This function will return a #GThread even for threads that were not created by GLib (i.e. those created by other threading APIs). This may be useful for thread identification purposes (i.e. comparisons) but you must not use GLib functions (such as g_thread_join()) on these threads. the #GThread representing the current thread Causes the calling thread to voluntarily relinquish the CPU, so that other threads can run. This function is often used as a method to make busy wait less evil. Possible errors of thread related functions. a thread couldn't be created due to resource shortage. Try again later. Specifies the type of the @func functions passed to g_thread_new() or g_thread_try_new(). the return value of the thread data passed to the thread The #GThreadPool struct represents a thread pool. It has three public read-only members, but the underlying struct is bigger, so you must not copy this struct. the function to execute in the threads of this pool the user data for the threads of this pool are all threads exclusive to this pool Frees all resources allocated for @pool. If @immediate is %TRUE, no new task is processed for @pool. Otherwise @pool is not freed before the last task is processed. Note however, that no thread of this pool is interrupted while processing a task. Instead at least all still running threads can finish their tasks before the @pool is freed. If @wait_ is %TRUE, the functions does not return before all tasks to be processed (dependent on @immediate, whether all or only the currently running) are ready. Otherwise the function returns immediately. After calling this function @pool must not be used anymore. a #GThreadPool should @pool shut down immediately? should the function wait for all tasks to be finished? Returns the maximal number of threads for @pool. the maximal number of threads a #GThreadPool Returns the number of threads currently running in @pool. the number of threads currently running a #GThreadPool Inserts @data into the list of tasks to be executed by @pool. When the number of currently running threads is lower than the maximal allowed number of threads, a new thread is started (or reused) with the properties given to g_thread_pool_new(). Otherwise, @data stays in the queue until a thread in this pool finishes its previous task and processes @data. @error can be %NULL to ignore errors, or non-%NULL to report errors. An error can only occur when a new thread couldn't be created. In that case @data is simply appended to the queue of work to do. Before version 2.32, this function did not return a success status. %TRUE on success, %FALSE if an error occurred a #GThreadPool a new task for @pool Sets the maximal allowed number of threads for @pool. A value of -1 means that the maximal number of threads is unlimited. If @pool is an exclusive thread pool, setting the maximal number of threads to -1 is not allowed. Setting @max_threads to 0 means stopping all work for @pool. It is effectively frozen until @max_threads is set to a non-zero value again. A thread is never terminated while calling @func, as supplied by g_thread_pool_new(). Instead the maximal number of threads only has effect for the allocation of new threads in g_thread_pool_push(). A new thread is allocated, whenever the number of currently running threads in @pool is smaller than the maximal number. @error can be %NULL to ignore errors, or non-%NULL to report errors. An error can only occur when a new thread couldn't be created. Before version 2.32, this function did not return a success status. %TRUE on success, %FALSE if an error occurred a #GThreadPool a new maximal number of threads for @pool, or -1 for unlimited Sets the function used to sort the list of tasks. This allows the tasks to be processed by a priority determined by @func, and not just in the order in which they were added to the pool. Note, if the maximum number of threads is more than 1, the order that threads are executed cannot be guaranteed 100%. Threads are scheduled by the operating system and are executed at random. It cannot be assumed that threads are executed in the order they are created. a #GThreadPool the #GCompareDataFunc used to sort the list of tasks. This function is passed two tasks. It should return 0 if the order in which they are handled does not matter, a negative value if the first task should be processed before the second or a positive value if the second task should be processed first. user data passed to @func Returns the number of tasks still unprocessed in @pool. the number of unprocessed tasks a #GThreadPool This function will return the maximum @interval that a thread will wait in the thread pool for new tasks before being stopped. If this function returns 0, threads waiting in the thread pool for new work are not stopped. the maximum @interval (milliseconds) to wait for new tasks in the thread pool before stopping the thread Returns the maximal allowed number of unused threads. the maximal number of unused threads Returns the number of currently unused threads. the number of currently unused threads This function creates a new thread pool. Whenever you call g_thread_pool_push(), either a new thread is created or an unused one is reused. At most @max_threads threads are running concurrently for this thread pool. @max_threads = -1 allows unlimited threads to be created for this thread pool. The newly created or reused thread now executes the function @func with the two arguments. The first one is the parameter to g_thread_pool_push() and the second one is @user_data. The parameter @exclusive determines whether the thread pool owns all threads exclusive or shares them with other thread pools. If @exclusive is %TRUE, @max_threads threads are started immediately and they will run exclusively for this thread pool until it is destroyed by g_thread_pool_free(). If @exclusive is %FALSE, threads are created when needed and shared between all non-exclusive thread pools. This implies that @max_threads may not be -1 for exclusive thread pools. Besides, exclusive thread pools are not affected by g_thread_pool_set_max_idle_time() since their threads are never considered idle and returned to the global pool. @error can be %NULL to ignore errors, or non-%NULL to report errors. An error can only occur when @exclusive is set to %TRUE and not all @max_threads threads could be created. See #GThreadError for possible errors that may occurr. Note, even in case of error a valid #GThreadPool is returned. the new #GThreadPool a function to execute in the threads of the new thread pool user data that is handed over to @func every time it is called the maximal number of threads to execute concurrently in the new thread pool, -1 means no limit should this thread pool be exclusive? This function will set the maximum @interval that a thread waiting in the pool for new tasks can be idle for before being stopped. This function is similar to calling g_thread_pool_stop_unused_threads() on a regular timeout, except this is done on a per thread basis. By setting @interval to 0, idle threads will not be stopped. The default value is 15000 (15 seconds). the maximum @interval (in milliseconds) a thread can be idle Sets the maximal number of unused threads to @max_threads. If @max_threads is -1, no limit is imposed on the number of unused threads. The default value is 2. maximal number of unused threads Stops all currently unused threads. This does not change the maximal number of unused threads. This function can be used to regularly stop all unused threads e.g. from g_timeout_add(). Disambiguates a given time in two ways. First, specifies if the given time is in universal or local time. Second, if the time is in local time, specifies if it is local standard time or local daylight time. This is important for the case where the same local time occurs twice (during daylight savings time transitions, for example). the time is in local standard time the time is in local daylight time the time is in UTC Represents a precise time, with seconds and microseconds. Similar to the struct timeval returned by the gettimeofday() UNIX system call. GLib is attempting to unify around the use of 64bit integers to represent microsecond-precision time. As such, this type will be removed from a future version of GLib. seconds microseconds Adds the given number of microseconds to @time_. @microseconds can also be negative to decrease the value of @time_. a #GTimeVal number of microseconds to add to @time Converts @time_ into an RFC 3339 encoded string, relative to the Coordinated Universal Time (UTC). This is one of the many formats allowed by ISO 8601. ISO 8601 allows a large number of date/time formats, with or without punctuation and optional elements. The format returned by this function is a complete date and time, with optional punctuation included, the UTC time zone represented as "Z", and the @tv_usec part included if and only if it is nonzero, i.e. either "YYYY-MM-DDTHH:MM:SSZ" or "YYYY-MM-DDTHH:MM:SS.fffffZ". This corresponds to the Internet date/time format defined by [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt), and to either of the two most-precise formats defined by the W3C Note [Date and Time Formats](http://www.w3.org/TR/NOTE-datetime-19980827). Both of these documents are profiles of ISO 8601. Use g_date_time_format() or g_strdup_printf() if a different variation of ISO 8601 format is required. a newly allocated string containing an ISO 8601 date a #GTimeVal Converts a string containing an ISO 8601 encoded date and time to a #GTimeVal and puts it into @time_. @iso_date must include year, month, day, hours, minutes, and seconds. It can optionally include fractions of a second and a time zone indicator. (In the absence of any time zone indication, the timestamp is assumed to be in local time.) %TRUE if the conversion was successful. an ISO 8601 encoded date string a #GTimeVal #GTimeZone is an opaque structure whose members cannot be accessed directly. Creates a #GTimeZone corresponding to @identifier. @identifier can either be an RFC3339/ISO 8601 time offset or something that would pass as a valid value for the `TZ` environment variable (including %NULL). In Windows, @identifier can also be the unlocalized name of a time zone for standard time, for example "Pacific Standard Time". Valid RFC3339 time offsets are `"Z"` (for UTC) or `"±hh:mm"`. ISO 8601 additionally specifies `"±hhmm"` and `"±hh"`. Offsets are time values to be added to Coordinated Universal Time (UTC) to get the local time. In UNIX, the `TZ` environment variable typically corresponds to the name of a file in the zoneinfo database, or string in "std offset [dst [offset],start[/time],end[/time]]" (POSIX) format. There are no spaces in the specification. The name of standard and daylight savings time zone must be three or more alphabetic characters. Offsets are time values to be added to local time to get Coordinated Universal Time (UTC) and should be `"[±]hh[[:]mm[:ss]]"`. Dates are either `"Jn"` (Julian day with n between 1 and 365, leap years not counted), `"n"` (zero-based Julian day with n between 0 and 365) or `"Mm.w.d"` (day d (0 <= d <= 6) of week w (1 <= w <= 5) of month m (1 <= m <= 12), day 0 is a Sunday). Times are in local wall clock time, the default is 02:00:00. In Windows, the "tzn[+|–]hh[:mm[:ss]][dzn]" format is used, but also accepts POSIX format. The Windows format uses US rules for all time zones; daylight savings time is 60 minutes behind the standard time with date and time of change taken from Pacific Standard Time. Offsets are time values to be added to the local time to get Coordinated Universal Time (UTC). g_time_zone_new_local() calls this function with the value of the `TZ` environment variable. This function itself is independent of the value of `TZ`, but if @identifier is %NULL then `/etc/localtime` will be consulted to discover the correct time zone on UNIX and the registry will be consulted or GetTimeZoneInformation() will be used to get the local time zone on Windows. If intervals are not available, only time zone rules from `TZ` environment variable or other means, then they will be computed from year 1900 to 2037. If the maximum year for the rules is available and it is greater than 2037, then it will followed instead. See [RFC3339 §5.6](http://tools.ietf.org/html/rfc3339#section-5.6) for a precise definition of valid RFC3339 time offsets (the `time-offset` expansion) and ISO 8601 for the full list of valid time offsets. See [The GNU C Library manual](http://www.gnu.org/s/libc/manual/html_node/TZ-Variable.html) for an explanation of the possible values of the `TZ` environment variable. See [Microsoft Time Zone Index Values](http://msdn.microsoft.com/en-us/library/ms912391%28v=winembedded.11%29.aspx) for the list of time zones on Windows. You should release the return value by calling g_time_zone_unref() when you are done with it. the requested timezone a timezone identifier Creates a #GTimeZone corresponding to local time. The local time zone may change between invocations to this function; for example, if the system administrator changes it. This is equivalent to calling g_time_zone_new() with the value of the `TZ` environment variable (including the possibility of %NULL). You should release the return value by calling g_time_zone_unref() when you are done with it. the local timezone Creates a #GTimeZone corresponding to UTC. This is equivalent to calling g_time_zone_new() with a value like "Z", "UTC", "+00", etc. You should release the return value by calling g_time_zone_unref() when you are done with it. the universal timezone Finds an interval within @tz that corresponds to the given @time_, possibly adjusting @time_ if required to fit into an interval. The meaning of @time_ depends on @type. This function is similar to g_time_zone_find_interval(), with the difference that it always succeeds (by making the adjustments described below). In any of the cases where g_time_zone_find_interval() succeeds then this function returns the same value, without modifying @time_. This function may, however, modify @time_ in order to deal with non-existent times. If the non-existent local @time_ of 02:30 were requested on March 14th 2010 in Toronto then this function would adjust @time_ to be 03:00 and return the interval containing the adjusted time. the interval containing @time_, never -1 a #GTimeZone the #GTimeType of @time_ a pointer to a number of seconds since January 1, 1970 Finds an the interval within @tz that corresponds to the given @time_. The meaning of @time_ depends on @type. If @type is %G_TIME_TYPE_UNIVERSAL then this function will always succeed (since universal time is monotonic and continuous). Otherwise @time_ is treated as local time. The distinction between %G_TIME_TYPE_STANDARD and %G_TIME_TYPE_DAYLIGHT is ignored except in the case that the given @time_ is ambiguous. In Toronto, for example, 01:30 on November 7th 2010 occurred twice (once inside of daylight savings time and the next, an hour later, outside of daylight savings time). In this case, the different value of @type would result in a different interval being returned. It is still possible for this function to fail. In Toronto, for example, 02:00 on March 14th 2010 does not exist (due to the leap forward to begin daylight savings time). -1 is returned in that case. the interval containing @time_, or -1 in case of failure a #GTimeZone the #GTimeType of @time_ a number of seconds since January 1, 1970 Determines the time zone abbreviation to be used during a particular @interval of time in the time zone @tz. For example, in Toronto this is currently "EST" during the winter months and "EDT" during the summer months when daylight savings time is in effect. the time zone abbreviation, which belongs to @tz a #GTimeZone an interval within the timezone Determines the offset to UTC in effect during a particular @interval of time in the time zone @tz. The offset is the number of seconds that you add to UTC time to arrive at local time for @tz (ie: negative numbers for time zones west of GMT, positive numbers for east). the number of seconds that should be added to UTC to get the local time in @tz a #GTimeZone an interval within the timezone Determines if daylight savings time is in effect during a particular @interval of time in the time zone @tz. %TRUE if daylight savings time is in effect a #GTimeZone an interval within the timezone Increases the reference count on @tz. a new reference to @tz. a #GTimeZone Decreases the reference count on @tz. a #GTimeZone Opaque datatype that records a start time. Resumes a timer that has previously been stopped with g_timer_stop(). g_timer_stop() must be called before using this function. a #GTimer. Destroys a timer, freeing associated resources. a #GTimer to destroy. If @timer has been started but not stopped, obtains the time since the timer was started. If @timer has been stopped, obtains the elapsed time between the time it was started and the time it was stopped. The return value is the number of seconds elapsed, including any fractional part. The @microseconds out parameter is essentially useless. seconds elapsed as a floating point value, including any fractional part. a #GTimer. return location for the fractional part of seconds elapsed, in microseconds (that is, the total number of microseconds elapsed, modulo 1000000), or %NULL This function is useless; it's fine to call g_timer_start() on an already-started timer to reset the start time, so g_timer_reset() serves no purpose. a #GTimer. Marks a start time, so that future calls to g_timer_elapsed() will report the time since g_timer_start() was called. g_timer_new() automatically marks the start time, so no need to call g_timer_start() immediately after creating the timer. a #GTimer. Marks an end time, so calls to g_timer_elapsed() will return the difference between this end time and the start time. a #GTimer. Creates a new timer, and starts timing (i.e. g_timer_start() is implicitly called for you). a new #GTimer. The possible types of token returned from each g_scanner_get_next_token() call. the end of the file a '(' character a ')' character a '{' character a '}' character a '[' character a ']' character a '=' character a ',' character not a token an error occurred a character a binary integer an octal integer an integer a hex integer a floating point number a string a symbol an identifier a null identifier one line comment multi line comment A union holding the value of the token. token symbol value token identifier value token binary integer value octal integer value integer value 64-bit integer value floating point value hex integer value string value comment value character value error value The type of functions which are used to translate user-visible strings, for <option>--help</option> output. a translation of the string for the current locale. The returned string is owned by GLib and must not be freed. the untranslated string user data specified when installing the function, e.g. in g_option_group_set_translate_func() Each piece of memory that is pushed onto the stack is cast to a GTrashStack*. pointer to the previous element of the stack, gets stored in the first `sizeof (gpointer)` bytes of the element Returns the height of a #GTrashStack. Note that execution of this function is of O(N) complexity where N denotes the number of items on the stack. the height of the stack a #GTrashStack Returns the element at the top of a #GTrashStack which may be %NULL. the element at the top of the stack a #GTrashStack Pops a piece of memory off a #GTrashStack. the element at the top of the stack a #GTrashStack Pushes a piece of memory onto a #GTrashStack. a #GTrashStack the piece of memory to push on the stack Specifies which nodes are visited during several of the tree functions, including g_node_traverse() and g_node_find(). only leaf nodes should be visited. This name has been introduced in 2.6, for older version use %G_TRAVERSE_LEAFS. only non-leaf nodes should be visited. This name has been introduced in 2.6, for older version use %G_TRAVERSE_NON_LEAFS. all nodes should be visited. a mask of all traverse flags. identical to %G_TRAVERSE_LEAVES. identical to %G_TRAVERSE_NON_LEAVES. Specifies the type of function passed to g_tree_traverse(). It is passed the key and value of each node, together with the @user_data parameter passed to g_tree_traverse(). If the function returns %TRUE, the traversal is stopped. %TRUE to stop the traversal a key of a #GTree node the value corresponding to the key user data passed to g_tree_traverse() Specifies the type of traveral performed by g_tree_traverse(), g_node_traverse() and g_node_find(). The different orders are illustrated here: - In order: A, B, C, D, E, F, G, H, I ![](Sorted_binary_tree_inorder.svg) - Pre order: F, B, A, D, C, E, G, I, H ![](Sorted_binary_tree_preorder.svg) - Post order: A, C, E, D, B, H, I, G, F ![](Sorted_binary_tree_postorder.svg) - Level order: F, B, G, A, D, I, C, E, H ![](Sorted_binary_tree_breadth-first_traversal.svg) vists a node's left child first, then the node itself, then its right child. This is the one to use if you want the output sorted according to the compare function. visits a node, then its children. visits the node's children, then the node itself. is not implemented for [balanced binary trees][glib-Balanced-Binary-Trees]. For [n-ary trees][glib-N-ary-Trees], it vists the root node first, then its children, then its grandchildren, and so on. Note that this is less efficient than the other orders. The GTree struct is an opaque data structure representing a [balanced binary tree][glib-Balanced-Binary-Trees]. It should be accessed only by using the following functions. Removes all keys and values from the #GTree and decreases its reference count by one. If keys and/or values are dynamically allocated, you should either free them first or create the #GTree using g_tree_new_full(). In the latter case the destroy functions you supplied will be called on all keys and values before destroying the #GTree. a #GTree Calls the given function for each of the key/value pairs in the #GTree. The function is passed the key and value of each pair, and the given @data parameter. The tree is traversed in sorted order. The tree may not be modified while iterating over it (you can't add/remove items). To remove all items matching a predicate, you need to add each item to a list in your #GTraverseFunc as you walk over the tree, then walk the list and remove each item. a #GTree the function to call for each node visited. If this function returns %TRUE, the traversal is stopped. user data to pass to the function Gets the height of a #GTree. If the #GTree contains no nodes, the height is 0. If the #GTree contains only one root node the height is 1. If the root node has children the height is 2, etc. the height of @tree a #GTree Inserts a key/value pair into a #GTree. If the given key already exists in the #GTree its corresponding value is set to the new value. If you supplied a @value_destroy_func when creating the #GTree, the old value is freed using that function. If you supplied a @key_destroy_func when creating the #GTree, the passed key is freed using that function. The tree is automatically 'balanced' as new key/value pairs are added, so that the distance from the root to every leaf is as small as possible. a #GTree the key to insert the value corresponding to the key Gets the value corresponding to the given key. Since a #GTree is automatically balanced as key/value pairs are added, key lookup is O(log n) (where n is the number of key/value pairs in the tree). the value corresponding to the key, or %NULL if the key was not found a #GTree the key to look up Looks up a key in the #GTree, returning the original key and the associated value. This is useful if you need to free the memory allocated for the original key, for example before calling g_tree_remove(). %TRUE if the key was found in the #GTree a #GTree the key to look up returns the original key returns the value associated with the key Gets the number of nodes in a #GTree. the number of nodes in @tree a #GTree Increments the reference count of @tree by one. It is safe to call this function from any thread. the passed in #GTree a #GTree Removes a key/value pair from a #GTree. If the #GTree was created using g_tree_new_full(), the key and value are freed using the supplied destroy functions, otherwise you have to make sure that any dynamically allocated values are freed yourself. If the key does not exist in the #GTree, the function does nothing. %TRUE if the key was found (prior to 2.8, this function returned nothing) a #GTree the key to remove Inserts a new key and value into a #GTree similar to g_tree_insert(). The difference is that if the key already exists in the #GTree, it gets replaced by the new key. If you supplied a @value_destroy_func when creating the #GTree, the old value is freed using that function. If you supplied a @key_destroy_func when creating the #GTree, the old key is freed using that function. The tree is automatically 'balanced' as new key/value pairs are added, so that the distance from the root to every leaf is as small as possible. a #GTree the key to insert the value corresponding to the key Searches a #GTree using @search_func. The @search_func is called with a pointer to the key of a key/value pair in the tree, and the passed in @user_data. If @search_func returns 0 for a key/value pair, then the corresponding value is returned as the result of g_tree_search(). If @search_func returns -1, searching will proceed among the key/value pairs that have a smaller key; if @search_func returns 1, searching will proceed among the key/value pairs that have a larger key. the value corresponding to the found key, or %NULL if the key was not found a #GTree a function used to search the #GTree the data passed as the second argument to @search_func Removes a key and its associated value from a #GTree without calling the key and value destroy functions. If the key does not exist in the #GTree, the function does nothing. %TRUE if the key was found (prior to 2.8, this function returned nothing) a #GTree the key to remove Calls the given function for each node in the #GTree. The order of a balanced tree is somewhat arbitrary. If you just want to visit all nodes in sorted order, use g_tree_foreach() instead. If you really need to visit nodes in a different order, consider using an [n-ary tree][glib-N-ary-Trees]. a #GTree the function to call for each node visited. If this function returns %TRUE, the traversal is stopped. the order in which nodes are visited, one of %G_IN_ORDER, %G_PRE_ORDER and %G_POST_ORDER user data to pass to the function Decrements the reference count of @tree by one. If the reference count drops to 0, all keys and values will be destroyed (if destroy functions were specified) and all memory allocated by @tree will be released. It is safe to call this function from any thread. a #GTree Creates a new #GTree. a newly allocated #GTree the function used to order the nodes in the #GTree. It should return values similar to the standard strcmp() function - 0 if the two arguments are equal, a negative value if the first argument comes before the second, or a positive value if the first argument comes after the second. Creates a new #GTree like g_tree_new() and allows to specify functions to free the memory allocated for the key and value that get called when removing the entry from the #GTree. a newly allocated #GTree qsort()-style comparison function data to pass to comparison function a function to free the memory allocated for the key used when removing the entry from the #GTree or %NULL if you don't want to supply such a function a function to free the memory allocated for the value used when removing the entry from the #GTree or %NULL if you don't want to supply such a function Creates a new #GTree with a comparison function that accepts user data. See g_tree_new() for more details. a newly allocated #GTree qsort()-style comparison function data to pass to comparison function The maximum length (in codepoints) of a compatibility or canonical decomposition of a single Unicode character. This is as defined by Unicode 6.1. Generic delimiters characters as defined in RFC 3986. Includes ":/?#[]@". Subcomponent delimiter characters as defined in RFC 3986. Includes "!$&'()*+,;=". Number of microseconds in one second (1 million). This macro is provided for code readability. These are the possible line break classifications. Since new unicode versions may add new types here, applications should be ready to handle unknown values. They may be regarded as %G_UNICODE_BREAK_UNKNOWN. See <ulink url="http://www.unicode.org/unicode/reports/tr14/">http://www.unicode.org/unicode/reports/tr14/</ulink>. Mandatory Break (BK) Carriage Return (CR) Line Feed (LF) Attached Characters and Combining Marks (CM) Surrogates (SG) Zero Width Space (ZW) Inseparable (IN) Non-breaking ("Glue") (GL) Contingent Break Opportunity (CB) Space (SP) Break Opportunity After (BA) Break Opportunity Before (BB) Break Opportunity Before and After (B2) Hyphen (HY) Nonstarter (NS) Opening Punctuation (OP) Closing Punctuation (CL) Ambiguous Quotation (QU) Exclamation/Interrogation (EX) Ideographic (ID) Numeric (NU) Infix Separator (Numeric) (IS) Symbols Allowing Break After (SY) Ordinary Alphabetic and Symbol Characters (AL) Prefix (Numeric) (PR) Postfix (Numeric) (PO) Complex Content Dependent (South East Asian) (SA) Ambiguous (Alphabetic or Ideographic) (AI) Unknown (XX) Next Line (NL) Word Joiner (WJ) Hangul L Jamo (JL) Hangul V Jamo (JV) Hangul T Jamo (JT) Hangul LV Syllable (H2) Hangul LVT Syllable (H3) Closing Parenthesis (CP). Since 2.28 Conditional Japanese Starter (CJ). Since: 2.32 Hebrew Letter (HL). Since: 2.32 Regional Indicator (RI). Since: 2.36 The #GUnicodeScript enumeration identifies different writing systems. The values correspond to the names as defined in the Unicode standard. The enumeration has been added in GLib 2.14, and is interchangeable with #PangoScript. Note that new types may be added in the future. Applications should be ready to handle unknown values. See <ulink url="http://www.unicode.org/reports/tr24/">Unicode Standard Annex #24: Script names</ulink>. a value never returned from g_unichar_get_script() a character used by multiple different scripts a mark glyph that takes its script from the i base glyph to which it is attached Arabic Armenian Bengali Bopomofo Cherokee Coptic Cyrillic Deseret Devanagari Ethiopic Georgian Gothic Greek Gujarati Gurmukhi Han Hangul Hebrew Hiragana Kannada Katakana Khmer Lao Latin Malayalam Mongolian Myanmar Ogham Old Italic Oriya Runic Sinhala Syriac Tamil Telugu Thaana Thai Tibetan Canadian Aboriginal Yi Tagalog Hanunoo Buhid Tagbanwa Braille Cypriot Limbu Osmanya Shavian Linear B Tai Le Ugaritic New Tai Lue Buginese Glagolitic Tifinagh Syloti Nagri Old Persian Kharoshthi an unassigned code point Balinese Cuneiform Phoenician Phags-pa N'Ko Kayah Li. Since 2.16.3 Lepcha. Since 2.16.3 Rejang. Since 2.16.3 Sundanese. Since 2.16.3 Saurashtra. Since 2.16.3 Cham. Since 2.16.3 Ol Chiki. Since 2.16.3 Vai. Since 2.16.3 Carian. Since 2.16.3 Lycian. Since 2.16.3 Lydian. Since 2.16.3 Avestan. Since 2.26 Bamum. Since 2.26 Egyptian Hieroglpyhs. Since 2.26 Imperial Aramaic. Since 2.26 Inscriptional Pahlavi. Since 2.26 Inscriptional Parthian. Since 2.26 Javanese. Since 2.26 Kaithi. Since 2.26 Lisu. Since 2.26 Meetei Mayek. Since 2.26 Old South Arabian. Since 2.26 Old Turkic. Since 2.28 Samaritan. Since 2.26 Tai Tham. Since 2.26 Tai Viet. Since 2.26 Batak. Since 2.28 Brahmi. Since 2.28 Mandaic. Since 2.28 Chakma. Since: 2.32 Meroitic Cursive. Since: 2.32 Meroitic Hieroglyphs. Since: 2.32 Miao. Since: 2.32 Sharada. Since: 2.32 Sora Sompeng. Since: 2.32 Takri. Since: 2.32 Bassa. Since: 2.42 Caucasian Albanian. Since: 2.42 Duployan. Since: 2.42 Elbasan. Since: 2.42 Grantha. Since: 2.42 Kjohki. Since: 2.42 Khudawadi, Sindhi. Since: 2.42 Linear A. Since: 2.42 Mahajani. Since: 2.42 Manichaean. Since: 2.42 Mende Kikakui. Since: 2.42 Modi. Since: 2.42 Mro. Since: 2.42 Nabataean. Since: 2.42 Old North Arabian. Since: 2.42 Old Permic. Since: 2.42 Pahawh Hmong. Since: 2.42 Palmyrene. Since: 2.42 Pau Cin Hau. Since: 2.42 Psalter Pahlavi. Since: 2.42 Siddham. Since: 2.42 Tirhuta. Since: 2.42 @G_UNICODE_SCRIPT_WARANG_CITI Warang Citi. Since: 2.42 These are the possible character classifications from the Unicode specification. See <ulink url="http://www.unicode.org/Public/UNIDATA/UnicodeData.html">http://www.unicode.org/Public/UNIDATA/UnicodeData.html</ulink>. General category "Other, Control" (Cc) General category "Other, Format" (Cf) General category "Other, Not Assigned" (Cn) General category "Other, Private Use" (Co) General category "Other, Surrogate" (Cs) General category "Letter, Lowercase" (Ll) General category "Letter, Modifier" (Lm) General category "Letter, Other" (Lo) General category "Letter, Titlecase" (Lt) General category "Letter, Uppercase" (Lu) General category "Mark, Spacing" (Mc) General category "Mark, Enclosing" (Me) General category "Mark, Nonspacing" (Mn) General category "Number, Decimal Digit" (Nd) General category "Number, Letter" (Nl) General category "Number, Other" (No) General category "Punctuation, Connector" (Pc) General category "Punctuation, Dash" (Pd) General category "Punctuation, Close" (Pe) General category "Punctuation, Final quote" (Pf) General category "Punctuation, Initial quote" (Pi) General category "Punctuation, Other" (Po) General category "Punctuation, Open" (Ps) General category "Symbol, Currency" (Sc) General category "Symbol, Modifier" (Sk) General category "Symbol, Math" (Sm) General category "Symbol, Other" (So) General category "Separator, Line" (Zl) General category "Separator, Paragraph" (Zp) General category "Separator, Space" (Zs) The type of functions to be called when a UNIX fd watch source triggers. %FALSE if the source should be removed the fd that triggered the event the IO conditions reported on @fd user data passed to g_unix_fd_add() These are logical ids for special directories which are defined depending on the platform used. You should use g_get_user_special_dir() to retrieve the full path associated to the logical id. The #GUserDirectory enumeration can be extended at later date. Not every platform has a directory for every logical id in this enumeration. the user's Desktop directory the user's Documents directory the user's Downloads directory the user's Music directory the user's Pictures directory the user's shared directory the user's Templates directory the user's Movies directory the number of enum values A macro that should be defined by the user prior to including the glib.h header. The definition should be one of the predefined GLib version macros: %GLIB_VERSION_2_26, %GLIB_VERSION_2_28,... This macro defines the earliest version of GLib that the package is required to be able to compile against. If the compiler is configured to warn about the use of deprecated functions, then using functions that were deprecated in version %GLIB_VERSION_MIN_REQUIRED or earlier will cause warnings (but using functions deprecated in later releases will not). #GVariant is a variant datatype; it stores a value along with information about the type of that value. The range of possible values is determined by the type. The type system used by #GVariant is #GVariantType. #GVariant instances always have a type and a value (which are given at construction time). The type and value of a #GVariant instance can never change other than by the #GVariant itself being destroyed. A #GVariant cannot contain a pointer. #GVariant is reference counted using g_variant_ref() and g_variant_unref(). #GVariant also has floating reference counts -- see g_variant_ref_sink(). #GVariant is completely threadsafe. A #GVariant instance can be concurrently accessed in any way from any number of threads without problems. #GVariant is heavily optimised for dealing with data in serialised form. It works particularly well with data located in memory-mapped files. It can perform nearly all deserialisation operations in a small constant time, usually touching only a single memory page. Serialised #GVariant data can also be sent over the network. #GVariant is largely compatible with D-Bus. Almost all types of #GVariant instances can be sent over D-Bus. See #GVariantType for exceptions. (However, #GVariant's serialisation format is not the same as the serialisation format of a D-Bus message body: use #GDBusMessage, in the gio library, for those.) For space-efficiency, the #GVariant serialisation format does not automatically include the variant's length, type or endianness, which must either be implied from context (such as knowledge that a particular file format always contains a little-endian %G_VARIANT_TYPE_VARIANT which occupies the whole length of the file) or supplied out-of-band (for instance, a length, type and/or endianness indicator could be placed at the beginning of a file, network message or network stream). A #GVariant's size is limited mainly by any lower level operating system constraints, such as the number of bits in #gsize. For example, it is reasonable to have a 2GB file mapped into memory with #GMappedFile, and call g_variant_new_from_data() on it. For convenience to C programmers, #GVariant features powerful varargs-based value construction and destruction. This feature is designed to be embedded in other libraries. There is a Python-inspired text language for describing #GVariant values. #GVariant includes a printer for this language and a parser with type inferencing. ## Memory Use #GVariant tries to be quite efficient with respect to memory use. This section gives a rough idea of how much memory is used by the current implementation. The information here is subject to change in the future. The memory allocated by #GVariant can be grouped into 4 broad purposes: memory for serialised data, memory for the type information cache, buffer management memory and memory for the #GVariant structure itself. ## Serialised Data Memory This is the memory that is used for storing GVariant data in serialised form. This is what would be sent over the network or what would end up on disk, not counting any indicator of the endianness, or of the length or type of the top-level variant. The amount of memory required to store a boolean is 1 byte. 16, 32 and 64 bit integers and double precision floating point numbers use their "natural" size. Strings (including object path and signature strings) are stored with a nul terminator, and as such use the length of the string plus 1 byte. Maybe types use no space at all to represent the null value and use the same amount of space (sometimes plus one byte) as the equivalent non-maybe-typed value to represent the non-null case. Arrays use the amount of space required to store each of their members, concatenated. Additionally, if the items stored in an array are not of a fixed-size (ie: strings, other arrays, etc) then an additional framing offset is stored for each item. The size of this offset is either 1, 2 or 4 bytes depending on the overall size of the container. Additionally, extra padding bytes are added as required for alignment of child values. Tuples (including dictionary entries) use the amount of space required to store each of their members, concatenated, plus one framing offset (as per arrays) for each non-fixed-sized item in the tuple, except for the last one. Additionally, extra padding bytes are added as required for alignment of child values. Variants use the same amount of space as the item inside of the variant, plus 1 byte, plus the length of the type string for the item inside the variant. As an example, consider a dictionary mapping strings to variants. In the case that the dictionary is empty, 0 bytes are required for the serialisation. If we add an item "width" that maps to the int32 value of 500 then we will use 4 byte to store the int32 (so 6 for the variant containing it) and 6 bytes for the string. The variant must be aligned to 8 after the 6 bytes of the string, so that's 2 extra bytes. 6 (string) + 2 (padding) + 6 (variant) is 14 bytes used for the dictionary entry. An additional 1 byte is added to the array as a framing offset making a total of 15 bytes. If we add another entry, "title" that maps to a nullable string that happens to have a value of null, then we use 0 bytes for the null value (and 3 bytes for the variant to contain it along with its type string) plus 6 bytes for the string. Again, we need 2 padding bytes. That makes a total of 6 + 2 + 3 = 11 bytes. We now require extra padding between the two items in the array. After the 14 bytes of the first item, that's 2 bytes required. We now require 2 framing offsets for an extra two bytes. 14 + 2 + 11 + 2 = 29 bytes to encode the entire two-item dictionary. ## Type Information Cache For each GVariant type that currently exists in the program a type information structure is kept in the type information cache. The type information structure is required for rapid deserialisation. Continuing with the above example, if a #GVariant exists with the type "a{sv}" then a type information struct will exist for "a{sv}", "{sv}", "s", and "v". Multiple uses of the same type will share the same type information. Additionally, all single-digit types are stored in read-only static memory and do not contribute to the writable memory footprint of a program using #GVariant. Aside from the type information structures stored in read-only memory, there are two forms of type information. One is used for container types where there is a single element type: arrays and maybe types. The other is used for container types where there are multiple element types: tuples and dictionary entries. Array type info structures are 6 * sizeof (void *), plus the memory required to store the type string itself. This means that on 32-bit systems, the cache entry for "a{sv}" would require 30 bytes of memory (plus malloc overhead). Tuple type info structures are 6 * sizeof (void *), plus 4 * sizeof (void *) for each item in the tuple, plus the memory required to store the type string itself. A 2-item tuple, for example, would have a type information structure that consumed writable memory in the size of 14 * sizeof (void *) (plus type string) This means that on 32-bit systems, the cache entry for "{sv}" would require 61 bytes of memory (plus malloc overhead). This means that in total, for our "a{sv}" example, 91 bytes of type information would be allocated. The type information cache, additionally, uses a #GHashTable to store and lookup the cached items and stores a pointer to this hash table in static storage. The hash table is freed when there are zero items in the type cache. Although these sizes may seem large it is important to remember that a program will probably only have a very small number of different types of values in it and that only one type information structure is required for many different values of the same type. ## Buffer Management Memory #GVariant uses an internal buffer management structure to deal with the various different possible sources of serialised data that it uses. The buffer is responsible for ensuring that the correct call is made when the data is no longer in use by #GVariant. This may involve a g_free() or a g_slice_free() or even g_mapped_file_unref(). One buffer management structure is used for each chunk of serialised data. The size of the buffer management structure is 4 * (void *). On 32-bit systems, that's 16 bytes. ## GVariant structure The size of a #GVariant structure is 6 * (void *). On 32-bit systems, that's 24 bytes. #GVariant structures only exist if they are explicitly created with API calls. For example, if a #GVariant is constructed out of serialised data for the example given above (with the dictionary) then although there are 9 individual values that comprise the entire dictionary (two keys, two values, two variants containing the values, two dictionary entries, plus the dictionary itself), only 1 #GVariant instance exists -- the one referring to the dictionary. If calls are made to start accessing the other values then #GVariant instances will exist for those values only for as long as they are in use (ie: until you call g_variant_unref()). The type information is shared. The serialised data and the buffer management structure for that serialised data is shared by the child. ## Summary To put the entire example together, for our dictionary mapping strings to variants (with two entries, as given above), we are using 91 bytes of memory for type information, 29 byes of memory for the serialised data, 16 bytes for buffer management and 24 bytes for the #GVariant instance, or a total of 160 bytes, plus malloc overhead. If we were to use g_variant_get_child_value() to access the two dictionary entries, we would use an additional 48 bytes. If we were to have other dictionaries of the same type, we would use more memory for the serialised data and buffer management for those dictionaries, but the type information would be shared. Creates a new #GVariant instance. Think of this function as an analogue to g_strdup_printf(). The type of the created instance and the arguments that are expected by this function are determined by @format_string. See the section on [GVariant format strings][gvariant-format-strings]. Please note that the syntax of the format string is very likely to be extended in the future. The first character of the format string must not be '*' '?' '@' or 'r'; in essence, a new #GVariant must always be constructed by this function (and not merely passed through it unmodified). Note that the arguments must be of the correct width for their types specified in @format_string. This can be achieved by casting them. See the [GVariant varargs documentation][gvariant-varargs]. |[<!-- language="C" --> MyFlags some_flags = FLAG_ONE | FLAG_TWO; const gchar *some_strings[] = { "a", "b", "c", NULL }; GVariant *new_variant; new_variant = g_variant_new ("(t^as)", /<!-- -->* This cast is required. *<!-- -->/ (guint64) some_flags, some_strings); ]| a new floating #GVariant instance a #GVariant format string arguments, as per @format_string Creates a new #GVariant array from @children. @child_type must be non-%NULL if @n_children is zero. Otherwise, the child type is determined by inspecting the first element of the @children array. If @child_type is non-%NULL then it must be a definite type. The items of the array are taken from the @children array. No entry in the @children array may be %NULL. All items in the array must have the same type, which must be the same as @child_type, if given. If the @children are floating references (see g_variant_ref_sink()), the new instance takes ownership of them as if via g_variant_ref_sink(). a floating reference to a new #GVariant array the element type of the new array an array of #GVariant pointers, the children the length of @children Creates a new boolean #GVariant instance -- either %TRUE or %FALSE. a floating reference to a new boolean #GVariant instance a #gboolean value Creates a new byte #GVariant instance. a floating reference to a new byte #GVariant instance a #guint8 value Creates an array-of-bytes #GVariant with the contents of @string. This function is just like g_variant_new_string() except that the string need not be valid utf8. The nul terminator character at the end of the string is stored in the array. a floating reference to a new bytestring #GVariant instance a normal nul-terminated string in no particular encoding Constructs an array of bytestring #GVariant from the given array of strings. If @length is -1 then @strv is %NULL-terminated. a new floating #GVariant instance an array of strings the length of @strv, or -1 Creates a new dictionary entry #GVariant. @key and @value must be non-%NULL. @key must be a value of a basic type (ie: not a container). If the @key or @value are floating references (see g_variant_ref_sink()), the new instance takes ownership of them as if via g_variant_ref_sink(). a floating reference to a new dictionary entry #GVariant a basic #GVariant, the key a #GVariant, the value Creates a new double #GVariant instance. a floating reference to a new double #GVariant instance a #gdouble floating point value Provides access to the serialised data for an array of fixed-sized items. @value must be an array with fixed-sized elements. Numeric types are fixed-size as are tuples containing only other fixed-sized types. @element_size must be the size of a single element in the array. For example, if calling this function for an array of 32-bit integers, you might say sizeof(gint32). This value isn't used except for the purpose of a double-check that the form of the serialised data matches the caller's expectation. @n_elements, which must be non-%NULL is set equal to the number of items in the array. a floating reference to a new array #GVariant instance the #GVariantType of each element a pointer to the fixed array of contiguous elements the number of elements the size of each element Constructs a new serialised-mode #GVariant instance. This is the inner interface for creation of new serialised values that gets called from various functions in gvariant.c. A reference is taken on @bytes. a new #GVariant with a floating reference a #GVariantType a #GBytes if the contents of @bytes are trusted Creates a new #GVariant instance from serialised data. @type is the type of #GVariant instance that will be constructed. The interpretation of @data depends on knowing the type. @data is not modified by this function and must remain valid with an unchanging value until such a time as @notify is called with @user_data. If the contents of @data change before that time then the result is undefined. If @data is trusted to be serialised data in normal form then @trusted should be %TRUE. This applies to serialised data created within this process or read from a trusted location on the disk (such as a file installed in /usr/lib alongside your application). You should set trusted to %FALSE if @data is read from the network, a file in the user's home directory, etc. If @data was not stored in this machine's native endianness, any multi-byte numeric values in the returned variant will also be in non-native endianness. g_variant_byteswap() can be used to recover the original values. @notify will be called with @user_data when @data is no longer needed. The exact time of this call is unspecified and might even be before this function returns. a new floating #GVariant of type @type a definite #GVariantType the serialised data the size of @data %TRUE if @data is definitely in normal form function to call when @data is no longer needed data for @notify Creates a new handle #GVariant instance. By convention, handles are indexes into an array of file descriptors that are sent alongside a D-Bus message. If you're not interacting with D-Bus, you probably don't need them. a floating reference to a new handle #GVariant instance a #gint32 value Creates a new int16 #GVariant instance. a floating reference to a new int16 #GVariant instance a #gint16 value Creates a new int32 #GVariant instance. a floating reference to a new int32 #GVariant instance a #gint32 value Creates a new int64 #GVariant instance. a floating reference to a new int64 #GVariant instance a #gint64 value Depending on if @child is %NULL, either wraps @child inside of a maybe container or creates a Nothing instance for the given @type. At least one of @child_type and @child must be non-%NULL. If @child_type is non-%NULL then it must be a definite type. If they are both non-%NULL then @child_type must be the type of @child. If @child is a floating reference (see g_variant_ref_sink()), the new instance takes ownership of @child. a floating reference to a new #GVariant maybe instance the #GVariantType of the child, or %NULL the child value, or %NULL Creates a D-Bus object path #GVariant with the contents of @string. @string must be a valid D-Bus object path. Use g_variant_is_object_path() if you're not sure. a floating reference to a new object path #GVariant instance a normal C nul-terminated string Constructs an array of object paths #GVariant from the given array of strings. Each string must be a valid #GVariant object path; see g_variant_is_object_path(). If @length is -1 then @strv is %NULL-terminated. a new floating #GVariant instance an array of strings the length of @strv, or -1 Parses @format and returns the result. @format must be a text format #GVariant with one extension: at any point that a value may appear in the text, a '%' character followed by a GVariant format string (as per g_variant_new()) may appear. In that case, the same arguments are collected from the argument list as g_variant_new() would have collected. Note that the arguments must be of the correct width for their types specified in @format. This can be achieved by casting them. See the [GVariant varargs documentation][gvariant-varargs]. Consider this simple example: |[<!-- language="C" --> g_variant_new_parsed ("[('one', 1), ('two', %i), (%s, 3)]", 2, "three"); ]| In the example, the variable argument parameters are collected and filled in as if they were part of the original string to produce the result of |[<!-- language="C" --> [('one', 1), ('two', 2), ('three', 3)] ]| This function is intended only to be used with @format as a string literal. Any parse error is fatal to the calling process. If you want to parse data from untrusted sources, use g_variant_parse(). You may not use this function to return, unmodified, a single #GVariant pointer from the argument list. ie: @format may not solely be anything along the lines of "%*", "%?", "\%r", or anything starting with "%@". a new floating #GVariant instance a text format #GVariant arguments as per @format Parses @format and returns the result. This is the version of g_variant_new_parsed() intended to be used from libraries. The return value will be floating if it was a newly created GVariant instance. In the case that @format simply specified the collection of a #GVariant pointer (eg: @format was "%*") then the collected #GVariant pointer will be returned unmodified, without adding any additional references. Note that the arguments in @app must be of the correct width for their types specified in @format when collected into the #va_list. See the [GVariant varargs documentation][gvariant-varargs]. In order to behave correctly in all cases it is necessary for the calling function to g_variant_ref_sink() the return result before returning control to the user that originally provided the pointer. At this point, the caller will have their own full reference to the result. This can also be done by adding the result to a container, or by passing it to another g_variant_new() call. a new, usually floating, #GVariant a text format #GVariant a pointer to a #va_list Creates a string-type GVariant using printf formatting. This is similar to calling g_strdup_printf() and then g_variant_new_string() but it saves a temporary variable and an unnecessary copy. a floating reference to a new string #GVariant instance a printf-style format string arguments for @format_string Creates a D-Bus type signature #GVariant with the contents of @string. @string must be a valid D-Bus type signature. Use g_variant_is_signature() if you're not sure. a floating reference to a new signature #GVariant instance a normal C nul-terminated string Creates a string #GVariant with the contents of @string. @string must be valid utf8. a floating reference to a new string #GVariant instance a normal utf8 nul-terminated string Constructs an array of strings #GVariant from the given array of strings. If @length is -1 then @strv is %NULL-terminated. a new floating #GVariant instance an array of strings the length of @strv, or -1 Creates a string #GVariant with the contents of @string. @string must be valid utf8. This function consumes @string. g_free() will be called on @string when it is no longer required. You must not modify or access @string in any other way after passing it to this function. It is even possible that @string is immediately freed. a floating reference to a new string #GVariant instance a normal utf8 nul-terminated string Creates a new tuple #GVariant out of the items in @children. The type is determined from the types of @children. No entry in the @children array may be %NULL. If @n_children is 0 then the unit tuple is constructed. If the @children are floating references (see g_variant_ref_sink()), the new instance takes ownership of them as if via g_variant_ref_sink(). a floating reference to a new #GVariant tuple the items to make the tuple out of the length of @children Creates a new uint16 #GVariant instance. a floating reference to a new uint16 #GVariant instance a #guint16 value Creates a new uint32 #GVariant instance. a floating reference to a new uint32 #GVariant instance a #guint32 value Creates a new uint64 #GVariant instance. a floating reference to a new uint64 #GVariant instance a #guint64 value This function is intended to be used by libraries based on #GVariant that want to provide g_variant_new()-like functionality to their users. The API is more general than g_variant_new() to allow a wider range of possible uses. @format_string must still point to a valid format string, but it only needs to be nul-terminated if @endptr is %NULL. If @endptr is non-%NULL then it is updated to point to the first character past the end of the format string. @app is a pointer to a #va_list. The arguments, according to @format_string, are collected from this #va_list and the list is left pointing to the argument following the last. Note that the arguments in @app must be of the correct width for their types specified in @format_string when collected into the #va_list. See the [GVariant varargs documentation][gvariant-varargs. These two generalisations allow mixing of multiple calls to g_variant_new_va() and g_variant_get_va() within a single actual varargs call by the user. The return value will be floating if it was a newly created GVariant instance (for example, if the format string was "(ii)"). In the case that the format_string was '*', '?', 'r', or a format starting with '@' then the collected #GVariant pointer will be returned unmodified, without adding any additional references. In order to behave correctly in all cases it is necessary for the calling function to g_variant_ref_sink() the return result before returning control to the user that originally provided the pointer. At this point, the caller will have their own full reference to the result. This can also be done by adding the result to a container, or by passing it to another g_variant_new() call. a new, usually floating, #GVariant a string that is prefixed with a format string location to store the end pointer, or %NULL a pointer to a #va_list Boxes @value. The result is a #GVariant instance representing a variant containing the original value. If @child is a floating reference (see g_variant_ref_sink()), the new instance takes ownership of @child. a floating reference to a new variant #GVariant instance a #GVariant instance Performs a byteswapping operation on the contents of @value. The result is that all multi-byte numeric data contained in @value is byteswapped. That includes 16, 32, and 64bit signed and unsigned integers as well as file handles and double precision floating point values. This function is an identity mapping on any value that does not contain multi-byte numeric data. That include strings, booleans, bytes and containers containing only these things (recursively). The returned value is always in normal form and is marked as trusted. the byteswapped form of @value a #GVariant Checks if calling g_variant_get() with @format_string on @value would be valid from a type-compatibility standpoint. @format_string is assumed to be a valid format string (from a syntactic standpoint). If @copy_only is %TRUE then this function additionally checks that it would be safe to call g_variant_unref() on @value immediately after the call to g_variant_get() without invalidating the result. This is only possible if deep copies are made (ie: there are no pointers to the data inside of the soon-to-be-freed #GVariant instance). If this check fails then a g_critical() is printed and %FALSE is returned. This function is meant to be used by functions that wish to provide varargs accessors to #GVariant values of uncertain values (eg: g_variant_lookup() or g_menu_model_get_item_attribute()). %TRUE if @format_string is safe to use a #GVariant a valid #GVariant format string %TRUE to ensure the format string makes deep copies Classifies @value according to its top-level type. the #GVariantClass of @value a #GVariant Compares @one and @two. The types of @one and @two are #gconstpointer only to allow use of this function with #GTree, #GPtrArray, etc. They must each be a #GVariant. Comparison is only defined for basic types (ie: booleans, numbers, strings). For booleans, %FALSE is less than %TRUE. Numbers are ordered in the usual way. Strings are in ASCII lexographical order. It is a programmer error to attempt to compare container values or two values that have types that are not exactly equal. For example, you cannot compare a 32-bit signed integer with a 32-bit unsigned integer. Also note that this function is not particularly well-behaved when it comes to comparison of doubles; in particular, the handling of incomparable values (ie: NaN) is undefined. If you only require an equality comparison, g_variant_equal() is more general. negative value if a < b; zero if a = b; positive value if a > b. a basic-typed #GVariant instance a #GVariant instance of the same type Similar to g_variant_get_bytestring() except that instead of returning a constant string, the string is duplicated. The return value must be freed using g_free(). a newly allocated string an array-of-bytes #GVariant instance a pointer to a #gsize, to store the length (not including the nul terminator) Gets the contents of an array of array of bytes #GVariant. This call makes a deep copy; the return result should be released with g_strfreev(). If @length is non-%NULL then the number of elements in the result is stored there. In any case, the resulting array will be %NULL-terminated. For an empty array, @length will be set to 0 and a pointer to a %NULL pointer will be returned. an array of strings an array of array of bytes #GVariant ('aay') the length of the result, or %NULL Gets the contents of an array of object paths #GVariant. This call makes a deep copy; the return result should be released with g_strfreev(). If @length is non-%NULL then the number of elements in the result is stored there. In any case, the resulting array will be %NULL-terminated. For an empty array, @length will be set to 0 and a pointer to a %NULL pointer will be returned. an array of strings an array of object paths #GVariant the length of the result, or %NULL Similar to g_variant_get_string() except that instead of returning a constant string, the string is duplicated. The string will always be utf8 encoded. The return value must be freed using g_free(). a newly allocated string, utf8 encoded a string #GVariant instance a pointer to a #gsize, to store the length Gets the contents of an array of strings #GVariant. This call makes a deep copy; the return result should be released with g_strfreev(). If @length is non-%NULL then the number of elements in the result is stored there. In any case, the resulting array will be %NULL-terminated. For an empty array, @length will be set to 0 and a pointer to a %NULL pointer will be returned. an array of strings an array of strings #GVariant the length of the result, or %NULL Checks if @one and @two have the same type and value. The types of @one and @two are #gconstpointer only to allow use of this function with #GHashTable. They must each be a #GVariant. %TRUE if @one and @two are equal a #GVariant instance a #GVariant instance Deconstructs a #GVariant instance. Think of this function as an analogue to scanf(). The arguments that are expected by this function are entirely determined by @format_string. @format_string also restricts the permissible types of @value. It is an error to give a value with an incompatible type. See the section on [GVariant format strings][gvariant-format-strings]. Please note that the syntax of the format string is very likely to be extended in the future. @format_string determines the C types that are used for unpacking the values and also determines if the values are copied or borrowed, see the section on [GVariant format strings][gvariant-format-strings-pointers]. a #GVariant instance a #GVariant format string arguments, as per @format_string Returns the boolean value of @value. It is an error to call this function with a @value of any type other than %G_VARIANT_TYPE_BOOLEAN. %TRUE or %FALSE a boolean #GVariant instance Returns the byte value of @value. It is an error to call this function with a @value of any type other than %G_VARIANT_TYPE_BYTE. a #guchar a byte #GVariant instance Returns the string value of a #GVariant instance with an array-of-bytes type. The string has no particular encoding. If the array does not end with a nul terminator character, the empty string is returned. For this reason, you can always trust that a non-%NULL nul-terminated string will be returned by this function. If the array contains a nul terminator character somewhere other than the last byte then the returned string is the string, up to the first such nul character. It is an error to call this function with a @value that is not an array of bytes. The return value remains valid as long as @value exists. the constant string an array-of-bytes #GVariant instance Gets the contents of an array of array of bytes #GVariant. This call makes a shallow copy; the return result should be released with g_free(), but the individual strings must not be modified. If @length is non-%NULL then the number of elements in the result is stored there. In any case, the resulting array will be %NULL-terminated. For an empty array, @length will be set to 0 and a pointer to a %NULL pointer will be returned. an array of constant strings an array of array of bytes #GVariant ('aay') the length of the result, or %NULL Reads a child item out of a container #GVariant instance and deconstructs it according to @format_string. This call is essentially a combination of g_variant_get_child_value() and g_variant_get(). @format_string determines the C types that are used for unpacking the values and also determines if the values are copied or borrowed, see the section on [GVariant format strings][gvariant-format-strings-pointers]. a container #GVariant the index of the child to deconstruct a #GVariant format string arguments, as per @format_string Reads a child item out of a container #GVariant instance. This includes variants, maybes, arrays, tuples and dictionary entries. It is an error to call this function on any other type of #GVariant. It is an error if @index_ is greater than the number of child items in the container. See g_variant_n_children(). The returned value is never floating. You should free it with g_variant_unref() when you're done with it. This function is O(1). the child at the specified index a container #GVariant the index of the child to fetch Returns a pointer to the serialised form of a #GVariant instance. The returned data may not be in fully-normalised form if read from an untrusted source. The returned data must not be freed; it remains valid for as long as @value exists. If @value is a fixed-sized value that was deserialised from a corrupted serialised container then %NULL may be returned. In this case, the proper thing to do is typically to use the appropriate number of nul bytes in place of @value. If @value is not fixed-sized then %NULL is never returned. In the case that @value is already in serialised form, this function is O(1). If the value is not already in serialised form, serialisation occurs implicitly and is approximately O(n) in the size of the result. To deserialise the data returned by this function, in addition to the serialised data, you must know the type of the #GVariant, and (if the machine might be different) the endianness of the machine that stored it. As a result, file formats or network messages that incorporate serialised #GVariants must include this information either implicitly (for instance "the file always contains a %G_VARIANT_TYPE_VARIANT and it is always in little-endian order") or explicitly (by storing the type and/or endianness in addition to the serialised data). the serialised form of @value, or %NULL a #GVariant instance Returns a pointer to the serialised form of a #GVariant instance. The semantics of this function are exactly the same as g_variant_get_data(), except that the returned #GBytes holds a reference to the variant data. A new #GBytes representing the variant data a #GVariant Returns the double precision floating point value of @value. It is an error to call this function with a @value of any type other than %G_VARIANT_TYPE_DOUBLE. a #gdouble a double #GVariant instance Provides access to the serialised data for an array of fixed-sized items. @value must be an array with fixed-sized elements. Numeric types are fixed-size, as are tuples containing only other fixed-sized types. @element_size must be the size of a single element in the array, as given by the section on [serialized data memory][gvariant-serialised-data-memory]. In particular, arrays of these fixed-sized types can be interpreted as an array of the given C type, with @element_size set to the size the appropriate type: - %G_VARIANT_TYPE_INT16 (etc.): #gint16 (etc.) - %G_VARIANT_TYPE_BOOLEAN: #guchar (not #gboolean!) - %G_VARIANT_TYPE_BYTE: #guchar - %G_VARIANT_TYPE_HANDLE: #guint32 - %G_VARIANT_TYPE_DOUBLE: #gdouble For example, if calling this function for an array of 32-bit integers, you might say sizeof(gint32). This value isn't used except for the purpose of a double-check that the form of the serialised data matches the caller's expectation. @n_elements, which must be non-%NULL is set equal to the number of items in the array. a pointer to the fixed array a #GVariant array with fixed-sized elements a pointer to the location to store the number of items the size of each element Returns the 32-bit signed integer value of @value. It is an error to call this function with a @value of any type other than %G_VARIANT_TYPE_HANDLE. By convention, handles are indexes into an array of file descriptors that are sent alongside a D-Bus message. If you're not interacting with D-Bus, you probably don't need them. a #gint32 a handle #GVariant instance Returns the 16-bit signed integer value of @value. It is an error to call this function with a @value of any type other than %G_VARIANT_TYPE_INT16. a #gint16 a int16 #GVariant instance Returns the 32-bit signed integer value of @value. It is an error to call this function with a @value of any type other than %G_VARIANT_TYPE_INT32. a #gint32 a int32 #GVariant instance Returns the 64-bit signed integer value of @value. It is an error to call this function with a @value of any type other than %G_VARIANT_TYPE_INT64. a #gint64 a int64 #GVariant instance Given a maybe-typed #GVariant instance, extract its value. If the value is Nothing, then this function returns %NULL. the contents of @value, or %NULL a maybe-typed value Gets a #GVariant instance that has the same value as @value and is trusted to be in normal form. If @value is already trusted to be in normal form then a new reference to @value is returned. If @value is not already trusted, then it is scanned to check if it is in normal form. If it is found to be in normal form then it is marked as trusted and a new reference to it is returned. If @value is found not to be in normal form then a new trusted #GVariant is created with the same value as @value. It makes sense to call this function if you've received #GVariant data from untrusted sources and you want to ensure your serialised output is definitely in normal form. a trusted #GVariant a #GVariant Gets the contents of an array of object paths #GVariant. This call makes a shallow copy; the return result should be released with g_free(), but the individual strings must not be modified. If @length is non-%NULL then the number of elements in the result is stored there. In any case, the resulting array will be %NULL-terminated. For an empty array, @length will be set to 0 and a pointer to a %NULL pointer will be returned. an array of constant strings an array of object paths #GVariant the length of the result, or %NULL Determines the number of bytes that would be required to store @value with g_variant_store(). If @value has a fixed-sized type then this function always returned that fixed size. In the case that @value is already in serialised form or the size has already been calculated (ie: this function has been called before) then this function is O(1). Otherwise, the size is calculated, an operation which is approximately O(n) in the number of values involved. the serialised size of @value a #GVariant instance Returns the string value of a #GVariant instance with a string type. This includes the types %G_VARIANT_TYPE_STRING, %G_VARIANT_TYPE_OBJECT_PATH and %G_VARIANT_TYPE_SIGNATURE. The string will always be utf8 encoded. If @length is non-%NULL then the length of the string (in bytes) is returned there. For trusted values, this information is already known. For untrusted values, a strlen() will be performed. It is an error to call this function with a @value of any type other than those three. The return value remains valid as long as @value exists. the constant string, utf8 encoded a string #GVariant instance a pointer to a #gsize, to store the length Gets the contents of an array of strings #GVariant. This call makes a shallow copy; the return result should be released with g_free(), but the individual strings must not be modified. If @length is non-%NULL then the number of elements in the result is stored there. In any case, the resulting array will be %NULL-terminated. For an empty array, @length will be set to 0 and a pointer to a %NULL pointer will be returned. an array of constant strings an array of strings #GVariant the length of the result, or %NULL Determines the type of @value. The return value is valid for the lifetime of @value and must not be freed. a #GVariantType a #GVariant Returns the type string of @value. Unlike the result of calling g_variant_type_peek_string(), this string is nul-terminated. This string belongs to #GVariant and must not be freed. the type string for the type of @value a #GVariant Returns the 16-bit unsigned integer value of @value. It is an error to call this function with a @value of any type other than %G_VARIANT_TYPE_UINT16. a #guint16 a uint16 #GVariant instance Returns the 32-bit unsigned integer value of @value. It is an error to call this function with a @value of any type other than %G_VARIANT_TYPE_UINT32. a #guint32 a uint32 #GVariant instance Returns the 64-bit unsigned integer value of @value. It is an error to call this function with a @value of any type other than %G_VARIANT_TYPE_UINT64. a #guint64 a uint64 #GVariant instance This function is intended to be used by libraries based on #GVariant that want to provide g_variant_get()-like functionality to their users. The API is more general than g_variant_get() to allow a wider range of possible uses. @format_string must still point to a valid format string, but it only need to be nul-terminated if @endptr is %NULL. If @endptr is non-%NULL then it is updated to point to the first character past the end of the format string. @app is a pointer to a #va_list. The arguments, according to @format_string, are collected from this #va_list and the list is left pointing to the argument following the last. These two generalisations allow mixing of multiple calls to g_variant_new_va() and g_variant_get_va() within a single actual varargs call by the user. @format_string determines the C types that are used for unpacking the values and also determines if the values are copied or borrowed, see the section on [GVariant format strings][gvariant-format-strings-pointers]. a #GVariant a string that is prefixed with a format string location to store the end pointer, or %NULL a pointer to a #va_list Unboxes @value. The result is the #GVariant instance that was contained in @value. the item contained in the variant a variant #GVariant instance Generates a hash value for a #GVariant instance. The output of this function is guaranteed to be the same for a given value only per-process. It may change between different processor architectures or even different versions of GLib. Do not use this function as a basis for building protocols or file formats. The type of @value is #gconstpointer only to allow use of this function with #GHashTable. @value must be a #GVariant. a hash value corresponding to @value a basic #GVariant value as a #gconstpointer Checks if @value is a container. %TRUE if @value is a container a #GVariant instance Checks whether @value has a floating reference count. This function should only ever be used to assert that a given variant is or is not floating, or for debug purposes. To acquire a reference to a variant that might be floating, always use g_variant_ref_sink() or g_variant_take_ref(). See g_variant_ref_sink() for more information about floating reference counts. whether @value is floating a #GVariant Checks if @value is in normal form. The main reason to do this is to detect if a given chunk of serialised data is in normal form: load the data into a #GVariant using g_variant_new_from_data() and then use this function to check. If @value is found to be in normal form then it will be marked as being trusted. If the value was already marked as being trusted then this function will immediately return %TRUE. %TRUE if @value is in normal form a #GVariant instance Checks if a value has a type matching the provided type. %TRUE if the type of @value matches @type a #GVariant instance a #GVariantType Creates a heap-allocated #GVariantIter for iterating over the items in @value. Use g_variant_iter_free() to free the return value when you no longer need it. A reference is taken to @value and will be released only when g_variant_iter_free() is called. a new heap-allocated #GVariantIter a container #GVariant Looks up a value in a dictionary #GVariant. This function is a wrapper around g_variant_lookup_value() and g_variant_get(). In the case that %NULL would have been returned, this function returns %FALSE. Otherwise, it unpacks the returned value and returns %TRUE. @format_string determines the C types that are used for unpacking the values and also determines if the values are copied or borrowed, see the section on [GVariant format strings][gvariant-format-strings-pointers]. This function is currently implemented with a linear scan. If you plan to do many lookups then #GVariantDict may be more efficient. %TRUE if a value was unpacked a dictionary #GVariant the key to lookup in the dictionary a GVariant format string the arguments to unpack the value into Looks up a value in a dictionary #GVariant. This function works with dictionaries of the type a{s*} (and equally well with type a{o*}, but we only further discuss the string case for sake of clarity). In the event that @dictionary has the type a{sv}, the @expected_type string specifies what type of value is expected to be inside of the variant. If the value inside the variant has a different type then %NULL is returned. In the event that @dictionary has a value type other than v then @expected_type must directly match the key type and it is used to unpack the value directly or an error occurs. In either case, if @key is not found in @dictionary, %NULL is returned. If the key is found and the value has the correct type, it is returned. If @expected_type was specified then any non-%NULL return value will have this type. This function is currently implemented with a linear scan. If you plan to do many lookups then #GVariantDict may be more efficient. the value of the dictionary key, or %NULL a dictionary #GVariant the key to lookup in the dictionary a #GVariantType, or %NULL Determines the number of children in a container #GVariant instance. This includes variants, maybes, arrays, tuples and dictionary entries. It is an error to call this function on any other type of #GVariant. For variants, the return value is always 1. For values with maybe types, it is always zero or one. For arrays, it is the length of the array. For tuples it is the number of tuple items (which depends only on the type). For dictionary entries, it is always 2 This function is O(1). the number of children in the container a container #GVariant Pretty-prints @value in the format understood by g_variant_parse(). The format is described [here][gvariant-text]. If @type_annotate is %TRUE, then type information is included in the output. a newly-allocated string holding the result. a #GVariant %TRUE if type information should be included in the output Behaves as g_variant_print(), but operates on a #GString. If @string is non-%NULL then it is appended to and returned. Else, a new empty #GString is allocated and it is returned. a #GString containing the string a #GVariant a #GString, or %NULL %TRUE if type information should be included in the output Increases the reference count of @value. the same @value a #GVariant #GVariant uses a floating reference count system. All functions with names starting with `g_variant_new_` return floating references. Calling g_variant_ref_sink() on a #GVariant with a floating reference will convert the floating reference into a full reference. Calling g_variant_ref_sink() on a non-floating #GVariant results in an additional normal reference being added. In other words, if the @value is floating, then this call "assumes ownership" of the floating reference, converting it to a normal reference. If the @value is not floating, then this call adds a new normal reference increasing the reference count by one. All calls that result in a #GVariant instance being inserted into a container will call g_variant_ref_sink() on the instance. This means that if the value was just created (and has only its floating reference) then the container will assume sole ownership of the value at that point and the caller will not need to unreference it. This makes certain common styles of programming much easier while still maintaining normal refcounting semantics in situations where values are not floating. the same @value a #GVariant Stores the serialised form of @value at @data. @data should be large enough. See g_variant_get_size(). The stored data is in machine native byte order but may not be in fully-normalised form if read from an untrusted source. See g_variant_get_normal_form() for a solution. As with g_variant_get_data(), to be able to deserialise the serialised variant successfully, its type and (if the destination machine might be different) its endianness must also be available. This function is approximately O(n) in the size of @data. the #GVariant to store the location to store the serialised data at If @value is floating, sink it. Otherwise, do nothing. Typically you want to use g_variant_ref_sink() in order to automatically do the correct thing with respect to floating or non-floating references, but there is one specific scenario where this function is helpful. The situation where this function is helpful is when creating an API that allows the user to provide a callback function that returns a #GVariant. We certainly want to allow the user the flexibility to return a non-floating reference from this callback (for the case where the value that is being returned already exists). At the same time, the style of the #GVariant API makes it likely that for newly-created #GVariant instances, the user can be saved some typing if they are allowed to return a #GVariant with a floating reference. Using this function on the return value of the user's callback allows the user to do whichever is more convenient for them. The caller will alway receives exactly one full reference to the value: either the one that was returned in the first place, or a floating reference that has been converted to a full reference. This function has an odd interaction when combined with g_variant_ref_sink() running at the same time in another thread on the same #GVariant instance. If g_variant_ref_sink() runs first then the result will be that the floating reference is converted to a hard reference. If g_variant_take_ref() runs first then the result will be that the floating reference is converted to a hard reference and an additional reference on top of that one is added. It is best to avoid this situation. the same @value a #GVariant Decreases the reference count of @value. When its reference count drops to 0, the memory used by the variant is freed. a #GVariant Determines if a given string is a valid D-Bus object path. You should ensure that a string is a valid D-Bus object path before passing it to g_variant_new_object_path(). A valid object path starts with '/' followed by zero or more sequences of characters separated by '/' characters. Each sequence must contain only the characters "[A-Z][a-z][0-9]_". No sequence (including the one following the final '/' character) may be empty. %TRUE if @string is a D-Bus object path a normal C nul-terminated string Determines if a given string is a valid D-Bus type signature. You should ensure that a string is a valid D-Bus type signature before passing it to g_variant_new_signature(). D-Bus type signatures consist of zero or more definite #GVariantType strings in sequence. %TRUE if @string is a D-Bus type signature a normal C nul-terminated string Parses a #GVariant from a text representation. A single #GVariant is parsed from the content of @text. The format is described [here][gvariant-text]. The memory at @limit will never be accessed and the parser behaves as if the character at @limit is the nul terminator. This has the effect of bounding @text. If @endptr is non-%NULL then @text is permitted to contain data following the value that this function parses and @endptr will be updated to point to the first character past the end of the text parsed by this function. If @endptr is %NULL and there is extra data then an error is returned. If @type is non-%NULL then the value will be parsed to have that type. This may result in additional parse errors (in the case that the parsed value doesn't fit the type) but may also result in fewer errors (in the case that the type would have been ambiguous, such as with empty arrays). In the event that the parsing is successful, the resulting #GVariant is returned. In case of any error, %NULL will be returned. If @error is non-%NULL then it will be set to reflect the error that occurred. Officially, the language understood by the parser is "any string produced by g_variant_print()". a reference to a #GVariant, or %NULL a #GVariantType, or %NULL a string containing a GVariant in text form a pointer to the end of @text, or %NULL a location to store the end pointer, or %NULL Pretty-prints a message showing the context of a #GVariant parse error within the string for which parsing was attempted. The resulting string is suitable for output to the console or other monospace media where newlines are treated in the usual way. The message will typically look something like one of the following: |[ unterminated string constant: (1, 2, 3, 'abc ^^^^ ]| or |[ unable to find a common type: [1, 2, 3, 'str'] ^ ^^^^^ ]| The format of the message may change in a future version. @error must have come from a failed attempt to g_variant_parse() and @source_str must be exactly the same string that caused the error. If @source_str was not nul-terminated when you passed it to g_variant_parse() then you must add nul termination before using this function. the printed message a #GError from the #GVariantParseError domain the string that was given to the parser Same as g_variant_error_quark(). Use g_variant_parse_error_quark() instead. A utility type for constructing container-type #GVariant instances. This is an opaque structure and may only be accessed using the following functions. #GVariantBuilder is not threadsafe in any way. Do not attempt to access it from more than one thread. Allocates and initialises a new #GVariantBuilder. You should call g_variant_builder_unref() on the return value when it is no longer needed. The memory will not be automatically freed by any other call. In most cases it is easier to place a #GVariantBuilder directly on the stack of the calling function and initialise it with g_variant_builder_init(). a #GVariantBuilder a container type Adds to a #GVariantBuilder. This call is a convenience wrapper that is exactly equivalent to calling g_variant_new() followed by g_variant_builder_add_value(). Note that the arguments must be of the correct width for their types specified in @format_string. This can be achieved by casting them. See the [GVariant varargs documentation][gvariant-varargs]. This function might be used as follows: |[<!-- language="C" --> GVariant * make_pointless_dictionary (void) { GVariantBuilder builder; int i; g_variant_builder_init (&builder, G_VARIANT_TYPE_ARRAY); for (i = 0; i < 16; i++) { gchar buf[3]; sprintf (buf, "%d", i); g_variant_builder_add (&builder, "{is}", i, buf); } return g_variant_builder_end (&builder); } ]| a #GVariantBuilder a #GVariant varargs format string arguments, as per @format_string Adds to a #GVariantBuilder. This call is a convenience wrapper that is exactly equivalent to calling g_variant_new_parsed() followed by g_variant_builder_add_value(). Note that the arguments must be of the correct width for their types specified in @format_string. This can be achieved by casting them. See the [GVariant varargs documentation][gvariant-varargs]. This function might be used as follows: |[<!-- language="C" --> GVariant * make_pointless_dictionary (void) { GVariantBuilder builder; int i; g_variant_builder_init (&builder, G_VARIANT_TYPE_ARRAY); g_variant_builder_add_parsed (&builder, "{'width', <%i>}", 600); g_variant_builder_add_parsed (&builder, "{'title', <%s>}", "foo"); g_variant_builder_add_parsed (&builder, "{'transparency', <0.5>}"); return g_variant_builder_end (&builder); } ]| a #GVariantBuilder a text format #GVariant arguments as per @format Adds @value to @builder. It is an error to call this function in any way that would create an inconsistent value to be constructed. Some examples of this are putting different types of items into an array, putting the wrong types or number of items in a tuple, putting more than one value into a variant, etc. If @value is a floating reference (see g_variant_ref_sink()), the @builder instance takes ownership of @value. a #GVariantBuilder a #GVariant Releases all memory associated with a #GVariantBuilder without freeing the #GVariantBuilder structure itself. It typically only makes sense to do this on a stack-allocated #GVariantBuilder if you want to abort building the value part-way through. This function need not be called if you call g_variant_builder_end() and it also doesn't need to be called on builders allocated with g_variant_builder_new (see g_variant_builder_unref() for that). This function leaves the #GVariantBuilder structure set to all-zeros. It is valid to call this function on either an initialised #GVariantBuilder or one that is set to all-zeros but it is not valid to call this function on uninitialised memory. a #GVariantBuilder Closes the subcontainer inside the given @builder that was opened by the most recent call to g_variant_builder_open(). It is an error to call this function in any way that would create an inconsistent value to be constructed (ie: too few values added to the subcontainer). a #GVariantBuilder Ends the builder process and returns the constructed value. It is not permissible to use @builder in any way after this call except for reference counting operations (in the case of a heap-allocated #GVariantBuilder) or by reinitialising it with g_variant_builder_init() (in the case of stack-allocated). It is an error to call this function in any way that would create an inconsistent value to be constructed (ie: insufficient number of items added to a container with a specific number of children required). It is also an error to call this function if the builder was created with an indefinite array or maybe type and no children have been added; in this case it is impossible to infer the type of the empty array. a new, floating, #GVariant a #GVariantBuilder Initialises a #GVariantBuilder structure. @type must be non-%NULL. It specifies the type of container to construct. It can be an indefinite type such as %G_VARIANT_TYPE_ARRAY or a definite type such as "as" or "(ii)". Maybe, array, tuple, dictionary entry and variant-typed values may be constructed. After the builder is initialised, values are added using g_variant_builder_add_value() or g_variant_builder_add(). After all the child values are added, g_variant_builder_end() frees the memory associated with the builder and returns the #GVariant that was created. This function completely ignores the previous contents of @builder. On one hand this means that it is valid to pass in completely uninitialised memory. On the other hand, this means that if you are initialising over top of an existing #GVariantBuilder you need to first call g_variant_builder_clear() in order to avoid leaking memory. You must not call g_variant_builder_ref() or g_variant_builder_unref() on a #GVariantBuilder that was initialised with this function. If you ever pass a reference to a #GVariantBuilder outside of the control of your own code then you should assume that the person receiving that reference may try to use reference counting; you should use g_variant_builder_new() instead of this function. a #GVariantBuilder a container type Opens a subcontainer inside the given @builder. When done adding items to the subcontainer, g_variant_builder_close() must be called. It is an error to call this function in any way that would cause an inconsistent value to be constructed (ie: adding too many values or a value of an incorrect type). a #GVariantBuilder a #GVariantType Increases the reference count on @builder. Don't call this on stack-allocated #GVariantBuilder instances or bad things will happen. a new reference to @builder a #GVariantBuilder allocated by g_variant_builder_new() Decreases the reference count on @builder. In the event that there are no more references, releases all memory associated with the #GVariantBuilder. Don't call this on stack-allocated #GVariantBuilder instances or bad things will happen. a #GVariantBuilder allocated by g_variant_builder_new() The range of possible top-level types of #GVariant instances. The #GVariant is a boolean. The #GVariant is a byte. The #GVariant is a signed 16 bit integer. The #GVariant is an unsigned 16 bit integer. The #GVariant is a signed 32 bit integer. The #GVariant is an unsigned 32 bit integer. The #GVariant is a signed 64 bit integer. The #GVariant is an unsigned 64 bit integer. The #GVariant is a file handle index. The #GVariant is a double precision floating point value. The #GVariant is a normal string. The #GVariant is a D-Bus object path string. The #GVariant is a D-Bus signature string. The #GVariant is a variant. The #GVariant is a maybe-typed value. The #GVariant is an array. The #GVariant is a tuple. The #GVariant is a dictionary entry. #GVariantDict is a mutable interface to #GVariant dictionaries. It can be used for doing a sequence of dictionary lookups in an efficient way on an existing #GVariant dictionary or it can be used to construct new dictionaries with a hashtable-like interface. It can also be used for taking existing dictionaries and modifying them in order to create new ones. #GVariantDict can only be used with %G_VARIANT_TYPE_VARDICT dictionaries. It is possible to use #GVariantDict allocated on the stack or on the heap. When using a stack-allocated #GVariantDict, you begin with a call to g_variant_dict_init() and free the resources with a call to g_variant_dict_clear(). Heap-allocated #GVariantDict follows normal refcounting rules: you allocate it with g_variant_dict_new() and use g_variant_dict_ref() and g_variant_dict_unref(). g_variant_dict_end() is used to convert the #GVariantDict back into a dictionary-type #GVariant. When used with stack-allocated instances, this also implicitly frees all associated memory, but for heap-allocated instances, you must still call g_variant_dict_unref() afterwards. You will typically want to use a heap-allocated #GVariantDict when you expose it as part of an API. For most other uses, the stack-allocated form will be more convenient. Consider the following two examples that do the same thing in each style: take an existing dictionary and look up the "count" uint32 key, adding 1 to it if it is found, or returning an error if the key is not found. Each returns the new dictionary as a floating #GVariant. ## Using a stack-allocated GVariantDict |[<!-- language="C" --> GVariant * add_to_count (GVariant *orig, GError **error) { GVariantDict dict; guint32 count; g_variant_dict_init (&dict, orig); if (!g_variant_dict_lookup (&dict, "count", "u", &count)) { g_set_error (...); g_variant_dict_clear (&dict); return NULL; } g_variant_dict_insert (&dict, "count", "u", count + 1); return g_variant_dict_end (&dict); } ]| ## Using heap-allocated GVariantDict |[<!-- language="C" --> GVariant * add_to_count (GVariant *orig, GError **error) { GVariantDict *dict; GVariant *result; guint32 count; dict = g_variant_dict_new (orig); if (g_variant_dict_lookup (dict, "count", "u", &count)) { g_variant_dict_insert (dict, "count", "u", count + 1); result = g_variant_dict_end (dict); } else { g_set_error (...); result = NULL; } g_variant_dict_unref (dict); return result; } ]| Allocates and initialises a new #GVariantDict. You should call g_variant_dict_unref() on the return value when it is no longer needed. The memory will not be automatically freed by any other call. In some cases it may be easier to place a #GVariantDict directly on the stack of the calling function and initialise it with g_variant_dict_init(). This is particularly useful when you are using #GVariantDict to construct a #GVariant. a #GVariantDict the #GVariant with which to initialise the dictionary Releases all memory associated with a #GVariantDict without freeing the #GVariantDict structure itself. It typically only makes sense to do this on a stack-allocated #GVariantDict if you want to abort building the value part-way through. This function need not be called if you call g_variant_dict_end() and it also doesn't need to be called on dicts allocated with g_variant_dict_new (see g_variant_dict_unref() for that). It is valid to call this function on either an initialised #GVariantDict or one that was previously cleared by an earlier call to g_variant_dict_clear() but it is not valid to call this function on uninitialised memory. a #GVariantDict Checks if @key exists in @dict. %TRUE if @key is in @dict a #GVariantDict the key to lookup in the dictionary Returns the current value of @dict as a #GVariant of type %G_VARIANT_TYPE_VARDICT, clearing it in the process. It is not permissible to use @dict in any way after this call except for reference counting operations (in the case of a heap-allocated #GVariantDict) or by reinitialising it with g_variant_dict_init() (in the case of stack-allocated). a new, floating, #GVariant a #GVariantDict Initialises a #GVariantDict structure. If @from_asv is given, it is used to initialise the dictionary. This function completely ignores the previous contents of @dict. On one hand this means that it is valid to pass in completely uninitialised memory. On the other hand, this means that if you are initialising over top of an existing #GVariantDict you need to first call g_variant_dict_clear() in order to avoid leaking memory. You must not call g_variant_dict_ref() or g_variant_dict_unref() on a #GVariantDict that was initialised with this function. If you ever pass a reference to a #GVariantDict outside of the control of your own code then you should assume that the person receiving that reference may try to use reference counting; you should use g_variant_dict_new() instead of this function. a #GVariantDict the initial value for @dict Inserts a value into a #GVariantDict. This call is a convenience wrapper that is exactly equivalent to calling g_variant_new() followed by g_variant_dict_insert_value(). a #GVariantDict the key to insert a value for a #GVariant varargs format string arguments, as per @format_string Inserts (or replaces) a key in a #GVariantDict. @value is consumed if it is floating. a #GVariantDict the key to insert a value for the value to insert Looks up a value in a #GVariantDict. This function is a wrapper around g_variant_dict_lookup_value() and g_variant_get(). In the case that %NULL would have been returned, this function returns %FALSE. Otherwise, it unpacks the returned value and returns %TRUE. @format_string determines the C types that are used for unpacking the values and also determines if the values are copied or borrowed, see the section on [GVariant format strings][gvariant-format-strings-pointers]. %TRUE if a value was unpacked a #GVariantDict the key to lookup in the dictionary a GVariant format string the arguments to unpack the value into Looks up a value in a #GVariantDict. If @key is not found in @dictionary, %NULL is returned. The @expected_type string specifies what type of value is expected. If the value associated with @key has a different type then %NULL is returned. If the key is found and the value has the correct type, it is returned. If @expected_type was specified then any non-%NULL return value will have this type. the value of the dictionary key, or %NULL a #GVariantDict the key to lookup in the dictionary a #GVariantType, or %NULL Increases the reference count on @dict. Don't call this on stack-allocated #GVariantDict instances or bad things will happen. a new reference to @dict a heap-allocated #GVariantDict Removes a key and its associated value from a #GVariantDict. %TRUE if the key was found and removed a #GVariantDict the key to remove Decreases the reference count on @dict. In the event that there are no more references, releases all memory associated with the #GVariantDict. Don't call this on stack-allocated #GVariantDict instances or bad things will happen. a heap-allocated #GVariantDict #GVariantIter is an opaque data structure and can only be accessed using the following functions. Creates a new heap-allocated #GVariantIter to iterate over the container that was being iterated over by @iter. Iteration begins on the new iterator from the current position of the old iterator but the two copies are independent past that point. Use g_variant_iter_free() to free the return value when you no longer need it. A reference is taken to the container that @iter is iterating over and will be releated only when g_variant_iter_free() is called. a new heap-allocated #GVariantIter a #GVariantIter Frees a heap-allocated #GVariantIter. Only call this function on iterators that were returned by g_variant_iter_new() or g_variant_iter_copy(). a heap-allocated #GVariantIter Initialises (without allocating) a #GVariantIter. @iter may be completely uninitialised prior to this call; its old value is ignored. The iterator remains valid for as long as @value exists, and need not be freed in any way. the number of items in @value a pointer to a #GVariantIter a container #GVariant Gets the next item in the container and unpacks it into the variable argument list according to @format_string, returning %TRUE. If no more items remain then %FALSE is returned. On the first call to this function, the pointers appearing on the variable argument list are assumed to point at uninitialised memory. On the second and later calls, it is assumed that the same pointers will be given and that they will point to the memory as set by the previous call to this function. This allows the previous values to be freed, as appropriate. This function is intended to be used with a while loop as demonstrated in the following example. This function can only be used when iterating over an array. It is only valid to call this function with a string constant for the format string and the same string constant must be used each time. Mixing calls to this function and g_variant_iter_next() or g_variant_iter_next_value() on the same iterator causes undefined behavior. If you break out of a such a while loop using g_variant_iter_loop() then you must free or unreference all the unpacked values as you would with g_variant_get(). Failure to do so will cause a memory leak. Here is an example for memory management with g_variant_iter_loop(): |[<!-- language="C" --> // Iterates a dictionary of type 'a{sv}' void iterate_dictionary (GVariant *dictionary) { GVariantIter iter; GVariant *value; gchar *key; g_variant_iter_init (&iter, dictionary); while (g_variant_iter_loop (&iter, "{sv}", &key, &value)) { g_print ("Item '%s' has type '%s'\n", key, g_variant_get_type_string (value)); // no need to free 'key' and 'value' here // unless breaking out of this loop } } ]| For most cases you should use g_variant_iter_next(). This function is really only useful when unpacking into #GVariant or #GVariantIter in order to allow you to skip the call to g_variant_unref() or g_variant_iter_free(). For example, if you are only looping over simple integer and string types, g_variant_iter_next() is definitely preferred. For string types, use the '&' prefix to avoid allocating any memory at all (and thereby avoiding the need to free anything as well). @format_string determines the C types that are used for unpacking the values and also determines if the values are copied or borrowed. See the section on [GVariant format strings][gvariant-format-strings-pointers]. %TRUE if a value was unpacked, or %FALSE if there was no value a #GVariantIter a GVariant format string the arguments to unpack the value into Queries the number of child items in the container that we are iterating over. This is the total number of items -- not the number of items remaining. This function might be useful for preallocation of arrays. the number of children in the container a #GVariantIter Gets the next item in the container and unpacks it into the variable argument list according to @format_string, returning %TRUE. If no more items remain then %FALSE is returned. All of the pointers given on the variable arguments list of this function are assumed to point at uninitialised memory. It is the responsibility of the caller to free all of the values returned by the unpacking process. Here is an example for memory management with g_variant_iter_next(): |[<!-- language="C" --> // Iterates a dictionary of type 'a{sv}' void iterate_dictionary (GVariant *dictionary) { GVariantIter iter; GVariant *value; gchar *key; g_variant_iter_init (&iter, dictionary); while (g_variant_iter_next (&iter, "{sv}", &key, &value)) { g_print ("Item '%s' has type '%s'\n", key, g_variant_get_type_string (value)); // must free data for ourselves g_variant_unref (value); g_free (key); } } ]| For a solution that is likely to be more convenient to C programmers when dealing with loops, see g_variant_iter_loop(). @format_string determines the C types that are used for unpacking the values and also determines if the values are copied or borrowed. See the section on [GVariant format strings][gvariant-format-strings-pointers]. %TRUE if a value was unpacked, or %FALSE if there as no value a #GVariantIter a GVariant format string the arguments to unpack the value into Gets the next item in the container. If no more items remain then %NULL is returned. Use g_variant_unref() to drop your reference on the return value when you no longer need it. Here is an example for iterating with g_variant_iter_next_value(): |[<!-- language="C" --> // recursively iterate a container void iterate_container_recursive (GVariant *container) { GVariantIter iter; GVariant *child; g_variant_iter_init (&iter, container); while ((child = g_variant_iter_next_value (&iter))) { g_print ("type '%s'\n", g_variant_get_type_string (child)); if (g_variant_is_container (child)) iterate_container_recursive (child); g_variant_unref (child); } } ]| a #GVariant, or %NULL a #GVariantIter Error codes returned by parsing text-format GVariants. generic error (unused) a non-basic #GVariantType was given where a basic type was expected cannot infer the #GVariantType an indefinite #GVariantType was given where a definite type was expected extra data after parsing finished invalid character in number or unicode escape not a valid #GVariant format string not a valid object path not a valid type signature not a valid #GVariant type string could not find a common type for array entries the numerical value is out of range of the given type the numerical value is out of range for any type cannot parse as variant of the specified type an unexpected token was encountered an unknown keyword was encountered unterminated string constant no value given This section introduces the GVariant type system. It is based, in large part, on the D-Bus type system, with two major changes and some minor lifting of restrictions. The [D-Bus specification](http://dbus.freedesktop.org/doc/dbus-specification.html), therefore, provides a significant amount of information that is useful when working with GVariant. The first major change with respect to the D-Bus type system is the introduction of maybe (or "nullable") types. Any type in GVariant can be converted to a maybe type, in which case, "nothing" (or "null") becomes a valid value. Maybe types have been added by introducing the character "m" to type strings. The second major change is that the GVariant type system supports the concept of "indefinite types" -- types that are less specific than the normal types found in D-Bus. For example, it is possible to speak of "an array of any type" in GVariant, where the D-Bus type system would require you to speak of "an array of integers" or "an array of strings". Indefinite types have been added by introducing the characters "*", "?" and "r" to type strings. Finally, all arbitrary restrictions relating to the complexity of types are lifted along with the restriction that dictionary entries may only appear nested inside of arrays. Just as in D-Bus, GVariant types are described with strings ("type strings"). Subject to the differences mentioned above, these strings are of the same form as those found in DBus. Note, however: D-Bus always works in terms of messages and therefore individual type strings appear nowhere in its interface. Instead, "signatures" are a concatenation of the strings of the type of each argument in a message. GVariant deals with single values directly so GVariant type strings always describe the type of exactly one value. This means that a D-Bus signature string is generally not a valid GVariant type string -- except in the case that it is the signature of a message containing exactly one argument. An indefinite type is similar in spirit to what may be called an abstract type in other type systems. No value can exist that has an indefinite type as its type, but values can exist that have types that are subtypes of indefinite types. That is to say, g_variant_get_type() will never return an indefinite type, but calling g_variant_is_of_type() with an indefinite type may return %TRUE. For example, you cannot have a value that represents "an array of no particular type", but you can have an "array of integers" which certainly matches the type of "an array of no particular type", since "array of integers" is a subtype of "array of no particular type". This is similar to how instances of abstract classes may not directly exist in other type systems, but instances of their non-abstract subtypes may. For example, in GTK, no object that has the type of #GtkBin can exist (since #GtkBin is an abstract class), but a #GtkWindow can certainly be instantiated, and you would say that the #GtkWindow is a #GtkBin (since #GtkWindow is a subclass of #GtkBin). ## GVariant Type Strings A GVariant type string can be any of the following: - any basic type string (listed below) - "v", "r" or "*" - one of the characters 'a' or 'm', followed by another type string - the character '(', followed by a concatenation of zero or more other type strings, followed by the character ')' - the character '{', followed by a basic type string (see below), followed by another type string, followed by the character '}' A basic type string describes a basic type (as per g_variant_type_is_basic()) and is always a single character in length. The valid basic type strings are "b", "y", "n", "q", "i", "u", "x", "t", "h", "d", "s", "o", "g" and "?". The above definition is recursive to arbitrary depth. "aaaaai" and "(ui(nq((y)))s)" are both valid type strings, as is "a(aa(ui)(qna{ya(yd)}))". The meaning of each of the characters is as follows: - `b`: the type string of %G_VARIANT_TYPE_BOOLEAN; a boolean value. - `y`: the type string of %G_VARIANT_TYPE_BYTE; a byte. - `n`: the type string of %G_VARIANT_TYPE_INT16; a signed 16 bit integer. - `q`: the type string of %G_VARIANT_TYPE_UINT16; an unsigned 16 bit integer. - `i`: the type string of %G_VARIANT_TYPE_INT32; a signed 32 bit integer. - `u`: the type string of %G_VARIANT_TYPE_UINT32; an unsigned 32 bit integer. - `x`: the type string of %G_VARIANT_TYPE_INT64; a signed 64 bit integer. - `t`: the type string of %G_VARIANT_TYPE_UINT64; an unsigned 64 bit integer. - `h`: the type string of %G_VARIANT_TYPE_HANDLE; a signed 32 bit value that, by convention, is used as an index into an array of file descriptors that are sent alongside a D-Bus message. - `d`: the type string of %G_VARIANT_TYPE_DOUBLE; a double precision floating point value. - `s`: the type string of %G_VARIANT_TYPE_STRING; a string. - `o`: the type string of %G_VARIANT_TYPE_OBJECT_PATH; a string in the form of a D-Bus object path. - `g`: the type string of %G_VARIANT_TYPE_STRING; a string in the form of a D-Bus type signature. - `?`: the type string of %G_VARIANT_TYPE_BASIC; an indefinite type that is a supertype of any of the basic types. - `v`: the type string of %G_VARIANT_TYPE_VARIANT; a container type that contain any other type of value. - `a`: used as a prefix on another type string to mean an array of that type; the type string "ai", for example, is the type of an array of signed 32-bit integers. - `m`: used as a prefix on another type string to mean a "maybe", or "nullable", version of that type; the type string "ms", for example, is the type of a value that maybe contains a string, or maybe contains nothing. - `()`: used to enclose zero or more other concatenated type strings to create a tuple type; the type string "(is)", for example, is the type of a pair of an integer and a string. - `r`: the type string of %G_VARIANT_TYPE_TUPLE; an indefinite type that is a supertype of any tuple type, regardless of the number of items. - `{}`: used to enclose a basic type string concatenated with another type string to create a dictionary entry type, which usually appears inside of an array to form a dictionary; the type string "a{sd}", for example, is the type of a dictionary that maps strings to double precision floating point values. The first type (the basic type) is the key type and the second type is the value type. The reason that the first type is restricted to being a basic type is so that it can easily be hashed. - `*`: the type string of %G_VARIANT_TYPE_ANY; the indefinite type that is a supertype of all types. Note that, as with all type strings, this character represents exactly one type. It cannot be used inside of tuples to mean "any number of items". Any type string of a container that contains an indefinite type is, itself, an indefinite type. For example, the type string "a*" (corresponding to %G_VARIANT_TYPE_ARRAY) is an indefinite type that is a supertype of every array type. "(*s)" is a supertype of all tuples that contain exactly two items where the second item is a string. "a{?*}" is an indefinite type that is a supertype of all arrays containing dictionary entries where the key is any basic type and the value is any type at all. This is, by definition, a dictionary, so this type string corresponds to %G_VARIANT_TYPE_DICTIONARY. Note that, due to the restriction that the key of a dictionary entry must be a basic type, "{**}" is not a valid type string. Creates a new #GVariantType corresponding to the type string given by @type_string. It is appropriate to call g_variant_type_free() on the return value. It is a programmer error to call this function with an invalid type string. Use g_variant_type_string_is_valid() if you are unsure. a new #GVariantType a valid GVariant type string Constructs the type corresponding to an array of elements of the type @type. It is appropriate to call g_variant_type_free() on the return value. a new array #GVariantType Since 2.24 a #GVariantType Constructs the type corresponding to a dictionary entry with a key of type @key and a value of type @value. It is appropriate to call g_variant_type_free() on the return value. a new dictionary entry #GVariantType Since 2.24 a basic #GVariantType a #GVariantType Constructs the type corresponding to a maybe instance containing type @type or Nothing. It is appropriate to call g_variant_type_free() on the return value. a new maybe #GVariantType Since 2.24 a #GVariantType Constructs a new tuple type, from @items. @length is the number of items in @items, or -1 to indicate that @items is %NULL-terminated. It is appropriate to call g_variant_type_free() on the return value. a new tuple #GVariantType Since 2.24 an array of #GVariantTypes, one for each item the length of @items, or -1 Makes a copy of a #GVariantType. It is appropriate to call g_variant_type_free() on the return value. @type may not be %NULL. a new #GVariantType Since 2.24 a #GVariantType Returns a newly-allocated copy of the type string corresponding to @type. The returned string is nul-terminated. It is appropriate to call g_free() on the return value. the corresponding type string Since 2.24 a #GVariantType Determines the element type of an array or maybe type. This function may only be used with array or maybe types. the element type of @type Since 2.24 an array or maybe #GVariantType Compares @type1 and @type2 for equality. Only returns %TRUE if the types are exactly equal. Even if one type is an indefinite type and the other is a subtype of it, %FALSE will be returned if they are not exactly equal. If you want to check for subtypes, use g_variant_type_is_subtype_of(). The argument types of @type1 and @type2 are only #gconstpointer to allow use with #GHashTable without function pointer casting. For both arguments, a valid #GVariantType must be provided. %TRUE if @type1 and @type2 are exactly equal Since 2.24 a #GVariantType a #GVariantType Determines the first item type of a tuple or dictionary entry type. This function may only be used with tuple or dictionary entry types, but must not be used with the generic tuple type %G_VARIANT_TYPE_TUPLE. In the case of a dictionary entry type, this returns the type of the key. %NULL is returned in case of @type being %G_VARIANT_TYPE_UNIT. This call, together with g_variant_type_next() provides an iterator interface over tuple and dictionary entry types. the first item type of @type, or %NULL Since 2.24 a tuple or dictionary entry #GVariantType Frees a #GVariantType that was allocated with g_variant_type_copy(), g_variant_type_new() or one of the container type constructor functions. In the case that @type is %NULL, this function does nothing. Since 2.24 a #GVariantType, or %NULL Returns the length of the type string corresponding to the given @type. This function must be used to determine the valid extent of the memory region returned by g_variant_type_peek_string(). the length of the corresponding type string Since 2.24 a #GVariantType Hashes @type. The argument type of @type is only #gconstpointer to allow use with #GHashTable without function pointer casting. A valid #GVariantType must be provided. the hash value Since 2.24 a #GVariantType Determines if the given @type is an array type. This is true if the type string for @type starts with an 'a'. This function returns %TRUE for any indefinite type for which every definite subtype is an array type -- %G_VARIANT_TYPE_ARRAY, for example. %TRUE if @type is an array type Since 2.24 a #GVariantType Determines if the given @type is a basic type. Basic types are booleans, bytes, integers, doubles, strings, object paths and signatures. Only a basic type may be used as the key of a dictionary entry. This function returns %FALSE for all indefinite types except %G_VARIANT_TYPE_BASIC. %TRUE if @type is a basic type Since 2.24 a #GVariantType Determines if the given @type is a container type. Container types are any array, maybe, tuple, or dictionary entry types plus the variant type. This function returns %TRUE for any indefinite type for which every definite subtype is a container -- %G_VARIANT_TYPE_ARRAY, for example. %TRUE if @type is a container type Since 2.24 a #GVariantType Determines if the given @type is definite (ie: not indefinite). A type is definite if its type string does not contain any indefinite type characters ('*', '?', or 'r'). A #GVariant instance may not have an indefinite type, so calling this function on the result of g_variant_get_type() will always result in %TRUE being returned. Calling this function on an indefinite type like %G_VARIANT_TYPE_ARRAY, however, will result in %FALSE being returned. %TRUE if @type is definite Since 2.24 a #GVariantType Determines if the given @type is a dictionary entry type. This is true if the type string for @type starts with a '{'. This function returns %TRUE for any indefinite type for which every definite subtype is a dictionary entry type -- %G_VARIANT_TYPE_DICT_ENTRY, for example. %TRUE if @type is a dictionary entry type Since 2.24 a #GVariantType Determines if the given @type is a maybe type. This is true if the type string for @type starts with an 'm'. This function returns %TRUE for any indefinite type for which every definite subtype is a maybe type -- %G_VARIANT_TYPE_MAYBE, for example. %TRUE if @type is a maybe type Since 2.24 a #GVariantType Checks if @type is a subtype of @supertype. This function returns %TRUE if @type is a subtype of @supertype. All types are considered to be subtypes of themselves. Aside from that, only indefinite types can have subtypes. %TRUE if @type is a subtype of @supertype Since 2.24 a #GVariantType a #GVariantType Determines if the given @type is a tuple type. This is true if the type string for @type starts with a '(' or if @type is %G_VARIANT_TYPE_TUPLE. This function returns %TRUE for any indefinite type for which every definite subtype is a tuple type -- %G_VARIANT_TYPE_TUPLE, for example. %TRUE if @type is a tuple type Since 2.24 a #GVariantType Determines if the given @type is the variant type. %TRUE if @type is the variant type Since 2.24 a #GVariantType Determines the key type of a dictionary entry type. This function may only be used with a dictionary entry type. Other than the additional restriction, this call is equivalent to g_variant_type_first(). the key type of the dictionary entry Since 2.24 a dictionary entry #GVariantType Determines the number of items contained in a tuple or dictionary entry type. This function may only be used with tuple or dictionary entry types, but must not be used with the generic tuple type %G_VARIANT_TYPE_TUPLE. In the case of a dictionary entry type, this function will always return 2. the number of items in @type Since 2.24 a tuple or dictionary entry #GVariantType Determines the next item type of a tuple or dictionary entry type. @type must be the result of a previous call to g_variant_type_first() or g_variant_type_next(). If called on the key type of a dictionary entry then this call returns the value type. If called on the value type of a dictionary entry then this call returns %NULL. For tuples, %NULL is returned when @type is the last item in a tuple. the next #GVariantType after @type, or %NULL Since 2.24 a #GVariantType from a previous call Returns the type string corresponding to the given @type. The result is not nul-terminated; in order to determine its length you must call g_variant_type_get_string_length(). To get a nul-terminated string, see g_variant_type_dup_string(). the corresponding type string (not nul-terminated) Since 2.24 a #GVariantType Determines the value type of a dictionary entry type. This function may only be used with a dictionary entry type. the value type of the dictionary entry Since 2.24 a dictionary entry #GVariantType Checks if @type_string is a valid GVariant type string. This call is equivalent to calling g_variant_type_string_scan() and confirming that the following character is a nul terminator. %TRUE if @type_string is exactly one valid type string Since 2.24 a pointer to any string Scan for a single complete and valid GVariant type string in @string. The memory pointed to by @limit (or bytes beyond it) is never accessed. If a valid type string is found, @endptr is updated to point to the first character past the end of the string that was found and %TRUE is returned. If there is no valid type string starting at @string, or if the type string does not end before @limit then %FALSE is returned. For the simple case of checking if a string is a valid type string, see g_variant_type_string_is_valid(). %TRUE if a valid type string was found a pointer to any string the end of @string, or %NULL location to store the end pointer, or %NULL Declares a type of function which takes no arguments and has no return value. It is used to specify the type function passed to g_atexit(). A wrapper for the POSIX access() function. This function is used to test a pathname for one or several of read, write or execute permissions, or just existence. On Windows, the file protection mechanism is not at all POSIX-like, and the underlying function in the C library only checks the FAT-style READONLY attribute, and does not look at the ACL of a file at all. This function is this in practise almost useless on Windows. Software that needs to handle file permissions on Windows more exactly should use the Win32 API. See your C library manual for more details about access(). zero if the pathname refers to an existing file system object that has all the tested permissions, or -1 otherwise or on error. a pathname in the GLib file name encoding (UTF-8 on Windows) as in access() Determines the numeric value of a character as a decimal digit. Differs from g_unichar_digit_value() because it takes a char, so there's no worry about sign extension if characters are signed. If @c is a decimal digit (according to g_ascii_isdigit()), its numeric value. Otherwise, -1. an ASCII character Converts a #gdouble to a string, using the '.' as decimal point. This function generates enough precision that converting the string back using g_ascii_strtod() gives the same machine-number (on machines with IEEE compatible 64bit doubles). It is guaranteed that the size of the resulting string will never be larger than @G_ASCII_DTOSTR_BUF_SIZE bytes. The pointer to the buffer with the converted string. A buffer to place the resulting string in The length of the buffer. The #gdouble to convert Converts a #gdouble to a string, using the '.' as decimal point. To format the number you pass in a printf()-style format string. Allowed conversion specifiers are 'e', 'E', 'f', 'F', 'g' and 'G'. If you just want to want to serialize the value into a string, use g_ascii_dtostr(). The pointer to the buffer with the converted string. A buffer to place the resulting string in The length of the buffer. The printf()-style format to use for the code to use for converting. The #gdouble to convert Compare two strings, ignoring the case of ASCII characters. Unlike the BSD strcasecmp() function, this only recognizes standard ASCII letters and ignores the locale, treating all non-ASCII bytes as if they are not letters. This function should be used only on strings that are known to be in encodings where the bytes corresponding to ASCII letters always represent themselves. This includes UTF-8 and the ISO-8859-* charsets, but not for instance double-byte encodings like the Windows Codepage 932, where the trailing bytes of double-byte characters include all ASCII letters. If you compare two CP932 strings using this function, you will get false matches. Both @s1 and @s2 must be non-%NULL. 0 if the strings match, a negative value if @s1 < @s2, or a positive value if @s1 > @s2. string to compare with @s2 string to compare with @s1 Converts all upper case ASCII letters to lower case ASCII letters. a newly-allocated string, with all the upper case characters in @str converted to lower case, with semantics that exactly match g_ascii_tolower(). (Note that this is unlike the old g_strdown(), which modified the string in place.) a string length of @str in bytes, or -1 if @str is nul-terminated Compare @s1 and @s2, ignoring the case of ASCII characters and any characters after the first @n in each string. Unlike the BSD strcasecmp() function, this only recognizes standard ASCII letters and ignores the locale, treating all non-ASCII characters as if they are not letters. The same warning as in g_ascii_strcasecmp() applies: Use this function only on strings known to be in encodings where bytes corresponding to ASCII letters always represent themselves. 0 if the strings match, a negative value if @s1 < @s2, or a positive value if @s1 > @s2. string to compare with @s2 string to compare with @s1 number of characters to compare Converts a string to a #gdouble value. This function behaves like the standard strtod() function does in the C locale. It does this without actually changing the current locale, since that would not be thread-safe. A limitation of the implementation is that this function will still accept localized versions of infinities and NANs. This function is typically used when reading configuration files or other non-user input that should be locale independent. To handle input from the user you should normally use the locale-sensitive system strtod() function. To convert from a #gdouble to a string in a locale-insensitive way, use g_ascii_dtostr(). If the correct value would cause overflow, plus or minus %HUGE_VAL is returned (according to the sign of the value), and %ERANGE is stored in %errno. If the correct value would cause underflow, zero is returned and %ERANGE is stored in %errno. This function resets %errno before calling strtod() so that you can reliably detect overflow and underflow. the #gdouble value. the string to convert to a numeric value. if non-%NULL, it returns the character after the last character used in the conversion. Converts a string to a #gint64 value. This function behaves like the standard strtoll() function does in the C locale. It does this without actually changing the current locale, since that would not be thread-safe. This function is typically used when reading configuration files or other non-user input that should be locale independent. To handle input from the user you should normally use the locale-sensitive system strtoll() function. If the correct value would cause overflow, %G_MAXINT64 or %G_MININT64 is returned, and `ERANGE` is stored in `errno`. If the base is outside the valid range, zero is returned, and `EINVAL` is stored in `errno`. If the string conversion fails, zero is returned, and @endptr returns @nptr (if @endptr is non-%NULL). the #gint64 value or zero on error. the string to convert to a numeric value. if non-%NULL, it returns the character after the last character used in the conversion. to be used for the conversion, 2..36 or 0 Converts a string to a #guint64 value. This function behaves like the standard strtoull() function does in the C locale. It does this without actually changing the current locale, since that would not be thread-safe. This function is typically used when reading configuration files or other non-user input that should be locale independent. To handle input from the user you should normally use the locale-sensitive system strtoull() function. If the correct value would cause overflow, %G_MAXUINT64 is returned, and `ERANGE` is stored in `errno`. If the base is outside the valid range, zero is returned, and `EINVAL` is stored in `errno`. If the string conversion fails, zero is returned, and @endptr returns @nptr (if @endptr is non-%NULL). the #guint64 value or zero on error. the string to convert to a numeric value. if non-%NULL, it returns the character after the last character used in the conversion. to be used for the conversion, 2..36 or 0 Converts all lower case ASCII letters to upper case ASCII letters. a newly allocated string, with all the lower case characters in @str converted to upper case, with semantics that exactly match g_ascii_toupper(). (Note that this is unlike the old g_strup(), which modified the string in place.) a string length of @str in bytes, or -1 if @str is nul-terminated Convert a character to ASCII lower case. Unlike the standard C library tolower() function, this only recognizes standard ASCII letters and ignores the locale, returning all non-ASCII characters unchanged, even if they are lower case letters in a particular character set. Also unlike the standard library function, this takes and returns a char, not an int, so don't call it on %EOF but no need to worry about casting to #guchar before passing a possibly non-ASCII character in. the result of converting @c to lower case. If @c is not an ASCII upper case letter, @c is returned unchanged. any character Convert a character to ASCII upper case. Unlike the standard C library toupper() function, this only recognizes standard ASCII letters and ignores the locale, returning all non-ASCII characters unchanged, even if they are upper case letters in a particular character set. Also unlike the standard library function, this takes and returns a char, not an int, so don't call it on %EOF but no need to worry about casting to #guchar before passing a possibly non-ASCII character in. the result of converting @c to upper case. If @c is not an ASCII lower case letter, @c is returned unchanged. any character Determines the numeric value of a character as a hexidecimal digit. Differs from g_unichar_xdigit_value() because it takes a char, so there's no worry about sign extension if characters are signed. If @c is a hex digit (according to g_ascii_isxdigit()), its numeric value. Otherwise, -1. an ASCII character. Specifies a function to be called at normal program termination. Since GLib 2.8.2, on Windows g_atexit() actually is a preprocessor macro that maps to a call to the atexit() function in the C library. This means that in case the code that calls g_atexit(), i.e. atexit(), is in a DLL, the function will be called when the DLL is detached from the program. This typically makes more sense than that the function is called when the GLib DLL is detached, which happened earlier when g_atexit() was a function in the GLib DLL. The behaviour of atexit() in the context of dynamically loaded modules is not formally specified and varies wildly. On POSIX systems, calling g_atexit() (or atexit()) in a dynamically loaded module which is unloaded before the program terminates might well cause a crash at program exit. Some POSIX systems implement atexit() like Windows, and have each dynamically loaded module maintain an own atexit chain that is called when the module is unloaded. On other POSIX systems, before a dynamically loaded module is unloaded, the registered atexit functions (if any) residing in that module are called, regardless where the code that registered them resided. This is presumably the most robust approach. As can be seen from the above, for portability it's best to avoid calling g_atexit() (or atexit()) except in the main executable of a program. It is best to avoid g_atexit(). the function to call on normal program termination. Atomically adds @val to the value of @atomic. Think of this operation as an atomic version of `{ tmp = *atomic; *atomic += val; return tmp; }`. This call acts as a full compiler and hardware memory barrier. Before version 2.30, this function did not return a value (but g_atomic_int_exchange_and_add() did, and had the same meaning). the value of @atomic before the add, signed a pointer to a #gint or #guint the value to add Performs an atomic bitwise 'and' of the value of @atomic and @val, storing the result back in @atomic. This call acts as a full compiler and hardware memory barrier. Think of this operation as an atomic version of `{ tmp = *atomic; *atomic &= val; return tmp; }`. the value of @atomic before the operation, unsigned a pointer to a #gint or #guint the value to 'and' Compares @atomic to @oldval and, if equal, sets it to @newval. If @atomic was not equal to @oldval then no change occurs. This compare and exchange is done atomically. Think of this operation as an atomic version of `{ if (*atomic == oldval) { *atomic = newval; return TRUE; } else return FALSE; }`. This call acts as a full compiler and hardware memory barrier. %TRUE if the exchange took place a pointer to a #gint or #guint the value to compare with the value to conditionally replace with Decrements the value of @atomic by 1. Think of this operation as an atomic version of `{ *atomic -= 1; return (*atomic == 0); }`. This call acts as a full compiler and hardware memory barrier. %TRUE if the resultant value is zero a pointer to a #gint or #guint This function existed before g_atomic_int_add() returned the prior value of the integer (which it now does). It is retained only for compatibility reasons. Don't use this function in new code. Use g_atomic_int_add() instead. the value of @atomic before the add, signed a pointer to a #gint the value to add Gets the current value of @atomic. This call acts as a full compiler and hardware memory barrier (before the get). the value of the integer a pointer to a #gint or #guint Increments the value of @atomic by 1. Think of this operation as an atomic version of `{ *atomic += 1; }`. This call acts as a full compiler and hardware memory barrier. a pointer to a #gint or #guint Performs an atomic bitwise 'or' of the value of @atomic and @val, storing the result back in @atomic. Think of this operation as an atomic version of `{ tmp = *atomic; *atomic |= val; return tmp; }`. This call acts as a full compiler and hardware memory barrier. the value of @atomic before the operation, unsigned a pointer to a #gint or #guint the value to 'or' Sets the value of @atomic to @newval. This call acts as a full compiler and hardware memory barrier (after the set). a pointer to a #gint or #guint a new value to store Performs an atomic bitwise 'xor' of the value of @atomic and @val, storing the result back in @atomic. Think of this operation as an atomic version of `{ tmp = *atomic; *atomic ^= val; return tmp; }`. This call acts as a full compiler and hardware memory barrier. the value of @atomic before the operation, unsigned a pointer to a #gint or #guint the value to 'xor' Atomically adds @val to the value of @atomic. Think of this operation as an atomic version of `{ tmp = *atomic; *atomic += val; return tmp; }`. This call acts as a full compiler and hardware memory barrier. the value of @atomic before the add, signed a pointer to a #gpointer-sized value the value to add Performs an atomic bitwise 'and' of the value of @atomic and @val, storing the result back in @atomic. Think of this operation as an atomic version of `{ tmp = *atomic; *atomic &= val; return tmp; }`. This call acts as a full compiler and hardware memory barrier. the value of @atomic before the operation, unsigned a pointer to a #gpointer-sized value the value to 'and' Compares @atomic to @oldval and, if equal, sets it to @newval. If @atomic was not equal to @oldval then no change occurs. This compare and exchange is done atomically. Think of this operation as an atomic version of `{ if (*atomic == oldval) { *atomic = newval; return TRUE; } else return FALSE; }`. This call acts as a full compiler and hardware memory barrier. %TRUE if the exchange took place a pointer to a #gpointer-sized value the value to compare with the value to conditionally replace with Gets the current value of @atomic. This call acts as a full compiler and hardware memory barrier (before the get). the value of the pointer a pointer to a #gpointer-sized value Performs an atomic bitwise 'or' of the value of @atomic and @val, storing the result back in @atomic. Think of this operation as an atomic version of `{ tmp = *atomic; *atomic |= val; return tmp; }`. This call acts as a full compiler and hardware memory barrier. the value of @atomic before the operation, unsigned a pointer to a #gpointer-sized value the value to 'or' Sets the value of @atomic to @newval. This call acts as a full compiler and hardware memory barrier (after the set). a pointer to a #gpointer-sized value a new value to store Performs an atomic bitwise 'xor' of the value of @atomic and @val, storing the result back in @atomic. Think of this operation as an atomic version of `{ tmp = *atomic; *atomic ^= val; return tmp; }`. This call acts as a full compiler and hardware memory barrier. the value of @atomic before the operation, unsigned a pointer to a #gpointer-sized value the value to 'xor' Decode a sequence of Base-64 encoded text into binary data. Note that the returned binary data is not necessarily zero-terminated, so it should not be used as a character string. newly allocated buffer containing the binary data that @text represents. The returned buffer must be freed with g_free(). zero-terminated string with base64 text to decode The length of the decoded data is written here Decode a sequence of Base-64 encoded text into binary data by overwriting the input data. The binary data that @text responds. This pointer is the same as the input @text. zero-terminated string with base64 text to decode The length of the decoded data is written here Incrementally decode a sequence of binary data from its Base-64 stringified representation. By calling this function multiple times you can convert data in chunks to avoid having to have the full encoded data in memory. The output buffer must be large enough to fit all the data that will be written to it. Since base64 encodes 3 bytes in 4 chars you need at least: (@len / 4) * 3 + 3 bytes (+ 3 may be needed in case of non-zero state). The number of bytes of output that was written binary input data max length of @in data to decode output buffer Saved state between steps, initialize to 0 Saved state between steps, initialize to 0 Encode a sequence of binary data into its Base-64 stringified representation. a newly allocated, zero-terminated Base-64 encoded string representing @data. The returned string must be freed with g_free(). the binary data to encode the length of @data Flush the status from a sequence of calls to g_base64_encode_step(). The output buffer must be large enough to fit all the data that will be written to it. It will need up to 4 bytes, or up to 5 bytes if line-breaking is enabled. The number of bytes of output that was written whether to break long lines pointer to destination buffer Saved state from g_base64_encode_step() Saved state from g_base64_encode_step() Incrementally encode a sequence of binary data into its Base-64 stringified representation. By calling this function multiple times you can convert data in chunks to avoid having to have the full encoded data in memory. When all of the data has been converted you must call g_base64_encode_close() to flush the saved state. The output buffer must be large enough to fit all the data that will be written to it. Due to the way base64 encodes you will need at least: (@len / 3 + 1) * 4 + 4 bytes (+ 4 may be needed in case of non-zero state). If you enable line-breaking you will need at least: ((@len / 3 + 1) * 4 + 4) / 72 + 1 bytes of extra space. @break_lines is typically used when putting base64-encoded data in emails. It breaks the lines at 72 columns instead of putting all of the text on the same line. This avoids problems with long lines in the email system. Note however that it breaks the lines with `LF` characters, not `CR LF` sequences, so the result cannot be passed directly to SMTP or certain other protocols. The number of bytes of output that was written the binary data to encode the length of @in whether to break long lines pointer to destination buffer Saved state between steps, initialize to 0 Saved state between steps, initialize to 0 Gets the name of the file without any leading directory components. It returns a pointer into the given file name string. Use g_path_get_basename() instead, but notice that g_path_get_basename() allocates new memory for the returned string, unlike this function which returns a pointer into the argument. the name of the file without any leading directory components the name of the file Sets the indicated @lock_bit in @address. If the bit is already set, this call will block until g_bit_unlock() unsets the corresponding bit. Attempting to lock on two different bits within the same integer is not supported and will very probably cause deadlocks. The value of the bit that is set is (1u << @bit). If @bit is not between 0 and 31 then the result is undefined. This function accesses @address atomically. All other accesses to @address must be atomic in order for this function to work reliably. a pointer to an integer a bit value between 0 and 31 Find the position of the first bit set in @mask, searching from (but not including) @nth_bit upwards. Bits are numbered from 0 (least significant) to sizeof(#gulong) * 8 - 1 (31 or 63, usually). To start searching from the 0th bit, set @nth_bit to -1. the index of the first bit set which is higher than @nth_bit a #gulong containing flags the index of the bit to start the search from Find the position of the first bit set in @mask, searching from (but not including) @nth_bit downwards. Bits are numbered from 0 (least significant) to sizeof(#gulong) * 8 - 1 (31 or 63, usually). To start searching from the last bit, set @nth_bit to -1 or GLIB_SIZEOF_LONG * 8. the index of the first bit set which is lower than @nth_bit a #gulong containing flags the index of the bit to start the search from Gets the number of bits used to hold @number, e.g. if @number is 4, 3 bits are needed. the number of bits used to hold @number a #guint Sets the indicated @lock_bit in @address, returning %TRUE if successful. If the bit is already set, returns %FALSE immediately. Attempting to lock on two different bits within the same integer is not supported. The value of the bit that is set is (1u << @bit). If @bit is not between 0 and 31 then the result is undefined. This function accesses @address atomically. All other accesses to @address must be atomic in order for this function to work reliably. %TRUE if the lock was acquired a pointer to an integer a bit value between 0 and 31 Clears the indicated @lock_bit in @address. If another thread is currently blocked in g_bit_lock() on this same bit then it will be woken up. This function accesses @address atomically. All other accesses to @address must be atomic in order for this function to work reliably. a pointer to an integer a bit value between 0 and 31 Creates a filename from a series of elements using the correct separator for filenames. On Unix, this function behaves identically to `g_build_path (G_DIR_SEPARATOR_S, first_element, ....)`. On Windows, it takes into account that either the backslash (`\` or slash (`/`) can be used as separator in filenames, but otherwise behaves as on UNIX. When file pathname separators need to be inserted, the one that last previously occurred in the parameters (reading from left to right) is used. No attempt is made to force the resulting filename to be an absolute path. If the first element is a relative path, the result will be a relative path. a newly-allocated string that must be freed with g_free(). the first element in the path remaining elements in path, terminated by %NULL Behaves exactly like g_build_filename(), but takes the path elements as a string array, instead of varargs. This function is mainly meant for language bindings. a newly-allocated string that must be freed with g_free(). %NULL-terminated array of strings containing the path elements. Creates a path from a series of elements using @separator as the separator between elements. At the boundary between two elements, any trailing occurrences of separator in the first element, or leading occurrences of separator in the second element are removed and exactly one copy of the separator is inserted. Empty elements are ignored. The number of leading copies of the separator on the result is the same as the number of leading copies of the separator on the first non-empty element. The number of trailing copies of the separator on the result is the same as the number of trailing copies of the separator on the last non-empty element. (Determination of the number of trailing copies is done without stripping leading copies, so if the separator is `ABA`, then `ABABA` has 1 trailing copy.) However, if there is only a single non-empty element, and there are no characters in that element not part of the leading or trailing separators, then the result is exactly the original value of that element. Other than for determination of the number of leading and trailing copies of the separator, elements consisting only of copies of the separator are ignored. a newly-allocated string that must be freed with g_free(). a string used to separator the elements of the path. the first element in the path remaining elements in path, terminated by %NULL Behaves exactly like g_build_path(), but takes the path elements as a string array, instead of varargs. This function is mainly meant for language bindings. a newly-allocated string that must be freed with g_free(). a string used to separator the elements of the path. %NULL-terminated array of strings containing the path elements. Frees the memory allocated by the #GByteArray. If @free_segment is %TRUE it frees the actual byte data. If the reference count of @array is greater than one, the #GByteArray wrapper is preserved but the size of @array will be set to zero. the element data if @free_segment is %FALSE, otherwise %NULL. The element data should be freed using g_free(). a #GByteArray if %TRUE the actual byte data is freed as well Transfers the data from the #GByteArray into a new immutable #GBytes. The #GByteArray is freed unless the reference count of @array is greater than one, the #GByteArray wrapper is preserved but the size of @array will be set to zero. This is identical to using g_bytes_new_take() and g_byte_array_free() together. a new immutable #GBytes representing same byte data that was in the array a #GByteArray Creates a new #GByteArray with a reference count of 1. the new #GByteArray Create byte array containing the data. The data will be owned by the array and will be freed with g_free(), i.e. it could be allocated using g_strdup(). a new #GByteArray byte data for the array length of @data Atomically decrements the reference count of @array by one. If the reference count drops to 0, all memory allocated by the array is released. This function is thread-safe and may be called from any thread. A #GByteArray A wrapper for the POSIX chdir() function. The function changes the current directory of the process to @path. See your C library manual for more details about chdir(). 0 on success, -1 if an error occurred. a pathname in the GLib file name encoding (UTF-8 on Windows) Checks that the GLib library in use is compatible with the given version. Generally you would pass in the constants #GLIB_MAJOR_VERSION, #GLIB_MINOR_VERSION, #GLIB_MICRO_VERSION as the three arguments to this function; that produces a check that the library in use is compatible with the version of GLib the application or module was compiled against. Compatibility is defined by two things: first the version of the running library is newer than the version @required_major.required_minor.@required_micro. Second the running library must be binary compatible with the version @required_major.required_minor.@required_micro (same major version.) %NULL if the GLib library is compatible with the given version, or a string describing the version mismatch. The returned string is owned by GLib and must not be modified or freed. the required major version the required minor version the required micro version Gets the length in bytes of digests of type @checksum_type the checksum length, or -1 if @checksum_type is not supported. a #GChecksumType Sets a function to be called when the child indicated by @pid exits, at a default priority, #G_PRIORITY_DEFAULT. If you obtain @pid from g_spawn_async() or g_spawn_async_with_pipes() you will need to pass #G_SPAWN_DO_NOT_REAP_CHILD as flag to the spawn function for the child watching to work. Note that on platforms where #GPid must be explicitly closed (see g_spawn_close_pid()) @pid must not be closed while the source is still active. Typically, you will want to call g_spawn_close_pid() in the callback function for the source. GLib supports only a single callback per process id. This internally creates a main loop source using g_child_watch_source_new() and attaches it to the main loop context using g_source_attach(). You can do these steps manually if you need greater control. the ID (greater than 0) of the event source. process id to watch. On POSIX the positive pid of a child process. On Windows a handle for a process (which doesn't have to be a child). function to call data to pass to @function Sets a function to be called when the child indicated by @pid exits, at the priority @priority. If you obtain @pid from g_spawn_async() or g_spawn_async_with_pipes() you will need to pass #G_SPAWN_DO_NOT_REAP_CHILD as flag to the spawn function for the child watching to work. In many programs, you will want to call g_spawn_check_exit_status() in the callback to determine whether or not the child exited successfully. Also, note that on platforms where #GPid must be explicitly closed (see g_spawn_close_pid()) @pid must not be closed while the source is still active. Typically, you should invoke g_spawn_close_pid() in the callback function for the source. GLib supports only a single callback per process id. This internally creates a main loop source using g_child_watch_source_new() and attaches it to the main loop context using g_source_attach(). You can do these steps manually if you need greater control. the ID (greater than 0) of the event source. the priority of the idle source. Typically this will be in the range between #G_PRIORITY_DEFAULT_IDLE and #G_PRIORITY_HIGH_IDLE. process to watch. On POSIX the positive pid of a child process. On Windows a handle for a process (which doesn't have to be a child). function to call data to pass to @function function to call when the idle is removed, or %NULL Creates a new child_watch source. The source will not initially be associated with any #GMainContext and must be added to one with g_source_attach() before it will be executed. Note that child watch sources can only be used in conjunction with `g_spawn...` when the %G_SPAWN_DO_NOT_REAP_CHILD flag is used. Note that on platforms where #GPid must be explicitly closed (see g_spawn_close_pid()) @pid must not be closed while the source is still active. Typically, you will want to call g_spawn_close_pid() in the callback function for the source. Note further that using g_child_watch_source_new() is not compatible with calling `waitpid` with a nonpositive first argument in the application. Calling waitpid() for individual pids will still work fine. Similarly, on POSIX platforms, the @pid passed to this function must be greater than 0 (i.e. this function must wait for a specific child, and cannot wait for one of many children by using a nonpositive argument). the newly-created child watch source process to watch. On POSIX the positive pid of a child process. On Windows a handle for a process (which doesn't have to be a child). If @err is %NULL, does nothing. If @err is non-%NULL, calls g_error_free() on *@err and sets *@err to %NULL. Clears a reference to a variable. @pp must not be %NULL. If the reference is %NULL then this function does nothing. Otherwise, the variable is destroyed using @destroy and the pointer is set to %NULL. A macro is also included that allows this function to be used without pointer casts. a pointer to a variable, struct member etc. holding a pointer a function to which a gpointer can be passed, to destroy *@pp This wraps the close() call; in case of error, %errno will be preserved, but the error will also be stored as a #GError in @error. Besides using #GError, there is another major reason to prefer this function over the call provided by the system; on Unix, it will attempt to correctly handle %EINTR, which has platform-specific semantics. A file descriptor Computes the checksum for a binary @data. This is a convenience wrapper for g_checksum_new(), g_checksum_get_string() and g_checksum_free(). The hexadecimal string returned will be in lower case. the digest of the binary data as a string in hexadecimal. The returned string should be freed with g_free() when done using it. a #GChecksumType binary blob to compute the digest of Computes the checksum for a binary @data of @length. This is a convenience wrapper for g_checksum_new(), g_checksum_get_string() and g_checksum_free(). The hexadecimal string returned will be in lower case. the digest of the binary data as a string in hexadecimal. The returned string should be freed with g_free() when done using it. a #GChecksumType binary blob to compute the digest of length of @data Computes the checksum of a string. The hexadecimal string returned will be in lower case. the checksum as a hexadecimal string. The returned string should be freed with g_free() when done using it. a #GChecksumType the string to compute the checksum of the length of the string, or -1 if the string is null-terminated. Computes the HMAC for a binary @data of @length. This is a convenience wrapper for g_hmac_new(), g_hmac_get_string() and g_hmac_unref(). The hexadecimal string returned will be in lower case. the HMAC of the binary data as a string in hexadecimal. The returned string should be freed with g_free() when done using it. a #GChecksumType to use for the HMAC the key to use in the HMAC the length of the key binary blob to compute the HMAC of length of @data Computes the HMAC for a string. The hexadecimal string returned will be in lower case. the HMAC as a hexadecimal string. The returned string should be freed with g_free() when done using it. a #GChecksumType to use for the HMAC the key to use in the HMAC the length of the key the string to compute the HMAC for the length of the string, or -1 if the string is nul-terminated Converts a string from one character set to another. Note that you should use g_iconv() for streaming conversions. Despite the fact that @byes_read can return information about partial characters, the g_convert_... functions are not generally suitable for streaming. If the underlying converter maintains internal state, then this won't be preserved across successive calls to g_convert(), g_convert_with_iconv() or g_convert_with_fallback(). (An example of this is the GNU C converter for CP1255 which does not emit a base character until it knows that the next character is not a mark that could combine with the base character.) Using extensions such as "//TRANSLIT" may not work (or may not work well) on many platforms. Consider using g_str_to_ascii() instead. If the conversion was successful, a newly allocated nul-terminated string, which must be freed with g_free(). Otherwise %NULL and @error will be set. the string to convert the length of the string in bytes, or -1 if the string is nul-terminated (Note that some encodings may allow nul bytes to occur inside strings. In that case, using -1 for the @len parameter is unsafe) name of character set into which to convert @str character set of @str. location to store the number of bytes in the input string that were successfully converted, or %NULL. Even if the conversion was successful, this may be less than @len if there were partial characters at the end of the input. If the error #G_CONVERT_ERROR_ILLEGAL_SEQUENCE occurs, the value stored will the byte offset after the last valid input sequence. the number of bytes stored in the output buffer (not including the terminating nul). Converts a string from one character set to another, possibly including fallback sequences for characters not representable in the output. Note that it is not guaranteed that the specification for the fallback sequences in @fallback will be honored. Some systems may do an approximate conversion from @from_codeset to @to_codeset in their iconv() functions, in which case GLib will simply return that approximate conversion. Note that you should use g_iconv() for streaming conversions. Despite the fact that @byes_read can return information about partial characters, the g_convert_... functions are not generally suitable for streaming. If the underlying converter maintains internal state, then this won't be preserved across successive calls to g_convert(), g_convert_with_iconv() or g_convert_with_fallback(). (An example of this is the GNU C converter for CP1255 which does not emit a base character until it knows that the next character is not a mark that could combine with the base character.) If the conversion was successful, a newly allocated nul-terminated string, which must be freed with g_free(). Otherwise %NULL and @error will be set. the string to convert the length of the string in bytes, or -1 if the string is nul-terminated (Note that some encodings may allow nul bytes to occur inside strings. In that case, using -1 for the @len parameter is unsafe) name of character set into which to convert @str character set of @str. UTF-8 string to use in place of character not present in the target encoding. (The string must be representable in the target encoding). If %NULL, characters not in the target encoding will be represented as Unicode escapes \uxxxx or \Uxxxxyyyy. location to store the number of bytes in the input string that were successfully converted, or %NULL. Even if the conversion was successful, this may be less than @len if there were partial characters at the end of the input. the number of bytes stored in the output buffer (not including the terminating nul). Converts a string from one character set to another. Note that you should use g_iconv() for streaming conversions. Despite the fact that @byes_read can return information about partial characters, the g_convert_... functions are not generally suitable for streaming. If the underlying converter maintains internal state, then this won't be preserved across successive calls to g_convert(), g_convert_with_iconv() or g_convert_with_fallback(). (An example of this is the GNU C converter for CP1255 which does not emit a base character until it knows that the next character is not a mark that could combine with the base character.) If the conversion was successful, a newly allocated nul-terminated string, which must be freed with g_free(). Otherwise %NULL and @error will be set. the string to convert the length of the string in bytes, or -1 if the string is nul-terminated (Note that some encodings may allow nul bytes to occur inside strings. In that case, using -1 for the @len parameter is unsafe) conversion descriptor from g_iconv_open() location to store the number of bytes in the input string that were successfully converted, or %NULL. Even if the conversion was successful, this may be less than @len if there were partial characters at the end of the input. If the error #G_CONVERT_ERROR_ILLEGAL_SEQUENCE occurs, the value stored will the byte offset after the last valid input sequence. the number of bytes stored in the output buffer (not including the terminating nul). Logs a "critical warning" (#G_LOG_LEVEL_CRITICAL). It's more or less application-defined what constitutes a critical vs. a regular warning. You could call g_log_set_always_fatal() to make critical warnings exit the program, then use g_critical() for fatal errors, for example. You can also make critical warnings fatal at runtime by setting the `G_DEBUG` environment variable (see [Running GLib Applications](glib-running.html)). If g_log_default_handler() is used as the log handler function, a new-line character will automatically be appended to @..., and need not be entered manually. format string, followed by parameters to insert into the format string (as with printf()) Frees all the data elements of the datalist. The data elements' destroy functions are called if they have been set. a datalist. Calls the given function for each data element of the datalist. The function is called with each data element's #GQuark id and data, together with the given @user_data parameter. Note that this function is NOT thread-safe. So unless @datalist can be protected from any modifications during invocation of this function, it should not be called. a datalist. the function to call for each data element. user data to pass to the function. Gets a data element, using its string identifier. This is slower than g_datalist_id_get_data() because it compares strings. the data element, or %NULL if it is not found. a datalist. the string identifying a data element. Gets flags values packed in together with the datalist. See g_datalist_set_flags(). the flags of the datalist pointer to the location that holds a list This is a variant of g_datalist_id_get_data() which returns a 'duplicate' of the value. @dup_func defines the meaning of 'duplicate' in this context, it could e.g. take a reference on a ref-counted object. If the @key_id is not set in the datalist then @dup_func will be called with a %NULL argument. Note that @dup_func is called while the datalist is locked, so it is not allowed to read or modify the datalist. This function can be useful to avoid races when multiple threads are using the same datalist and the same key. the result of calling @dup_func on the value associated with @key_id in @datalist, or %NULL if not set. If @dup_func is %NULL, the value is returned unmodified. location of a datalist the #GQuark identifying a data element function to duplicate the old value passed as user_data to @dup_func Retrieves the data element corresponding to @key_id. the data element, or %NULL if it is not found. a datalist. the #GQuark identifying a data element. Removes an element, without calling its destroy notification function. the data previously stored at @key_id, or %NULL if none. a datalist. the #GQuark identifying a data element. Compares the member that is associated with @key_id in @datalist to @oldval, and if they are the same, replace @oldval with @newval. This is like a typical atomic compare-and-exchange operation, for a member of @datalist. If the previous value was replaced then ownership of the old value (@oldval) is passed to the caller, including the registred destroy notify for it (passed out in @old_destroy). Its up to the caller to free this as he wishes, which may or may not include using @old_destroy as sometimes replacement should not destroy the object in the normal way. %TRUE if the existing value for @key_id was replaced by @newval, %FALSE otherwise. location of a datalist the #GQuark identifying a data element the old value to compare against the new value to replace it with destroy notify for the new value destroy notify for the existing value Sets the data corresponding to the given #GQuark id, and the function to be called when the element is removed from the datalist. Any previous data with the same key is removed, and its destroy function is called. a datalist. the #GQuark to identify the data element. the data element or %NULL to remove any previous element corresponding to @key_id. the function to call when the data element is removed. This function will be called with the data element and can be used to free any memory allocated for it. If @data is %NULL, then @destroy_func must also be %NULL. Resets the datalist to %NULL. It does not free any memory or call any destroy functions. a pointer to a pointer to a datalist. Turns on flag values for a data list. This function is used to keep a small number of boolean flags in an object with a data list without using any additional space. It is not generally useful except in circumstances where space is very tight. (It is used in the base #GObject type, for example.) pointer to the location that holds a list the flags to turn on. The values of the flags are restricted by %G_DATALIST_FLAGS_MASK (currently 3; giving two possible boolean flags). A value for @flags that doesn't fit within the mask is an error. Turns off flag values for a data list. See g_datalist_unset_flags() pointer to the location that holds a list the flags to turn off. The values of the flags are restricted by %G_DATALIST_FLAGS_MASK (currently 3: giving two possible boolean flags). A value for @flags that doesn't fit within the mask is an error. Destroys the dataset, freeing all memory allocated, and calling any destroy functions set for data elements. the location identifying the dataset. Calls the given function for each data element which is associated with the given location. Note that this function is NOT thread-safe. So unless @datalist can be protected from any modifications during invocation of this function, it should not be called. the location identifying the dataset. the function to call for each data element. user data to pass to the function. Gets the data element corresponding to a #GQuark. the data element corresponding to the #GQuark, or %NULL if it is not found. the location identifying the dataset. the #GQuark id to identify the data element. Removes an element, without calling its destroy notification function. the data previously stored at @key_id, or %NULL if none. the location identifying the dataset. the #GQuark ID identifying the data element. Sets the data element associated with the given #GQuark id, and also the function to call when the data element is destroyed. Any previous data with the same key is removed, and its destroy function is called. the location identifying the dataset. the #GQuark id to identify the data element. the data element. the function to call when the data element is removed. This function will be called with the data element and can be used to free any memory allocated for it. Returns the number of days in a month, taking leap years into account. number of days in @month during the @year month year Returns the number of weeks in the year, where weeks are taken to start on Monday. Will be 52 or 53. The date must be valid. (Years always have 52 7-day periods, plus 1 or 2 extra days depending on whether it's a leap year. This function is basically telling you how many Mondays are in the year, i.e. there are 53 Mondays if one of the extra days happens to be a Monday.) number of Mondays in the year a year Returns the number of weeks in the year, where weeks are taken to start on Sunday. Will be 52 or 53. The date must be valid. (Years always have 52 7-day periods, plus 1 or 2 extra days depending on whether it's a leap year. This function is basically telling you how many Sundays are in the year, i.e. there are 53 Sundays if one of the extra days happens to be a Sunday.) the number of weeks in @year year to count weeks in Returns %TRUE if the year is a leap year. For the purposes of this function, leap year is every year divisible by 4 unless that year is divisible by 100. If it is divisible by 100 it would be a leap year only if that year is also divisible by 400. %TRUE if the year is a leap year year to check Generates a printed representation of the date, in a [locale][setlocale]-specific way. Works just like the platform's C library strftime() function, but only accepts date-related formats; time-related formats give undefined results. Date must be valid. Unlike strftime() (which uses the locale encoding), works on a UTF-8 format string and stores a UTF-8 result. This function does not provide any conversion specifiers in addition to those implemented by the platform's C library. For example, don't expect that using g_date_strftime() would make the \%F provided by the C99 strftime() work on Windows where the C library only complies to C89. number of characters written to the buffer, or 0 the buffer was too small destination buffer buffer size format string valid #GDate A comparison function for #GDateTimes that is suitable as a #GCompareFunc. Both #GDateTimes must be non-%NULL. -1, 0 or 1 if @dt1 is less than, equal to or greater than @dt2. first #GDateTime to compare second #GDateTime to compare Checks to see if @dt1 and @dt2 are equal. Equal here means that they represent the same moment after converting them to the same time zone. %TRUE if @dt1 and @dt2 are equal a #GDateTime a #GDateTime Hashes @datetime into a #guint, suitable for use within #GHashTable. a #guint containing the hash a #GDateTime Returns %TRUE if the day of the month is valid (a day is valid if it's between 1 and 31 inclusive). %TRUE if the day is valid day to check Returns %TRUE if the day-month-year triplet forms a valid, existing day in the range of days #GDate understands (Year 1 or later, no more than a few thousand years in the future). %TRUE if the date is a valid one day month year Returns %TRUE if the Julian day is valid. Anything greater than zero is basically a valid Julian, though there is a 32-bit limit. %TRUE if the Julian day is valid Julian day to check Returns %TRUE if the month value is valid. The 12 #GDateMonth enumeration values are the only valid months. %TRUE if the month is valid month Returns %TRUE if the weekday is valid. The seven #GDateWeekday enumeration values are the only valid weekdays. %TRUE if the weekday is valid weekday Returns %TRUE if the year is valid. Any year greater than 0 is valid, though there is a 16-bit limit to what #GDate will understand. %TRUE if the year is valid year This is a variant of g_dgettext() that allows specifying a locale category instead of always using `LC_MESSAGES`. See g_dgettext() for more information about how this functions differs from calling dcgettext() directly. the translated string for the given locale category the translation domain to use, or %NULL to use the domain set with textdomain() message to translate a locale category This function is a wrapper of dgettext() which does not translate the message if the default domain as set with textdomain() has no translations for the current locale. The advantage of using this function over dgettext() proper is that libraries using this function (like GTK+) will not use translations if the application using the library does not have translations for the current locale. This results in a consistent English-only interface instead of one having partial translations. For this feature to work, the call to textdomain() and setlocale() should precede any g_dgettext() invocations. For GTK+, it means calling textdomain() before gtk_init or its variants. This function disables translations if and only if upon its first call all the following conditions hold: - @domain is not %NULL - textdomain() has been called to set a default text domain - there is no translations available for the default text domain and the current locale - current locale is not "C" or any English locales (those starting with "en_") Note that this behavior may not be desired for example if an application has its untranslated messages in a language other than English. In those cases the application should call textdomain() after initializing GTK+. Applications should normally not use this function directly, but use the _() macro for translations. The translated string the translation domain to use, or %NULL to use the domain set with textdomain() message to translate Creates a subdirectory in the preferred directory for temporary files (as returned by g_get_tmp_dir()). @tmpl should be a string in the GLib file name encoding containing a sequence of six 'X' characters, as the parameter to g_mkstemp(). However, unlike these functions, the template should only be a basename, no directory components are allowed. If template is %NULL, a default template is used. Note that in contrast to g_mkdtemp() (and mkdtemp()) @tmpl is not modified, and might thus be a read-only literal string. The actual name used. This string should be freed with g_free() when not needed any longer and is is in the GLib file name encoding. In case of errors, %NULL is returned and @error will be set. Template for directory name, as in g_mkdtemp(), basename only, or %NULL for a default template Compares two #gpointer arguments and returns %TRUE if they are equal. It can be passed to g_hash_table_new() as the @key_equal_func parameter, when using opaque pointers compared by pointer value as keys in a #GHashTable. This equality function is also appropriate for keys that are integers stored in pointers, such as `GINT_TO_POINTER (n)`. %TRUE if the two keys match. a key a key to compare with @v1 Converts a gpointer to a hash value. It can be passed to g_hash_table_new() as the @hash_func parameter, when using opaque pointers compared by pointer value as keys in a #GHashTable. This hash function is also appropriate for keys that are integers stored in pointers, such as `GINT_TO_POINTER (n)`. a hash value corresponding to the key. a #gpointer key This function is a wrapper of dngettext() which does not translate the message if the default domain as set with textdomain() has no translations for the current locale. See g_dgettext() for details of how this differs from dngettext() proper. The translated string the translation domain to use, or %NULL to use the domain set with textdomain() message to translate plural form of the message the quantity for which translation is needed Compares the two #gdouble values being pointed to and returns %TRUE if they are equal. It can be passed to g_hash_table_new() as the @key_equal_func parameter, when using non-%NULL pointers to doubles as keys in a #GHashTable. %TRUE if the two keys match. a pointer to a #gdouble key a pointer to a #gdouble key to compare with @v1 Converts a pointer to a #gdouble to a hash value. It can be passed to g_hash_table_new() as the @hash_func parameter, It can be passed to g_hash_table_new() as the @hash_func parameter, when using non-%NULL pointers to doubles as keys in a #GHashTable. a hash value corresponding to the key. a pointer to a #gdouble key This function is a variant of g_dgettext() which supports a disambiguating message context. GNU gettext uses the '\004' character to separate the message context and message id in @msgctxtid. If 0 is passed as @msgidoffset, this function will fall back to trying to use the deprecated convention of using "|" as a separation character. This uses g_dgettext() internally. See that functions for differences with dgettext() proper. Applications should normally not use this function directly, but use the C_() macro for translations with context. The translated string the translation domain to use, or %NULL to use the domain set with textdomain() a combined message context and message id, separated by a \004 character the offset of the message id in @msgctxid This function is a variant of g_dgettext() which supports a disambiguating message context. GNU gettext uses the '\004' character to separate the message context and message id in @msgctxtid. This uses g_dgettext() internally. See that functions for differences with dgettext() proper. This function differs from C_() in that it is not a macro and thus you may use non-string-literals as context and msgid arguments. The translated string the translation domain to use, or %NULL to use the domain set with textdomain() the message context the message Returns the value of the environment variable @variable in the provided list @envp. the value of the environment variable, or %NULL if the environment variable is not set in @envp. The returned string is owned by @envp, and will be freed if @variable is set or unset again. an environment list (eg, as returned from g_get_environ()), or %NULL for an empty environment list the environment variable to get, in the GLib file name encoding Sets the environment variable @variable in the provided list @envp to @value. the updated environment list. Free it using g_strfreev(). an environment list that can be freed using g_strfreev() (e.g., as returned from g_get_environ()), or %NULL for an empty environment list the environment variable to set, must not contain '=' the value for to set the variable to whether to change the variable if it already exists Removes the environment variable @variable from the provided environment @envp. the updated environment list. Free it using g_strfreev(). an environment list that can be freed using g_strfreev() (e.g., as returned from g_get_environ()), or %NULL for an empty environment list the environment variable to remove, must not contain '=' A convenience function/macro to log an error message. Error messages are always fatal, resulting in a call to abort() to terminate the application. This function will result in a core dump; don't use it for errors you expect. Using this function indicates a bug in your program, i.e. an assertion failure. If g_log_default_handler() is used as the log handler function, a new-line character will automatically be appended to @..., and need not be entered manually. format string, followed by parameters to insert into the format string (as with printf()) Gets a #GFileError constant based on the passed-in @err_no. For example, if you pass in `EEXIST` this function returns #G_FILE_ERROR_EXIST. Unlike `errno` values, you can portably assume that all #GFileError values will exist. Normally a #GFileError value goes into a #GError returned from a function that manipulates files. So you would use g_file_error_from_errno() when constructing a #GError. #GFileError corresponding to the given @errno an "errno" value Reads an entire file into allocated memory, with good error checking. If the call was successful, it returns %TRUE and sets @contents to the file contents and @length to the length of the file contents in bytes. The string stored in @contents will be nul-terminated, so for text files you can pass %NULL for the @length argument. If the call was not successful, it returns %FALSE and sets @error. The error domain is #G_FILE_ERROR. Possible error codes are those in the #GFileError enumeration. In the error case, @contents is set to %NULL and @length is set to zero. %TRUE on success, %FALSE if an error occurred name of a file to read contents from, in the GLib file name encoding location to store an allocated string, use g_free() to free the returned string location to store length in bytes of the contents, or %NULL Opens a file for writing in the preferred directory for temporary files (as returned by g_get_tmp_dir()). @tmpl should be a string in the GLib file name encoding containing a sequence of six 'X' characters, as the parameter to g_mkstemp(). However, unlike these functions, the template should only be a basename, no directory components are allowed. If template is %NULL, a default template is used. Note that in contrast to g_mkstemp() (and mkstemp()) @tmpl is not modified, and might thus be a read-only literal string. Upon success, and if @name_used is non-%NULL, the actual name used is returned in @name_used. This string should be freed with g_free() when not needed any longer. The returned name is in the GLib file name encoding. A file handle (as from open()) to the file opened for reading and writing. The file is opened in binary mode on platforms where there is a difference. The file handle should be closed with close(). In case of errors, -1 is returned and @error will be set. Template for file name, as in g_mkstemp(), basename only, or %NULL for a default template location to store actual name used, or %NULL Reads the contents of the symbolic link @filename like the POSIX readlink() function. The returned string is in the encoding used for filenames. Use g_filename_to_utf8() to convert it to UTF-8. A newly-allocated string with the contents of the symbolic link, or %NULL if an error occurred. the symbolic link Writes all of @contents to a file named @filename, with good error checking. If a file called @filename already exists it will be overwritten. This write is atomic in the sense that it is first written to a temporary file which is then renamed to the final name. Notes: - On UNIX, if @filename already exists hard links to @filename will break. Also since the file is recreated, existing permissions, access control lists, metadata etc. may be lost. If @filename is a symbolic link, the link itself will be replaced, not the linked file. - On Windows renaming a file will not remove an existing file with the new name, so on Windows there is a race condition between the existing file being removed and the temporary file being renamed. - On Windows there is no way to remove a file that is open to some process, or mapped into memory. Thus, this function will fail if @filename already exists and is open. If the call was successful, it returns %TRUE. If the call was not successful, it returns %FALSE and sets @error. The error domain is #G_FILE_ERROR. Possible error codes are those in the #GFileError enumeration. Note that the name for the temporary file is constructed by appending up to 7 characters to @filename. %TRUE on success, %FALSE if an error occurred name of a file to write @contents to, in the GLib file name encoding string to write to the file length of @contents, or -1 if @contents is a nul-terminated string Returns %TRUE if any of the tests in the bitfield @test are %TRUE. For example, `(G_FILE_TEST_EXISTS | G_FILE_TEST_IS_DIR)` will return %TRUE if the file exists; the check whether it's a directory doesn't matter since the existence test is %TRUE. With the current set of available tests, there's no point passing in more than one test at a time. Apart from %G_FILE_TEST_IS_SYMLINK all tests follow symbolic links, so for a symbolic link to a regular file g_file_test() will return %TRUE for both %G_FILE_TEST_IS_SYMLINK and %G_FILE_TEST_IS_REGULAR. Note, that for a dangling symbolic link g_file_test() will return %TRUE for %G_FILE_TEST_IS_SYMLINK and %FALSE for all other flags. You should never use g_file_test() to test whether it is safe to perform an operation, because there is always the possibility of the condition changing before you actually perform the operation. For example, you might think you could use %G_FILE_TEST_IS_SYMLINK to know whether it is safe to write to a file without being tricked into writing into a different location. It doesn't work! |[<!-- language="C" --> // DON'T DO THIS if (!g_file_test (filename, G_FILE_TEST_IS_SYMLINK)) { fd = g_open (filename, O_WRONLY); // write to fd } ]| Another thing to note is that %G_FILE_TEST_EXISTS and %G_FILE_TEST_IS_EXECUTABLE are implemented using the access() system call. This usually doesn't matter, but if your program is setuid or setgid it means that these tests will give you the answer for the real user ID and group ID, rather than the effective user ID and group ID. On Windows, there are no symlinks, so testing for %G_FILE_TEST_IS_SYMLINK will always return %FALSE. Testing for %G_FILE_TEST_IS_EXECUTABLE will just check that the file exists and its name indicates that it is executable, checking for well-known extensions and those listed in the `PATHEXT` environment variable. whether a test was %TRUE a filename to test in the GLib file name encoding bitfield of #GFileTest flags Returns the display basename for the particular filename, guaranteed to be valid UTF-8. The display name might not be identical to the filename, for instance there might be problems converting it to UTF-8, and some files can be translated in the display. If GLib cannot make sense of the encoding of @filename, as a last resort it replaces unknown characters with U+FFFD, the Unicode replacement character. You can search the result for the UTF-8 encoding of this character (which is "\357\277\275" in octal notation) to find out if @filename was in an invalid encoding. You must pass the whole absolute pathname to this functions so that translation of well known locations can be done. This function is preferred over g_filename_display_name() if you know the whole path, as it allows translation. a newly allocated string containing a rendition of the basename of the filename in valid UTF-8 an absolute pathname in the GLib file name encoding Converts a filename into a valid UTF-8 string. The conversion is not necessarily reversible, so you should keep the original around and use the return value of this function only for display purposes. Unlike g_filename_to_utf8(), the result is guaranteed to be non-%NULL even if the filename actually isn't in the GLib file name encoding. If GLib cannot make sense of the encoding of @filename, as a last resort it replaces unknown characters with U+FFFD, the Unicode replacement character. You can search the result for the UTF-8 encoding of this character (which is "\357\277\275" in octal notation) to find out if @filename was in an invalid encoding. If you know the whole pathname of the file you should use g_filename_display_basename(), since that allows location-based translation of filenames. a newly allocated string containing a rendition of the filename in valid UTF-8 a pathname hopefully in the GLib file name encoding Converts an escaped ASCII-encoded URI to a local filename in the encoding used for filenames. a newly-allocated string holding the resulting filename, or %NULL on an error. a uri describing a filename (escaped, encoded in ASCII). Location to store hostname for the URI, or %NULL. If there is no hostname in the URI, %NULL will be stored in this location. Converts a string from UTF-8 to the encoding GLib uses for filenames. Note that on Windows GLib uses UTF-8 for filenames; on other platforms, this function indirectly depends on the [current locale][setlocale]. The converted string, or %NULL on an error. a UTF-8 encoded string. the length of the string, or -1 if the string is nul-terminated. location to store the number of bytes in the input string that were successfully converted, or %NULL. Even if the conversion was successful, this may be less than @len if there were partial characters at the end of the input. If the error #G_CONVERT_ERROR_ILLEGAL_SEQUENCE occurs, the value stored will the byte offset after the last valid input sequence. the number of bytes stored in the output buffer (not including the terminating nul). Converts an absolute filename to an escaped ASCII-encoded URI, with the path component following Section 3.3. of RFC 2396. a newly-allocated string holding the resulting URI, or %NULL on an error. an absolute filename specified in the GLib file name encoding, which is the on-disk file name bytes on Unix, and UTF-8 on Windows A UTF-8 encoded hostname, or %NULL for none. Converts a string which is in the encoding used by GLib for filenames into a UTF-8 string. Note that on Windows GLib uses UTF-8 for filenames; on other platforms, this function indirectly depends on the [current locale][setlocale]. The converted string, or %NULL on an error. a string in the encoding for filenames the length of the string, or -1 if the string is nul-terminated (Note that some encodings may allow nul bytes to occur inside strings. In that case, using -1 for the @len parameter is unsafe) location to store the number of bytes in the input string that were successfully converted, or %NULL. Even if the conversion was successful, this may be less than @len if there were partial characters at the end of the input. If the error #G_CONVERT_ERROR_ILLEGAL_SEQUENCE occurs, the value stored will the byte offset after the last valid input sequence. the number of bytes stored in the output buffer (not including the terminating nul). Locates the first executable named @program in the user's path, in the same way that execvp() would locate it. Returns an allocated string with the absolute path name, or %NULL if the program is not found in the path. If @program is already an absolute path, returns a copy of @program if @program exists and is executable, and %NULL otherwise. On Windows, if @program does not have a file type suffix, tries with the suffixes .exe, .cmd, .bat and .com, and the suffixes in the `PATHEXT` environment variable. On Windows, it looks for the file in the same way as CreateProcess() would. This means first in the directory where the executing program was loaded from, then in the current directory, then in the Windows 32-bit system directory, then in the Windows directory, and finally in the directories in the `PATH` environment variable. If the program is found, the return value contains the full name including the type suffix. a newly-allocated string with the absolute path, or %NULL a program name in the GLib file name encoding Formats a size (for example the size of a file) into a human readable string. Sizes are rounded to the nearest size prefix (kB, MB, GB) and are displayed rounded to the nearest tenth. E.g. the file size 3292528 bytes will be converted into the string "3.2 MB". The prefix units base is 1000 (i.e. 1 kB is 1000 bytes). This string should be freed with g_free() when not needed any longer. See g_format_size_full() for more options about how the size might be formatted. a newly-allocated formatted string containing a human readable file size a size in bytes Formats a size (for example the size of a file) into a human readable string. Sizes are rounded to the nearest size prefix (KB, MB, GB) and are displayed rounded to the nearest tenth. E.g. the file size 3292528 bytes will be converted into the string "3.1 MB". The prefix units base is 1024 (i.e. 1 KB is 1024 bytes). This string should be freed with g_free() when not needed any longer. This function is broken due to its use of SI suffixes to denote IEC units. Use g_format_size() instead. a newly-allocated formatted string containing a human readable file size a size in bytes Formats a size. This function is similar to g_format_size() but allows for flags that modify the output. See #GFormatSizeFlags. a newly-allocated formatted string containing a human readable file size a size in bytes #GFormatSizeFlags to modify the output An implementation of the standard fprintf() function which supports positional parameters, as specified in the Single Unix Specification. the number of bytes printed. the stream to write to. a standard printf() format string, but notice [string precision pitfalls][string-precision] the arguments to insert in the output. Frees the memory pointed to by @mem. If @mem is %NULL it simply returns. the memory to free Gets a human-readable name for the application, as set by g_set_application_name(). This name should be localized if possible, and is intended for display to the user. Contrast with g_get_prgname(), which gets a non-localized name. If g_set_application_name() has not been called, returns the result of g_get_prgname() (which may be %NULL if g_set_prgname() has also not been called). human-readable application name. may return %NULL Obtains the character set for the [current locale][setlocale]; you might use this character set as an argument to g_convert(), to convert from the current locale's encoding to some other encoding. (Frequently g_locale_to_utf8() and g_locale_from_utf8() are nice shortcuts, though.) On Windows the character set returned by this function is the so-called system default ANSI code-page. That is the character set used by the "narrow" versions of C library and Win32 functions that handle file names. It might be different from the character set used by the C library's current locale. The return value is %TRUE if the locale's encoding is UTF-8, in that case you can perhaps avoid calling g_convert(). The string returned in @charset is not allocated, and should not be freed. %TRUE if the returned charset is UTF-8 return location for character set name Gets the character set for the current locale. a newly allocated string containing the name of the character set. This string must be freed with g_free(). Gets the current directory. The returned string should be freed when no longer needed. The encoding of the returned string is system defined. On Windows, it is always UTF-8. Since GLib 2.40, this function will return the value of the "PWD" environment variable if it is set and it happens to be the same as the current directory. This can make a difference in the case that the current directory is the target of a symbolic link. the current directory Equivalent to the UNIX gettimeofday() function, but portable. You may find g_get_real_time() to be more convenient. #GTimeVal structure in which to store current time. Gets the list of environment variables for the current process. The list is %NULL terminated and each item in the list is of the form 'NAME=VALUE'. This is equivalent to direct access to the 'environ' global variable, except portable. The return value is freshly allocated and it should be freed with g_strfreev() when it is no longer needed. the list of environment variables Determines the preferred character sets used for filenames. The first character set from the @charsets is the filename encoding, the subsequent character sets are used when trying to generate a displayable representation of a filename, see g_filename_display_name(). On Unix, the character sets are determined by consulting the environment variables `G_FILENAME_ENCODING` and `G_BROKEN_FILENAMES`. On Windows, the character set used in the GLib API is always UTF-8 and said environment variables have no effect. `G_FILENAME_ENCODING` may be set to a comma-separated list of character set names. The special token "&commat;locale" is taken to mean the character set for the [current locale][setlocale]. If `G_FILENAME_ENCODING` is not set, but `G_BROKEN_FILENAMES` is, the character set of the current locale is taken as the filename encoding. If neither environment variable is set, UTF-8 is taken as the filename encoding, but the character set of the current locale is also put in the list of encodings. The returned @charsets belong to GLib and must not be freed. Note that on Unix, regardless of the locale character set or `G_FILENAME_ENCODING` value, the actual file names present on a system might be in any random encoding or just gibberish. %TRUE if the filename encoding is UTF-8. return location for the %NULL-terminated list of encoding names Gets the current user's home directory. As with most UNIX tools, this function will return the value of the `HOME` environment variable if it is set to an existing absolute path name, falling back to the `passwd` file in the case that it is unset. If the path given in `HOME` is non-absolute, does not exist, or is not a directory, the result is undefined. Before version 2.36 this function would ignore the `HOME` environment variable, taking the value from the `passwd` database instead. This was changed to increase the compatibility of GLib with other programs (and the XDG basedir specification) and to increase testability of programs based on GLib (by making it easier to run them from test frameworks). If your program has a strong requirement for either the new or the old behaviour (and if you don't wish to increase your GLib dependency to ensure that the new behaviour is in effect) then you should either directly check the `HOME` environment variable yourself or unset it before calling any functions in GLib. the current user's home directory Return a name for the machine. The returned name is not necessarily a fully-qualified domain name, or even present in DNS or some other name service at all. It need not even be unique on your local network or site, but usually it is. Callers should not rely on the return value having any specific properties like uniqueness for security purposes. Even if the name of the machine is changed while an application is running, the return value from this function does not change. The returned string is owned by GLib and should not be modified or freed. If no name can be determined, a default fixed string "localhost" is returned. the host name of the machine. Computes a list of applicable locale names, which can be used to e.g. construct locale-dependent filenames or search paths. The returned list is sorted from most desirable to least desirable and always contains the default locale "C". For example, if LANGUAGE=de:en_US, then the returned list is "de", "en_US", "en", "C". This function consults the environment variables `LANGUAGE`, `LC_ALL`, `LC_MESSAGES` and `LANG` to find the list of locales specified by the user. a %NULL-terminated array of strings owned by GLib that must not be modified or freed. Returns a list of derived variants of @locale, which can be used to e.g. construct locale-dependent filenames or search paths. The returned list is sorted from most desirable to least desirable. This function handles territory, charset and extra locale modifiers. For example, if @locale is "fr_BE", then the returned list is "fr_BE", "fr". If you need the list of variants for the current locale, use g_get_language_names(). a newly allocated array of newly allocated strings with the locale variants. Free with g_strfreev(). a locale identifier Queries the system monotonic time. The monotonic clock will always increase and doesn't suffer discontinuities when the user (or NTP) changes the system time. It may or may not continue to tick during times where the machine is suspended. We try to use the clock that corresponds as closely as possible to the passage of time as measured by system calls such as poll() but it may not always be possible to do this. the monotonic time, in microseconds Determine the approximate number of threads that the system will schedule simultaneously for this process. This is intended to be used as a parameter to g_thread_pool_new() for CPU bound tasks and similar cases. Number of schedulable threads, always greater than 0 Gets the name of the program. This name should not be localized, in contrast to g_get_application_name(). If you are using GDK or GTK+ the program name is set in gdk_init(), which is called by gtk_init(). The program name is found by taking the last component of @argv[0]. the name of the program. The returned string belongs to GLib and must not be modified or freed. Gets the real name of the user. This usually comes from the user's entry in the `passwd` file. The encoding of the returned string is system-defined. (On Windows, it is, however, always UTF-8.) If the real user name cannot be determined, the string "Unknown" is returned. the user's real name. Queries the system wall-clock time. This call is functionally equivalent to g_get_current_time() except that the return value is often more convenient than dealing with a #GTimeVal. You should only use this call if you are actually interested in the real wall-clock time. g_get_monotonic_time() is probably more useful for measuring intervals. the number of microseconds since January 1, 1970 UTC. Returns an ordered list of base directories in which to access system-wide configuration information. On UNIX platforms this is determined using the mechanisms described in the [XDG Base Directory Specification](http://www.freedesktop.org/Standards/basedir-spec). In this case the list of directories retrieved will be `XDG_CONFIG_DIRS`. On Windows is the directory that contains application data for all users. A typical path is C:\Documents and Settings\All Users\Application Data. This folder is used for application data that is not user specific. For example, an application can store a spell-check dictionary, a database of clip art, or a log file in the CSIDL_COMMON_APPDATA folder. This information will not roam and is available to anyone using the computer. a %NULL-terminated array of strings owned by GLib that must not be modified or freed. Returns an ordered list of base directories in which to access system-wide application data. On UNIX platforms this is determined using the mechanisms described in the [XDG Base Directory Specification](http://www.freedesktop.org/Standards/basedir-spec) In this case the list of directories retrieved will be XDG_DATA_DIRS. On Windows the first elements in the list are the Application Data and Documents folders for All Users. (These can be determined only on Windows 2000 or later and are not present in the list on other Windows versions.) See documentation for CSIDL_COMMON_APPDATA and CSIDL_COMMON_DOCUMENTS. Then follows the "share" subfolder in the installation folder for the package containing the DLL that calls this function, if it can be determined. Finally the list contains the "share" subfolder in the installation folder for GLib, and in the installation folder for the package the application's .exe file belongs to. The installation folders above are determined by looking up the folder where the module (DLL or EXE) in question is located. If the folder's name is "bin", its parent is used, otherwise the folder itself. Note that on Windows the returned list can vary depending on where this function is called. a %NULL-terminated array of strings owned by GLib that must not be modified or freed. Gets the directory to use for temporary files. On UNIX, this is taken from the `TMPDIR` environment variable. If the variable is not set, `P_tmpdir` is used, as defined by the system C library. Failing that, a hard-coded default of "/tmp" is returned. On Windows, the `TEMP` environment variable is used, with the root directory of the Windows installation (eg: "C:\") used as a default. The encoding of the returned string is system-defined. On Windows, it is always UTF-8. The return value is never %NULL or the empty string. the directory to use for temporary files. Returns a base directory in which to store non-essential, cached data specific to particular user. On UNIX platforms this is determined using the mechanisms described in the [XDG Base Directory Specification](http://www.freedesktop.org/Standards/basedir-spec). In this case the directory retrieved will be XDG_CACHE_HOME. On Windows is the directory that serves as a common repository for temporary Internet files. A typical path is C:\Documents and Settings\username\Local Settings\Temporary Internet Files. See documentation for CSIDL_INTERNET_CACHE. a string owned by GLib that must not be modified or freed. Returns a base directory in which to store user-specific application configuration information such as user preferences and settings. On UNIX platforms this is determined using the mechanisms described in the [XDG Base Directory Specification](http://www.freedesktop.org/Standards/basedir-spec). In this case the directory retrieved will be `XDG_CONFIG_HOME`. On Windows this is the folder to use for local (as opposed to roaming) application data. See documentation for CSIDL_LOCAL_APPDATA. Note that on Windows it thus is the same as what g_get_user_data_dir() returns. a string owned by GLib that must not be modified or freed. Returns a base directory in which to access application data such as icons that is customized for a particular user. On UNIX platforms this is determined using the mechanisms described in the [XDG Base Directory Specification](http://www.freedesktop.org/Standards/basedir-spec). In this case the directory retrieved will be `XDG_DATA_HOME`. On Windows this is the folder to use for local (as opposed to roaming) application data. See documentation for CSIDL_LOCAL_APPDATA. Note that on Windows it thus is the same as what g_get_user_config_dir() returns. a string owned by GLib that must not be modified or freed. Gets the user name of the current user. The encoding of the returned string is system-defined. On UNIX, it might be the preferred file name encoding, or something else, and there is no guarantee that it is even consistent on a machine. On Windows, it is always UTF-8. the user name of the current user. Returns a directory that is unique to the current user on the local system. On UNIX platforms this is determined using the mechanisms described in the [XDG Base Directory Specification](http://www.freedesktop.org/Standards/basedir-spec). This is the directory specified in the `XDG_RUNTIME_DIR` environment variable. In the case that this variable is not set, GLib will issue a warning message to stderr and return the value of g_get_user_cache_dir(). On Windows this is the folder to use for local (as opposed to roaming) application data. See documentation for CSIDL_LOCAL_APPDATA. Note that on Windows it thus is the same as what g_get_user_config_dir() returns. a string owned by GLib that must not be modified or freed. Returns the full path of a special directory using its logical id. On UNIX this is done using the XDG special user directories. For compatibility with existing practise, %G_USER_DIRECTORY_DESKTOP falls back to `$HOME/Desktop` when XDG special user directories have not been set up. Depending on the platform, the user might be able to change the path of the special directory without requiring the session to restart; GLib will not reflect any change once the special directories are loaded. the path to the specified special directory, or %NULL if the logical id was not found. The returned string is owned by GLib and should not be modified or freed. the logical id of special directory Returns the value of an environment variable. The name and value are in the GLib file name encoding. On UNIX, this means the actual bytes which might or might not be in some consistent character set and encoding. On Windows, it is in UTF-8. On Windows, in case the environment variable's value contains references to other environment variables, they are expanded. the value of the environment variable, or %NULL if the environment variable is not found. The returned string may be overwritten by the next call to g_getenv(), g_setenv() or g_unsetenv(). the environment variable to get, in the GLib file name encoding This is a convenience function for using a #GHashTable as a set. It is equivalent to calling g_hash_table_replace() with @key as both the key and the value. When a hash table only ever contains keys that have themselves as the corresponding value it is able to be stored more efficiently. See the discussion in the section description. %TRUE if the key did not exist yet a #GHashTable a key to insert Checks if @key is in @hash_table. a #GHashTable a key to check Destroys all keys and values in the #GHashTable and decrements its reference count by 1. If keys and/or values are dynamically allocated, you should either free them first or create the #GHashTable with destroy notifiers using g_hash_table_new_full(). In the latter case the destroy functions you supplied will be called on all keys and values during the destruction phase. a #GHashTable Inserts a new key and value into a #GHashTable. If the key already exists in the #GHashTable its current value is replaced with the new value. If you supplied a @value_destroy_func when creating the #GHashTable, the old value is freed using that function. If you supplied a @key_destroy_func when creating the #GHashTable, the passed key is freed using that function. %TRUE if the key did not exist yet a #GHashTable a key to insert the value to associate with the key Looks up a key in the #GHashTable, returning the original key and the associated value and a #gboolean which is %TRUE if the key was found. This is useful if you need to free the memory allocated for the original key, for example before calling g_hash_table_remove(). You can actually pass %NULL for @lookup_key to test whether the %NULL key exists, provided the hash and equal functions of @hash_table are %NULL-safe. %TRUE if the key was found in the #GHashTable a #GHashTable the key to look up return location for the original key, or %NULL return location for the value associated with the key, or %NULL Removes a key and its associated value from a #GHashTable. If the #GHashTable was created using g_hash_table_new_full(), the key and value are freed using the supplied destroy functions, otherwise you have to make sure that any dynamically allocated values are freed yourself. %TRUE if the key was found and removed from the #GHashTable a #GHashTable the key to remove Removes all keys and their associated values from a #GHashTable. If the #GHashTable was created using g_hash_table_new_full(), the keys and values are freed using the supplied destroy functions, otherwise you have to make sure that any dynamically allocated values are freed yourself. a #GHashTable Inserts a new key and value into a #GHashTable similar to g_hash_table_insert(). The difference is that if the key already exists in the #GHashTable, it gets replaced by the new key. If you supplied a @value_destroy_func when creating the #GHashTable, the old value is freed using that function. If you supplied a @key_destroy_func when creating the #GHashTable, the old key is freed using that function. %TRUE of the key did not exist yet a #GHashTable a key to insert the value to associate with the key Returns the number of elements contained in the #GHashTable. the number of key/value pairs in the #GHashTable. a #GHashTable Removes a key and its associated value from a #GHashTable without calling the key and value destroy functions. %TRUE if the key was found and removed from the #GHashTable a #GHashTable the key to remove Removes all keys and their associated values from a #GHashTable without calling the key and value destroy functions. a #GHashTable Atomically decrements the reference count of @hash_table by one. If the reference count drops to 0, all keys and values will be destroyed, and all memory allocated by the hash table is released. This function is MT-safe and may be called from any thread. a valid #GHashTable Destroys a #GHook, given its ID. %TRUE if the #GHook was found in the #GHookList and destroyed a #GHookList a hook ID Removes one #GHook from a #GHookList, marking it inactive and calling g_hook_unref() on it. a #GHookList the #GHook to remove Calls the #GHookList @finalize_hook function if it exists, and frees the memory allocated for the #GHook. a #GHookList the #GHook to free Inserts a #GHook into a #GHookList, before a given #GHook. a #GHookList the #GHook to insert the new #GHook before the #GHook to insert Prepends a #GHook on the start of a #GHookList. a #GHookList the #GHook to add to the start of @hook_list Decrements the reference count of a #GHook. If the reference count falls to 0, the #GHook is removed from the #GHookList and g_hook_free() is called to free it. a #GHookList the #GHook to unref Tests if @hostname contains segments with an ASCII-compatible encoding of an Internationalized Domain Name. If this returns %TRUE, you should decode the hostname with g_hostname_to_unicode() before displaying it to the user. Note that a hostname might contain a mix of encoded and unencoded segments, and so it is possible for g_hostname_is_non_ascii() and g_hostname_is_ascii_encoded() to both return %TRUE for a name. %TRUE if @hostname contains any ASCII-encoded segments. a hostname Tests if @hostname is the string form of an IPv4 or IPv6 address. (Eg, "192.168.0.1".) %TRUE if @hostname is an IP address a hostname (or IP address in string form) Tests if @hostname contains Unicode characters. If this returns %TRUE, you need to encode the hostname with g_hostname_to_ascii() before using it in non-IDN-aware contexts. Note that a hostname might contain a mix of encoded and unencoded segments, and so it is possible for g_hostname_is_non_ascii() and g_hostname_is_ascii_encoded() to both return %TRUE for a name. %TRUE if @hostname contains any non-ASCII characters a hostname Converts @hostname to its canonical ASCII form; an ASCII-only string containing no uppercase letters and not ending with a trailing dot. an ASCII hostname, which must be freed, or %NULL if @hostname is in some way invalid. a valid UTF-8 or ASCII hostname Converts @hostname to its canonical presentation form; a UTF-8 string in Unicode normalization form C, containing no uppercase letters, no forbidden characters, and no ASCII-encoded segments, and not ending with a trailing dot. Of course if @hostname is not an internationalized hostname, then the canonical presentation form will be entirely ASCII. a UTF-8 hostname, which must be freed, or %NULL if @hostname is in some way invalid. a valid UTF-8 or ASCII hostname Same as the standard UNIX routine iconv(), but may be implemented via libiconv on UNIX flavors that lack a native implementation. GLib provides g_convert() and g_locale_to_utf8() which are likely more convenient than the raw iconv wrappers. count of non-reversible conversions, or -1 on error conversion descriptor from g_iconv_open() bytes to convert inout parameter, bytes remaining to convert in @inbuf converted output bytes inout parameter, bytes available to fill in @outbuf Adds a function to be called whenever there are no higher priority events pending to the default main loop. The function is given the default idle priority, #G_PRIORITY_DEFAULT_IDLE. If the function returns %FALSE it is automatically removed from the list of event sources and will not be called again. This internally creates a main loop source using g_idle_source_new() and attaches it to the main loop context using g_source_attach(). You can do these steps manually if you need greater control. the ID (greater than 0) of the event source. function to call data to pass to @function. Adds a function to be called whenever there are no higher priority events pending. If the function returns %FALSE it is automatically removed from the list of event sources and will not be called again. This internally creates a main loop source using g_idle_source_new() and attaches it to the main loop context using g_source_attach(). You can do these steps manually if you need greater control. the ID (greater than 0) of the event source. the priority of the idle source. Typically this will be in the range between #G_PRIORITY_DEFAULT_IDLE and #G_PRIORITY_HIGH_IDLE. function to call data to pass to @function function to call when the idle is removed, or %NULL Removes the idle function with the given data. %TRUE if an idle source was found and removed. the data for the idle source's callback. Creates a new idle source. The source will not initially be associated with any #GMainContext and must be added to one with g_source_attach() before it will be executed. Note that the default priority for idle sources is %G_PRIORITY_DEFAULT_IDLE, as compared to other sources which have a default priority of %G_PRIORITY_DEFAULT. the newly-created idle source Compares the two #gint64 values being pointed to and returns %TRUE if they are equal. It can be passed to g_hash_table_new() as the @key_equal_func parameter, when using non-%NULL pointers to 64-bit integers as keys in a #GHashTable. %TRUE if the two keys match. a pointer to a #gint64 key a pointer to a #gint64 key to compare with @v1 Converts a pointer to a #gint64 to a hash value. It can be passed to g_hash_table_new() as the @hash_func parameter, when using non-%NULL pointers to 64-bit integer values as keys in a #GHashTable. a hash value corresponding to the key. a pointer to a #gint64 key Compares the two #gint values being pointed to and returns %TRUE if they are equal. It can be passed to g_hash_table_new() as the @key_equal_func parameter, when using non-%NULL pointers to integers as keys in a #GHashTable. Note that this function acts on pointers to #gint, not on #gint directly: if your hash table's keys are of the form `GINT_TO_POINTER (n)`, use g_direct_equal() instead. %TRUE if the two keys match. a pointer to a #gint key a pointer to a #gint key to compare with @v1 Converts a pointer to a #gint to a hash value. It can be passed to g_hash_table_new() as the @hash_func parameter, when using non-%NULL pointers to integer values as keys in a #GHashTable. Note that this function acts on pointers to #gint, not on #gint directly: if your hash table's keys are of the form `GINT_TO_POINTER (n)`, use g_direct_hash() instead. a hash value corresponding to the key. a pointer to a #gint key Returns a canonical representation for @string. Interned strings can be compared for equality by comparing the pointers, instead of using strcmp(). g_intern_static_string() does not copy the string, therefore @string must not be freed or modified. a canonical representation for the string a static string Returns a canonical representation for @string. Interned strings can be compared for equality by comparing the pointers, instead of using strcmp(). a canonical representation for the string a string Adds the #GIOChannel into the default main loop context with the default priority. the event source id a #GIOChannel the condition to watch for the function to call when the condition is satisfied user data to pass to @func Adds the #GIOChannel into the default main loop context with the given priority. This internally creates a main loop source using g_io_create_watch() and attaches it to the main loop context with g_source_attach(). You can do these steps manually if you need greater control. the event source id a #GIOChannel the priority of the #GIOChannel source the condition to watch for the function to call when the condition is satisfied user data to pass to @func the function to call when the source is removed Converts an `errno` error number to a #GIOChannelError. a #GIOChannelError error number, e.g. %G_IO_CHANNEL_ERROR_INVAL. an `errno` error number, e.g. `EINVAL` Creates a #GSource that's dispatched when @condition is met for the given @channel. For example, if condition is #G_IO_IN, the source will be dispatched when there's data available for reading. g_io_add_watch() is a simpler interface to this same functionality, for the case where you want to add the source to the default main loop context at the default priority. On Windows, polling a #GSource created to watch a channel for a socket puts the socket in non-blocking mode. This is a side-effect of the implementation and unavoidable. a new #GSource a #GIOChannel to watch conditions to watch for Gets the names of all variables set in the environment. Programs that want to be portable to Windows should typically use this function and g_getenv() instead of using the environ array from the C library directly. On Windows, the strings in the environ array are in system codepage encoding, while in most of the typical use cases for environment variables in GLib-using programs you want the UTF-8 encoding that this function and g_getenv() provide. a %NULL-terminated list of strings which must be freed with g_strfreev(). Converts a string from UTF-8 to the encoding used for strings by the C runtime (usually the same as that used by the operating system) in the [current locale][setlocale]. On Windows this means the system codepage. A newly-allocated buffer containing the converted string, or %NULL on an error, and error will be set. a UTF-8 encoded string the length of the string, or -1 if the string is nul-terminated (Note that some encodings may allow nul bytes to occur inside strings. In that case, using -1 for the @len parameter is unsafe) location to store the number of bytes in the input string that were successfully converted, or %NULL. Even if the conversion was successful, this may be less than @len if there were partial characters at the end of the input. If the error #G_CONVERT_ERROR_ILLEGAL_SEQUENCE occurs, the value stored will the byte offset after the last valid input sequence. the number of bytes stored in the output buffer (not including the terminating nul). Converts a string which is in the encoding used for strings by the C runtime (usually the same as that used by the operating system) in the [current locale][setlocale] into a UTF-8 string. A newly-allocated buffer containing the converted string, or %NULL on an error, and error will be set. a string in the encoding of the current locale. On Windows this means the system codepage. the length of the string, or -1 if the string is nul-terminated (Note that some encodings may allow nul bytes to occur inside strings. In that case, using -1 for the @len parameter is unsafe) location to store the number of bytes in the input string that were successfully converted, or %NULL. Even if the conversion was successful, this may be less than @len if there were partial characters at the end of the input. If the error #G_CONVERT_ERROR_ILLEGAL_SEQUENCE occurs, the value stored will the byte offset after the last valid input sequence. the number of bytes stored in the output buffer (not including the terminating nul). Logs an error or debugging message. If the log level has been set as fatal, the abort() function is called to terminate the program. If g_log_default_handler() is used as the log handler function, a new-line character will automatically be appended to @..., and need not be entered manually. the log domain, usually #G_LOG_DOMAIN the log level, either from #GLogLevelFlags or a user-defined level the message format. See the printf() documentation the parameters to insert into the format string The default log handler set up by GLib; g_log_set_default_handler() allows to install an alternate default log handler. This is used if no log handler has been set for the particular log domain and log level combination. It outputs the message to stderr or stdout and if the log level is fatal it calls abort(). It automatically prints a new-line character after the message, so one does not need to be manually included in @message. The behavior of this log handler can be influenced by a number of environment variables: - `G_MESSAGES_PREFIXED`: A :-separated list of log levels for which messages should be prefixed by the program name and PID of the aplication. - `G_MESSAGES_DEBUG`: A space-separated list of log domains for which debug and informational messages are printed. By default these messages are not printed. stderr is used for levels %G_LOG_LEVEL_ERROR, %G_LOG_LEVEL_CRITICAL, %G_LOG_LEVEL_WARNING and %G_LOG_LEVEL_MESSAGE. stdout is used for the rest. the log domain of the message the level of the message the message data passed from g_log() which is unused Removes the log handler. the log domain the id of the handler, which was returned in g_log_set_handler() Sets the message levels which are always fatal, in any log domain. When a message with any of these levels is logged the program terminates. You can only set the levels defined by GLib to be fatal. %G_LOG_LEVEL_ERROR is always fatal. You can also make some message levels fatal at runtime by setting the `G_DEBUG` environment variable (see [Running GLib Applications](glib-running.html)). the old fatal mask the mask containing bits set for each level of error which is to be fatal Installs a default log handler which is used if no log handler has been set for the particular log domain and log level combination. By default, GLib uses g_log_default_handler() as default log handler. the previous default log handler the log handler function data passed to the log handler Sets the log levels which are fatal in the given domain. %G_LOG_LEVEL_ERROR is always fatal. the old fatal mask for the log domain the log domain the new fatal mask Sets the log handler for a domain and a set of log levels. To handle fatal and recursive messages the @log_levels parameter must be combined with the #G_LOG_FLAG_FATAL and #G_LOG_FLAG_RECURSION bit flags. Note that since the #G_LOG_LEVEL_ERROR log level is always fatal, if you want to set a handler for this log level you must combine it with #G_LOG_FLAG_FATAL. Here is an example for adding a log handler for all warning messages in the default domain: |[<!-- language="C" --> g_log_set_handler (NULL, G_LOG_LEVEL_WARNING | G_LOG_FLAG_FATAL | G_LOG_FLAG_RECURSION, my_log_handler, NULL); ]| This example adds a log handler for all critical messages from GTK+: |[<!-- language="C" --> g_log_set_handler ("Gtk", G_LOG_LEVEL_CRITICAL | G_LOG_FLAG_FATAL | G_LOG_FLAG_RECURSION, my_log_handler, NULL); ]| This example adds a log handler for all messages from GLib: |[<!-- language="C" --> g_log_set_handler ("GLib", G_LOG_LEVEL_MASK | G_LOG_FLAG_FATAL | G_LOG_FLAG_RECURSION, my_log_handler, NULL); ]| the id of the new handler the log domain, or %NULL for the default "" application domain the log levels to apply the log handler for. To handle fatal and recursive messages as well, combine the log levels with the #G_LOG_FLAG_FATAL and #G_LOG_FLAG_RECURSION bit flags. the log handler function data passed to the log handler Logs an error or debugging message. If the log level has been set as fatal, the abort() function is called to terminate the program. If g_log_default_handler() is used as the log handler function, a new-line character will automatically be appended to @..., and need not be entered manually. the log domain the log level the message format. See the printf() documentation the parameters to insert into the format string Returns the global default main context. This is the main context used for main loop functions when a main loop is not explicitly specified, and corresponds to the "main" main loop. See also g_main_context_get_thread_default(). the global default main context. Gets the thread-default #GMainContext for this thread. Asynchronous operations that want to be able to be run in contexts other than the default one should call this method or g_main_context_ref_thread_default() to get a #GMainContext to add their #GSources to. (Note that even in single-threaded programs applications may sometimes want to temporarily push a non-default context, so it is not safe to assume that this will always return %NULL if you are running in the default thread.) If you need to hold a reference on the context, use g_main_context_ref_thread_default() instead. the thread-default #GMainContext, or %NULL if the thread-default context is the global default context. Gets the thread-default #GMainContext for this thread, as with g_main_context_get_thread_default(), but also adds a reference to it with g_main_context_ref(). In addition, unlike g_main_context_get_thread_default(), if the thread-default context is the global default context, this will return that #GMainContext (with a ref added to it) rather than returning %NULL. the thread-default #GMainContext. Unref with g_main_context_unref() when you are done with it. Returns the currently firing source for this thread. The currently firing source or %NULL. Returns the depth of the stack of calls to g_main_context_dispatch() on any #GMainContext in the current thread. That is, when called from the toplevel, it gives 0. When called from within a callback from g_main_context_iteration() (or g_main_loop_run(), etc.) it returns 1. When called from within a callback to a recursive call to g_main_context_iteration(), it returns 2. And so forth. This function is useful in a situation like the following: Imagine an extremely simple "garbage collected" system. |[<!-- language="C" --> static GList *free_list; gpointer allocate_memory (gsize size) { gpointer result = g_malloc (size); free_list = g_list_prepend (free_list, result); return result; } void free_allocated_memory (void) { GList *l; for (l = free_list; l; l = l->next); g_free (l->data); g_list_free (free_list); free_list = NULL; } [...] while (TRUE); { g_main_context_iteration (NULL, TRUE); free_allocated_memory(); } ]| This works from an application, however, if you want to do the same thing from a library, it gets more difficult, since you no longer control the main loop. You might think you can simply use an idle function to make the call to free_allocated_memory(), but that doesn't work, since the idle function could be called from a recursive callback. This can be fixed by using g_main_depth() |[<!-- language="C" --> gpointer allocate_memory (gsize size) { FreeListBlock *block = g_new (FreeListBlock, 1); block->mem = g_malloc (size); block->depth = g_main_depth (); free_list = g_list_prepend (free_list, block); return block->mem; } void free_allocated_memory (void) { GList *l; int depth = g_main_depth (); for (l = free_list; l; ); { GList *next = l->next; FreeListBlock *block = l->data; if (block->depth > depth) { g_free (block->mem); g_free (block); free_list = g_list_delete_link (free_list, l); } l = next; } } ]| There is a temptation to use g_main_depth() to solve problems with reentrancy. For instance, while waiting for data to be received from the network in response to a menu item, the menu item might be selected again. It might seem that one could make the menu item's callback return immediately and do nothing if g_main_depth() returns a value greater than 1. However, this should be avoided since the user then sees selecting the menu item do nothing. Furthermore, you'll find yourself adding these checks all over your code, since there are doubtless many, many things that the user could do. Instead, you can use the following techniques: 1. Use gtk_widget_set_sensitive() or modal dialogs to prevent the user from interacting with elements while the main loop is recursing. 2. Avoid main loop recursion in situations where you can't handle arbitrary callbacks. Instead, structure your code so that you simply return to the main loop and then get called again when there is more work to do. The main loop recursion level in the current thread Allocates @n_bytes bytes of memory. If @n_bytes is 0 it returns %NULL. a pointer to the allocated memory the number of bytes to allocate Allocates @n_bytes bytes of memory, initialized to 0's. If @n_bytes is 0 it returns %NULL. a pointer to the allocated memory the number of bytes to allocate This function is similar to g_malloc0(), allocating (@n_blocks * @n_block_bytes) bytes, but care is taken to detect possible overflow during multiplication. a pointer to the allocated memory the number of blocks to allocate the size of each block in bytes This function is similar to g_malloc(), allocating (@n_blocks * @n_block_bytes) bytes, but care is taken to detect possible overflow during multiplication. a pointer to the allocated memory the number of blocks to allocate the size of each block in bytes Collects the attributes of the element from the data passed to the #GMarkupParser start_element function, dealing with common error conditions and supporting boolean values. This utility function is not required to write a parser but can save a lot of typing. The @element_name, @attribute_names, @attribute_values and @error parameters passed to the start_element callback should be passed unmodified to this function. Following these arguments is a list of "supported" attributes to collect. It is an error to specify multiple attributes with the same name. If any attribute not in the list appears in the @attribute_names array then an unknown attribute error will result. The #GMarkupCollectType field allows specifying the type of collection to perform and if a given attribute must appear or is optional. The attribute name is simply the name of the attribute to collect. The pointer should be of the appropriate type (see the descriptions under #GMarkupCollectType) and may be %NULL in case a particular attribute is to be allowed but ignored. This function deals with issuing errors for missing attributes (of type %G_MARKUP_ERROR_MISSING_ATTRIBUTE), unknown attributes (of type %G_MARKUP_ERROR_UNKNOWN_ATTRIBUTE) and duplicate attributes (of type %G_MARKUP_ERROR_INVALID_CONTENT) as well as parse errors for boolean-valued attributes (again of type %G_MARKUP_ERROR_INVALID_CONTENT). In all of these cases %FALSE will be returned and @error will be set as appropriate. %TRUE if successful the current tag name the attribute names the attribute values a pointer to a #GError or %NULL the #GMarkupCollectType of the first attribute the name of the first attribute a pointer to the storage location of the first attribute (or %NULL), followed by more types names and pointers, ending with %G_MARKUP_COLLECT_INVALID Escapes text so that the markup parser will parse it verbatim. Less than, greater than, ampersand, etc. are replaced with the corresponding entities. This function would typically be used when writing out a file to be parsed with the markup parser. Note that this function doesn't protect whitespace and line endings from being processed according to the XML rules for normalization of line endings and attribute values. Note also that this function will produce character references in the range of &#x1; ... &#x1f; for all control sequences except for tabstop, newline and carriage return. The character references in this range are not valid XML 1.0, but they are valid XML 1.1 and will be accepted by the GMarkup parser. a newly allocated string with the escaped text some valid UTF-8 text length of @text in bytes, or -1 if the text is nul-terminated Formats arguments according to @format, escaping all string and character arguments in the fashion of g_markup_escape_text(). This is useful when you want to insert literal strings into XML-style markup output, without having to worry that the strings might themselves contain markup. |[<!-- language="C" --> const char *store = "Fortnum & Mason"; const char *item = "Tea"; char *output; output = g_markup_printf_escaped ("<purchase>" "<store>%s</store>" "<item>%s</item>" "</purchase>", store, item); ]| newly allocated result from formatting operation. Free with g_free(). printf() style format string the arguments to insert in the format string Formats the data in @args according to @format, escaping all string and character arguments in the fashion of g_markup_escape_text(). See g_markup_printf_escaped(). newly allocated result from formatting operation. Free with g_free(). printf() style format string variable argument list, similar to vprintf() Checks whether the allocator used by g_malloc() is the system's malloc implementation. If it returns %TRUE memory allocated with malloc() can be used interchangeable with memory allocated using g_malloc(). This function is useful for avoiding an extra copy of allocated memory returned by a non-GLib-based API. A different allocator can be set using g_mem_set_vtable(). if %TRUE, malloc() and g_malloc() can be mixed. Outputs a summary of memory usage. It outputs the frequency of allocations of different sizes, the total number of bytes which have been allocated, the total number of bytes which have been freed, and the difference between the previous two values, i.e. the number of bytes still in use. Note that this function will not output anything unless you have previously installed the #glib_mem_profiler_table with g_mem_set_vtable(). Sets the #GMemVTable to use for memory allocation. You can use this to provide custom memory allocation routines. The @vtable only needs to provide malloc(), realloc(), and free() functions; GLib can provide default implementations of the others. The malloc() and realloc() implementations should return %NULL on failure, GLib will handle error-checking for you. @vtable is copied, so need not persist after this function has been called. Note that this function must be called before using any other GLib functions. table of memory allocation routines. Allocates @byte_size bytes of memory, and copies @byte_size bytes into it from @mem. If @mem is %NULL it returns %NULL. a pointer to the newly-allocated copy of the memory, or %NULL if @mem is %NULL. the memory to copy. the number of bytes to copy. Create a directory if it doesn't already exist. Create intermediate parent directories as needed, too. 0 if the directory already exists, or was successfully created. Returns -1 if an error occurred, with errno set. a pathname in the GLib file name encoding permissions to use for newly created directories Creates a temporary directory. See the mkdtemp() documentation on most UNIX-like systems. The parameter is a string that should follow the rules for mkdtemp() templates, i.e. contain the string "XXXXXX". g_mkdtemp() is slightly more flexible than mkdtemp() in that the sequence does not have to occur at the very end of the template and you can pass a @mode and additional @flags. The X string will be modified to form the name of a directory that didn't exist. The string should be in the GLib file name encoding. Most importantly, on Windows it should be in UTF-8. A pointer to @tmpl, which has been modified to hold the directory name. In case of errors, %NULL is returned and %errno will be set. template directory name Creates a temporary directory. See the mkdtemp() documentation on most UNIX-like systems. The parameter is a string that should follow the rules for mkdtemp() templates, i.e. contain the string "XXXXXX". g_mkdtemp() is slightly more flexible than mkdtemp() in that the sequence does not have to occur at the very end of the template and you can pass a @mode. The X string will be modified to form the name of a directory that didn't exist. The string should be in the GLib file name encoding. Most importantly, on Windows it should be in UTF-8. A pointer to @tmpl, which has been modified to hold the directory name. In case of errors, %NULL is returned, and %errno will be set. template directory name permissions to create the temporary directory with Opens a temporary file. See the mkstemp() documentation on most UNIX-like systems. The parameter is a string that should follow the rules for mkstemp() templates, i.e. contain the string "XXXXXX". g_mkstemp() is slightly more flexible than mkstemp() in that the sequence does not have to occur at the very end of the template. The X string will be modified to form the name of a file that didn't exist. The string should be in the GLib file name encoding. Most importantly, on Windows it should be in UTF-8. A file handle (as from open()) to the file opened for reading and writing. The file is opened in binary mode on platforms where there is a difference. The file handle should be closed with close(). In case of errors, -1 is returned and %errno will be set. template filename Opens a temporary file. See the mkstemp() documentation on most UNIX-like systems. The parameter is a string that should follow the rules for mkstemp() templates, i.e. contain the string "XXXXXX". g_mkstemp_full() is slightly more flexible than mkstemp() in that the sequence does not have to occur at the very end of the template and you can pass a @mode and additional @flags. The X string will be modified to form the name of a file that didn't exist. The string should be in the GLib file name encoding. Most importantly, on Windows it should be in UTF-8. A file handle (as from open()) to the file opened for reading and writing. The file handle should be closed with close(). In case of errors, -1 is returned and %errno will be set. template filename flags to pass to an open() call in addition to O_EXCL and O_CREAT, which are passed automatically permissions to create the temporary file with Set the pointer at the specified location to %NULL. the memory address of the pointer. Prompts the user with `[E]xit, [H]alt, show [S]tack trace or [P]roceed`. This function is intended to be used for debugging use only. The following example shows how it can be used together with the g_log() functions. |[<!-- language="C" --> #include <glib.h> static void log_handler (const gchar *log_domain, GLogLevelFlags log_level, const gchar *message, gpointer user_data) { g_log_default_handler (log_domain, log_level, message, user_data); g_on_error_query (MY_PROGRAM_NAME); } int main (int argc, char *argv[]) { g_log_set_handler (MY_LOG_DOMAIN, G_LOG_LEVEL_WARNING | G_LOG_LEVEL_ERROR | G_LOG_LEVEL_CRITICAL, log_handler, NULL); ... ]| If "[E]xit" is selected, the application terminates with a call to _exit(0). If "[S]tack" trace is selected, g_on_error_stack_trace() is called. This invokes gdb, which attaches to the current process and shows a stack trace. The prompt is then shown again. If "[P]roceed" is selected, the function returns. This function may cause different actions on non-UNIX platforms. the program name, needed by gdb for the "[S]tack trace" option. If @prg_name is %NULL, g_get_prgname() is called to get the program name (which will work correctly if gdk_init() or gtk_init() has been called) Invokes gdb, which attaches to the current process and shows a stack trace. Called by g_on_error_query() when the "[S]tack trace" option is selected. You can get the current process's program name with g_get_prgname(), assuming that you have called gtk_init() or gdk_init(). This function may cause different actions on non-UNIX platforms. the program name, needed by gdb for the "[S]tack trace" option Function to be called when starting a critical initialization section. The argument @location must point to a static 0-initialized variable that will be set to a value other than 0 at the end of the initialization section. In combination with g_once_init_leave() and the unique address @value_location, it can be ensured that an initialization section will be executed only once during a program's life time, and that concurrent threads are blocked until initialization completed. To be used in constructs like this: |[<!-- language="C" --> static gsize initialization_value = 0; if (g_once_init_enter (&initialization_value)) { gsize setup_value = 42; // initialization code here g_once_init_leave (&initialization_value, setup_value); } // use initialization_value here ]| %TRUE if the initialization section should be entered, %FALSE and blocks otherwise location of a static initializable variable containing 0 Counterpart to g_once_init_enter(). Expects a location of a static 0-initialized initialization variable, and an initialization value other than 0. Sets the variable to the initialization value, and releases concurrent threads blocking in g_once_init_enter() on this initialization variable. location of a static initializable variable containing 0 new non-0 value for *@value_location Parses a string containing debugging options into a %guint containing bit flags. This is used within GDK and GTK+ to parse the debug options passed on the command line or through environment variables. If @string is equal to "all", all flags are set. Any flags specified along with "all" in @string are inverted; thus, "all,foo,bar" or "foo,bar,all" sets all flags except those corresponding to "foo" and "bar". If @string is equal to "help", all the available keys in @keys are printed out to standard error. the combined set of bit flags. a list of debug options separated by colons, spaces, or commas, or %NULL. pointer to an array of #GDebugKey which associate strings with bit flags. the number of #GDebugKeys in the array. Gets the last component of the filename. If @file_name ends with a directory separator it gets the component before the last slash. If @file_name consists only of directory separators (and on Windows, possibly a drive letter), a single separator is returned. If @file_name is empty, it gets ".". a newly allocated string containing the last component of the filename the name of the file Gets the directory components of a file name. If the file name has no directory components "." is returned. The returned string should be freed when no longer needed. the directory components of the file the name of the file Returns %TRUE if the given @file_name is an absolute file name. Note that this is a somewhat vague concept on Windows. On POSIX systems, an absolute file name is well-defined. It always starts from the single root directory. For example "/usr/local". On Windows, the concepts of current drive and drive-specific current directory introduce vagueness. This function interprets as an absolute file name one that either begins with a directory separator such as "\Users\tml" or begins with the root on a drive, for example "C:\Windows". The first case also includes UNC paths such as "\\myserver\docs\foo". In all cases, either slashes or backslashes are accepted. Note that a file name relative to the current drive root does not truly specify a file uniquely over time and across processes, as the current drive is a per-process value and can be changed. File names relative the current directory on some specific drive, such as "D:foo/bar", are not interpreted as absolute by this function, but they obviously are not relative to the normal current directory as returned by getcwd() or g_get_current_dir() either. Such paths should be avoided, or need to be handled using Windows-specific code. %TRUE if @file_name is absolute a file name Returns a pointer into @file_name after the root component, i.e. after the "/" in UNIX or "C:\" under Windows. If @file_name is not an absolute path it returns %NULL. a pointer into @file_name after the root component a file name Matches a string against a compiled pattern. Passing the correct length of the string given is mandatory. The reversed string can be omitted by passing %NULL, this is more efficient if the reversed version of the string to be matched is not at hand, as g_pattern_match() will only construct it if the compiled pattern requires reverse matches. Note that, if the user code will (possibly) match a string against a multitude of patterns containing wildcards, chances are high that some patterns will require a reversed string. In this case, it's more efficient to provide the reversed string to avoid multiple constructions thereof in the various calls to g_pattern_match(). Note also that the reverse of a UTF-8 encoded string can in general not be obtained by g_strreverse(). This works only if the string does not contain any multibyte characters. GLib offers the g_utf8_strreverse() function to reverse UTF-8 encoded strings. %TRUE if @string matches @pspec a #GPatternSpec the length of @string (in bytes, i.e. strlen(), not g_utf8_strlen()) the UTF-8 encoded string to match the reverse of @string or %NULL Matches a string against a pattern given as a string. If this function is to be called in a loop, it's more efficient to compile the pattern once with g_pattern_spec_new() and call g_pattern_match_string() repeatedly. %TRUE if @string matches @pspec the UTF-8 encoded pattern the UTF-8 encoded string to match Matches a string against a compiled pattern. If the string is to be matched against more than one pattern, consider using g_pattern_match() instead while supplying the reversed string. %TRUE if @string matches @pspec a #GPatternSpec the UTF-8 encoded string to match This is equivalent to g_bit_lock, but working on pointers (or other pointer-sized values). For portability reasons, you may only lock on the bottom 32 bits of the pointer. a pointer to a #gpointer-sized value a bit value between 0 and 31 This is equivalent to g_bit_trylock, but working on pointers (or other pointer-sized values). For portability reasons, you may only lock on the bottom 32 bits of the pointer. %TRUE if the lock was acquired a pointer to a #gpointer-sized value a bit value between 0 and 31 This is equivalent to g_bit_unlock, but working on pointers (or other pointer-sized values). For portability reasons, you may only lock on the bottom 32 bits of the pointer. a pointer to a #gpointer-sized value a bit value between 0 and 31 Polls @fds, as with the poll() system call, but portably. (On systems that don't have poll(), it is emulated using select().) This is used internally by #GMainContext, but it can be called directly if you need to block until a file descriptor is ready, but don't want to run the full main loop. Each element of @fds is a #GPollFD describing a single file descriptor to poll. The %fd field indicates the file descriptor, and the %events field indicates the events to poll for. On return, the %revents fields will be filled with the events that actually occurred. On POSIX systems, the file descriptors in @fds can be any sort of file descriptor, but the situation is much more complicated on Windows. If you need to use g_poll() in code that has to run on Windows, the easiest solution is to construct all of your #GPollFDs with g_io_channel_win32_make_pollfd(). the number of entries in @fds whose %revents fields were filled in, or 0 if the operation timed out, or -1 on error or if the call was interrupted. file descriptors to poll the number of file descriptors in @fds amount of time to wait, in milliseconds, or -1 to wait forever Formats a string according to @format and prefix it to an existing error message. If @err is %NULL (ie: no error variable) then do nothing. If *@err is %NULL (ie: an error variable is present but there is no error condition) then also do nothing. Whether or not it makes sense to take advantage of this feature is up to you. a return location for a #GError, or %NULL printf()-style format string arguments to @format Outputs a formatted message via the print handler. The default print handler simply outputs the message to stdout, without appending a trailing new-line character. Typically, @format should end with its own new-line character. g_print() should not be used from within libraries for debugging messages, since it may be redirected by applications to special purpose message windows or even files. Instead, libraries should use g_log(), or the convenience functions g_message(), g_warning() and g_error(). the message format. See the printf() documentation the parameters to insert into the format string Outputs a formatted message via the error message handler. The default handler simply outputs the message to stderr, without appending a trailing new-line character. Typically, @format should end with its own new-line character. g_printerr() should not be used from within libraries. Instead g_log() should be used, or the convenience functions g_message(), g_warning() and g_error(). the message format. See the printf() documentation the parameters to insert into the format string An implementation of the standard printf() function which supports positional parameters, as specified in the Single Unix Specification. As with the standard printf(), this does not automatically append a trailing new-line character to the message, so typically @format should end with its own new-line character. the number of bytes printed. a standard printf() format string, but notice [string precision pitfalls][string-precision] the arguments to insert in the output. Calculates the maximum space needed to store the output of the sprintf() function. the maximum space needed to store the formatted string the format string. See the printf() documentation the parameters to be inserted into the format string If @dest is %NULL, free @src; otherwise, moves @src into *@dest. The error variable @dest points to must be %NULL. error return location error to move into the return location If @dest is %NULL, free @src; otherwise, moves @src into *@dest. *@dest must be %NULL. After the move, add a prefix as with g_prefix_error(). error return location error to move into the return location printf()-style format string arguments to @format This is just like the standard C qsort() function, but the comparison routine accepts a user data argument. This is guaranteed to be a stable sort since version 2.32. start of array to sort elements in the array size of each element function to compare elements data to pass to @compare_func Gets the #GQuark identifying the given (static) string. If the string does not currently have an associated #GQuark, a new #GQuark is created, linked to the given string. Note that this function is identical to g_quark_from_string() except that if a new #GQuark is created the string itself is used rather than a copy. This saves memory, but can only be used if the string will continue to exist until the program terminates. It can be used with statically allocated strings in the main program, but not with statically allocated memory in dynamically loaded modules, if you expect to ever unload the module again (e.g. do not use this function in GTK+ theme engines). the #GQuark identifying the string, or 0 if @string is %NULL a string Gets the #GQuark identifying the given string. If the string does not currently have an associated #GQuark, a new #GQuark is created, using a copy of the string. the #GQuark identifying the string, or 0 if @string is %NULL a string Gets the string associated with the given #GQuark. the string associated with the #GQuark a #GQuark. Gets the #GQuark associated with the given string, or 0 if string is %NULL or it has no associated #GQuark. If you want the GQuark to be created if it doesn't already exist, use g_quark_from_string() or g_quark_from_static_string(). the #GQuark associated with the string, or 0 if @string is %NULL or there is no #GQuark associated with it a string Returns a random #gdouble equally distributed over the range [0..1). a random number Returns a random #gdouble equally distributed over the range [@begin..@end). a random number lower closed bound of the interval upper open bound of the interval Return a random #guint32 equally distributed over the range [0..2^32-1]. a random number Returns a random #gint32 equally distributed over the range [@begin..@end-1]. a random number lower closed bound of the interval upper open bound of the interval Sets the seed for the global random number generator, which is used by the g_random_* functions, to @seed. a value to reinitialize the global random number generator Reallocates the memory pointed to by @mem, so that it now has space for @n_bytes bytes of memory. It returns the new address of the memory, which may have been moved. @mem may be %NULL, in which case it's considered to have zero-length. @n_bytes may be 0, in which case %NULL will be returned and @mem will be freed unless it is %NULL. the new address of the allocated memory the memory to reallocate new size of the memory in bytes This function is similar to g_realloc(), allocating (@n_blocks * @n_block_bytes) bytes, but care is taken to detect possible overflow during multiplication. the new address of the allocated memory the memory to reallocate the number of blocks to allocate the size of each block in bytes Checks whether @replacement is a valid replacement string (see g_regex_replace()), i.e. that all escape sequences in it are valid. If @has_references is not %NULL then @replacement is checked for pattern references. For instance, replacement text 'foo\n' does not contain references and may be evaluated without information about actual match, but '\0\1' (whole match followed by first subpattern) requires valid #GMatchInfo object. whether @replacement is a valid replacement string the replacement string location to store information about references in @replacement or %NULL Escapes the nul characters in @string to "\x00". It can be used to compile a regex with embedded nul characters. For completeness, @length can be -1 for a nul-terminated string. In this case the output string will be of course equal to @string. a newly-allocated escaped string the string to escape the length of @string Escapes the special characters used for regular expressions in @string, for instance "a.b*c" becomes "a\.b\*c". This function is useful to dynamically generate regular expressions. @string can contain nul characters that are replaced with "\0", in this case remember to specify the correct length of @string in @length. a newly-allocated escaped string the string to escape the length of @string, or -1 if @string is nul-terminated Scans for a match in @string for @pattern. This function is equivalent to g_regex_match() but it does not require to compile the pattern with g_regex_new(), avoiding some lines of code when you need just to do a match without extracting substrings, capture counts, and so on. If this function is to be called on the same @pattern more than once, it's more efficient to compile the pattern once with g_regex_new() and then use g_regex_match(). %TRUE if the string matched, %FALSE otherwise the regular expression the string to scan for matches compile options for the regular expression, or 0 match options, or 0 Breaks the string on the pattern, and returns an array of the tokens. If the pattern contains capturing parentheses, then the text for each of the substrings will also be returned. If the pattern does not match anywhere in the string, then the whole string is returned as the first token. This function is equivalent to g_regex_split() but it does not require to compile the pattern with g_regex_new(), avoiding some lines of code when you need just to do a split without extracting substrings, capture counts, and so on. If this function is to be called on the same @pattern more than once, it's more efficient to compile the pattern once with g_regex_new() and then use g_regex_split(). As a special case, the result of splitting the empty string "" is an empty vector, not a vector containing a single string. The reason for this special case is that being able to represent a empty vector is typically more useful than consistent handling of empty elements. If you do need to represent empty elements, you'll need to check for the empty string before calling this function. A pattern that can match empty strings splits @string into separate characters wherever it matches the empty string between characters. For example splitting "ab c" using as a separator "\s*", you will get "a", "b" and "c". a %NULL-terminated array of strings. Free it using g_strfreev() the regular expression the string to scan for matches compile options for the regular expression, or 0 match options, or 0 Resets the cache used for g_get_user_special_dir(), so that the latest on-disk version is used. Call this only if you just changed the data on disk yourself. Due to threadsafety issues this may cause leaking of strings that were previously returned from g_get_user_special_dir() that can't be freed. We ensure to only leak the data for the directories that actually changed value though. A wrapper for the POSIX rmdir() function. The rmdir() function deletes a directory from the filesystem. See your C library manual for more details about how rmdir() works on your system. 0 if the directory was successfully removed, -1 if an error occurred a pathname in the GLib file name encoding (UTF-8 on Windows) Moves the item pointed to by @src to the position indicated by @dest. After calling this function @dest will point to the position immediately after @src. It is allowed for @src and @dest to point into different sequences. a #GSequenceIter pointing to the item to move a #GSequenceIter pointing to the position to which the item is moved Inserts the (@begin, @end) range at the destination pointed to by ptr. The @begin and @end iters must point into the same sequence. It is allowed for @dest to point to a different sequence than the one pointed into by @begin and @end. If @dest is NULL, the range indicated by @begin and @end is removed from the sequence. If @dest iter points to a place within the (@begin, @end) range, the range does not move. a #GSequenceIter a #GSequenceIter a #GSequenceIter Removes the item pointed to by @iter. It is an error to pass the end iterator to this function. If the sequence has a data destroy function associated with it, this function is called on the data for the removed item. a #GSequenceIter Removes all items in the (@begin, @end) range. If the sequence has a data destroy function associated with it, this function is called on the data for the removed items. a #GSequenceIter a #GSequenceIter Changes the data for the item pointed to by @iter to be @data. If the sequence has a data destroy function associated with it, that function is called on the existing data that @iter pointed to. a #GSequenceIter new data for the item Swaps the items pointed to by @a and @b. It is allowed for @a and @b to point into difference sequences. a #GSequenceIter a #GSequenceIter Sets a human-readable name for the application. This name should be localized if possible, and is intended for display to the user. Contrast with g_set_prgname(), which sets a non-localized name. g_set_prgname() will be called automatically by gtk_init(), but g_set_application_name() will not. Note that for thread safety reasons, this function can only be called once. The application name will be used in contexts such as error messages, or when displaying an application's name in the task list. localized name of the application Does nothing if @err is %NULL; if @err is non-%NULL, then *@err must be %NULL. A new #GError is created and assigned to *@err. a return location for a #GError, or %NULL error domain error code printf()-style format args for @format Does nothing if @err is %NULL; if @err is non-%NULL, then *@err must be %NULL. A new #GError is created and assigned to *@err. Unlike g_set_error(), @message is not a printf()-style format string. Use this function if @message contains text you don't have control over, that could include printf() escape sequences. a return location for a #GError, or %NULL error domain error code error message Sets the name of the program. This name should not be localized, in contrast to g_set_application_name(). Note that for thread-safety reasons this function can only be called once. the name of the program. Sets the print handler. Any messages passed to g_print() will be output via the new handler. The default handler simply outputs the message to stdout. By providing your own handler you can redirect the output, to a GTK+ widget or a log file for example. the old print handler the new print handler Sets the handler for printing error messages. Any messages passed to g_printerr() will be output via the new handler. The default handler simply outputs the message to stderr. By providing your own handler you can redirect the output, to a GTK+ widget or a log file for example. the old error message handler the new error message handler Sets an environment variable. Both the variable's name and value should be in the GLib file name encoding. On UNIX, this means that they can be arbitrary byte strings. On Windows, they should be in UTF-8. Note that on some systems, when variables are overwritten, the memory used for the previous variables and its value isn't reclaimed. You should be mindful of the fact that environment variable handling in UNIX is not thread-safe, and your program may crash if one thread calls g_setenv() while another thread is calling getenv(). (And note that many functions, such as gettext(), call getenv() internally.) This function is only safe to use at the very start of your program, before creating any other threads (or creating objects that create worker threads of their own). If you need to set up the environment for a child process, you can use g_get_environ() to get an environment array, modify that with g_environ_setenv() and g_environ_unsetenv(), and then pass that array directly to execvpe(), g_spawn_async(), or the like. %FALSE if the environment variable couldn't be set. the environment variable to set, must not contain '='. the value for to set the variable to. whether to change the variable if it already exists. Parses a command line into an argument vector, in much the same way the shell would, but without many of the expansions the shell would perform (variable expansion, globs, operators, filename expansion, etc. are not supported). The results are defined to be the same as those you would get from a UNIX98 /bin/sh, as long as the input contains none of the unsupported shell expansions. If the input does contain such expansions, they are passed through literally. Possible errors are those from the #G_SHELL_ERROR domain. Free the returned vector with g_strfreev(). %TRUE on success, %FALSE if error set command line to parse return location for number of args, or %NULL return location for array of args, or %NULL Quotes a string so that the shell (/bin/sh) will interpret the quoted string to mean @unquoted_string. If you pass a filename to the shell, for example, you should first quote it with this function. The return value must be freed with g_free(). The quoting style used is undefined (single or double quotes may be used). quoted string a literal string Unquotes a string as the shell (/bin/sh) would. Only handles quotes; if a string contains file globs, arithmetic operators, variables, backticks, redirections, or other special-to-the-shell features, the result will be different from the result a real shell would produce (the variables, backticks, etc. will be passed through literally instead of being expanded). This function is guaranteed to succeed if applied to the result of g_shell_quote(). If it fails, it returns %NULL and sets the error. The @quoted_string need not actually contain quoted or escaped text; g_shell_unquote() simply goes through the string and unquotes/unescapes anything that the shell would. Both single and double quotes are handled, as are escapes including escaped newlines. The return value must be freed with g_free(). Possible errors are in the #G_SHELL_ERROR domain. Shell quoting rules are a bit strange. Single quotes preserve the literal string exactly. escape sequences are not allowed; not even \' - if you want a ' in the quoted text, you have to do something like 'foo'\''bar'. Double quotes allow $, `, ", \, and newline to be escaped with backslash. Otherwise double quotes preserve things literally. an unquoted string shell-quoted string Allocates a block of memory from the slice allocator. The block adress handed out can be expected to be aligned to at least 1 * sizeof (void*), though in general slices are 2 * sizeof (void*) bytes aligned, if a malloc() fallback implementation is used instead, the alignment may be reduced in a libc dependent fashion. Note that the underlying slice allocation mechanism can be changed with the [`G_SLICE=always-malloc`][G_SLICE] environment variable. a pointer to the allocated memory block the number of bytes to allocate Allocates a block of memory via g_slice_alloc() and initializes the returned memory to 0. Note that the underlying slice allocation mechanism can be changed with the [`G_SLICE=always-malloc`][G_SLICE] environment variable. a pointer to the allocated block the number of bytes to allocate Allocates a block of memory from the slice allocator and copies @block_size bytes into it from @mem_block. a pointer to the allocated memory block the number of bytes to allocate the memory to copy Frees a block of memory. The memory must have been allocated via g_slice_alloc() or g_slice_alloc0() and the @block_size has to match the size specified upon allocation. Note that the exact release behaviour can be changed with the [`G_DEBUG=gc-friendly`][G_DEBUG] environment variable, also see [`G_SLICE`][G_SLICE] for related debugging options. the size of the block a pointer to the block to free Frees a linked list of memory blocks of structure type @type. The memory blocks must be equal-sized, allocated via g_slice_alloc() or g_slice_alloc0() and linked together by a @next pointer (similar to #GSList). The offset of the @next field in each block is passed as third argument. Note that the exact release behaviour can be changed with the [`G_DEBUG=gc-friendly`][G_DEBUG] environment variable, also see [`G_SLICE`][G_SLICE] for related debugging options. the size of the blocks a pointer to the first block of the chain the offset of the @next field in the blocks A safer form of the standard sprintf() function. The output is guaranteed to not exceed @n characters (including the terminating nul character), so it is easy to ensure that a buffer overflow cannot occur. See also g_strdup_printf(). In versions of GLib prior to 1.2.3, this function may return -1 if the output was truncated, and the truncated string may not be nul-terminated. In versions prior to 1.3.12, this function returns the length of the output string. The return value of g_snprintf() conforms to the snprintf() function as standardized in ISO C99. Note that this is different from traditional snprintf(), which returns the length of the output string. The format string may contain positional parameters, as specified in the Single Unix Specification. the number of bytes which would be produced if the buffer was large enough. the buffer to hold the output. the maximum number of bytes to produce (including the terminating nul character). a standard printf() format string, but notice [string precision pitfalls][string-precision] the arguments to insert in the output. Removes the source with the given id from the default main context. The id of a #GSource is given by g_source_get_id(), or will be returned by the functions g_source_attach(), g_idle_add(), g_idle_add_full(), g_timeout_add(), g_timeout_add_full(), g_child_watch_add(), g_child_watch_add_full(), g_io_add_watch(), and g_io_add_watch_full(). See also g_source_destroy(). You must use g_source_destroy() for sources added to a non-default main context. It is a programmer error to attempt to remove a non-existent source. More specifically: source IDs can be reissued after a source has been destroyed and therefore it is never valid to use this function with a source ID which may have already been removed. An example is when scheduling an idle to run in another thread with g_idle_add(): the idle may already have run and been removed by the time this function is called on its (now invalid) source ID. This source ID may have been reissued, leading to the operation being performed against the wrong source. For historical reasons, this function always returns %TRUE the ID of the source to remove. Removes a source from the default main loop context given the source functions and user data. If multiple sources exist with the same source functions and user data, only one will be destroyed. %TRUE if a source was found and removed. The @source_funcs passed to g_source_new() the user data for the callback Removes a source from the default main loop context given the user data for the callback. If multiple sources exist with the same user data, only one will be destroyed. %TRUE if a source was found and removed. the user_data for the callback. Sets the name of a source using its ID. This is a convenience utility to set source names from the return value of g_idle_add(), g_timeout_add(), etc. It is a programmer error to attempt to set the name of a non-existent source. More specifically: source IDs can be reissued after a source has been destroyed and therefore it is never valid to use this function with a source ID which may have already been removed. An example is when scheduling an idle to run in another thread with g_idle_add(): the idle may already have run and been removed by the time this function is called on its (now invalid) source ID. This source ID may have been reissued, leading to the operation being performed against the wrong source. a #GSource ID debug name for the source Gets the smallest prime number from a built-in array of primes which is larger than @num. This is used within GLib to calculate the optimum size of a #GHashTable. The built-in array of primes ranges from 11 to 13845163 such that each prime is approximately 1.5-2 times the previous prime. the smallest prime number from a built-in array of primes which is larger than @num a #guint See g_spawn_async_with_pipes() for a full description; this function simply calls the g_spawn_async_with_pipes() without any pipes. You should call g_spawn_close_pid() on the returned child process reference when you don't need it any more. If you are writing a GTK+ application, and the program you are spawning is a graphical application, too, then you may want to use gdk_spawn_on_screen() instead to ensure that the spawned program opens its windows on the right screen. Note that the returned @child_pid on Windows is a handle to the child process and not its identifier. Process handles and process identifiers are different concepts on Windows. %TRUE on success, %FALSE if error is set child's current working directory, or %NULL to inherit parent's child's argument vector child's environment, or %NULL to inherit parent's flags from #GSpawnFlags function to run in the child just before exec() user data for @child_setup return location for child process reference, or %NULL Executes a child program asynchronously (your program will not block waiting for the child to exit). The child program is specified by the only argument that must be provided, @argv. @argv should be a %NULL-terminated array of strings, to be passed as the argument vector for the child. The first string in @argv is of course the name of the program to execute. By default, the name of the program must be a full path. If @flags contains the %G_SPAWN_SEARCH_PATH flag, the `PATH` environment variable is used to search for the executable. If @flags contains the %G_SPAWN_SEARCH_PATH_FROM_ENVP flag, the `PATH` variable from @envp is used to search for the executable. If both the %G_SPAWN_SEARCH_PATH and %G_SPAWN_SEARCH_PATH_FROM_ENVP flags are set, the `PATH` variable from @envp takes precedence over the environment variable. If the program name is not a full path and %G_SPAWN_SEARCH_PATH flag is not used, then the program will be run from the current directory (or @working_directory, if specified); this might be unexpected or even dangerous in some cases when the current directory is world-writable. On Windows, note that all the string or string vector arguments to this function and the other g_spawn*() functions are in UTF-8, the GLib file name encoding. Unicode characters that are not part of the system codepage passed in these arguments will be correctly available in the spawned program only if it uses wide character API to retrieve its command line. For C programs built with Microsoft's tools it is enough to make the program have a wmain() instead of main(). wmain() has a wide character argument vector as parameter. At least currently, mingw doesn't support wmain(), so if you use mingw to develop the spawned program, it will have to call the undocumented function __wgetmainargs() to get the wide character argument vector and environment. See gspawn-win32-helper.c in the GLib sources or init.c in the mingw runtime sources for a prototype for that function. Alternatively, you can retrieve the Win32 system level wide character command line passed to the spawned program using the GetCommandLineW() function. On Windows the low-level child process creation API CreateProcess() doesn't use argument vectors, but a command line. The C runtime library's spawn*() family of functions (which g_spawn_async_with_pipes() eventually calls) paste the argument vector elements together into a command line, and the C runtime startup code does a corresponding reconstruction of an argument vector from the command line, to be passed to main(). Complications arise when you have argument vector elements that contain spaces of double quotes. The spawn*() functions don't do any quoting or escaping, but on the other hand the startup code does do unquoting and unescaping in order to enable receiving arguments with embedded spaces or double quotes. To work around this asymmetry, g_spawn_async_with_pipes() will do quoting and escaping on argument vector elements that need it before calling the C runtime spawn() function. The returned @child_pid on Windows is a handle to the child process, not its identifier. Process handles and process identifiers are different concepts on Windows. @envp is a %NULL-terminated array of strings, where each string has the form `KEY=VALUE`. This will become the child's environment. If @envp is %NULL, the child inherits its parent's environment. @flags should be the bitwise OR of any flags you want to affect the function's behaviour. The %G_SPAWN_DO_NOT_REAP_CHILD means that the child will not automatically be reaped; you must use a child watch to be notified about the death of the child process. Eventually you must call g_spawn_close_pid() on the @child_pid, in order to free resources which may be associated with the child process. (On Unix, using a child watch is equivalent to calling waitpid() or handling the %SIGCHLD signal manually. On Windows, calling g_spawn_close_pid() is equivalent to calling CloseHandle() on the process handle returned in @child_pid). See g_child_watch_add(). %G_SPAWN_LEAVE_DESCRIPTORS_OPEN means that the parent's open file descriptors will be inherited by the child; otherwise all descriptors except stdin/stdout/stderr will be closed before calling exec() in the child. %G_SPAWN_SEARCH_PATH means that @argv[0] need not be an absolute path, it will be looked for in the `PATH` environment variable. %G_SPAWN_SEARCH_PATH_FROM_ENVP means need not be an absolute path, it will be looked for in the `PATH` variable from @envp. If both %G_SPAWN_SEARCH_PATH and %G_SPAWN_SEARCH_PATH_FROM_ENVP are used, the value from @envp takes precedence over the environment. %G_SPAWN_STDOUT_TO_DEV_NULL means that the child's standard output will be discarded, instead of going to the same location as the parent's standard output. If you use this flag, @standard_output must be %NULL. %G_SPAWN_STDERR_TO_DEV_NULL means that the child's standard error will be discarded, instead of going to the same location as the parent's standard error. If you use this flag, @standard_error must be %NULL. %G_SPAWN_CHILD_INHERITS_STDIN means that the child will inherit the parent's standard input (by default, the child's standard input is attached to /dev/null). If you use this flag, @standard_input must be %NULL. %G_SPAWN_FILE_AND_ARGV_ZERO means that the first element of @argv is the file to execute, while the remaining elements are the actual argument vector to pass to the file. Normally g_spawn_async_with_pipes() uses @argv[0] as the file to execute, and passes all of @argv to the child. @child_setup and @user_data are a function and user data. On POSIX platforms, the function is called in the child after GLib has performed all the setup it plans to perform (including creating pipes, closing file descriptors, etc.) but before calling exec(). That is, @child_setup is called just before calling exec() in the child. Obviously actions taken in this function will only affect the child, not the parent. On Windows, there is no separate fork() and exec() functionality. Child processes are created and run with a single API call, CreateProcess(). There is no sensible thing @child_setup could be used for on Windows so it is ignored and not called. If non-%NULL, @child_pid will on Unix be filled with the child's process ID. You can use the process ID to send signals to the child, or to use g_child_watch_add() (or waitpid()) if you specified the %G_SPAWN_DO_NOT_REAP_CHILD flag. On Windows, @child_pid will be filled with a handle to the child process only if you specified the %G_SPAWN_DO_NOT_REAP_CHILD flag. You can then access the child process using the Win32 API, for example wait for its termination with the WaitFor*() functions, or examine its exit code with GetExitCodeProcess(). You should close the handle with CloseHandle() or g_spawn_close_pid() when you no longer need it. If non-%NULL, the @standard_input, @standard_output, @standard_error locations will be filled with file descriptors for writing to the child's standard input or reading from its standard output or standard error. The caller of g_spawn_async_with_pipes() must close these file descriptors when they are no longer in use. If these parameters are %NULL, the corresponding pipe won't be created. If @standard_input is NULL, the child's standard input is attached to /dev/null unless %G_SPAWN_CHILD_INHERITS_STDIN is set. If @standard_error is NULL, the child's standard error goes to the same location as the parent's standard error unless %G_SPAWN_STDERR_TO_DEV_NULL is set. If @standard_output is NULL, the child's standard output goes to the same location as the parent's standard output unless %G_SPAWN_STDOUT_TO_DEV_NULL is set. @error can be %NULL to ignore errors, or non-%NULL to report errors. If an error is set, the function returns %FALSE. Errors are reported even if they occur in the child (for example if the executable in @argv[0] is not found). Typically the `message` field of returned errors should be displayed to users. Possible errors are those from the #G_SPAWN_ERROR domain. If an error occurs, @child_pid, @standard_input, @standard_output, and @standard_error will not be filled with valid values. If @child_pid is not %NULL and an error does not occur then the returned process reference must be closed using g_spawn_close_pid(). If you are writing a GTK+ application, and the program you are spawning is a graphical application, too, then you may want to use gdk_spawn_on_screen_with_pipes() instead to ensure that the spawned program opens its windows on the right screen. %TRUE on success, %FALSE if an error was set child's current working directory, or %NULL to inherit parent's, in the GLib file name encoding child's argument vector, in the GLib file name encoding child's environment, or %NULL to inherit parent's, in the GLib file name encoding flags from #GSpawnFlags function to run in the child just before exec() user data for @child_setup return location for child process ID, or %NULL return location for file descriptor to write to child's stdin, or %NULL return location for file descriptor to read child's stdout, or %NULL return location for file descriptor to read child's stderr, or %NULL Set @error if @exit_status indicates the child exited abnormally (e.g. with a nonzero exit code, or via a fatal signal). The g_spawn_sync() and g_child_watch_add() family of APIs return an exit status for subprocesses encoded in a platform-specific way. On Unix, this is guaranteed to be in the same format waitpid() returns, and on Windows it is guaranteed to be the result of GetExitCodeProcess(). Prior to the introduction of this function in GLib 2.34, interpreting @exit_status required use of platform-specific APIs, which is problematic for software using GLib as a cross-platform layer. Additionally, many programs simply want to determine whether or not the child exited successfully, and either propagate a #GError or print a message to standard error. In that common case, this function can be used. Note that the error message in @error will contain human-readable information about the exit status. The @domain and @code of @error have special semantics in the case where the process has an "exit code", as opposed to being killed by a signal. On Unix, this happens if WIFEXITED() would be true of @exit_status. On Windows, it is always the case. The special semantics are that the actual exit code will be the code set in @error, and the domain will be %G_SPAWN_EXIT_ERROR. This allows you to differentiate between different exit codes. If the process was terminated by some means other than an exit status, the domain will be %G_SPAWN_ERROR, and the code will be %G_SPAWN_ERROR_FAILED. This function just offers convenience; you can of course also check the available platform via a macro such as %G_OS_UNIX, and use WIFEXITED() and WEXITSTATUS() on @exit_status directly. Do not attempt to scan or parse the error message string; it may be translated and/or change in future versions of GLib. %TRUE if child exited successfully, %FALSE otherwise (and @error will be set) An exit code as returned from g_spawn_sync() On some platforms, notably Windows, the #GPid type represents a resource which must be closed to prevent resource leaking. g_spawn_close_pid() is provided for this purpose. It should be used on all platforms, even though it doesn't do anything under UNIX. The process reference to close A simple version of g_spawn_async() that parses a command line with g_shell_parse_argv() and passes it to g_spawn_async(). Runs a command line in the background. Unlike g_spawn_async(), the %G_SPAWN_SEARCH_PATH flag is enabled, other flags are not. Note that %G_SPAWN_SEARCH_PATH can have security implications, so consider using g_spawn_async() directly if appropriate. Possible errors are those from g_shell_parse_argv() and g_spawn_async(). The same concerns on Windows apply as for g_spawn_command_line_sync(). %TRUE on success, %FALSE if error is set a command line A simple version of g_spawn_sync() with little-used parameters removed, taking a command line instead of an argument vector. See g_spawn_sync() for full details. @command_line will be parsed by g_shell_parse_argv(). Unlike g_spawn_sync(), the %G_SPAWN_SEARCH_PATH flag is enabled. Note that %G_SPAWN_SEARCH_PATH can have security implications, so consider using g_spawn_sync() directly if appropriate. Possible errors are those from g_spawn_sync() and those from g_shell_parse_argv(). If @exit_status is non-%NULL, the platform-specific exit status of the child is stored there; see the documentation of g_spawn_check_exit_status() for how to use and interpret this. On Windows, please note the implications of g_shell_parse_argv() parsing @command_line. Parsing is done according to Unix shell rules, not Windows command interpreter rules. Space is a separator, and backslashes are special. Thus you cannot simply pass a @command_line containing canonical Windows paths, like "c:\\program files\\app\\app.exe", as the backslashes will be eaten, and the space will act as a separator. You need to enclose such paths with single quotes, like "'c:\\program files\\app\\app.exe' 'e:\\folder\\argument.txt'". %TRUE on success, %FALSE if an error was set a command line return location for child output return location for child errors return location for child exit status, as returned by waitpid() Executes a child synchronously (waits for the child to exit before returning). All output from the child is stored in @standard_output and @standard_error, if those parameters are non-%NULL. Note that you must set the %G_SPAWN_STDOUT_TO_DEV_NULL and %G_SPAWN_STDERR_TO_DEV_NULL flags when passing %NULL for @standard_output and @standard_error. If @exit_status is non-%NULL, the platform-specific exit status of the child is stored there; see the documentation of g_spawn_check_exit_status() for how to use and interpret this. Note that it is invalid to pass %G_SPAWN_DO_NOT_REAP_CHILD in @flags. If an error occurs, no data is returned in @standard_output, @standard_error, or @exit_status. This function calls g_spawn_async_with_pipes() internally; see that function for full details on the other parameters and details on how these functions work on Windows. %TRUE on success, %FALSE if an error was set child's current working directory, or %NULL to inherit parent's child's argument vector child's environment, or %NULL to inherit parent's flags from #GSpawnFlags function to run in the child just before exec() user data for @child_setup return location for child output, or %NULL return location for child error messages, or %NULL return location for child exit status, as returned by waitpid(), or %NULL An implementation of the standard sprintf() function which supports positional parameters, as specified in the Single Unix Specification. Note that it is usually better to use g_snprintf(), to avoid the risk of buffer overflow. See also g_strdup_printf(). the number of bytes printed. A pointer to a memory buffer to contain the resulting string. It is up to the caller to ensure that the allocated buffer is large enough to hold the formatted result a standard printf() format string, but notice [string precision pitfalls][string-precision] the arguments to insert in the output. Copies a nul-terminated string into the dest buffer, include the trailing nul, and return a pointer to the trailing nul byte. This is useful for concatenating multiple strings together without having to repeatedly scan for the end. a pointer to trailing nul byte. destination buffer. source string. Compares two strings for byte-by-byte equality and returns %TRUE if they are equal. It can be passed to g_hash_table_new() as the @key_equal_func parameter, when using non-%NULL strings as keys in a #GHashTable. Note that this function is primarily meant as a hash table comparison function. For a general-purpose, %NULL-safe string comparison function, see g_strcmp0(). %TRUE if the two keys match a key a key to compare with @v1 Looks whether the string @str begins with @prefix. %TRUE if @str begins with @prefix, %FALSE otherwise. a nul-terminated string the nul-terminated prefix to look for Looks whether the string @str ends with @suffix. %TRUE if @str end with @suffix, %FALSE otherwise. a nul-terminated string the nul-terminated suffix to look for Converts a string to a hash value. This function implements the widely used "djb" hash apparently posted by Daniel Bernstein to comp.lang.c some time ago. The 32 bit unsigned hash value starts at 5381 and for each byte 'c' in the string, is updated: `hash = hash * 33 + c`. This function uses the signed value of each byte. It can be passed to g_hash_table_new() as the @hash_func parameter, when using non-%NULL strings as keys in a #GHashTable. a hash value corresponding to the key a string key Determines if a string is pure ASCII. A string is pure ASCII if it contains no bytes with the high bit set. %TRUE if @str is ASCII a string Checks if a search conducted for @search_term should match @potential_hit. This function calls g_str_tokenize_and_fold() on both @search_term and @potential_hit. ASCII alternates are never taken for @search_term but will be taken for @potential_hit according to the value of @accept_alternates. A hit occurs when each folded token in @search_term is a prefix of a folded token from @potential_hit. Depending on how you're performing the search, it will typically be faster to call g_str_tokenize_and_fold() on each string in your corpus and build an index on the returned folded tokens, then call g_str_tokenize_and_fold() on the search term and perform lookups into that index. As some examples, searching for "fred" would match the potential hit "Smith, Fred" and also "Frédéric". Searching for "Fréd" would match "Frédéric" but not "Frederic" (due to the one-directional nature of accent matching). Searching "fo" would match "Foo" and "Bar Foo Baz", but not "SFO" (because no word as "fo" as a prefix). %TRUE if @potential_hit is a hit the search term from the user the text that may be a hit %TRUE to accept ASCII alternates Transliterate @str to plain ASCII. For best results, @str should be in composed normalised form. This function performs a reasonably good set of character replacements. The particular set of replacements that is done may change by version or even by runtime environment. If the source language of @str is known, it can used to improve the accuracy of the translation by passing it as @from_locale. It should be a valid POSIX locale string (of the form "language[_territory][.codeset][@modifier]"). If @from_locale is %NULL then the current locale is used. If you want to do translation for no specific locale, and you want it to be done independently of the currently locale, specify "C" for @from_locale. a string in plain ASCII a string, in UTF-8 the source locale, if known Tokenises @string and performs folding on each token. A token is a non-empty sequence of alphanumeric characters in the source string, separated by non-alphanumeric characters. An "alphanumeric" character for this purpose is one that matches g_unichar_isalnum() or g_unichar_ismark(). Each token is then (Unicode) normalised and case-folded. If @ascii_alternates is non-%NULL and some of the returned tokens contain non-ASCII characters, ASCII alternatives will be generated. The number of ASCII alternatives that are generated and the method for doing so is unspecified, but @translit_locale (if specified) may improve the transliteration if the language of the source string is known. the folded tokens a string the language code (like 'de' or 'en_GB') from which @string originates a return location for ASCII alternates For each character in @string, if the character is not in @valid_chars, replaces the character with @substitutor. Modifies @string in place, and return @string itself, not a copy. The return value is to allow nesting such as |[<!-- language="C" --> g_ascii_strup (g_strcanon (str, "abc", '?')) ]| @string a nul-terminated array of bytes bytes permitted in @string replacement character for disallowed bytes A case-insensitive string comparison, corresponding to the standard strcasecmp() function on platforms which support it. See g_strncasecmp() for a discussion of why this function is deprecated and how to replace it. 0 if the strings match, a negative value if @s1 < @s2, or a positive value if @s1 > @s2. a string a string to compare with @s1 Removes trailing whitespace from a string. This function doesn't allocate or reallocate any memory; it modifies @string in place. Therefore, it cannot be used on statically allocated strings. The pointer to @string is returned to allow the nesting of functions. Also see g_strchug() and g_strstrip(). @string a string to remove the trailing whitespace from Removes leading whitespace from a string, by moving the rest of the characters forward. This function doesn't allocate or reallocate any memory; it modifies @string in place. Therefore, it cannot be used on statically allocated strings. The pointer to @string is returned to allow the nesting of functions. Also see g_strchomp() and g_strstrip(). @string a string to remove the leading whitespace from Compares @str1 and @str2 like strcmp(). Handles %NULL gracefully by sorting it before non-%NULL strings. Comparing two %NULL pointers returns 0. an integer less than, equal to, or greater than zero, if @str1 is <, == or > than @str2. a C string or %NULL another C string or %NULL Replaces all escaped characters with their one byte equivalent. This function does the reverse conversion of g_strescape(). a newly-allocated copy of @source with all escaped character compressed a string to compress Concatenates all of the given strings into one long string. The returned string should be freed with g_free() when no longer needed. The variable argument list must end with %NULL. If you forget the %NULL, g_strconcat() will start appending random memory junk to your string. Note that this function is usually not the right function to use to assemble a translated message from pieces, since proper translation often requires the pieces to be reordered. a newly-allocated string containing all the string arguments the first string to add, which must not be %NULL a %NULL-terminated list of strings to append to the string Converts any delimiter characters in @string to @new_delimiter. Any characters in @string which are found in @delimiters are changed to the @new_delimiter character. Modifies @string in place, and returns @string itself, not a copy. The return value is to allow nesting such as |[<!-- language="C" --> g_ascii_strup (g_strdelimit (str, "abc", '?')) ]| @string the string to convert a string containing the current delimiters, or %NULL to use the standard delimiters defined in #G_STR_DELIMITERS the new delimiter character Converts a string to lower case. This function is totally broken for the reasons discussed in the g_strncasecmp() docs - use g_ascii_strdown() or g_utf8_strdown() instead. the string the string to convert. Duplicates a string. If @str is %NULL it returns %NULL. The returned string should be freed with g_free() when no longer needed. a newly-allocated copy of @str the string to duplicate Similar to the standard C sprintf() function but safer, since it calculates the maximum space required and allocates memory to hold the result. The returned string should be freed with g_free() when no longer needed. a newly-allocated string holding the result a standard printf() format string, but notice [string precision pitfalls][string-precision] the parameters to insert into the format string Similar to the standard C vsprintf() function but safer, since it calculates the maximum space required and allocates memory to hold the result. The returned string should be freed with g_free() when no longer needed. See also g_vasprintf(), which offers the same functionality, but additionally returns the length of the allocated string. a newly-allocated string holding the result a standard printf() format string, but notice [string precision pitfalls][string-precision] the list of parameters to insert into the format string Copies %NULL-terminated array of strings. The copy is a deep copy; the new array should be freed by first freeing each string, then the array itself. g_strfreev() does this for you. If called on a %NULL value, g_strdupv() simply returns %NULL. a new %NULL-terminated array of strings. a %NULL-terminated array of strings Returns a string corresponding to the given error code, e.g. "no such process". You should use this function in preference to strerror(), because it returns a string in UTF-8 encoding, and since not all platforms support the strerror() function. a UTF-8 string describing the error code. If the error code is unknown, it returns "unknown error (<code>)". the system error number. See the standard C %errno documentation Escapes the special characters '\b', '\f', '\n', '\r', '\t', '\v', '\' and '&quot;' in the string @source by inserting a '\' before them. Additionally all characters in the range 0x01-0x1F (everything below SPACE) and in the range 0x7F-0xFF (all non-ASCII chars) are replaced with a '\' followed by their octal representation. Characters supplied in @exceptions are not escaped. g_strcompress() does the reverse conversion. a newly-allocated copy of @source with certain characters escaped. See above. a string to escape a string of characters not to escape in @source Frees a %NULL-terminated array of strings, and the array itself. If called on a %NULL value, g_strfreev() simply returns. a %NULL-terminated array of strings to free Creates a new #GString, initialized with the given string. the new #GString the initial text to copy into the string, or %NULL to start with an empty string. Creates a new #GString with @len bytes of the @init buffer. Because a length is provided, @init need not be nul-terminated, and can contain embedded nul bytes. Since this function does not stop at nul bytes, it is the caller's responsibility to ensure that @init has at least @len addressable bytes. a new #GString initial contents of the string length of @init to use Creates a new #GString, with enough space for @dfl_size bytes. This is useful if you are going to add a lot of text to the string and don't want it to be reallocated too often. the new #GString the default size of the space allocated to hold the string An auxiliary function for gettext() support (see Q_()). @msgval, unless @msgval is identical to @msgid and contains a '|' character, in which case a pointer to the substring of msgid after the first '|' character is returned. a string another string Joins a number of strings together to form one long string, with the optional @separator inserted between each of them. The returned string should be freed with g_free(). a newly-allocated string containing all of the strings joined together, with @separator between them a string to insert between each of the strings, or %NULL a %NULL-terminated list of strings to join Joins a number of strings together to form one long string, with the optional @separator inserted between each of them. The returned string should be freed with g_free(). a newly-allocated string containing all of the strings joined together, with @separator between them a string to insert between each of the strings, or %NULL a %NULL-terminated array of strings to join Portability wrapper that calls strlcat() on systems which have it, and emulates it otherwise. Appends nul-terminated @src string to @dest, guaranteeing nul-termination for @dest. The total size of @dest won't exceed @dest_size. At most @dest_size - 1 characters will be copied. Unlike strncat(), @dest_size is the full size of dest, not the space left over. This function does not allocate memory. It always nul-terminates (unless @dest_size == 0 or there were no nul characters in the @dest_size characters of dest to start with). Caveat: this is supposedly a more secure alternative to strcat() or strncat(), but for real security g_strconcat() is harder to mess up. size of attempted result, which is MIN (dest_size, strlen (original dest)) + strlen (src), so if retval >= dest_size, truncation occurred. destination buffer, already containing one nul-terminated string source buffer length of @dest buffer in bytes (not length of existing string inside @dest) Portability wrapper that calls strlcpy() on systems which have it, and emulates strlcpy() otherwise. Copies @src to @dest; @dest is guaranteed to be nul-terminated; @src must be nul-terminated; @dest_size is the buffer size, not the number of bytes to copy. At most @dest_size - 1 characters will be copied. Always nul-terminates (unless @dest_size is 0). This function does not allocate memory. Unlike strncpy(), this function doesn't pad @dest (so it's often faster). It returns the size of the attempted result, strlen (src), so if @retval >= @dest_size, truncation occurred. Caveat: strlcpy() is supposedly more secure than strcpy() or strncpy(), but if you really want to avoid screwups, g_strdup() is an even better idea. length of @src destination buffer source buffer length of @dest in bytes A case-insensitive string comparison, corresponding to the standard strncasecmp() function on platforms which support it. It is similar to g_strcasecmp() except it only compares the first @n characters of the strings. The problem with g_strncasecmp() is that it does the comparison by calling toupper()/tolower(). These functions are locale-specific and operate on single bytes. However, it is impossible to handle things correctly from an internationalization standpoint by operating on bytes, since characters may be multibyte. Thus g_strncasecmp() is broken if your string is guaranteed to be ASCII, since it is locale-sensitive, and it's broken if your string is localized, since it doesn't work on many encodings at all, including UTF-8, EUC-JP, etc. There are therefore two replacement techniques: g_ascii_strncasecmp(), which only works on ASCII and is not locale-sensitive, and g_utf8_casefold() followed by strcmp() on the resulting strings, which is good for case-insensitive sorting of UTF-8. 0 if the strings match, a negative value if @s1 < @s2, or a positive value if @s1 > @s2. a string a string to compare with @s1 the maximum number of characters to compare Duplicates the first @n bytes of a string, returning a newly-allocated buffer @n + 1 bytes long which will always be nul-terminated. If @str is less than @n bytes long the buffer is padded with nuls. If @str is %NULL it returns %NULL. The returned value should be freed when no longer needed. To copy a number of characters from a UTF-8 encoded string, use g_utf8_strncpy() instead. a newly-allocated buffer containing the first @n bytes of @str, nul-terminated the string to duplicate the maximum number of bytes to copy from @str Creates a new string @length bytes long filled with @fill_char. The returned string should be freed when no longer needed. a newly-allocated string filled the @fill_char the length of the new string the byte to fill the string with Reverses all of the bytes in a string. For example, `g_strreverse ("abcdef")` will result in "fedcba". Note that g_strreverse() doesn't work on UTF-8 strings containing multibyte characters. For that purpose, use g_utf8_strreverse(). the same pointer passed in as @string the string to reverse Searches the string @haystack for the last occurrence of the string @needle. a pointer to the found occurrence, or %NULL if not found. a nul-terminated string the nul-terminated string to search for Searches the string @haystack for the last occurrence of the string @needle, limiting the length of the search to @haystack_len. a pointer to the found occurrence, or %NULL if not found. a nul-terminated string the maximum length of @haystack the nul-terminated string to search for Returns a string describing the given signal, e.g. "Segmentation fault". You should use this function in preference to strsignal(), because it returns a string in UTF-8 encoding, and since not all platforms support the strsignal() function. a UTF-8 string describing the signal. If the signal is unknown, it returns "unknown signal (<signum>)". the signal number. See the `signal` documentation Splits a string into a maximum of @max_tokens pieces, using the given @delimiter. If @max_tokens is reached, the remainder of @string is appended to the last token. As an example, the result of g_strsplit (":a:bc::d:", ":", -1) is a %NULL-terminated vector containing the six strings "", "a", "bc", "", "d" and "". As a special case, the result of splitting the empty string "" is an empty vector, not a vector containing a single string. The reason for this special case is that being able to represent a empty vector is typically more useful than consistent handling of empty elements. If you do need to represent empty elements, you'll need to check for the empty string before calling g_strsplit(). a newly-allocated %NULL-terminated array of strings. Use g_strfreev() to free it. a string to split a string which specifies the places at which to split the string. The delimiter is not included in any of the resulting strings, unless @max_tokens is reached. the maximum number of pieces to split @string into. If this is less than 1, the string is split completely. Splits @string into a number of tokens not containing any of the characters in @delimiter. A token is the (possibly empty) longest string that does not contain any of the characters in @delimiters. If @max_tokens is reached, the remainder is appended to the last token. For example the result of g_strsplit_set ("abc:def/ghi", ":/", -1) is a %NULL-terminated vector containing the three strings "abc", "def", and "ghi". The result of g_strsplit_set (":def/ghi:", ":/", -1) is a %NULL-terminated vector containing the four strings "", "def", "ghi", and "". As a special case, the result of splitting the empty string "" is an empty vector, not a vector containing a single string. The reason for this special case is that being able to represent a empty vector is typically more useful than consistent handling of empty elements. If you do need to represent empty elements, you'll need to check for the empty string before calling g_strsplit_set(). Note that this function works on bytes not characters, so it can't be used to delimit UTF-8 strings for anything but ASCII characters. a newly-allocated %NULL-terminated array of strings. Use g_strfreev() to free it. The string to be tokenized A nul-terminated string containing bytes that are used to split the string. The maximum number of tokens to split @string into. If this is less than 1, the string is split completely Searches the string @haystack for the first occurrence of the string @needle, limiting the length of the search to @haystack_len. a pointer to the found occurrence, or %NULL if not found. a string the maximum length of @haystack. Note that -1 is a valid length, if @haystack is nul-terminated, meaning it will search through the whole string. the string to search for Converts a string to a #gdouble value. It calls the standard strtod() function to handle the conversion, but if the string is not completely converted it attempts the conversion again with g_ascii_strtod(), and returns the best match. This function should seldom be used. The normal situation when reading numbers not for human consumption is to use g_ascii_strtod(). Only when you know that you must expect both locale formatted and C formatted numbers should you use this. Make sure that you don't pass strings such as comma separated lists of values, since the commas may be interpreted as a decimal point in some locales, causing unexpected results. the #gdouble value. the string to convert to a numeric value. if non-%NULL, it returns the character after the last character used in the conversion. Converts a string to upper case. This function is totally broken for the reasons discussed in the g_strncasecmp() docs - use g_ascii_strup() or g_utf8_strup() instead. the string the string to convert Returns the length of the given %NULL-terminated string array @str_array. length of @str_array. a %NULL-terminated array of strings Create a new test case, similar to g_test_create_case(). However the test is assumed to use no fixture, and test suites are automatically created on the fly and added to the root fixture, based on the slash-separated portions of @testpath. The @test_data argument will be passed as first argument to @test_func. If @testpath includes the component "subprocess" anywhere in it, the test will be skipped by default, and only run if explicitly required via the `-p` command-line option or g_test_trap_subprocess(). /-separated test case path name for the test. Test data argument for the test function. The test function to invoke for this test. Create a new test case, as with g_test_add_data_func(), but freeing @test_data after the test run is complete. /-separated test case path name for the test. Test data argument for the test function. The test function to invoke for this test. #GDestroyNotify for @test_data. Create a new test case, similar to g_test_create_case(). However the test is assumed to use no fixture, and test suites are automatically created on the fly and added to the root fixture, based on the slash-separated portions of @testpath. If @testpath includes the component "subprocess" anywhere in it, the test will be skipped by default, and only run if explicitly required via the `-p` command-line option or g_test_trap_subprocess(). /-separated test case path name for the test. The test function to invoke for this test. This function adds a message to test reports that associates a bug URI with a test case. Bug URIs are constructed from a base URI set with g_test_bug_base() and @bug_uri_snippet. Bug specific bug tracker URI portion. Specify the base URI for bug reports. The base URI is used to construct bug report messages for g_test_message() when g_test_bug() is called. Calling this function outside of a test case sets the default base URI for all test cases. Calling it from within a test case changes the base URI for the scope of the test case only. Bug URIs are constructed by appending a bug specific URI portion to @uri_pattern, or by replacing the special string '\%s' within @uri_pattern if that is present. the base pattern for bug URIs Creates the pathname to a data file that is required for a test. This function is conceptually similar to g_build_filename() except that the first argument has been replaced with a #GTestFileType argument. The data file should either have been distributed with the module containing the test (%G_TEST_DIST) or built as part of the build system of that module (%G_TEST_BUILT). In order for this function to work in srcdir != builddir situations, the G_TEST_SRCDIR and G_TEST_BUILDDIR environment variables need to have been defined. As of 2.38, this is done by the glib.mk included in GLib. Please ensure that your copy is up to date before using this function. In case neither variable is set, this function will fall back to using the dirname portion of argv[0], possibly removing ".libs". This allows for casual running of tests directly from the commandline in the srcdir == builddir case and should also support running of installed tests, assuming the data files have been installed in the same relative path as the test binary. the path of the file, to be freed using g_free() the type of file (built vs. distributed) the first segment of the pathname %NULL-terminated additional path segments Create a new #GTestCase, named @test_name, this API is fairly low level, calling g_test_add() or g_test_add_func() is preferable. When this test is executed, a fixture structure of size @data_size will be allocated and filled with 0s. Then @data_setup is called to initialize the fixture. After fixture setup, the actual test function @data_test is called. Once the test run completed, the fixture structure is torn down by calling @data_teardown and after that the memory is released. Splitting up a test run into fixture setup, test function and fixture teardown is most usful if the same fixture is used for multiple tests. In this cases, g_test_create_case() will be called with the same fixture, but varying @test_name and @data_test arguments. a newly allocated #GTestCase. the name for the test case the size of the fixture data structure test data argument for the test functions the function to set up the fixture data the actual test function the function to teardown the fixture data Create a new test suite with the name @suite_name. A newly allocated #GTestSuite instance. a name for the suite Indicates that a message with the given @log_domain and @log_level, with text matching @pattern, is expected to be logged. When this message is logged, it will not be printed, and the test case will not abort. Use g_test_assert_expected_messages() to assert that all previously-expected messages have been seen and suppressed. You can call this multiple times in a row, if multiple messages are expected as a result of a single call. (The messages must appear in the same order as the calls to g_test_expect_message().) For example: |[<!-- language="C" --> // g_main_context_push_thread_default() should fail if the // context is already owned by another thread. g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, "assertion*acquired_context*failed"); g_main_context_push_thread_default (bad_context); g_test_assert_expected_messages (); ]| Note that you cannot use this to test g_error() messages, since g_error() intentionally never returns even if the program doesn't abort; use g_test_trap_subprocess() in this case. If messages at %G_LOG_LEVEL_DEBUG are emitted, but not explicitly expected via g_test_expect_message() then they will be ignored. the log domain of the message the log level of the message a glob-style [pattern][glib-Glob-style-pattern-matching] Indicates that a test failed. This function can be called multiple times from the same test. You can use this function if your test failed in a recoverable way. Do not use this function if the failure of a test could cause other tests to malfunction. Calling this function will not stop the test from running, you need to return from the test function yourself. So you can produce additional diagnostic messages or even continue running the test. If not called from inside a test, this function does nothing. Returns whether a test has already failed. This will be the case when g_test_fail(), g_test_incomplete() or g_test_skip() have been called, but also if an assertion has failed. This can be useful to return early from a test if continuing after a failed assertion might be harmful. The return value of this function is only meaningful if it is called from inside a test function. %TRUE if the test has failed Gets the pathname of the directory containing test files of the type specified by @file_type. This is approximately the same as calling g_test_build_filename("."), but you don't need to free the return value. the path of the directory, owned by GLib the type of file (built vs. distributed) Gets the pathname to a data file that is required for a test. This is the same as g_test_build_filename() with two differences. The first difference is that must only use this function from within a testcase function. The second difference is that you need not free the return value -- it will be automatically freed when the testcase finishes running. It is safe to use this function from a thread inside of a testcase but you must ensure that all such uses occur before the main testcase function returns (ie: it is best to ensure that all threads have been joined). the path, automatically freed at the end of the testcase the type of file (built vs. distributed) the first segment of the pathname %NULL-terminated additional path segments Get the toplevel test suite for the test path API. the toplevel #GTestSuite Indicates that a test failed because of some incomplete functionality. This function can be called multiple times from the same test. Calling this function will not stop the test from running, you need to return from the test function yourself. So you can produce additional diagnostic messages or even continue running the test. If not called from inside a test, this function does nothing. explanation Initialize the GLib testing framework, e.g. by seeding the test random number generator, the name for g_get_prgname() and parsing test related command line args. So far, the following arguments are understood: - `-l`: List test cases available in a test executable. - `--seed=SEED`: Provide a random seed to reproduce test runs using random numbers. - `--verbose`: Run tests verbosely. - `-q`, `--quiet`: Run tests quietly. - `-p PATH`: Execute all tests matching the given path. This can also be used to force a test to run that would otherwise be skipped (ie, a test whose name contains "/subprocess"). - `-m {perf|slow|thorough|quick|undefined|no-undefined}`: Execute tests according to these test modes: `perf`: Performance tests, may take long and report results. `slow`, `thorough`: Slow and thorough tests, may take quite long and maximize coverage. `quick`: Quick tests, should run really quickly and give good coverage. `undefined`: Tests for undefined behaviour, may provoke programming errors under g_test_trap_subprocess() or g_test_expect_messages() to check that appropriate assertions or warnings are given `no-undefined`: Avoid tests for undefined behaviour - `--debug-log`: Debug test logging output. Address of the @argc parameter of the main() function. Changed if any arguments were handled. Address of the @argv parameter of main(). Any parameters understood by g_test_init() stripped before return. %NULL-terminated list of special options. Currently the only defined option is `"no_g_set_prgname"`, which will cause g_test_init() to not call g_set_prgname(). Installs a non-error fatal log handler which can be used to decide whether log messages which are counted as fatal abort the program. The use case here is that you are running a test case that depends on particular libraries or circumstances and cannot prevent certain known critical or warning messages. So you install a handler that compares the domain and message to precisely not abort in such a case. Note that the handler is reset at the beginning of any test case, so you have to set it inside each test function which needs the special behavior. This handler has no effect on g_error messages. the log handler function. data passed to the log handler. Report the result of a performance or measurement test. The test should generally strive to maximize the reported quantities (larger values are better than smaller ones), this and @maximized_quantity can determine sorting order for test result reports. the reported value the format string of the report message arguments to pass to the printf() function Add a message to the test report. the format string printf-like arguments to @format Report the result of a performance or measurement test. The test should generally strive to minimize the reported quantities (smaller values are better than larger ones), this and @minimized_quantity can determine sorting order for test result reports. the reported value the format string of the report message arguments to pass to the printf() function This function enqueus a callback @destroy_func to be executed during the next test case teardown phase. This is most useful to auto destruct allocted test resources at the end of a test run. Resources are released in reverse queue order, that means enqueueing callback A before callback B will cause B() to be called before A() during teardown. Destroy callback for teardown phase. Destroy callback data. Enqueue a pointer to be released with g_free() during the next teardown phase. This is equivalent to calling g_test_queue_destroy() with a destroy callback of g_free(). the pointer to be stored. Get a reproducible random floating point number, see g_test_rand_int() for details on test case random numbers. a random number from the seeded random number generator. Get a reproducible random floating pointer number out of a specified range, see g_test_rand_int() for details on test case random numbers. a number with @range_start <= number < @range_end. the minimum value returned by this function the minimum value not returned by this function Get a reproducible random integer number. The random numbers generated by the g_test_rand_*() family of functions change with every new test program start, unless the --seed option is given when starting test programs. For individual test cases however, the random number generator is reseeded, to avoid dependencies between tests and to make --seed effective for all test cases. a random number from the seeded random number generator. Get a reproducible random integer number out of a specified range, see g_test_rand_int() for details on test case random numbers. a number with @begin <= number < @end. the minimum value returned by this function the smallest value not to be returned by this function Runs all tests under the toplevel suite which can be retrieved with g_test_get_root(). Similar to g_test_run_suite(), the test cases to be run are filtered according to test path arguments (`-p testpath`) as parsed by g_test_init(). g_test_run_suite() or g_test_run() may only be called once in a program. In general, the tests and sub-suites within each suite are run in the order in which they are defined. However, note that prior to GLib 2.36, there was a bug in the `g_test_add_*` functions which caused them to create multiple suites with the same name, meaning that if you created tests "/foo/simple", "/bar/simple", and "/foo/using-bar" in that order, they would get run in that order (since g_test_run() would run the first "/foo" suite, then the "/bar" suite, then the second "/foo" suite). As of 2.36, this bug is fixed, and adding the tests in that order would result in a running order of "/foo/simple", "/foo/using-bar", "/bar/simple". If this new ordering is sub-optimal (because it puts more-complicated tests before simpler ones, making it harder to figure out exactly what has failed), you can fix it by changing the test paths to group tests by suite in a way that will result in the desired running order. Eg, "/simple/foo", "/simple/bar", "/complex/foo-using-bar". However, you should never make the actual result of a test depend on the order that tests are run in. If you need to ensure that some particular code runs before or after a given test case, use g_test_add(), which lets you specify setup and teardown functions. If all tests are skipped, this function will return 0 if producing TAP output, or 77 (treated as "skip test" by Automake) otherwise. 0 on success, 1 on failure (assuming it returns at all), 0 or 77 if all tests were skipped with g_test_skip() Execute the tests within @suite and all nested #GTestSuites. The test suites to be executed are filtered according to test path arguments (`-p testpath`) as parsed by g_test_init(). See the g_test_run() documentation for more information on the order that tests are run in. g_test_run_suite() or g_test_run() may only be called once in a program. 0 on success a #GTestSuite Changes the behaviour of g_assert_cmpstr(), g_assert_cmpint(), g_assert_cmpuint(), g_assert_cmphex(), g_assert_cmpfloat(), g_assert_true(), g_assert_false(), g_assert_null(), g_assert_no_error(), g_assert_error(), g_test_assert_expected_messages() and the various g_test_trap_assert_*() macros to not abort to program, but instead call g_test_fail() and continue. (This also changes the behavior of g_test_fail() so that it will not cause the test program to abort after completing the failed test.) Note that the g_assert_not_reached() and g_assert() are not affected by this. This function can only be called after g_test_init(). Indicates that a test was skipped. Calling this function will not stop the test from running, you need to return from the test function yourself. So you can produce additional diagnostic messages or even continue running the test. If not called from inside a test, this function does nothing. explanation Returns %TRUE (after g_test_init() has been called) if the test program is running under g_test_trap_subprocess(). %TRUE if the test program is running under g_test_trap_subprocess(). Get the time since the last start of the timer with g_test_timer_start(). the time since the last start of the timer, as a double Report the last result of g_test_timer_elapsed(). the last result of g_test_timer_elapsed(), as a double Start a timing test. Call g_test_timer_elapsed() when the task is supposed to be done. Call this function again to restart the timer. Fork the current test program to execute a test case that might not return or that might abort. If @usec_timeout is non-0, the forked test case is aborted and considered failing if its run time exceeds it. The forking behavior can be configured with the #GTestTrapFlags flags. In the following example, the test code forks, the forked child process produces some sample output and exits successfully. The forking parent process then asserts successful child program termination and validates child program outputs. |[<!-- language="C" --> static void test_fork_patterns (void) { if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDOUT | G_TEST_TRAP_SILENCE_STDERR)) { g_print ("some stdout text: somagic17\n"); g_printerr ("some stderr text: semagic43\n"); exit (0); // successful test run } g_test_trap_assert_passed (); g_test_trap_assert_stdout ("*somagic17*"); g_test_trap_assert_stderr ("*semagic43*"); } ]| This function is implemented only on Unix platforms, and is not always reliable due to problems inherent in fork-without-exec. Use g_test_trap_subprocess() instead. %TRUE for the forked child and %FALSE for the executing parent process. Timeout for the forked test in micro seconds. Flags to modify forking behaviour. Check the result of the last g_test_trap_subprocess() call. %TRUE if the last test subprocess terminated successfully. Check the result of the last g_test_trap_subprocess() call. %TRUE if the last test subprocess got killed due to a timeout. Respawns the test program to run only @test_path in a subprocess. This can be used for a test case that might not return, or that might abort. If @test_path is %NULL then the same test is re-run in a subprocess. You can use g_test_subprocess() to determine whether the test is in a subprocess or not. @test_path can also be the name of the parent test, followed by "`/subprocess/`" and then a name for the specific subtest (or just ending with "`/subprocess`" if the test only has one child test); tests with names of this form will automatically be skipped in the parent process. If @usec_timeout is non-0, the test subprocess is aborted and considered failing if its run time exceeds it. The subprocess behavior can be configured with the #GTestSubprocessFlags flags. You can use methods such as g_test_trap_assert_passed(), g_test_trap_assert_failed(), and g_test_trap_assert_stderr() to check the results of the subprocess. (But note that g_test_trap_assert_stdout() and g_test_trap_assert_stderr() cannot be used if @test_flags specifies that the child should inherit the parent stdout/stderr.) If your `main ()` needs to behave differently in the subprocess, you can call g_test_subprocess() (after calling g_test_init()) to see whether you are in a subprocess. The following example tests that calling `my_object_new(1000000)` will abort with an error message. |[<!-- language="C" --> static void test_create_large_object_subprocess (void) { if (g_test_subprocess ()) { my_object_new (1000000); return; } // Reruns this same test in a subprocess g_test_trap_subprocess (NULL, 0, 0); g_test_trap_assert_failed (); g_test_trap_assert_stderr ("*ERROR*too large*"); } int main (int argc, char **argv) { g_test_init (&argc, &argv, NULL); g_test_add_func ("/myobject/create_large_object", test_create_large_object); return g_test_run (); } ]| Test to run in a subprocess Timeout for the subprocess test in micro seconds. Flags to modify subprocess behaviour. Terminates the current thread. If another thread is waiting for us using g_thread_join() then the waiting thread will be woken up and get @retval as the return value of g_thread_join(). Calling g_thread_exit() with a parameter @retval is equivalent to returning @retval from the function @func, as given to g_thread_new(). You must only call g_thread_exit() from a thread that you created yourself with g_thread_new() or related APIs. You must not call this function from a thread created with another threading library or or from within a #GThreadPool. the return value of this thread This function will return the maximum @interval that a thread will wait in the thread pool for new tasks before being stopped. If this function returns 0, threads waiting in the thread pool for new work are not stopped. the maximum @interval (milliseconds) to wait for new tasks in the thread pool before stopping the thread Returns the maximal allowed number of unused threads. the maximal number of unused threads Returns the number of currently unused threads. the number of currently unused threads This function will set the maximum @interval that a thread waiting in the pool for new tasks can be idle for before being stopped. This function is similar to calling g_thread_pool_stop_unused_threads() on a regular timeout, except this is done on a per thread basis. By setting @interval to 0, idle threads will not be stopped. The default value is 15000 (15 seconds). the maximum @interval (in milliseconds) a thread can be idle Sets the maximal number of unused threads to @max_threads. If @max_threads is -1, no limit is imposed on the number of unused threads. The default value is 2. maximal number of unused threads Stops all currently unused threads. This does not change the maximal number of unused threads. This function can be used to regularly stop all unused threads e.g. from g_timeout_add(). This functions returns the #GThread corresponding to the current thread. Note that this function does not increase the reference count of the returned struct. This function will return a #GThread even for threads that were not created by GLib (i.e. those created by other threading APIs). This may be useful for thread identification purposes (i.e. comparisons) but you must not use GLib functions (such as g_thread_join()) on these threads. the #GThread representing the current thread Causes the calling thread to voluntarily relinquish the CPU, so that other threads can run. This function is often used as a method to make busy wait less evil. Converts a string containing an ISO 8601 encoded date and time to a #GTimeVal and puts it into @time_. @iso_date must include year, month, day, hours, minutes, and seconds. It can optionally include fractions of a second and a time zone indicator. (In the absence of any time zone indication, the timestamp is assumed to be in local time.) %TRUE if the conversion was successful. an ISO 8601 encoded date string a #GTimeVal Sets a function to be called at regular intervals, with the default priority, #G_PRIORITY_DEFAULT. The function is called repeatedly until it returns %FALSE, at which point the timeout is automatically destroyed and the function will not be called again. The first call to the function will be at the end of the first @interval. Note that timeout functions may be delayed, due to the processing of other event sources. Thus they should not be relied on for precise timing. After each call to the timeout function, the time of the next timeout is recalculated based on the current time and the given interval (it does not try to 'catch up' time lost in delays). If you want to have a timer in the "seconds" range and do not care about the exact time of the first call of the timer, use the g_timeout_add_seconds() function; this function allows for more optimizations and more efficient system power usage. This internally creates a main loop source using g_timeout_source_new() and attaches it to the main loop context using g_source_attach(). You can do these steps manually if you need greater control. The interval given is in terms of monotonic time, not wall clock time. See g_get_monotonic_time(). the ID (greater than 0) of the event source. the time between calls to the function, in milliseconds (1/1000ths of a second) function to call data to pass to @function Sets a function to be called at regular intervals, with the given priority. The function is called repeatedly until it returns %FALSE, at which point the timeout is automatically destroyed and the function will not be called again. The @notify function is called when the timeout is destroyed. The first call to the function will be at the end of the first @interval. Note that timeout functions may be delayed, due to the processing of other event sources. Thus they should not be relied on for precise timing. After each call to the timeout function, the time of the next timeout is recalculated based on the current time and the given interval (it does not try to 'catch up' time lost in delays). This internally creates a main loop source using g_timeout_source_new() and attaches it to the main loop context using g_source_attach(). You can do these steps manually if you need greater control. The interval given in terms of monotonic time, not wall clock time. See g_get_monotonic_time(). the ID (greater than 0) of the event source. the priority of the timeout source. Typically this will be in the range between #G_PRIORITY_DEFAULT and #G_PRIORITY_HIGH. the time between calls to the function, in milliseconds (1/1000ths of a second) function to call data to pass to @function function to call when the timeout is removed, or %NULL Sets a function to be called at regular intervals with the default priority, #G_PRIORITY_DEFAULT. The function is called repeatedly until it returns %FALSE, at which point the timeout is automatically destroyed and the function will not be called again. This internally creates a main loop source using g_timeout_source_new_seconds() and attaches it to the main loop context using g_source_attach(). You can do these steps manually if you need greater control. Also see g_timeout_add_seconds_full(). Note that the first call of the timer may not be precise for timeouts of one second. If you need finer precision and have such a timeout, you may want to use g_timeout_add() instead. The interval given is in terms of monotonic time, not wall clock time. See g_get_monotonic_time(). the ID (greater than 0) of the event source. the time between calls to the function, in seconds function to call data to pass to @function Sets a function to be called at regular intervals, with @priority. The function is called repeatedly until it returns %FALSE, at which point the timeout is automatically destroyed and the function will not be called again. Unlike g_timeout_add(), this function operates at whole second granularity. The initial starting point of the timer is determined by the implementation and the implementation is expected to group multiple timers together so that they fire all at the same time. To allow this grouping, the @interval to the first timer is rounded and can deviate up to one second from the specified interval. Subsequent timer iterations will generally run at the specified interval. Note that timeout functions may be delayed, due to the processing of other event sources. Thus they should not be relied on for precise timing. After each call to the timeout function, the time of the next timeout is recalculated based on the current time and the given @interval If you want timing more precise than whole seconds, use g_timeout_add() instead. The grouping of timers to fire at the same time results in a more power and CPU efficient behavior so if your timer is in multiples of seconds and you don't require the first timer exactly one second from now, the use of g_timeout_add_seconds() is preferred over g_timeout_add(). This internally creates a main loop source using g_timeout_source_new_seconds() and attaches it to the main loop context using g_source_attach(). You can do these steps manually if you need greater control. The interval given is in terms of monotonic time, not wall clock time. See g_get_monotonic_time(). the ID (greater than 0) of the event source. the priority of the timeout source. Typically this will be in the range between #G_PRIORITY_DEFAULT and #G_PRIORITY_HIGH. the time between calls to the function, in seconds function to call data to pass to @function function to call when the timeout is removed, or %NULL Creates a new timeout source. The source will not initially be associated with any #GMainContext and must be added to one with g_source_attach() before it will be executed. The interval given is in terms of monotonic time, not wall clock time. See g_get_monotonic_time(). the newly-created timeout source the timeout interval in milliseconds. Creates a new timeout source. The source will not initially be associated with any #GMainContext and must be added to one with g_source_attach() before it will be executed. The scheduling granularity/accuracy of this timeout source will be in seconds. The interval given in terms of monotonic time, not wall clock time. See g_get_monotonic_time(). the newly-created timeout source the timeout interval in seconds Returns the height of a #GTrashStack. Note that execution of this function is of O(N) complexity where N denotes the number of items on the stack. the height of the stack a #GTrashStack Pushes a piece of memory onto a #GTrashStack. a #GTrashStack the piece of memory to push on the stack Attempts to allocate @n_bytes, and returns %NULL on failure. Contrast with g_malloc(), which aborts the program on failure. the allocated memory, or %NULL. number of bytes to allocate. Attempts to allocate @n_bytes, initialized to 0's, and returns %NULL on failure. Contrast with g_malloc0(), which aborts the program on failure. the allocated memory, or %NULL number of bytes to allocate This function is similar to g_try_malloc0(), allocating (@n_blocks * @n_block_bytes) bytes, but care is taken to detect possible overflow during multiplication. the allocated memory, or %NULL the number of blocks to allocate the size of each block in bytes This function is similar to g_try_malloc(), allocating (@n_blocks * @n_block_bytes) bytes, but care is taken to detect possible overflow during multiplication. the allocated memory, or %NULL. the number of blocks to allocate the size of each block in bytes Attempts to realloc @mem to a new size, @n_bytes, and returns %NULL on failure. Contrast with g_realloc(), which aborts the program on failure. If @mem is %NULL, behaves the same as g_try_malloc(). the allocated memory, or %NULL. previously-allocated memory, or %NULL. number of bytes to allocate. This function is similar to g_try_realloc(), allocating (@n_blocks * @n_block_bytes) bytes, but care is taken to detect possible overflow during multiplication. the allocated memory, or %NULL. previously-allocated memory, or %NULL. the number of blocks to allocate the size of each block in bytes Convert a string from UCS-4 to UTF-16. A 0 character will be added to the result after the converted text. a pointer to a newly allocated UTF-16 string. This value must be freed with g_free(). If an error occurs, %NULL will be returned and @error set. a UCS-4 encoded string the maximum length (number of characters) of @str to use. If @len < 0, then the string is nul-terminated. location to store number of bytes read, or %NULL. If an error occurs then the index of the invalid input is stored here. location to store number of #gunichar2 written, or %NULL. The value stored here does not include the trailing 0. Convert a string from a 32-bit fixed width representation as UCS-4. to UTF-8. The result will be terminated with a 0 byte. a pointer to a newly allocated UTF-8 string. This value must be freed with g_free(). If an error occurs, %NULL will be returned and @error set. In that case, @items_read will be set to the position of the first invalid input character. a UCS-4 encoded string the maximum length (number of characters) of @str to use. If @len < 0, then the string is nul-terminated. location to store number of characters read, or %NULL. location to store number of bytes written or %NULL. The value here stored does not include the trailing 0 byte. Determines the break type of @c. @c should be a Unicode character (to derive a character from UTF-8 encoded text, use g_utf8_get_char()). The break type is used to find word and line breaks ("text boundaries"), Pango implements the Unicode boundary resolution algorithms and normally you would use a function such as pango_break() instead of caring about break types yourself. the break type of @c a Unicode character Determines the canonical combining class of a Unicode character. the combining class of the character a Unicode character Performs a single composition step of the Unicode canonical composition algorithm. This function includes algorithmic Hangul Jamo composition, but it is not exactly the inverse of g_unichar_decompose(). No composition can have either of @a or @b equal to zero. To be precise, this function composes if and only if there exists a Primary Composite P which is canonically equivalent to the sequence <@a,@b>. See the Unicode Standard for the definition of Primary Composite. If @a and @b do not compose a new character, @ch is set to zero. See [UAX#15](http://unicode.org/reports/tr15/) for details. %TRUE if the characters could be composed a Unicode character a Unicode character return location for the composed character Performs a single decomposition step of the Unicode canonical decomposition algorithm. This function does not include compatibility decompositions. It does, however, include algorithmic Hangul Jamo decomposition, as well as 'singleton' decompositions which replace a character by a single other character. In the case of singletons *@b will be set to zero. If @ch is not decomposable, *@a is set to @ch and *@b is set to zero. Note that the way Unicode decomposition pairs are defined, it is guaranteed that @b would not decompose further, but @a may itself decompose. To get the full canonical decomposition for @ch, one would need to recursively call this function on @a. Or use g_unichar_fully_decompose(). See [UAX#15](http://unicode.org/reports/tr15/) for details. %TRUE if the character could be decomposed a Unicode character return location for the first component of @ch return location for the second component of @ch Determines the numeric value of a character as a decimal digit. If @c is a decimal digit (according to g_unichar_isdigit()), its numeric value. Otherwise, -1. a Unicode character Computes the canonical or compatibility decomposition of a Unicode character. For compatibility decomposition, pass %TRUE for @compat; for canonical decomposition pass %FALSE for @compat. The decomposed sequence is placed in @result. Only up to @result_len characters are written into @result. The length of the full decomposition (irrespective of @result_len) is returned by the function. For canonical decomposition, currently all decompositions are of length at most 4, but this may change in the future (very unlikely though). At any rate, Unicode does guarantee that a buffer of length 18 is always enough for both compatibility and canonical decompositions, so that is the size recommended. This is provided as %G_UNICHAR_MAX_DECOMPOSITION_LENGTH. See [UAX#15](http://unicode.org/reports/tr15/) for details. the length of the full decomposition. a Unicode character. whether perform canonical or compatibility decomposition location to store decomposed result, or %NULL length of @result In Unicode, some characters are "mirrored". This means that their images are mirrored horizontally in text that is laid out from right to left. For instance, "(" would become its mirror image, ")", in right-to-left text. If @ch has the Unicode mirrored property and there is another unicode character that typically has a glyph that is the mirror image of @ch's glyph and @mirrored_ch is set, it puts that character in the address pointed to by @mirrored_ch. Otherwise the original character is put. %TRUE if @ch has a mirrored character, %FALSE otherwise a Unicode character location to store the mirrored character Looks up the #GUnicodeScript for a particular character (as defined by Unicode Standard Annex \#24). No check is made for @ch being a valid Unicode character; if you pass in invalid character, the result is undefined. This function is equivalent to pango_script_for_unichar() and the two are interchangeable. the #GUnicodeScript for the character. a Unicode character Determines whether a character is alphanumeric. Given some UTF-8 text, obtain a character value with g_utf8_get_char(). %TRUE if @c is an alphanumeric character a Unicode character Determines whether a character is alphabetic (i.e. a letter). Given some UTF-8 text, obtain a character value with g_utf8_get_char(). %TRUE if @c is an alphabetic character a Unicode character Determines whether a character is a control character. Given some UTF-8 text, obtain a character value with g_utf8_get_char(). %TRUE if @c is a control character a Unicode character Determines if a given character is assigned in the Unicode standard. %TRUE if the character has an assigned value a Unicode character Determines whether a character is numeric (i.e. a digit). This covers ASCII 0-9 and also digits in other languages/scripts. Given some UTF-8 text, obtain a character value with g_utf8_get_char(). %TRUE if @c is a digit a Unicode character Determines whether a character is printable and not a space (returns %FALSE for control characters, format characters, and spaces). g_unichar_isprint() is similar, but returns %TRUE for spaces. Given some UTF-8 text, obtain a character value with g_utf8_get_char(). %TRUE if @c is printable unless it's a space a Unicode character Determines whether a character is a lowercase letter. Given some UTF-8 text, obtain a character value with g_utf8_get_char(). %TRUE if @c is a lowercase letter a Unicode character Determines whether a character is a mark (non-spacing mark, combining mark, or enclosing mark in Unicode speak). Given some UTF-8 text, obtain a character value with g_utf8_get_char(). Note: in most cases where isalpha characters are allowed, ismark characters should be allowed to as they are essential for writing most European languages as well as many non-Latin scripts. %TRUE if @c is a mark character a Unicode character Determines whether a character is printable. Unlike g_unichar_isgraph(), returns %TRUE for spaces. Given some UTF-8 text, obtain a character value with g_utf8_get_char(). %TRUE if @c is printable a Unicode character Determines whether a character is punctuation or a symbol. Given some UTF-8 text, obtain a character value with g_utf8_get_char(). %TRUE if @c is a punctuation or symbol character a Unicode character Determines whether a character is a space, tab, or line separator (newline, carriage return, etc.). Given some UTF-8 text, obtain a character value with g_utf8_get_char(). (Note: don't use this to do word breaking; you have to use Pango or equivalent to get word breaking right, the algorithm is fairly complex.) %TRUE if @c is a space character a Unicode character Determines if a character is titlecase. Some characters in Unicode which are composites, such as the DZ digraph have three case variants instead of just two. The titlecase form is used at the beginning of a word where only the first letter is capitalized. The titlecase form of the DZ digraph is U+01F2 LATIN CAPITAL LETTTER D WITH SMALL LETTER Z. %TRUE if the character is titlecase a Unicode character Determines if a character is uppercase. %TRUE if @c is an uppercase character a Unicode character Determines if a character is typically rendered in a double-width cell. %TRUE if the character is wide a Unicode character Determines if a character is typically rendered in a double-width cell under legacy East Asian locales. If a character is wide according to g_unichar_iswide(), then it is also reported wide with this function, but the converse is not necessarily true. See the [Unicode Standard Annex #11](http://www.unicode.org/reports/tr11/) for details. If a character passes the g_unichar_iswide() test then it will also pass this test, but not the other way around. Note that some characters may pass both this test and g_unichar_iszerowidth(). %TRUE if the character is wide in legacy East Asian locales a Unicode character Determines if a character is a hexidecimal digit. %TRUE if the character is a hexadecimal digit a Unicode character. Determines if a given character typically takes zero width when rendered. The return value is %TRUE for all non-spacing and enclosing marks (e.g., combining accents), format characters, zero-width space, but not U+00AD SOFT HYPHEN. A typical use of this function is with one of g_unichar_iswide() or g_unichar_iswide_cjk() to determine the number of cells a string occupies when displayed on a grid display (terminals). However, note that not all terminals support zero-width rendering of zero-width marks. %TRUE if the character has zero width a Unicode character Converts a single character to UTF-8. number of bytes written a Unicode character code output buffer, must have at least 6 bytes of space. If %NULL, the length will be computed and returned and nothing will be written to @outbuf. Converts a character to lower case. the result of converting @c to lower case. If @c is not an upperlower or titlecase character, or has no lowercase equivalent @c is returned unchanged. a Unicode character. Converts a character to the titlecase. the result of converting @c to titlecase. If @c is not an uppercase or lowercase character, @c is returned unchanged. a Unicode character Converts a character to uppercase. the result of converting @c to uppercase. If @c is not an lowercase or titlecase character, or has no upper case equivalent @c is returned unchanged. a Unicode character Classifies a Unicode character by type. the type of the character. a Unicode character Checks whether @ch is a valid Unicode character. Some possible integer values of @ch will not be valid. 0 is considered a valid character, though it's normally a string terminator. %TRUE if @ch is a valid Unicode character a Unicode character Determines the numeric value of a character as a hexidecimal digit. If @c is a hex digit (according to g_unichar_isxdigit()), its numeric value. Otherwise, -1. a Unicode character Computes the canonical decomposition of a Unicode character. Use the more flexible g_unichar_fully_decompose() instead. a newly allocated string of Unicode characters. @result_len is set to the resulting length of the string. a Unicode character. location to store the length of the return value. Computes the canonical ordering of a string in-place. This rearranges decomposed characters in the string according to their combining classes. See the Unicode manual for more information. a UCS-4 encoded string. the maximum length of @string to use. Looks up the Unicode script for @iso15924. ISO 15924 assigns four-letter codes to scripts. For example, the code for Arabic is 'Arab'. This function accepts four letter codes encoded as a @guint32 in a big-endian fashion. That is, the code expected for Arabic is 0x41726162 (0x41 is ASCII code for 'A', 0x72 is ASCII code for 'r', etc). See [Codes for the representation of names of scripts](http://unicode.org/iso15924/codelists.html) for details. the Unicode script for @iso15924, or of %G_UNICODE_SCRIPT_INVALID_CODE if @iso15924 is zero and %G_UNICODE_SCRIPT_UNKNOWN if @iso15924 is unknown. a Unicode script Looks up the ISO 15924 code for @script. ISO 15924 assigns four-letter codes to scripts. For example, the code for Arabic is 'Arab'. The four letter codes are encoded as a @guint32 by this function in a big-endian fashion. That is, the code returned for Arabic is 0x41726162 (0x41 is ASCII code for 'A', 0x72 is ASCII code for 'r', etc). See [Codes for the representation of names of scripts](http://unicode.org/iso15924/codelists.html) for details. the ISO 15924 code for @script, encoded as an integer, of zero if @script is %G_UNICODE_SCRIPT_INVALID_CODE or ISO 15924 code 'Zzzz' (script code for UNKNOWN) if @script is not understood. a Unicode script Sets a function to be called when the IO condition, as specified by @condition becomes true for @fd. @function will be called when the specified IO condition becomes %TRUE. The function is expected to clear whatever event caused the IO condition to become true and return %TRUE in order to be notified when it happens again. If @function returns %FALSE then the watch will be cancelled. The return value of this function can be passed to g_source_remove() to cancel the watch at any time that it exists. The source will never close the fd -- you must do it yourself. the ID (greater than 0) of the event source a file descriptor IO conditions to watch for on @fd a #GPollFDFunc data to pass to @function Sets a function to be called when the IO condition, as specified by @condition becomes true for @fd. This is the same as g_unix_fd_add(), except that it allows you to specify a non-default priority and a provide a #GDestroyNotify for @user_data. the ID (greater than 0) of the event source the priority of the source a file descriptor IO conditions to watch for on @fd a #GUnixFDSourceFunc data to pass to @function function to call when the idle is removed, or %NULL Creates a #GSource to watch for a particular IO condition on a file descriptor. The source will never close the fd -- you must do it yourself. the newly created #GSource a file descriptor IO conditions to watch for on @fd Similar to the UNIX pipe() call, but on modern systems like Linux uses the pipe2() system call, which atomically creates a pipe with the configured flags. The only supported flag currently is %FD_CLOEXEC. If for example you want to configure %O_NONBLOCK, that must still be done separately with fcntl(). This function does not take %O_CLOEXEC, it takes %FD_CLOEXEC as if for fcntl(); these are different on Linux/glibc. %TRUE on success, %FALSE if not (and errno will be set). Array of two integers Bitfield of file descriptor flags, as for fcntl() Control the non-blocking state of the given file descriptor, according to @nonblock. On most systems this uses %O_NONBLOCK, but on some older ones may use %O_NDELAY. %TRUE if successful A file descriptor If %TRUE, set the descriptor to be non-blocking A convenience function for g_unix_signal_source_new(), which attaches to the default #GMainContext. You can remove the watch using g_source_remove(). An ID (greater than 0) for the event source Signal number Callback Data for @handler A convenience function for g_unix_signal_source_new(), which attaches to the default #GMainContext. You can remove the watch using g_source_remove(). An ID (greater than 0) for the event source the priority of the signal source. Typically this will be in the range between #G_PRIORITY_DEFAULT and #G_PRIORITY_HIGH. Signal number Callback Data for @handler #GDestroyNotify for @handler Create a #GSource that will be dispatched upon delivery of the UNIX signal @signum. In GLib versions before 2.36, only `SIGHUP`, `SIGINT`, `SIGTERM` can be monitored. In GLib 2.36, `SIGUSR1` and `SIGUSR2` were added. Note that unlike the UNIX default, all sources which have created a watch will be dispatched, regardless of which underlying thread invoked g_unix_signal_source_new(). For example, an effective use of this function is to handle `SIGTERM` cleanly; flushing any outstanding files, and then calling g_main_loop_quit (). It is not safe to do any of this a regular UNIX signal handler; your handler may be invoked while malloc() or another library function is running, causing reentrancy if you attempt to use it from the handler. None of the GLib/GObject API is safe against this kind of reentrancy. The interaction of this source when combined with native UNIX functions like sigprocmask() is not defined. The source will not initially be associated with any #GMainContext and must be added to one with g_source_attach() before it will be executed. A newly created #GSource A signal number A wrapper for the POSIX unlink() function. The unlink() function deletes a name from the filesystem. If this was the last link to the file and no processes have it opened, the diskspace occupied by the file is freed. See your C library manual for more details about unlink(). Note that on Windows, it is in general not possible to delete files that are open to some process, or mapped into memory. 0 if the name was successfully deleted, -1 if an error occurred a pathname in the GLib file name encoding (UTF-8 on Windows) Removes an environment variable from the environment. Note that on some systems, when variables are overwritten, the memory used for the previous variables and its value isn't reclaimed. You should be mindful of the fact that environment variable handling in UNIX is not thread-safe, and your program may crash if one thread calls g_unsetenv() while another thread is calling getenv(). (And note that many functions, such as gettext(), call getenv() internally.) This function is only safe to use at the very start of your program, before creating any other threads (or creating objects that create worker threads of their own). If you need to set up the environment for a child process, you can use g_get_environ() to get an environment array, modify that with g_environ_setenv() and g_environ_unsetenv(), and then pass that array directly to execvpe(), g_spawn_async(), or the like. the environment variable to remove, must not contain '=' Escapes a string for use in a URI. Normally all characters that are not "unreserved" (i.e. ASCII alphanumerical characters plus dash, dot, underscore and tilde) are escaped. But if you specify characters in @reserved_chars_allowed they are not escaped. This is useful for the "reserved" characters in the URI specification, since those are allowed unescaped in some portions of a URI. an escaped version of @unescaped. The returned string should be freed when no longer needed. the unescaped input string. a string of reserved characters that are allowed to be used, or %NULL. %TRUE if the result can include UTF-8 characters. Splits an URI list conforming to the text/uri-list mime type defined in RFC 2483 into individual URIs, discarding any comments. The URIs are not validated. a newly allocated %NULL-terminated list of strings holding the individual URIs. The array should be freed with g_strfreev(). an URI list Gets the scheme portion of a URI string. RFC 3986 decodes the scheme as: |[ URI = scheme ":" hier-part [ "?" query ] [ "#" fragment ] ]| Common schemes include "file", "http", "svn+ssh", etc. The "Scheme" component of the URI, or %NULL on error. The returned string should be freed when no longer needed. a valid URI. Unescapes a segment of an escaped string. If any of the characters in @illegal_characters or the character zero appears as an escaped character in @escaped_string then that is an error and %NULL will be returned. This is useful it you want to avoid for instance having a slash being expanded in an escaped path element, which might confuse pathname handling. an unescaped version of @escaped_string or %NULL on error. The returned string should be freed when no longer needed. As a special case if %NULL is given for @escaped_string, this function will return %NULL. A string, may be %NULL Pointer to end of @escaped_string, may be %NULL An optional string of illegal characters not to be allowed, may be %NULL Unescapes a whole escaped string. If any of the characters in @illegal_characters or the character zero appears as an escaped character in @escaped_string then that is an error and %NULL will be returned. This is useful it you want to avoid for instance having a slash being expanded in an escaped path element, which might confuse pathname handling. an unescaped version of @escaped_string. The returned string should be freed when no longer needed. an escaped string to be unescaped. a string of illegal characters not to be allowed, or %NULL. Pauses the current thread for the given number of microseconds. There are 1 million microseconds per second (represented by the #G_USEC_PER_SEC macro). g_usleep() may have limited precision, depending on hardware and operating system; don't rely on the exact length of the sleep. number of microseconds to pause Convert a string from UTF-16 to UCS-4. The result will be nul-terminated. a pointer to a newly allocated UCS-4 string. This value must be freed with g_free(). If an error occurs, %NULL will be returned and @error set. a UTF-16 encoded string the maximum length (number of #gunichar2) of @str to use. If @len < 0, then the string is nul-terminated. location to store number of words read, or %NULL. If %NULL, then %G_CONVERT_ERROR_PARTIAL_INPUT will be returned in case @str contains a trailing partial character. If an error occurs then the index of the invalid input is stored here. location to store number of characters written, or %NULL. The value stored here does not include the trailing 0 character. Convert a string from UTF-16 to UTF-8. The result will be terminated with a 0 byte. Note that the input is expected to be already in native endianness, an initial byte-order-mark character is not handled specially. g_convert() can be used to convert a byte buffer of UTF-16 data of ambiguous endianess. Further note that this function does not validate the result string; it may e.g. include embedded NUL characters. The only validation done by this function is to ensure that the input can be correctly interpreted as UTF-16, i.e. it doesn't contain things unpaired surrogates. a pointer to a newly allocated UTF-8 string. This value must be freed with g_free(). If an error occurs, %NULL will be returned and @error set. a UTF-16 encoded string the maximum length (number of #gunichar2) of @str to use. If @len < 0, then the string is nul-terminated. location to store number of words read, or %NULL. If %NULL, then %G_CONVERT_ERROR_PARTIAL_INPUT will be returned in case @str contains a trailing partial character. If an error occurs then the index of the invalid input is stored here. location to store number of bytes written, or %NULL. The value stored here does not include the trailing 0 byte. Converts a string into a form that is independent of case. The result will not correspond to any particular case, but can be compared for equality or ordered with the results of calling g_utf8_casefold() on other strings. Note that calling g_utf8_casefold() followed by g_utf8_collate() is only an approximation to the correct linguistic case insensitive ordering, though it is a fairly good one. Getting this exactly right would require a more sophisticated collation function that takes case sensitivity into account. GLib does not currently provide such a function. a newly allocated string, that is a case independent form of @str. a UTF-8 encoded string length of @str, in bytes, or -1 if @str is nul-terminated. Compares two strings for ordering using the linguistically correct rules for the [current locale][setlocale]. When sorting a large number of strings, it will be significantly faster to obtain collation keys with g_utf8_collate_key() and compare the keys with strcmp() when sorting instead of sorting the original strings. < 0 if @str1 compares before @str2, 0 if they compare equal, > 0 if @str1 compares after @str2. a UTF-8 encoded string a UTF-8 encoded string Converts a string into a collation key that can be compared with other collation keys produced by the same function using strcmp(). The results of comparing the collation keys of two strings with strcmp() will always be the same as comparing the two original keys with g_utf8_collate(). Note that this function depends on the [current locale][setlocale]. a newly allocated string. This string should be freed with g_free() when you are done with it. a UTF-8 encoded string. length of @str, in bytes, or -1 if @str is nul-terminated. Converts a string into a collation key that can be compared with other collation keys produced by the same function using strcmp(). In order to sort filenames correctly, this function treats the dot '.' as a special case. Most dictionary orderings seem to consider it insignificant, thus producing the ordering "event.c" "eventgenerator.c" "event.h" instead of "event.c" "event.h" "eventgenerator.c". Also, we would like to treat numbers intelligently so that "file1" "file10" "file5" is sorted as "file1" "file5" "file10". Note that this function depends on the [current locale][setlocale]. a newly allocated string. This string should be freed with g_free() when you are done with it. a UTF-8 encoded string. length of @str, in bytes, or -1 if @str is nul-terminated. Finds the start of the next UTF-8 character in the string after @p. @p does not have to be at the beginning of a UTF-8 character. No check is made to see if the character found is actually valid other than it starts with an appropriate byte. a pointer to the found character or %NULL a pointer to a position within a UTF-8 encoded string a pointer to the byte following the end of the string, or %NULL to indicate that the string is nul-terminated Given a position @p with a UTF-8 encoded string @str, find the start of the previous UTF-8 character starting before @p. Returns %NULL if no UTF-8 characters are present in @str before @p. @p does not have to be at the beginning of a UTF-8 character. No check is made to see if the character found is actually valid other than it starts with an appropriate byte. a pointer to the found character or %NULL. pointer to the beginning of a UTF-8 encoded string pointer to some position within @str Converts a sequence of bytes encoded as UTF-8 to a Unicode character. If @p does not point to a valid UTF-8 encoded character, results are undefined. If you are not sure that the bytes are complete valid Unicode characters, you should use g_utf8_get_char_validated() instead. the resulting character a pointer to Unicode character encoded as UTF-8 Convert a sequence of bytes encoded as UTF-8 to a Unicode character. This function checks for incomplete characters, for invalid characters such as characters that are out of the range of Unicode, and for overlong encodings of valid characters. the resulting character. If @p points to a partial sequence at the end of a string that could begin a valid character (or if @max_len is zero), returns (gunichar)-2; otherwise, if @p does not point to a valid UTF-8 encoded Unicode character, returns (gunichar)-1. a pointer to Unicode character encoded as UTF-8 the maximum number of bytes to read, or -1, for no maximum or if @p is nul-terminated Converts a string into canonical form, standardizing such issues as whether a character with an accent is represented as a base character and combining accent or as a single precomposed character. The string has to be valid UTF-8, otherwise %NULL is returned. You should generally call g_utf8_normalize() before comparing two Unicode strings. The normalization mode %G_NORMALIZE_DEFAULT only standardizes differences that do not affect the text content, such as the above-mentioned accent representation. %G_NORMALIZE_ALL also standardizes the "compatibility" characters in Unicode, such as SUPERSCRIPT THREE to the standard forms (in this case DIGIT THREE). Formatting information may be lost but for most text operations such characters should be considered the same. %G_NORMALIZE_DEFAULT_COMPOSE and %G_NORMALIZE_ALL_COMPOSE are like %G_NORMALIZE_DEFAULT and %G_NORMALIZE_ALL, but returned a result with composed forms rather than a maximally decomposed form. This is often useful if you intend to convert the string to a legacy encoding or pass it to a system with less capable Unicode handling. a newly allocated string, that is the normalized form of @str, or %NULL if @str is not valid UTF-8. a UTF-8 encoded string. length of @str, in bytes, or -1 if @str is nul-terminated. the type of normalization to perform. Converts from an integer character offset to a pointer to a position within the string. Since 2.10, this function allows to pass a negative @offset to step backwards. It is usually worth stepping backwards from the end instead of forwards if @offset is in the last fourth of the string, since moving forward is about 3 times faster than moving backward. Note that this function doesn't abort when reaching the end of @str. Therefore you should be sure that @offset is within string boundaries before calling that function. Call g_utf8_strlen() when unsure. This limitation exists as this function is called frequently during text rendering and therefore has to be as fast as possible. the resulting pointer a UTF-8 encoded string a character offset within @str Converts from a pointer to position within a string to a integer character offset. Since 2.10, this function allows @pos to be before @str, and returns a negative offset in this case. the resulting character offset a UTF-8 encoded string a pointer to a position within @str Finds the previous UTF-8 character in the string before @p. @p does not have to be at the beginning of a UTF-8 character. No check is made to see if the character found is actually valid other than it starts with an appropriate byte. If @p might be the first character of the string, you must use g_utf8_find_prev_char() instead. a pointer to the found character a pointer to a position within a UTF-8 encoded string Finds the leftmost occurrence of the given Unicode character in a UTF-8 encoded string, while limiting the search to @len bytes. If @len is -1, allow unbounded search. %NULL if the string does not contain the character, otherwise, a pointer to the start of the leftmost occurrence of the character in the string. a nul-terminated UTF-8 encoded string the maximum length of @p a Unicode character Converts all Unicode characters in the string that have a case to lowercase. The exact manner that this is done depends on the current locale, and may result in the number of characters in the string changing. a newly allocated string, with all characters converted to lowercase. a UTF-8 encoded string length of @str, in bytes, or -1 if @str is nul-terminated. Computes the length of the string in characters, not including the terminating nul character. If the @max'th byte falls in the middle of a character, the last (partial) character is not counted. the length of the string in characters pointer to the start of a UTF-8 encoded string the maximum number of bytes to examine. If @max is less than 0, then the string is assumed to be nul-terminated. If @max is 0, @p will not be examined and may be %NULL. If @max is greater than 0, up to @max bytes are examined Like the standard C strncpy() function, but copies a given number of characters instead of a given number of bytes. The @src string must be valid UTF-8 encoded text. (Use g_utf8_validate() on all text before trying to use UTF-8 utility functions with it.) @dest buffer to fill with characters from @src UTF-8 encoded string character count Find the rightmost occurrence of the given Unicode character in a UTF-8 encoded string, while limiting the search to @len bytes. If @len is -1, allow unbounded search. %NULL if the string does not contain the character, otherwise, a pointer to the start of the rightmost occurrence of the character in the string. a nul-terminated UTF-8 encoded string the maximum length of @p a Unicode character Reverses a UTF-8 string. @str must be valid UTF-8 encoded text. (Use g_utf8_validate() on all text before trying to use UTF-8 utility functions with it.) This function is intended for programmatic uses of reversed strings. It pays no attention to decomposed characters, combining marks, byte order marks, directional indicators (LRM, LRO, etc) and similar characters which might need special handling when reversing a string for display purposes. Note that unlike g_strreverse(), this function returns newly-allocated memory, which should be freed with g_free() when no longer needed. a newly-allocated string which is the reverse of @str a UTF-8 encoded string the maximum length of @str to use, in bytes. If @len < 0, then the string is nul-terminated. Converts all Unicode characters in the string that have a case to uppercase. The exact manner that this is done depends on the current locale, and may result in the number of characters in the string increasing. (For instance, the German ess-zet will be changed to SS.) a newly allocated string, with all characters converted to uppercase. a UTF-8 encoded string length of @str, in bytes, or -1 if @str is nul-terminated. Copies a substring out of a UTF-8 encoded string. The substring will contain @end_pos - @start_pos characters. a newly allocated copy of the requested substring. Free with g_free() when no longer needed. a UTF-8 encoded string a character offset within @str another character offset within @str Convert a string from UTF-8 to a 32-bit fixed width representation as UCS-4. A trailing 0 character will be added to the string after the converted text. a pointer to a newly allocated UCS-4 string. This value must be freed with g_free(). If an error occurs, %NULL will be returned and @error set. a UTF-8 encoded string the maximum length of @str to use, in bytes. If @len < 0, then the string is nul-terminated. location to store number of bytes read, or %NULL. If %NULL, then %G_CONVERT_ERROR_PARTIAL_INPUT will be returned in case @str contains a trailing partial character. If an error occurs then the index of the invalid input is stored here. location to store number of characters written or %NULL. The value here stored does not include the trailing 0 character. Convert a string from UTF-8 to a 32-bit fixed width representation as UCS-4, assuming valid UTF-8 input. This function is roughly twice as fast as g_utf8_to_ucs4() but does no error checking on the input. A trailing 0 character will be added to the string after the converted text. a pointer to a newly allocated UCS-4 string. This value must be freed with g_free(). a UTF-8 encoded string the maximum length of @str to use, in bytes. If @len < 0, then the string is nul-terminated. location to store the number of characters in the result, or %NULL. Convert a string from UTF-8 to UTF-16. A 0 character will be added to the result after the converted text. a pointer to a newly allocated UTF-16 string. This value must be freed with g_free(). If an error occurs, %NULL will be returned and @error set. a UTF-8 encoded string the maximum length (number of bytes) of @str to use. If @len < 0, then the string is nul-terminated. location to store number of bytes read, or %NULL. If %NULL, then %G_CONVERT_ERROR_PARTIAL_INPUT will be returned in case @str contains a trailing partial character. If an error occurs then the index of the invalid input is stored here. location to store number of #gunichar2 written, or %NULL. The value stored here does not include the trailing 0. Validates UTF-8 encoded text. @str is the text to validate; if @str is nul-terminated, then @max_len can be -1, otherwise @max_len should be the number of bytes to validate. If @end is non-%NULL, then the end of the valid range will be stored there (i.e. the start of the first invalid character if some bytes were invalid, or the end of the text being validated otherwise). Note that g_utf8_validate() returns %FALSE if @max_len is positive and any of the @max_len bytes are nul. Returns %TRUE if all of @str was valid. Many GLib and GTK+ routines require valid UTF-8 as input; so data read from a file or the network should be checked with g_utf8_validate() before doing anything else with it. %TRUE if the text was valid UTF-8 a pointer to character data max bytes to validate, or -1 to go until NUL return location for end of valid data Determines if a given string is a valid D-Bus object path. You should ensure that a string is a valid D-Bus object path before passing it to g_variant_new_object_path(). A valid object path starts with '/' followed by zero or more sequences of characters separated by '/' characters. Each sequence must contain only the characters "[A-Z][a-z][0-9]_". No sequence (including the one following the final '/' character) may be empty. %TRUE if @string is a D-Bus object path a normal C nul-terminated string Determines if a given string is a valid D-Bus type signature. You should ensure that a string is a valid D-Bus type signature before passing it to g_variant_new_signature(). D-Bus type signatures consist of zero or more definite #GVariantType strings in sequence. %TRUE if @string is a D-Bus type signature a normal C nul-terminated string Parses a #GVariant from a text representation. A single #GVariant is parsed from the content of @text. The format is described [here][gvariant-text]. The memory at @limit will never be accessed and the parser behaves as if the character at @limit is the nul terminator. This has the effect of bounding @text. If @endptr is non-%NULL then @text is permitted to contain data following the value that this function parses and @endptr will be updated to point to the first character past the end of the text parsed by this function. If @endptr is %NULL and there is extra data then an error is returned. If @type is non-%NULL then the value will be parsed to have that type. This may result in additional parse errors (in the case that the parsed value doesn't fit the type) but may also result in fewer errors (in the case that the type would have been ambiguous, such as with empty arrays). In the event that the parsing is successful, the resulting #GVariant is returned. In case of any error, %NULL will be returned. If @error is non-%NULL then it will be set to reflect the error that occurred. Officially, the language understood by the parser is "any string produced by g_variant_print()". a reference to a #GVariant, or %NULL a #GVariantType, or %NULL a string containing a GVariant in text form a pointer to the end of @text, or %NULL a location to store the end pointer, or %NULL Pretty-prints a message showing the context of a #GVariant parse error within the string for which parsing was attempted. The resulting string is suitable for output to the console or other monospace media where newlines are treated in the usual way. The message will typically look something like one of the following: |[ unterminated string constant: (1, 2, 3, 'abc ^^^^ ]| or |[ unable to find a common type: [1, 2, 3, 'str'] ^ ^^^^^ ]| The format of the message may change in a future version. @error must have come from a failed attempt to g_variant_parse() and @source_str must be exactly the same string that caused the error. If @source_str was not nul-terminated when you passed it to g_variant_parse() then you must add nul termination before using this function. the printed message a #GError from the #GVariantParseError domain the string that was given to the parser Same as g_variant_error_quark(). Use g_variant_parse_error_quark() instead. Checks if @type_string is a valid GVariant type string. This call is equivalent to calling g_variant_type_string_scan() and confirming that the following character is a nul terminator. %TRUE if @type_string is exactly one valid type string Since 2.24 a pointer to any string Scan for a single complete and valid GVariant type string in @string. The memory pointed to by @limit (or bytes beyond it) is never accessed. If a valid type string is found, @endptr is updated to point to the first character past the end of the string that was found and %TRUE is returned. If there is no valid type string starting at @string, or if the type string does not end before @limit then %FALSE is returned. For the simple case of checking if a string is a valid type string, see g_variant_type_string_is_valid(). %TRUE if a valid type string was found a pointer to any string the end of @string, or %NULL location to store the end pointer, or %NULL An implementation of the GNU vasprintf() function which supports positional parameters, as specified in the Single Unix Specification. This function is similar to g_vsprintf(), except that it allocates a string to hold the output, instead of putting the output in a buffer you allocate in advance. the number of bytes printed. the return location for the newly-allocated string. a standard printf() format string, but notice [string precision pitfalls][string-precision] the list of arguments to insert in the output. An implementation of the standard fprintf() function which supports positional parameters, as specified in the Single Unix Specification. the number of bytes printed. the stream to write to. a standard printf() format string, but notice [string precision pitfalls][string-precision] the list of arguments to insert in the output. An implementation of the standard vprintf() function which supports positional parameters, as specified in the Single Unix Specification. the number of bytes printed. a standard printf() format string, but notice [string precision pitfalls][string-precision] the list of arguments to insert in the output. A safer form of the standard vsprintf() function. The output is guaranteed to not exceed @n characters (including the terminating nul character), so it is easy to ensure that a buffer overflow cannot occur. See also g_strdup_vprintf(). In versions of GLib prior to 1.2.3, this function may return -1 if the output was truncated, and the truncated string may not be nul-terminated. In versions prior to 1.3.12, this function returns the length of the output string. The return value of g_vsnprintf() conforms to the vsnprintf() function as standardized in ISO C99. Note that this is different from traditional vsnprintf(), which returns the length of the output string. The format string may contain positional parameters, as specified in the Single Unix Specification. the number of bytes which would be produced if the buffer was large enough. the buffer to hold the output. the maximum number of bytes to produce (including the terminating nul character). a standard printf() format string, but notice string precision pitfalls][string-precision] the list of arguments to insert in the output. An implementation of the standard vsprintf() function which supports positional parameters, as specified in the Single Unix Specification. the number of bytes printed. the buffer to hold the output. a standard printf() format string, but notice [string precision pitfalls][string-precision] the list of arguments to insert in the output. gtkada-24.0.0/contrib/GObject-2.0.gir000066400000000000000000050036571446021174000170240ustar00rootroot00000000000000 This is the signature of marshaller functions, required to marshall arrays of parameter values to signal emissions into C language callback invocations. It is merely an alias to #GClosureMarshal since the #GClosure mechanism takes over responsibility of actual function invocation for the signal system. This is the signature of va_list marshaller functions, an optional marshaller that can be used in some situations to avoid marshalling the signal argument into GValues. A numerical value which represents the unique identifier of a registered type. A convenience macro to ease adding private data to instances of a new type in the @_C_ section of G_DEFINE_TYPE_WITH_CODE() or G_DEFINE_ABSTRACT_TYPE_WITH_CODE(). For instance: |[<!-- language="C" --> typedef struct _MyObject MyObject; typedef struct _MyObjectClass MyObjectClass; typedef struct { gint foo; gint bar; } MyObjectPrivate; G_DEFINE_TYPE_WITH_CODE (MyObject, my_object, G_TYPE_OBJECT, G_ADD_PRIVATE (MyObject)) ]| Will add MyObjectPrivate as the private data to any instance of the MyObject type. G_DEFINE_TYPE_* macros will automatically create a private function based on the arguments to this macro, which can be used to safely retrieve the private data from an instance of the type; for instance: |[<!-- language="C" --> gint my_object_get_foo (MyObject *obj) { MyObjectPrivate *priv = my_object_get_instance_private (obj); g_return_val_if_fail (MY_IS_OBJECT (obj), 0); return priv->foo; } void my_object_set_bar (MyObject *obj, gint bar) { MyObjectPrivate *priv = my_object_get_instance_private (obj); g_return_if_fail (MY_IS_OBJECT (obj)); if (priv->bar != bar) priv->bar = bar; } ]| Note that this macro can only be used together with the G_DEFINE_TYPE_* macros, since it depends on variable names from those macros. Also note that private structs added with these macros must have a struct name of the form `TypeNamePrivate`. It is safe to call the `_get_instance_private` function on %NULL or invalid objects since it's only adding an offset to the instance pointer. In that case the returned pointer must not be dereferenced. the name of the type in CamelCase A convenience macro to ease adding private data to instances of a new dynamic type in the @_C_ section of G_DEFINE_DYNAMIC_TYPE_EXTENDED(). See G_ADD_PRIVATE() for details, it is similar but for static types. Note that this macro can only be used together with the G_DEFINE_DYNAMIC_TYPE_EXTENDED macros, since it depends on variable names from that macro. the name of the type in CamelCase A callback function used by the type system to finalize those portions of a derived types class structure that were setup from the corresponding GBaseInitFunc() function. Class finalization basically works the inverse way in which class initialization is performed. See GClassInitFunc() for a discussion of the class initialization process. The #GTypeClass structure to finalize A callback function used by the type system to do base initialization of the class structures of derived types. It is called as part of the initialization process of all derived classes and should reallocate or reset all dynamic class members copied over from the parent class. For example, class members (such as strings) that are not sufficiently handled by a plain memory copy of the parent class into the derived class have to be altered. See GClassInitFunc() for a discussion of the class initialization process. The #GTypeClass structure to initialize #GBinding is the representation of a binding between a property on a #GObject instance (or source) and another property on another #GObject instance (or target). Whenever the source property changes, the same value is applied to the target property; for instance, the following binding: |[<!-- language="C" --> g_object_bind_property (object1, "property-a", object2, "property-b", G_BINDING_DEFAULT); ]| will cause the property named "property-b" of @object2 to be updated every time g_object_set() or the specific accessor changes the value of the property "property-a" of @object1. It is possible to create a bidirectional binding between two properties of two #GObject instances, so that if either property changes, the other is updated as well, for instance: |[<!-- language="C" --> g_object_bind_property (object1, "property-a", object2, "property-b", G_BINDING_BIDIRECTIONAL); ]| will keep the two properties in sync. It is also possible to set a custom transformation function (in both directions, in case of a bidirectional binding) to apply a custom transformation from the source value to the target value before applying it; for instance, the following binding: |[<!-- language="C" --> g_object_bind_property_full (adjustment1, "value", adjustment2, "value", G_BINDING_BIDIRECTIONAL, celsius_to_fahrenheit, fahrenheit_to_celsius, NULL, NULL); ]| will keep the "value" property of the two adjustments in sync; the @celsius_to_fahrenheit function will be called whenever the "value" property of @adjustment1 changes and will transform the current value of the property before applying it to the "value" property of @adjustment2. Vice versa, the @fahrenheit_to_celsius function will be called whenever the "value" property of @adjustment2 changes, and will transform the current value of the property before applying it to the "value" property of @adjustment1. Note that #GBinding does not resolve cycles by itself; a cycle like |[ object1:propertyA -> object2:propertyB object2:propertyB -> object3:propertyC object3:propertyC -> object1:propertyA ]| might lead to an infinite loop. The loop, in this particular case, can be avoided if the objects emit the #GObject::notify signal only if the value has effectively been changed. A binding is implemented using the #GObject::notify signal, so it is susceptible to all the various ways of blocking a signal emission, like g_signal_stop_emission() or g_signal_handler_block(). A binding will be severed, and the resources it allocates freed, whenever either one of the #GObject instances it refers to are finalized, or when the #GBinding instance loses its last reference. Bindings for languages with garbage collection can use g_binding_unbind() to explicitly release a binding between the source and target properties, instead of relying on the last reference on the binding, source, and target instances to drop. #GBinding is available since GObject 2.26 Retrieves the flags passed when constructing the #GBinding. the #GBindingFlags used by the #GBinding a #GBinding Retrieves the #GObject instance used as the source of the binding. the source #GObject a #GBinding Retrieves the name of the property of #GBinding:source used as the source of the binding. the name of the source property a #GBinding Retrieves the #GObject instance used as the target of the binding. the target #GObject a #GBinding Retrieves the name of the property of #GBinding:target used as the target of the binding. the name of the target property a #GBinding Explicitly releases the binding between the source and the target property expressed by @binding. This function will release the reference that is being held on the @binding instance; if you want to hold on to the #GBinding instance after calling g_binding_unbind(), you will need to hold a reference to it. a #GBinding Flags to be used to control the #GBinding The #GObject that should be used as the source of the binding The name of the property of #GBinding:source that should be used as the source of the binding. This should be in [canonical form][canonical-parameter-names] to get the best performance. The #GObject that should be used as the target of the binding The name of the property of #GBinding:target that should be used as the target of the binding. This should be in [canonical form][canonical-parameter-names] to get the best performance. Flags to be passed to g_object_bind_property() or g_object_bind_property_full(). This enumeration can be extended at later date. The default binding; if the source property changes, the target property is updated with its value. Bidirectional binding; if either the property of the source or the property of the target changes, the other is updated. Synchronize the values of the source and target properties when creating the binding; the direction of the synchronization is always from the source to the target. If the two properties being bound are booleans, setting one to %TRUE will result in the other being set to %FALSE and vice versa. This flag will only work for boolean properties, and cannot be used when passing custom transformation functions to g_object_bind_property_full(). A function to be called to transform @from_value to @to_value. If this is the @transform_to function of a binding, then @from_value is the @source_property on the @source object, and @to_value is the @target_property on the @target object. If this is the @transform_from function of a %G_BINDING_BIDIRECTIONAL binding, then those roles are reversed. %TRUE if the transformation was successful, and %FALSE otherwise a #GBinding the #GValue containing the value to transform the #GValue in which to store the transformed value data passed to the transform function This function is provided by the user and should produce a copy of the passed in boxed structure. The newly created copy of the boxed structure. The boxed structure to be copied. This function is provided by the user and should free the boxed structure passed. The boxed structure to be freed. Cast a function pointer to a #GCallback. a function pointer. Checks whether the user data of the #GCClosure should be passed as the first parameter to the callback. See g_cclosure_new_swap(). a #GCClosure A #GCClosure is a specialization of #GClosure for C function callbacks. the #GClosure the callback function A #GClosureMarshal function for use with signals with handlers that take two boxed pointers as arguments and return a boolean. If you have such a signal, you will probably also need to use an accumulator, such as g_signal_accumulator_true_handled(). A #GClosure. A #GValue to store the return value. May be %NULL if the callback of closure doesn't return a value. The length of the @param_values array. An array of #GValues holding the arguments on which to invoke the callback of closure. The invocation hint given as the last argument to g_closure_invoke(). Additional data specified when registering the marshaller, see g_closure_set_marshal() and g_closure_set_meta_marshal() The #GVaClosureMarshal equivalent to g_cclosure_marshal_BOOLEAN__BOXED_BOXED(). the #GClosure to which the marshaller belongs a #GValue to store the return value. May be %NULL if the callback of @closure doesn't return a value. the instance on which the closure is invoked. va_list of arguments to be passed to the closure. additional data specified when registering the marshaller, see g_closure_set_marshal() and g_closure_set_meta_marshal() the length of the @param_types array the #GType of each argument from @args. A marshaller for a #GCClosure with a callback of type `gboolean (*callback) (gpointer instance, gint arg1, gpointer user_data)` where the #gint parameter denotes a flags type. the #GClosure to which the marshaller belongs a #GValue which can store the returned #gboolean 2 a #GValue array holding instance and arg1 the invocation hint given as the last argument to g_closure_invoke() additional data specified when registering the marshaller The #GVaClosureMarshal equivalent to g_cclosure_marshal_BOOLEAN__FLAGS(). the #GClosure to which the marshaller belongs a #GValue to store the return value. May be %NULL if the callback of @closure doesn't return a value. the instance on which the closure is invoked. va_list of arguments to be passed to the closure. additional data specified when registering the marshaller, see g_closure_set_marshal() and g_closure_set_meta_marshal() the length of the @param_types array the #GType of each argument from @args. A marshaller for a #GCClosure with a callback of type `gchar* (*callback) (gpointer instance, GObject *arg1, gpointer arg2, gpointer user_data)`. the #GClosure to which the marshaller belongs a #GValue, which can store the returned string 3 a #GValue array holding instance, arg1 and arg2 the invocation hint given as the last argument to g_closure_invoke() additional data specified when registering the marshaller The #GVaClosureMarshal equivalent to g_cclosure_marshal_STRING__OBJECT_POINTER(). the #GClosure to which the marshaller belongs a #GValue to store the return value. May be %NULL if the callback of @closure doesn't return a value. the instance on which the closure is invoked. va_list of arguments to be passed to the closure. additional data specified when registering the marshaller, see g_closure_set_marshal() and g_closure_set_meta_marshal() the length of the @param_types array the #GType of each argument from @args. A marshaller for a #GCClosure with a callback of type `void (*callback) (gpointer instance, gboolean arg1, gpointer user_data)`. the #GClosure to which the marshaller belongs ignored 2 a #GValue array holding the instance and the #gboolean parameter the invocation hint given as the last argument to g_closure_invoke() additional data specified when registering the marshaller The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__BOOLEAN(). the #GClosure to which the marshaller belongs a #GValue to store the return value. May be %NULL if the callback of @closure doesn't return a value. the instance on which the closure is invoked. va_list of arguments to be passed to the closure. additional data specified when registering the marshaller, see g_closure_set_marshal() and g_closure_set_meta_marshal() the length of the @param_types array the #GType of each argument from @args. A marshaller for a #GCClosure with a callback of type `void (*callback) (gpointer instance, GBoxed *arg1, gpointer user_data)`. the #GClosure to which the marshaller belongs ignored 2 a #GValue array holding the instance and the #GBoxed* parameter the invocation hint given as the last argument to g_closure_invoke() additional data specified when registering the marshaller The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__BOXED(). the #GClosure to which the marshaller belongs a #GValue to store the return value. May be %NULL if the callback of @closure doesn't return a value. the instance on which the closure is invoked. va_list of arguments to be passed to the closure. additional data specified when registering the marshaller, see g_closure_set_marshal() and g_closure_set_meta_marshal() the length of the @param_types array the #GType of each argument from @args. A marshaller for a #GCClosure with a callback of type `void (*callback) (gpointer instance, gchar arg1, gpointer user_data)`. the #GClosure to which the marshaller belongs ignored 2 a #GValue array holding the instance and the #gchar parameter the invocation hint given as the last argument to g_closure_invoke() additional data specified when registering the marshaller The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__CHAR(). the #GClosure to which the marshaller belongs a #GValue to store the return value. May be %NULL if the callback of @closure doesn't return a value. the instance on which the closure is invoked. va_list of arguments to be passed to the closure. additional data specified when registering the marshaller, see g_closure_set_marshal() and g_closure_set_meta_marshal() the length of the @param_types array the #GType of each argument from @args. A marshaller for a #GCClosure with a callback of type `void (*callback) (gpointer instance, gdouble arg1, gpointer user_data)`. the #GClosure to which the marshaller belongs ignored 2 a #GValue array holding the instance and the #gdouble parameter the invocation hint given as the last argument to g_closure_invoke() additional data specified when registering the marshaller The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__DOUBLE(). the #GClosure to which the marshaller belongs a #GValue to store the return value. May be %NULL if the callback of @closure doesn't return a value. the instance on which the closure is invoked. va_list of arguments to be passed to the closure. additional data specified when registering the marshaller, see g_closure_set_marshal() and g_closure_set_meta_marshal() the length of the @param_types array the #GType of each argument from @args. A marshaller for a #GCClosure with a callback of type `void (*callback) (gpointer instance, gint arg1, gpointer user_data)` where the #gint parameter denotes an enumeration type.. the #GClosure to which the marshaller belongs ignored 2 a #GValue array holding the instance and the enumeration parameter the invocation hint given as the last argument to g_closure_invoke() additional data specified when registering the marshaller The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__ENUM(). the #GClosure to which the marshaller belongs a #GValue to store the return value. May be %NULL if the callback of @closure doesn't return a value. the instance on which the closure is invoked. va_list of arguments to be passed to the closure. additional data specified when registering the marshaller, see g_closure_set_marshal() and g_closure_set_meta_marshal() the length of the @param_types array the #GType of each argument from @args. A marshaller for a #GCClosure with a callback of type `void (*callback) (gpointer instance, gint arg1, gpointer user_data)` where the #gint parameter denotes a flags type. the #GClosure to which the marshaller belongs ignored 2 a #GValue array holding the instance and the flags parameter the invocation hint given as the last argument to g_closure_invoke() additional data specified when registering the marshaller The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__FLAGS(). the #GClosure to which the marshaller belongs a #GValue to store the return value. May be %NULL if the callback of @closure doesn't return a value. the instance on which the closure is invoked. va_list of arguments to be passed to the closure. additional data specified when registering the marshaller, see g_closure_set_marshal() and g_closure_set_meta_marshal() the length of the @param_types array the #GType of each argument from @args. A marshaller for a #GCClosure with a callback of type `void (*callback) (gpointer instance, gfloat arg1, gpointer user_data)`. the #GClosure to which the marshaller belongs ignored 2 a #GValue array holding the instance and the #gfloat parameter the invocation hint given as the last argument to g_closure_invoke() additional data specified when registering the marshaller The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__FLOAT(). the #GClosure to which the marshaller belongs a #GValue to store the return value. May be %NULL if the callback of @closure doesn't return a value. the instance on which the closure is invoked. va_list of arguments to be passed to the closure. additional data specified when registering the marshaller, see g_closure_set_marshal() and g_closure_set_meta_marshal() the length of the @param_types array the #GType of each argument from @args. A marshaller for a #GCClosure with a callback of type `void (*callback) (gpointer instance, gint arg1, gpointer user_data)`. the #GClosure to which the marshaller belongs ignored 2 a #GValue array holding the instance and the #gint parameter the invocation hint given as the last argument to g_closure_invoke() additional data specified when registering the marshaller The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__INT(). the #GClosure to which the marshaller belongs a #GValue to store the return value. May be %NULL if the callback of @closure doesn't return a value. the instance on which the closure is invoked. va_list of arguments to be passed to the closure. additional data specified when registering the marshaller, see g_closure_set_marshal() and g_closure_set_meta_marshal() the length of the @param_types array the #GType of each argument from @args. A marshaller for a #GCClosure with a callback of type `void (*callback) (gpointer instance, glong arg1, gpointer user_data)`. the #GClosure to which the marshaller belongs ignored 2 a #GValue array holding the instance and the #glong parameter the invocation hint given as the last argument to g_closure_invoke() additional data specified when registering the marshaller The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__LONG(). the #GClosure to which the marshaller belongs a #GValue to store the return value. May be %NULL if the callback of @closure doesn't return a value. the instance on which the closure is invoked. va_list of arguments to be passed to the closure. additional data specified when registering the marshaller, see g_closure_set_marshal() and g_closure_set_meta_marshal() the length of the @param_types array the #GType of each argument from @args. A marshaller for a #GCClosure with a callback of type `void (*callback) (gpointer instance, GObject *arg1, gpointer user_data)`. the #GClosure to which the marshaller belongs ignored 2 a #GValue array holding the instance and the #GObject* parameter the invocation hint given as the last argument to g_closure_invoke() additional data specified when registering the marshaller The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__OBJECT(). the #GClosure to which the marshaller belongs a #GValue to store the return value. May be %NULL if the callback of @closure doesn't return a value. the instance on which the closure is invoked. va_list of arguments to be passed to the closure. additional data specified when registering the marshaller, see g_closure_set_marshal() and g_closure_set_meta_marshal() the length of the @param_types array the #GType of each argument from @args. A marshaller for a #GCClosure with a callback of type `void (*callback) (gpointer instance, GParamSpec *arg1, gpointer user_data)`. the #GClosure to which the marshaller belongs ignored 2 a #GValue array holding the instance and the #GParamSpec* parameter the invocation hint given as the last argument to g_closure_invoke() additional data specified when registering the marshaller The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__PARAM(). the #GClosure to which the marshaller belongs a #GValue to store the return value. May be %NULL if the callback of @closure doesn't return a value. the instance on which the closure is invoked. va_list of arguments to be passed to the closure. additional data specified when registering the marshaller, see g_closure_set_marshal() and g_closure_set_meta_marshal() the length of the @param_types array the #GType of each argument from @args. A marshaller for a #GCClosure with a callback of type `void (*callback) (gpointer instance, gpointer arg1, gpointer user_data)`. the #GClosure to which the marshaller belongs ignored 2 a #GValue array holding the instance and the #gpointer parameter the invocation hint given as the last argument to g_closure_invoke() additional data specified when registering the marshaller The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__POINTER(). the #GClosure to which the marshaller belongs a #GValue to store the return value. May be %NULL if the callback of @closure doesn't return a value. the instance on which the closure is invoked. va_list of arguments to be passed to the closure. additional data specified when registering the marshaller, see g_closure_set_marshal() and g_closure_set_meta_marshal() the length of the @param_types array the #GType of each argument from @args. A marshaller for a #GCClosure with a callback of type `void (*callback) (gpointer instance, const gchar *arg1, gpointer user_data)`. the #GClosure to which the marshaller belongs ignored 2 a #GValue array holding the instance and the #gchar* parameter the invocation hint given as the last argument to g_closure_invoke() additional data specified when registering the marshaller The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__STRING(). the #GClosure to which the marshaller belongs a #GValue to store the return value. May be %NULL if the callback of @closure doesn't return a value. the instance on which the closure is invoked. va_list of arguments to be passed to the closure. additional data specified when registering the marshaller, see g_closure_set_marshal() and g_closure_set_meta_marshal() the length of the @param_types array the #GType of each argument from @args. A marshaller for a #GCClosure with a callback of type `void (*callback) (gpointer instance, guchar arg1, gpointer user_data)`. the #GClosure to which the marshaller belongs ignored 2 a #GValue array holding the instance and the #guchar parameter the invocation hint given as the last argument to g_closure_invoke() additional data specified when registering the marshaller The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__UCHAR(). the #GClosure to which the marshaller belongs a #GValue to store the return value. May be %NULL if the callback of @closure doesn't return a value. the instance on which the closure is invoked. va_list of arguments to be passed to the closure. additional data specified when registering the marshaller, see g_closure_set_marshal() and g_closure_set_meta_marshal() the length of the @param_types array the #GType of each argument from @args. A marshaller for a #GCClosure with a callback of type `void (*callback) (gpointer instance, guint arg1, gpointer user_data)`. the #GClosure to which the marshaller belongs ignored 2 a #GValue array holding the instance and the #guint parameter the invocation hint given as the last argument to g_closure_invoke() additional data specified when registering the marshaller A marshaller for a #GCClosure with a callback of type `void (*callback) (gpointer instance, guint arg1, gpointer arg2, gpointer user_data)`. the #GClosure to which the marshaller belongs ignored 3 a #GValue array holding instance, arg1 and arg2 the invocation hint given as the last argument to g_closure_invoke() additional data specified when registering the marshaller The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__UINT_POINTER(). the #GClosure to which the marshaller belongs a #GValue to store the return value. May be %NULL if the callback of @closure doesn't return a value. the instance on which the closure is invoked. va_list of arguments to be passed to the closure. additional data specified when registering the marshaller, see g_closure_set_marshal() and g_closure_set_meta_marshal() the length of the @param_types array the #GType of each argument from @args. The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__UINT(). the #GClosure to which the marshaller belongs a #GValue to store the return value. May be %NULL if the callback of @closure doesn't return a value. the instance on which the closure is invoked. va_list of arguments to be passed to the closure. additional data specified when registering the marshaller, see g_closure_set_marshal() and g_closure_set_meta_marshal() the length of the @param_types array the #GType of each argument from @args. A marshaller for a #GCClosure with a callback of type `void (*callback) (gpointer instance, gulong arg1, gpointer user_data)`. the #GClosure to which the marshaller belongs ignored 2 a #GValue array holding the instance and the #gulong parameter the invocation hint given as the last argument to g_closure_invoke() additional data specified when registering the marshaller The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__ULONG(). the #GClosure to which the marshaller belongs a #GValue to store the return value. May be %NULL if the callback of @closure doesn't return a value. the instance on which the closure is invoked. va_list of arguments to be passed to the closure. additional data specified when registering the marshaller, see g_closure_set_marshal() and g_closure_set_meta_marshal() the length of the @param_types array the #GType of each argument from @args. A marshaller for a #GCClosure with a callback of type `void (*callback) (gpointer instance, GVariant *arg1, gpointer user_data)`. the #GClosure to which the marshaller belongs ignored 2 a #GValue array holding the instance and the #GVariant* parameter the invocation hint given as the last argument to g_closure_invoke() additional data specified when registering the marshaller The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__VARIANT(). the #GClosure to which the marshaller belongs a #GValue to store the return value. May be %NULL if the callback of @closure doesn't return a value. the instance on which the closure is invoked. va_list of arguments to be passed to the closure. additional data specified when registering the marshaller, see g_closure_set_marshal() and g_closure_set_meta_marshal() the length of the @param_types array the #GType of each argument from @args. A marshaller for a #GCClosure with a callback of type `void (*callback) (gpointer instance, gpointer user_data)`. the #GClosure to which the marshaller belongs ignored 1 a #GValue array holding only the instance the invocation hint given as the last argument to g_closure_invoke() additional data specified when registering the marshaller The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__VOID(). the #GClosure to which the marshaller belongs a #GValue to store the return value. May be %NULL if the callback of @closure doesn't return a value. the instance on which the closure is invoked. va_list of arguments to be passed to the closure. additional data specified when registering the marshaller, see g_closure_set_marshal() and g_closure_set_meta_marshal() the length of the @param_types array the #GType of each argument from @args. A generic marshaller function implemented via [libffi](http://sourceware.org/libffi/). Normally this function is not passed explicitly to g_signal_new(), but used automatically by GLib when specifying a %NULL marshaller. A #GClosure. A #GValue to store the return value. May be %NULL if the callback of closure doesn't return a value. The length of the @param_values array. An array of #GValues holding the arguments on which to invoke the callback of closure. The invocation hint given as the last argument to g_closure_invoke(). Additional data specified when registering the marshaller, see g_closure_set_marshal() and g_closure_set_meta_marshal() A generic #GVaClosureMarshal function implemented via [libffi](http://sourceware.org/libffi/). the #GClosure to which the marshaller belongs a #GValue to store the return value. May be %NULL if the callback of @closure doesn't return a value. the instance on which the closure is invoked. va_list of arguments to be passed to the closure. additional data specified when registering the marshaller, see g_closure_set_marshal() and g_closure_set_meta_marshal() the length of the @param_types array the #GType of each argument from @args_list. Creates a new closure which invokes @callback_func with @user_data as the last parameter. @destroy_data will be called as a finalize notifier on the #GClosure. a floating reference to a new #GCClosure the function to invoke user data to pass to @callback_func destroy notify to be called when @user_data is no longer used A variant of g_cclosure_new() which uses @object as @user_data and calls g_object_watch_closure() on @object and the created closure. This function is useful when you have a callback closely associated with a #GObject, and want the callback to no longer run after the object is is freed. a new #GCClosure the function to invoke a #GObject pointer to pass to @callback_func A variant of g_cclosure_new_swap() which uses @object as @user_data and calls g_object_watch_closure() on @object and the created closure. This function is useful when you have a callback closely associated with a #GObject, and want the callback to no longer run after the object is is freed. a new #GCClosure the function to invoke a #GObject pointer to pass to @callback_func Creates a new closure which invokes @callback_func with @user_data as the first parameter. @destroy_data will be called as a finalize notifier on the #GClosure. a floating reference to a new #GCClosure the function to invoke user data to pass to @callback_func destroy notify to be called when @user_data is no longer used Check if the closure still needs a marshaller. See g_closure_set_marshal(). a #GClosure Get the total number of notifiers connected with the closure @cl. The count includes the meta marshaller, the finalize and invalidate notifiers and the marshal guards. Note that each guard counts as two notifiers. See g_closure_set_meta_marshal(), g_closure_add_finalize_notifier(), g_closure_add_invalidate_notifier() and g_closure_add_marshal_guards(). a #GClosure The type used for callback functions in structure definitions and function signatures. This doesn't mean that all callback functions must take no parameters and return void. The required signature of a callback function is determined by the context in which is used (e.g. the signal to which it is connected). Use G_CALLBACK() to cast the callback function to a #GCallback. A callback function used by the type system to finalize a class. This function is rarely needed, as dynamically allocated class resources should be handled by GBaseInitFunc() and GBaseFinalizeFunc(). Also, specification of a GClassFinalizeFunc() in the #GTypeInfo structure of a static type is invalid, because classes of static types will never be finalized (they are artificially kept alive when their reference count drops to zero). The #GTypeClass structure to finalize The @class_data member supplied via the #GTypeInfo structure A callback function used by the type system to initialize the class of a specific type. This function should initialize all static class members. The initialization process of a class involves: - Copying common members from the parent class over to the derived class structure. - Zero initialization of the remaining members not copied over from the parent class. - Invocation of the GBaseInitFunc() initializers of all parent types and the class' type. - Invocation of the class' GClassInitFunc() initializer. Since derived classes are partially initialized through a memory copy of the parent class, the general rule is that GBaseInitFunc() and GBaseFinalizeFunc() should take care of necessary reinitialization and release of those class members that were introduced by the type that specified these GBaseInitFunc()/GBaseFinalizeFunc(). GClassInitFunc() should only care about initializing static class members, while dynamic class members (such as allocated strings or reference counted resources) are better handled by a GBaseInitFunc() for this type, so proper initialization of the dynamic class members is performed for class initialization of derived types as well. An example may help to correspond the intend of the different class initializers: |[<!-- language="C" --> typedef struct { GObjectClass parent_class; gint static_integer; gchar *dynamic_string; } TypeAClass; static void type_a_base_class_init (TypeAClass *class) { class->dynamic_string = g_strdup ("some string"); } static void type_a_base_class_finalize (TypeAClass *class) { g_free (class->dynamic_string); } static void type_a_class_init (TypeAClass *class) { class->static_integer = 42; } typedef struct { TypeAClass parent_class; gfloat static_float; GString *dynamic_gstring; } TypeBClass; static void type_b_base_class_init (TypeBClass *class) { class->dynamic_gstring = g_string_new ("some other string"); } static void type_b_base_class_finalize (TypeBClass *class) { g_string_free (class->dynamic_gstring); } static void type_b_class_init (TypeBClass *class) { class->static_float = 3.14159265358979323846; } ]| Initialization of TypeBClass will first cause initialization of TypeAClass (derived classes reference their parent classes, see g_type_class_ref() on this). Initialization of TypeAClass roughly involves zero-initializing its fields, then calling its GBaseInitFunc() type_a_base_class_init() to allocate its dynamic members (dynamic_string), and finally calling its GClassInitFunc() type_a_class_init() to initialize its static members (static_integer). The first step in the initialization process of TypeBClass is then a plain memory copy of the contents of TypeAClass into TypeBClass and zero-initialization of the remaining fields in TypeBClass. The dynamic members of TypeAClass within TypeBClass now need reinitialization which is performed by calling type_a_base_class_init() with an argument of TypeBClass. After that, the GBaseInitFunc() of TypeBClass, type_b_base_class_init() is called to allocate the dynamic members of TypeBClass (dynamic_gstring), and finally the GClassInitFunc() of TypeBClass, type_b_class_init(), is called to complete the initialization process with the static members (static_float). Corresponding finalization counter parts to the GBaseInitFunc() functions have to be provided to release allocated resources at class finalization time. The #GTypeClass structure to initialize. The @class_data member supplied via the #GTypeInfo structure. A #GClosure represents a callback supplied by the programmer. It will generally comprise a function of some kind and a marshaller used to call it. It is the responsibility of the marshaller to convert the arguments for the invocation from #GValues into a suitable form, perform the callback on the converted arguments, and transform the return value back into a #GValue. In the case of C programs, a closure usually just holds a pointer to a function and maybe a data argument, and the marshaller converts between #GValue and native C types. The GObject library provides the #GCClosure type for this purpose. Bindings for other languages need marshallers which convert between #GValues and suitable representations in the runtime of the language in order to use functions written in that language as callbacks. Use g_closure_set_marshal() to set the marshaller on such a custom closure implementation. Within GObject, closures play an important role in the implementation of signals. When a signal is registered, the @c_marshaller argument to g_signal_new() specifies the default C marshaller for any closure which is connected to this signal. GObject provides a number of C marshallers for this purpose, see the g_cclosure_marshal_*() functions. Additional C marshallers can be generated with the [glib-genmarshal][glib-genmarshal] utility. Closures can be explicitly connected to signals with g_signal_connect_closure(), but it usually more convenient to let GObject create a closure automatically by using one of the g_signal_connect_*() functions which take a callback function/user data pair. Using closures has a number of important advantages over a simple callback function/data pointer combination: - Closures allow the callee to get the types of the callback parameters, which means that language bindings don't have to write individual glue for each callback type. - The reference counting of #GClosure makes it easy to handle reentrancy right; if a callback is removed while it is being invoked, the closure and its parameters won't be freed until the invocation finishes. - g_closure_invalidate() and invalidation notifiers allow callbacks to be automatically removed when the objects they point to go away. Indicates whether the closure is currently being invoked with g_closure_invoke() Indicates whether the closure has been invalidated by g_closure_invalidate() A variant of g_closure_new_simple() which stores @object in the @data field of the closure and calls g_object_watch_closure() on @object and the created closure. This function is mainly useful when implementing new types of closures. a newly allocated #GClosure the size of the structure to allocate, must be at least `sizeof (GClosure)` a #GObject pointer to store in the @data field of the newly allocated #GClosure Allocates a struct of the given size and initializes the initial part as a #GClosure. This function is mainly useful when implementing new types of closures. |[<!-- language="C" --> typedef struct _MyClosure MyClosure; struct _MyClosure { GClosure closure; // extra data goes here }; static void my_closure_finalize (gpointer notify_data, GClosure *closure) { MyClosure *my_closure = (MyClosure *)closure; // free extra data here } MyClosure *my_closure_new (gpointer data) { GClosure *closure; MyClosure *my_closure; closure = g_closure_new_simple (sizeof (MyClosure), data); my_closure = (MyClosure *) closure; // initialize extra data here g_closure_add_finalize_notifier (closure, notify_data, my_closure_finalize); return my_closure; } ]| a floating reference to a new #GClosure the size of the structure to allocate, must be at least `sizeof (GClosure)` data to store in the @data field of the newly allocated #GClosure Registers a finalization notifier which will be called when the reference count of @closure goes down to 0. Multiple finalization notifiers on a single closure are invoked in unspecified order. If a single call to g_closure_unref() results in the closure being both invalidated and finalized, then the invalidate notifiers will be run before the finalize notifiers. a #GClosure data to pass to @notify_func the callback function to register Registers an invalidation notifier which will be called when the @closure is invalidated with g_closure_invalidate(). Invalidation notifiers are invoked before finalization notifiers, in an unspecified order. a #GClosure data to pass to @notify_func the callback function to register Adds a pair of notifiers which get invoked before and after the closure callback, respectively. This is typically used to protect the extra arguments for the duration of the callback. See g_object_watch_closure() for an example of marshal guards. a #GClosure data to pass to @pre_marshal_notify a function to call before the closure callback data to pass to @post_marshal_notify a function to call after the closure callback Sets a flag on the closure to indicate that its calling environment has become invalid, and thus causes any future invocations of g_closure_invoke() on this @closure to be ignored. Also, invalidation notifiers installed on the closure will be called at this point. Note that unless you are holding a reference to the closure yourself, the invalidation notifiers may unref the closure and cause it to be destroyed, so if you need to access the closure after calling g_closure_invalidate(), make sure that you've previously called g_closure_ref(). Note that g_closure_invalidate() will also be called when the reference count of a closure drops to zero (unless it has already been invalidated before). #GClosure to invalidate Invokes the closure, i.e. executes the callback represented by the @closure. a #GClosure a #GValue to store the return value. May be %NULL if the callback of @closure doesn't return a value. the length of the @param_values array an array of #GValues holding the arguments on which to invoke the callback of @closure a context-dependent invocation hint Increments the reference count on a closure to force it staying alive while the caller holds a pointer to it. The @closure passed in, for convenience #GClosure to increment the reference count on Removes a finalization notifier. Notice that notifiers are automatically removed after they are run. a #GClosure data which was passed to g_closure_add_finalize_notifier() when registering @notify_func the callback function to remove Removes an invalidation notifier. Notice that notifiers are automatically removed after they are run. a #GClosure data which was passed to g_closure_add_invalidate_notifier() when registering @notify_func the callback function to remove Sets the marshaller of @closure. The `marshal_data` of @marshal provides a way for a meta marshaller to provide additional information to the marshaller. (See g_closure_set_meta_marshal().) For GObject's C predefined marshallers (the g_cclosure_marshal_*() functions), what it provides is a callback function to use instead of @closure->callback. a #GClosure a #GClosureMarshal function Sets the meta marshaller of @closure. A meta marshaller wraps @closure->marshal and modifies the way it is called in some fashion. The most common use of this facility is for C callbacks. The same marshallers (generated by [glib-genmarshal][glib-genmarshal]), are used everywhere, but the way that we get the callback function differs. In most cases we want to use @closure->callback, but in other cases we want to use some different technique to retrieve the callback function. For example, class closures for signals (see g_signal_type_cclosure_new()) retrieve the callback function from a fixed offset in the class structure. The meta marshaller retrieves the right callback and passes it to the marshaller as the @marshal_data argument. a #GClosure context-dependent data to pass to @meta_marshal a #GClosureMarshal function Takes over the initial ownership of a closure. Each closure is initially created in a "floating" state, which means that the initial reference count is not owned by any caller. g_closure_sink() checks to see if the object is still floating, and if so, unsets the floating state and decreases the reference count. If the closure is not floating, g_closure_sink() does nothing. The reason for the existence of the floating state is to prevent cumbersome code sequences like: |[<!-- language="C" --> closure = g_cclosure_new (cb_func, cb_data); g_source_set_closure (source, closure); g_closure_unref (closure); // GObject doesn't really need this ]| Because g_source_set_closure() (and similar functions) take ownership of the initial reference count, if it is unowned, we instead can write: |[<!-- language="C" --> g_source_set_closure (source, g_cclosure_new (cb_func, cb_data)); ]| Generally, this function is used together with g_closure_ref(). An example of storing a closure for later notification looks like: |[<!-- language="C" --> static GClosure *notify_closure = NULL; void foo_notify_set_closure (GClosure *closure) { if (notify_closure) g_closure_unref (notify_closure); notify_closure = closure; if (notify_closure) { g_closure_ref (notify_closure); g_closure_sink (notify_closure); } } ]| Because g_closure_sink() may decrement the reference count of a closure (if it hasn't been called on @closure yet) just like g_closure_unref(), g_closure_ref() should be called prior to this function. #GClosure to decrement the initial reference count on, if it's still being held Decrements the reference count of a closure after it was previously incremented by the same caller. If no other callers are using the closure, then the closure will be destroyed and freed. #GClosure to decrement the reference count on The type used for marshaller functions. the #GClosure to which the marshaller belongs a #GValue to store the return value. May be %NULL if the callback of @closure doesn't return a value. the length of the @param_values array an array of #GValues holding the arguments on which to invoke the callback of @closure the invocation hint given as the last argument to g_closure_invoke() additional data specified when registering the marshaller, see g_closure_set_marshal() and g_closure_set_meta_marshal() The type used for the various notification callbacks which can be registered on closures. data specified when registering the notification callback the #GClosure on which the notification is emitted The connection flags are used to specify the behaviour of a signal's connection. whether the handler should be called before or after the default handler of the signal. whether the instance and data should be swapped when calling the handler; see g_signal_connect_swapped() for an example. A convenience macro for emitting the usual declarations in the header file for a type which is intended to be subclassed. You might use it in a header as follows: |[ #ifndef _gtk_frobber_h_ #define _gtk_frobber_h_ #define GTK_TYPE_FROBBER gtk_frobber_get_type () GDK_AVAILABLE_IN_3_12 G_DECLARE_DERIVABLE_TYPE (GtkFrobber, gtk_frobber, GTK, FROBBER, GtkWidget) struct _GtkFrobberClass { GtkWidgetClass parent_class; void (* handle_frob) (GtkFrobber *frobber, guint n_frobs); gpointer padding[12]; }; GtkWidget * gtk_frobber_new (void); ... #endif ]| This results in the following things happening: - the usual gtk_frobber_get_type() function is declared with a return type of #GType - the GtkFrobber struct is created with GtkWidget as the first and only item. You are expected to use a private structure from your .c file to store your instance variables. - the GtkFrobberClass type is defined as a typedef to struct _GtkFrobberClass, which is left undefined. You should do this from the header file directly after you use the macro. - the GTK_FROBBER() and GTK_FROBBER_CLASS() casts are emitted as static inline functions along with the GTK_IS_FROBBER() and GTK_IS_FROBBER_CLASS() type checking functions and GTK_FROBBER_GET_CLASS() function. - g_autoptr() support being added for your type, based on the type of your parent class You can only use this function if your parent type also supports g_autoptr(). Because the type macro (GTK_TYPE_FROBBER in the above example) is not a callable, you must continue to manually define this as a macro for yourself. The declaration of the _get_type() function is the first thing emitted by the macro. This allows this macro to be used in the usual way with export control and API versioning macros. If you are writing a library, it is important to note that it is possible to convert a type from using G_DECLARE_FINAL_TYPE() to G_DECLARE_DERIVABLE_TYPE() without breaking API or ABI. As a precaution, you should therefore use G_DECLARE_FINAL_TYPE() until you are sure that it makes sense for your class to be subclassed. Once a class structure has been exposed it is not possible to change its size or remove or reorder items without breaking the API and/or ABI. If you want to declare your own class structure, use G_DECLARE_DERIVABLE_TYPE(). If you want to declare a class without exposing the class or instance structures, use G_DECLARE_FINAL_TYPE(). If you must use G_DECLARE_DERIVABLE_TYPE() you should be sure to include some padding at the bottom of your class structure to leave space for the addition of future virtual functions. The name of the new type, in camel case (like GtkWidget) The name of the new type in lowercase, with words separated by '_' (like 'gtk_widget') The name of the module, in all caps (like 'GTK') The bare name of the type, in all caps (like 'WIDGET') the name of the parent type, in camel case (like GtkWidget) A convenience macro for emitting the usual declarations in the header file for a type which is not (at the present time) intended to be subclassed. You might use it in a header as follows: |[ #ifndef _myapp_window_h_ #define _myapp_window_h_ #include <gtk/gtk.h> #define MY_APP_TYPE_WINDOW my_app_window_get_type () G_DECLARE_FINAL_TYPE (MyAppWindow, my_app_window, MY_APP, WINDOW, GtkWindow) MyAppWindow * my_app_window_new (void); ... #endif ]| This results in the following things happening: - the usual my_app_window_get_type() function is declared with a return type of #GType - the MyAppWindow types is defined as a typedef of struct _MyAppWindow. The struct itself is not defined and should be defined from the .c file before G_DEFINE_TYPE() is used. - the MY_APP_WINDOW() cast is emitted as static inline function along with the MY_APP_IS_WINDOW() type checking function - the MyAppWindowClass type is defined as a struct containing GtkWindowClass. This is done for the convenience of the person defining the type and should not be considered to be part of the ABI. In particular, without a firm declaration of the instance structure, it is not possible to subclass the type and therefore the fact that the size of the class structure is exposed is not a concern and it can be freely changed at any point in the future. - g_autoptr() support being added for your type, based on the type of your parent class You can only use this function if your parent type also supports g_autoptr(). Because the type macro (MY_APP_TYPE_WINDOW in the above example) is not a callable, you must continue to manually define this as a macro for yourself. The declaration of the _get_type() function is the first thing emitted by the macro. This allows this macro to be used in the usual way with export control and API versioning macros. If you want to declare your own class structure, use G_DECLARE_DERIVABLE_TYPE(). If you are writing a library, it is important to note that it is possible to convert a type from using G_DECLARE_FINAL_TYPE() to G_DECLARE_DERIVABLE_TYPE() without breaking API or ABI. As a precaution, you should therefore use G_DECLARE_FINAL_TYPE() until you are sure that it makes sense for your class to be subclassed. Once a class structure has been exposed it is not possible to change its size or remove or reorder items without breaking the API and/or ABI. The name of the new type, in camel case (like GtkWidget) The name of the new type in lowercase, with words separated by '_' (like 'gtk_widget') The name of the module, in all caps (like 'GTK') The bare name of the type, in all caps (like 'WIDGET') the name of the parent type, in camel case (like GtkWidget) A convenience macro for emitting the usual declarations in the header file for a GInterface type. You might use it in a header as follows: |[ #ifndef _my_model_h_ #define _my_model_h_ #define MY_TYPE_MODEL my_model_get_type () GDK_AVAILABLE_IN_3_12 G_DECLARE_INTERFACE (MyModel, my_model, MY, MODEL, GObject) struct _MyModelInterface { GTypeInterface g_iface; gpointer (* get_item) (MyModel *model); }; gpointer my_model_get_item (MyModel *model); ... #endif ]| This results in the following things happening: - the usual my_model_get_type() function is declared with a return type of #GType - the MyModelInterface type is defined as a typedef to struct _MyModelInterface, which is left undefined. You should do this from the header file directly after you use the macro. - the MY_MODEL() cast is emitted as static inline functions along with the MY_IS_MODEL() type checking function and MY_MODEL_GET_IFACE() function. - g_autoptr() support being added for your type, based on your prerequisite type. You can only use this function if your prerequisite type also supports g_autoptr(). Because the type macro (MY_TYPE_MODEL in the above example) is not a callable, you must continue to manually define this as a macro for yourself. The declaration of the _get_type() function is the first thing emitted by the macro. This allows this macro to be used in the usual way with export control and API versioning macros. The name of the new type, in camel case (like GtkWidget) The name of the new type in lowercase, with words separated by '_' (like 'gtk_widget') The name of the module, in all caps (like 'GTK') The bare name of the type, in all caps (like 'WIDGET') the name of the prerequisite type, in camel case (like GtkWidget) A convenience macro for type implementations. Similar to G_DEFINE_TYPE(), but defines an abstract type. See G_DEFINE_TYPE_EXTENDED() for an example. The name of the new type, in Camel case. The name of the new type, in lowercase, with words separated by '_'. The #GType of the parent type. A convenience macro for type implementations. Similar to G_DEFINE_TYPE_WITH_CODE(), but defines an abstract type and allows you to insert custom code into the *_get_type() function, e.g. interface implementations via G_IMPLEMENT_INTERFACE(). See G_DEFINE_TYPE_EXTENDED() for an example. The name of the new type, in Camel case. The name of the new type, in lowercase, with words separated by '_'. The #GType of the parent type. Custom code that gets inserted in the @type_name_get_type() function. Similar to G_DEFINE_TYPE_WITH_PRIVATE(), but defines an abstract type. See G_DEFINE_TYPE_EXTENDED() for an example. The name of the new type, in Camel case. The name of the new type, in lowercase, with words separated by '_'. The #GType of the parent type. A convenience macro for boxed type implementations, which defines a type_name_get_type() function registering the boxed type. The name of the new type, in Camel case The name of the new type, in lowercase, with words separated by '_' the #GBoxedCopyFunc for the new type the #GBoxedFreeFunc for the new type A convenience macro for boxed type implementations. Similar to G_DEFINE_BOXED_TYPE(), but allows to insert custom code into the type_name_get_type() function, e.g. to register value transformations with g_value_register_transform_func(), for instance: |[<!-- language="C" --> G_DEFINE_BOXED_TYPE_WITH_CODE (GdkRectangle, gdk_rectangle, gdk_rectangle_copy, gdk_rectangle_free, register_rectangle_transform_funcs (g_define_type_id)) ]| Similarly to the %G_DEFINE_TYPE family of macros, the #GType of the newly defined boxed type is exposed in the `g_define_type_id` variable. The name of the new type, in Camel case The name of the new type, in lowercase, with words separated by '_' the #GBoxedCopyFunc for the new type the #GBoxedFreeFunc for the new type Custom code that gets inserted in the *_get_type() function A convenience macro for dynamic type implementations, which declares a class initialization function, an instance initialization function (see #GTypeInfo for information about these) and a static variable named `t_n`_parent_class pointing to the parent class. Furthermore, it defines a `*_get_type()` and a static `*_register_type()` functions for use in your `module_init()`. See G_DEFINE_DYNAMIC_TYPE_EXTENDED() for an example. The name of the new type, in Camel case. The name of the new type, in lowercase, with words separated by '_'. The #GType of the parent type. A more general version of G_DEFINE_DYNAMIC_TYPE() which allows to specify #GTypeFlags and custom code. |[ G_DEFINE_DYNAMIC_TYPE_EXTENDED (GtkGadget, gtk_gadget, GTK_TYPE_THING, 0, G_IMPLEMENT_INTERFACE_DYNAMIC (TYPE_GIZMO, gtk_gadget_gizmo_init)); ]| expands to |[ static void gtk_gadget_init (GtkGadget *self); static void gtk_gadget_class_init (GtkGadgetClass *klass); static void gtk_gadget_class_finalize (GtkGadgetClass *klass); static gpointer gtk_gadget_parent_class = NULL; static GType gtk_gadget_type_id = 0; static void gtk_gadget_class_intern_init (gpointer klass) { gtk_gadget_parent_class = g_type_class_peek_parent (klass); gtk_gadget_class_init ((GtkGadgetClass*) klass); } GType gtk_gadget_get_type (void) { return gtk_gadget_type_id; } static void gtk_gadget_register_type (GTypeModule *type_module) { const GTypeInfo g_define_type_info = { sizeof (GtkGadgetClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) gtk_gadget_class_intern_init, (GClassFinalizeFunc) gtk_gadget_class_finalize, NULL, // class_data sizeof (GtkGadget), 0, // n_preallocs (GInstanceInitFunc) gtk_gadget_init, NULL // value_table }; gtk_gadget_type_id = g_type_module_register_type (type_module, GTK_TYPE_THING, "GtkGadget", &g_define_type_info, (GTypeFlags) flags); { const GInterfaceInfo g_implement_interface_info = { (GInterfaceInitFunc) gtk_gadget_gizmo_init }; g_type_module_add_interface (type_module, g_define_type_id, TYPE_GIZMO, &g_implement_interface_info); } } ]| The name of the new type, in Camel case. The name of the new type, in lowercase, with words separated by '_'. The #GType of the parent type. #GTypeFlags to pass to g_type_module_register_type() Custom code that gets inserted in the *_get_type() function. A convenience macro for #GTypeInterface definitions, which declares a default vtable initialization function and defines a *_get_type() function. The macro expects the interface initialization function to have the name `t_n ## _default_init`, and the interface structure to have the name `TN ## Interface`. The initialization function has signature `static void t_n ## _default_init (TypeName##Interface *klass);`, rather than the full #GInterfaceInitFunc signature, for brevity and convenience. If you need to use an initialization function with an `iface_data` argument, you must write the #GTypeInterface definitions manually. The name of the new type, in Camel case. The name of the new type, in lowercase, with words separated by '_'. The #GType of the prerequisite type for the interface, or 0 (%G_TYPE_INVALID) for no prerequisite type. A convenience macro for #GTypeInterface definitions. Similar to G_DEFINE_INTERFACE(), but allows you to insert custom code into the *_get_type() function, e.g. additional interface implementations via G_IMPLEMENT_INTERFACE(), or additional prerequisite types. See G_DEFINE_TYPE_EXTENDED() for a similar example using G_DEFINE_TYPE_WITH_CODE(). The name of the new type, in Camel case. The name of the new type, in lowercase, with words separated by '_'. The #GType of the prerequisite type for the interface, or 0 (%G_TYPE_INVALID) for no prerequisite type. Custom code that gets inserted in the *_get_type() function. A convenience macro for pointer type implementations, which defines a type_name_get_type() function registering the pointer type. The name of the new type, in Camel case The name of the new type, in lowercase, with words separated by '_' A convenience macro for pointer type implementations. Similar to G_DEFINE_POINTER_TYPE(), but allows to insert custom code into the type_name_get_type() function. The name of the new type, in Camel case The name of the new type, in lowercase, with words separated by '_' Custom code that gets inserted in the *_get_type() function A convenience macro for type implementations, which declares a class initialization function, an instance initialization function (see #GTypeInfo for information about these) and a static variable named `t_n_parent_class` pointing to the parent class. Furthermore, it defines a *_get_type() function. See G_DEFINE_TYPE_EXTENDED() for an example. The name of the new type, in Camel case. The name of the new type, in lowercase, with words separated by '_'. The #GType of the parent type. The most general convenience macro for type implementations, on which G_DEFINE_TYPE(), etc are based. |[<!-- language="C" --> G_DEFINE_TYPE_EXTENDED (GtkGadget, gtk_gadget, GTK_TYPE_WIDGET, 0, G_ADD_PRIVATE (GtkGadget) G_IMPLEMENT_INTERFACE (TYPE_GIZMO, gtk_gadget_gizmo_init)); ]| expands to |[<!-- language="C" --> static void gtk_gadget_init (GtkGadget *self); static void gtk_gadget_class_init (GtkGadgetClass *klass); static gpointer gtk_gadget_parent_class = NULL; static gint GtkGadget_private_offset; static void gtk_gadget_class_intern_init (gpointer klass) { gtk_gadget_parent_class = g_type_class_peek_parent (klass); if (GtkGadget_private_offset != 0) g_type_class_adjust_private_offset (klass, &GtkGadget_private_offset); gtk_gadget_class_init ((GtkGadgetClass*) klass); } static inline gpointer gtk_gadget_get_instance_private (GtkGadget *self) { return (G_STRUCT_MEMBER_P (self, GtkGadget_private_offset)); } GType gtk_gadget_get_type (void) { static volatile gsize g_define_type_id__volatile = 0; if (g_once_init_enter (&g_define_type_id__volatile)) { GType g_define_type_id = g_type_register_static_simple (GTK_TYPE_WIDGET, g_intern_static_string ("GtkGadget"), sizeof (GtkGadgetClass), (GClassInitFunc) gtk_gadget_class_intern_init, sizeof (GtkGadget), (GInstanceInitFunc) gtk_gadget_init, 0); { GtkGadget_private_offset = g_type_add_instance_private (g_define_type_id, sizeof (GtkGadgetPrivate)); } { const GInterfaceInfo g_implement_interface_info = { (GInterfaceInitFunc) gtk_gadget_gizmo_init }; g_type_add_interface_static (g_define_type_id, TYPE_GIZMO, &g_implement_interface_info); } g_once_init_leave (&g_define_type_id__volatile, g_define_type_id); } return g_define_type_id__volatile; } ]| The only pieces which have to be manually provided are the definitions of the instance and class structure and the definitions of the instance and class init functions. The name of the new type, in Camel case. The name of the new type, in lowercase, with words separated by '_'. The #GType of the parent type. #GTypeFlags to pass to g_type_register_static() Custom code that gets inserted in the *_get_type() function. A convenience macro for type implementations. Similar to G_DEFINE_TYPE(), but allows you to insert custom code into the *_get_type() function, e.g. interface implementations via G_IMPLEMENT_INTERFACE(). See G_DEFINE_TYPE_EXTENDED() for an example. The name of the new type, in Camel case. The name of the new type in lowercase, with words separated by '_'. The #GType of the parent type. Custom code that gets inserted in the *_get_type() function. A convenience macro for type implementations, which declares a class initialization function, an instance initialization function (see #GTypeInfo for information about these), a static variable named `t_n_parent_class` pointing to the parent class, and adds private instance data to the type. Furthermore, it defines a *_get_type() function. See G_DEFINE_TYPE_EXTENDED() for an example. Note that private structs added with this macros must have a struct name of the form @TN Private. The private instance data can be retrieved using the automatically generated getter function `t_n_get_instance_private()`. See also: G_ADD_PRIVATE() The name of the new type, in Camel case. The name of the new type, in lowercase, with words separated by '_'. The #GType of the parent type. Casts a derived #GEnumClass structure into a #GEnumClass structure. a valid #GEnumClass Get the type identifier from a given #GEnumClass structure. a #GEnumClass Get the static type name from a given #GEnumClass structure. a #GEnumClass The class of an enumeration type holds information about its possible values. the parent class the smallest possible value. the largest possible value. the number of possible values. an array of #GEnumValue structs describing the individual values. A structure which contains a single enum value, its name, and its nickname. the enum value the name of the value the nickname of the value Casts a derived #GFlagsClass structure into a #GFlagsClass structure. a valid #GFlagsClass Get the type identifier from a given #GFlagsClass structure. a #GFlagsClass Get the static type name from a given #GFlagsClass structure. a #GFlagsClass The class of a flags type holds information about its possible values. the parent class a mask covering all possible values. the number of possible values. an array of #GFlagsValue structs describing the individual values. A structure which contains a single flags value, its name, and its nickname. the flags value the name of the value the nickname of the value A convenience macro to ease interface addition in the `_C_` section of G_DEFINE_TYPE_WITH_CODE() or G_DEFINE_ABSTRACT_TYPE_WITH_CODE(). See G_DEFINE_TYPE_EXTENDED() for an example. Note that this macro can only be used together with the G_DEFINE_TYPE_* macros, since it depends on variable names from those macros. The #GType of the interface to add The interface init function, of type #GInterfaceInitFunc A convenience macro to ease interface addition in the @_C_ section of G_DEFINE_DYNAMIC_TYPE_EXTENDED(). See G_DEFINE_DYNAMIC_TYPE_EXTENDED() for an example. Note that this macro can only be used together with the G_DEFINE_DYNAMIC_TYPE_EXTENDED macros, since it depends on variable names from that macro. The #GType of the interface to add The interface init function Casts a #GInitiallyUnowned or derived pointer into a (GInitiallyUnowned*) pointer. Depending on the current debugging level, this function may invoke certain runtime checks to identify invalid casts. Object which is subject to casting. Casts a derived #GInitiallyUnownedClass structure into a #GInitiallyUnownedClass structure. a valid #GInitiallyUnownedClass Get the class structure associated to a #GInitiallyUnowned instance. a #GInitiallyUnowned instance. Checks whether @class "is a" valid #GEnumClass structure of type %G_TYPE_ENUM or derived. a #GEnumClass Checks whether @class "is a" valid #GFlagsClass structure of type %G_TYPE_FLAGS or derived. a #GFlagsClass Checks whether a valid #GTypeInstance pointer is of type %G_TYPE_INITIALLY_UNOWNED. Instance to check for being a %G_TYPE_INITIALLY_UNOWNED. Checks whether @class "is a" valid #GInitiallyUnownedClass structure of type %G_TYPE_INITIALLY_UNOWNED or derived. a #GInitiallyUnownedClass Checks whether a valid #GTypeInstance pointer is of type %G_TYPE_OBJECT. Instance to check for being a %G_TYPE_OBJECT. Checks whether @class "is a" valid #GObjectClass structure of type %G_TYPE_OBJECT or derived. a #GObjectClass Checks whether @pspec "is a" valid #GParamSpec structure of type %G_TYPE_PARAM or derived. a #GParamSpec Checks whether the given #GParamSpec is of type %G_TYPE_PARAM_BOOLEAN. a valid #GParamSpec instance Checks whether the given #GParamSpec is of type %G_TYPE_PARAM_BOXED. a valid #GParamSpec instance Checks whether the given #GParamSpec is of type %G_TYPE_PARAM_CHAR. a valid #GParamSpec instance Checks whether @pclass "is a" valid #GParamSpecClass structure of type %G_TYPE_PARAM or derived. a #GParamSpecClass Checks whether the given #GParamSpec is of type %G_TYPE_PARAM_DOUBLE. a valid #GParamSpec instance Checks whether the given #GParamSpec is of type %G_TYPE_PARAM_ENUM. a valid #GParamSpec instance Checks whether the given #GParamSpec is of type %G_TYPE_PARAM_FLAGS. a valid #GParamSpec instance Checks whether the given #GParamSpec is of type %G_TYPE_PARAM_FLOAT. a valid #GParamSpec instance Checks whether the given #GParamSpec is of type %G_TYPE_PARAM_GTYPE. a #GParamSpec Checks whether the given #GParamSpec is of type %G_TYPE_PARAM_INT. a valid #GParamSpec instance Checks whether the given #GParamSpec is of type %G_TYPE_PARAM_INT64. a valid #GParamSpec instance Checks whether the given #GParamSpec is of type %G_TYPE_PARAM_LONG. a valid #GParamSpec instance Checks whether the given #GParamSpec is of type %G_TYPE_PARAM_OBJECT. a valid #GParamSpec instance Checks whether the given #GParamSpec is of type %G_TYPE_PARAM_OVERRIDE. a #GParamSpec Checks whether the given #GParamSpec is of type %G_TYPE_PARAM_PARAM. a valid #GParamSpec instance Checks whether the given #GParamSpec is of type %G_TYPE_PARAM_POINTER. a valid #GParamSpec instance Checks whether the given #GParamSpec is of type %G_TYPE_PARAM_STRING. a valid #GParamSpec instance Checks whether the given #GParamSpec is of type %G_TYPE_PARAM_UCHAR. a valid #GParamSpec instance Checks whether the given #GParamSpec is of type %G_TYPE_PARAM_UINT. a valid #GParamSpec instance Checks whether the given #GParamSpec is of type %G_TYPE_PARAM_UINT64. a valid #GParamSpec instance Checks whether the given #GParamSpec is of type %G_TYPE_PARAM_ULONG. a valid #GParamSpec instance Checks whether the given #GParamSpec is of type %G_TYPE_PARAM_UNICHAR. a valid #GParamSpec instance Checks whether the given #GParamSpec is of type %G_TYPE_PARAM_VALUE_ARRAY. Use #GArray instead of #GValueArray a valid #GParamSpec instance Checks whether the given #GParamSpec is of type %G_TYPE_PARAM_VARIANT. a #GParamSpec Checks if @value is a valid and initialized #GValue structure. A #GValue structure. All the fields in the GInitiallyUnowned structure are private to the #GInitiallyUnowned implementation and should never be accessed directly. The class structure for the GInitiallyUnowned type. the parent class a #GObject A callback function used by the type system to initialize a new instance of a type. This function initializes all instance members and allocates any resources required by it. Initialization of a derived instance involves calling all its parent types instance initializers, so the class member of the instance is altered during its initialization to always point to the class that belongs to the type the current initializer was introduced for. The extended members of @instance are guaranteed to have been filled with zeros before this function is called. The instance to initialize The class of the type the instance is created for A callback function used by the type system to finalize an interface. This function should destroy any internal data and release any resources allocated by the corresponding GInterfaceInitFunc() function. The interface structure to finalize The @interface_data supplied via the #GInterfaceInfo structure A structure that provides information to the type system which is used specifically for managing interface types. location of the interface initialization function location of the interface finalization function user-supplied data passed to the interface init/finalize functions A callback function used by the type system to initialize a new interface. This function should initialize all internal data and allocate any resources required by the interface. The members of @iface_data are guaranteed to have been filled with zeros before this function is called. The interface structure to initialize The @interface_data supplied via the #GInterfaceInfo structure Casts a #GObject or derived pointer into a (GObject*) pointer. Depending on the current debugging level, this function may invoke certain runtime checks to identify invalid casts. Object which is subject to casting. Casts a derived #GObjectClass structure into a #GObjectClass structure. a valid #GObjectClass Return the name of a class structure's type. a valid #GObjectClass Get the type id of a class structure. a valid #GObjectClass Get the class structure associated to a #GObject instance. a #GObject instance. Get the type id of an object. Object to return the type id for. Get the name of an object's type. Object to return the type name for. This macro should be used to emit a standard warning about unexpected properties in set_property() and get_property() implementations. the #GObject on which set_property() or get_property() was called the numeric id of the property the #GParamSpec of the property All the fields in the GObject structure are private to the #GObject implementation and should never be accessed directly. Creates a new instance of a #GObject subtype and sets its properties. Construction parameters (see #G_PARAM_CONSTRUCT, #G_PARAM_CONSTRUCT_ONLY) which are not explicitly specified are set to their default values. Any private data for the object is guaranteed to be initialized with zeros, as per g_type_create_instance(). Note that in C, small integer types in variable argument lists are promoted up to #gint or #guint as appropriate, and read back accordingly. #gint is 32 bits on every platform on which GLib is currently supported. This means that you can use C expressions of type #gint with g_object_new() and properties of type #gint or #guint or smaller. Specifically, you can use integer literals with these property types. When using property types of #gint64 or #guint64, you must ensure that the value that you provide is 64 bit. This means that you should use a cast or make use of the %G_GINT64_CONSTANT or %G_GUINT64_CONSTANT macros. Similarly, #gfloat is promoted to #gdouble, so you must ensure that the value you provide is a #gdouble, even for a property of type #gfloat. a new instance of @object_type the type id of the #GObject subtype to instantiate the name of the first property the value of the first property, followed optionally by more name/value pairs, followed by %NULL Creates a new instance of a #GObject subtype and sets its properties. Construction parameters (see #G_PARAM_CONSTRUCT, #G_PARAM_CONSTRUCT_ONLY) which are not explicitly specified are set to their default values. a new instance of @object_type the type id of the #GObject subtype to instantiate the name of the first property the value of the first property, followed optionally by more name/value pairs, followed by %NULL Creates a new instance of a #GObject subtype and sets its properties using the provided arrays. Both arrays must have exactly @n_properties elements, and the names and values correspond by index. Construction parameters (see %G_PARAM_CONSTRUCT, %G_PARAM_CONSTRUCT_ONLY) which are not explicitly specified are set to their default values. a new instance of @object_type the object type to instantiate the number of properties the names of each property to be set the values of each property to be set Creates a new instance of a #GObject subtype and sets its properties. Construction parameters (see #G_PARAM_CONSTRUCT, #G_PARAM_CONSTRUCT_ONLY) which are not explicitly specified are set to their default values. Use g_object_new_with_properties() instead. deprecated. See #GParameter for more information. a new instance of @object_type the type id of the #GObject subtype to instantiate the length of the @parameters array an array of #GParameter Find the #GParamSpec with the given name for an interface. Generally, the interface vtable passed in as @g_iface will be the default vtable from g_type_default_interface_ref(), or, if you know the interface has already been loaded, g_type_default_interface_peek(). the #GParamSpec for the property of the interface with the name @property_name, or %NULL if no such property exists. any interface vtable for the interface, or the default vtable for the interface name of a property to look up. Add a property to an interface; this is only useful for interfaces that are added to GObject-derived types. Adding a property to an interface forces all objects classes with that interface to have a compatible property. The compatible property could be a newly created #GParamSpec, but normally g_object_class_override_property() will be used so that the object class only needs to provide an implementation and inherits the property description, default value, bounds, and so forth from the interface property. This function is meant to be called from the interface's default vtable initialization function (the @class_init member of #GTypeInfo.) It must not be called after after @class_init has been called for any object types implementing this interface. If @pspec is a floating reference, it will be consumed. any interface vtable for the interface, or the default vtable for the interface. the #GParamSpec for the new property Lists the properties of an interface.Generally, the interface vtable passed in as @g_iface will be the default vtable from g_type_default_interface_ref(), or, if you know the interface has already been loaded, g_type_default_interface_peek(). a pointer to an array of pointers to #GParamSpec structures. The paramspecs are owned by GLib, but the array should be freed with g_free() when you are done with it. any interface vtable for the interface, or the default vtable for the interface location to store number of properties returned. Emits a "notify" signal for the property @property_name on @object. When possible, eg. when signaling a property change from within the class that registered the property, you should use g_object_notify_by_pspec() instead. Note that emission of the notify signal may be blocked with g_object_freeze_notify(). In this case, the signal emissions are queued and will be emitted (in reverse order) when g_object_thaw_notify() is called. a #GObject Increases the reference count of the object by one and sets a callback to be called when all other references to the object are dropped, or when this is already the last reference to the object and another reference is established. This functionality is intended for binding @object to a proxy object managed by another memory manager. This is done with two paired references: the strong reference added by g_object_add_toggle_ref() and a reverse reference to the proxy object which is either a strong reference or weak reference. The setup is that when there are no other references to @object, only a weak reference is held in the reverse direction from @object to the proxy object, but when there are other references held to @object, a strong reference is held. The @notify callback is called when the reference from @object to the proxy object should be "toggled" from strong to weak (@is_last_ref true) or weak to strong (@is_last_ref false). Since a (normal) reference must be held to the object before calling g_object_add_toggle_ref(), the initial state of the reverse link is always strong. Multiple toggle references may be added to the same gobject, however if there are multiple toggle references to an object, none of them will ever be notified until all but one are removed. For this reason, you should only ever use a toggle reference if there is important state in the proxy object. a #GObject a function to call when this reference is the last reference to the object, or is no longer the last reference. data to pass to @notify Adds a weak reference from weak_pointer to @object to indicate that the pointer located at @weak_pointer_location is only valid during the lifetime of @object. When the @object is finalized, @weak_pointer will be set to %NULL. Note that as with g_object_weak_ref(), the weak references created by this method are not thread-safe: they cannot safely be used in one thread if the object's last g_object_unref() might happen in another thread. Use #GWeakRef if thread-safety is required. The object that should be weak referenced. The memory address of a pointer. Creates a binding between @source_property on @source and @target_property on @target. Whenever the @source_property is changed the @target_property is updated using the same value. For instance: |[ g_object_bind_property (action, "active", widget, "sensitive", 0); ]| Will result in the "sensitive" property of the widget #GObject instance to be updated with the same value of the "active" property of the action #GObject instance. If @flags contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual: if @target_property on @target changes then the @source_property on @source will be updated as well. The binding will automatically be removed when either the @source or the @target instances are finalized. To remove the binding without affecting the @source and the @target you can just call g_object_unref() on the returned #GBinding instance. A #GObject can have multiple bindings. the #GBinding instance representing the binding between the two #GObject instances. The binding is released whenever the #GBinding reference count reaches zero. the source #GObject the property on @source to bind the target #GObject the property on @target to bind flags to pass to #GBinding Complete version of g_object_bind_property(). Creates a binding between @source_property on @source and @target_property on @target, allowing you to set the transformation functions to be used by the binding. If @flags contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual: if @target_property on @target changes then the @source_property on @source will be updated as well. The @transform_from function is only used in case of bidirectional bindings, otherwise it will be ignored The binding will automatically be removed when either the @source or the @target instances are finalized. This will release the reference that is being held on the #GBinding instance; if you want to hold on to the #GBinding instance, you will need to hold a reference to it. To remove the binding, call g_binding_unbind(). A #GObject can have multiple bindings. The same @user_data parameter will be used for both @transform_to and @transform_from transformation functions; the @notify function will be called once, when the binding is removed. If you need different data for each transformation function, please use g_object_bind_property_with_closures() instead. the #GBinding instance representing the binding between the two #GObject instances. The binding is released whenever the #GBinding reference count reaches zero. the source #GObject the property on @source to bind the target #GObject the property on @target to bind flags to pass to #GBinding the transformation function from the @source to the @target, or %NULL to use the default the transformation function from the @target to the @source, or %NULL to use the default custom data to be passed to the transformation functions, or %NULL a function to call when disposing the binding, to free resources used by the transformation functions, or %NULL if not required Creates a binding between @source_property on @source and @target_property on @target, allowing you to set the transformation functions to be used by the binding. This function is the language bindings friendly version of g_object_bind_property_full(), using #GClosures instead of function pointers. the #GBinding instance representing the binding between the two #GObject instances. The binding is released whenever the #GBinding reference count reaches zero. the source #GObject the property on @source to bind the target #GObject the property on @target to bind flags to pass to #GBinding a #GClosure wrapping the transformation function from the @source to the @target, or %NULL to use the default a #GClosure wrapping the transformation function from the @target to the @source, or %NULL to use the default A convenience function to connect multiple signals at once. The signal specs expected by this function have the form "modifier::signal_name", where modifier can be one of the following: - signal: equivalent to g_signal_connect_data (..., NULL, 0) - object-signal, object_signal: equivalent to g_signal_connect_object (..., 0) - swapped-signal, swapped_signal: equivalent to g_signal_connect_data (..., NULL, G_CONNECT_SWAPPED) - swapped_object_signal, swapped-object-signal: equivalent to g_signal_connect_object (..., G_CONNECT_SWAPPED) - signal_after, signal-after: equivalent to g_signal_connect_data (..., NULL, G_CONNECT_AFTER) - object_signal_after, object-signal-after: equivalent to g_signal_connect_object (..., G_CONNECT_AFTER) - swapped_signal_after, swapped-signal-after: equivalent to g_signal_connect_data (..., NULL, G_CONNECT_SWAPPED | G_CONNECT_AFTER) - swapped_object_signal_after, swapped-object-signal-after: equivalent to g_signal_connect_object (..., G_CONNECT_SWAPPED | G_CONNECT_AFTER) |[<!-- language="C" --> menu->toplevel = g_object_connect (g_object_new (GTK_TYPE_WINDOW, "type", GTK_WINDOW_POPUP, "child", menu, NULL), "signal::event", gtk_menu_window_event, menu, "signal::size_request", gtk_menu_window_size_request, menu, "signal::destroy", gtk_widget_destroyed, &menu->toplevel, NULL); ]| @object a #GObject the spec for the first signal #GCallback for the first signal, followed by data for the first signal, followed optionally by more signal spec/callback/data triples, followed by %NULL A convenience function to disconnect multiple signals at once. The signal specs expected by this function have the form "any_signal", which means to disconnect any signal with matching callback and data, or "any_signal::signal_name", which only disconnects the signal named "signal_name". a #GObject the spec for the first signal #GCallback for the first signal, followed by data for the first signal, followed optionally by more signal spec/callback/data triples, followed by %NULL This is a variant of g_object_get_data() which returns a 'duplicate' of the value. @dup_func defines the meaning of 'duplicate' in this context, it could e.g. take a reference on a ref-counted object. If the @key is not set on the object then @dup_func will be called with a %NULL argument. Note that @dup_func is called while user data of @object is locked. This function can be useful to avoid races when multiple threads are using object data on the same key on the same object. the result of calling @dup_func on the value associated with @key on @object, or %NULL if not set. If @dup_func is %NULL, the value is returned unmodified. the #GObject to store user data on a string, naming the user data pointer function to dup the value passed as user_data to @dup_func This is a variant of g_object_get_qdata() which returns a 'duplicate' of the value. @dup_func defines the meaning of 'duplicate' in this context, it could e.g. take a reference on a ref-counted object. If the @quark is not set on the object then @dup_func will be called with a %NULL argument. Note that @dup_func is called while user data of @object is locked. This function can be useful to avoid races when multiple threads are using object data on the same key on the same object. the result of calling @dup_func on the value associated with @quark on @object, or %NULL if not set. If @dup_func is %NULL, the value is returned unmodified. the #GObject to store user data on a #GQuark, naming the user data pointer function to dup the value passed as user_data to @dup_func This function is intended for #GObject implementations to re-enforce a [floating][floating-ref] object reference. Doing this is seldom required: all #GInitiallyUnowneds are created with a floating reference which usually just needs to be sunken by calling g_object_ref_sink(). a #GObject Increases the freeze count on @object. If the freeze count is non-zero, the emission of "notify" signals on @object is stopped. The signals are queued until the freeze count is decreased to zero. Duplicate notifications are squashed so that at most one #GObject::notify signal is emitted for each property modified while the object is frozen. This is necessary for accessors that modify multiple properties to prevent premature notification while the object is still being modified. a #GObject Gets properties of an object. In general, a copy is made of the property contents and the caller is responsible for freeing the memory in the appropriate manner for the type, for instance by calling g_free() or g_object_unref(). Here is an example of using g_object_get() to get the contents of three properties: an integer, a string and an object: |[<!-- language="C" --> gint intval; guint64 uint64val; gchar *strval; GObject *objval; g_object_get (my_object, "int-property", &intval, "uint64-property", &uint64val, "str-property", &strval, "obj-property", &objval, NULL); // Do something with intval, uint64val, strval, objval g_free (strval); g_object_unref (objval); ]| a #GObject name of the first property to get return location for the first property, followed optionally by more name/return location pairs, followed by %NULL Gets a named field from the objects table of associations (see g_object_set_data()). the data if found, or %NULL if no such data exists. #GObject containing the associations name of the key for that association Gets a property of an object. The @value can be: - an empty #GValue initialized by %G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60) - a #GValue initialized with the expected type of the property - a #GValue initialized with a type to which the expected type of the property can be transformed In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling g_value_unset(). Note that g_object_get_property() is really intended for language bindings, g_object_get() is much more convenient for C programming. a #GObject the name of the property to get return location for the property value This function gets back user data pointers stored via g_object_set_qdata(). The user data pointer set, or %NULL The GObject to get a stored user data pointer from A #GQuark, naming the user data pointer Gets properties of an object. In general, a copy is made of the property contents and the caller is responsible for freeing the memory in the appropriate manner for the type, for instance by calling g_free() or g_object_unref(). See g_object_get(). a #GObject name of the first property to get return location for the first property, followed optionally by more name/return location pairs, followed by %NULL Gets @n_properties properties for an @object. Obtained properties will be set to @values. All properties must be valid. Warnings will be emitted and undefined behaviour may result if invalid properties are passed in. a #GObject the number of properties the names of each property to get the values of each property to get Checks whether @object has a [floating][floating-ref] reference. %TRUE if @object has a floating reference a #GObject Emits a "notify" signal for the property @property_name on @object. When possible, eg. when signaling a property change from within the class that registered the property, you should use g_object_notify_by_pspec() instead. Note that emission of the notify signal may be blocked with g_object_freeze_notify(). In this case, the signal emissions are queued and will be emitted (in reverse order) when g_object_thaw_notify() is called. a #GObject the name of a property installed on the class of @object. Emits a "notify" signal for the property specified by @pspec on @object. This function omits the property name lookup, hence it is faster than g_object_notify(). One way to avoid using g_object_notify() from within the class that registered the properties, and using g_object_notify_by_pspec() instead, is to store the GParamSpec used with g_object_class_install_property() inside a static array, e.g.: |[<!-- language="C" --> enum { PROP_0, PROP_FOO, PROP_LAST }; static GParamSpec *properties[PROP_LAST]; static void my_object_class_init (MyObjectClass *klass) { properties[PROP_FOO] = g_param_spec_int ("foo", "Foo", "The foo", 0, 100, 50, G_PARAM_READWRITE); g_object_class_install_property (gobject_class, PROP_FOO, properties[PROP_FOO]); } ]| and then notify a change on the "foo" property with: |[<!-- language="C" --> g_object_notify_by_pspec (self, properties[PROP_FOO]); ]| a #GObject the #GParamSpec of a property installed on the class of @object. Increases the reference count of @object. Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type of @object will be propagated to the return type (using the GCC typeof() extension), so any casting the caller needs to do on the return type must be explicit. the same @object a #GObject Increase the reference count of @object, and possibly remove the [floating][floating-ref] reference, if @object has a floating reference. In other words, if the object is floating, then this call "assumes ownership" of the floating reference, converting it to a normal reference by clearing the floating flag while leaving the reference count unchanged. If the object is not floating, then this call adds a new normal reference increasing the reference count by one. Since GLib 2.56, the type of @object will be propagated to the return type under the same conditions as for g_object_ref(). @object a #GObject Removes a reference added with g_object_add_toggle_ref(). The reference count of the object is decreased by one. a #GObject a function to call when this reference is the last reference to the object, or is no longer the last reference. data to pass to @notify Removes a weak reference from @object that was previously added using g_object_add_weak_pointer(). The @weak_pointer_location has to match the one used with g_object_add_weak_pointer(). The object that is weak referenced. The memory address of a pointer. Compares the user data for the key @key on @object with @oldval, and if they are the same, replaces @oldval with @newval. This is like a typical atomic compare-and-exchange operation, for user data on an object. If the previous value was replaced then ownership of the old value (@oldval) is passed to the caller, including the registered destroy notify for it (passed out in @old_destroy). It’s up to the caller to free this as needed, which may or may not include using @old_destroy as sometimes replacement should not destroy the object in the normal way. See g_object_set_data() for guidance on using a small, bounded set of values for @key. %TRUE if the existing value for @key was replaced by @newval, %FALSE otherwise. the #GObject to store user data on a string, naming the user data pointer the old value to compare against the new value a destroy notify for the new value destroy notify for the existing value Compares the user data for the key @quark on @object with @oldval, and if they are the same, replaces @oldval with @newval. This is like a typical atomic compare-and-exchange operation, for user data on an object. If the previous value was replaced then ownership of the old value (@oldval) is passed to the caller, including the registered destroy notify for it (passed out in @old_destroy). It’s up to the caller to free this as needed, which may or may not include using @old_destroy as sometimes replacement should not destroy the object in the normal way. %TRUE if the existing value for @quark was replaced by @newval, %FALSE otherwise. the #GObject to store user data on a #GQuark, naming the user data pointer the old value to compare against the new value a destroy notify for the new value destroy notify for the existing value Releases all references to other objects. This can be used to break reference cycles. This function should only be called from object system implementations. a #GObject Sets properties on an object. The same caveats about passing integer literals as varargs apply as with g_object_new(). In particular, any integer literals set as the values for properties of type #gint64 or #guint64 must be 64 bits wide, using the %G_GINT64_CONSTANT or %G_GUINT64_CONSTANT macros. Note that the "notify" signals are queued and only emitted (in reverse order) after all properties have been set. See g_object_freeze_notify(). a #GObject name of the first property to set value for the first property, followed optionally by more name/value pairs, followed by %NULL Each object carries around a table of associations from strings to pointers. This function lets you set an association. If the object already had an association with that name, the old association will be destroyed. Internally, the @key is converted to a #GQuark using g_quark_from_string(). This means a copy of @key is kept permanently (even after @object has been finalized) — so it is recommended to only use a small, bounded set of values for @key in your program, to avoid the #GQuark storage growing unbounded. #GObject containing the associations. name of the key data to associate with that key Like g_object_set_data() except it adds notification for when the association is destroyed, either by setting it to a different value or when the object is destroyed. Note that the @destroy callback is not called if @data is %NULL. #GObject containing the associations name of the key data to associate with that key function to call when the association is destroyed Sets a property on an object. a #GObject the name of the property to set the value This sets an opaque, named pointer on an object. The name is specified through a #GQuark (retrieved e.g. via g_quark_from_static_string()), and the pointer can be gotten back from the @object with g_object_get_qdata() until the @object is finalized. Setting a previously set user data pointer, overrides (frees) the old pointer set, using #NULL as pointer essentially removes the data stored. The GObject to set store a user data pointer A #GQuark, naming the user data pointer An opaque user data pointer This function works like g_object_set_qdata(), but in addition, a void (*destroy) (gpointer) function may be specified which is called with @data as argument when the @object is finalized, or the data is being overwritten by a call to g_object_set_qdata() with the same @quark. The GObject to set store a user data pointer A #GQuark, naming the user data pointer An opaque user data pointer Function to invoke with @data as argument, when @data needs to be freed Sets properties on an object. a #GObject name of the first property to set value for the first property, followed optionally by more name/value pairs, followed by %NULL Sets @n_properties properties for an @object. Properties to be set will be taken from @values. All properties must be valid. Warnings will be emitted and undefined behaviour may result if invalid properties are passed in. a #GObject the number of properties the names of each property to be set the values of each property to be set Remove a specified datum from the object's data associations, without invoking the association's destroy handler. the data if found, or %NULL if no such data exists. #GObject containing the associations name of the key This function gets back user data pointers stored via g_object_set_qdata() and removes the @data from object without invoking its destroy() function (if any was set). Usually, calling this function is only required to update user data pointers with a destroy notifier, for example: |[<!-- language="C" --> void object_add_to_user_list (GObject *object, const gchar *new_string) { // the quark, naming the object data GQuark quark_string_list = g_quark_from_static_string ("my-string-list"); // retrieve the old string list GList *list = g_object_steal_qdata (object, quark_string_list); // prepend new string list = g_list_prepend (list, g_strdup (new_string)); // this changed 'list', so we need to set it again g_object_set_qdata_full (object, quark_string_list, list, free_string_list); } static void free_string_list (gpointer data) { GList *node, *list = data; for (node = list; node; node = node->next) g_free (node->data); g_list_free (list); } ]| Using g_object_get_qdata() in the above example, instead of g_object_steal_qdata() would have left the destroy function set, and thus the partial string list would have been freed upon g_object_set_qdata_full(). The user data pointer set, or %NULL The GObject to get a stored user data pointer from A #GQuark, naming the user data pointer Reverts the effect of a previous call to g_object_freeze_notify(). The freeze count is decreased on @object and when it reaches zero, queued "notify" signals are emitted. Duplicate notifications for each property are squashed so that at most one #GObject::notify signal is emitted for each property, in the reverse order in which they have been queued. It is an error to call this function when the freeze count is zero. a #GObject Decreases the reference count of @object. When its reference count drops to 0, the object is finalized (i.e. its memory is freed). If the pointer to the #GObject may be reused in future (for example, if it is an instance variable of another object), it is recommended to clear the pointer to %NULL rather than retain a dangling pointer to a potentially invalid #GObject instance. Use g_clear_object() for this. a #GObject This function essentially limits the life time of the @closure to the life time of the object. That is, when the object is finalized, the @closure is invalidated by calling g_closure_invalidate() on it, in order to prevent invocations of the closure with a finalized (nonexisting) object. Also, g_object_ref() and g_object_unref() are added as marshal guards to the @closure, to ensure that an extra reference count is held on @object during invocation of the @closure. Usually, this function will be called on closures that use this @object as closure data. #GObject restricting lifetime of @closure #GClosure to watch Adds a weak reference callback to an object. Weak references are used for notification when an object is finalized. They are called "weak references" because they allow you to safely hold a pointer to an object without calling g_object_ref() (g_object_ref() adds a strong reference, that is, forces the object to stay alive). Note that the weak references created by this method are not thread-safe: they cannot safely be used in one thread if the object's last g_object_unref() might happen in another thread. Use #GWeakRef if thread-safety is required. #GObject to reference weakly callback to invoke before the object is freed extra data to pass to notify Removes a weak reference callback to an object. #GObject to remove a weak reference from callback to search for data to search for The notify signal is emitted on an object when one of its properties has its value set through g_object_set_property(), g_object_set(), et al. Note that getting this signal doesn’t itself guarantee that the value of the property has actually changed. When it is emitted is determined by the derived GObject class. If the implementor did not create the property with %G_PARAM_EXPLICIT_NOTIFY, then any call to g_object_set_property() results in ::notify being emitted, even if the new value is the same as the old. If they did pass %G_PARAM_EXPLICIT_NOTIFY, then this signal is emitted only when they explicitly call g_object_notify() or g_object_notify_by_pspec(), and common practice is to do that only when the value has actually changed. This signal is typically used to obtain change notification for a single property, by specifying the property name as a detail in the g_signal_connect() call, like this: |[<!-- language="C" --> g_signal_connect (text_view->buffer, "notify::paste-target-list", G_CALLBACK (gtk_text_view_target_list_notify), text_view) ]| It is important to note that you must use [canonical parameter names][canonical-parameter-names] as detail strings for the notify signal. the #GParamSpec of the property which changed. The class structure for the GObject type. |[<!-- language="C" --> // Example of implementing a singleton using a constructor. static MySingleton *the_singleton = NULL; static GObject* my_singleton_constructor (GType type, guint n_construct_params, GObjectConstructParam *construct_params) { GObject *object; if (!the_singleton) { object = G_OBJECT_CLASS (parent_class)->constructor (type, n_construct_params, construct_params); the_singleton = MY_SINGLETON (object); } else object = g_object_ref (G_OBJECT (the_singleton)); return object; } ]| the parent class a #GObject Looks up the #GParamSpec for a property of a class. the #GParamSpec for the property, or %NULL if the class doesn't have a property of that name a #GObjectClass the name of the property to look up Installs new properties from an array of #GParamSpecs. All properties should be installed during the class initializer. It is possible to install properties after that, but doing so is not recommend, and specifically, is not guaranteed to be thread-safe vs. use of properties on the same type on other threads. The property id of each property is the index of each #GParamSpec in the @pspecs array. The property id of 0 is treated specially by #GObject and it should not be used to store a #GParamSpec. This function should be used if you plan to use a static array of #GParamSpecs and g_object_notify_by_pspec(). For instance, this class initialization: |[<!-- language="C" --> enum { PROP_0, PROP_FOO, PROP_BAR, N_PROPERTIES }; static GParamSpec *obj_properties[N_PROPERTIES] = { NULL, }; static void my_object_class_init (MyObjectClass *klass) { GObjectClass *gobject_class = G_OBJECT_CLASS (klass); obj_properties[PROP_FOO] = g_param_spec_int ("foo", "Foo", "Foo", -1, G_MAXINT, 0, G_PARAM_READWRITE); obj_properties[PROP_BAR] = g_param_spec_string ("bar", "Bar", "Bar", NULL, G_PARAM_READWRITE); gobject_class->set_property = my_object_set_property; gobject_class->get_property = my_object_get_property; g_object_class_install_properties (gobject_class, N_PROPERTIES, obj_properties); } ]| allows calling g_object_notify_by_pspec() to notify of property changes: |[<!-- language="C" --> void my_object_set_foo (MyObject *self, gint foo) { if (self->foo != foo) { self->foo = foo; g_object_notify_by_pspec (G_OBJECT (self), obj_properties[PROP_FOO]); } } ]| a #GObjectClass the length of the #GParamSpecs array the #GParamSpecs array defining the new properties Installs a new property. All properties should be installed during the class initializer. It is possible to install properties after that, but doing so is not recommend, and specifically, is not guaranteed to be thread-safe vs. use of properties on the same type on other threads. Note that it is possible to redefine a property in a derived class, by installing a property with the same name. This can be useful at times, e.g. to change the range of allowed values or the default value. a #GObjectClass the id for the new property the #GParamSpec for the new property Get an array of #GParamSpec* for all properties of a class. an array of #GParamSpec* which should be freed after use a #GObjectClass return location for the length of the returned array Registers @property_id as referring to a property with the name @name in a parent class or in an interface implemented by @oclass. This allows this class to "override" a property implementation in a parent class or to provide the implementation of a property from an interface. Internally, overriding is implemented by creating a property of type #GParamSpecOverride; generally operations that query the properties of the object class, such as g_object_class_find_property() or g_object_class_list_properties() will return the overridden property. However, in one case, the @construct_properties argument of the @constructor virtual function, the #GParamSpecOverride is passed instead, so that the @param_id field of the #GParamSpec will be correct. For virtually all uses, this makes no difference. If you need to get the overridden property, you can call g_param_spec_get_redirect_target(). a #GObjectClass the new property ID the name of a property registered in a parent class or in an interface of this class. The GObjectConstructParam struct is an auxiliary structure used to hand #GParamSpec/#GValue pairs to the @constructor of a #GObjectClass. the #GParamSpec of the construct parameter the value to set the parameter to The type of the @finalize function of #GObjectClass. the #GObject being finalized The type of the @get_property function of #GObjectClass. a #GObject the numeric id under which the property was registered with g_object_class_install_property(). a #GValue to return the property value in the #GParamSpec describing the property The type of the @set_property function of #GObjectClass. a #GObject the numeric id under which the property was registered with g_object_class_install_property(). the new value for the property the #GParamSpec describing the property Mask containing the bits of #GParamSpec.flags which are reserved for GLib. Casts a derived #GParamSpec object (e.g. of type #GParamSpecInt) into a #GParamSpec object. a valid #GParamSpec Cast a #GParamSpec instance into a #GParamSpecBoolean. a valid #GParamSpec instance Cast a #GParamSpec instance into a #GParamSpecBoxed. a valid #GParamSpec instance Cast a #GParamSpec instance into a #GParamSpecChar. a valid #GParamSpec instance Casts a derived #GParamSpecClass structure into a #GParamSpecClass structure. a valid #GParamSpecClass Cast a #GParamSpec instance into a #GParamSpecDouble. a valid #GParamSpec instance Cast a #GParamSpec instance into a #GParamSpecEnum. a valid #GParamSpec instance Cast a #GParamSpec instance into a #GParamSpecFlags. a valid #GParamSpec instance Cast a #GParamSpec instance into a #GParamSpecFloat. a valid #GParamSpec instance Retrieves the #GParamSpecClass of a #GParamSpec. a valid #GParamSpec Casts a #GParamSpec into a #GParamSpecGType. a #GParamSpec Cast a #GParamSpec instance into a #GParamSpecInt. a valid #GParamSpec instance Cast a #GParamSpec instance into a #GParamSpecInt64. a valid #GParamSpec instance Cast a #GParamSpec instance into a #GParamSpecLong. a valid #GParamSpec instance Casts a #GParamSpec instance into a #GParamSpecObject. a valid #GParamSpec instance Casts a #GParamSpec into a #GParamSpecOverride. a #GParamSpec Casts a #GParamSpec instance into a #GParamSpecParam. a valid #GParamSpec instance Casts a #GParamSpec instance into a #GParamSpecPointer. a valid #GParamSpec instance Casts a #GParamSpec instance into a #GParamSpecString. a valid #GParamSpec instance Retrieves the #GType of this @pspec. a valid #GParamSpec Retrieves the #GType name of this @pspec. a valid #GParamSpec Cast a #GParamSpec instance into a #GParamSpecUChar. a valid #GParamSpec instance Cast a #GParamSpec instance into a #GParamSpecUInt. a valid #GParamSpec instance Cast a #GParamSpec instance into a #GParamSpecUInt64. a valid #GParamSpec instance Cast a #GParamSpec instance into a #GParamSpecULong. a valid #GParamSpec instance Cast a #GParamSpec instance into a #GParamSpecUnichar. a valid #GParamSpec instance Cast a #GParamSpec instance into a #GParamSpecValueArray. Use #GArray instead of #GValueArray a valid #GParamSpec instance Retrieves the #GType to initialize a #GValue for this parameter. a valid #GParamSpec Casts a #GParamSpec into a #GParamSpecVariant. a #GParamSpec #GParamFlags value alias for %G_PARAM_STATIC_NAME | %G_PARAM_STATIC_NICK | %G_PARAM_STATIC_BLURB. Since 2.13.0 Minimum shift count to be used for user defined flags, to be stored in #GParamSpec.flags. The maximum allowed is 10. Evaluates to the @field_name inside the @inst private data structure for @TypeName. Note that this macro can only be used together with the G_DEFINE_TYPE_* and G_ADD_PRIVATE() macros, since it depends on variable names from those macros. the name of the type in CamelCase the instance of @TypeName you wish to access the type of the field in the private data structure the name of the field in the private data structure Evaluates to a pointer to the @field_name inside the @inst private data structure for @TypeName. Note that this macro can only be used together with the G_DEFINE_TYPE_* and G_ADD_PRIVATE() macros, since it depends on variable names from those macros. the name of the type in CamelCase the instance of @TypeName you wish to access the name of the field in the private data structure Evaluates to the offset of the @field inside the instance private data structure for @TypeName. Note that this macro can only be used together with the G_DEFINE_TYPE_* and G_ADD_PRIVATE() macros, since it depends on variable names from those macros. the name of the type in CamelCase the name of the field in the private data structure Through the #GParamFlags flag values, certain aspects of parameters can be configured. See also #G_PARAM_STATIC_STRINGS. the parameter is readable the parameter is writable alias for %G_PARAM_READABLE | %G_PARAM_WRITABLE the parameter will be set upon object construction the parameter can only be set upon object construction upon parameter conversion (see g_param_value_convert()) strict validation is not required the string used as name when constructing the parameter is guaranteed to remain valid and unmodified for the lifetime of the parameter. Since 2.8 internal the string used as nick when constructing the parameter is guaranteed to remain valid and unmmodified for the lifetime of the parameter. Since 2.8 the string used as blurb when constructing the parameter is guaranteed to remain valid and unmodified for the lifetime of the parameter. Since 2.8 calls to g_object_set_property() for this property will not automatically result in a "notify" signal being emitted: the implementation must call g_object_notify() themselves in case the property actually changes. Since: 2.42. the parameter is deprecated and will be removed in a future version. A warning will be generated if it is used while running with G_ENABLE_DIAGNOSTIC=1. Since 2.26 #GParamSpec is an object structure that encapsulates the metadata required to specify parameters, such as e.g. #GObject properties. ## Parameter names # {#canonical-parameter-names} A property name consists of one or more segments consisting of ASCII letters and digits, separated by either the `-` or `_` character. The first character of a property name must be a letter. These are the same rules as for signal naming (see g_signal_new()). When creating and looking up a #GParamSpec, either separator can be used, but they cannot be mixed. Using `-` is considerably more efficient, and is the ‘canonical form’. Using `_` is discouraged. Creates a new #GParamSpec instance. See [canonical parameter names][canonical-parameter-names] for details of the rules for @name. Names which violate these rules lead to undefined behaviour. Beyond the name, #GParamSpecs have two more descriptive strings associated with them, the @nick, which should be suitable for use as a label for the property in a property editor, and the @blurb, which should be a somewhat longer description, suitable for e.g. a tooltip. The @nick and @blurb should ideally be localized. a newly allocated #GParamSpec instance the #GType for the property; must be derived from #G_TYPE_PARAM the canonical name of the property the nickname of the property a short description of the property a combination of #GParamFlags Validate a property name for a #GParamSpec. This can be useful for dynamically-generated properties which need to be validated at run-time before actually trying to create them. See [canonical parameter names][canonical-parameter-names] for details of the rules for valid names. %TRUE if @name is a valid property name, %FALSE otherwise. the canonical name of the property Get the short description of a #GParamSpec. the short description of @pspec. a valid #GParamSpec Gets the default value of @pspec as a pointer to a #GValue. The #GValue will remain valid for the life of @pspec. a pointer to a #GValue which must not be modified a #GParamSpec Get the name of a #GParamSpec. The name is always an "interned" string (as per g_intern_string()). This allows for pointer-value comparisons. the name of @pspec. a valid #GParamSpec Gets the GQuark for the name. the GQuark for @pspec->name. a #GParamSpec Get the nickname of a #GParamSpec. the nickname of @pspec. a valid #GParamSpec Gets back user data pointers stored via g_param_spec_set_qdata(). the user data pointer set, or %NULL a valid #GParamSpec a #GQuark, naming the user data pointer If the paramspec redirects operations to another paramspec, returns that paramspec. Redirect is used typically for providing a new implementation of a property in a derived type while preserving all the properties from the parent type. Redirection is established by creating a property of type #GParamSpecOverride. See g_object_class_override_property() for an example of the use of this capability. paramspec to which requests on this paramspec should be redirected, or %NULL if none. a #GParamSpec Increments the reference count of @pspec. the #GParamSpec that was passed into this function a valid #GParamSpec Convenience function to ref and sink a #GParamSpec. the #GParamSpec that was passed into this function a valid #GParamSpec Sets an opaque, named pointer on a #GParamSpec. The name is specified through a #GQuark (retrieved e.g. via g_quark_from_static_string()), and the pointer can be gotten back from the @pspec with g_param_spec_get_qdata(). Setting a previously set user data pointer, overrides (frees) the old pointer set, using %NULL as pointer essentially removes the data stored. the #GParamSpec to set store a user data pointer a #GQuark, naming the user data pointer an opaque user data pointer This function works like g_param_spec_set_qdata(), but in addition, a `void (*destroy) (gpointer)` function may be specified which is called with @data as argument when the @pspec is finalized, or the data is being overwritten by a call to g_param_spec_set_qdata() with the same @quark. the #GParamSpec to set store a user data pointer a #GQuark, naming the user data pointer an opaque user data pointer function to invoke with @data as argument, when @data needs to be freed The initial reference count of a newly created #GParamSpec is 1, even though no one has explicitly called g_param_spec_ref() on it yet. So the initial reference count is flagged as "floating", until someone calls `g_param_spec_ref (pspec); g_param_spec_sink (pspec);` in sequence on it, taking over the initial reference count (thus ending up with a @pspec that has a reference count of 1 still, but is not flagged "floating" anymore). a valid #GParamSpec Gets back user data pointers stored via g_param_spec_set_qdata() and removes the @data from @pspec without invoking its destroy() function (if any was set). Usually, calling this function is only required to update user data pointers with a destroy notifier. the user data pointer set, or %NULL the #GParamSpec to get a stored user data pointer from a #GQuark, naming the user data pointer Decrements the reference count of a @pspec. a valid #GParamSpec private #GTypeInstance portion name of this parameter: always an interned string #GParamFlags flags for this parameter the #GValue type for this parameter #GType type that uses (introduces) this parameter A #GParamSpec derived structure that contains the meta data for boolean properties. private #GParamSpec portion default value for the property specified A #GParamSpec derived structure that contains the meta data for boxed properties. private #GParamSpec portion A #GParamSpec derived structure that contains the meta data for character properties. private #GParamSpec portion minimum value for the property specified maximum value for the property specified default value for the property specified The class structure for the GParamSpec type. Normally, GParamSpec classes are filled by g_param_type_register_static(). the parent class the #GValue type for this parameter A #GParamSpec derived structure that contains the meta data for double properties. private #GParamSpec portion minimum value for the property specified maximum value for the property specified default value for the property specified values closer than @epsilon will be considered identical by g_param_values_cmp(); the default value is 1e-90. A #GParamSpec derived structure that contains the meta data for enum properties. private #GParamSpec portion the #GEnumClass for the enum default value for the property specified A #GParamSpec derived structure that contains the meta data for flags properties. private #GParamSpec portion the #GFlagsClass for the flags default value for the property specified A #GParamSpec derived structure that contains the meta data for float properties. private #GParamSpec portion minimum value for the property specified maximum value for the property specified default value for the property specified values closer than @epsilon will be considered identical by g_param_values_cmp(); the default value is 1e-30. A #GParamSpec derived structure that contains the meta data for #GType properties. private #GParamSpec portion a #GType whose subtypes can occur as values A #GParamSpec derived structure that contains the meta data for integer properties. private #GParamSpec portion minimum value for the property specified maximum value for the property specified default value for the property specified A #GParamSpec derived structure that contains the meta data for 64bit integer properties. private #GParamSpec portion minimum value for the property specified maximum value for the property specified default value for the property specified A #GParamSpec derived structure that contains the meta data for long integer properties. private #GParamSpec portion minimum value for the property specified maximum value for the property specified default value for the property specified A #GParamSpec derived structure that contains the meta data for object properties. private #GParamSpec portion This is a type of #GParamSpec type that simply redirects operations to another paramspec. All operations other than getting or setting the value are redirected, including accessing the nick and blurb, validating a value, and so forth. See g_param_spec_get_redirect_target() for retrieving the overridden property. #GParamSpecOverride is used in implementing g_object_class_override_property(), and will not be directly useful unless you are implementing a new base type similar to GObject. A #GParamSpec derived structure that contains the meta data for %G_TYPE_PARAM properties. private #GParamSpec portion A #GParamSpec derived structure that contains the meta data for pointer properties. private #GParamSpec portion A #GParamSpecPool maintains a collection of #GParamSpecs which can be quickly accessed by owner and name. The implementation of the #GObject property system uses such a pool to store the #GParamSpecs of the properties all object types. Inserts a #GParamSpec in the pool. a #GParamSpecPool. the #GParamSpec to insert a #GType identifying the owner of @pspec Gets an array of all #GParamSpecs owned by @owner_type in the pool. a newly allocated array containing pointers to all #GParamSpecs owned by @owner_type in the pool a #GParamSpecPool the owner to look for return location for the length of the returned array Gets an #GList of all #GParamSpecs owned by @owner_type in the pool. a #GList of all #GParamSpecs owned by @owner_type in the pool#GParamSpecs. a #GParamSpecPool the owner to look for Looks up a #GParamSpec in the pool. The found #GParamSpec, or %NULL if no matching #GParamSpec was found. a #GParamSpecPool the name to look for the owner to look for If %TRUE, also try to find a #GParamSpec with @param_name owned by an ancestor of @owner_type. Removes a #GParamSpec from the pool. a #GParamSpecPool the #GParamSpec to remove Creates a new #GParamSpecPool. If @type_prefixing is %TRUE, lookups in the newly created pool will allow to specify the owner as a colon-separated prefix of the property name, like "GtkContainer:border-width". This feature is deprecated, so you should always set @type_prefixing to %FALSE. a newly allocated #GParamSpecPool. Whether the pool will support type-prefixed property names. A #GParamSpec derived structure that contains the meta data for string properties. private #GParamSpec portion default value for the property specified a string containing the allowed values for the first byte a string containing the allowed values for the subsequent bytes the replacement byte for bytes which don't match @cset_first or @cset_nth. replace empty string by %NULL replace %NULL strings by an empty string This structure is used to provide the type system with the information required to initialize and destruct (finalize) a parameter's class and instances thereof. The initialized structure is passed to the g_param_type_register_static() The type system will perform a deep copy of this structure, so its memory does not need to be persistent across invocation of g_param_type_register_static(). Size of the instance (object) structure. Prior to GLib 2.10, it specified the number of pre-allocated (cached) instances to reserve memory for (0 indicates no caching). Since GLib 2.10, it is ignored, since instances are allocated with the [slice allocator][glib-Memory-Slices] now. The #GType of values conforming to this #GParamSpec A #GParamSpec derived structure that contains the meta data for unsigned character properties. private #GParamSpec portion minimum value for the property specified maximum value for the property specified default value for the property specified A #GParamSpec derived structure that contains the meta data for unsigned integer properties. private #GParamSpec portion minimum value for the property specified maximum value for the property specified default value for the property specified A #GParamSpec derived structure that contains the meta data for unsigned 64bit integer properties. private #GParamSpec portion minimum value for the property specified maximum value for the property specified default value for the property specified A #GParamSpec derived structure that contains the meta data for unsigned long integer properties. private #GParamSpec portion minimum value for the property specified maximum value for the property specified default value for the property specified A #GParamSpec derived structure that contains the meta data for unichar (unsigned integer) properties. private #GParamSpec portion default value for the property specified A #GParamSpec derived structure that contains the meta data for #GValueArray properties. private #GParamSpec portion a #GParamSpec describing the elements contained in arrays of this property, may be %NULL if greater than 0, arrays of this property will always have this many elements A #GParamSpec derived structure that contains the meta data for #GVariant properties. When comparing values with g_param_values_cmp(), scalar values with the same type will be compared with g_variant_compare(). Other non-%NULL variants will be checked for equality with g_variant_equal(), and their sort order is otherwise undefined. %NULL is ordered before non-%NULL variants. Two %NULL values compare equal. private #GParamSpec portion a #GVariantType, or %NULL a #GVariant, or %NULL The GParameter struct is an auxiliary structure used to hand parameter name/value pairs to g_object_newv(). This type is not introspectable. the parameter name the parameter value A mask for all #GSignalFlags bits. A mask for all #GSignalMatchType bits. The signal accumulator is a special callback function that can be used to collect return values of the various callbacks that are called during a signal emission. The signal accumulator is specified at signal creation time, if it is left %NULL, no accumulation of callback return values is performed. The return value of signal emissions is then the value returned by the last callback. The accumulator function returns whether the signal emission should be aborted. Returning %FALSE means to abort the current emission and %TRUE is returned for continuation. Signal invocation hint, see #GSignalInvocationHint. Accumulator to collect callback return values in, this is the return value of the current signal emission. A #GValue holding the return value of the signal handler. Callback data that was specified when creating the signal. A simple function pointer to get invoked when the signal is emitted. This allows you to tie a hook to the signal type, so that it will trap all emissions of that signal, from any object. You may not attach these to signals created with the #G_SIGNAL_NO_HOOKS flag. whether it wants to stay connected. If it returns %FALSE, the signal hook is disconnected (and destroyed). Signal invocation hint, see #GSignalInvocationHint. the number of parameters to the function, including the instance on which the signal was emitted. the instance on which the signal was emitted, followed by the parameters of the emission. user data associated with the hook. The signal flags are used to specify a signal's behaviour, the overall signal description outlines how especially the RUN flags control the stages of a signal emission. Invoke the object method handler in the first emission stage. Invoke the object method handler in the third emission stage. Invoke the object method handler in the last emission stage. Signals being emitted for an object while currently being in emission for this very object will not be emitted recursively, but instead cause the first emission to be restarted. This signal supports "::detail" appendices to the signal name upon handler connections and emissions. Action signals are signals that may freely be emitted on alive objects from user code via g_signal_emit() and friends, without the need of being embedded into extra code that performs pre or post emission adjustments on the object. They can also be thought of as object methods which can be called generically by third-party code. No emissions hooks are supported for this signal. Varargs signal emission will always collect the arguments, even if there are no signal handlers connected. Since 2.30. The signal is deprecated and will be removed in a future version. A warning will be generated if it is connected while running with G_ENABLE_DIAGNOSTIC=1. Since 2.32. The #GSignalInvocationHint structure is used to pass on additional information to callbacks during a signal emission. The signal id of the signal invoking the callback The detail passed on for this emission The stage the signal emission is currently in, this field will contain one of %G_SIGNAL_RUN_FIRST, %G_SIGNAL_RUN_LAST or %G_SIGNAL_RUN_CLEANUP. The match types specify what g_signal_handlers_block_matched(), g_signal_handlers_unblock_matched() and g_signal_handlers_disconnect_matched() match signals by. The signal id must be equal. The signal detail must be equal. The closure must be the same. The C closure callback must be the same. The closure data must be the same. Only unblocked signals may be matched. A structure holding in-depth information for a specific signal. It is filled in by the g_signal_query() function. The signal id of the signal being queried, or 0 if the signal to be queried was unknown. The signal name. The interface/instance type that this signal can be emitted for. The signal flags as passed in to g_signal_new(). The return type for user callbacks. The number of parameters that user callbacks take. The individual parameter types for user callbacks, note that the effective callback signature is: |[<!-- language="C" --> @return_type callback (#gpointer data1, [param_types param_names,] gpointer data2); ]| Checks that @g_class is a class structure of the type identified by @g_type and issues a warning if this is not the case. Returns @g_class casted to a pointer to @c_type. %NULL is not a valid class structure. This macro should only be used in type implementations. Location of a #GTypeClass structure The type to be returned The corresponding C type of class structure of @g_type Checks if @g_class is a class structure of the type identified by @g_type. If @g_class is %NULL, %FALSE will be returned. This macro should only be used in type implementations. Location of a #GTypeClass structure The type to be checked Checks if @instance is a valid #GTypeInstance structure, otherwise issues a warning and returns %FALSE. %NULL is not a valid #GTypeInstance. This macro should only be used in type implementations. Location of a #GTypeInstance structure Checks that @instance is an instance of the type identified by @g_type and issues a warning if this is not the case. Returns @instance casted to a pointer to @c_type. No warning will be issued if @instance is %NULL, and %NULL will be returned. This macro should only be used in type implementations. Location of a #GTypeInstance structure The type to be returned The corresponding C type of @g_type Checks if @instance is an instance of the fundamental type identified by @g_type. If @instance is %NULL, %FALSE will be returned. This macro should only be used in type implementations. Location of a #GTypeInstance structure. The fundamental type to be checked Checks if @instance is an instance of the type identified by @g_type. If @instance is %NULL, %FALSE will be returned. This macro should only be used in type implementations. Location of a #GTypeInstance structure. The type to be checked Checks if @value has been initialized to hold values of a value type. This macro should only be used in type implementations. a #GValue Checks if @value has been initialized to hold values of type @g_type. This macro should only be used in type implementations. a #GValue The type to be checked Gets the private class structure for a particular type. The private structure must have been registered in the get_type() function with g_type_add_class_private(). This macro should only be used in type implementations. the class of a type deriving from @private_type the type identifying which private data to retrieve The C type for the private structure A bit in the type number that's supposed to be left untouched. Get the type identifier from a given @class structure. This macro should only be used in type implementations. Location of a valid #GTypeClass structure Get the type identifier from a given @instance structure. This macro should only be used in type implementations. Location of a valid #GTypeInstance structure Get the type identifier from a given @interface structure. This macro should only be used in type implementations. Location of a valid #GTypeInterface structure The fundamental type which is the ancestor of @type. Fundamental types are types that serve as ultimate bases for the derived types, thus they are the roots of distinct inheritance hierarchies. A #GType value. An integer constant that represents the number of identifiers reserved for types that are assigned at compile-time. Shift value used in converting numbers to type IDs. Checks if @type has a #GTypeValueTable. A #GType value Get the class structure of a given @instance, casted to a specified ancestor type @g_type of the instance. Note that while calling a GInstanceInitFunc(), the class pointer gets modified, so it might not always return the expected pointer. This macro should only be used in type implementations. Location of the #GTypeInstance structure The #GType of the class to be returned The C type of the class structure Get the interface structure for interface @g_type of a given @instance. This macro should only be used in type implementations. Location of the #GTypeInstance structure The #GType of the interface to be returned The C type of the interface structure Gets the private structure for a particular type. The private structure must have been registered in the class_init function with g_type_class_add_private(). This macro should only be used in type implementations. Use %G_ADD_PRIVATE and the generated `your_type_get_instance_private()` function instead the instance of a type deriving from @private_type the type identifying which private data to retrieve The C type for the private structure Checks if @type is an abstract type. An abstract type cannot be instantiated and is normally used as an abstract base class for derived classes. A #GType value Checks if @type is a classed type. A #GType value Checks if @type is a deep derivable type. A deep derivable type can be used as the base class of a deep (multi-level) class hierarchy. A #GType value Checks if @type is a derivable type. A derivable type can be used as the base class of a flat (single-level) class hierarchy. A #GType value Checks if @type is derived (or in object-oriented terminology: inherited) from another type (this holds true for all non-fundamental types). A #GType value Checks whether @type "is a" %G_TYPE_ENUM. a #GType ID. Checks whether @type "is a" %G_TYPE_FLAGS. a #GType ID. Checks if @type is a fundamental type. A #GType value Checks if @type can be instantiated. Instantiation is the process of creating an instance (object) of this type. A #GType value Checks if @type is an interface type. An interface type provides a pure API, the implementation of which is provided by another type (which is then said to conform to the interface). GLib interfaces are somewhat analogous to Java interfaces and C++ classes containing only pure virtual functions, with the difference that GType interfaces are not derivable (but see g_type_interface_add_prerequisite() for an alternative). A #GType value Check if the passed in type id is a %G_TYPE_OBJECT or derived from it. Type id to check Checks whether @type "is a" %G_TYPE_PARAM. a #GType ID Checks whether the passed in type ID can be used for g_value_init(). That is, this macro checks whether this type provides an implementation of the #GTypeValueTable functions required for a type to create a #GValue of. A #GType value. Checks if @type is an abstract value type. An abstract value type introduces a value table, but can't be used for g_value_init() and is normally used as an abstract base type for derived value types. A #GType value Checks if @type is a value type and can be used with g_value_init(). A #GType value Get the type ID for the fundamental type number @x. Use g_type_fundamental_next() instead of this macro to create new fundamental types. the fundamental type number. First fundamental type number to create a new fundamental type id with G_TYPE_MAKE_FUNDAMENTAL() reserved for BSE. Last fundamental type number reserved for BSE. First fundamental type number to create a new fundamental type id with G_TYPE_MAKE_FUNDAMENTAL() reserved for GLib. Last fundamental type number reserved for GLib. First available fundamental type number to create new fundamental type id with G_TYPE_MAKE_FUNDAMENTAL(). A callback function used for notification when the state of a toggle reference changes. See g_object_add_toggle_ref(). Callback data passed to g_object_add_toggle_ref() The object on which g_object_add_toggle_ref() was called. %TRUE if the toggle reference is now the last reference to the object. %FALSE if the toggle reference was the last reference and there are now other references. An opaque structure used as the base of all classes. Registers a private structure for an instantiatable type. When an object is allocated, the private structures for the type and all of its parent types are allocated sequentially in the same memory block as the public structures, and are zero-filled. Note that the accumulated size of the private structures of a type and all its parent types cannot exceed 64 KiB. This function should be called in the type's class_init() function. The private structure can be retrieved using the G_TYPE_INSTANCE_GET_PRIVATE() macro. The following example shows attaching a private structure MyObjectPrivate to an object MyObject defined in the standard GObject fashion in the type's class_init() function. Note the use of a structure member "priv" to avoid the overhead of repeatedly calling MY_OBJECT_GET_PRIVATE(). |[<!-- language="C" --> typedef struct _MyObject MyObject; typedef struct _MyObjectPrivate MyObjectPrivate; struct _MyObject { GObject parent; MyObjectPrivate *priv; }; struct _MyObjectPrivate { int some_field; }; static void my_object_class_init (MyObjectClass *klass) { g_type_class_add_private (klass, sizeof (MyObjectPrivate)); } static void my_object_init (MyObject *my_object) { my_object->priv = G_TYPE_INSTANCE_GET_PRIVATE (my_object, MY_TYPE_OBJECT, MyObjectPrivate); // my_object->priv->some_field will be automatically initialised to 0 } static int my_object_get_some_field (MyObject *my_object) { MyObjectPrivate *priv; g_return_val_if_fail (MY_IS_OBJECT (my_object), 0); priv = my_object->priv; return priv->some_field; } ]| Use the G_ADD_PRIVATE() macro with the `G_DEFINE_*` family of macros to add instance private data to a type class structure for an instantiatable type size of private structure Gets the offset of the private data for instances of @g_class. This is how many bytes you should add to the instance pointer of a class in order to get the private data for the type represented by @g_class. You can only call this function after you have registered a private data area for @g_class using g_type_class_add_private(). the offset, in bytes a #GTypeClass This is a convenience function often needed in class initializers. It returns the class structure of the immediate parent type of the class passed in. Since derived classes hold a reference count on their parent classes as long as they are instantiated, the returned class will always exist. This function is essentially equivalent to: g_type_class_peek (g_type_parent (G_TYPE_FROM_CLASS (g_class))) the parent class of @g_class the #GTypeClass structure to retrieve the parent class for Decrements the reference count of the class structure being passed in. Once the last reference count of a class has been released, classes may be finalized by the type system, so further dereferencing of a class pointer after g_type_class_unref() are invalid. a #GTypeClass structure to unref A variant of g_type_class_unref() for use in #GTypeClassCacheFunc implementations. It unreferences a class without consulting the chain of #GTypeClassCacheFuncs, avoiding the recursion which would occur otherwise. a #GTypeClass structure to unref This function is essentially the same as g_type_class_ref(), except that the classes reference count isn't incremented. As a consequence, this function may return %NULL if the class of the type passed in does not currently exist (hasn't been referenced before). the #GTypeClass structure for the given type ID or %NULL if the class does not currently exist type ID of a classed type A more efficient version of g_type_class_peek() which works only for static types. the #GTypeClass structure for the given type ID or %NULL if the class does not currently exist or is dynamically loaded type ID of a classed type Increments the reference count of the class structure belonging to @type. This function will demand-create the class if it doesn't exist already. the #GTypeClass structure for the given type ID type ID of a classed type A callback function which is called when the reference count of a class drops to zero. It may use g_type_class_ref() to prevent the class from being freed. You should not call g_type_class_unref() from a #GTypeClassCacheFunc function to prevent infinite recursion, use g_type_class_unref_uncached() instead. The functions have to check the class id passed in to figure whether they actually want to cache the class of this type, since all classes are routed through the same #GTypeClassCacheFunc chain. %TRUE to stop further #GTypeClassCacheFuncs from being called, %FALSE to continue data that was given to the g_type_add_class_cache_func() call The #GTypeClass structure which is unreferenced These flags used to be passed to g_type_init_with_debug_flags() which is now deprecated. If you need to enable debugging features, use the GOBJECT_DEBUG environment variable. g_type_init() is now done automatically Print no messages Print messages about object bookkeeping Print messages about signal emissions Keep a count of instances of each type Mask covering all debug flags Bit masks used to check or determine characteristics of a type. Indicates an abstract type. No instances can be created for an abstract type Indicates an abstract value type, i.e. a type that introduces a value table, but can't be used for g_value_init() Bit masks used to check or determine specific characteristics of a fundamental type. Indicates a classed type Indicates an instantiable type (implies classed) Indicates a flat derivable type Indicates a deep derivable type (implies derivable) A structure that provides information to the type system which is used specifically for managing fundamental types. #GTypeFundamentalFlags describing the characteristics of the fundamental type This structure is used to provide the type system with the information required to initialize and destruct (finalize) a type's class and its instances. The initialized structure is passed to the g_type_register_static() function (or is copied into the provided #GTypeInfo structure in the g_type_plugin_complete_type_info()). The type system will perform a deep copy of this structure, so its memory does not need to be persistent across invocation of g_type_register_static(). Size of the class structure (required for interface, classed and instantiatable types) Location of the base initialization function (optional) Location of the base finalization function (optional) Location of the class initialization function for classed and instantiatable types. Location of the default vtable inititalization function for interface types. (optional) This function is used both to fill in virtual functions in the class or default vtable, and to do type-specific setup such as registering signals and object properties. Location of the class finalization function for classed and instantiatable types. Location of the default vtable finalization function for interface types. (optional) User-supplied data passed to the class init/finalize functions Size of the instance (object) structure (required for instantiatable types only) Prior to GLib 2.10, it specified the number of pre-allocated (cached) instances to reserve memory for (0 indicates no caching). Since GLib 2.10, it is ignored, since instances are allocated with the [slice allocator][glib-Memory-Slices] now. Location of the instance initialization function (optional, for instantiatable types only) A #GTypeValueTable function table for generic handling of GValues of this type (usually only useful for fundamental types) An opaque structure used as the base of all type instances. An opaque structure used as the base of all interface types. Returns the corresponding #GTypeInterface structure of the parent type of the instance type to which @g_iface belongs. This is useful when deriving the implementation of an interface from the parent type and then possibly overriding some methods. the corresponding #GTypeInterface structure of the parent type of the instance type to which @g_iface belongs, or %NULL if the parent type doesn't conform to the interface a #GTypeInterface structure Adds @prerequisite_type to the list of prerequisites of @interface_type. This means that any type implementing @interface_type must also implement @prerequisite_type. Prerequisites can be thought of as an alternative to interface derivation (which GType doesn't support). An interface can have at most one instantiatable prerequisite type. #GType value of an interface type #GType value of an interface or instantiatable type Returns the #GTypePlugin structure for the dynamic interface @interface_type which has been added to @instance_type, or %NULL if @interface_type has not been added to @instance_type or does not have a #GTypePlugin structure. See g_type_add_interface_dynamic(). the #GTypePlugin for the dynamic interface @interface_type of @instance_type #GType of an instantiatable type #GType of an interface type Returns the #GTypeInterface structure of an interface to which the passed in class conforms. the #GTypeInterface structure of @iface_type if implemented by @instance_class, %NULL otherwise a #GTypeClass structure an interface ID which this class conforms to Returns the prerequisites of an interfaces type. a newly-allocated zero-terminated array of #GType containing the prerequisites of @interface_type an interface type location to return the number of prerequisites, or %NULL A callback called after an interface vtable is initialized. See g_type_add_interface_check(). data passed to g_type_add_interface_check() the interface that has been initialized #GTypeModule provides a simple implementation of the #GTypePlugin interface. The model of #GTypeModule is a dynamically loaded module which implements some number of types and interface implementations. When the module is loaded, it registers its types and interfaces using g_type_module_register_type() and g_type_module_add_interface(). As long as any instances of these types and interface implementations are in use, the module is kept loaded. When the types and interfaces are gone, the module may be unloaded. If the types and interfaces become used again, the module will be reloaded. Note that the last unref cannot happen in module code, since that would lead to the caller's code being unloaded before g_object_unref() returns to it. Keeping track of whether the module should be loaded or not is done by using a use count - it starts at zero, and whenever it is greater than zero, the module is loaded. The use count is maintained internally by the type system, but also can be explicitly controlled by g_type_module_use() and g_type_module_unuse(). Typically, when loading a module for the first type, g_type_module_use() will be used to load it so that it can initialize its types. At some later point, when the module no longer needs to be loaded except for the type implementations it contains, g_type_module_unuse() is called. #GTypeModule does not actually provide any implementation of module loading and unloading. To create a particular module type you must derive from #GTypeModule and implement the load and unload functions in #GTypeModuleClass. Registers an additional interface for a type, whose interface lives in the given type plugin. If the interface was already registered for the type in this plugin, nothing will be done. As long as any instances of the type exist, the type plugin will not be unloaded. Since 2.56 if @module is %NULL this will call g_type_add_interface_static() instead. This can be used when making a static build of the module. a #GTypeModule type to which to add the interface. interface type to add type information structure Looks up or registers an enumeration that is implemented with a particular type plugin. If a type with name @type_name was previously registered, the #GType identifier for the type is returned, otherwise the type is newly registered, and the resulting #GType identifier returned. As long as any instances of the type exist, the type plugin will not be unloaded. Since 2.56 if @module is %NULL this will call g_type_register_static() instead. This can be used when making a static build of the module. the new or existing type ID a #GTypeModule name for the type an array of #GEnumValue structs for the possible enumeration values. The array is terminated by a struct with all members being 0. Looks up or registers a flags type that is implemented with a particular type plugin. If a type with name @type_name was previously registered, the #GType identifier for the type is returned, otherwise the type is newly registered, and the resulting #GType identifier returned. As long as any instances of the type exist, the type plugin will not be unloaded. Since 2.56 if @module is %NULL this will call g_type_register_static() instead. This can be used when making a static build of the module. the new or existing type ID a #GTypeModule name for the type an array of #GFlagsValue structs for the possible flags values. The array is terminated by a struct with all members being 0. Looks up or registers a type that is implemented with a particular type plugin. If a type with name @type_name was previously registered, the #GType identifier for the type is returned, otherwise the type is newly registered, and the resulting #GType identifier returned. When reregistering a type (typically because a module is unloaded then reloaded, and reinitialized), @module and @parent_type must be the same as they were previously. As long as any instances of the type exist, the type plugin will not be unloaded. Since 2.56 if @module is %NULL this will call g_type_register_static() instead. This can be used when making a static build of the module. the new or existing type ID a #GTypeModule the type for the parent class name for the type type information structure flags field providing details about the type Sets the name for a #GTypeModule a #GTypeModule. a human-readable name to use in error messages. Decreases the use count of a #GTypeModule by one. If the result is zero, the module will be unloaded. (However, the #GTypeModule will not be freed, and types associated with the #GTypeModule are not unregistered. Once a #GTypeModule is initialized, it must exist forever.) a #GTypeModule Increases the use count of a #GTypeModule by one. If the use count was zero before, the plugin will be loaded. If loading the plugin fails, the use count is reset to its prior value. %FALSE if the plugin needed to be loaded and loading the plugin failed. a #GTypeModule the name of the module In order to implement dynamic loading of types based on #GTypeModule, the @load and @unload functions in #GTypeModuleClass must be implemented. the parent class The GObject type system supports dynamic loading of types. The #GTypePlugin interface is used to handle the lifecycle of dynamically loaded types. It goes as follows: 1. The type is initially introduced (usually upon loading the module the first time, or by your main application that knows what modules introduces what types), like this: |[<!-- language="C" --> new_type_id = g_type_register_dynamic (parent_type_id, "TypeName", new_type_plugin, type_flags); ]| where @new_type_plugin is an implementation of the #GTypePlugin interface. 2. The type's implementation is referenced, e.g. through g_type_class_ref() or through g_type_create_instance() (this is being called by g_object_new()) or through one of the above done on a type derived from @new_type_id. 3. This causes the type system to load the type's implementation by calling g_type_plugin_use() and g_type_plugin_complete_type_info() on @new_type_plugin. 4. At some point the type's implementation isn't required anymore, e.g. after g_type_class_unref() or g_type_free_instance() (called when the reference count of an instance drops to zero). 5. This causes the type system to throw away the information retrieved from g_type_plugin_complete_type_info() and then it calls g_type_plugin_unuse() on @new_type_plugin. 6. Things may repeat from the second step. So basically, you need to implement a #GTypePlugin type that carries a use_count, once use_count goes from zero to one, you need to load the implementation to successfully handle the upcoming g_type_plugin_complete_type_info() call. Later, maybe after succeeding use/unuse calls, once use_count drops to zero, you can unload the implementation again. The type system makes sure to call g_type_plugin_use() and g_type_plugin_complete_type_info() again when the type is needed again. #GTypeModule is an implementation of #GTypePlugin that already implements most of this except for the actual module loading and unloading. It even handles multiple registered types per module. Calls the @complete_interface_info function from the #GTypePluginClass of @plugin. There should be no need to use this function outside of the GObject type system itself. the #GTypePlugin the #GType of an instantiable type to which the interface is added the #GType of the interface whose info is completed the #GInterfaceInfo to fill in Calls the @complete_type_info function from the #GTypePluginClass of @plugin. There should be no need to use this function outside of the GObject type system itself. a #GTypePlugin the #GType whose info is completed the #GTypeInfo struct to fill in the #GTypeValueTable to fill in Calls the @unuse_plugin function from the #GTypePluginClass of @plugin. There should be no need to use this function outside of the GObject type system itself. a #GTypePlugin Calls the @use_plugin function from the #GTypePluginClass of @plugin. There should be no need to use this function outside of the GObject type system itself. a #GTypePlugin The #GTypePlugin interface is used by the type system in order to handle the lifecycle of dynamically loaded types. Increases the use count of the plugin. Decreases the use count of the plugin. Fills in the #GTypeInfo and #GTypeValueTable structs for the type. The structs are initialized with `memset(s, 0, sizeof (s))` before calling this function. Fills in missing parts of the #GInterfaceInfo for the interface. The structs is initialized with `memset(s, 0, sizeof (s))` before calling this function. The type of the @complete_interface_info function of #GTypePluginClass. the #GTypePlugin the #GType of an instantiable type to which the interface is added the #GType of the interface whose info is completed the #GInterfaceInfo to fill in The type of the @complete_type_info function of #GTypePluginClass. the #GTypePlugin the #GType whose info is completed the #GTypeInfo struct to fill in the #GTypeValueTable to fill in The type of the @unuse_plugin function of #GTypePluginClass. the #GTypePlugin whose use count should be decreased The type of the @use_plugin function of #GTypePluginClass, which gets called to increase the use count of @plugin. the #GTypePlugin whose use count should be increased A structure holding information for a specific type. It is filled in by the g_type_query() function. the #GType value of the type the name of the type the size of the class structure the size of the instance structure The #GTypeValueTable provides the functions required by the #GValue implementation, to serve as a container for values of a type. A string format describing how to collect the contents of this value bit-by-bit. Each character in the format represents an argument to be collected, and the characters themselves indicate the type of the argument. Currently supported arguments are: - 'i' - Integers. passed as collect_values[].v_int. - 'l' - Longs. passed as collect_values[].v_long. - 'd' - Doubles. passed as collect_values[].v_double. - 'p' - Pointers. passed as collect_values[].v_pointer. It should be noted that for variable argument list construction, ANSI C promotes every type smaller than an integer to an int, and floats to doubles. So for collection of short int or char, 'i' needs to be used, and for collection of floats 'd'. Format description of the arguments to collect for @lcopy_value, analogous to @collect_format. Usually, @lcopy_format string consists only of 'p's to provide lcopy_value() with pointers to storage locations. Returns the location of the #GTypeValueTable associated with @type. Note that this function should only be used from source code that implements or has internal knowledge of the implementation of @type. location of the #GTypeValueTable associated with @type or %NULL if there is no #GTypeValueTable associated with @type a #GType Checks if @value holds (or contains) a value of @type. This macro will also check for @value != %NULL and issue a warning if the check fails. A #GValue structure. A #GType value. Checks whether the given #GValue can hold values of type %G_TYPE_BOOLEAN. a valid #GValue structure Checks whether the given #GValue can hold values derived from type %G_TYPE_BOXED. a valid #GValue structure Checks whether the given #GValue can hold values of type %G_TYPE_CHAR. a valid #GValue structure Checks whether the given #GValue can hold values of type %G_TYPE_DOUBLE. a valid #GValue structure Checks whether the given #GValue can hold values derived from type %G_TYPE_ENUM. a valid #GValue structure Checks whether the given #GValue can hold values derived from type %G_TYPE_FLAGS. a valid #GValue structure Checks whether the given #GValue can hold values of type %G_TYPE_FLOAT. a valid #GValue structure Checks whether the given #GValue can hold values of type %G_TYPE_GTYPE. a valid #GValue structure Checks whether the given #GValue can hold values of type %G_TYPE_INT. a valid #GValue structure Checks whether the given #GValue can hold values of type %G_TYPE_INT64. a valid #GValue structure Checks whether the given #GValue can hold values of type %G_TYPE_LONG. a valid #GValue structure Checks whether the given #GValue can hold values derived from type %G_TYPE_OBJECT. a valid #GValue structure Checks whether the given #GValue can hold values derived from type %G_TYPE_PARAM. a valid #GValue structure Checks whether the given #GValue can hold values of type %G_TYPE_POINTER. a valid #GValue structure Checks whether the given #GValue can hold values of type %G_TYPE_STRING. a valid #GValue structure Checks whether the given #GValue can hold values of type %G_TYPE_UCHAR. a valid #GValue structure Checks whether the given #GValue can hold values of type %G_TYPE_UINT. a valid #GValue structure Checks whether the given #GValue can hold values of type %G_TYPE_UINT64. a valid #GValue structure Checks whether the given #GValue can hold values of type %G_TYPE_ULONG. a valid #GValue structure Checks whether the given #GValue can hold values of type %G_TYPE_VARIANT. a valid #GValue structure For string values, indicates that the string contained is canonical and will exist for the duration of the process. See g_value_set_interned_string(). Checks whether @value contains a string which is canonical. a valid #GValue structure If passed to G_VALUE_COLLECT(), allocated data won't be copied but used verbatim. This does not affect ref-counted types like objects. This does not affect usage of g_value_copy(), the data will be copied if it is not ref-counted. Get the type identifier of @value. A #GValue structure. Gets the type name of @value. A #GValue structure. This is the signature of va_list marshaller functions, an optional marshaller that can be used in some situations to avoid marshalling the signal argument into GValues. the #GClosure to which the marshaller belongs a #GValue to store the return value. May be %NULL if the callback of @closure doesn't return a value. the instance on which the closure is invoked. va_list of arguments to be passed to the closure. additional data specified when registering the marshaller, see g_closure_set_marshal() and g_closure_set_meta_marshal() the length of the @param_types array the #GType of each argument from @args. An opaque structure used to hold different types of values. The data within the structure has protected scope: it is accessible only to functions within a #GTypeValueTable structure, or implementations of the g_value_*() API. That is, code portions which implement new fundamental types. #GValue users cannot make any assumptions about how data is stored within the 2 element @data union, and the @g_type member should only be accessed through the G_VALUE_TYPE() macro. Copies the value of @src_value into @dest_value. An initialized #GValue structure. An initialized #GValue structure of the same type as @src_value. Get the contents of a %G_TYPE_BOXED derived #GValue. Upon getting, the boxed value is duplicated and needs to be later freed with g_boxed_free(), e.g. like: g_boxed_free (G_VALUE_TYPE (@value), return_value); boxed contents of @value a valid #GValue of %G_TYPE_BOXED derived type Get the contents of a %G_TYPE_OBJECT derived #GValue, increasing its reference count. If the contents of the #GValue are %NULL, then %NULL will be returned. object content of @value, should be unreferenced when no longer needed. a valid #GValue whose type is derived from %G_TYPE_OBJECT Get the contents of a %G_TYPE_PARAM #GValue, increasing its reference count. #GParamSpec content of @value, should be unreferenced when no longer needed. a valid #GValue whose type is derived from %G_TYPE_PARAM Get a copy the contents of a %G_TYPE_STRING #GValue. a newly allocated copy of the string content of @value a valid #GValue of type %G_TYPE_STRING Get the contents of a variant #GValue, increasing its refcount. The returned #GVariant is never floating. variant contents of @value (may be %NULL); should be unreffed using g_variant_unref() when no longer needed a valid #GValue of type %G_TYPE_VARIANT Determines if @value will fit inside the size of a pointer value. This is an internal function introduced mainly for C marshallers. %TRUE if @value will fit inside a pointer value. An initialized #GValue structure. Get the contents of a %G_TYPE_BOOLEAN #GValue. boolean contents of @value a valid #GValue of type %G_TYPE_BOOLEAN Get the contents of a %G_TYPE_BOXED derived #GValue. boxed contents of @value a valid #GValue of %G_TYPE_BOXED derived type Do not use this function; it is broken on platforms where the %char type is unsigned, such as ARM and PowerPC. See g_value_get_schar(). Get the contents of a %G_TYPE_CHAR #GValue. This function's return type is broken, see g_value_get_schar() character contents of @value a valid #GValue of type %G_TYPE_CHAR Get the contents of a %G_TYPE_DOUBLE #GValue. double contents of @value a valid #GValue of type %G_TYPE_DOUBLE Get the contents of a %G_TYPE_ENUM #GValue. enum contents of @value a valid #GValue whose type is derived from %G_TYPE_ENUM Get the contents of a %G_TYPE_FLAGS #GValue. flags contents of @value a valid #GValue whose type is derived from %G_TYPE_FLAGS Get the contents of a %G_TYPE_FLOAT #GValue. float contents of @value a valid #GValue of type %G_TYPE_FLOAT Get the contents of a %G_TYPE_GTYPE #GValue. the #GType stored in @value a valid #GValue of type %G_TYPE_GTYPE Get the contents of a %G_TYPE_INT #GValue. integer contents of @value a valid #GValue of type %G_TYPE_INT Get the contents of a %G_TYPE_INT64 #GValue. 64bit integer contents of @value a valid #GValue of type %G_TYPE_INT64 Get the contents of a %G_TYPE_LONG #GValue. long integer contents of @value a valid #GValue of type %G_TYPE_LONG Get the contents of a %G_TYPE_OBJECT derived #GValue. object contents of @value a valid #GValue of %G_TYPE_OBJECT derived type Get the contents of a %G_TYPE_PARAM #GValue. #GParamSpec content of @value a valid #GValue whose type is derived from %G_TYPE_PARAM Get the contents of a pointer #GValue. pointer contents of @value a valid #GValue of %G_TYPE_POINTER Get the contents of a %G_TYPE_CHAR #GValue. signed 8 bit integer contents of @value a valid #GValue of type %G_TYPE_CHAR Get the contents of a %G_TYPE_STRING #GValue. string content of @value a valid #GValue of type %G_TYPE_STRING Get the contents of a %G_TYPE_UCHAR #GValue. unsigned character contents of @value a valid #GValue of type %G_TYPE_UCHAR Get the contents of a %G_TYPE_UINT #GValue. unsigned integer contents of @value a valid #GValue of type %G_TYPE_UINT Get the contents of a %G_TYPE_UINT64 #GValue. unsigned 64bit integer contents of @value a valid #GValue of type %G_TYPE_UINT64 Get the contents of a %G_TYPE_ULONG #GValue. unsigned long integer contents of @value a valid #GValue of type %G_TYPE_ULONG Get the contents of a variant #GValue. variant contents of @value (may be %NULL) a valid #GValue of type %G_TYPE_VARIANT Initializes @value with the default value of @type. the #GValue structure that has been passed in A zero-filled (uninitialized) #GValue structure. Type the #GValue should hold values of. Initializes and sets @value from an instantiatable type via the value_table's collect_value() function. Note: The @value will be initialised with the exact type of @instance. If you wish to set the @value's type to a different GType (such as a parent class GType), you need to manually call g_value_init() and g_value_set_instance(). An uninitialized #GValue structure. the instance Returns the value contents as pointer. This function asserts that g_value_fits_pointer() returned %TRUE for the passed in value. This is an internal function introduced mainly for C marshallers. the value contents as pointer An initialized #GValue structure Clears the current value in @value and resets it to the default value (as if the value had just been initialized). the #GValue structure that has been passed in An initialized #GValue structure. Set the contents of a %G_TYPE_BOOLEAN #GValue to @v_boolean. a valid #GValue of type %G_TYPE_BOOLEAN boolean value to be set Set the contents of a %G_TYPE_BOXED derived #GValue to @v_boxed. a valid #GValue of %G_TYPE_BOXED derived type boxed value to be set This is an internal function introduced mainly for C marshallers. Use g_value_take_boxed() instead. a valid #GValue of %G_TYPE_BOXED derived type duplicated unowned boxed value to be set Set the contents of a %G_TYPE_CHAR #GValue to @v_char. This function's input type is broken, see g_value_set_schar() a valid #GValue of type %G_TYPE_CHAR character value to be set Set the contents of a %G_TYPE_DOUBLE #GValue to @v_double. a valid #GValue of type %G_TYPE_DOUBLE double value to be set Set the contents of a %G_TYPE_ENUM #GValue to @v_enum. a valid #GValue whose type is derived from %G_TYPE_ENUM enum value to be set Set the contents of a %G_TYPE_FLAGS #GValue to @v_flags. a valid #GValue whose type is derived from %G_TYPE_FLAGS flags value to be set Set the contents of a %G_TYPE_FLOAT #GValue to @v_float. a valid #GValue of type %G_TYPE_FLOAT float value to be set Set the contents of a %G_TYPE_GTYPE #GValue to @v_gtype. a valid #GValue of type %G_TYPE_GTYPE #GType to be set Sets @value from an instantiatable type via the value_table's collect_value() function. An initialized #GValue structure. the instance Set the contents of a %G_TYPE_INT #GValue to @v_int. a valid #GValue of type %G_TYPE_INT integer value to be set Set the contents of a %G_TYPE_INT64 #GValue to @v_int64. a valid #GValue of type %G_TYPE_INT64 64bit integer value to be set Set the contents of a %G_TYPE_STRING #GValue to @v_string. The string is assumed to be static and interned (canonical, for example from g_intern_string()), and is thus not duplicated when setting the #GValue. a valid #GValue of type %G_TYPE_STRING static string to be set Set the contents of a %G_TYPE_LONG #GValue to @v_long. a valid #GValue of type %G_TYPE_LONG long integer value to be set Set the contents of a %G_TYPE_OBJECT derived #GValue to @v_object. g_value_set_object() increases the reference count of @v_object (the #GValue holds a reference to @v_object). If you do not wish to increase the reference count of the object (i.e. you wish to pass your current reference to the #GValue because you no longer need it), use g_value_take_object() instead. It is important that your #GValue holds a reference to @v_object (either its own, or one it has taken) to ensure that the object won't be destroyed while the #GValue still exists). a valid #GValue of %G_TYPE_OBJECT derived type object value to be set This is an internal function introduced mainly for C marshallers. Use g_value_take_object() instead. a valid #GValue of %G_TYPE_OBJECT derived type object value to be set Set the contents of a %G_TYPE_PARAM #GValue to @param. a valid #GValue of type %G_TYPE_PARAM the #GParamSpec to be set This is an internal function introduced mainly for C marshallers. Use g_value_take_param() instead. a valid #GValue of type %G_TYPE_PARAM the #GParamSpec to be set Set the contents of a pointer #GValue to @v_pointer. a valid #GValue of %G_TYPE_POINTER pointer value to be set Set the contents of a %G_TYPE_CHAR #GValue to @v_char. a valid #GValue of type %G_TYPE_CHAR signed 8 bit integer to be set Set the contents of a %G_TYPE_BOXED derived #GValue to @v_boxed. The boxed value is assumed to be static, and is thus not duplicated when setting the #GValue. a valid #GValue of %G_TYPE_BOXED derived type static boxed value to be set Set the contents of a %G_TYPE_STRING #GValue to @v_string. The string is assumed to be static, and is thus not duplicated when setting the #GValue. If the the string is a canonical string, using g_value_set_interned_string() is more appropriate. a valid #GValue of type %G_TYPE_STRING static string to be set Set the contents of a %G_TYPE_STRING #GValue to @v_string. a valid #GValue of type %G_TYPE_STRING caller-owned string to be duplicated for the #GValue This is an internal function introduced mainly for C marshallers. Use g_value_take_string() instead. a valid #GValue of type %G_TYPE_STRING duplicated unowned string to be set Set the contents of a %G_TYPE_UCHAR #GValue to @v_uchar. a valid #GValue of type %G_TYPE_UCHAR unsigned character value to be set Set the contents of a %G_TYPE_UINT #GValue to @v_uint. a valid #GValue of type %G_TYPE_UINT unsigned integer value to be set Set the contents of a %G_TYPE_UINT64 #GValue to @v_uint64. a valid #GValue of type %G_TYPE_UINT64 unsigned 64bit integer value to be set Set the contents of a %G_TYPE_ULONG #GValue to @v_ulong. a valid #GValue of type %G_TYPE_ULONG unsigned long integer value to be set Set the contents of a variant #GValue to @variant. If the variant is floating, it is consumed. a valid #GValue of type %G_TYPE_VARIANT a #GVariant, or %NULL Sets the contents of a %G_TYPE_BOXED derived #GValue to @v_boxed and takes over the ownership of the caller’s reference to @v_boxed; the caller doesn’t have to unref it any more. a valid #GValue of %G_TYPE_BOXED derived type duplicated unowned boxed value to be set Sets the contents of a %G_TYPE_OBJECT derived #GValue to @v_object and takes over the ownership of the caller’s reference to @v_object; the caller doesn’t have to unref it any more (i.e. the reference count of the object is not increased). If you want the #GValue to hold its own reference to @v_object, use g_value_set_object() instead. a valid #GValue of %G_TYPE_OBJECT derived type object value to be set Sets the contents of a %G_TYPE_PARAM #GValue to @param and takes over the ownership of the caller’s reference to @param; the caller doesn’t have to unref it any more. a valid #GValue of type %G_TYPE_PARAM the #GParamSpec to be set Sets the contents of a %G_TYPE_STRING #GValue to @v_string. a valid #GValue of type %G_TYPE_STRING string to take ownership of Set the contents of a variant #GValue to @variant, and takes over the ownership of the caller's reference to @variant; the caller doesn't have to unref it any more (i.e. the reference count of the variant is not increased). If @variant was floating then its floating reference is converted to a hard reference. If you want the #GValue to hold its own reference to @variant, use g_value_set_variant() instead. This is an internal function introduced mainly for C marshallers. a valid #GValue of type %G_TYPE_VARIANT a #GVariant, or %NULL Tries to cast the contents of @src_value into a type appropriate to store in @dest_value, e.g. to transform a %G_TYPE_INT value into a %G_TYPE_FLOAT value. Performing transformations between value types might incur precision lossage. Especially transformations into strings might reveal seemingly arbitrary results and shouldn't be relied upon for production code (such as rcfile value or object property serialization). Whether a transformation rule was found and could be applied. Upon failing transformations, @dest_value is left untouched. Source value. Target value. Clears the current value in @value (if any) and "unsets" the type, this releases all resources associated with this GValue. An unset value is the same as an uninitialized (zero-filled) #GValue structure. An initialized #GValue structure. Registers a value transformation function for use in g_value_transform(). A previously registered transformation function for @src_type and @dest_type will be replaced. Source type. Target type. a function which transforms values of type @src_type into value of type @dest_type Returns whether a #GValue of type @src_type can be copied into a #GValue of type @dest_type. %TRUE if g_value_copy() is possible with @src_type and @dest_type. source type to be copied. destination type for copying. Check whether g_value_transform() is able to transform values of type @src_type into values of type @dest_type. Note that for the types to be transformable, they must be compatible or a transformation function must be registered. %TRUE if the transformation is possible, %FALSE otherwise. Source type. Target type. A #GValueArray contains an array of #GValue elements. number of values contained in the array array of values Allocate and initialize a new #GValueArray, optionally preserve space for @n_prealloced elements. New arrays always contain 0 elements, regardless of the value of @n_prealloced. Use #GArray and g_array_sized_new() instead. a newly allocated #GValueArray with 0 values number of values to preallocate space for Insert a copy of @value as last element of @value_array. If @value is %NULL, an uninitialized value is appended. Use #GArray and g_array_append_val() instead. the #GValueArray passed in as @value_array #GValueArray to add an element to #GValue to copy into #GValueArray, or %NULL Construct an exact copy of a #GValueArray by duplicating all its contents. Use #GArray and g_array_ref() instead. Newly allocated copy of #GValueArray #GValueArray to copy Free a #GValueArray including its contents. Use #GArray and g_array_unref() instead. #GValueArray to free Return a pointer to the value at @index_ containd in @value_array. Use g_array_index() instead. pointer to a value at @index_ in @value_array #GValueArray to get a value from index of the value of interest Insert a copy of @value at specified position into @value_array. If @value is %NULL, an uninitialized value is inserted. Use #GArray and g_array_insert_val() instead. the #GValueArray passed in as @value_array #GValueArray to add an element to insertion position, must be <= value_array->;n_values #GValue to copy into #GValueArray, or %NULL Insert a copy of @value as first element of @value_array. If @value is %NULL, an uninitialized value is prepended. Use #GArray and g_array_prepend_val() instead. the #GValueArray passed in as @value_array #GValueArray to add an element to #GValue to copy into #GValueArray, or %NULL Remove the value at position @index_ from @value_array. Use #GArray and g_array_remove_index() instead. the #GValueArray passed in as @value_array #GValueArray to remove an element from position of value to remove, which must be less than @value_array->n_values Sort @value_array using @compare_func to compare the elements according to the semantics of #GCompareFunc. The current implementation uses the same sorting algorithm as standard C qsort() function. Use #GArray and g_array_sort(). the #GValueArray passed in as @value_array #GValueArray to sort function to compare elements Sort @value_array using @compare_func to compare the elements according to the semantics of #GCompareDataFunc. The current implementation uses the same sorting algorithm as standard C qsort() function. Use #GArray and g_array_sort_with_data(). the #GValueArray passed in as @value_array #GValueArray to sort function to compare elements extra data argument provided for @compare_func The type of value transformation functions which can be registered with g_value_register_transform_func(). @dest_value will be initialized to the correct destination type. Source value. Target value. A #GWeakNotify function can be added to an object as a callback that gets triggered when the object is finalized. Since the object is already being finalized when the #GWeakNotify is called, there's not much you could do with the object, apart from e.g. using its address as hash-index or the like. data that was provided when the weak reference was established the object being finalized A structure containing a weak reference to a #GObject. It can either be empty (i.e. point to %NULL), or point to an object for as long as at least one "strong" reference to that object exists. Before the object's #GObjectClass.dispose method is called, every #GWeakRef associated with becomes empty (i.e. points to %NULL). Like #GValue, #GWeakRef can be statically allocated, stack- or heap-allocated, or embedded in larger structures. Unlike g_object_weak_ref() and g_object_add_weak_pointer(), this weak reference is thread-safe: converting a weak pointer to a reference is atomic with respect to invalidation of weak pointers to destroyed objects. If the object's #GObjectClass.dispose method results in additional references to the object being held, any #GWeakRefs taken before it was disposed will continue to point to %NULL. If #GWeakRefs are taken after the object is disposed and re-referenced, they will continue to point to it until its refcount goes back to zero, at which point they too will be invalidated. Frees resources associated with a non-statically-allocated #GWeakRef. After this call, the #GWeakRef is left in an undefined state. You should only call this on a #GWeakRef that previously had g_weak_ref_init() called on it. location of a weak reference, which may be empty If @weak_ref is not empty, atomically acquire a strong reference to the object it points to, and return that reference. This function is needed because of the potential race between taking the pointer value and g_object_ref() on it, if the object was losing its last reference at the same time in a different thread. The caller should release the resulting reference in the usual way, by using g_object_unref(). the object pointed to by @weak_ref, or %NULL if it was empty location of a weak reference to a #GObject Initialise a non-statically-allocated #GWeakRef. This function also calls g_weak_ref_set() with @object on the freshly-initialised weak reference. This function should always be matched with a call to g_weak_ref_clear(). It is not necessary to use this function for a #GWeakRef in static storage because it will already be properly initialised. Just use g_weak_ref_set() directly. uninitialized or empty location for a weak reference a #GObject or %NULL Change the object to which @weak_ref points, or set it to %NULL. You must own a strong reference on @object while calling this function. location for a weak reference a #GObject or %NULL Assert that @object is non-%NULL, then release one reference to it with g_object_unref() and assert that it has been finalized (i.e. that there are no more references). If assertions are disabled via `G_DISABLE_ASSERT`, this macro just calls g_object_unref() without any further checks. This macro should only be used in regression tests. an object Provide a copy of a boxed structure @src_boxed which is of type @boxed_type. The newly created copy of the boxed structure. The type of @src_boxed. The boxed structure to be copied. Free the boxed structure @boxed which is of type @boxed_type. The type of @boxed. The boxed structure to be freed. This function creates a new %G_TYPE_BOXED derived type id for a new boxed type with name @name. Boxed type handling functions have to be provided to copy and free opaque boxed structures of this type. New %G_TYPE_BOXED derived type id for @name. Name of the new boxed type. Boxed structure copy function. Boxed structure free function. A #GClosureMarshal function for use with signals with handlers that take two boxed pointers as arguments and return a boolean. If you have such a signal, you will probably also need to use an accumulator, such as g_signal_accumulator_true_handled(). A #GClosure. A #GValue to store the return value. May be %NULL if the callback of closure doesn't return a value. The length of the @param_values array. An array of #GValues holding the arguments on which to invoke the callback of closure. The invocation hint given as the last argument to g_closure_invoke(). Additional data specified when registering the marshaller, see g_closure_set_marshal() and g_closure_set_meta_marshal() A marshaller for a #GCClosure with a callback of type `gboolean (*callback) (gpointer instance, gint arg1, gpointer user_data)` where the #gint parameter denotes a flags type. the #GClosure to which the marshaller belongs a #GValue which can store the returned #gboolean 2 a #GValue array holding instance and arg1 the invocation hint given as the last argument to g_closure_invoke() additional data specified when registering the marshaller A marshaller for a #GCClosure with a callback of type `gchar* (*callback) (gpointer instance, GObject *arg1, gpointer arg2, gpointer user_data)`. the #GClosure to which the marshaller belongs a #GValue, which can store the returned string 3 a #GValue array holding instance, arg1 and arg2 the invocation hint given as the last argument to g_closure_invoke() additional data specified when registering the marshaller A marshaller for a #GCClosure with a callback of type `void (*callback) (gpointer instance, gboolean arg1, gpointer user_data)`. the #GClosure to which the marshaller belongs ignored 2 a #GValue array holding the instance and the #gboolean parameter the invocation hint given as the last argument to g_closure_invoke() additional data specified when registering the marshaller A marshaller for a #GCClosure with a callback of type `void (*callback) (gpointer instance, GBoxed *arg1, gpointer user_data)`. the #GClosure to which the marshaller belongs ignored 2 a #GValue array holding the instance and the #GBoxed* parameter the invocation hint given as the last argument to g_closure_invoke() additional data specified when registering the marshaller A marshaller for a #GCClosure with a callback of type `void (*callback) (gpointer instance, gchar arg1, gpointer user_data)`. the #GClosure to which the marshaller belongs ignored 2 a #GValue array holding the instance and the #gchar parameter the invocation hint given as the last argument to g_closure_invoke() additional data specified when registering the marshaller A marshaller for a #GCClosure with a callback of type `void (*callback) (gpointer instance, gdouble arg1, gpointer user_data)`. the #GClosure to which the marshaller belongs ignored 2 a #GValue array holding the instance and the #gdouble parameter the invocation hint given as the last argument to g_closure_invoke() additional data specified when registering the marshaller A marshaller for a #GCClosure with a callback of type `void (*callback) (gpointer instance, gint arg1, gpointer user_data)` where the #gint parameter denotes an enumeration type.. the #GClosure to which the marshaller belongs ignored 2 a #GValue array holding the instance and the enumeration parameter the invocation hint given as the last argument to g_closure_invoke() additional data specified when registering the marshaller A marshaller for a #GCClosure with a callback of type `void (*callback) (gpointer instance, gint arg1, gpointer user_data)` where the #gint parameter denotes a flags type. the #GClosure to which the marshaller belongs ignored 2 a #GValue array holding the instance and the flags parameter the invocation hint given as the last argument to g_closure_invoke() additional data specified when registering the marshaller A marshaller for a #GCClosure with a callback of type `void (*callback) (gpointer instance, gfloat arg1, gpointer user_data)`. the #GClosure to which the marshaller belongs ignored 2 a #GValue array holding the instance and the #gfloat parameter the invocation hint given as the last argument to g_closure_invoke() additional data specified when registering the marshaller A marshaller for a #GCClosure with a callback of type `void (*callback) (gpointer instance, gint arg1, gpointer user_data)`. the #GClosure to which the marshaller belongs ignored 2 a #GValue array holding the instance and the #gint parameter the invocation hint given as the last argument to g_closure_invoke() additional data specified when registering the marshaller A marshaller for a #GCClosure with a callback of type `void (*callback) (gpointer instance, glong arg1, gpointer user_data)`. the #GClosure to which the marshaller belongs ignored 2 a #GValue array holding the instance and the #glong parameter the invocation hint given as the last argument to g_closure_invoke() additional data specified when registering the marshaller A marshaller for a #GCClosure with a callback of type `void (*callback) (gpointer instance, GObject *arg1, gpointer user_data)`. the #GClosure to which the marshaller belongs ignored 2 a #GValue array holding the instance and the #GObject* parameter the invocation hint given as the last argument to g_closure_invoke() additional data specified when registering the marshaller A marshaller for a #GCClosure with a callback of type `void (*callback) (gpointer instance, GParamSpec *arg1, gpointer user_data)`. the #GClosure to which the marshaller belongs ignored 2 a #GValue array holding the instance and the #GParamSpec* parameter the invocation hint given as the last argument to g_closure_invoke() additional data specified when registering the marshaller A marshaller for a #GCClosure with a callback of type `void (*callback) (gpointer instance, gpointer arg1, gpointer user_data)`. the #GClosure to which the marshaller belongs ignored 2 a #GValue array holding the instance and the #gpointer parameter the invocation hint given as the last argument to g_closure_invoke() additional data specified when registering the marshaller A marshaller for a #GCClosure with a callback of type `void (*callback) (gpointer instance, const gchar *arg1, gpointer user_data)`. the #GClosure to which the marshaller belongs ignored 2 a #GValue array holding the instance and the #gchar* parameter the invocation hint given as the last argument to g_closure_invoke() additional data specified when registering the marshaller A marshaller for a #GCClosure with a callback of type `void (*callback) (gpointer instance, guchar arg1, gpointer user_data)`. the #GClosure to which the marshaller belongs ignored 2 a #GValue array holding the instance and the #guchar parameter the invocation hint given as the last argument to g_closure_invoke() additional data specified when registering the marshaller A marshaller for a #GCClosure with a callback of type `void (*callback) (gpointer instance, guint arg1, gpointer user_data)`. the #GClosure to which the marshaller belongs ignored 2 a #GValue array holding the instance and the #guint parameter the invocation hint given as the last argument to g_closure_invoke() additional data specified when registering the marshaller A marshaller for a #GCClosure with a callback of type `void (*callback) (gpointer instance, guint arg1, gpointer arg2, gpointer user_data)`. the #GClosure to which the marshaller belongs ignored 3 a #GValue array holding instance, arg1 and arg2 the invocation hint given as the last argument to g_closure_invoke() additional data specified when registering the marshaller A marshaller for a #GCClosure with a callback of type `void (*callback) (gpointer instance, gulong arg1, gpointer user_data)`. the #GClosure to which the marshaller belongs ignored 2 a #GValue array holding the instance and the #gulong parameter the invocation hint given as the last argument to g_closure_invoke() additional data specified when registering the marshaller A marshaller for a #GCClosure with a callback of type `void (*callback) (gpointer instance, GVariant *arg1, gpointer user_data)`. the #GClosure to which the marshaller belongs ignored 2 a #GValue array holding the instance and the #GVariant* parameter the invocation hint given as the last argument to g_closure_invoke() additional data specified when registering the marshaller A marshaller for a #GCClosure with a callback of type `void (*callback) (gpointer instance, gpointer user_data)`. the #GClosure to which the marshaller belongs ignored 1 a #GValue array holding only the instance the invocation hint given as the last argument to g_closure_invoke() additional data specified when registering the marshaller A generic marshaller function implemented via [libffi](http://sourceware.org/libffi/). Normally this function is not passed explicitly to g_signal_new(), but used automatically by GLib when specifying a %NULL marshaller. A #GClosure. A #GValue to store the return value. May be %NULL if the callback of closure doesn't return a value. The length of the @param_values array. An array of #GValues holding the arguments on which to invoke the callback of closure. The invocation hint given as the last argument to g_closure_invoke(). Additional data specified when registering the marshaller, see g_closure_set_marshal() and g_closure_set_meta_marshal() Creates a new closure which invokes @callback_func with @user_data as the last parameter. @destroy_data will be called as a finalize notifier on the #GClosure. a floating reference to a new #GCClosure the function to invoke user data to pass to @callback_func destroy notify to be called when @user_data is no longer used A variant of g_cclosure_new() which uses @object as @user_data and calls g_object_watch_closure() on @object and the created closure. This function is useful when you have a callback closely associated with a #GObject, and want the callback to no longer run after the object is is freed. a new #GCClosure the function to invoke a #GObject pointer to pass to @callback_func A variant of g_cclosure_new_swap() which uses @object as @user_data and calls g_object_watch_closure() on @object and the created closure. This function is useful when you have a callback closely associated with a #GObject, and want the callback to no longer run after the object is is freed. a new #GCClosure the function to invoke a #GObject pointer to pass to @callback_func Creates a new closure which invokes @callback_func with @user_data as the first parameter. @destroy_data will be called as a finalize notifier on the #GClosure. a floating reference to a new #GCClosure the function to invoke user data to pass to @callback_func destroy notify to be called when @user_data is no longer used Clears a reference to a #GObject. @object_ptr must not be %NULL. If the reference is %NULL then this function does nothing. Otherwise, the reference count of the object is decreased and the pointer is set to %NULL. A macro is also included that allows this function to be used without pointer casts. a pointer to a #GObject reference Disconnects a handler from @instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to. The @handler_id_ptr is then set to zero, which is never a valid handler ID value (see g_signal_connect()). If the handler ID is 0 then this function does nothing. A macro is also included that allows this function to be used without pointer casts. A pointer to a handler ID (of type #gulong) of the handler to be disconnected. The instance to remove the signal handler from. Clears a weak reference to a #GObject. @weak_pointer_location must not be %NULL. If the weak reference is %NULL then this function does nothing. Otherwise, the weak reference to the object is removed for that location and the pointer is set to %NULL. A macro is also included that allows this function to be used without pointer casts. The function itself is static inline, so its address may vary between compilation units. The memory address of a pointer This function is meant to be called from the `complete_type_info` function of a #GTypePlugin implementation, as in the following example: |[<!-- language="C" --> static void my_enum_complete_type_info (GTypePlugin *plugin, GType g_type, GTypeInfo *info, GTypeValueTable *value_table) { static const GEnumValue values[] = { { MY_ENUM_FOO, "MY_ENUM_FOO", "foo" }, { MY_ENUM_BAR, "MY_ENUM_BAR", "bar" }, { 0, NULL, NULL } }; g_enum_complete_type_info (type, info, values); } ]| the type identifier of the type being completed the #GTypeInfo struct to be filled in An array of #GEnumValue structs for the possible enumeration values. The array is terminated by a struct with all members being 0. Returns the #GEnumValue for a value. the #GEnumValue for @value, or %NULL if @value is not a member of the enumeration a #GEnumClass the value to look up Looks up a #GEnumValue by name. the #GEnumValue with name @name, or %NULL if the enumeration doesn't have a member with that name a #GEnumClass the name to look up Looks up a #GEnumValue by nickname. the #GEnumValue with nickname @nick, or %NULL if the enumeration doesn't have a member with that nickname a #GEnumClass the nickname to look up Registers a new static enumeration type with the name @name. It is normally more convenient to let [glib-mkenums][glib-mkenums], generate a my_enum_get_type() function from a usual C enumeration definition than to write one yourself using g_enum_register_static(). The new type identifier. A nul-terminated string used as the name of the new type. An array of #GEnumValue structs for the possible enumeration values. The array is terminated by a struct with all members being 0. GObject keeps a reference to the data, so it cannot be stack-allocated. Pretty-prints @value in the form of the enum’s name. This is intended to be used for debugging purposes. The format of the output may change in the future. a newly-allocated text string the type identifier of a #GEnumClass type the value The GLib type system provides fundamental types for enumeration and flags types. (Flags types are like enumerations, but allow their values to be combined by bitwise or). A registered enumeration or flags type associates a name and a nickname with each allowed value, and the methods g_enum_get_value_by_name(), g_enum_get_value_by_nick(), g_flags_get_value_by_name() and g_flags_get_value_by_nick() can look up values by their name or nickname. When an enumeration or flags type is registered with the GLib type system, it can be used as value type for object properties, using g_param_spec_enum() or g_param_spec_flags(). GObject ships with a utility called [glib-mkenums][glib-mkenums], that can construct suitable type registration functions from C enumeration definitions. Example of how to get a string representation of an enum value: |[<!-- language="C" --> GEnumClass *enum_class; GEnumValue *enum_value; enum_class = g_type_class_ref (MAMAN_TYPE_MY_ENUM); enum_value = g_enum_get_value (enum_class, MAMAN_MY_ENUM_FOO); g_print ("Name: %s\n", enum_value->value_name); g_type_class_unref (enum_class); ]| This function is meant to be called from the complete_type_info() function of a #GTypePlugin implementation, see the example for g_enum_complete_type_info() above. the type identifier of the type being completed the #GTypeInfo struct to be filled in An array of #GFlagsValue structs for the possible enumeration values. The array is terminated by a struct with all members being 0. Returns the first #GFlagsValue which is set in @value. the first #GFlagsValue which is set in @value, or %NULL if none is set a #GFlagsClass the value Looks up a #GFlagsValue by name. the #GFlagsValue with name @name, or %NULL if there is no flag with that name a #GFlagsClass the name to look up Looks up a #GFlagsValue by nickname. the #GFlagsValue with nickname @nick, or %NULL if there is no flag with that nickname a #GFlagsClass the nickname to look up Registers a new static flags type with the name @name. It is normally more convenient to let [glib-mkenums][glib-mkenums] generate a my_flags_get_type() function from a usual C enumeration definition than to write one yourself using g_flags_register_static(). The new type identifier. A nul-terminated string used as the name of the new type. An array of #GFlagsValue structs for the possible flags values. The array is terminated by a struct with all members being 0. GObject keeps a reference to the data, so it cannot be stack-allocated. Pretty-prints @value in the form of the flag names separated by ` | ` and sorted. Any extra bits will be shown at the end as a hexadecimal number. This is intended to be used for debugging purposes. The format of the output may change in the future. a newly-allocated text string the type identifier of a #GFlagsClass type the value #GBoxed is a generic wrapper mechanism for arbitrary C structures. The only thing the type system needs to know about the structures is how to copy them (a #GBoxedCopyFunc) and how to free them (a #GBoxedFreeFunc) — beyond that they are treated as opaque chunks of memory. Boxed types are useful for simple value-holder structures like rectangles or points. They can also be used for wrapping structures defined in non-#GObject based libraries. They allow arbitrary structures to be handled in a uniform way, allowing uniform copying (or referencing) and freeing (or unreferencing) of them, and uniform representation of the type of the contained structure. In turn, this allows any type which can be boxed to be set as the data in a #GValue, which allows for polymorphic handling of a much wider range of data types, and hence usage of such types as #GObject property values. #GBoxed is designed so that reference counted types can be boxed. Use the type’s ‘ref’ function as the #GBoxedCopyFunc, and its ‘unref’ function as the #GBoxedFreeFunc. For example, for #GBytes, the #GBoxedCopyFunc is g_bytes_ref(), and the #GBoxedFreeFunc is g_bytes_unref(). The #GValue structure is basically a variable container that consists of a type identifier and a specific value of that type. The type identifier within a #GValue structure always determines the type of the associated value. To create an undefined #GValue structure, simply create a zero-filled #GValue structure. To initialize the #GValue, use the g_value_init() function. A #GValue cannot be used until it is initialized. The basic type operations (such as freeing and copying) are determined by the #GTypeValueTable associated with the type ID stored in the #GValue. Other #GValue operations (such as converting values between types) are provided by this interface. The code in the example program below demonstrates #GValue's features. |[<!-- language="C" --> #include <glib-object.h> static void int2string (const GValue *src_value, GValue *dest_value) { if (g_value_get_int (src_value) == 42) g_value_set_static_string (dest_value, "An important number"); else g_value_set_static_string (dest_value, "What's that?"); } int main (int argc, char *argv[]) { // GValues must be initialized GValue a = G_VALUE_INIT; GValue b = G_VALUE_INIT; const gchar *message; // The GValue starts empty g_assert (!G_VALUE_HOLDS_STRING (&a)); // Put a string in it g_value_init (&a, G_TYPE_STRING); g_assert (G_VALUE_HOLDS_STRING (&a)); g_value_set_static_string (&a, "Hello, world!"); g_printf ("%s\n", g_value_get_string (&a)); // Reset it to its pristine state g_value_unset (&a); // It can then be reused for another type g_value_init (&a, G_TYPE_INT); g_value_set_int (&a, 42); // Attempt to transform it into a GValue of type STRING g_value_init (&b, G_TYPE_STRING); // An INT is transformable to a STRING g_assert (g_value_type_transformable (G_TYPE_INT, G_TYPE_STRING)); g_value_transform (&a, &b); g_printf ("%s\n", g_value_get_string (&b)); // Attempt to transform it again using a custom transform function g_value_register_transform_func (G_TYPE_INT, G_TYPE_STRING, int2string); g_value_transform (&a, &b); g_printf ("%s\n", g_value_get_string (&b)); return 0; } ]| The GType API is the foundation of the GObject system. It provides the facilities for registering and managing all fundamental data types, user-defined object and interface types. For type creation and registration purposes, all types fall into one of two categories: static or dynamic. Static types are never loaded or unloaded at run-time as dynamic types may be. Static types are created with g_type_register_static() that gets type specific information passed in via a #GTypeInfo structure. Dynamic types are created with g_type_register_dynamic() which takes a #GTypePlugin structure instead. The remaining type information (the #GTypeInfo structure) is retrieved during runtime through #GTypePlugin and the g_type_plugin_*() API. These registration functions are usually called only once from a function whose only purpose is to return the type identifier for a specific class. Once the type (or class or interface) is registered, it may be instantiated, inherited, or implemented depending on exactly what sort of type it is. There is also a third registration function for registering fundamental types called g_type_register_fundamental() which requires both a #GTypeInfo structure and a #GTypeFundamentalInfo structure but it is seldom used since most fundamental types are predefined rather than user-defined. Type instance and class structs are limited to a total of 64 KiB, including all parent types. Similarly, type instances' private data (as created by G_ADD_PRIVATE()) are limited to a total of 64 KiB. If a type instance needs a large static buffer, allocate it separately (typically by using #GArray or #GPtrArray) and put a pointer to the buffer in the structure. As mentioned in the [GType conventions][gtype-conventions], type names must be at least three characters long. There is no upper length limit. The first character must be a letter (a–z or A–Z) or an underscore (‘_’). Subsequent characters can be letters, numbers or any of ‘-_+’. GObject is the fundamental type providing the common attributes and methods for all object types in GTK+, Pango and other libraries based on GObject. The GObject class provides methods for object construction and destruction, property access methods, and signal support. Signals are described in detail [here][gobject-Signals]. For a tutorial on implementing a new GObject class, see [How to define and implement a new GObject][howto-gobject]. For a list of naming conventions for GObjects and their methods, see the [GType conventions][gtype-conventions]. For the high-level concepts behind GObject, read [Instantiable classed types: Objects][gtype-instantiable-classed]. ## Floating references # {#floating-ref} **Note**: Floating references are a C convenience API and should not be used in modern GObject code. Language bindings in particular find the concept highly problematic, as floating references are not identifiable through annotations, and neither are deviations from the floating reference behavior, like types that inherit from #GInitiallyUnowned and still return a full reference from g_object_new(). GInitiallyUnowned is derived from GObject. The only difference between the two is that the initial reference of a GInitiallyUnowned is flagged as a "floating" reference. This means that it is not specifically claimed to be "owned" by any code portion. The main motivation for providing floating references is C convenience. In particular, it allows code to be written as: |[<!-- language="C" --> container = create_container (); container_add_child (container, create_child()); ]| If container_add_child() calls g_object_ref_sink() on the passed-in child, no reference of the newly created child is leaked. Without floating references, container_add_child() can only g_object_ref() the new child, so to implement this code without reference leaks, it would have to be written as: |[<!-- language="C" --> Child *child; container = create_container (); child = create_child (); container_add_child (container, child); g_object_unref (child); ]| The floating reference can be converted into an ordinary reference by calling g_object_ref_sink(). For already sunken objects (objects that don't have a floating reference anymore), g_object_ref_sink() is equivalent to g_object_ref() and returns a new reference. Since floating references are useful almost exclusively for C convenience, language bindings that provide automated reference and memory ownership maintenance (such as smart pointers or garbage collection) should not expose floating references in their API. The best practice for handling types that have initially floating references is to immediately sink those references after g_object_new() returns, by checking if the #GType inherits from #GInitiallyUnowned. For instance: |[<!-- language="C" --> GObject *res = g_object_new_with_properties (gtype, n_props, prop_names, prop_values); // or: if (g_type_is_a (gtype, G_TYPE_INITIALLY_UNOWNED)) if (G_IS_INITIALLY_UNOWNED (res)) g_object_ref_sink (res); return res; ]| Some object implementations may need to save an objects floating state across certain code portions (an example is #GtkMenu), to achieve this, the following sequence can be used: |[<!-- language="C" --> // save floating state gboolean was_floating = g_object_is_floating (object); g_object_ref_sink (object); // protected code portion ... // restore floating state if (was_floating) g_object_force_floating (object); else g_object_unref (object); // release previously acquired reference ]| Creates a new #GParamSpecBoolean instance specifying a %G_TYPE_BOOLEAN property. In many cases, it may be more appropriate to use an enum with g_param_spec_enum(), both to improve code clarity by using explicitly named values, and to allow for more values to be added in future without breaking API. See g_param_spec_internal() for details on property names. a newly created parameter specification canonical name of the property specified nick name for the property specified description of the property specified default value for the property specified flags for the property specified Creates a new #GParamSpecBoxed instance specifying a %G_TYPE_BOXED derived property. See g_param_spec_internal() for details on property names. a newly created parameter specification canonical name of the property specified nick name for the property specified description of the property specified %G_TYPE_BOXED derived type of this property flags for the property specified Creates a new #GParamSpecChar instance specifying a %G_TYPE_CHAR property. a newly created parameter specification canonical name of the property specified nick name for the property specified description of the property specified minimum value for the property specified maximum value for the property specified default value for the property specified flags for the property specified Creates a new #GParamSpecDouble instance specifying a %G_TYPE_DOUBLE property. See g_param_spec_internal() for details on property names. a newly created parameter specification canonical name of the property specified nick name for the property specified description of the property specified minimum value for the property specified maximum value for the property specified default value for the property specified flags for the property specified Creates a new #GParamSpecEnum instance specifying a %G_TYPE_ENUM property. See g_param_spec_internal() for details on property names. a newly created parameter specification canonical name of the property specified nick name for the property specified description of the property specified a #GType derived from %G_TYPE_ENUM default value for the property specified flags for the property specified Creates a new #GParamSpecFlags instance specifying a %G_TYPE_FLAGS property. See g_param_spec_internal() for details on property names. a newly created parameter specification canonical name of the property specified nick name for the property specified description of the property specified a #GType derived from %G_TYPE_FLAGS default value for the property specified flags for the property specified Creates a new #GParamSpecFloat instance specifying a %G_TYPE_FLOAT property. See g_param_spec_internal() for details on property names. a newly created parameter specification canonical name of the property specified nick name for the property specified description of the property specified minimum value for the property specified maximum value for the property specified default value for the property specified flags for the property specified Creates a new #GParamSpecGType instance specifying a %G_TYPE_GTYPE property. See g_param_spec_internal() for details on property names. a newly created parameter specification canonical name of the property specified nick name for the property specified description of the property specified a #GType whose subtypes are allowed as values of the property (use %G_TYPE_NONE for any type) flags for the property specified Creates a new #GParamSpecInt instance specifying a %G_TYPE_INT property. See g_param_spec_internal() for details on property names. a newly created parameter specification canonical name of the property specified nick name for the property specified description of the property specified minimum value for the property specified maximum value for the property specified default value for the property specified flags for the property specified Creates a new #GParamSpecInt64 instance specifying a %G_TYPE_INT64 property. See g_param_spec_internal() for details on property names. a newly created parameter specification canonical name of the property specified nick name for the property specified description of the property specified minimum value for the property specified maximum value for the property specified default value for the property specified flags for the property specified Creates a new #GParamSpecLong instance specifying a %G_TYPE_LONG property. See g_param_spec_internal() for details on property names. a newly created parameter specification canonical name of the property specified nick name for the property specified description of the property specified minimum value for the property specified maximum value for the property specified default value for the property specified flags for the property specified Creates a new #GParamSpecBoxed instance specifying a %G_TYPE_OBJECT derived property. See g_param_spec_internal() for details on property names. a newly created parameter specification canonical name of the property specified nick name for the property specified description of the property specified %G_TYPE_OBJECT derived type of this property flags for the property specified Creates a new property of type #GParamSpecOverride. This is used to direct operations to another paramspec, and will not be directly useful unless you are implementing a new base type similar to GObject. the newly created #GParamSpec the name of the property. The property that is being overridden Creates a new #GParamSpecParam instance specifying a %G_TYPE_PARAM property. See g_param_spec_internal() for details on property names. a newly created parameter specification canonical name of the property specified nick name for the property specified description of the property specified a #GType derived from %G_TYPE_PARAM flags for the property specified Creates a new #GParamSpecPointer instance specifying a pointer property. Where possible, it is better to use g_param_spec_object() or g_param_spec_boxed() to expose memory management information. See g_param_spec_internal() for details on property names. a newly created parameter specification canonical name of the property specified nick name for the property specified description of the property specified flags for the property specified Creates a new #GParamSpecPool. If @type_prefixing is %TRUE, lookups in the newly created pool will allow to specify the owner as a colon-separated prefix of the property name, like "GtkContainer:border-width". This feature is deprecated, so you should always set @type_prefixing to %FALSE. a newly allocated #GParamSpecPool. Whether the pool will support type-prefixed property names. Creates a new #GParamSpecString instance. See g_param_spec_internal() for details on property names. a newly created parameter specification canonical name of the property specified nick name for the property specified description of the property specified default value for the property specified flags for the property specified Creates a new #GParamSpecUChar instance specifying a %G_TYPE_UCHAR property. a newly created parameter specification canonical name of the property specified nick name for the property specified description of the property specified minimum value for the property specified maximum value for the property specified default value for the property specified flags for the property specified Creates a new #GParamSpecUInt instance specifying a %G_TYPE_UINT property. See g_param_spec_internal() for details on property names. a newly created parameter specification canonical name of the property specified nick name for the property specified description of the property specified minimum value for the property specified maximum value for the property specified default value for the property specified flags for the property specified Creates a new #GParamSpecUInt64 instance specifying a %G_TYPE_UINT64 property. See g_param_spec_internal() for details on property names. a newly created parameter specification canonical name of the property specified nick name for the property specified description of the property specified minimum value for the property specified maximum value for the property specified default value for the property specified flags for the property specified Creates a new #GParamSpecULong instance specifying a %G_TYPE_ULONG property. See g_param_spec_internal() for details on property names. a newly created parameter specification canonical name of the property specified nick name for the property specified description of the property specified minimum value for the property specified maximum value for the property specified default value for the property specified flags for the property specified Creates a new #GParamSpecUnichar instance specifying a %G_TYPE_UINT property. #GValue structures for this property can be accessed with g_value_set_uint() and g_value_get_uint(). See g_param_spec_internal() for details on property names. a newly created parameter specification canonical name of the property specified nick name for the property specified description of the property specified default value for the property specified flags for the property specified Creates a new #GParamSpecValueArray instance specifying a %G_TYPE_VALUE_ARRAY property. %G_TYPE_VALUE_ARRAY is a %G_TYPE_BOXED type, as such, #GValue structures for this property can be accessed with g_value_set_boxed() and g_value_get_boxed(). See g_param_spec_internal() for details on property names. a newly created parameter specification canonical name of the property specified nick name for the property specified description of the property specified a #GParamSpec describing the elements contained in arrays of this property, may be %NULL flags for the property specified Creates a new #GParamSpecVariant instance specifying a #GVariant property. If @default_value is floating, it is consumed. See g_param_spec_internal() for details on property names. the newly created #GParamSpec canonical name of the property specified nick name for the property specified description of the property specified a #GVariantType a #GVariant of type @type to use as the default value, or %NULL flags for the property specified Registers @name as the name of a new static type derived from #G_TYPE_PARAM. The type system uses the information contained in the #GParamSpecTypeInfo structure pointed to by @info to manage the #GParamSpec type and its instances. The new type identifier. 0-terminated string used as the name of the new #GParamSpec type. The #GParamSpecTypeInfo for this #GParamSpec type. Transforms @src_value into @dest_value if possible, and then validates @dest_value, in order for it to conform to @pspec. If @strict_validation is %TRUE this function will only succeed if the transformed @dest_value complied to @pspec without modifications. See also g_value_type_transformable(), g_value_transform() and g_param_value_validate(). %TRUE if transformation and validation were successful, %FALSE otherwise and @dest_value is left untouched. a valid #GParamSpec source #GValue destination #GValue of correct type for @pspec %TRUE requires @dest_value to conform to @pspec without modifications Checks whether @value contains the default value as specified in @pspec. whether @value contains the canonical default for this @pspec a valid #GParamSpec a #GValue of correct type for @pspec Sets @value to its default value as specified in @pspec. a valid #GParamSpec a #GValue of correct type for @pspec; since 2.64, you can also pass an empty #GValue, initialized with %G_VALUE_INIT #GValue provides an abstract container structure which can be copied, transformed and compared while holding a value of any (derived) type, which is registered as a #GType with a #GTypeValueTable in its #GTypeInfo structure. Parameter specifications for most value types can be created as #GParamSpec derived instances, to implement e.g. #GObject properties which operate on #GValue containers. Parameter names need to start with a letter (a-z or A-Z). Subsequent characters can be letters, numbers or a '-'. All other characters are replaced by a '-' during construction. Ensures that the contents of @value comply with the specifications set out by @pspec. For example, a #GParamSpecInt might require that integers stored in @value may not be smaller than -42 and not be greater than +42. If @value contains an integer outside of this range, it is modified accordingly, so the resulting value will fit into the range -42 .. +42. whether modifying @value was necessary to ensure validity a valid #GParamSpec a #GValue of correct type for @pspec Compares @value1 with @value2 according to @pspec, and return -1, 0 or +1, if @value1 is found to be less than, equal to or greater than @value2, respectively. -1, 0 or +1, for a less than, equal to or greater than result a valid #GParamSpec a #GValue of correct type for @pspec a #GValue of correct type for @pspec Creates a new %G_TYPE_POINTER derived type id for a new pointer type with name @name. a new %G_TYPE_POINTER derived type id for @name. the name of the new pointer type. Updates a #GObject pointer to refer to @new_object. It increments the reference count of @new_object (if non-%NULL), decrements the reference count of the current value of @object_ptr (if non-%NULL), and assigns @new_object to @object_ptr. The assignment is not atomic. @object_ptr must not be %NULL. A macro is also included that allows this function to be used without pointer casts. The function itself is static inline, so its address may vary between compilation units. One convenient usage of this function is in implementing property setters: |[ void foo_set_bar (Foo *foo, Bar *new_bar) { g_return_if_fail (IS_FOO (foo)); g_return_if_fail (new_bar == NULL || IS_BAR (new_bar)); if (g_set_object (&foo->bar, new_bar)) g_object_notify (foo, "bar"); } ]| a pointer to a #GObject reference a pointer to the new #GObject to assign to it, or %NULL to clear the pointer Updates a pointer to weakly refer to @new_object. It assigns @new_object to @weak_pointer_location and ensures that @weak_pointer_location will automatically be set to %NULL if @new_object gets destroyed. The assignment is not atomic. The weak reference is not thread-safe, see g_object_add_weak_pointer() for details. @weak_pointer_location must not be %NULL. A macro is also included that allows this function to be used without pointer casts. The function itself is static inline, so its address may vary between compilation units. One convenient usage of this function is in implementing property setters: |[ void foo_set_bar (Foo *foo, Bar *new_bar) { g_return_if_fail (IS_FOO (foo)); g_return_if_fail (new_bar == NULL || IS_BAR (new_bar)); if (g_set_weak_pointer (&foo->bar, new_bar)) g_object_notify (foo, "bar"); } ]| the memory address of a pointer a pointer to the new #GObject to assign to it, or %NULL to clear the pointer A predefined #GSignalAccumulator for signals intended to be used as a hook for application code to provide a particular value. Usually only one such value is desired and multiple handlers for the same signal don't make much sense (except for the case of the default handler defined in the class structure, in which case you will usually want the signal connection to override the class handler). This accumulator will use the return value from the first signal handler that is run as the return value for the signal and not run any further handlers (ie: the first handler "wins"). standard #GSignalAccumulator result standard #GSignalAccumulator parameter standard #GSignalAccumulator parameter standard #GSignalAccumulator parameter standard #GSignalAccumulator parameter A predefined #GSignalAccumulator for signals that return a boolean values. The behavior that this accumulator gives is that a return of %TRUE stops the signal emission: no further callbacks will be invoked, while a return of %FALSE allows the emission to continue. The idea here is that a %TRUE return indicates that the callback handled the signal, and no further handling is needed. standard #GSignalAccumulator result standard #GSignalAccumulator parameter standard #GSignalAccumulator parameter standard #GSignalAccumulator parameter standard #GSignalAccumulator parameter Adds an emission hook for a signal, which will get called for any emission of that signal, independent of the instance. This is possible only for signals which don't have #G_SIGNAL_NO_HOOKS flag set. the hook id, for later use with g_signal_remove_emission_hook(). the signal identifier, as returned by g_signal_lookup(). the detail on which to call the hook. a #GSignalEmissionHook function. user data for @hook_func. a #GDestroyNotify for @hook_data. Calls the original class closure of a signal. This function should only be called from an overridden class closure; see g_signal_override_class_closure() and g_signal_override_class_handler(). the argument list of the signal emission. The first element in the array is a #GValue for the instance the signal is being emitted on. The rest are any arguments to be passed to the signal. Location for the return value. Calls the original class closure of a signal. This function should only be called from an overridden class closure; see g_signal_override_class_closure() and g_signal_override_class_handler(). the instance the signal is being emitted on. parameters to be passed to the parent class closure, followed by a location for the return value. If the return type of the signal is #G_TYPE_NONE, the return value location can be omitted. Connects a #GCallback function to a signal for a particular object. The handler will be called before the default handler of the signal. See [memory management of signal handlers][signal-memory-management] for details on how to handle the return value and memory management of @data. the instance to connect to. a string of the form "signal-name::detail". the #GCallback to connect. data to pass to @c_handler calls. Connects a #GCallback function to a signal for a particular object. The handler will be called after the default handler of the signal. the instance to connect to. a string of the form "signal-name::detail". the #GCallback to connect. data to pass to @c_handler calls. Connects a closure to a signal for a particular object. the handler ID (always greater than 0 for successful connections) the instance to connect to. a string of the form "signal-name::detail". the closure to connect. whether the handler should be called before or after the default handler of the signal. Connects a closure to a signal for a particular object. the handler ID (always greater than 0 for successful connections) the instance to connect to. the id of the signal. the detail. the closure to connect. whether the handler should be called before or after the default handler of the signal. Connects a #GCallback function to a signal for a particular object. Similar to g_signal_connect(), but allows to provide a #GClosureNotify for the data which will be called when the signal handler is disconnected and no longer used. Specify @connect_flags if you need `..._after()` or `..._swapped()` variants of this function. the handler ID (always greater than 0 for successful connections) the instance to connect to. a string of the form "signal-name::detail". the #GCallback to connect. data to pass to @c_handler calls. a #GClosureNotify for @data. a combination of #GConnectFlags. This is similar to g_signal_connect_data(), but uses a closure which ensures that the @gobject stays alive during the call to @c_handler by temporarily adding a reference count to @gobject. When the @gobject is destroyed the signal handler will be automatically disconnected. Note that this is not currently threadsafe (ie: emitting a signal while @gobject is being destroyed in another thread is not safe). the handler id. the instance to connect to. a string of the form "signal-name::detail". the #GCallback to connect. the object to pass as data to @c_handler. a combination of #GConnectFlags. Connects a #GCallback function to a signal for a particular object. The instance on which the signal is emitted and @data will be swapped when calling the handler. This is useful when calling pre-existing functions to operate purely on the @data, rather than the @instance: swapping the parameters avoids the need to write a wrapper function. For example, this allows the shorter code: |[<!-- language="C" --> g_signal_connect_swapped (button, "clicked", (GCallback) gtk_widget_hide, other_widget); ]| Rather than the cumbersome: |[<!-- language="C" --> static void button_clicked_cb (GtkButton *button, GtkWidget *other_widget) { gtk_widget_hide (other_widget); } ... g_signal_connect (button, "clicked", (GCallback) button_clicked_cb, other_widget); ]| the instance to connect to. a string of the form "signal-name::detail". the #GCallback to connect. data to pass to @c_handler calls. Emits a signal. Note that g_signal_emit() resets the return value to the default if no handlers are connected, in contrast to g_signal_emitv(). the instance the signal is being emitted on. the signal id the detail parameters to be passed to the signal, followed by a location for the return value. If the return type of the signal is #G_TYPE_NONE, the return value location can be omitted. Emits a signal. Note that g_signal_emit_by_name() resets the return value to the default if no handlers are connected, in contrast to g_signal_emitv(). the instance the signal is being emitted on. a string of the form "signal-name::detail". parameters to be passed to the signal, followed by a location for the return value. If the return type of the signal is #G_TYPE_NONE, the return value location can be omitted. Emits a signal. Note that g_signal_emit_valist() resets the return value to the default if no handlers are connected, in contrast to g_signal_emitv(). the instance the signal is being emitted on. the signal id the detail a list of parameters to be passed to the signal, followed by a location for the return value. If the return type of the signal is #G_TYPE_NONE, the return value location can be omitted. Emits a signal. Note that g_signal_emitv() doesn't change @return_value if no handlers are connected, in contrast to g_signal_emit() and g_signal_emit_valist(). argument list for the signal emission. The first element in the array is a #GValue for the instance the signal is being emitted on. The rest are any arguments to be passed to the signal. the signal id the detail Location to store the return value of the signal emission. This must be provided if the specified signal returns a value, but may be ignored otherwise. Returns the invocation hint of the innermost signal emission of instance. the invocation hint of the innermost signal emission. the instance to query Blocks a handler of an instance so it will not be called during any signal emissions unless it is unblocked again. Thus "blocking" a signal handler means to temporarily deactivate it, a signal handler has to be unblocked exactly the same amount of times it has been blocked before to become active again. The @handler_id has to be a valid signal handler id, connected to a signal of @instance. The instance to block the signal handler of. Handler id of the handler to be blocked. Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to. The @handler_id becomes invalid and may be reused. The @handler_id has to be a valid signal handler id, connected to a signal of @instance. The instance to remove the signal handler from. Handler id of the handler to be disconnected. Finds the first signal handler that matches certain selection criteria. The criteria mask is passed as an OR-ed combination of #GSignalMatchType flags, and the criteria values are passed as arguments. The match @mask has to be non-0 for successful matches. If no handler was found, 0 is returned. A valid non-0 signal handler id for a successful match. The instance owning the signal handler to be found. Mask indicating which of @signal_id, @detail, @closure, @func and/or @data the handler has to match. Signal the handler has to be connected to. Signal detail the handler has to be connected to. The closure the handler will invoke. The C closure callback of the handler (useless for non-C closures). The closure data of the handler's closure. Returns whether @handler_id is the ID of a handler connected to @instance. whether @handler_id identifies a handler connected to @instance. The instance where a signal handler is sought. the handler ID. Undoes the effect of a previous g_signal_handler_block() call. A blocked handler is skipped during signal emissions and will not be invoked, unblocking it (for exactly the amount of times it has been blocked before) reverts its "blocked" state, so the handler will be recognized by the signal system and is called upon future or currently ongoing signal emissions (since the order in which handlers are called during signal emissions is deterministic, whether the unblocked handler in question is called as part of a currently ongoing emission depends on how far that emission has proceeded yet). The @handler_id has to be a valid id of a signal handler that is connected to a signal of @instance and is currently blocked. The instance to unblock the signal handler of. Handler id of the handler to be unblocked. Blocks all handlers on an instance that match @func and @data. The instance to block handlers from. The C closure callback of the handlers (useless for non-C closures). The closure data of the handlers' closures. Blocks all handlers on an instance that match a certain selection criteria. The criteria mask is passed as an OR-ed combination of #GSignalMatchType flags, and the criteria values are passed as arguments. Passing at least one of the %G_SIGNAL_MATCH_CLOSURE, %G_SIGNAL_MATCH_FUNC or %G_SIGNAL_MATCH_DATA match flags is required for successful matches. If no handlers were found, 0 is returned, the number of blocked handlers otherwise. The number of handlers that matched. The instance to block handlers from. Mask indicating which of @signal_id, @detail, @closure, @func and/or @data the handlers have to match. Signal the handlers have to be connected to. Signal detail the handlers have to be connected to. The closure the handlers will invoke. The C closure callback of the handlers (useless for non-C closures). The closure data of the handlers' closures. Destroy all signal handlers of a type instance. This function is an implementation detail of the #GObject dispose implementation, and should not be used outside of the type system. The instance whose signal handlers are destroyed Disconnects all handlers on an instance that match @data. The instance to remove handlers from the closure data of the handlers' closures Disconnects all handlers on an instance that match @func and @data. The instance to remove handlers from. The C closure callback of the handlers (useless for non-C closures). The closure data of the handlers' closures. Disconnects all handlers on an instance that match a certain selection criteria. The criteria mask is passed as an OR-ed combination of #GSignalMatchType flags, and the criteria values are passed as arguments. Passing at least one of the %G_SIGNAL_MATCH_CLOSURE, %G_SIGNAL_MATCH_FUNC or %G_SIGNAL_MATCH_DATA match flags is required for successful matches. If no handlers were found, 0 is returned, the number of disconnected handlers otherwise. The number of handlers that matched. The instance to remove handlers from. Mask indicating which of @signal_id, @detail, @closure, @func and/or @data the handlers have to match. Signal the handlers have to be connected to. Signal detail the handlers have to be connected to. The closure the handlers will invoke. The C closure callback of the handlers (useless for non-C closures). The closure data of the handlers' closures. Unblocks all handlers on an instance that match @func and @data. The instance to unblock handlers from. The C closure callback of the handlers (useless for non-C closures). The closure data of the handlers' closures. Unblocks all handlers on an instance that match a certain selection criteria. The criteria mask is passed as an OR-ed combination of #GSignalMatchType flags, and the criteria values are passed as arguments. Passing at least one of the %G_SIGNAL_MATCH_CLOSURE, %G_SIGNAL_MATCH_FUNC or %G_SIGNAL_MATCH_DATA match flags is required for successful matches. If no handlers were found, 0 is returned, the number of unblocked handlers otherwise. The match criteria should not apply to any handlers that are not currently blocked. The number of handlers that matched. The instance to unblock handlers from. Mask indicating which of @signal_id, @detail, @closure, @func and/or @data the handlers have to match. Signal the handlers have to be connected to. Signal detail the handlers have to be connected to. The closure the handlers will invoke. The C closure callback of the handlers (useless for non-C closures). The closure data of the handlers' closures. Returns whether there are any handlers connected to @instance for the given signal id and detail. If @detail is 0 then it will only match handlers that were connected without detail. If @detail is non-zero then it will match handlers connected both without detail and with the given detail. This is consistent with how a signal emitted with @detail would be delivered to those handlers. Since 2.46 this also checks for a non-default class closure being installed, as this is basically always what you want. One example of when you might use this is when the arguments to the signal are difficult to compute. A class implementor may opt to not emit the signal if no one is attached anyway, thus saving the cost of building the arguments. %TRUE if a handler is connected to the signal, %FALSE otherwise. the object whose signal handlers are sought. the signal id. the detail. whether blocked handlers should count as match. Validate a signal name. This can be useful for dynamically-generated signals which need to be validated at run-time before actually trying to create them. See [canonical parameter names][canonical-parameter-names] for details of the rules for valid names. The rules for signal names are the same as those for property names. %TRUE if @name is a valid signal name, %FALSE otherwise. the canonical name of the signal Lists the signals by id that a certain instance or interface type created. Further information about the signals can be acquired through g_signal_query(). Newly allocated array of signal IDs. Instance or interface type. Location to store the number of signal ids for @itype. Given the name of the signal and the type of object it connects to, gets the signal's identifying integer. Emitting the signal by number is somewhat faster than using the name each time. Also tries the ancestors of the given type. The type class passed as @itype must already have been instantiated (for example, using g_type_class_ref()) for this function to work, as signals are always installed during class initialization. See g_signal_new() for details on allowed signal names. the signal's identifying number, or 0 if no signal was found. the signal's name. the type that the signal operates on. Given the signal's identifier, finds its name. Two different signals may have the same name, if they have differing types. the signal name, or %NULL if the signal number was invalid. the signal's identifying number. Creates a new signal. (This is usually done in the class initializer.) A signal name consists of segments consisting of ASCII letters and digits, separated by either the `-` or `_` character. The first character of a signal name must be a letter. Names which violate these rules lead to undefined behaviour. These are the same rules as for property naming (see g_param_spec_internal()). When registering a signal and looking up a signal, either separator can be used, but they cannot be mixed. Using `-` is considerably more efficient. Using `_` is discouraged. If 0 is used for @class_offset subclasses cannot override the class handler in their class_init method by doing super_class->signal_handler = my_signal_handler. Instead they will have to use g_signal_override_class_handler(). If @c_marshaller is %NULL, g_cclosure_marshal_generic() will be used as the marshaller for this signal. In some simple cases, g_signal_new() will use a more optimized c_marshaller and va_marshaller for the signal instead of g_cclosure_marshal_generic(). If @c_marshaller is non-%NULL, you need to also specify a va_marshaller using g_signal_set_va_marshaller() or the generic va_marshaller will be used. the signal id the name for the signal the type this signal pertains to. It will also pertain to types which are derived from this type. a combination of #GSignalFlags specifying detail of when the default handler is to be invoked. You should at least specify %G_SIGNAL_RUN_FIRST or %G_SIGNAL_RUN_LAST. The offset of the function pointer in the class structure for this type. Used to invoke a class method generically. Pass 0 to not associate a class method slot with this signal. the accumulator for this signal; may be %NULL. user data for the @accumulator. the function to translate arrays of parameter values to signal emissions into C language callback invocations or %NULL. the type of return value, or #G_TYPE_NONE for a signal without a return value. the number of parameter types to follow. a list of types, one for each parameter. Creates a new signal. (This is usually done in the class initializer.) This is a variant of g_signal_new() that takes a C callback instead of a class offset for the signal's class handler. This function doesn't need a function pointer exposed in the class structure of an object definition, instead the function pointer is passed directly and can be overridden by derived classes with g_signal_override_class_closure() or g_signal_override_class_handler()and chained to with g_signal_chain_from_overridden() or g_signal_chain_from_overridden_handler(). See g_signal_new() for information about signal names. If c_marshaller is %NULL, g_cclosure_marshal_generic() will be used as the marshaller for this signal. the signal id the name for the signal the type this signal pertains to. It will also pertain to types which are derived from this type. a combination of #GSignalFlags specifying detail of when the default handler is to be invoked. You should at least specify %G_SIGNAL_RUN_FIRST or %G_SIGNAL_RUN_LAST. a #GCallback which acts as class implementation of this signal. Used to invoke a class method generically. Pass %NULL to not associate a class method with this signal. the accumulator for this signal; may be %NULL. user data for the @accumulator. the function to translate arrays of parameter values to signal emissions into C language callback invocations or %NULL. the type of return value, or #G_TYPE_NONE for a signal without a return value. the number of parameter types to follow. a list of types, one for each parameter. Creates a new signal. (This is usually done in the class initializer.) See g_signal_new() for details on allowed signal names. If c_marshaller is %NULL, g_cclosure_marshal_generic() will be used as the marshaller for this signal. the signal id the name for the signal the type this signal pertains to. It will also pertain to types which are derived from this type. a combination of #GSignalFlags specifying detail of when the default handler is to be invoked. You should at least specify %G_SIGNAL_RUN_FIRST or %G_SIGNAL_RUN_LAST. The closure to invoke on signal emission; may be %NULL. the accumulator for this signal; may be %NULL. user data for the @accumulator. the function to translate arrays of parameter values to signal emissions into C language callback invocations or %NULL. the type of return value, or #G_TYPE_NONE for a signal without a return value. the number of parameter types in @args. va_list of #GType, one for each parameter. Creates a new signal. (This is usually done in the class initializer.) See g_signal_new() for details on allowed signal names. If c_marshaller is %NULL, g_cclosure_marshal_generic() will be used as the marshaller for this signal. the signal id the name for the signal the type this signal pertains to. It will also pertain to types which are derived from this type a combination of #GSignalFlags specifying detail of when the default handler is to be invoked. You should at least specify %G_SIGNAL_RUN_FIRST or %G_SIGNAL_RUN_LAST The closure to invoke on signal emission; may be %NULL the accumulator for this signal; may be %NULL user data for the @accumulator the function to translate arrays of parameter values to signal emissions into C language callback invocations or %NULL the type of return value, or #G_TYPE_NONE for a signal without a return value the length of @param_types an array of types, one for each parameter Overrides the class closure (i.e. the default handler) for the given signal for emissions on instances of @instance_type. @instance_type must be derived from the type to which the signal belongs. See g_signal_chain_from_overridden() and g_signal_chain_from_overridden_handler() for how to chain up to the parent class closure from inside the overridden one. the signal id the instance type on which to override the class closure for the signal. the closure. Overrides the class closure (i.e. the default handler) for the given signal for emissions on instances of @instance_type with callback @class_handler. @instance_type must be derived from the type to which the signal belongs. See g_signal_chain_from_overridden() and g_signal_chain_from_overridden_handler() for how to chain up to the parent class closure from inside the overridden one. the name for the signal the instance type on which to override the class handler for the signal. the handler. Internal function to parse a signal name into its @signal_id and @detail quark. Whether the signal name could successfully be parsed and @signal_id_p and @detail_p contain valid return values. a string of the form "signal-name::detail". The interface/instance type that introduced "signal-name". Location to store the signal id. Location to store the detail quark. %TRUE forces creation of a #GQuark for the detail. Queries the signal system for in-depth information about a specific signal. This function will fill in a user-provided structure to hold signal-specific information. If an invalid signal id is passed in, the @signal_id member of the #GSignalQuery is 0. All members filled into the #GSignalQuery structure should be considered constant and have to be left untouched. The signal id of the signal to query information for. A user provided structure that is filled in with constant values upon success. Deletes an emission hook. the id of the signal the id of the emission hook, as returned by g_signal_add_emission_hook() Change the #GSignalCVaMarshaller used for a given signal. This is a specialised form of the marshaller that can often be used for the common case of a single connected signal handler and avoids the overhead of #GValue. Its use is optional. the signal id the instance type on which to set the marshaller. the marshaller to set. Stops a signal's current emission. This will prevent the default method from running, if the signal was %G_SIGNAL_RUN_LAST and you connected normally (i.e. without the "after" flag). Prints a warning if used on a signal which isn't being emitted. the object whose signal handlers you wish to stop. the signal identifier, as returned by g_signal_lookup(). the detail which the signal was emitted with. Stops a signal's current emission. This is just like g_signal_stop_emission() except it will look up the signal id for you. the object whose signal handlers you wish to stop. a string of the form "signal-name::detail". Creates a new closure which invokes the function found at the offset @struct_offset in the class structure of the interface or classed type identified by @itype. a floating reference to a new #GCClosure the #GType identifier of an interface or classed type the offset of the member function of @itype's class structure which is to be invoked by the new closure The basic concept of the signal system is that of the emission of a signal. Signals are introduced per-type and are identified through strings. Signals introduced for a parent type are available in derived types as well, so basically they are a per-type facility that is inherited. A signal emission mainly involves invocation of a certain set of callbacks in precisely defined manner. There are two main categories of such callbacks, per-object ones and user provided ones. (Although signals can deal with any kind of instantiatable type, I'm referring to those types as "object types" in the following, simply because that is the context most users will encounter signals in.) The per-object callbacks are most often referred to as "object method handler" or "default (signal) handler", while user provided callbacks are usually just called "signal handler". The object method handler is provided at signal creation time (this most frequently happens at the end of an object class' creation), while user provided handlers are frequently connected and disconnected to/from a certain signal on certain object instances. A signal emission consists of five stages, unless prematurely stopped: 1. Invocation of the object method handler for %G_SIGNAL_RUN_FIRST signals 2. Invocation of normal user-provided signal handlers (where the @after flag is not set) 3. Invocation of the object method handler for %G_SIGNAL_RUN_LAST signals 4. Invocation of user provided signal handlers (where the @after flag is set) 5. Invocation of the object method handler for %G_SIGNAL_RUN_CLEANUP signals The user-provided signal handlers are called in the order they were connected in. All handlers may prematurely stop a signal emission, and any number of handlers may be connected, disconnected, blocked or unblocked during a signal emission. There are certain criteria for skipping user handlers in stages 2 and 4 of a signal emission. First, user handlers may be blocked. Blocked handlers are omitted during callback invocation, to return from the blocked state, a handler has to get unblocked exactly the same amount of times it has been blocked before. Second, upon emission of a %G_SIGNAL_DETAILED signal, an additional @detail argument passed in to g_signal_emit() has to match the detail argument of the signal handler currently subject to invocation. Specification of no detail argument for signal handlers (omission of the detail part of the signal specification upon connection) serves as a wildcard and matches any detail argument passed in to emission. While the @detail argument is typically used to pass an object property name (as with #GObject::notify), no specific format is mandated for the detail string, other than that it must be non-empty. ## Memory management of signal handlers # {#signal-memory-management} If you are connecting handlers to signals and using a #GObject instance as your signal handler user data, you should remember to pair calls to g_signal_connect() with calls to g_signal_handler_disconnect() or g_signal_handlers_disconnect_by_func(). While signal handlers are automatically disconnected when the object emitting the signal is finalised, they are not automatically disconnected when the signal handler user data is destroyed. If this user data is a #GObject instance, using it from a signal handler after it has been finalised is an error. There are two strategies for managing such user data. The first is to disconnect the signal handler (using g_signal_handler_disconnect() or g_signal_handlers_disconnect_by_func()) when the user data (object) is finalised; this has to be implemented manually. For non-threaded programs, g_signal_connect_object() can be used to implement this automatically. Currently, however, it is unsafe to use in threaded programs. The second is to hold a strong reference on the user data until after the signal is disconnected for other reasons. This can be implemented automatically using g_signal_connect_data(). The first approach is recommended, as the second approach can result in effective memory leaks of the user data if the signal handler is never disconnected for some reason. Set the callback for a source as a #GClosure. If the source is not one of the standard GLib types, the @closure_callback and @closure_marshal fields of the #GSourceFuncs structure must have been filled in with pointers to appropriate functions. the source a #GClosure Sets a dummy callback for @source. The callback will do nothing, and if the source expects a #gboolean return value, it will return %TRUE. (If the source expects any other type of return value, it will return a 0/%NULL value; whatever g_value_init() initializes a #GValue to for that type.) If the source is not one of the standard GLib types, the @closure_callback and @closure_marshal fields of the #GSourceFuncs structure must have been filled in with pointers to appropriate functions. the source Return a newly allocated string, which describes the contents of a #GValue. The main purpose of this function is to describe #GValue contents for debugging output, the way in which the contents are described may change between different GLib versions. Newly allocated string. #GValue which contents are to be described. Adds a #GTypeClassCacheFunc to be called before the reference count of a class goes from one to zero. This can be used to prevent premature class destruction. All installed #GTypeClassCacheFunc functions will be chained until one of them returns %TRUE. The functions have to check the class id passed in to figure whether they actually want to cache the class of this type, since all classes are routed through the same #GTypeClassCacheFunc chain. data to be passed to @cache_func a #GTypeClassCacheFunc Registers a private class structure for a classed type; when the class is allocated, the private structures for the class and all of its parent types are allocated sequentially in the same memory block as the public structures, and are zero-filled. This function should be called in the type's get_type() function after the type is registered. The private structure can be retrieved using the G_TYPE_CLASS_GET_PRIVATE() macro. GType of a classed type size of private structure Adds a function to be called after an interface vtable is initialized for any class (i.e. after the @interface_init member of #GInterfaceInfo has been called). This function is useful when you want to check an invariant that depends on the interfaces of a class. For instance, the implementation of #GObject uses this facility to check that an object implements all of the properties that are defined on its interfaces. data to pass to @check_func function to be called after each interface is initialized Adds @interface_type to the dynamic @instantiable_type. The information contained in the #GTypePlugin structure pointed to by @plugin is used to manage the relationship. #GType value of an instantiable type #GType value of an interface type #GTypePlugin structure to retrieve the #GInterfaceInfo from Adds @interface_type to the static @instantiable_type. The information contained in the #GInterfaceInfo structure pointed to by @info is used to manage the relationship. #GType value of an instantiable type #GType value of an interface type #GInterfaceInfo structure for this (@instance_type, @interface_type) combination Private helper function to aid implementation of the G_TYPE_CHECK_INSTANCE() macro. %TRUE if @instance is valid, %FALSE otherwise a valid #GTypeInstance structure Return a newly allocated and 0-terminated array of type IDs, listing the child types of @type. Newly allocated and 0-terminated array of child types, free with g_free() the parent type location to store the length of the returned array, or %NULL This function is essentially the same as g_type_class_ref(), except that the classes reference count isn't incremented. As a consequence, this function may return %NULL if the class of the type passed in does not currently exist (hasn't been referenced before). the #GTypeClass structure for the given type ID or %NULL if the class does not currently exist type ID of a classed type A more efficient version of g_type_class_peek() which works only for static types. the #GTypeClass structure for the given type ID or %NULL if the class does not currently exist or is dynamically loaded type ID of a classed type Increments the reference count of the class structure belonging to @type. This function will demand-create the class if it doesn't exist already. the #GTypeClass structure for the given type ID type ID of a classed type Creates and initializes an instance of @type if @type is valid and can be instantiated. The type system only performs basic allocation and structure setups for instances: actual instance creation should happen through functions supplied by the type's fundamental type implementation. So use of g_type_create_instance() is reserved for implementers of fundamental types only. E.g. instances of the #GObject hierarchy should be created via g_object_new() and never directly through g_type_create_instance() which doesn't handle things like singleton objects or object construction. The extended members of the returned instance are guaranteed to be filled with zeros. Note: Do not use this function, unless you're implementing a fundamental type. Also language bindings should not use this function, but g_object_new() instead. an allocated and initialized instance, subject to further treatment by the fundamental type implementation an instantiatable type to create an instance for If the interface type @g_type is currently in use, returns its default interface vtable. the default vtable for the interface, or %NULL if the type is not currently in use an interface type Increments the reference count for the interface type @g_type, and returns the default interface vtable for the type. If the type is not currently in use, then the default vtable for the type will be created and initialized by calling the base interface init and default vtable init functions for the type (the @base_init and @class_init members of #GTypeInfo). Calling g_type_default_interface_ref() is useful when you want to make sure that signals and properties for an interface have been installed. the default vtable for the interface; call g_type_default_interface_unref() when you are done using the interface. an interface type Decrements the reference count for the type corresponding to the interface default vtable @g_iface. If the type is dynamic, then when no one is using the interface and all references have been released, the finalize function for the interface's default vtable (the @class_finalize member of #GTypeInfo) will be called. the default vtable structure for an interface, as returned by g_type_default_interface_ref() Returns the length of the ancestry of the passed in type. This includes the type itself, so that e.g. a fundamental type has depth 1. the depth of @type a #GType Ensures that the indicated @type has been registered with the type system, and its _class_init() method has been run. In theory, simply calling the type's _get_type() method (or using the corresponding macro) is supposed take care of this. However, _get_type() methods are often marked %G_GNUC_CONST for performance reasons, even though this is technically incorrect (since %G_GNUC_CONST requires that the function not have side effects, which _get_type() methods do on the first call). As a result, if you write a bare call to a _get_type() macro, it may get optimized out by the compiler. Using g_type_ensure() guarantees that the type's _get_type() method is called. a #GType Frees an instance of a type, returning it to the instance pool for the type, if there is one. Like g_type_create_instance(), this function is reserved for implementors of fundamental types. an instance of a type Look up the type ID from a given type name, returning 0 if no type has been registered under this name (this is the preferred method to find out by name whether a specific type has been registered yet). corresponding type ID or 0 type name to look up Internal function, used to extract the fundamental type ID portion. Use G_TYPE_FUNDAMENTAL() instead. fundamental type ID valid type ID Returns the next free fundamental type id which can be used to register a new fundamental type with g_type_register_fundamental(). The returned type ID represents the highest currently registered fundamental type identifier. the next available fundamental type ID to be registered, or 0 if the type system ran out of fundamental type IDs Returns the number of instances allocated of the particular type; this is only available if GLib is built with debugging support and the instance_count debug flag is set (by setting the GOBJECT_DEBUG variable to include instance-count). the number of instances allocated of the given type; if instance counts are not available, returns 0. a #GType Returns the #GTypePlugin structure for @type. the corresponding plugin if @type is a dynamic type, %NULL otherwise #GType to retrieve the plugin for Obtains data which has previously been attached to @type with g_type_set_qdata(). Note that this does not take subtyping into account; data attached to one type with g_type_set_qdata() cannot be retrieved from a subtype using g_type_get_qdata(). the data, or %NULL if no data was found a #GType a #GQuark id to identify the data Returns an opaque serial number that represents the state of the set of registered types. Any time a type is registered this serial changes, which means you can cache information based on type lookups (such as g_type_from_name()) and know if the cache is still valid at a later time by comparing the current serial with the one at the type lookup. An unsigned int, representing the state of type registrations This function used to initialise the type system. Since GLib 2.36, the type system is initialised automatically and this function does nothing. the type system is now initialised automatically This function used to initialise the type system with debugging flags. Since GLib 2.36, the type system is initialised automatically and this function does nothing. If you need to enable debugging features, use the GOBJECT_DEBUG environment variable. the type system is now initialised automatically bitwise combination of #GTypeDebugFlags values for debugging purposes Adds @prerequisite_type to the list of prerequisites of @interface_type. This means that any type implementing @interface_type must also implement @prerequisite_type. Prerequisites can be thought of as an alternative to interface derivation (which GType doesn't support). An interface can have at most one instantiatable prerequisite type. #GType value of an interface type #GType value of an interface or instantiatable type Returns the #GTypePlugin structure for the dynamic interface @interface_type which has been added to @instance_type, or %NULL if @interface_type has not been added to @instance_type or does not have a #GTypePlugin structure. See g_type_add_interface_dynamic(). the #GTypePlugin for the dynamic interface @interface_type of @instance_type #GType of an instantiatable type #GType of an interface type Returns the #GTypeInterface structure of an interface to which the passed in class conforms. the #GTypeInterface structure of @iface_type if implemented by @instance_class, %NULL otherwise a #GTypeClass structure an interface ID which this class conforms to Returns the prerequisites of an interfaces type. a newly-allocated zero-terminated array of #GType containing the prerequisites of @interface_type an interface type location to return the number of prerequisites, or %NULL Return a newly allocated and 0-terminated array of type IDs, listing the interface types that @type conforms to. Newly allocated and 0-terminated array of interface types, free with g_free() the type to list interface types for location to store the length of the returned array, or %NULL If @is_a_type is a derivable type, check whether @type is a descendant of @is_a_type. If @is_a_type is an interface, check whether @type conforms to it. %TRUE if @type is a @is_a_type type to check anchestry for possible anchestor of @type or interface that @type could conform to Get the unique name that is assigned to a type ID. Note that this function (like all other GType API) cannot cope with invalid type IDs. %G_TYPE_INVALID may be passed to this function, as may be any other validly registered type ID, but randomized type IDs should not be passed in and will most likely lead to a crash. static type name or %NULL type to return name for Given a @leaf_type and a @root_type which is contained in its anchestry, return the type that @root_type is the immediate parent of. In other words, this function determines the type that is derived directly from @root_type which is also a base class of @leaf_type. Given a root type and a leaf type, this function can be used to determine the types and order in which the leaf type is descended from the root type. immediate child of @root_type and anchestor of @leaf_type descendant of @root_type and the type to be returned immediate parent of the returned type Return the direct parent type of the passed in type. If the passed in type has no parent, i.e. is a fundamental type, 0 is returned. the parent type the derived type Get the corresponding quark of the type IDs name. the type names quark or 0 type to return quark of type name for Queries the type system for information about a specific type. This function will fill in a user-provided structure to hold type-specific information. If an invalid #GType is passed in, the @type member of the #GTypeQuery is 0. All members filled into the #GTypeQuery structure should be considered constant and have to be left untouched. #GType of a static, classed type a user provided structure that is filled in with constant values upon success Registers @type_name as the name of a new dynamic type derived from @parent_type. The type system uses the information contained in the #GTypePlugin structure pointed to by @plugin to manage the type and its instances (if not abstract). The value of @flags determines the nature (e.g. abstract or not) of the type. the new type identifier or #G_TYPE_INVALID if registration failed type from which this type will be derived 0-terminated string used as the name of the new type #GTypePlugin structure to retrieve the #GTypeInfo from bitwise combination of #GTypeFlags values Registers @type_id as the predefined identifier and @type_name as the name of a fundamental type. If @type_id is already registered, or a type named @type_name is already registered, the behaviour is undefined. The type system uses the information contained in the #GTypeInfo structure pointed to by @info and the #GTypeFundamentalInfo structure pointed to by @finfo to manage the type and its instances. The value of @flags determines additional characteristics of the fundamental type. the predefined type identifier a predefined type identifier 0-terminated string used as the name of the new type #GTypeInfo structure for this type #GTypeFundamentalInfo structure for this type bitwise combination of #GTypeFlags values Registers @type_name as the name of a new static type derived from @parent_type. The type system uses the information contained in the #GTypeInfo structure pointed to by @info to manage the type and its instances (if not abstract). The value of @flags determines the nature (e.g. abstract or not) of the type. the new type identifier type from which this type will be derived 0-terminated string used as the name of the new type #GTypeInfo structure for this type bitwise combination of #GTypeFlags values Registers @type_name as the name of a new static type derived from @parent_type. The value of @flags determines the nature (e.g. abstract or not) of the type. It works by filling a #GTypeInfo struct and calling g_type_register_static(). the new type identifier type from which this type will be derived 0-terminated string used as the name of the new type size of the class structure (see #GTypeInfo) location of the class initialization function (see #GTypeInfo) size of the instance structure (see #GTypeInfo) location of the instance initialization function (see #GTypeInfo) bitwise combination of #GTypeFlags values Removes a previously installed #GTypeClassCacheFunc. The cache maintained by @cache_func has to be empty when calling g_type_remove_class_cache_func() to avoid leaks. data that was given when adding @cache_func a #GTypeClassCacheFunc Removes an interface check function added with g_type_add_interface_check(). callback data passed to g_type_add_interface_check() callback function passed to g_type_add_interface_check() Attaches arbitrary data to a type. a #GType a #GQuark id to identify the data the data Returns the location of the #GTypeValueTable associated with @type. Note that this function should only be used from source code that implements or has internal knowledge of the implementation of @type. location of the #GTypeValueTable associated with @type or %NULL if there is no #GTypeValueTable associated with @type a #GType The prime purpose of a #GValueArray is for it to be used as an object property that holds an array of values. A #GValueArray wraps an array of #GValue elements in order for it to be used as a boxed type through %G_TYPE_VALUE_ARRAY. #GValueArray is deprecated in favour of #GArray since GLib 2.32. It is possible to create a #GArray that behaves like a #GValueArray by using the size of #GValue as the element size, and by setting g_value_unset() as the clear function using g_array_set_clear_func(), for instance, the following code: |[<!-- language="C" --> GValueArray *array = g_value_array_new (10); ]| can be replaced by: |[<!-- language="C" --> GArray *array = g_array_sized_new (FALSE, TRUE, sizeof (GValue), 10); g_array_set_clear_func (array, (GDestroyNotify) g_value_unset); ]| Registers a value transformation function for use in g_value_transform(). A previously registered transformation function for @src_type and @dest_type will be replaced. Source type. Target type. a function which transforms values of type @src_type into value of type @dest_type Returns whether a #GValue of type @src_type can be copied into a #GValue of type @dest_type. %TRUE if g_value_copy() is possible with @src_type and @dest_type. source type to be copied. destination type for copying. Check whether g_value_transform() is able to transform values of type @src_type into values of type @dest_type. Note that for the types to be transformable, they must be compatible or a transformation function must be registered. %TRUE if the transformation is possible, %FALSE otherwise. Source type. Target type. gtkada-24.0.0/contrib/Gdk-3.0.gir000066400000000000000000064555241446021174000162220ustar00rootroot00000000000000 Used to represent native events (XEvents for the X11 backend, MSGs for Win32). Converts a #GdkAtom into a pointer type. a #GdkAtom. Positioning hints for aligning a window relative to a rectangle. These hints determine how the window should be positioned in the case that the window would fall off-screen if placed in its ideal position. For example, %GDK_ANCHOR_FLIP_X will replace %GDK_GRAVITY_NORTH_WEST with %GDK_GRAVITY_NORTH_EAST and vice versa if the window extends beyond the left or right edges of the monitor. If %GDK_ANCHOR_SLIDE_X is set, the window can be shifted horizontally to fit on-screen. If %GDK_ANCHOR_RESIZE_X is set, the window can be shrunken horizontally to fit. In general, when multiple flags are set, flipping should take precedence over sliding, which should take precedence over resizing. allow flipping anchors horizontally allow flipping anchors vertically allow sliding window horizontally allow sliding window vertically allow resizing window horizontally allow resizing window vertically allow flipping anchors on both axes allow sliding window on both axes allow resizing window on both axes GdkAppLaunchContext is an implementation of #GAppLaunchContext that handles launching an application in a graphical context. It provides startup notification and allows to launch applications on a specific screen or workspace. ## Launching an application |[<!-- language="C" --> GdkAppLaunchContext *context; context = gdk_display_get_app_launch_context (display); gdk_app_launch_context_set_screen (screen); gdk_app_launch_context_set_timestamp (event->time); if (!g_app_info_launch_default_for_uri ("http://www.gtk.org", context, &error)) g_warning ("Launching failed: %s\n", error->message); g_object_unref (context); ]| Creates a new #GdkAppLaunchContext. Use gdk_display_get_app_launch_context() instead a new #GdkAppLaunchContext Sets the workspace on which applications will be launched when using this context when running under a window manager that supports multiple workspaces, as described in the [Extended Window Manager Hints](http://www.freedesktop.org/Standards/wm-spec). When the workspace is not specified or @desktop is set to -1, it is up to the window manager to pick one, typically it will be the current workspace. a #GdkAppLaunchContext the number of a workspace, or -1 Sets the display on which applications will be launched when using this context. See also gdk_app_launch_context_set_screen(). Use gdk_display_get_app_launch_context() instead a #GdkAppLaunchContext a #GdkDisplay Sets the icon for applications that are launched with this context. Window Managers can use this information when displaying startup notification. See also gdk_app_launch_context_set_icon_name(). a #GdkAppLaunchContext a #GIcon, or %NULL Sets the icon for applications that are launched with this context. The @icon_name will be interpreted in the same way as the Icon field in desktop files. See also gdk_app_launch_context_set_icon(). If both @icon and @icon_name are set, the @icon_name takes priority. If neither @icon or @icon_name is set, the icon is taken from either the file that is passed to launched application or from the #GAppInfo for the launched application itself. a #GdkAppLaunchContext an icon name, or %NULL Sets the screen on which applications will be launched when using this context. See also gdk_app_launch_context_set_display(). If both @screen and @display are set, the @screen takes priority. If neither @screen or @display are set, the default screen and display are used. a #GdkAppLaunchContext a #GdkScreen Sets the timestamp of @context. The timestamp should ideally be taken from the event that triggered the launch. Window managers can use this information to avoid moving the focus to the newly launched application when the user is busy typing in another window. This is also known as 'focus stealing prevention'. a #GdkAppLaunchContext a timestamp An opaque type representing a string as an index into a table of strings on the X server. Determines the string corresponding to an atom. a newly-allocated string containing the string corresponding to @atom. When you are done with the return value, you should free it using g_free(). a #GdkAtom. Finds or creates an atom corresponding to a given string. the atom corresponding to @atom_name. a string. if %TRUE, GDK is allowed to not create a new atom, but just return %GDK_NONE if the requested atom doesn’t already exists. Currently, the flag is ignored, since checking the existance of an atom is as expensive as creating it. Finds or creates an atom corresponding to a given string. Note that this function is identical to gdk_atom_intern() except that if a new #GdkAtom is created the string itself is used rather than a copy. This saves memory, but can only be used if the string will always exist. It can be used with statically allocated strings in the main program, but not with statically allocated memory in dynamically loaded modules, if you expect to ever unload the module again (e.g. do not use this function in GTK+ theme engines). the atom corresponding to @atom_name a static string Flags describing the current capabilities of a device/tool. X axis is present Y axis is present Pressure axis is present X tilt axis is present Y tilt axis is present Wheel axis is present Distance axis is present Z-axis rotation is present Slider axis is present An enumeration describing the way in which a device axis (valuator) maps onto the predefined valuator types that GTK+ understands. Note that the X and Y axes are not really needed; pointer devices report their location via the x/y members of events regardless. Whether X and Y are present as axes depends on the GDK backend. the axis is ignored. the axis is used as the x axis. the axis is used as the y axis. the axis is used for pressure information. the axis is used for x tilt information. the axis is used for y tilt information. the axis is used for wheel information. the axis is used for pen/tablet distance information. (Since: 3.22) the axis is used for pen rotation information. (Since: 3.22) the axis is used for pen slider information. (Since: 3.22) a constant equal to the numerically highest axis value. The middle button. The primary button. This is typically the left mouse button, or the right button in a left-handed setup. The secondary button. This is typically the right mouse button, or the left button in a left-handed setup. A set of values describing the possible byte-orders for storing pixel values in memory. The values are stored with the least-significant byte first. For instance, the 32-bit value 0xffeecc would be stored in memory as 0xcc, 0xee, 0xff, 0x00. The values are stored with the most-significant byte first. For instance, the 32-bit value 0xffeecc would be stored in memory as 0x00, 0xff, 0xee, 0xcc. Represents the current time, and can be used anywhere a time is expected. A #GdkColor is used to describe a color, similar to the XColor struct used in the X11 drawing API. Use #GdkRGBA For allocated colors, the pixel value used to draw this color on the screen. Not used anymore. The red component of the color. This is a value between 0 and 65535, with 65535 indicating full intensity The green component of the color The blue component of the color Makes a copy of a #GdkColor. The result must be freed using gdk_color_free(). Use #GdkRGBA a copy of @color a #GdkColor Compares two colors. Use #GdkRGBA %TRUE if the two colors compare equal a #GdkColor another #GdkColor Frees a #GdkColor created with gdk_color_copy(). Use #GdkRGBA a #GdkColor A hash function suitable for using for a hash table that stores #GdkColors. Use #GdkRGBA The hash function applied to @color a #GdkColor Returns a textual specification of @color in the hexadecimal form “\#rrrrggggbbbb” where “r”, “g” and “b” are hex digits representing the red, green and blue components respectively. The returned string can be parsed by gdk_color_parse(). Use #GdkRGBA a newly-allocated text string a #GdkColor Parses a textual specification of a color and fill in the @red, @green, and @blue fields of a #GdkColor. The string can either one of a large set of standard names (taken from the X11 `rgb.txt` file), or it can be a hexadecimal value in the form “\#rgb” “\#rrggbb”, “\#rrrgggbbb” or “\#rrrrggggbbbb” where “r”, “g” and “b” are hex digits of the red, green, and blue components of the color, respectively. (White in the four forms is “\#fff”, “\#ffffff”, “\#fffffffff” and “\#ffffffffffff”). Use #GdkRGBA %TRUE if the parsing succeeded the string specifying the color the #GdkColor to fill in Specifies the crossing mode for #GdkEventCrossing. crossing because of pointer motion. crossing because a grab is activated. crossing because a grab is deactivated. crossing because a GTK+ grab is activated. crossing because a GTK+ grab is deactivated. crossing because a GTK+ widget changed state (e.g. sensitivity). crossing because a touch sequence has begun, this event is synthetic as the pointer might have not left the window. crossing because a touch sequence has ended, this event is synthetic as the pointer might have not left the window. crossing because of a device switch (i.e. a mouse taking control of the pointer after a touch device), this event is synthetic as the pointer didn’t leave the window. A #GdkCursor represents a cursor. Its contents are private. Creates a new cursor from the set of builtin cursors for the default display. See gdk_cursor_new_for_display(). To make the cursor invisible, use %GDK_BLANK_CURSOR. Use gdk_cursor_new_for_display() instead. a new #GdkCursor cursor to create Creates a new cursor from the set of builtin cursors. a new #GdkCursor, or %NULL on failure the #GdkDisplay for which the cursor will be created cursor to create Creates a new cursor by looking up @name in the current cursor theme. A recommended set of cursor names that will work across different platforms can be found in the CSS specification: - "none" - ![](default_cursor.png) "default" - ![](help_cursor.png) "help" - ![](pointer_cursor.png) "pointer" - ![](context_menu_cursor.png) "context-menu" - ![](progress_cursor.png) "progress" - ![](wait_cursor.png) "wait" - ![](cell_cursor.png) "cell" - ![](crosshair_cursor.png) "crosshair" - ![](text_cursor.png) "text" - ![](vertical_text_cursor.png) "vertical-text" - ![](alias_cursor.png) "alias" - ![](copy_cursor.png) "copy" - ![](no_drop_cursor.png) "no-drop" - ![](move_cursor.png) "move" - ![](not_allowed_cursor.png) "not-allowed" - ![](grab_cursor.png) "grab" - ![](grabbing_cursor.png) "grabbing" - ![](all_scroll_cursor.png) "all-scroll" - ![](col_resize_cursor.png) "col-resize" - ![](row_resize_cursor.png) "row-resize" - ![](n_resize_cursor.png) "n-resize" - ![](e_resize_cursor.png) "e-resize" - ![](s_resize_cursor.png) "s-resize" - ![](w_resize_cursor.png) "w-resize" - ![](ne_resize_cursor.png) "ne-resize" - ![](nw_resize_cursor.png) "nw-resize" - ![](sw_resize_cursor.png) "sw-resize" - ![](se_resize_cursor.png) "se-resize" - ![](ew_resize_cursor.png) "ew-resize" - ![](ns_resize_cursor.png) "ns-resize" - ![](nesw_resize_cursor.png) "nesw-resize" - ![](nwse_resize_cursor.png) "nwse-resize" - ![](zoom_in_cursor.png) "zoom-in" - ![](zoom_out_cursor.png) "zoom-out" a new #GdkCursor, or %NULL if there is no cursor with the given name the #GdkDisplay for which the cursor will be created the name of the cursor Creates a new cursor from a pixbuf. Not all GDK backends support RGBA cursors. If they are not supported, a monochrome approximation will be displayed. The functions gdk_display_supports_cursor_alpha() and gdk_display_supports_cursor_color() can be used to determine whether RGBA cursors are supported; gdk_display_get_default_cursor_size() and gdk_display_get_maximal_cursor_size() give information about cursor sizes. If @x or @y are `-1`, the pixbuf must have options named “x_hot” and “y_hot”, resp., containing integer values between `0` and the width resp. height of the pixbuf. (Since: 3.0) On the X backend, support for RGBA cursors requires a sufficently new version of the X Render extension. a new #GdkCursor. the #GdkDisplay for which the cursor will be created the #GdkPixbuf containing the cursor image the horizontal offset of the “hotspot” of the cursor. the vertical offset of the “hotspot” of the cursor. Creates a new cursor from a cairo image surface. Not all GDK backends support RGBA cursors. If they are not supported, a monochrome approximation will be displayed. The functions gdk_display_supports_cursor_alpha() and gdk_display_supports_cursor_color() can be used to determine whether RGBA cursors are supported; gdk_display_get_default_cursor_size() and gdk_display_get_maximal_cursor_size() give information about cursor sizes. On the X backend, support for RGBA cursors requires a sufficently new version of the X Render extension. a new #GdkCursor. the #GdkDisplay for which the cursor will be created the cairo image surface containing the cursor pixel data the horizontal offset of the “hotspot” of the cursor the vertical offset of the “hotspot” of the cursor Returns the cursor type for this cursor. a #GdkCursorType a #GdkCursor Returns the display on which the #GdkCursor is defined. the #GdkDisplay associated to @cursor a #GdkCursor. Returns a #GdkPixbuf with the image used to display the cursor. Note that depending on the capabilities of the windowing system and on the cursor, GDK may not be able to obtain the image data. In this case, %NULL is returned. a #GdkPixbuf representing @cursor, or %NULL a #GdkCursor Returns a cairo image surface with the image used to display the cursor. Note that depending on the capabilities of the windowing system and on the cursor, GDK may not be able to obtain the image data. In this case, %NULL is returned. a #cairo_surface_t representing @cursor, or %NULL a #GdkCursor Location to store the hotspot x position, or %NULL Location to store the hotspot y position, or %NULL Adds a reference to @cursor. Use g_object_ref() instead Same @cursor that was passed in a #GdkCursor Removes a reference from @cursor, deallocating the cursor if no references remain. Use g_object_unref() instead a #GdkCursor Predefined cursors. Note that these IDs are directly taken from the X cursor font, and many of these cursors are either not useful, or are not available on other platforms. The recommended way to create cursors is to use gdk_cursor_new_from_name(). ![](X_cursor.png) ![](arrow.png) ![](based_arrow_down.png) ![](based_arrow_up.png) ![](boat.png) ![](bogosity.png) ![](bottom_left_corner.png) ![](bottom_right_corner.png) ![](bottom_side.png) ![](bottom_tee.png) ![](box_spiral.png) ![](center_ptr.png) ![](circle.png) ![](clock.png) ![](coffee_mug.png) ![](cross.png) ![](cross_reverse.png) ![](crosshair.png) ![](diamond_cross.png) ![](dot.png) ![](dotbox.png) ![](double_arrow.png) ![](draft_large.png) ![](draft_small.png) ![](draped_box.png) ![](exchange.png) ![](fleur.png) ![](gobbler.png) ![](gumby.png) ![](hand1.png) ![](hand2.png) ![](heart.png) ![](icon.png) ![](iron_cross.png) ![](left_ptr.png) ![](left_side.png) ![](left_tee.png) ![](leftbutton.png) ![](ll_angle.png) ![](lr_angle.png) ![](man.png) ![](middlebutton.png) ![](mouse.png) ![](pencil.png) ![](pirate.png) ![](plus.png) ![](question_arrow.png) ![](right_ptr.png) ![](right_side.png) ![](right_tee.png) ![](rightbutton.png) ![](rtl_logo.png) ![](sailboat.png) ![](sb_down_arrow.png) ![](sb_h_double_arrow.png) ![](sb_left_arrow.png) ![](sb_right_arrow.png) ![](sb_up_arrow.png) ![](sb_v_double_arrow.png) ![](shuttle.png) ![](sizing.png) ![](spider.png) ![](spraycan.png) ![](star.png) ![](target.png) ![](tcross.png) ![](top_left_arrow.png) ![](top_left_corner.png) ![](top_right_corner.png) ![](top_side.png) ![](top_tee.png) ![](trek.png) ![](ul_angle.png) ![](umbrella.png) ![](ur_angle.png) ![](watch.png) ![](xterm.png) last cursor type Blank cursor. Since 2.16 type of cursors constructed with gdk_cursor_new_from_pixbuf() The #GdkDevice object represents a single input device, such as a keyboard, a mouse, a touchpad, etc. See the #GdkDeviceManager documentation for more information about the various kinds of master and slave devices, and their relationships. Frees an array of #GdkTimeCoord that was returned by gdk_device_get_history(). an array of #GdkTimeCoord. the length of the array. Determines information about the current keyboard grab. This is not public API and must not be used by applications. The symbol was never meant to be used outside of GTK+ %TRUE if this application currently has the keyboard grabbed. the display for which to get the grab information device to get the grab information from location to store current grab window location to store boolean indicating whether the @owner_events flag to gdk_keyboard_grab() or gdk_pointer_grab() was %TRUE. Returns the associated device to @device, if @device is of type %GDK_DEVICE_TYPE_MASTER, it will return the paired pointer or keyboard. If @device is of type %GDK_DEVICE_TYPE_SLAVE, it will return the master device to which @device is attached to. If @device is of type %GDK_DEVICE_TYPE_FLOATING, %NULL will be returned, as there is no associated device. The associated device, or %NULL a #GdkDevice Returns the axes currently available on the device. a #GdkDevice Interprets an array of double as axis values for a given device, and locates the value in the array for a given axis use. %TRUE if the given axis use was found, otherwise %FALSE a #GdkDevice pointer to an array of axes the use to look for location to store the found value. Returns the axis use for @index_. a #GdkAxisUse specifying how the axis is used. a pointer #GdkDevice. the index of the axis. Interprets an array of double as axis values for a given device, and locates the value in the array for a given axis label, as returned by gdk_device_list_axes() %TRUE if the given axis use was found, otherwise %FALSE. a pointer #GdkDevice. pointer to an array of axes #GdkAtom with the axis label. location to store the found value. Returns the device type for @device. the #GdkDeviceType for @device. a #GdkDevice Returns the #GdkDisplay to which @device pertains. a #GdkDisplay. This memory is owned by GTK+, and must not be freed or unreffed. a #GdkDevice Determines whether the pointer follows device motion. This is not meaningful for keyboard devices, which don't have a pointer. %TRUE if the pointer follows device motion a #GdkDevice Obtains the motion history for a pointer device; given a starting and ending timestamp, return all events in the motion history for the device in the given range of time. Some windowing systems do not support motion history, in which case, %FALSE will be returned. (This is not distinguishable from the case where motion history is supported and no events were found.) Note that there is also gdk_window_set_event_compression() to get more motion events delivered directly, independent of the windowing system. %TRUE if the windowing system supports motion history and at least one event was found. a #GdkDevice the window with respect to which which the event coordinates will be reported starting timestamp for range of events to return ending timestamp for the range of events to return location to store a newly-allocated array of #GdkTimeCoord, or %NULL location to store the length of @events, or %NULL If @index_ has a valid keyval, this function will return %TRUE and fill in @keyval and @modifiers with the keyval settings. %TRUE if keyval is set for @index. a #GdkDevice. the index of the macro button to get. return value for the keyval. return value for modifiers. Gets information about which window the given pointer device is in, based on events that have been received so far from the display server. If another application has a pointer grab, or this application has a grab with owner_events = %FALSE, %NULL may be returned even if the pointer is physically over one of this application's windows. the last window the device a #GdkDevice, with a source other than %GDK_SOURCE_KEYBOARD Determines the mode of the device. a #GdkInputSource a #GdkDevice Returns the number of axes the device currently has. the number of axes. a pointer #GdkDevice Returns the number of keys the device currently has. the number of keys. a #GdkDevice Determines the name of the device. a name a #GdkDevice Gets the current location of @device. As a slave device coordinates are those of its master pointer, This function may not be called on devices of type %GDK_DEVICE_TYPE_SLAVE, unless there is an ongoing grab on them, see gdk_device_grab(). pointer device to query status about. location to store the #GdkScreen the @device is on, or %NULL. location to store root window X coordinate of @device, or %NULL. location to store root window Y coordinate of @device, or %NULL. Gets the current location of @device in double precision. As a slave device's coordinates are those of its master pointer, this function may not be called on devices of type %GDK_DEVICE_TYPE_SLAVE, unless there is an ongoing grab on them. See gdk_device_grab(). pointer device to query status about. location to store the #GdkScreen the @device is on, or %NULL. location to store root window X coordinate of @device, or %NULL. location to store root window Y coordinate of @device, or %NULL. Returns the product ID of this device, or %NULL if this information couldn't be obtained. This ID is retrieved from the device, and is thus constant for it. See gdk_device_get_vendor_id() for more information. the product ID, or %NULL a slave #GdkDevice Returns the #GdkSeat the device belongs to. A #GdkSeat. This memory is owned by GTK+ and must not be freed. A #GdkDevice Determines the type of the device. a #GdkInputSource a #GdkDevice Gets the current state of a pointer device relative to @window. As a slave device’s coordinates are those of its master pointer, this function may not be called on devices of type %GDK_DEVICE_TYPE_SLAVE, unless there is an ongoing grab on them. See gdk_device_grab(). a #GdkDevice. a #GdkWindow. an array of doubles to store the values of the axes of @device in, or %NULL. location to store the modifiers, or %NULL. Returns the vendor ID of this device, or %NULL if this information couldn't be obtained. This ID is retrieved from the device, and is thus constant for it. This function, together with gdk_device_get_product_id(), can be used to eg. compose #GSettings paths to store settings for this device. |[<!-- language="C" --> static GSettings * get_device_settings (GdkDevice *device) { const gchar *vendor, *product; GSettings *settings; GdkDevice *device; gchar *path; vendor = gdk_device_get_vendor_id (device); product = gdk_device_get_product_id (device); path = g_strdup_printf ("/org/example/app/devices/%s:%s/", vendor, product); settings = g_settings_new_with_path (DEVICE_SCHEMA, path); g_free (path); return settings; } ]| the vendor ID, or %NULL a slave #GdkDevice Obtains the window underneath @device, returning the location of the device in @win_x and @win_y. Returns %NULL if the window tree under @device is not known to GDK (for example, belongs to another application). As a slave device coordinates are those of its master pointer, This function may not be called on devices of type %GDK_DEVICE_TYPE_SLAVE, unless there is an ongoing grab on them, see gdk_device_grab(). the #GdkWindow under the device position, or %NULL. pointer #GdkDevice to query info to. return location for the X coordinate of the device location, relative to the window origin, or %NULL. return location for the Y coordinate of the device location, relative to the window origin, or %NULL. Obtains the window underneath @device, returning the location of the device in @win_x and @win_y in double precision. Returns %NULL if the window tree under @device is not known to GDK (for example, belongs to another application). As a slave device coordinates are those of its master pointer, This function may not be called on devices of type %GDK_DEVICE_TYPE_SLAVE, unless there is an ongoing grab on them, see gdk_device_grab(). the #GdkWindow under the device position, or %NULL. pointer #GdkDevice to query info to. return location for the X coordinate of the device location, relative to the window origin, or %NULL. return location for the Y coordinate of the device location, relative to the window origin, or %NULL. Grabs the device so that all events coming from this device are passed to this application until the device is ungrabbed with gdk_device_ungrab(), or the window becomes unviewable. This overrides any previous grab on the device by this client. Note that @device and @window need to be on the same display. Device grabs are used for operations which need complete control over the given device events (either pointer or keyboard). For example in GTK+ this is used for Drag and Drop operations, popup menus and such. Note that if the event mask of an X window has selected both button press and button release events, then a button press event will cause an automatic pointer grab until the button is released. X does this automatically since most applications expect to receive button press and release events in pairs. It is equivalent to a pointer grab on the window with @owner_events set to %TRUE. If you set up anything at the time you take the grab that needs to be cleaned up when the grab ends, you should handle the #GdkEventGrabBroken events that are emitted when the grab ends unvoluntarily. Use gdk_seat_grab() instead. %GDK_GRAB_SUCCESS if the grab was successful. a #GdkDevice. To get the device you can use gtk_get_current_event_device() or gdk_event_get_device() if the grab is in reaction to an event. Also, you can use gdk_device_manager_get_client_pointer() but only in code that isn’t triggered by a #GdkEvent and there aren’t other means to get a meaningful #GdkDevice to operate on. the #GdkWindow which will own the grab (the grab window) specifies the grab ownership. if %FALSE then all device events are reported with respect to @window and are only reported if selected by @event_mask. If %TRUE then pointer events for this application are reported as normal, but pointer events outside this application are reported with respect to @window and only if selected by @event_mask. In either mode, unreported events are discarded. specifies the event mask, which is used in accordance with @owner_events. the cursor to display while the grab is active if the device is a pointer. If this is %NULL then the normal cursors are used for @window and its descendants, and the cursor for @window is used elsewhere. the timestamp of the event which led to this pointer grab. This usually comes from the #GdkEvent struct, though %GDK_CURRENT_TIME can be used if the time isn’t known. Returns a #GList of #GdkAtoms, containing the labels for the axes that @device currently has. A #GList of #GdkAtoms, free with g_list_free(). a pointer #GdkDevice If the device if of type %GDK_DEVICE_TYPE_MASTER, it will return the list of slave devices attached to it, otherwise it will return %NULL the list of slave devices, or %NULL. The list must be freed with g_list_free(), the contents of the list are owned by GTK+ and should not be freed. a #GdkDevice Specifies how an axis of a device is used. a pointer #GdkDevice the index of the axis specifies how the axis is used Specifies the X key event to generate when a macro button of a device is pressed. a #GdkDevice the index of the macro button to set the keyval to generate the modifiers to set Sets a the mode of an input device. The mode controls if the device is active and whether the device’s range is mapped to the entire screen or to a single window. Note: This is only meaningful for floating devices, master devices (and slaves connected to these) drive the pointer cursor, which is not limited by the input mode. %TRUE if the mode was successfully changed. a #GdkDevice. the input mode. Release any grab on @device. Use gdk_seat_ungrab() instead. a #GdkDevice a timestap (e.g. %GDK_CURRENT_TIME). Warps @device in @display to the point @x,@y on the screen @screen, unless the device is confined to a window by a grab, in which case it will be moved as far as allowed by the grab. Warping the pointer creates events as if the user had moved the mouse instantaneously to the destination. Note that the pointer should normally be under the control of the user. This function was added to cover some rare use cases like keyboard navigation support for the color picker in the #GtkColorSelectionDialog. the device to warp. the screen to warp @device to. the X coordinate of the destination. the Y coordinate of the destination. Associated pointer or keyboard with this device, if any. Devices of type #GDK_DEVICE_TYPE_MASTER always come in keyboard/pointer pairs. Other device types will have a %NULL associated device. The axes currently available for this device. The #GdkDeviceManager the #GdkDevice pertains to. The #GdkDisplay the #GdkDevice pertains to. Whether the device is represented by a cursor on the screen. Devices of type %GDK_DEVICE_TYPE_MASTER will have %TRUE here. Source type for the device. Number of axes in the device. The device name. The maximal number of concurrent touches on a touch device. Will be 0 if the device is not a touch device or if the number of touches is unknown. Product ID of this device, see gdk_device_get_product_id(). #GdkSeat of this device. Device role in the device manager. Vendor ID of this device, see gdk_device_get_vendor_id(). The ::changed signal is emitted either when the #GdkDevice has changed the number of either axes or keys. For example In X this will normally happen when the slave device routing events through the master device changes (for example, user switches from the USB mouse to a tablet), in that case the master device will change to reflect the new slave device axes and keys. The ::tool-changed signal is emitted on pen/eraser #GdkDevices whenever tools enter or leave proximity. The new current tool In addition to a single pointer and keyboard for user interface input, GDK contains support for a variety of input devices, including graphics tablets, touchscreens and multiple pointers/keyboards interacting simultaneously with the user interface. Such input devices often have additional features, such as sub-pixel positioning information and additional device-dependent information. In order to query the device hierarchy and be aware of changes in the device hierarchy (such as virtual devices being created or removed, or physical devices being plugged or unplugged), GDK provides #GdkDeviceManager. By default, and if the platform supports it, GDK is aware of multiple keyboard/pointer pairs and multitouch devices. This behavior can be changed by calling gdk_disable_multidevice() before gdk_display_open(). There should rarely be a need to do that though, since GDK defaults to a compatibility mode in which it will emit just one enter/leave event pair for all devices on a window. To enable per-device enter/leave events and other multi-pointer interaction features, gdk_window_set_support_multidevice() must be called on #GdkWindows (or gtk_widget_set_support_multidevice() on widgets). window. See the gdk_window_set_support_multidevice() documentation for more information. On X11, multi-device support is implemented through XInput 2. Unless gdk_disable_multidevice() is called, the XInput 2 #GdkDeviceManager implementation will be used as the input source. Otherwise either the core or XInput 1 implementations will be used. For simple applications that don’t have any special interest in input devices, the so-called “client pointer” provides a reasonable approximation to a simple setup with a single pointer and keyboard. The device that has been set as the client pointer can be accessed via gdk_device_manager_get_client_pointer(). Conceptually, in multidevice mode there are 2 device types. Virtual devices (or master devices) are represented by the pointer cursors and keyboard foci that are seen on the screen. Physical devices (or slave devices) represent the hardware that is controlling the virtual devices, and thus have no visible cursor on the screen. Virtual devices are always paired, so there is a keyboard device for every pointer device. Associations between devices may be inspected through gdk_device_get_associated_device(). There may be several virtual devices, and several physical devices could be controlling each of these virtual devices. Physical devices may also be “floating”, which means they are not attached to any virtual device. # Master and slave devices |[ carlos@sacarino:~$ xinput list ⎡ Virtual core pointer id=2 [master pointer (3)] ⎜ ↳ Virtual core XTEST pointer id=4 [slave pointer (2)] ⎜ ↳ Wacom ISDv4 E6 Pen stylus id=10 [slave pointer (2)] ⎜ ↳ Wacom ISDv4 E6 Finger touch id=11 [slave pointer (2)] ⎜ ↳ SynPS/2 Synaptics TouchPad id=13 [slave pointer (2)] ⎜ ↳ TPPS/2 IBM TrackPoint id=14 [slave pointer (2)] ⎜ ↳ Wacom ISDv4 E6 Pen eraser id=16 [slave pointer (2)] ⎣ Virtual core keyboard id=3 [master keyboard (2)] ↳ Virtual core XTEST keyboard id=5 [slave keyboard (3)] ↳ Power Button id=6 [slave keyboard (3)] ↳ Video Bus id=7 [slave keyboard (3)] ↳ Sleep Button id=8 [slave keyboard (3)] ↳ Integrated Camera id=9 [slave keyboard (3)] ↳ AT Translated Set 2 keyboard id=12 [slave keyboard (3)] ↳ ThinkPad Extra Buttons id=15 [slave keyboard (3)] ]| By default, GDK will automatically listen for events coming from all master devices, setting the #GdkDevice for all events coming from input devices. Events containing device information are #GDK_MOTION_NOTIFY, #GDK_BUTTON_PRESS, #GDK_2BUTTON_PRESS, #GDK_3BUTTON_PRESS, #GDK_BUTTON_RELEASE, #GDK_SCROLL, #GDK_KEY_PRESS, #GDK_KEY_RELEASE, #GDK_ENTER_NOTIFY, #GDK_LEAVE_NOTIFY, #GDK_FOCUS_CHANGE, #GDK_PROXIMITY_IN, #GDK_PROXIMITY_OUT, #GDK_DRAG_ENTER, #GDK_DRAG_LEAVE, #GDK_DRAG_MOTION, #GDK_DRAG_STATUS, #GDK_DROP_START, #GDK_DROP_FINISHED and #GDK_GRAB_BROKEN. When dealing with an event on a master device, it is possible to get the source (slave) device that the event originated from via gdk_event_get_source_device(). On a standard session, all physical devices are connected by default to the "Virtual Core Pointer/Keyboard" master devices, hence routing all events through these. This behavior is only modified by device grabs, where the slave device is temporarily detached for as long as the grab is held, and more permanently by user modifications to the device hierarchy. On certain application specific setups, it may make sense to detach a physical device from its master pointer, and mapping it to an specific window. This can be achieved by the combination of gdk_device_grab() and gdk_device_set_mode(). In order to listen for events coming from devices other than a virtual device, gdk_window_set_device_events() must be called. Generally, this function can be used to modify the event mask for any given device. Input devices may also provide additional information besides X/Y. For example, graphics tablets may also provide pressure and X/Y tilt information. This information is device-dependent, and may be queried through gdk_device_get_axis(). In multidevice mode, virtual devices will change axes in order to always represent the physical device that is routing events through it. Whenever the physical device changes, the #GdkDevice:n-axes property will be notified, and gdk_device_list_axes() will return the new device axes. Devices may also have associated “keys” or macro buttons. Such keys can be globally set to map into normal X keyboard events. The mapping is set using gdk_device_set_key(). In GTK+ 3.20, a new #GdkSeat object has been introduced that supersedes #GdkDeviceManager and should be preferred in newly written code. Returns the client pointer, that is, the master pointer that acts as the core pointer for this application. In X11, window managers may change this depending on the interaction pattern under the presence of several pointers. You should use this function seldomly, only in code that isn’t triggered by a #GdkEvent and there aren’t other means to get a meaningful #GdkDevice to operate on. Use gdk_seat_get_pointer() instead. The client pointer. This memory is owned by GDK and must not be freed or unreferenced. a #GdkDeviceManager Gets the #GdkDisplay associated to @device_manager. the #GdkDisplay to which @device_manager is associated to, or %NULL. This memory is owned by GDK and must not be freed or unreferenced. a #GdkDeviceManager Returns the list of devices of type @type currently attached to @device_manager. , use gdk_seat_get_pointer(), gdk_seat_get_keyboard() and gdk_seat_get_slaves() instead. a list of #GdkDevices. The returned list must be freed with g_list_free (). The list elements are owned by GTK+ and must not be freed or unreffed. a #GdkDeviceManager device type to get. The ::device-added signal is emitted either when a new master pointer is created, or when a slave (Hardware) input device is plugged in. the newly added #GdkDevice. The ::device-changed signal is emitted whenever a device has changed in the hierarchy, either slave devices being disconnected from their master device or connected to another one, or master devices being added or removed a slave device. If a slave device is detached from all master devices (gdk_device_get_associated_device() returns %NULL), its #GdkDeviceType will change to %GDK_DEVICE_TYPE_FLOATING, if it's attached, it will change to %GDK_DEVICE_TYPE_SLAVE. the #GdkDevice that changed. The ::device-removed signal is emitted either when a master pointer is removed, or when a slave (Hardware) input device is unplugged. the just removed #GdkDevice. #GdkDevicePad is an interface implemented by devices of type %GDK_SOURCE_TABLET_PAD, it allows querying the features provided by the pad device. Tablet pads may contain one or more groups, each containing a subset of the buttons/rings/strips available. gdk_device_pad_get_n_groups() can be used to obtain the number of groups, gdk_device_pad_get_n_features() and gdk_device_pad_get_feature_group() can be combined to find out the number of buttons/rings/strips the device has, and how are they grouped. Each of those groups have different modes, which may be used to map each individual pad feature to multiple actions. Only one mode is effective (current) for each given group, different groups may have different current modes. The number of available modes in a group can be found out through gdk_device_pad_get_group_n_modes(), and the current mode for a given group will be notified through the #GdkEventPadGroupMode event. Returns the group the given @feature and @idx belong to, or -1 if feature/index do not exist in @pad. The group number of the queried pad feature. a #GdkDevicePad the feature type to get the group from the index of the feature to get the group from Returns the number of modes that @group may have. The number of modes available in @group. a #GdkDevicePad group to get the number of available modes from Returns the number of features a tablet pad has. The amount of elements of type @feature that this pad has. a #GdkDevicePad a pad feature Returns the number of groups this pad device has. Pads have at least one group. A pad group is a subcollection of buttons/strip/rings that is affected collectively by a same current mode. The number of button/ring/strip groups in the pad. a #GdkDevicePad A pad feature. a button a ring-shaped interactive area a straight interactive area Gets the hardware ID of this tool, or 0 if it's not known. When non-zero, the identificator is unique for the given tool model, meaning that two identical tools will share the same @hardware_id, but will have different serial numbers (see gdk_device_tool_get_serial()). This is a more concrete (and device specific) method to identify a #GdkDeviceTool than gdk_device_tool_get_tool_type(), as a tablet may support multiple devices with the same #GdkDeviceToolType, but having different hardware identificators. The hardware identificator of this tool. a #GdkDeviceTool Gets the serial of this tool, this value can be used to identify a physical tool (eg. a tablet pen) across program executions. The serial ID for this tool a #GdkDeviceTool Gets the #GdkDeviceToolType of the tool. The physical type for this tool. This can be used to figure out what sort of pen is being used, such as an airbrush or a pencil. a #GdkDeviceTool Indicates the specific type of tool being used being a tablet. Such as an airbrush, pencil, etc. Tool is of an unknown type. Tool is a standard tablet stylus. Tool is standard tablet eraser. Tool is a brush stylus. Tool is a pencil stylus. Tool is an airbrush stylus. Tool is a mouse. Tool is a lens cursor. Indicates the device type. See [above][GdkDeviceManager.description] for more information about the meaning of these device types. Device is a master (or virtual) device. There will be an associated focus indicator on the screen. Device is a slave (or physical) device. Device is a physical device, currently not attached to any virtual device. #GdkDisplay objects purpose are two fold: - To manage and provide information about input devices (pointers and keyboards) - To manage and provide information about the available #GdkScreens GdkDisplay objects are the GDK representation of an X Display, which can be described as a workstation consisting of a keyboard, a pointing device (such as a mouse) and one or more screens. It is used to open and keep track of various GdkScreen objects currently instantiated by the application. It is also used to access the keyboard(s) and mouse pointer(s) of the display. Most of the input device handling has been factored out into the separate #GdkDeviceManager object. Every display has a device manager, which you can obtain using gdk_display_get_device_manager(). Gets the default #GdkDisplay. This is a convenience function for: `gdk_display_manager_get_default_display (gdk_display_manager_get ())`. a #GdkDisplay, or %NULL if there is no default display. Opens a display. a #GdkDisplay, or %NULL if the display could not be opened the name of the display to open Opens the default display specified by command line arguments or environment variables, sets it as the default display, and returns it. gdk_parse_args() must have been called first. If the default display has previously been set, simply returns that. An internal function that should not be used by applications. This symbol was never meant to be used outside of GTK+ the default display, if it could be opened, otherwise %NULL. Emits a short beep on @display a #GdkDisplay Closes the connection to the windowing system for the given display, and cleans up associated resources. a #GdkDisplay Returns %TRUE if there is an ongoing grab on @device for @display. %TRUE if there is a grab in effect for @device. a #GdkDisplay a #GdkDevice Flushes any requests queued for the windowing system; this happens automatically when the main loop blocks waiting for new events, but if your application is drawing without returning control to the main loop, you may need to call this function explicitly. A common case where this function needs to be called is when an application is executing drawing commands from a thread other than the thread where the main loop is running. This is most useful for X11. On windowing systems where requests are handled synchronously, this function will do nothing. a #GdkDisplay Returns a #GdkAppLaunchContext suitable for launching applications on the given display. a new #GdkAppLaunchContext for @display. Free with g_object_unref() when done a #GdkDisplay Returns the default size to use for cursors on @display. the default cursor size. a #GdkDisplay Returns the default group leader window for all toplevel windows on @display. This window is implicitly created by GDK. See gdk_window_set_group(). The default group leader window for @display a #GdkDisplay Get the default #GdkScreen for @display. the default #GdkScreen object for @display a #GdkDisplay Returns the default #GdkSeat for this display. the default seat. a #GdkDisplay Returns the #GdkDeviceManager associated to @display. Use gdk_display_get_default_seat() and #GdkSeat operations. A #GdkDeviceManager, or %NULL. This memory is owned by GDK and must not be freed or unreferenced. a #GdkDisplay. Gets the next #GdkEvent to be processed for @display, fetching events from the windowing system if necessary. the next #GdkEvent to be processed, or %NULL if no events are pending. The returned #GdkEvent should be freed with gdk_event_free(). a #GdkDisplay Gets the maximal size to use for cursors on @display. a #GdkDisplay the return location for the maximal cursor width the return location for the maximal cursor height Gets a monitor associated with this display. the #GdkMonitor, or %NULL if @monitor_num is not a valid monitor number a #GdkDisplay number of the monitor Gets the monitor in which the point (@x, @y) is located, or a nearby monitor if the point is not in any monitor. the monitor containing the point a #GdkDisplay the x coordinate of the point the y coordinate of the point Gets the monitor in which the largest area of @window resides, or a monitor close to @window if it is outside of all monitors. the monitor with the largest overlap with @window a #GdkDisplay a #GdkWindow Gets the number of monitors that belong to @display. The returned number is valid until the next emission of the #GdkDisplay::monitor-added or #GdkDisplay::monitor-removed signal. the number of monitors a #GdkDisplay Gets the number of screen managed by the @display. The number of screens is always 1. number of screens. a #GdkDisplay Gets the name of the display. a string representing the display name. This string is owned by GDK and should not be modified or freed. a #GdkDisplay Gets the current location of the pointer and the current modifier mask for a given display. Use gdk_device_get_position() instead. a #GdkDisplay location to store the screen that the cursor is on, or %NULL. location to store root window X coordinate of pointer, or %NULL. location to store root window Y coordinate of pointer, or %NULL. location to store current modifier mask, or %NULL Gets the primary monitor for the display. The primary monitor is considered the monitor where the “main desktop” lives. While normal application windows typically allow the window manager to place the windows, specialized desktop applications such as panels should place themselves on the primary monitor. the primary monitor, or %NULL if no primary monitor is configured by the user a #GdkDisplay Returns a screen object for one of the screens of the display. There is only one screen; use gdk_display_get_default_screen() to get it. the #GdkScreen object a #GdkDisplay the screen number Obtains the window underneath the mouse pointer, returning the location of the pointer in that window in @win_x, @win_y for @screen. Returns %NULL if the window under the mouse pointer is not known to GDK (for example, belongs to another application). Use gdk_device_get_window_at_position() instead. the window under the mouse pointer, or %NULL a #GdkDisplay return location for x coordinate of the pointer location relative to the window origin, or %NULL return location for y coordinate of the pointer location relative & to the window origin, or %NULL Returns whether the display has events that are waiting to be processed. %TRUE if there are events ready to be processed. a #GdkDisplay Finds out if the display has been closed. %TRUE if the display is closed. a #GdkDisplay Release any keyboard grab Use gdk_device_ungrab(), together with gdk_device_grab() instead. a #GdkDisplay. a timestap (e.g #GDK_CURRENT_TIME). Returns the list of available input devices attached to @display. The list is statically allocated and should not be freed. Use gdk_device_manager_list_devices() instead. a list of #GdkDevice a #GdkDisplay Returns the list of seats known to @display. the list of seats known to the #GdkDisplay a #GdkDisplay Indicates to the GUI environment that the application has finished loading, using a given identifier. GTK+ will call this function automatically for #GtkWindow with custom startup-notification identifier unless gtk_window_set_auto_startup_notification() is called to disable that feature. a #GdkDisplay a startup-notification identifier, for which notification process should be completed Gets a copy of the first #GdkEvent in the @display’s event queue, without removing the event from the queue. (Note that this function will not get more events from the windowing system. It only checks the events that have already been moved to the GDK event queue.) a copy of the first #GdkEvent on the event queue, or %NULL if no events are in the queue. The returned #GdkEvent should be freed with gdk_event_free(). a #GdkDisplay Test if the pointer is grabbed. Use gdk_display_device_is_grabbed() instead. %TRUE if an active X pointer grab is in effect a #GdkDisplay Release any pointer grab. Use gdk_device_ungrab(), together with gdk_device_grab() instead. a #GdkDisplay. a timestap (e.g. %GDK_CURRENT_TIME). Appends a copy of the given event onto the front of the event queue for @display. a #GdkDisplay a #GdkEvent. Request #GdkEventOwnerChange events for ownership changes of the selection named by the given atom. whether #GdkEventOwnerChange events will be sent. a #GdkDisplay the #GdkAtom naming the selection for which ownership change notification is requested Sets the double click distance (two clicks within this distance count as a double click and result in a #GDK_2BUTTON_PRESS event). See also gdk_display_set_double_click_time(). Applications should not set this, it is a global user-configured setting. a #GdkDisplay distance in pixels Sets the double click time (two clicks within this time interval count as a double click and result in a #GDK_2BUTTON_PRESS event). Applications should not set this, it is a global user-configured setting. a #GdkDisplay double click time in milliseconds (thousandths of a second) Issues a request to the clipboard manager to store the clipboard data. On X11, this is a special program that works according to the [FreeDesktop Clipboard Specification](http://www.freedesktop.org/Standards/clipboard-manager-spec). a #GdkDisplay a #GdkWindow belonging to the clipboard owner a timestamp an array of targets that should be saved, or %NULL if all available targets should be saved. length of the @targets array Returns whether the speicifed display supports clipboard persistance; i.e. if it’s possible to store the clipboard data after an application has quit. On X11 this checks if a clipboard daemon is running. %TRUE if the display supports clipboard persistance. a #GdkDisplay Returns %TRUE if gdk_window_set_composited() can be used to redirect drawing on the window using compositing. Currently this only works on X11 with XComposite and XDamage extensions available. Compositing is an outdated technology that only ever worked on X11. %TRUE if windows may be composited. a #GdkDisplay Returns %TRUE if cursors can use an 8bit alpha channel on @display. Otherwise, cursors are restricted to bilevel alpha (i.e. a mask). whether cursors can have alpha channels. a #GdkDisplay Returns %TRUE if multicolored cursors are supported on @display. Otherwise, cursors have only a forground and a background color. whether cursors can have multiple colors. a #GdkDisplay Returns %TRUE if gdk_window_input_shape_combine_mask() can be used to modify the input shape of windows on @display. %TRUE if windows with modified input shape are supported a #GdkDisplay Returns whether #GdkEventOwnerChange events will be sent when the owner of a selection changes. whether #GdkEventOwnerChange events will be sent. a #GdkDisplay Returns %TRUE if gdk_window_shape_combine_mask() can be used to create shaped windows on @display. %TRUE if shaped windows are supported a #GdkDisplay Flushes any requests queued for the windowing system and waits until all requests have been handled. This is often used for making sure that the display is synchronized with the current state of the program. Calling gdk_display_sync() before gdk_error_trap_pop() makes sure that any errors generated from earlier requests are handled before the error trap is removed. This is most useful for X11. On windowing systems where requests are handled synchronously, this function will do nothing. a #GdkDisplay Warps the pointer of @display to the point @x,@y on the screen @screen, unless the pointer is confined to a window by a grab, in which case it will be moved as far as allowed by the grab. Warping the pointer creates events as if the user had moved the mouse instantaneously to the destination. Note that the pointer should normally be under the control of the user. This function was added to cover some rare use cases like keyboard navigation support for the color picker in the #GtkColorSelectionDialog. Use gdk_device_warp() instead. a #GdkDisplay the screen of @display to warp the pointer to the x coordinate of the destination the y coordinate of the destination The ::closed signal is emitted when the connection to the windowing system for @display is closed. %TRUE if the display was closed due to an error The ::monitor-added signal is emitted whenever a monitor is added. the monitor that was just added The ::monitor-removed signal is emitted whenever a monitor is removed. the monitor that was just removed The ::opened signal is emitted when the connection to the windowing system for @display is opened. The ::seat-added signal is emitted whenever a new seat is made known to the windowing system. the seat that was just added The ::seat-removed signal is emitted whenever a seat is removed by the windowing system. the seat that was just removed The purpose of the #GdkDisplayManager singleton object is to offer notification when displays appear or disappear or the default display changes. You can use gdk_display_manager_get() to obtain the #GdkDisplayManager singleton, but that should be rarely necessary. Typically, initializing GTK+ opens a display that you can work with without ever accessing the #GdkDisplayManager. The GDK library can be built with support for multiple backends. The #GdkDisplayManager object determines which backend is used at runtime. When writing backend-specific code that is supposed to work with multiple GDK backends, you have to consider both compile time and runtime. At compile time, use the #GDK_WINDOWING_X11, #GDK_WINDOWING_WIN32 macros, etc. to find out which backends are present in the GDK library you are building your application against. At runtime, use type-check macros like GDK_IS_X11_DISPLAY() to find out which backend is in use: ## Backend-specific code ## {#backend-specific} |[<!-- language="C" --> #ifdef GDK_WINDOWING_X11 if (GDK_IS_X11_DISPLAY (display)) { // make X11-specific calls here } else #endif #ifdef GDK_WINDOWING_QUARTZ if (GDK_IS_QUARTZ_DISPLAY (display)) { // make Quartz-specific calls here } else #endif g_error ("Unsupported GDK backend"); ]| Gets the singleton #GdkDisplayManager object. When called for the first time, this function consults the `GDK_BACKEND` environment variable to find out which of the supported GDK backends to use (in case GDK has been compiled with multiple backends). Applications can use gdk_set_allowed_backends() to limit what backends can be used. The global #GdkDisplayManager singleton; gdk_parse_args(), gdk_init(), or gdk_init_check() must have been called first. Gets the default #GdkDisplay. a #GdkDisplay, or %NULL if there is no default display. a #GdkDisplayManager List all currently open displays. a newly allocated #GSList of #GdkDisplay objects. Free with g_slist_free() when you are done with it. a #GdkDisplayManager Opens a display. a #GdkDisplay, or %NULL if the display could not be opened a #GdkDisplayManager the name of the display to open Sets @display as the default display. a #GdkDisplayManager a #GdkDisplay The ::display-opened signal is emitted when a display is opened. the opened display Used in #GdkDragContext to indicate what the destination should do with the dropped data. Means nothing, and should not be used. Copy the data. Move the data, i.e. first copy it, then delete it from the source using the DELETE target of the X selection protocol. Add a link to the data. Note that this is only useful if source and destination agree on what it means. Special action which tells the source that the destination will do something that the source doesn’t understand. Ask the user what to do with the data. Used in #GdkDragContext to the reason of a cancelled DND operation. There is no suitable drop target. Drag cancelled by the user Unspecified error. Determines the bitmask of actions proposed by the source if gdk_drag_context_get_suggested_action() returns %GDK_ACTION_ASK. the #GdkDragAction flags a #GdkDragContext Returns the destination window for the DND operation. a #GdkWindow a #GdkDragContext Returns the #GdkDevice associated to the drag context. The #GdkDevice associated to @context. a #GdkDragContext Returns the window on which the drag icon should be rendered during the drag operation. Note that the window may not be available until the drag operation has begun. GDK will move the window in accordance with the ongoing drag operation. The window is owned by @context and will be destroyed when the drag operation is over. the drag window, or %NULL a #GdkDragContext Returns the drag protocol that is used by this context. the drag protocol a #GdkDragContext Determines the action chosen by the drag destination. a #GdkDragAction value a #GdkDragContext Returns the #GdkWindow where the DND operation started. a #GdkWindow a #GdkDragContext Determines the suggested drag action of the context. a #GdkDragAction value a #GdkDragContext Retrieves the list of targets of the context. a #GList of targets a #GdkDragContext Requests the drag and drop operation to be managed by @context. When a drag and drop operation becomes managed, the #GdkDragContext will internally handle all input and source-side #GdkEventDND events as required by the windowing system. Once the drag and drop operation is managed, the drag context will emit the following signals: - The #GdkDragContext::action-changed signal whenever the final action to be performed by the drag and drop operation changes. - The #GdkDragContext::drop-performed signal after the user performs the drag and drop gesture (typically by releasing the mouse button). - The #GdkDragContext::dnd-finished signal after the drag and drop operation concludes (after all #GdkSelection transfers happen). - The #GdkDragContext::cancel signal if the drag and drop operation is finished but doesn't happen over an accepting destination, or is cancelled through other means. #TRUE if the drag and drop operation is managed. a #GdkDragContext Window to use for IPC messaging/events the actions supported by the drag source Associates a #GdkDevice to @context, so all Drag and Drop events for @context are emitted as if they came from this device. a #GdkDragContext a #GdkDevice Sets the position of the drag window that will be kept under the cursor hotspot. Initially, the hotspot is at the top left corner of the drag window. a #GdkDragContext x coordinate of the drag window hotspot y coordinate of the drag window hotspot A new action is being chosen for the drag and drop operation. This signal will only be emitted if the #GdkDragContext manages the drag and drop operation. See gdk_drag_context_manage_dnd() for more information. The action currently chosen The drag and drop operation was cancelled. This signal will only be emitted if the #GdkDragContext manages the drag and drop operation. See gdk_drag_context_manage_dnd() for more information. The reason the context was cancelled The drag and drop operation was finished, the drag destination finished reading all data. The drag source can now free all miscellaneous data. This signal will only be emitted if the #GdkDragContext manages the drag and drop operation. See gdk_drag_context_manage_dnd() for more information. The drag and drop operation was performed on an accepting client. This signal will only be emitted if the #GdkDragContext manages the drag and drop operation. See gdk_drag_context_manage_dnd() for more information. the time at which the drop happened. Used in #GdkDragContext to indicate the protocol according to which DND is done. no protocol. The Motif DND protocol. No longer supported The Xdnd protocol. An extension to the Xdnd protocol for unclaimed root window drops. The simple WM_DROPFILES protocol. The complex OLE2 DND protocol (not implemented). Intra-application DND. Wayland DND protocol. #GdkDrawingContext is an object that represents the current drawing state of a #GdkWindow. It's possible to use a #GdkDrawingContext to draw on a #GdkWindow via rendering API like Cairo or OpenGL. A #GdkDrawingContext can only be created by calling gdk_window_begin_draw_frame() and will be valid until a call to gdk_window_end_draw_frame(). #GdkDrawingContext is available since GDK 3.22 Retrieves a Cairo context to be used to draw on the #GdkWindow that created the #GdkDrawingContext. The returned context is guaranteed to be valid as long as the #GdkDrawingContext is valid, that is between a call to gdk_window_begin_draw_frame() and gdk_window_end_draw_frame(). a Cairo context to be used to draw the contents of the #GdkWindow. The context is owned by the #GdkDrawingContext and should not be destroyed Retrieves a copy of the clip region used when creating the @context. a Cairo region a #GdkDrawingContext Retrieves the window that created the drawing @context. a #GdkWindow a #GdkDrawingContext Checks whether the given #GdkDrawingContext is valid. %TRUE if the context is valid a #GdkDrawingContext The clip region applied to the drawing context. The #GdkWindow that created the drawing context. Use this macro as the return value for continuing the propagation of an event handler. Use this macro as the return value for stopping the propagation of an event handler. A #GdkEvent contains a union of all of the event types, and allows access to the data fields in a number of ways. The event type is always the first field in all of the event types, and can always be accessed with the following code, no matter what type of event it is: |[<!-- language="C" --> GdkEvent *event; GdkEventType type; type = event->type; ]| To access other fields of the event, the pointer to the event can be cast to the appropriate event type, or the union member name can be used. For example if the event type is %GDK_BUTTON_PRESS then the x coordinate of the button press can be accessed with: |[<!-- language="C" --> GdkEvent *event; gdouble x; x = ((GdkEventButton*)event)->x; ]| or: |[<!-- language="C" --> GdkEvent *event; gdouble x; x = event->button.x; ]| the #GdkEventType a #GdkEventAny a #GdkEventExpose a #GdkEventVisibility a #GdkEventMotion a #GdkEventButton a #GdkEventTouch a #GdkEventScroll a #GdkEventKey a #GdkEventCrossing a #GdkEventFocus a #GdkEventConfigure a #GdkEventProperty a #GdkEventSelection a #GdkEventOwnerChange a #GdkEventProximity a #GdkEventDND a #GdkEventWindowState a #GdkEventSetting a #GdkEventGrabBroken a #GdkEventTouchpadSwipe a #GdkEventTouchpadPinch a #GdkEventPadButton a #GdkEventPadAxis a #GdkEventPadGroupMode Creates a new event of the given type. All fields are set to 0. a newly-allocated #GdkEvent. The returned #GdkEvent should be freed with gdk_event_free(). a #GdkEventType If both events contain X/Y information, this function will return %TRUE and return in @angle the relative angle from @event1 to @event2. The rotation direction for positive angles is from the positive X axis towards the positive Y axis. %TRUE if the angle could be calculated. first #GdkEvent second #GdkEvent return location for the relative angle between both events If both events contain X/Y information, the center of both coordinates will be returned in @x and @y. %TRUE if the center could be calculated. first #GdkEvent second #GdkEvent return location for the X coordinate of the center return location for the Y coordinate of the center If both events have X/Y information, the distance between both coordinates (as in a straight line going from @event1 to @event2) will be returned. %TRUE if the distance could be calculated. first #GdkEvent second #GdkEvent return location for the distance Copies a #GdkEvent, copying or incrementing the reference count of the resources associated with it (e.g. #GdkWindow’s and strings). a copy of @event. The returned #GdkEvent should be freed with gdk_event_free(). a #GdkEvent Frees a #GdkEvent, freeing or decrementing any resources associated with it. Note that this function should only be called with events returned from functions such as gdk_event_peek(), gdk_event_get(), gdk_event_copy() and gdk_event_new(). a #GdkEvent. Extract the axis value for a particular axis use from an event structure. %TRUE if the specified axis was found, otherwise %FALSE a #GdkEvent the axis use to look for location to store the value found Extract the button number from an event. %TRUE if the event delivered a button number a #GdkEvent location to store mouse button number Extracts the click count from an event. %TRUE if the event delivered a click count a #GdkEvent location to store click count Extract the event window relative x/y coordinates from an event. %TRUE if the event delivered event window coordinates a #GdkEvent location to put event window x coordinate location to put event window y coordinate If the event contains a “device” field, this function will return it, else it will return %NULL. a #GdkDevice, or %NULL. a #GdkEvent. If the event was generated by a device that supports different tools (eg. a tablet), this function will return a #GdkDeviceTool representing the tool that caused the event. Otherwise, %NULL will be returned. Note: the #GdkDeviceTool<!-- -->s will be constant during the application lifetime, if settings must be stored persistently across runs, see gdk_device_tool_get_serial() The current device tool, or %NULL a #GdkEvent If @event if of type %GDK_TOUCH_BEGIN, %GDK_TOUCH_UPDATE, %GDK_TOUCH_END or %GDK_TOUCH_CANCEL, returns the #GdkEventSequence to which the event belongs. Otherwise, return %NULL. the event sequence that the event belongs to a #GdkEvent Retrieves the type of the event. a #GdkEventType a #GdkEvent Extracts the hardware keycode from an event. Also see gdk_event_get_scancode(). %TRUE if the event delivered a hardware keycode a #GdkEvent location to store the keycode Extracts the keyval from an event. %TRUE if the event delivered a key symbol a #GdkEvent location to store the keyval #event: a #GdkEvent Returns whether this event is an 'emulated' pointer event (typically from a touch event), as opposed to a real one. %TRUE if this event is emulated Extract the root window relative x/y coordinates from an event. %TRUE if the event delivered root window coordinates a #GdkEvent location to put root window x coordinate location to put root window y coordinate Gets the keyboard low-level scancode of a key event. This is usually hardware_keycode. On Windows this is the high word of WM_KEY{DOWN,UP} lParam which contains the scancode and some extended flags. The associated keyboard scancode or 0 a #GdkEvent Returns the screen for the event. The screen is typically the screen for `event->any.window`, but for events such as mouse events, it is the screen where the pointer was when the event occurs - that is, the screen which has the root window to which `event->motion.x_root` and `event->motion.y_root` are relative. the screen for the event a #GdkEvent Retrieves the scroll deltas from a #GdkEvent See also: gdk_event_get_scroll_direction() %TRUE if the event contains smooth scroll information and %FALSE otherwise a #GdkEvent return location for X delta return location for Y delta Extracts the scroll direction from an event. If @event is not of type %GDK_SCROLL, the contents of @direction are undefined. If you wish to handle both discrete and smooth scrolling, you should check the return value of this function, or of gdk_event_get_scroll_deltas(); for instance: |[<!-- language="C" --> GdkScrollDirection direction; double vscroll_factor = 0.0; double x_scroll, y_scroll; if (gdk_event_get_scroll_direction (event, &direction)) { // Handle discrete scrolling with a known constant delta; const double delta = 12.0; switch (direction) { case GDK_SCROLL_UP: vscroll_factor = -delta; break; case GDK_SCROLL_DOWN: vscroll_factor = delta; break; default: // no scrolling break; } } else if (gdk_event_get_scroll_deltas (event, &x_scroll, &y_scroll)) { // Handle smooth scrolling directly vscroll_factor = y_scroll; } ]| %TRUE if the event delivered a scroll direction and %FALSE otherwise a #GdkEvent location to store the scroll direction Returns the #GdkSeat this event was generated for. The #GdkSeat of this event a #GdkEvent This function returns the hardware (slave) #GdkDevice that has triggered the event, falling back to the virtual (master) device (as in gdk_event_get_device()) if the event wasn’t caused by interaction with a hardware device. This may happen for example in synthesized crossing events after a #GdkWindow updates its geometry or a grab is acquired/released. If the event does not contain a device field, this function will return %NULL. a #GdkDevice, or %NULL. a #GdkEvent If the event contains a “state” field, puts that field in @state. Otherwise stores an empty state (0). Returns %TRUE if there was a state field in the event. @event may be %NULL, in which case it’s treated as if the event had no state field. %TRUE if there was a state field in the event a #GdkEvent or %NULL return location for state Returns the time stamp from @event, if there is one; otherwise returns #GDK_CURRENT_TIME. If @event is %NULL, returns #GDK_CURRENT_TIME. time stamp field from @event a #GdkEvent Extracts the #GdkWindow associated with an event. The #GdkWindow associated with the event a #GdkEvent Check whether a scroll event is a stop scroll event. Scroll sequences with smooth scroll information may provide a stop scroll event once the interaction with the device finishes, e.g. by lifting a finger. This stop scroll event is the signal that a widget may trigger kinetic scrolling based on the current velocity. Stop scroll events always have a a delta of 0/0. %TRUE if the event is a scroll stop event a #GdkEvent Appends a copy of the given event onto the front of the event queue for event->any.window’s display, or the default event queue if event->any.window is %NULL. See gdk_display_put_event(). a #GdkEvent. Sets the device for @event to @device. The event must have been allocated by GTK+, for instance, by gdk_event_copy(). a #GdkEvent a #GdkDevice Sets the device tool for this event, should be rarely used. a #GdkEvent tool to set on the event, or %NULL Sets the screen for @event to @screen. The event must have been allocated by GTK+, for instance, by gdk_event_copy(). a #GdkEvent a #GdkScreen Sets the slave device for @event to @device. The event must have been allocated by GTK+, for instance by gdk_event_copy(). a #GdkEvent a #GdkDevice This function returns whether a #GdkEventButton should trigger a context menu, according to platform conventions. The right mouse button always triggers context menus. Additionally, if gdk_keymap_get_modifier_mask() returns a non-0 mask for %GDK_MODIFIER_INTENT_CONTEXT_MENU, then the left mouse button will also trigger a context menu if this modifier is pressed. This function should always be used instead of simply checking for event->button == %GDK_BUTTON_SECONDARY. %TRUE if the event should trigger a context menu. a #GdkEvent, currently only button events are meaningful values Checks all open displays for a #GdkEvent to process,to be processed on, fetching events from the windowing system if necessary. See gdk_display_get_event(). the next #GdkEvent to be processed, or %NULL if no events are pending. The returned #GdkEvent should be freed with gdk_event_free(). Sets the function to call to handle all events from GDK. Note that GTK+ uses this to install its own event handler, so it is usually not useful for GTK+ applications. (Although an application can call this function then call gtk_main_do_event() to pass events to GTK+.) the function to call to handle events from GDK. user data to pass to the function. the function to call when the handler function is removed, i.e. when gdk_event_handler_set() is called with another event handler. If there is an event waiting in the event queue of some open display, returns a copy of it. See gdk_display_peek_event(). a copy of the first #GdkEvent on some event queue, or %NULL if no events are in any queues. The returned #GdkEvent should be freed with gdk_event_free(). Request more motion notifies if @event is a motion notify hint event. This function should be used instead of gdk_window_get_pointer() to request further motion notifies, because it also works for extension events where motion notifies are provided for devices other than the core pointer. Coordinate extraction, processing and requesting more motion events from a %GDK_MOTION_NOTIFY event usually works like this: |[<!-- language="C" --> { // motion_event handler x = motion_event->x; y = motion_event->y; // handle (x,y) motion gdk_event_request_motions (motion_event); // handles is_hint events } ]| a valid #GdkEvent Contains the fields which are common to all event structs. Any event pointer can safely be cast to a pointer to a #GdkEventAny to access these fields. the type of the event. the window which received the event. %TRUE if the event was sent explicitly. Used for button press and button release events. The @type field will be one of %GDK_BUTTON_PRESS, %GDK_2BUTTON_PRESS, %GDK_3BUTTON_PRESS or %GDK_BUTTON_RELEASE, Double and triple-clicks result in a sequence of events being received. For double-clicks the order of events will be: - %GDK_BUTTON_PRESS - %GDK_BUTTON_RELEASE - %GDK_BUTTON_PRESS - %GDK_2BUTTON_PRESS - %GDK_BUTTON_RELEASE Note that the first click is received just like a normal button press, while the second click results in a %GDK_2BUTTON_PRESS being received just after the %GDK_BUTTON_PRESS. Triple-clicks are very similar to double-clicks, except that %GDK_3BUTTON_PRESS is inserted after the third click. The order of the events is: - %GDK_BUTTON_PRESS - %GDK_BUTTON_RELEASE - %GDK_BUTTON_PRESS - %GDK_2BUTTON_PRESS - %GDK_BUTTON_RELEASE - %GDK_BUTTON_PRESS - %GDK_3BUTTON_PRESS - %GDK_BUTTON_RELEASE For a double click to occur, the second button press must occur within 1/4 of a second of the first. For a triple click to occur, the third button press must also occur within 1/2 second of the first button press. the type of the event (%GDK_BUTTON_PRESS, %GDK_2BUTTON_PRESS, %GDK_3BUTTON_PRESS or %GDK_BUTTON_RELEASE). the window which received the event. %TRUE if the event was sent explicitly. the time of the event in milliseconds. the x coordinate of the pointer relative to the window. the y coordinate of the pointer relative to the window. @x, @y translated to the axes of @device, or %NULL if @device is the mouse. a bit-mask representing the state of the modifier keys (e.g. Control, Shift and Alt) and the pointer buttons. See #GdkModifierType. the button which was pressed or released, numbered from 1 to 5. Normally button 1 is the left mouse button, 2 is the middle button, and 3 is the right button. On 2-button mice, the middle button can often be simulated by pressing both mouse buttons together. the master device that the event originated from. Use gdk_event_get_source_device() to get the slave device. the x coordinate of the pointer relative to the root of the screen. the y coordinate of the pointer relative to the root of the screen. Generated when a window size or position has changed. the type of the event (%GDK_CONFIGURE). the window which received the event. %TRUE if the event was sent explicitly. the new x coordinate of the window, relative to its parent. the new y coordinate of the window, relative to its parent. the new width of the window. the new height of the window. Generated when the pointer enters or leaves a window. the type of the event (%GDK_ENTER_NOTIFY or %GDK_LEAVE_NOTIFY). the window which received the event. %TRUE if the event was sent explicitly. the window that was entered or left. the time of the event in milliseconds. the x coordinate of the pointer relative to the window. the y coordinate of the pointer relative to the window. the x coordinate of the pointer relative to the root of the screen. the y coordinate of the pointer relative to the root of the screen. the crossing mode (%GDK_CROSSING_NORMAL, %GDK_CROSSING_GRAB, %GDK_CROSSING_UNGRAB, %GDK_CROSSING_GTK_GRAB, %GDK_CROSSING_GTK_UNGRAB or %GDK_CROSSING_STATE_CHANGED). %GDK_CROSSING_GTK_GRAB, %GDK_CROSSING_GTK_UNGRAB, and %GDK_CROSSING_STATE_CHANGED were added in 2.14 and are always synthesized, never native. the kind of crossing that happened (%GDK_NOTIFY_INFERIOR, %GDK_NOTIFY_ANCESTOR, %GDK_NOTIFY_VIRTUAL, %GDK_NOTIFY_NONLINEAR or %GDK_NOTIFY_NONLINEAR_VIRTUAL). %TRUE if @window is the focus window or an inferior. a bit-mask representing the state of the modifier keys (e.g. Control, Shift and Alt) and the pointer buttons. See #GdkModifierType. Generated during DND operations. the type of the event (%GDK_DRAG_ENTER, %GDK_DRAG_LEAVE, %GDK_DRAG_MOTION, %GDK_DRAG_STATUS, %GDK_DROP_START or %GDK_DROP_FINISHED). the window which received the event. %TRUE if the event was sent explicitly. the #GdkDragContext for the current DND operation. the time of the event in milliseconds. the x coordinate of the pointer relative to the root of the screen, only set for %GDK_DRAG_MOTION and %GDK_DROP_START. the y coordinate of the pointer relative to the root of the screen, only set for %GDK_DRAG_MOTION and %GDK_DROP_START. Generated when all or part of a window becomes visible and needs to be redrawn. the type of the event (%GDK_EXPOSE or %GDK_DAMAGE). the window which received the event. %TRUE if the event was sent explicitly. bounding box of @region. the region that needs to be redrawn. the number of contiguous %GDK_EXPOSE events following this one. The only use for this is “exposure compression”, i.e. handling all contiguous %GDK_EXPOSE events in one go, though GDK performs some exposure compression so this is not normally needed. Describes a change of keyboard focus. the type of the event (%GDK_FOCUS_CHANGE). the window which received the event. %TRUE if the event was sent explicitly. %TRUE if the window has gained the keyboard focus, %FALSE if it has lost the focus. Specifies the type of function passed to gdk_event_handler_set() to handle all GDK events. the #GdkEvent to process. user data set when the event handler was installed with gdk_event_handler_set(). Generated when a pointer or keyboard grab is broken. On X11, this happens when the grab window becomes unviewable (i.e. it or one of its ancestors is unmapped), or if the same application grabs the pointer or keyboard again. Note that implicit grabs (which are initiated by button presses) can also cause #GdkEventGrabBroken events. the type of the event (%GDK_GRAB_BROKEN) the window which received the event, i.e. the window that previously owned the grab %TRUE if the event was sent explicitly. %TRUE if a keyboard grab was broken, %FALSE if a pointer grab was broken %TRUE if the broken grab was implicit If this event is caused by another grab in the same application, @grab_window contains the new grab window. Otherwise @grab_window is %NULL. Describes a key press or key release event. the type of the event (%GDK_KEY_PRESS or %GDK_KEY_RELEASE). the window which received the event. %TRUE if the event was sent explicitly. the time of the event in milliseconds. a bit-mask representing the state of the modifier keys (e.g. Control, Shift and Alt) and the pointer buttons. See #GdkModifierType. the key that was pressed or released. See the `gdk/gdkkeysyms.h` header file for a complete list of GDK key codes. the length of @string. a string containing an approximation of the text that would result from this keypress. The only correct way to handle text input of text is using input methods (see #GtkIMContext), so this field is deprecated and should never be used. (gdk_unicode_to_keyval() provides a non-deprecated way of getting an approximate translation for a key.) The string is encoded in the encoding of the current locale (Note: this for backwards compatibility: strings in GTK+ and GDK are typically in UTF-8.) and NUL-terminated. In some cases, the translation of the key code will be a single NUL byte, in which case looking at @length is necessary to distinguish it from the an empty translation. the raw code of the key that was pressed or released. the keyboard group. a flag that indicates if @hardware_keycode is mapped to a modifier. Since 2.10 A set of bit-flags to indicate which events a window is to receive. Most of these masks map onto one or more of the #GdkEventType event types above. See the [input handling overview][chap-input-handling] for details of [event masks][event-masks] and [event propagation][event-propagation]. %GDK_POINTER_MOTION_HINT_MASK is deprecated. It is a special mask to reduce the number of %GDK_MOTION_NOTIFY events received. When using %GDK_POINTER_MOTION_HINT_MASK, fewer %GDK_MOTION_NOTIFY events will be sent, some of which are marked as a hint (the is_hint member is %TRUE). To receive more motion events after a motion hint event, the application needs to asks for more, by calling gdk_event_request_motions(). Since GTK 3.8, motion events are already compressed by default, independent of this mechanism. This compression can be disabled with gdk_window_set_event_compression(). See the documentation of that function for details. If %GDK_TOUCH_MASK is enabled, the window will receive touch events from touch-enabled devices. Those will come as sequences of #GdkEventTouch with type %GDK_TOUCH_UPDATE, enclosed by two events with type %GDK_TOUCH_BEGIN and %GDK_TOUCH_END (or %GDK_TOUCH_CANCEL). gdk_event_get_event_sequence() returns the event sequence for these events, so different sequences may be distinguished. receive expose events receive all pointer motion events deprecated. see the explanation above receive pointer motion events while any button is pressed receive pointer motion events while 1 button is pressed receive pointer motion events while 2 button is pressed receive pointer motion events while 3 button is pressed receive button press events receive button release events receive key press events receive key release events receive window enter events receive window leave events receive focus change events receive events about window configuration change receive property change events receive visibility change events receive proximity in events receive proximity out events receive events about window configuration changes of child windows receive scroll events receive touch events. Since 3.4 receive smooth scrolling events. Since 3.4 receive touchpad gesture events. Since 3.18 receive tablet pad events. Since 3.22 the combination of all the above event masks. Generated when the pointer moves. the type of the event. the window which received the event. %TRUE if the event was sent explicitly. the time of the event in milliseconds. the x coordinate of the pointer relative to the window. the y coordinate of the pointer relative to the window. @x, @y translated to the axes of @device, or %NULL if @device is the mouse. a bit-mask representing the state of the modifier keys (e.g. Control, Shift and Alt) and the pointer buttons. See #GdkModifierType. set to 1 if this event is just a hint, see the %GDK_POINTER_MOTION_HINT_MASK value of #GdkEventMask. the master device that the event originated from. Use gdk_event_get_source_device() to get the slave device. the x coordinate of the pointer relative to the root of the screen. the y coordinate of the pointer relative to the root of the screen. Generated when the owner of a selection changes. On X11, this information is only available if the X server supports the XFIXES extension. the type of the event (%GDK_OWNER_CHANGE). the window which received the event %TRUE if the event was sent explicitly. the new owner of the selection, or %NULL if there is none the reason for the ownership change as a #GdkOwnerChange value the atom identifying the selection the timestamp of the event the time at which the selection ownership was taken over Generated during %GDK_SOURCE_TABLET_PAD interaction with tactile sensors. the type of the event (%GDK_PAD_RING or %GDK_PAD_STRIP). the window which received the event. %TRUE if the event was sent explicitly. the time of the event in milliseconds. the pad group the ring/strip belongs to. A %GDK_SOURCE_TABLET_PAD device may have one or more groups containing a set of buttons/rings/strips each. number of strip/ring that was interacted. This number is 0-indexed. The current mode of @group. Different groups in a %GDK_SOURCE_TABLET_PAD device may have different current modes. The current value for the given axis. Generated during %GDK_SOURCE_TABLET_PAD button presses and releases. the type of the event (%GDK_PAD_BUTTON_PRESS or %GDK_PAD_BUTTON_RELEASE). the window which received the event. %TRUE if the event was sent explicitly. the time of the event in milliseconds. the pad group the button belongs to. A %GDK_SOURCE_TABLET_PAD device may have one or more groups containing a set of buttons/rings/strips each. The pad button that was pressed. The current mode of @group. Different groups in a %GDK_SOURCE_TABLET_PAD device may have different current modes. Generated during %GDK_SOURCE_TABLET_PAD mode switches in a group. the type of the event (%GDK_PAD_GROUP_MODE). the window which received the event. %TRUE if the event was sent explicitly. the time of the event in milliseconds. the pad group that is switching mode. A %GDK_SOURCE_TABLET_PAD device may have one or more groups containing a set of buttons/rings/strips each. The new mode of @group. Different groups in a %GDK_SOURCE_TABLET_PAD device may have different current modes. Describes a property change on a window. the type of the event (%GDK_PROPERTY_NOTIFY). the window which received the event. %TRUE if the event was sent explicitly. the property that was changed. the time of the event in milliseconds. whether the property was changed (%GDK_PROPERTY_NEW_VALUE) or deleted (%GDK_PROPERTY_DELETE). Proximity events are generated when using GDK’s wrapper for the XInput extension. The XInput extension is an add-on for standard X that allows you to use nonstandard devices such as graphics tablets. A proximity event indicates that the stylus has moved in or out of contact with the tablet, or perhaps that the user’s finger has moved in or out of contact with a touch screen. This event type will be used pretty rarely. It only is important for XInput aware programs that are drawing their own cursor. the type of the event (%GDK_PROXIMITY_IN or %GDK_PROXIMITY_OUT). the window which received the event. %TRUE if the event was sent explicitly. the time of the event in milliseconds. the master device that the event originated from. Use gdk_event_get_source_device() to get the slave device. Generated from button presses for the buttons 4 to 7. Wheel mice are usually configured to generate button press events for buttons 4 and 5 when the wheel is turned. Some GDK backends can also generate “smooth” scroll events, which can be recognized by the %GDK_SCROLL_SMOOTH scroll direction. For these, the scroll deltas can be obtained with gdk_event_get_scroll_deltas(). the type of the event (%GDK_SCROLL). the window which received the event. %TRUE if the event was sent explicitly. the time of the event in milliseconds. the x coordinate of the pointer relative to the window. the y coordinate of the pointer relative to the window. a bit-mask representing the state of the modifier keys (e.g. Control, Shift and Alt) and the pointer buttons. See #GdkModifierType. the direction to scroll to (one of %GDK_SCROLL_UP, %GDK_SCROLL_DOWN, %GDK_SCROLL_LEFT, %GDK_SCROLL_RIGHT or %GDK_SCROLL_SMOOTH). the master device that the event originated from. Use gdk_event_get_source_device() to get the slave device. the x coordinate of the pointer relative to the root of the screen. the y coordinate of the pointer relative to the root of the screen. the x coordinate of the scroll delta the y coordinate of the scroll delta Generated when a selection is requested or ownership of a selection is taken over by another client application. the type of the event (%GDK_SELECTION_CLEAR, %GDK_SELECTION_NOTIFY or %GDK_SELECTION_REQUEST). the window which received the event. %TRUE if the event was sent explicitly. the selection. the target to which the selection should be converted. the property in which to place the result of the conversion. the time of the event in milliseconds. the window on which to place @property or %NULL if none. Generated when a setting is modified. the type of the event (%GDK_SETTING). the window which received the event. %TRUE if the event was sent explicitly. what happened to the setting (%GDK_SETTING_ACTION_NEW, %GDK_SETTING_ACTION_CHANGED or %GDK_SETTING_ACTION_DELETED). the name of the setting. Used for touch events. @type field will be one of %GDK_TOUCH_BEGIN, %GDK_TOUCH_UPDATE, %GDK_TOUCH_END or %GDK_TOUCH_CANCEL. Touch events are grouped into sequences by means of the @sequence field, which can also be obtained with gdk_event_get_event_sequence(). Each sequence begins with a %GDK_TOUCH_BEGIN event, followed by any number of %GDK_TOUCH_UPDATE events, and ends with a %GDK_TOUCH_END (or %GDK_TOUCH_CANCEL) event. With multitouch devices, there may be several active sequences at the same time. the type of the event (%GDK_TOUCH_BEGIN, %GDK_TOUCH_UPDATE, %GDK_TOUCH_END, %GDK_TOUCH_CANCEL) the window which received the event %TRUE if the event was sent explicitly. the time of the event in milliseconds. the x coordinate of the pointer relative to the window the y coordinate of the pointer relative to the window @x, @y translated to the axes of @device, or %NULL if @device is the mouse a bit-mask representing the state of the modifier keys (e.g. Control, Shift and Alt) and the pointer buttons. See #GdkModifierType the event sequence that the event belongs to whether the event should be used for emulating pointer event the master device that the event originated from. Use gdk_event_get_source_device() to get the slave device. the x coordinate of the pointer relative to the root of the screen the y coordinate of the pointer relative to the root of the screen Generated during touchpad swipe gestures. the type of the event (%GDK_TOUCHPAD_PINCH) the window which received the event %TRUE if the event was sent explicitly the current phase of the gesture The number of fingers triggering the pinch the time of the event in milliseconds The X coordinate of the pointer The Y coordinate of the pointer Movement delta in the X axis of the swipe focal point Movement delta in the Y axis of the swipe focal point The angle change in radians, negative angles denote counter-clockwise movements The current scale, relative to that at the time of the corresponding %GDK_TOUCHPAD_GESTURE_PHASE_BEGIN event The X coordinate of the pointer, relative to the root of the screen. The Y coordinate of the pointer, relative to the root of the screen. a bit-mask representing the state of the modifier keys (e.g. Control, Shift and Alt) and the pointer buttons. See #GdkModifierType. Generated during touchpad swipe gestures. the type of the event (%GDK_TOUCHPAD_SWIPE) the window which received the event %TRUE if the event was sent explicitly the current phase of the gesture The number of fingers triggering the swipe the time of the event in milliseconds The X coordinate of the pointer The Y coordinate of the pointer Movement delta in the X axis of the swipe focal point Movement delta in the Y axis of the swipe focal point The X coordinate of the pointer, relative to the root of the screen. The Y coordinate of the pointer, relative to the root of the screen. a bit-mask representing the state of the modifier keys (e.g. Control, Shift and Alt) and the pointer buttons. See #GdkModifierType. Specifies the type of the event. Do not confuse these events with the signals that GTK+ widgets emit. Although many of these events result in corresponding signals being emitted, the events are often transformed or filtered along the way. In some language bindings, the values %GDK_2BUTTON_PRESS and %GDK_3BUTTON_PRESS would translate into something syntactically invalid (eg `Gdk.EventType.2ButtonPress`, where a symbol is not allowed to start with a number). In that case, the aliases %GDK_DOUBLE_BUTTON_PRESS and %GDK_TRIPLE_BUTTON_PRESS can be used instead. a special code to indicate a null event. the window manager has requested that the toplevel window be hidden or destroyed, usually when the user clicks on a special icon in the title bar. the window has been destroyed. all or part of the window has become visible and needs to be redrawn. the pointer (usually a mouse) has moved. a mouse button has been pressed. a mouse button has been double-clicked (clicked twice within a short period of time). Note that each click also generates a %GDK_BUTTON_PRESS event. alias for %GDK_2BUTTON_PRESS, added in 3.6. a mouse button has been clicked 3 times in a short period of time. Note that each click also generates a %GDK_BUTTON_PRESS event. alias for %GDK_3BUTTON_PRESS, added in 3.6. a mouse button has been released. a key has been pressed. a key has been released. the pointer has entered the window. the pointer has left the window. the keyboard focus has entered or left the window. the size, position or stacking order of the window has changed. Note that GTK+ discards these events for %GDK_WINDOW_CHILD windows. the window has been mapped. the window has been unmapped. a property on the window has been changed or deleted. the application has lost ownership of a selection. another application has requested a selection. a selection has been received. an input device has moved into contact with a sensing surface (e.g. a touchscreen or graphics tablet). an input device has moved out of contact with a sensing surface. the mouse has entered the window while a drag is in progress. the mouse has left the window while a drag is in progress. the mouse has moved in the window while a drag is in progress. the status of the drag operation initiated by the window has changed. a drop operation onto the window has started. the drop operation initiated by the window has completed. a message has been received from another application. the window visibility status has changed. the scroll wheel was turned the state of a window has changed. See #GdkWindowState for the possible window states a setting has been modified. the owner of a selection has changed. This event type was added in 2.6 a pointer or keyboard grab was broken. This event type was added in 2.8. the content of the window has been changed. This event type was added in 2.14. A new touch event sequence has just started. This event type was added in 3.4. A touch event sequence has been updated. This event type was added in 3.4. A touch event sequence has finished. This event type was added in 3.4. A touch event sequence has been canceled. This event type was added in 3.4. A touchpad swipe gesture event, the current state is determined by its phase field. This event type was added in 3.18. A touchpad pinch gesture event, the current state is determined by its phase field. This event type was added in 3.18. A tablet pad button press event. This event type was added in 3.22. A tablet pad button release event. This event type was added in 3.22. A tablet pad axis event from a "ring". This event type was added in 3.22. A tablet pad axis event from a "strip". This event type was added in 3.22. A tablet pad group mode change. This event type was added in 3.22. marks the end of the GdkEventType enumeration. Added in 2.18 Generated when the window visibility status has changed. Modern composited windowing systems with pervasive transparency make it impossible to track the visibility of a window reliably, so this event can not be guaranteed to provide useful information. the type of the event (%GDK_VISIBILITY_NOTIFY). the window which received the event. %TRUE if the event was sent explicitly. the new visibility state (%GDK_VISIBILITY_FULLY_OBSCURED, %GDK_VISIBILITY_PARTIAL or %GDK_VISIBILITY_UNOBSCURED). Generated when the state of a toplevel window changes. the type of the event (%GDK_WINDOW_STATE). the window which received the event. %TRUE if the event was sent explicitly. mask specifying what flags have changed. the new window state, a combination of #GdkWindowState bits. Specifies the type of function used to filter native events before they are converted to GDK events. When a filter is called, @event is unpopulated, except for `event->window`. The filter may translate the native event to a GDK event and store the result in @event, or handle it without translation. If the filter translates the event and processing should continue, it should return %GDK_FILTER_TRANSLATE. a #GdkFilterReturn value. the native event to filter. the GDK event to which the X event will be translated. user data set when the filter was installed. Specifies the result of applying a #GdkFilterFunc to a native event. event not handled, continue processing. native event translated into a GDK event and stored in the `event` structure that was passed in. event handled, terminate processing. A #GdkFrameClock tells the application when to update and repaint a window. This may be synced to the vertical refresh rate of the monitor, for example. Even when the frame clock uses a simple timer rather than a hardware-based vertical sync, the frame clock helps because it ensures everything paints at the same time (reducing the total number of frames). The frame clock can also automatically stop painting when it knows the frames will not be visible, or scale back animation framerates. #GdkFrameClock is designed to be compatible with an OpenGL-based implementation or with mozRequestAnimationFrame in Firefox, for example. A frame clock is idle until someone requests a frame with gdk_frame_clock_request_phase(). At some later point that makes sense for the synchronization being implemented, the clock will process a frame and emit signals for each phase that has been requested. (See the signals of the #GdkFrameClock class for documentation of the phases. %GDK_FRAME_CLOCK_PHASE_UPDATE and the #GdkFrameClock::update signal are most interesting for application writers, and are used to update the animations, using the frame time given by gdk_frame_clock_get_frame_time(). The frame time is reported in microseconds and generally in the same timescale as g_get_monotonic_time(), however, it is not the same as g_get_monotonic_time(). The frame time does not advance during the time a frame is being painted, and outside of a frame, an attempt is made so that all calls to gdk_frame_clock_get_frame_time() that are called at a “similar” time get the same value. This means that if different animations are timed by looking at the difference in time between an initial value from gdk_frame_clock_get_frame_time() and the value inside the #GdkFrameClock::update signal of the clock, they will stay exactly synchronized. Starts updates for an animation. Until a matching call to gdk_frame_clock_end_updating() is made, the frame clock will continually request a new frame with the %GDK_FRAME_CLOCK_PHASE_UPDATE phase. This function may be called multiple times and frames will be requested until gdk_frame_clock_end_updating() is called the same number of times. a #GdkFrameClock Stops updates for an animation. See the documentation for gdk_frame_clock_begin_updating(). a #GdkFrameClock Gets the frame timings for the current frame. the #GdkFrameTimings for the frame currently being processed, or even no frame is being processed, for the previous frame. Before any frames have been processed, returns %NULL. a #GdkFrameClock A #GdkFrameClock maintains a 64-bit counter that increments for each frame drawn. inside frame processing, the value of the frame counter for the current frame. Outside of frame processing, the frame counter for the last frame. a #GdkFrameClock Gets the time that should currently be used for animations. Inside the processing of a frame, it’s the time used to compute the animation position of everything in a frame. Outside of a frame, it's the time of the conceptual “previous frame,” which may be either the actual previous frame time, or if that’s too old, an updated time. a timestamp in microseconds, in the timescale of of g_get_monotonic_time(). a #GdkFrameClock #GdkFrameClock internally keeps a history of #GdkFrameTimings objects for recent frames that can be retrieved with gdk_frame_clock_get_timings(). The set of stored frames is the set from the counter values given by gdk_frame_clock_get_history_start() and gdk_frame_clock_get_frame_counter(), inclusive. the frame counter value for the oldest frame that is available in the internal frame history of the #GdkFrameClock. a #GdkFrameClock Using the frame history stored in the frame clock, finds the last known presentation time and refresh interval, and assuming that presentation times are separated by the refresh interval, predicts a presentation time that is a multiple of the refresh interval after the last presentation time, and later than @base_time. a #GdkFrameClock base time for determining a presentaton time a location to store the determined refresh interval, or %NULL. A default refresh interval of 1/60th of a second will be stored if no history is present. a location to store the next candidate presentation time after the given base time. 0 will be will be stored if no history is present. Retrieves a #GdkFrameTimings object holding timing information for the current frame or a recent frame. The #GdkFrameTimings object may not yet be complete: see gdk_frame_timings_get_complete(). the #GdkFrameTimings object for the specified frame, or %NULL if it is not available. See gdk_frame_clock_get_history_start(). a #GdkFrameClock the frame counter value identifying the frame to be received. Asks the frame clock to run a particular phase. The signal corresponding the requested phase will be emitted the next time the frame clock processes. Multiple calls to gdk_frame_clock_request_phase() will be combined together and only one frame processed. If you are displaying animated content and want to continually request the %GDK_FRAME_CLOCK_PHASE_UPDATE phase for a period of time, you should use gdk_frame_clock_begin_updating() instead, since this allows GTK+ to adjust system parameters to get maximally smooth animations. a #GdkFrameClock the phase that is requested This signal ends processing of the frame. Applications should generally not handle this signal. This signal begins processing of the frame. Applications should generally not handle this signal. This signal is used to flush pending motion events that are being batched up and compressed together. Applications should not handle this signal. This signal is emitted as the second step of toolkit and application processing of the frame. Any work to update sizes and positions of application elements should be performed. GTK+ normally handles this internally. This signal is emitted as the third step of toolkit and application processing of the frame. The frame is repainted. GDK normally handles this internally and produces expose events, which are turned into GTK+ #GtkWidget::draw signals. This signal is emitted after processing of the frame is finished, and is handled internally by GTK+ to resume normal event processing. Applications should not handle this signal. This signal is emitted as the first step of toolkit and application processing of the frame. Animations should be updated using gdk_frame_clock_get_frame_time(). Applications can connect directly to this signal, or use gtk_widget_add_tick_callback() as a more convenient interface. #GdkFrameClockPhase is used to represent the different paint clock phases that can be requested. The elements of the enumeration correspond to the signals of #GdkFrameClock. no phase corresponds to GdkFrameClock::flush-events. Should not be handled by applications. corresponds to GdkFrameClock::before-paint. Should not be handled by applications. corresponds to GdkFrameClock::update. corresponds to GdkFrameClock::layout. corresponds to GdkFrameClock::paint. corresponds to GdkFrameClock::resume-events. Should not be handled by applications. corresponds to GdkFrameClock::after-paint. Should not be handled by applications. A #GdkFrameTimings object holds timing information for a single frame of the application’s displays. To retrieve #GdkFrameTimings objects, use gdk_frame_clock_get_timings() or gdk_frame_clock_get_current_timings(). The information in #GdkFrameTimings is useful for precise synchronization of video with the event or audio streams, and for measuring quality metrics for the application’s display, such as latency and jitter. The timing information in a #GdkFrameTimings is filled in incrementally as the frame as drawn and passed off to the window system for processing and display to the user. The accessor functions for #GdkFrameTimings can return 0 to indicate an unavailable value for two reasons: either because the information is not yet available, or because it isn't available at all. Once gdk_frame_timings_get_complete() returns %TRUE for a frame, you can be certain that no further values will become available and be stored in the #GdkFrameTimings. %TRUE if all information that will be available for the frame has been filled in. a #GdkFrameTimings Gets the frame counter value of the #GdkFrameClock when this this frame was drawn. the frame counter value for this frame a #GdkFrameTimings Returns the frame time for the frame. This is the time value that is typically used to time animations for the frame. See gdk_frame_clock_get_frame_time(). the frame time for the frame, in the timescale of g_get_monotonic_time() A #GdkFrameTimings Gets the predicted time at which this frame will be displayed. Although no predicted time may be available, if one is available, it will be available while the frame is being generated, in contrast to gdk_frame_timings_get_presentation_time(), which is only available after the frame has been presented. In general, if you are simply animating, you should use gdk_frame_clock_get_frame_time() rather than this function, but this function is useful for applications that want exact control over latency. For example, a movie player may want this information for Audio/Video synchronization. The predicted time at which the frame will be presented, in the timescale of g_get_monotonic_time(), or 0 if no predicted presentation time is available. a #GdkFrameTimings Reurns the presentation time. This is the time at which the frame became visible to the user. the time the frame was displayed to the user, in the timescale of g_get_monotonic_time(), or 0 if no presentation time is available. See gdk_frame_timings_get_complete() a #GdkFrameTimings Gets the natural interval between presentation times for the display that this frame was displayed on. Frame presentation usually happens during the “vertical blanking interval”. the refresh interval of the display, in microseconds, or 0 if the refresh interval is not available. See gdk_frame_timings_get_complete(). a #GdkFrameTimings Increases the reference count of @timings. @timings a #GdkFrameTimings Decreases the reference count of @timings. If @timings is no longer referenced, it will be freed. a #GdkFrameTimings Indicates which monitor (in a multi-head setup) a window should span over when in fullscreen mode. Fullscreen on current monitor only. Span across all monitors when fullscreen. #GdkGLContext is an object representing the platform-specific OpenGL drawing context. #GdkGLContexts are created for a #GdkWindow using gdk_window_create_gl_context(), and the context will match the #GdkVisual of the window. A #GdkGLContext is not tied to any particular normal framebuffer. For instance, it cannot draw to the #GdkWindow back buffer. The GDK repaint system is in full control of the painting to that. Instead, you can create render buffers or textures and use gdk_cairo_draw_from_gl() in the draw function of your widget to draw them. Then GDK will handle the integration of your rendering with that of other widgets. Support for #GdkGLContext is platform-specific, context creation can fail, returning %NULL context. A #GdkGLContext has to be made "current" in order to start using it, otherwise any OpenGL call will be ignored. ## Creating a new OpenGL context ## In order to create a new #GdkGLContext instance you need a #GdkWindow, which you typically get during the realize call of a widget. A #GdkGLContext is not realized until either gdk_gl_context_make_current(), or until it is realized using gdk_gl_context_realize(). It is possible to specify details of the GL context like the OpenGL version to be used, or whether the GL context should have extra state validation enabled after calling gdk_window_create_gl_context() by calling gdk_gl_context_realize(). If the realization fails you have the option to change the settings of the #GdkGLContext and try again. ## Using a GdkGLContext ## You will need to make the #GdkGLContext the current context before issuing OpenGL calls; the system sends OpenGL commands to whichever context is current. It is possible to have multiple contexts, so you always need to ensure that the one which you want to draw with is the current one before issuing commands: |[<!-- language="C" --> gdk_gl_context_make_current (context); ]| You can now perform your drawing using OpenGL commands. You can check which #GdkGLContext is the current one by using gdk_gl_context_get_current(); you can also unset any #GdkGLContext that is currently set by calling gdk_gl_context_clear_current(). Clears the current #GdkGLContext. Any OpenGL call after this function returns will be ignored until gdk_gl_context_make_current() is called. Retrieves the current #GdkGLContext. the current #GdkGLContext, or %NULL Retrieves the value set using gdk_gl_context_set_debug_enabled(). %TRUE if debugging is enabled a #GdkGLContext Retrieves the #GdkDisplay the @context is created for a #GdkDisplay or %NULL a #GdkGLContext Retrieves the value set using gdk_gl_context_set_forward_compatible(). %TRUE if the context should be forward compatible a #GdkGLContext Retrieves the major and minor version requested by calling gdk_gl_context_set_required_version(). a #GdkGLContext return location for the major version to request return location for the minor version to request Retrieves the #GdkGLContext that this @context share data with. a #GdkGLContext or %NULL a #GdkGLContext Checks whether the @context is using an OpenGL or OpenGL ES profile. %TRUE if the #GdkGLContext is using an OpenGL ES profile a #GdkGLContext Retrieves the OpenGL version of the @context. The @context must be realized prior to calling this function. a #GdkGLContext return location for the major version return location for the minor version Retrieves the #GdkWindow used by the @context. a #GdkWindow or %NULL a #GdkGLContext Whether the #GdkGLContext is in legacy mode or not. The #GdkGLContext must be realized before calling this function. When realizing a GL context, GDK will try to use the OpenGL 3.2 core profile; this profile removes all the OpenGL API that was deprecated prior to the 3.2 version of the specification. If the realization is successful, this function will return %FALSE. If the underlying OpenGL implementation does not support core profiles, GDK will fall back to a pre-3.2 compatibility profile, and this function will return %TRUE. You can use the value returned by this function to decide which kind of OpenGL API to use, or whether to do extension discovery, or what kind of shader programs to load. %TRUE if the GL context is in legacy mode a #GdkGLContext Makes the @context the current one. a #GdkGLContext Realizes the given #GdkGLContext. It is safe to call this function on a realized #GdkGLContext. %TRUE if the context is realized a #GdkGLContext Sets whether the #GdkGLContext should perform extra validations and run time checking. This is useful during development, but has additional overhead. The #GdkGLContext must not be realized or made current prior to calling this function. a #GdkGLContext whether to enable debugging in the context Sets whether the #GdkGLContext should be forward compatible. Forward compatibile contexts must not support OpenGL functionality that has been marked as deprecated in the requested version; non-forward compatible contexts, on the other hand, must support both deprecated and non deprecated functionality. The #GdkGLContext must not be realized or made current prior to calling this function. a #GdkGLContext whether the context should be forward compatible Sets the major and minor version of OpenGL to request. Setting @major and @minor to zero will use the default values. The #GdkGLContext must not be realized or made current prior to calling this function. a #GdkGLContext the major version to request the minor version to request Requests that GDK create a OpenGL ES context instead of an OpenGL one, if the platform and windowing system allows it. The @context must not have been realized. By default, GDK will attempt to automatically detect whether the underlying GL implementation is OpenGL or OpenGL ES once the @context is realized. You should check the return value of gdk_gl_context_get_use_es() after calling gdk_gl_context_realize() to decide whether to use the OpenGL or OpenGL ES API, extensions, or shaders. a #GdkGLContext: whether the context should use OpenGL ES instead of OpenGL, or -1 to allow auto-detection The #GdkDisplay used to create the #GdkGLContext. The #GdkGLContext that this context is sharing data with, or %NULL The #GdkWindow the gl context is bound to. Error enumeration for #GdkGLContext. OpenGL support is not available The requested visual format is not supported The requested profile is not supported The #GdkGeometry struct gives the window manager information about a window’s geometry constraints. Normally you would set these on the GTK+ level using gtk_window_set_geometry_hints(). #GtkWindow then sets the hints on the #GdkWindow it creates. gdk_window_set_geometry_hints() expects the hints to be fully valid already and simply passes them to the window manager; in contrast, gtk_window_set_geometry_hints() performs some interpretation. For example, #GtkWindow will apply the hints to the geometry widget instead of the toplevel window, if you set a geometry widget. Also, the @min_width/@min_height/@max_width/@max_height fields may be set to -1, and #GtkWindow will substitute the size request of the window or geometry widget. If the minimum size hint is not provided, #GtkWindow will use its requisition as the minimum size. If the minimum size is provided and a geometry widget is set, #GtkWindow will take the minimum size as the minimum size of the geometry widget rather than the entire window. The base size is treated similarly. The canonical use-case for gtk_window_set_geometry_hints() is to get a terminal widget to resize properly. Here, the terminal text area should be the geometry widget; #GtkWindow will then automatically set the base size to the size of other widgets in the terminal window, such as the menubar and scrollbar. Then, the @width_inc and @height_inc fields should be set to the size of one character in the terminal. Finally, the base size should be set to the size of one character. The net effect is that the minimum size of the terminal will have a 1x1 character terminal area, and only terminal sizes on the “character grid” will be allowed. Here’s an example of how the terminal example would be implemented, assuming a terminal area widget called “terminal” and a toplevel window “toplevel”: |[<!-- language="C" --> GdkGeometry hints; hints.base_width = terminal->char_width; hints.base_height = terminal->char_height; hints.min_width = terminal->char_width; hints.min_height = terminal->char_height; hints.width_inc = terminal->char_width; hints.height_inc = terminal->char_height; gtk_window_set_geometry_hints (GTK_WINDOW (toplevel), GTK_WIDGET (terminal), &hints, GDK_HINT_RESIZE_INC | GDK_HINT_MIN_SIZE | GDK_HINT_BASE_SIZE); ]| The other useful fields are the @min_aspect and @max_aspect fields; these contain a width/height ratio as a floating point number. If a geometry widget is set, the aspect applies to the geometry widget rather than the entire window. The most common use of these hints is probably to set @min_aspect and @max_aspect to the same value, thus forcing the window to keep a constant aspect ratio. minimum width of window (or -1 to use requisition, with #GtkWindow only) minimum height of window (or -1 to use requisition, with #GtkWindow only) maximum width of window (or -1 to use requisition, with #GtkWindow only) maximum height of window (or -1 to use requisition, with #GtkWindow only) allowed window widths are @base_width + @width_inc * N where N is any integer (-1 allowed with #GtkWindow) allowed window widths are @base_height + @height_inc * N where N is any integer (-1 allowed with #GtkWindow) width resize increment height resize increment minimum width/height ratio maximum width/height ratio window gravity, see gtk_window_set_gravity() Defines how device grabs interact with other devices. All other devices’ events are allowed. Other devices’ events are blocked for the grab window. Other devices’ events are blocked for the whole application. Returned by gdk_device_grab(), gdk_pointer_grab() and gdk_keyboard_grab() to indicate success or the reason for the failure of the grab attempt. the resource was successfully grabbed. the resource is actively grabbed by another client. the resource was grabbed more recently than the specified time. the grab window or the @confine_to window are not viewable. the resource is frozen by an active grab of another client. the grab failed for some other reason. Since 3.16 Defines the reference point of a window and the meaning of coordinates passed to gtk_window_move(). See gtk_window_move() and the "implementation notes" section of the [Extended Window Manager Hints](http://www.freedesktop.org/Standards/wm-spec) specification for more details. the reference point is at the top left corner. the reference point is in the middle of the top edge. the reference point is at the top right corner. the reference point is at the middle of the left edge. the reference point is at the center of the window. the reference point is at the middle of the right edge. the reference point is at the lower left corner. the reference point is at the middle of the lower edge. the reference point is at the lower right corner. the reference point is at the top left corner of the window itself, ignoring window manager decorations. An enumeration that describes the mode of an input device. the device is disabled and will not report any events. the device is enabled. The device’s coordinate space maps to the entire screen. the device is enabled. The device’s coordinate space is mapped to a single window. The manner in which this window is chosen is undefined, but it will typically be the same way in which the focus window for key events is determined. An enumeration describing the type of an input device in general terms. the device is a mouse. (This will be reported for the core pointer, even if it is something else, such as a trackball.) the device is a stylus of a graphics tablet or similar device. the device is an eraser. Typically, this would be the other end of a stylus on a graphics tablet. the device is a graphics tablet “puck” or similar device. the device is a keyboard. the device is a direct-input touch device, such as a touchscreen or tablet. This device type has been added in 3.4. the device is an indirect touch device, such as a touchpad. This device type has been added in 3.4. the device is a trackpoint. This device type has been added in 3.22 the device is a "pad", a collection of buttons, rings and strips found in drawing tablets. This device type has been added in 3.22. A #GdkKeymap defines the translation from keyboard state (including a hardware key, a modifier mask, and active keyboard group) to a keyval. This translation has two phases. The first phase is to determine the effective keyboard group and level for the keyboard state; the second phase is to look up the keycode/group/level triplet in the keymap and see what keyval it corresponds to. Returns the #GdkKeymap attached to the default display. Use gdk_keymap_get_for_display() instead the #GdkKeymap attached to the default display. Returns the #GdkKeymap attached to @display. the #GdkKeymap attached to @display. the #GdkDisplay. Maps the non-virtual modifiers (i.e Mod2, Mod3, ...) which are set in @state to the virtual modifiers (i.e. Super, Hyper and Meta) and set the corresponding bits in @state. GDK already does this before delivering key events, but for compatibility reasons, it only sets the first virtual modifier it finds, whereas this function sets all matching virtual modifiers. This function is useful when matching key events against accelerators. a #GdkKeymap pointer to the modifier mask to change Returns whether the Caps Lock modifer is locked. %TRUE if Caps Lock is on a #GdkKeymap Returns the direction of effective layout of the keymap. %PANGO_DIRECTION_LTR or %PANGO_DIRECTION_RTL if it can determine the direction. %PANGO_DIRECTION_NEUTRAL otherwise. a #GdkKeymap Returns the keyvals bound to @hardware_keycode. The Nth #GdkKeymapKey in @keys is bound to the Nth keyval in @keyvals. Free the returned arrays with g_free(). When a keycode is pressed by the user, the keyval from this list of entries is selected by considering the effective keyboard group and level. See gdk_keymap_translate_keyboard_state(). %TRUE if there were any entries a #GdkKeymap a keycode return location for array of #GdkKeymapKey, or %NULL return location for array of keyvals, or %NULL length of @keys and @keyvals Obtains a list of keycode/group/level combinations that will generate @keyval. Groups and levels are two kinds of keyboard mode; in general, the level determines whether the top or bottom symbol on a key is used, and the group determines whether the left or right symbol is used. On US keyboards, the shift key changes the keyboard level, and there are no groups. A group switch key might convert a keyboard between Hebrew to English modes, for example. #GdkEventKey contains a %group field that indicates the active keyboard group. The level is computed from the modifier mask. The returned array should be freed with g_free(). %TRUE if keys were found and returned a #GdkKeymap a keyval, such as %GDK_KEY_a, %GDK_KEY_Up, %GDK_KEY_Return, etc. return location for an array of #GdkKeymapKey return location for number of elements in returned array Returns the modifier mask the @keymap’s windowing system backend uses for a particular purpose. Note that this function always returns real hardware modifiers, not virtual ones (e.g. it will return #GDK_MOD1_MASK rather than #GDK_META_MASK if the backend maps MOD1 to META), so there are use cases where the return value of this function has to be transformed by gdk_keymap_add_virtual_modifiers() in order to contain the expected result. the modifier mask used for @intent. a #GdkKeymap the use case for the modifier mask Returns the current modifier state. the current modifier state. a #GdkKeymap Returns whether the Num Lock modifer is locked. %TRUE if Num Lock is on a #GdkKeymap Returns whether the Scroll Lock modifer is locked. %TRUE if Scroll Lock is on a #GdkKeymap Determines if keyboard layouts for both right-to-left and left-to-right languages are in use. %TRUE if there are layouts in both directions, %FALSE otherwise a #GdkKeymap Looks up the keyval mapped to a keycode/group/level triplet. If no keyval is bound to @key, returns 0. For normal user input, you want to use gdk_keymap_translate_keyboard_state() instead of this function, since the effective group/level may not be the same as the current keyboard state. a keyval, or 0 if none was mapped to the given @key a #GdkKeymap a #GdkKeymapKey with keycode, group, and level initialized Maps the virtual modifiers (i.e. Super, Hyper and Meta) which are set in @state to their non-virtual counterparts (i.e. Mod2, Mod3,...) and set the corresponding bits in @state. This function is useful when matching key events against accelerators. %FALSE if two virtual modifiers were mapped to the same non-virtual modifier. Note that %FALSE is also returned if a virtual modifier is mapped to a non-virtual modifier that was already set in @state. a #GdkKeymap pointer to the modifier state to map Translates the contents of a #GdkEventKey into a keyval, effective group, and level. Modifiers that affected the translation and are thus unavailable for application use are returned in @consumed_modifiers. See [Groups][key-group-explanation] for an explanation of groups and levels. The @effective_group is the group that was actually used for the translation; some keys such as Enter are not affected by the active keyboard group. The @level is derived from @state. For convenience, #GdkEventKey already contains the translated keyval, so this function isn’t as useful as you might think. @consumed_modifiers gives modifiers that should be masked outfrom @state when comparing this key press to a hot key. For instance, on a US keyboard, the `plus` symbol is shifted, so when comparing a key press to a `<Control>plus` accelerator `<Shift>` should be masked out. |[<!-- language="C" --> // We want to ignore irrelevant modifiers like ScrollLock #define ALL_ACCELS_MASK (GDK_CONTROL_MASK | GDK_SHIFT_MASK | GDK_MOD1_MASK) gdk_keymap_translate_keyboard_state (keymap, event->hardware_keycode, event->state, event->group, &keyval, NULL, NULL, &consumed); if (keyval == GDK_PLUS && (event->state & ~consumed & ALL_ACCELS_MASK) == GDK_CONTROL_MASK) // Control was pressed ]| An older interpretation @consumed_modifiers was that it contained all modifiers that might affect the translation of the key; this allowed accelerators to be stored with irrelevant consumed modifiers, by doing: |[<!-- language="C" --> // XXX Don’t do this XXX if (keyval == accel_keyval && (event->state & ~consumed & ALL_ACCELS_MASK) == (accel_mods & ~consumed)) // Accelerator was pressed ]| However, this did not work if multi-modifier combinations were used in the keymap, since, for instance, `<Control>` would be masked out even if only `<Control><Alt>` was used in the keymap. To support this usage as well as well as possible, all single modifier combinations that could affect the key for any combination of modifiers will be returned in @consumed_modifiers; multi-modifier combinations are returned only when actually found in @state. When you store accelerators, you should always store them with consumed modifiers removed. Store `<Control>plus`, not `<Control><Shift>plus`, %TRUE if there was a keyval bound to the keycode/state/group a #GdkKeymap a keycode a modifier state active keyboard group return location for keyval, or %NULL return location for effective group, or %NULL return location for level, or %NULL return location for modifiers that were used to determine the group or level, or %NULL The ::direction-changed signal gets emitted when the direction of the keymap changes. The ::keys-changed signal is emitted when the mapping represented by @keymap changes. The ::state-changed signal is emitted when the state of the keyboard changes, e.g when Caps Lock is turned on or off. See gdk_keymap_get_caps_lock_state(). A #GdkKeymapKey is a hardware key that can be mapped to a keyval. the hardware keycode. This is an identifying number for a physical key. indicates movement in a horizontal direction. Usually groups are used for two different languages. In group 0, a key might have two English characters, and in group 1 it might have two Hebrew characters. The Hebrew characters will be printed on the key next to the English characters. indicates which symbol on the key will be used, in a vertical direction. So on a standard US keyboard, the key with the number “1” on it also has the exclamation point ("!") character on it. The level indicates whether to use the “1” or the “!” symbol. The letter keys are considered to have a lowercase letter at level 0, and an uppercase letter at level 1, though only the uppercase letter is printed. This enum is used with gdk_keymap_get_modifier_mask() in order to determine what modifiers the currently used windowing system backend uses for particular purposes. For example, on X11/Windows, the Control key is used for invoking menu shortcuts (accelerators), whereas on Apple computers it’s the Command key (which correspond to %GDK_CONTROL_MASK and %GDK_MOD2_MASK, respectively). the primary modifier used to invoke menu accelerators. the modifier used to invoke context menus. Note that mouse button 3 always triggers context menus. When this modifier is not 0, it additionally triggers context menus when used with mouse button 1. the modifier used to extend selections using `modifier`-click or `modifier`-cursor-key the modifier used to modify selections, which in most cases means toggling the clicked item into or out of the selection. when any of these modifiers is pressed, the key event cannot produce a symbol directly. This is meant to be used for input methods, and for use cases like typeahead search. the modifier that switches between keyboard groups (AltGr on X11/Windows and Option/Alt on OS X). The set of modifier masks accepted as modifiers in accelerators. Needed because Command is mapped to MOD2 on OSX, which is widely used, but on X11 MOD2 is NumLock and using that for a mod key is problematic at best. Ref: https://bugzilla.gnome.org/show_bug.cgi?id=736125. A set of bit-flags to indicate the state of modifier keys and mouse buttons in various event types. Typical modifier keys are Shift, Control, Meta, Super, Hyper, Alt, Compose, Apple, CapsLock or ShiftLock. Like the X Window System, GDK supports 8 modifier keys and 5 mouse buttons. Since 2.10, GDK recognizes which of the Meta, Super or Hyper keys are mapped to Mod2 - Mod5, and indicates this by setting %GDK_SUPER_MASK, %GDK_HYPER_MASK or %GDK_META_MASK in the state field of key events. Note that GDK may add internal values to events which include reserved values such as %GDK_MODIFIER_RESERVED_13_MASK. Your code should preserve and ignore them. You can use %GDK_MODIFIER_MASK to remove all reserved values. Also note that the GDK X backend interprets button press events for button 4-7 as scroll events, so %GDK_BUTTON4_MASK and %GDK_BUTTON5_MASK will never be set. the Shift key. a Lock key (depending on the modifier mapping of the X server this may either be CapsLock or ShiftLock). the Control key. the fourth modifier key (it depends on the modifier mapping of the X server which key is interpreted as this modifier, but normally it is the Alt key). the fifth modifier key (it depends on the modifier mapping of the X server which key is interpreted as this modifier). the sixth modifier key (it depends on the modifier mapping of the X server which key is interpreted as this modifier). the seventh modifier key (it depends on the modifier mapping of the X server which key is interpreted as this modifier). the eighth modifier key (it depends on the modifier mapping of the X server which key is interpreted as this modifier). the first mouse button. the second mouse button. the third mouse button. the fourth mouse button. the fifth mouse button. A reserved bit flag; do not use in your own code A reserved bit flag; do not use in your own code A reserved bit flag; do not use in your own code A reserved bit flag; do not use in your own code A reserved bit flag; do not use in your own code A reserved bit flag; do not use in your own code A reserved bit flag; do not use in your own code A reserved bit flag; do not use in your own code A reserved bit flag; do not use in your own code A reserved bit flag; do not use in your own code A reserved bit flag; do not use in your own code A reserved bit flag; do not use in your own code A reserved bit flag; do not use in your own code the Super modifier. Since 2.10 the Hyper modifier. Since 2.10 the Meta modifier. Since 2.10 A reserved bit flag; do not use in your own code not used in GDK itself. GTK+ uses it to differentiate between (keyval, modifiers) pairs from key press and release events. a mask covering all modifier types. GdkMonitor objects represent the individual outputs that are associated with a #GdkDisplay. GdkDisplay has APIs to enumerate monitors with gdk_display_get_n_monitors() and gdk_display_get_monitor(), and to find particular monitors with gdk_display_get_primary_monitor() or gdk_display_get_monitor_at_window(). GdkMonitor was introduced in GTK+ 3.22 and supersedes earlier APIs in GdkScreen to obtain monitor-related information. Gets the display that this monitor belongs to. the display a #GdkMonitor Retrieves the size and position of an individual monitor within the display coordinate space. The returned geometry is in ”application pixels”, not in ”device pixels” (see gdk_monitor_get_scale_factor()). a #GdkMonitor a #GdkRectangle to be filled with the monitor geometry Gets the height in millimeters of the monitor. the physical height of the monitor a #GdkMonitor Gets the name or PNP ID of the monitor's manufacturer, if available. Note that this value might also vary depending on actual display backend. PNP ID registry is located at https://uefi.org/pnp_id_list the name of the manufacturer, or %NULL a #GdkMonitor Gets the a string identifying the monitor model, if available. the monitor model, or %NULL a #GdkMonitor Gets the refresh rate of the monitor, if available. The value is in milli-Hertz, so a refresh rate of 60Hz is returned as 60000. the refresh rate in milli-Hertz, or 0 a #GdkMonitor Gets the internal scale factor that maps from monitor coordinates to the actual device pixels. On traditional systems this is 1, but on very high density outputs this can be a higher value (often 2). This can be used if you want to create pixel based data for a particular monitor, but most of the time you’re drawing to a window where it is better to use gdk_window_get_scale_factor() instead. the scale factor a #GdkMonitor Gets information about the layout of red, green and blue primaries for each pixel in this monitor, if available. the subpixel layout a #GdkMonitor Gets the width in millimeters of the monitor. the physical width of the monitor a #GdkMonitor Retrieves the size and position of the “work area” on a monitor within the display coordinate space. The returned geometry is in ”application pixels”, not in ”device pixels” (see gdk_monitor_get_scale_factor()). The work area should be considered when positioning menus and similar popups, to avoid placing them below panels, docks or other desktop components. Note that not all backends may have a concept of workarea. This function will return the monitor geometry if a workarea is not available, or does not apply. a #GdkMonitor a #GdkRectangle to be filled with the monitor workarea Gets whether this monitor should be considered primary (see gdk_display_get_primary_monitor()). %TRUE if @monitor is primary a #GdkMonitor Specifies the kind of crossing for #GdkEventCrossing. See the X11 protocol specification of LeaveNotify for full details of crossing event generation. the window is entered from an ancestor or left towards an ancestor. the pointer moves between an ancestor and an inferior of the window. the window is entered from an inferior or left towards an inferior. the window is entered from or left towards a window which is neither an ancestor nor an inferior. the pointer moves between two windows which are not ancestors of each other and the window is part of the ancestor chain between one of these windows and their least common ancestor. an unknown type of enter/leave event occurred. Specifies why a selection ownership was changed. some other app claimed the ownership the window was destroyed the client was closed A special value, indicating that the background for a window should be inherited from the parent window. Extracts a #GdkAtom from a pointer. The #GdkAtom must have been stored in the pointer with GDK_ATOM_TO_POINTER(). a pointer containing a #GdkAtom. This is the priority that the idle handler processing window updates is given in the [GLib Main Loop][glib-The-Main-Event-Loop]. Defines the x and y coordinates of a point. the x coordinate of the point. the y coordinate of the point. Describes how existing data is combined with new data when using gdk_property_change(). the new data replaces the existing data. the new data is prepended to the existing data. the new data is appended to the existing data. Specifies the type of a property change for a #GdkEventProperty. the property value was changed. the property was deleted. A #GdkRGBA is used to represent a (possibly translucent) color, in a way that is compatible with cairo’s notion of color. The intensity of the red channel from 0.0 to 1.0 inclusive The intensity of the green channel from 0.0 to 1.0 inclusive The intensity of the blue channel from 0.0 to 1.0 inclusive The opacity of the color from 0.0 for completely translucent to 1.0 for opaque Makes a copy of a #GdkRGBA. The result must be freed through gdk_rgba_free(). A newly allocated #GdkRGBA, with the same contents as @rgba a #GdkRGBA Compares two RGBA colors. %TRUE if the two colors compare equal a #GdkRGBA pointer another #GdkRGBA pointer Frees a #GdkRGBA created with gdk_rgba_copy() a #GdkRGBA A hash function suitable for using for a hash table that stores #GdkRGBAs. The hash value for @p a #GdkRGBA pointer Parses a textual representation of a color, filling in the @red, @green, @blue and @alpha fields of the @rgba #GdkRGBA. The string can be either one of: - A standard name (Taken from the X11 rgb.txt file). - A hexadecimal value in the form “\#rgb”, “\#rrggbb”, “\#rrrgggbbb” or ”\#rrrrggggbbbb” - A RGB color in the form “rgb(r,g,b)” (In this case the color will have full opacity) - A RGBA color in the form “rgba(r,g,b,a)” Where “r”, “g”, “b” and “a” are respectively the red, green, blue and alpha color values. In the last two cases, “r”, “g”, and “b” are either integers in the range 0 to 255 or percentage values in the range 0% to 100%, and a is a floating point value in the range 0 to 1. %TRUE if the parsing succeeded the #GdkRGBA to fill in the string specifying the color Returns a textual specification of @rgba in the form `rgb(r,g,b)` or `rgba(r g,b,a)`, where “r”, “g”, “b” and “a” represent the red, green, blue and alpha values respectively. “r”, “g”, and “b” are represented as integers in the range 0 to 255, and “a” is represented as a floating point value in the range 0 to 1. These string forms are string forms that are supported by the CSS3 colors module, and can be parsed by gdk_rgba_parse(). Note that this string representation may lose some precision, since “r”, “g” and “b” are represented as 8-bit integers. If this is a concern, you should use a different representation. A newly allocated text string a #GdkRGBA Defines the position and size of a rectangle. It is identical to #cairo_rectangle_int_t. Checks if the two given rectangles are equal. %TRUE if the rectangles are equal. a #GdkRectangle a #GdkRectangle Calculates the intersection of two rectangles. It is allowed for @dest to be the same as either @src1 or @src2. If the rectangles do not intersect, @dest’s width and height is set to 0 and its x and y values are undefined. If you are only interested in whether the rectangles intersect, but not in the intersecting area itself, pass %NULL for @dest. %TRUE if the rectangles intersect. a #GdkRectangle a #GdkRectangle return location for the intersection of @src1 and @src2, or %NULL Calculates the union of two rectangles. The union of rectangles @src1 and @src2 is the smallest rectangle which includes both @src1 and @src2 within it. It is allowed for @dest to be the same as either @src1 or @src2. Note that this function does not ignore 'empty' rectangles (ie. with zero width or height). a #GdkRectangle a #GdkRectangle return location for the union of @src1 and @src2 #GdkScreen objects are the GDK representation of the screen on which windows can be displayed and on which the pointer moves. X originally identified screens with physical screens, but nowadays it is more common to have a single #GdkScreen which combines several physical monitors (see gdk_screen_get_n_monitors()). GdkScreen is used throughout GDK and GTK+ to specify which screen the top level windows are to be displayed on. it is also used to query the screen specification and default settings such as the default visual (gdk_screen_get_system_visual()), the dimensions of the physical monitors (gdk_screen_get_monitor_geometry()), etc. Gets the default screen for the default display. (See gdk_display_get_default ()). a #GdkScreen, or %NULL if there is no default display. Gets the height of the default screen in pixels. The returned size is in ”application pixels”, not in ”device pixels” (see gdk_screen_get_monitor_scale_factor()). Use per-monitor information the height of the default screen in pixels. Returns the height of the default screen in millimeters. Note that on many X servers this value will not be correct. Use per-monitor information the height of the default screen in millimeters, though it is not always correct. Gets the width of the default screen in pixels. The returned size is in ”application pixels”, not in ”device pixels” (see gdk_screen_get_monitor_scale_factor()). Use per-monitor information the width of the default screen in pixels. Returns the width of the default screen in millimeters. Note that on many X servers this value will not be correct. Use per-monitor information the width of the default screen in millimeters, though it is not always correct. Returns the screen’s currently active window. On X11, this is done by inspecting the _NET_ACTIVE_WINDOW property on the root window, as described in the [Extended Window Manager Hints](http://www.freedesktop.org/Standards/wm-spec). If there is no currently currently active window, or the window manager does not support the _NET_ACTIVE_WINDOW hint, this function returns %NULL. On other platforms, this function may return %NULL, depending on whether it is implementable on that platform. The returned window should be unrefed using g_object_unref() when no longer needed. the currently active window, or %NULL. a #GdkScreen Gets the display to which the @screen belongs. the display to which @screen belongs a #GdkScreen Gets any options previously set with gdk_screen_set_font_options(). the current font options, or %NULL if no default font options have been set. a #GdkScreen Gets the height of @screen in pixels. The returned size is in ”application pixels”, not in ”device pixels” (see gdk_screen_get_monitor_scale_factor()). Use per-monitor information instead the height of @screen in pixels. a #GdkScreen Returns the height of @screen in millimeters. Note that this value is somewhat ill-defined when the screen has multiple monitors of different resolution. It is recommended to use the monitor dimensions instead. Use per-monitor information instead the heigth of @screen in millimeters. a #GdkScreen Returns the monitor number in which the point (@x,@y) is located. Use gdk_display_get_monitor_at_point() instead the monitor number in which the point (@x,@y) lies, or a monitor close to (@x,@y) if the point is not in any monitor. a #GdkScreen. the x coordinate in the virtual screen. the y coordinate in the virtual screen. Returns the number of the monitor in which the largest area of the bounding rectangle of @window resides. Use gdk_display_get_monitor_at_window() instead the monitor number in which most of @window is located, or if @window does not intersect any monitors, a monitor, close to @window. a #GdkScreen. a #GdkWindow Retrieves the #GdkRectangle representing the size and position of the individual monitor within the entire screen area. The returned geometry is in ”application pixels”, not in ”device pixels” (see gdk_screen_get_monitor_scale_factor()). Monitor numbers start at 0. To obtain the number of monitors of @screen, use gdk_screen_get_n_monitors(). Note that the size of the entire screen area can be retrieved via gdk_screen_get_width() and gdk_screen_get_height(). Use gdk_monitor_get_geometry() instead a #GdkScreen the monitor number a #GdkRectangle to be filled with the monitor geometry Gets the height in millimeters of the specified monitor. Use gdk_monitor_get_height_mm() instead the height of the monitor, or -1 if not available a #GdkScreen number of the monitor, between 0 and gdk_screen_get_n_monitors (screen) Returns the output name of the specified monitor. Usually something like VGA, DVI, or TV, not the actual product name of the display device. Use gdk_monitor_get_model() instead a newly-allocated string containing the name of the monitor, or %NULL if the name cannot be determined a #GdkScreen number of the monitor, between 0 and gdk_screen_get_n_monitors (screen) Returns the internal scale factor that maps from monitor coordinates to the actual device pixels. On traditional systems this is 1, but on very high density outputs this can be a higher value (often 2). This can be used if you want to create pixel based data for a particular monitor, but most of the time you’re drawing to a window where it is better to use gdk_window_get_scale_factor() instead. Use gdk_monitor_get_scale_factor() instead the scale factor screen to get scale factor for number of the monitor, between 0 and gdk_screen_get_n_monitors (screen) Gets the width in millimeters of the specified monitor, if available. Use gdk_monitor_get_width_mm() instead the width of the monitor, or -1 if not available a #GdkScreen number of the monitor, between 0 and gdk_screen_get_n_monitors (screen) Retrieves the #GdkRectangle representing the size and position of the “work area” on a monitor within the entire screen area. The returned geometry is in ”application pixels”, not in ”device pixels” (see gdk_screen_get_monitor_scale_factor()). The work area should be considered when positioning menus and similar popups, to avoid placing them below panels, docks or other desktop components. Note that not all backends may have a concept of workarea. This function will return the monitor geometry if a workarea is not available, or does not apply. Monitor numbers start at 0. To obtain the number of monitors of @screen, use gdk_screen_get_n_monitors(). Use gdk_monitor_get_workarea() instead a #GdkScreen the monitor number a #GdkRectangle to be filled with the monitor workarea Returns the number of monitors which @screen consists of. Use gdk_display_get_n_monitors() instead number of monitors which @screen consists of a #GdkScreen Gets the index of @screen among the screens in the display to which it belongs. (See gdk_screen_get_display()) the index a #GdkScreen Gets the primary monitor for @screen. The primary monitor is considered the monitor where the “main desktop” lives. While normal application windows typically allow the window manager to place the windows, specialized desktop applications such as panels should place themselves on the primary monitor. If no primary monitor is configured by the user, the return value will be 0, defaulting to the first monitor. Use gdk_display_get_primary_monitor() instead An integer index for the primary monitor, or 0 if none is configured. a #GdkScreen. Gets the resolution for font handling on the screen; see gdk_screen_set_resolution() for full details. the current resolution, or -1 if no resolution has been set. a #GdkScreen Gets a visual to use for creating windows with an alpha channel. The windowing system on which GTK+ is running may not support this capability, in which case %NULL will be returned. Even if a non-%NULL value is returned, its possible that the window’s alpha channel won’t be honored when displaying the window on the screen: in particular, for X an appropriate windowing manager and compositing manager must be running to provide appropriate display. This functionality is not implemented in the Windows backend. For setting an overall opacity for a top-level window, see gdk_window_set_opacity(). a visual to use for windows with an alpha channel or %NULL if the capability is not available. a #GdkScreen Gets the root window of @screen. the root window a #GdkScreen Retrieves a desktop-wide setting such as double-click time for the #GdkScreen @screen. FIXME needs a list of valid settings here, or a link to more information. %TRUE if the setting existed and a value was stored in @value, %FALSE otherwise. the #GdkScreen where the setting is located the name of the setting location to store the value of the setting Get the system’s default visual for @screen. This is the visual for the root window of the display. The return value should not be freed. the system visual a #GdkScreen. Obtains a list of all toplevel windows known to GDK on the screen @screen. A toplevel window is a child of the root window (see gdk_get_default_root_window()). The returned list should be freed with g_list_free(), but its elements need not be freed. list of toplevel windows, free with g_list_free() The #GdkScreen where the toplevels are located. Gets the width of @screen in pixels. The returned size is in ”application pixels”, not in ”device pixels” (see gdk_screen_get_monitor_scale_factor()). Use per-monitor information instead the width of @screen in pixels. a #GdkScreen Gets the width of @screen in millimeters. Note that this value is somewhat ill-defined when the screen has multiple monitors of different resolution. It is recommended to use the monitor dimensions instead. Use per-monitor information instead the width of @screen in millimeters. a #GdkScreen Returns a #GList of #GdkWindows representing the current window stack. On X11, this is done by inspecting the _NET_CLIENT_LIST_STACKING property on the root window, as described in the [Extended Window Manager Hints](http://www.freedesktop.org/Standards/wm-spec). If the window manager does not support the _NET_CLIENT_LIST_STACKING hint, this function returns %NULL. On other platforms, this function may return %NULL, depending on whether it is implementable on that platform. The returned list is newly allocated and owns references to the windows it contains, so it should be freed using g_list_free() and its windows unrefed using g_object_unref() when no longer needed. a list of #GdkWindows for the current window stack, or %NULL. a #GdkScreen Returns whether windows with an RGBA visual can reasonably be expected to have their alpha channel drawn correctly on the screen. On X11 this function returns whether a compositing manager is compositing @screen. Whether windows with RGBA visuals can reasonably be expected to have their alpha channels drawn correctly on the screen. a #GdkScreen Lists the available visuals for the specified @screen. A visual describes a hardware image data format. For example, a visual might support 24-bit color, or 8-bit color, and might expect pixels to be in a certain format. Call g_list_free() on the return value when you’re finished with it. a list of visuals; the list must be freed, but not its contents the relevant #GdkScreen. Determines the name to pass to gdk_display_open() to get a #GdkDisplay with this screen as the default screen. a newly allocated string, free with g_free() a #GdkScreen Sets the default font options for the screen. These options will be set on any #PangoContext’s newly created with gdk_pango_context_get_for_screen(). Changing the default set of font options does not affect contexts that have already been created. a #GdkScreen a #cairo_font_options_t, or %NULL to unset any previously set default font options. Sets the resolution for font handling on the screen. This is a scale factor between points specified in a #PangoFontDescription and cairo units. The default value is 96, meaning that a 10 point font will be 13 units high. (10 * 96. / 72. = 13.3). a #GdkScreen the resolution in “dots per inch”. (Physical inches aren’t actually involved; the terminology is conventional.) The ::composited-changed signal is emitted when the composited status of the screen changes The ::monitors-changed signal is emitted when the number, size or position of the monitors attached to the screen change. Only for X11 and OS X for now. A future implementation for Win32 may be a possibility. The ::size-changed signal is emitted when the pixel width or height of a screen changes. Specifies the direction for #GdkEventScroll. the window is scrolled up. the window is scrolled down. the window is scrolled to the left. the window is scrolled to the right. the scrolling is determined by the delta values in #GdkEventScroll. See gdk_event_get_scroll_deltas(). Since: 3.4 The #GdkSeat object represents a collection of input devices that belong to a user. Returns the capabilities this #GdkSeat currently has. the seat capabilities a #GdkSeat Returns the #GdkDisplay this seat belongs to. a #GdkDisplay. This object is owned by GTK+ and must not be freed. a #GdkSeat Returns the master device that routes keyboard events. a master #GdkDevice with keyboard capabilities. This object is owned by GTK+ and must not be freed. a #GdkSeat Returns the master device that routes pointer events. a master #GdkDevice with pointer capabilities. This object is owned by GTK+ and must not be freed. a #GdkSeat Returns the slave devices that match the given capabilities. A list of #GdkDevices. The list must be freed with g_list_free(), the elements are owned by GDK and must not be freed. a #GdkSeat capabilities to get devices for Grabs the seat so that all events corresponding to the given @capabilities are passed to this application until the seat is ungrabbed with gdk_seat_ungrab(), or the window becomes hidden. This overrides any previous grab on the seat by this client. As a rule of thumb, if a grab is desired over %GDK_SEAT_CAPABILITY_POINTER, all other "pointing" capabilities (eg. %GDK_SEAT_CAPABILITY_TOUCH) should be grabbed too, so the user is able to interact with all of those while the grab holds, you should thus use %GDK_SEAT_CAPABILITY_ALL_POINTING most commonly. Grabs are used for operations which need complete control over the events corresponding to the given capabilities. For example in GTK+ this is used for Drag and Drop operations, popup menus and such. Note that if the event mask of a #GdkWindow has selected both button press and button release events, or touch begin and touch end, then a press event will cause an automatic grab until the button is released, equivalent to a grab on the window with @owner_events set to %TRUE. This is done because most applications expect to receive paired press and release events. If you set up anything at the time you take the grab that needs to be cleaned up when the grab ends, you should handle the #GdkEventGrabBroken events that are emitted when the grab ends unvoluntarily. %GDK_GRAB_SUCCESS if the grab was successful. a #GdkSeat the #GdkWindow which will own the grab capabilities that will be grabbed if %FALSE then all device events are reported with respect to @window and are only reported if selected by @event_mask. If %TRUE then pointer events for this application are reported as normal, but pointer events outside this application are reported with respect to @window and only if selected by @event_mask. In either mode, unreported events are discarded. the cursor to display while the grab is active. If this is %NULL then the normal cursors are used for @window and its descendants, and the cursor for @window is used elsewhere. the event that is triggering the grab, or %NULL if none is available. function to prepare the window to be grabbed, it can be %NULL if @window is visible before this call. user data to pass to @prepare_func Releases a grab added through gdk_seat_grab(). a #GdkSeat #GdkDisplay of this seat. The ::device-added signal is emitted when a new input device is related to this seat. the newly added #GdkDevice. The ::device-removed signal is emitted when an input device is removed (e.g. unplugged). the just removed #GdkDevice. The ::tool-added signal is emitted whenever a new tool is made known to the seat. The tool may later be assigned to a device (i.e. on proximity with a tablet). The device will emit the #GdkDevice::tool-changed signal accordingly. A same tool may be used by several devices. the new #GdkDeviceTool known to the seat This signal is emitted whenever a tool is no longer known to this @seat. the just removed #GdkDeviceTool Flags describing the seat capabilities. No input capabilities The seat has a pointer (e.g. mouse) The seat has touchscreen(s) attached The seat has drawing tablet(s) attached The seat has keyboard(s) attached The union of all pointing capabilities The union of all capabilities Type of the callback used to set up @window so it can be grabbed. A typical action would be ensuring the window is visible, although there's room for other initialization actions. the #GdkSeat being grabbed the #GdkWindow being grabbed user data passed in gdk_seat_grab() Specifies the kind of modification applied to a setting in a #GdkEventSetting. a setting was added. a setting was changed. a setting was deleted. This enumeration describes how the red, green and blue components of physical pixels on an output device are laid out. The layout is not known Not organized in this way The layout is horizontal, the order is RGB The layout is horizontal, the order is BGR The layout is vertical, the order is RGB The layout is vertical, the order is BGR A #GdkTimeCoord stores a single event in a motion history. The timestamp for this event. the values of the device’s axes. Specifies the current state of a touchpad gesture. All gestures are guaranteed to begin with an event with phase %GDK_TOUCHPAD_GESTURE_PHASE_BEGIN, followed by 0 or several events with phase %GDK_TOUCHPAD_GESTURE_PHASE_UPDATE. A finished gesture may have 2 possible outcomes, an event with phase %GDK_TOUCHPAD_GESTURE_PHASE_END will be emitted when the gesture is considered successful, this should be used as the hint to perform any permanent changes. Cancelled gestures may be so for a variety of reasons, due to hardware or the compositor, or due to the gesture recognition layers hinting the gesture did not finish resolutely (eg. a 3rd finger being added during a pinch gesture). In these cases, the last event will report the phase %GDK_TOUCHPAD_GESTURE_PHASE_CANCEL, this should be used as a hint to undo any visible/permanent changes that were done throughout the progress of the gesture. See also #GdkEventTouchpadSwipe and #GdkEventTouchpadPinch. The gesture has begun. The gesture has been updated. The gesture was finished, changes should be permanently applied. The gesture was cancelled, all changes should be undone. Specifies the visiblity status of a window for a #GdkEventVisibility. the window is completely visible. the window is partially visible. the window is not visible at all. A #GdkVisual contains information about a particular visual. Get the visual with the most available colors for the default GDK screen. The return value should not be freed. Visual selection should be done using gdk_screen_get_system_visual() and gdk_screen_get_rgba_visual() best visual Get the best available depth for the default GDK screen. “Best” means “largest,” i.e. 32 preferred over 24 preferred over 8 bits per pixel. Visual selection should be done using gdk_screen_get_system_visual() and gdk_screen_get_rgba_visual() best available depth Return the best available visual type for the default GDK screen. Visual selection should be done using gdk_screen_get_system_visual() and gdk_screen_get_rgba_visual() best visual type Combines gdk_visual_get_best_with_depth() and gdk_visual_get_best_with_type(). Visual selection should be done using gdk_screen_get_system_visual() and gdk_screen_get_rgba_visual() best visual with both @depth and @visual_type, or %NULL if none a bit depth a visual type Get the best visual with depth @depth for the default GDK screen. Color visuals and visuals with mutable colormaps are preferred over grayscale or fixed-colormap visuals. The return value should not be freed. %NULL may be returned if no visual supports @depth. Visual selection should be done using gdk_screen_get_system_visual() and gdk_screen_get_rgba_visual() best visual for the given depth a bit depth Get the best visual of the given @visual_type for the default GDK screen. Visuals with higher color depths are considered better. The return value should not be freed. %NULL may be returned if no visual has type @visual_type. Visual selection should be done using gdk_screen_get_system_visual() and gdk_screen_get_rgba_visual() best visual of the given type a visual type Get the system’s default visual for the default GDK screen. This is the visual for the root window of the display. The return value should not be freed. Use gdk_screen_get_system_visual (gdk_screen_get_default ()). system visual Returns the number of significant bits per red, green and blue value. Not all GDK backend provide a meaningful value for this function. Use gdk_visual_get_red_pixel_details() and its variants to learn about the pixel layout of TrueColor and DirectColor visuals The number of significant bits per color value for @visual. a #GdkVisual Obtains values that are needed to calculate blue pixel values in TrueColor and DirectColor. The “mask” is the significant bits within the pixel. The “shift” is the number of bits left we must shift a primary for it to be in position (according to the "mask"). Finally, "precision" refers to how much precision the pixel value contains for a particular primary. a #GdkVisual A pointer to a #guint32 to be filled in, or %NULL A pointer to a #gint to be filled in, or %NULL A pointer to a #gint to be filled in, or %NULL Returns the byte order of this visual. The information returned by this function is only relevant when working with XImages, and not all backends return meaningful information for this. This information is not useful A #GdkByteOrder stating the byte order of @visual. A #GdkVisual. Returns the size of a colormap for this visual. You have to use platform-specific APIs to manipulate colormaps. This information is not useful, since GDK does not provide APIs to operate on colormaps. The size of a colormap that is suitable for @visual. A #GdkVisual. Returns the bit depth of this visual. The bit depth of this visual. A #GdkVisual. Obtains values that are needed to calculate green pixel values in TrueColor and DirectColor. The “mask” is the significant bits within the pixel. The “shift” is the number of bits left we must shift a primary for it to be in position (according to the "mask"). Finally, "precision" refers to how much precision the pixel value contains for a particular primary. a #GdkVisual A pointer to a #guint32 to be filled in, or %NULL A pointer to a #gint to be filled in, or %NULL A pointer to a #gint to be filled in, or %NULL Obtains values that are needed to calculate red pixel values in TrueColor and DirectColor. The “mask” is the significant bits within the pixel. The “shift” is the number of bits left we must shift a primary for it to be in position (according to the "mask"). Finally, "precision" refers to how much precision the pixel value contains for a particular primary. A #GdkVisual A pointer to a #guint32 to be filled in, or %NULL A pointer to a #gint to be filled in, or %NULL A pointer to a #gint to be filled in, or %NULL Gets the screen to which this visual belongs the screen to which this visual belongs. a #GdkVisual Returns the type of visual this is (PseudoColor, TrueColor, etc). A #GdkVisualType stating the type of @visual. A #GdkVisual. A set of values that describe the manner in which the pixel values for a visual are converted into RGB values for display. Each pixel value indexes a grayscale value directly. Each pixel is an index into a color map that maps pixel values into grayscale values. The color map can be changed by an application. Each pixel value is an index into a predefined, unmodifiable color map that maps pixel values into RGB values. Each pixel is an index into a color map that maps pixel values into rgb values. The color map can be changed by an application. Each pixel value directly contains red, green, and blue components. Use gdk_visual_get_red_pixel_details(), etc, to obtain information about how the components are assembled into a pixel value. Each pixel value contains red, green, and blue components as for %GDK_VISUAL_TRUE_COLOR, but the components are mapped via a color table into the final output table instead of being converted directly. These are hints originally defined by the Motif toolkit. The window manager can use them when determining how to decorate the window. The hint must be set before mapping the window. all decorations should be applied. a frame should be drawn around the window. the frame should have resize handles. a titlebar should be placed above the window. a button for opening a menu should be included. a minimize button should be included. a maximize button should be included. These are hints originally defined by the Motif toolkit. The window manager can use them when determining the functions to offer for the window. The hint must be set before mapping the window. all functions should be offered. the window should be resizable. the window should be movable. the window should be minimizable. the window should be maximizable. the window should be closable. Creates a new #GdkWindow using the attributes from @attributes. See #GdkWindowAttr and #GdkWindowAttributesType for more details. Note: to use this on displays other than the default display, @parent must be specified. the new #GdkWindow a #GdkWindow, or %NULL to create the window as a child of the default root window for the default display. attributes of the new window mask indicating which fields in @attributes are valid Obtains the window underneath the mouse pointer, returning the location of that window in @win_x, @win_y. Returns %NULL if the window under the mouse pointer is not known to GDK (if the window belongs to another application and a #GdkWindow hasn’t been created for it with gdk_window_foreign_new()) NOTE: For multihead-aware widgets or applications use gdk_display_get_window_at_pointer() instead. Use gdk_device_get_window_at_position() instead. window under the mouse pointer return location for origin of the window under the pointer return location for origin of the window under the pointer Constrains a desired width and height according to a set of geometry hints (such as minimum and maximum size). a #GdkGeometry structure a mask indicating what portions of @geometry are set desired width of window desired height of the window location to store resulting width location to store resulting height Calls gdk_window_process_updates() for all windows (see #GdkWindow) in the application. With update debugging enabled, calls to gdk_window_invalidate_region() clear the invalidated region of the screen to a noticeable color, and GDK pauses for a short time before sending exposes to windows during gdk_window_process_updates(). The net effect is that you can see the invalid region for each window and watch redraws as they occur. This allows you to diagnose inefficiencies in your application. In essence, because the GDK rendering model prevents all flicker, if you are redrawing the same region 400 times you may never notice, aside from noticing a speed problem. Enabling update debugging causes GTK to flicker slowly and noticeably, so you can see exactly what’s being redrawn when, in what order. The --gtk-debug=updates command line option passed to GTK+ programs enables this debug option at application startup time. That's usually more useful than calling gdk_window_set_debug_updates() yourself, though you might want to use this function to enable updates sometime after application startup time. %TRUE to turn on update debugging Adds an event filter to @window, allowing you to intercept events before they reach GDK. This is a low-level operation and makes it easy to break GDK and/or GTK+, so you have to know what you're doing. Pass %NULL for @window to get all events for all windows, instead of events for a specific window. If you are interested in X GenericEvents, bear in mind that XGetEventData() has been already called on the event, and XFreeEventData() must not be called within @function. a #GdkWindow filter callback data to pass to filter callback Emits a short beep associated to @window in the appropriate display, if supported. Otherwise, emits a short beep on the display just as gdk_display_beep(). a toplevel #GdkWindow Indicates that you are beginning the process of redrawing @region on @window, and provides you with a #GdkDrawingContext. If @window is a top level #GdkWindow, backed by a native window implementation, a backing store (offscreen buffer) large enough to contain @region will be created. The backing store will be initialized with the background color or background surface for @window. Then, all drawing operations performed on @window will be diverted to the backing store. When you call gdk_window_end_frame(), the contents of the backing store will be copied to @window, making it visible on screen. Only the part of @window contained in @region will be modified; that is, drawing operations are clipped to @region. The net result of all this is to remove flicker, because the user sees the finished product appear all at once when you call gdk_window_end_draw_frame(). If you draw to @window directly without calling gdk_window_begin_draw_frame(), the user may see flicker as individual drawing operations are performed in sequence. When using GTK+, the widget system automatically places calls to gdk_window_begin_draw_frame() and gdk_window_end_draw_frame() around emissions of the `GtkWidget::draw` signal. That is, if you’re drawing the contents of the widget yourself, you can assume that the widget has a cleared background, is already set as the clip region, and already has a backing store. Therefore in most cases, application code in GTK does not need to call gdk_window_begin_draw_frame() explicitly. a #GdkDrawingContext context that should be used to draw the contents of the window; the returned context is owned by GDK. a #GdkWindow a Cairo region Begins a window move operation (for a toplevel window). This function assumes that the drag is controlled by the client pointer device, use gdk_window_begin_move_drag_for_device() to begin a drag with a different device. a toplevel #GdkWindow the button being used to drag, or 0 for a keyboard-initiated drag root window X coordinate of mouse click that began the drag root window Y coordinate of mouse click that began the drag timestamp of mouse click that began the drag Begins a window move operation (for a toplevel window). You might use this function to implement a “window move grip,” for example. The function works best with window managers that support the [Extended Window Manager Hints](http://www.freedesktop.org/Standards/wm-spec) but has a fallback implementation for other window managers. a toplevel #GdkWindow the device used for the operation the button being used to drag, or 0 for a keyboard-initiated drag root window X coordinate of mouse click that began the drag root window Y coordinate of mouse click that began the drag timestamp of mouse click that began the drag A convenience wrapper around gdk_window_begin_paint_region() which creates a rectangular region for you. See gdk_window_begin_paint_region() for details. Use gdk_window_begin_draw_frame() instead a #GdkWindow rectangle you intend to draw to Indicates that you are beginning the process of redrawing @region. A backing store (offscreen buffer) large enough to contain @region will be created. The backing store will be initialized with the background color or background surface for @window. Then, all drawing operations performed on @window will be diverted to the backing store. When you call gdk_window_end_paint(), the backing store will be copied to @window, making it visible onscreen. Only the part of @window contained in @region will be modified; that is, drawing operations are clipped to @region. The net result of all this is to remove flicker, because the user sees the finished product appear all at once when you call gdk_window_end_paint(). If you draw to @window directly without calling gdk_window_begin_paint_region(), the user may see flicker as individual drawing operations are performed in sequence. The clipping and background-initializing features of gdk_window_begin_paint_region() are conveniences for the programmer, so you can avoid doing that work yourself. When using GTK+, the widget system automatically places calls to gdk_window_begin_paint_region() and gdk_window_end_paint() around emissions of the expose_event signal. That is, if you’re writing an expose event handler, you can assume that the exposed area in #GdkEventExpose has already been cleared to the window background, is already set as the clip region, and already has a backing store. Therefore in most cases, application code need not call gdk_window_begin_paint_region(). (You can disable the automatic calls around expose events on a widget-by-widget basis by calling gtk_widget_set_double_buffered().) If you call this function multiple times before calling the matching gdk_window_end_paint(), the backing stores are pushed onto a stack. gdk_window_end_paint() copies the topmost backing store onscreen, subtracts the topmost region from all other regions in the stack, and pops the stack. All drawing operations affect only the topmost backing store in the stack. One matching call to gdk_window_end_paint() is required for each call to gdk_window_begin_paint_region(). Use gdk_window_begin_draw_frame() instead a #GdkWindow region you intend to draw to Begins a window resize operation (for a toplevel window). This function assumes that the drag is controlled by the client pointer device, use gdk_window_begin_resize_drag_for_device() to begin a drag with a different device. a toplevel #GdkWindow the edge or corner from which the drag is started the button being used to drag, or 0 for a keyboard-initiated drag root window X coordinate of mouse click that began the drag root window Y coordinate of mouse click that began the drag timestamp of mouse click that began the drag (use gdk_event_get_time()) Begins a window resize operation (for a toplevel window). You might use this function to implement a “window resize grip,” for example; in fact #GtkStatusbar uses it. The function works best with window managers that support the [Extended Window Manager Hints](http://www.freedesktop.org/Standards/wm-spec) but has a fallback implementation for other window managers. a toplevel #GdkWindow the edge or corner from which the drag is started the device used for the operation the button being used to drag, or 0 for a keyboard-initiated drag root window X coordinate of mouse click that began the drag root window Y coordinate of mouse click that began the drag timestamp of mouse click that began the drag (use gdk_event_get_time()) Does nothing, present only for compatiblity. this function is no longer needed a toplevel #GdkWindow Transforms window coordinates from a parent window to a child window, where the parent window is the normal parent as returned by gdk_window_get_parent() for normal windows, and the window's embedder as returned by gdk_offscreen_window_get_embedder() for offscreen windows. For normal windows, calling this function is equivalent to subtracting the return values of gdk_window_get_position() from the parent coordinates. For offscreen windows however (which can be arbitrarily transformed), this function calls the GdkWindow::from-embedder: signal to translate the coordinates. You should always use this function when writing generic code that walks down a window hierarchy. See also: gdk_window_coords_to_parent() a child window X coordinate in parent’s coordinate system Y coordinate in parent’s coordinate system return location for X coordinate in child’s coordinate system return location for Y coordinate in child’s coordinate system Transforms window coordinates from a child window to its parent window, where the parent window is the normal parent as returned by gdk_window_get_parent() for normal windows, and the window's embedder as returned by gdk_offscreen_window_get_embedder() for offscreen windows. For normal windows, calling this function is equivalent to adding the return values of gdk_window_get_position() to the child coordinates. For offscreen windows however (which can be arbitrarily transformed), this function calls the GdkWindow::to-embedder: signal to translate the coordinates. You should always use this function when writing generic code that walks up a window hierarchy. See also: gdk_window_coords_from_parent() a child window X coordinate in child’s coordinate system Y coordinate in child’s coordinate system return location for X coordinate in parent’s coordinate system, or %NULL return location for Y coordinate in parent’s coordinate system, or %NULL Creates a new #GdkGLContext matching the framebuffer format to the visual of the #GdkWindow. The context is disconnected from any particular window or surface. If the creation of the #GdkGLContext failed, @error will be set. Before using the returned #GdkGLContext, you will need to call gdk_gl_context_make_current() or gdk_gl_context_realize(). the newly created #GdkGLContext, or %NULL on error a #GdkWindow Create a new image surface that is efficient to draw on the given @window. Initially the surface contents are all 0 (transparent if contents have transparency, black otherwise.) The @width and @height of the new surface are not affected by the scaling factor of the @window, or by the @scale argument; they are the size of the surface in device pixels. If you wish to create an image surface capable of holding the contents of @window you can use: |[<!-- language="C" --> int scale = gdk_window_get_scale_factor (window); int width = gdk_window_get_width (window) * scale; int height = gdk_window_get_height (window) * scale; // format is set elsewhere cairo_surface_t *surface = gdk_window_create_similar_image_surface (window, format, width, height, scale); ]| Note that unlike cairo_surface_create_similar_image(), the new surface's device scale is set to @scale, or to the scale factor of @window if @scale is 0. a pointer to the newly allocated surface. The caller owns the surface and should call cairo_surface_destroy() when done with it. This function always returns a valid pointer, but it will return a pointer to a “nil” surface if @other is already in an error state or any other error occurs. window to make new surface similar to, or %NULL if none the format for the new surface width of the new surface height of the new surface the scale of the new surface, or 0 to use same as @window Create a new surface that is as compatible as possible with the given @window. For example the new surface will have the same fallback resolution and font options as @window. Generally, the new surface will also use the same backend as @window, unless that is not possible for some reason. The type of the returned surface may be examined with cairo_surface_get_type(). Initially the surface contents are all 0 (transparent if contents have transparency, black otherwise.) a pointer to the newly allocated surface. The caller owns the surface and should call cairo_surface_destroy() when done with it. This function always returns a valid pointer, but it will return a pointer to a “nil” surface if @other is already in an error state or any other error occurs. window to make new surface similar to the content for the new surface width of the new surface height of the new surface Attempt to deiconify (unminimize) @window. On X11 the window manager may choose to ignore the request to deiconify. When using GTK+, use gtk_window_deiconify() instead of the #GdkWindow variant. Or better yet, you probably want to use gtk_window_present_with_time(), which raises the window, focuses it, unminimizes it, and puts it on the current desktop. a toplevel #GdkWindow Destroys the window system resources associated with @window and decrements @window's reference count. The window system resources for all children of @window are also destroyed, but the children’s reference counts are not decremented. Note that a window will not be destroyed automatically when its reference count reaches zero. You must call this function yourself before that happens. a #GdkWindow Does nothing, present only for compatiblity. this function is no longer needed a toplevel #GdkWindow Indicates that the drawing of the contents of @window started with gdk_window_begin_frame() has been completed. This function will take care of destroying the #GdkDrawingContext. It is an error to call this function without a matching gdk_window_begin_frame() first. a #GdkWindow the #GdkDrawingContext created by gdk_window_begin_draw_frame() Indicates that the backing store created by the most recent call to gdk_window_begin_paint_region() should be copied onscreen and deleted, leaving the next-most-recent backing store or no backing store at all as the active paint region. See gdk_window_begin_paint_region() for full details. It is an error to call this function without a matching gdk_window_begin_paint_region() first. a #GdkWindow Tries to ensure that there is a window-system native window for this GdkWindow. This may fail in some situations, returning %FALSE. Offscreen window and children of them can never have native windows. Some backends may not support native child windows. %TRUE if the window has a native window, %FALSE otherwise a #GdkWindow This function does nothing. a #GdkWindow Sets keyboard focus to @window. In most cases, gtk_window_present_with_time() should be used on a #GtkWindow, rather than calling this function. a #GdkWindow timestamp of the event triggering the window focus Temporarily freezes a window and all its descendants such that it won't receive expose events. The window will begin receiving expose events again when gdk_window_thaw_toplevel_updates_libgtk_only() is called. If gdk_window_freeze_toplevel_updates_libgtk_only() has been called more than once, gdk_window_thaw_toplevel_updates_libgtk_only() must be called an equal number of times to begin processing exposes. This function is not part of the GDK public API and is only for use by GTK+. This symbol was never meant to be used outside of GTK+ a #GdkWindow Temporarily freezes a window such that it won’t receive expose events. The window will begin receiving expose events again when gdk_window_thaw_updates() is called. If gdk_window_freeze_updates() has been called more than once, gdk_window_thaw_updates() must be called an equal number of times to begin processing exposes. a #GdkWindow Moves the window into fullscreen mode. This means the window covers the entire screen and is above any panels or task bars. If the window was already fullscreen, then this function does nothing. On X11, asks the window manager to put @window in a fullscreen state, if the window manager supports this operation. Not all window managers support this, and some deliberately ignore it or don’t have a concept of “fullscreen”; so you can’t rely on the fullscreenification actually happening. But it will happen with most standard window managers, and GDK makes a best effort to get it to happen. a toplevel #GdkWindow Moves the window into fullscreen mode on the given monitor. This means the window covers the entire screen and is above any panels or task bars. If the window was already fullscreen, then this function does nothing. UNRELEASED a toplevel #GdkWindow Which monitor to display fullscreen on. This function informs GDK that the geometry of an embedded offscreen window has changed. This is necessary for GDK to keep track of which offscreen window the pointer is in. an embedded offscreen #GdkWindow Determines whether or not the desktop environment shuld be hinted that the window does not want to receive input focus. whether or not the window should receive input focus. a toplevel #GdkWindow. Gets the pattern used to clear the background on @window. Don't use this function The pattern to use for the background or %NULL if there is no background. a window Gets the list of children of @window known to GDK. This function only returns children created via GDK, so for example it’s useless when used with the root window; it only returns windows an application created itself. The returned list must be freed, but the elements in the list need not be. list of child windows inside @window a #GdkWindow Gets the list of children of @window known to GDK with a particular @user_data set on it. The returned list must be freed, but the elements in the list need not be. The list is returned in (relative) stacking order, i.e. the lowest window is first. list of child windows inside @window a #GdkWindow user data to look for Computes the region of a window that potentially can be written to by drawing primitives. This region may not take into account other factors such as if the window is obscured by other windows, but no area outside of this region will be affected by drawing primitives. a #cairo_region_t. This must be freed with cairo_region_destroy() when you are done. a #GdkWindow Determines whether @window is composited. See gdk_window_set_composited(). Compositing is an outdated technology that only ever worked on X11. %TRUE if the window is composited. a #GdkWindow Retrieves a #GdkCursor pointer for the cursor currently set on the specified #GdkWindow, or %NULL. If the return value is %NULL then there is no custom cursor set on the specified window, and it is using the cursor for its parent window. a #GdkCursor, or %NULL. The returned object is owned by the #GdkWindow and should not be unreferenced directly. Use gdk_window_set_cursor() to unset the cursor of the window a #GdkWindow Returns the decorations set on the GdkWindow with gdk_window_set_decorations(). %TRUE if the window has decorations set, %FALSE otherwise. The toplevel #GdkWindow to get the decorations from The window decorations will be written here Retrieves a #GdkCursor pointer for the @device currently set on the specified #GdkWindow, or %NULL. If the return value is %NULL then there is no custom cursor set on the specified window, and it is using the cursor for its parent window. a #GdkCursor, or %NULL. The returned object is owned by the #GdkWindow and should not be unreferenced directly. Use gdk_window_set_cursor() to unset the cursor of the window a #GdkWindow. a master, pointer #GdkDevice. Returns the event mask for @window corresponding to an specific device. device event mask for @window a #GdkWindow. a #GdkDevice. Obtains the current device position and modifier state. The position is given in coordinates relative to the upper left corner of @window. Use gdk_window_get_device_position_double() if you need subpixel precision. The window underneath @device (as with gdk_device_get_window_at_position()), or %NULL if the window is not known to GDK. a #GdkWindow. pointer #GdkDevice to query to. return location for the X coordinate of @device, or %NULL. return location for the Y coordinate of @device, or %NULL. return location for the modifier mask, or %NULL. Obtains the current device position in doubles and modifier state. The position is given in coordinates relative to the upper left corner of @window. The window underneath @device (as with gdk_device_get_window_at_position()), or %NULL if the window is not known to GDK. a #GdkWindow. pointer #GdkDevice to query to. return location for the X coordinate of @device, or %NULL. return location for the Y coordinate of @device, or %NULL. return location for the modifier mask, or %NULL. Gets the #GdkDisplay associated with a #GdkWindow. the #GdkDisplay associated with @window a #GdkWindow Finds out the DND protocol supported by a window. the supported DND protocol. the destination window location of the window where the drop should happen. This may be @window or a proxy window, or %NULL if @window does not support Drag and Drop. Obtains the parent of @window, as known to GDK. Works like gdk_window_get_parent() for normal windows, but returns the window’s embedder for offscreen windows. See also: gdk_offscreen_window_get_embedder() effective parent of @window a #GdkWindow Gets the toplevel window that’s an ancestor of @window. Works like gdk_window_get_toplevel(), but treats an offscreen window's embedder as its parent, using gdk_window_get_effective_parent(). See also: gdk_offscreen_window_get_embedder() the effective toplevel window containing @window a #GdkWindow Get the current event compression setting for this window. %TRUE if motion events will be compressed a #GdkWindow Gets the event mask for @window for all master input devices. See gdk_window_set_events(). event mask for @window a #GdkWindow Determines whether or not the desktop environment should be hinted that the window does not want to receive input focus when it is mapped. whether or not the window wants to receive input focus when it is mapped. a toplevel #GdkWindow. Gets the frame clock for the window. The frame clock for a window never changes unless the window is reparented to a new toplevel window. the frame clock window to get frame clock for Obtains the bounding box of the window, including window manager titlebar/borders if any. The frame position is given in root window coordinates. To get the position of the window itself (rather than the frame) in root window coordinates, use gdk_window_get_origin(). a toplevel #GdkWindow rectangle to fill with bounding box of the window frame Obtains the #GdkFullscreenMode of the @window. The #GdkFullscreenMode applied to the window when fullscreen. a toplevel #GdkWindow Any of the return location arguments to this function may be %NULL, if you aren’t interested in getting the value of that field. The X and Y coordinates returned are relative to the parent window of @window, which for toplevels usually means relative to the window decorations (titlebar, etc.) rather than relative to the root window (screen-size background window). On the X11 platform, the geometry is obtained from the X server, so reflects the latest position of @window; this may be out-of-sync with the position of @window delivered in the most-recently-processed #GdkEventConfigure. gdk_window_get_position() in contrast gets the position from the most recent configure event. Note: If @window is not a toplevel, it is much better to call gdk_window_get_position(), gdk_window_get_width() and gdk_window_get_height() instead, because it avoids the roundtrip to the X server and because these functions support the full 32-bit coordinate space, whereas gdk_window_get_geometry() is restricted to the 16-bit coordinates of X11. a #GdkWindow return location for X coordinate of window (relative to its parent) return location for Y coordinate of window (relative to its parent) return location for width of window return location for height of window Returns the group leader window for @window. See gdk_window_set_group(). the group leader window for @window a toplevel #GdkWindow Returns the height of the given @window. On the X11 platform the returned size is the size reported in the most-recently-processed configure event, rather than the current size on the X server. The height of @window a #GdkWindow Determines whether or not the window manager is hinted that @window has modal behaviour. whether or not the window has the modal hint set. A toplevel #GdkWindow. Obtains the position of a window in root window coordinates. (Compare with gdk_window_get_position() and gdk_window_get_geometry() which return the position of a window relative to its parent window.) not meaningful, ignore a #GdkWindow return location for X coordinate return location for Y coordinate Obtains the parent of @window, as known to GDK. Does not query the X server; thus this returns the parent as passed to gdk_window_new(), not the actual parent. This should never matter unless you’re using Xlib calls mixed with GDK calls on the X11 platform. It may also matter for toplevel windows, because the window manager may choose to reparent them. Note that you should use gdk_window_get_effective_parent() when writing generic code that walks up a window hierarchy, because gdk_window_get_parent() will most likely not do what you expect if there are offscreen windows in the hierarchy. parent of @window a #GdkWindow Returns whether input to the window is passed through to the window below. See gdk_window_set_pass_through() for details a #GdkWindow Obtains the current pointer position and modifier state. The position is given in coordinates relative to the upper left corner of @window. Use gdk_window_get_device_position() instead. the window containing the pointer (as with gdk_window_at_pointer()), or %NULL if the window containing the pointer isn’t known to GDK a #GdkWindow return location for X coordinate of pointer or %NULL to not return the X coordinate return location for Y coordinate of pointer or %NULL to not return the Y coordinate return location for modifier mask or %NULL to not return the modifier mask Obtains the position of the window as reported in the most-recently-processed #GdkEventConfigure. Contrast with gdk_window_get_geometry() which queries the X server for the current window position, regardless of which events have been received or processed. The position coordinates are relative to the window’s parent window. a #GdkWindow X coordinate of window Y coordinate of window Obtains the position of a window position in root window coordinates. This is similar to gdk_window_get_origin() but allows you to pass in any position in the window, not just the origin. a #GdkWindow X coordinate in window Y coordinate in window return location for X coordinate return location for Y coordinate Obtains the top-left corner of the window manager frame in root window coordinates. a toplevel #GdkWindow return location for X position of window frame return location for Y position of window frame Returns the internal scale factor that maps from window coordiantes to the actual device pixels. On traditional systems this is 1, but on very high density outputs this can be a higher value (often 2). A higher value means that drawing is automatically scaled up to a higher resolution, so any code doing drawing will automatically look nicer. However, if you are supplying pixel-based data the scale value can be used to determine whether to use a pixel resource with higher resolution data. The scale of a window may change during runtime, if this happens a configure event will be sent to the toplevel window. the scale factor window to get scale factor for Gets the #GdkScreen associated with a #GdkWindow. the #GdkScreen associated with @window a #GdkWindow Returns the event mask for @window corresponding to the device class specified by @source. source event mask for @window a #GdkWindow a #GdkInputSource to define the source class. Gets the bitwise OR of the currently active window state flags, from the #GdkWindowState enumeration. window state bitfield a #GdkWindow Returns %TRUE if the window is aware of the existence of multiple devices. %TRUE if the window handles multidevice features. a #GdkWindow. Gets the toplevel window that’s an ancestor of @window. Any window type but %GDK_WINDOW_CHILD is considered a toplevel window, as is a %GDK_WINDOW_CHILD window that has a root window as parent. Note that you should use gdk_window_get_effective_toplevel() when you want to get to a window’s toplevel as seen on screen, because gdk_window_get_toplevel() will most likely not do what you expect if there are offscreen windows in the hierarchy. the toplevel window containing @window a #GdkWindow This function returns the type hint set for a window. The type hint set for @window A toplevel #GdkWindow Transfers ownership of the update area from @window to the caller of the function. That is, after calling this function, @window will no longer have an invalid/dirty region; the update area is removed from @window and handed to you. If a window has no update area, gdk_window_get_update_area() returns %NULL. You are responsible for calling cairo_region_destroy() on the returned region if it’s non-%NULL. the update area for @window a #GdkWindow Retrieves the user data for @window, which is normally the widget that @window belongs to. See gdk_window_set_user_data(). a #GdkWindow return location for user data Computes the region of the @window that is potentially visible. This does not necessarily take into account if the window is obscured by other windows, but no area outside of this region is visible. a #cairo_region_t. This must be freed with cairo_region_destroy() when you are done. a #GdkWindow Gets the #GdkVisual describing the pixel format of @window. a #GdkVisual a #GdkWindow Returns the width of the given @window. On the X11 platform the returned size is the size reported in the most-recently-processed configure event, rather than the current size on the X server. The width of @window a #GdkWindow Gets the type of the window. See #GdkWindowType. type of window a #GdkWindow Checks whether the window has a native window or not. Note that you can use gdk_window_ensure_native() if a native window is needed. %TRUE if the @window has a native window, %FALSE otherwise. a #GdkWindow For toplevel windows, withdraws them, so they will no longer be known to the window manager; for all windows, unmaps them, so they won’t be displayed. Normally done automatically as part of gtk_widget_hide(). a #GdkWindow Asks to iconify (minimize) @window. The window manager may choose to ignore the request, but normally will honor it. Using gtk_window_iconify() is preferred, if you have a #GtkWindow widget. This function only makes sense when @window is a toplevel window. a toplevel #GdkWindow Like gdk_window_shape_combine_region(), but the shape applies only to event handling. Mouse events which happen while the pointer position corresponds to an unset bit in the mask will be passed on the window below @window. An input shape is typically used with RGBA windows. The alpha channel of the window defines which pixels are invisible and allows for nicely antialiased borders, and the input shape controls where the window is “clickable”. On the X11 platform, this requires version 1.1 of the shape extension. On the Win32 platform, this functionality is not present and the function does nothing. a #GdkWindow region of window to be non-transparent X position of @shape_region in @window coordinates Y position of @shape_region in @window coordinates Adds @region to the update area for @window. The update area is the region that needs to be redrawn, or “dirty region.” The call gdk_window_process_updates() sends one or more expose events to the window, which together cover the entire update area. An application would normally redraw the contents of @window in response to those expose events. GDK will call gdk_window_process_all_updates() on your behalf whenever your program returns to the main loop and becomes idle, so normally there’s no need to do that manually, you just need to invalidate regions that you know should be redrawn. The @child_func parameter controls whether the region of each child window that intersects @region will also be invalidated. Only children for which @child_func returns #TRUE will have the area invalidated. a #GdkWindow a #cairo_region_t function to use to decide if to recurse to a child, %NULL means never recurse. data passed to @child_func A convenience wrapper around gdk_window_invalidate_region() which invalidates a rectangular region. See gdk_window_invalidate_region() for details. a #GdkWindow rectangle to invalidate or %NULL to invalidate the whole window whether to also invalidate child windows Adds @region to the update area for @window. The update area is the region that needs to be redrawn, or “dirty region.” The call gdk_window_process_updates() sends one or more expose events to the window, which together cover the entire update area. An application would normally redraw the contents of @window in response to those expose events. GDK will call gdk_window_process_all_updates() on your behalf whenever your program returns to the main loop and becomes idle, so normally there’s no need to do that manually, you just need to invalidate regions that you know should be redrawn. The @invalidate_children parameter controls whether the region of each child window that intersects @region will also be invalidated. If %FALSE, then the update area for child windows will remain unaffected. See gdk_window_invalidate_maybe_recurse if you need fine grained control over which children are invalidated. a #GdkWindow a #cairo_region_t %TRUE to also invalidate child windows Check to see if a window is destroyed.. %TRUE if the window is destroyed a #GdkWindow Determines whether or not the window is an input only window. %TRUE if @window is input only a toplevel #GdkWindow Determines whether or not the window is shaped. %TRUE if @window is shaped a toplevel #GdkWindow Check if the window and all ancestors of the window are mapped. (This is not necessarily "viewable" in the X sense, since we only check as far as we have GDK window parents, not to the root window.) %TRUE if the window is viewable a #GdkWindow Checks whether the window has been mapped (with gdk_window_show() or gdk_window_show_unraised()). %TRUE if the window is mapped a #GdkWindow Lowers @window to the bottom of the Z-order (stacking order), so that other windows with the same parent window appear above @window. This is true whether or not the other windows are visible. If @window is a toplevel, the window manager may choose to deny the request to move the window in the Z-order, gdk_window_lower() only requests the restack, does not guarantee it. Note that gdk_window_show() raises the window again, so don’t call this function before gdk_window_show(). (Try gdk_window_show_unraised().) a #GdkWindow If you call this during a paint (e.g. between gdk_window_begin_paint_region() and gdk_window_end_paint() then GDK will mark the current clip region of the window as being drawn. This is required when mixing GL rendering via gdk_cairo_draw_from_gl() and cairo rendering, as otherwise GDK has no way of knowing when something paints over the GL-drawn regions. This is typically called automatically by GTK+ and you don't need to care about this. a #GdkWindow a #cairo_t Maximizes the window. If the window was already maximized, then this function does nothing. On X11, asks the window manager to maximize @window, if the window manager supports this operation. Not all window managers support this, and some deliberately ignore it or don’t have a concept of “maximized”; so you can’t rely on the maximization actually happening. But it will happen with most standard window managers, and GDK makes a best effort to get it to happen. On Windows, reliably maximizes the window. a toplevel #GdkWindow Merges the input shape masks for any child windows into the input shape mask for @window. i.e. the union of all input masks for @window and its children will become the new input mask for @window. See gdk_window_input_shape_combine_region(). This function is distinct from gdk_window_set_child_input_shapes() because it includes @window’s input shape mask in the set of shapes to be merged. a #GdkWindow Merges the shape masks for any child windows into the shape mask for @window. i.e. the union of all masks for @window and its children will become the new mask for @window. See gdk_window_shape_combine_region(). This function is distinct from gdk_window_set_child_shapes() because it includes @window’s shape mask in the set of shapes to be merged. a #GdkWindow Repositions a window relative to its parent window. For toplevel windows, window managers may ignore or modify the move; you should probably use gtk_window_move() on a #GtkWindow widget anyway, instead of using GDK functions. For child windows, the move will reliably succeed. If you’re also planning to resize the window, use gdk_window_move_resize() to both move and resize simultaneously, for a nicer visual effect. a #GdkWindow X coordinate relative to window’s parent Y coordinate relative to window’s parent Move the part of @window indicated by @region by @dy pixels in the Y direction and @dx pixels in the X direction. The portions of @region that not covered by the new position of @region are invalidated. Child windows are not moved. a #GdkWindow The #cairo_region_t to move Amount to move in the X direction Amount to move in the Y direction Equivalent to calling gdk_window_move() and gdk_window_resize(), except that both operations are performed at once, avoiding strange visual effects. (i.e. the user may be able to see the window first move, then resize, if you don’t use gdk_window_move_resize().) a #GdkWindow new X position relative to window’s parent new Y position relative to window’s parent new width new height Moves @window to @rect, aligning their anchor points. @rect is relative to the top-left corner of the window that @window is transient for. @rect_anchor and @window_anchor determine anchor points on @rect and @window to pin together. @rect's anchor point can optionally be offset by @rect_anchor_dx and @rect_anchor_dy, which is equivalent to offsetting the position of @window. @anchor_hints determines how @window will be moved if the anchor points cause it to move off-screen. For example, %GDK_ANCHOR_FLIP_X will replace %GDK_GRAVITY_NORTH_WEST with %GDK_GRAVITY_NORTH_EAST and vice versa if @window extends beyond the left or right edges of the monitor. Connect to the #GdkWindow::moved-to-rect signal to find out how it was actually positioned. the #GdkWindow to move the destination #GdkRectangle to align @window with the point on @rect to align with @window's anchor point the point on @window to align with @rect's anchor point positioning hints to use when limited on space horizontal offset to shift @window, i.e. @rect's anchor point vertical offset to shift @window, i.e. @rect's anchor point Like gdk_window_get_children(), but does not copy the list of children, so the list does not need to be freed. a reference to the list of child windows in @window a #GdkWindow Sends one or more expose events to @window. The areas in each expose event will cover the entire update area for the window (see gdk_window_invalidate_region() for details). Normally GDK calls gdk_window_process_all_updates() on your behalf, so there’s no need to call this function unless you want to force expose events to be delivered immediately and synchronously (vs. the usual case, where GDK delivers them in an idle handler). Occasionally this is useful to produce nicer scrolling behavior, for example. a #GdkWindow whether to also process updates for child windows Raises @window to the top of the Z-order (stacking order), so that other windows with the same parent window appear below @window. This is true whether or not the windows are visible. If @window is a toplevel, the window manager may choose to deny the request to move the window in the Z-order, gdk_window_raise() only requests the restack, does not guarantee it. a #GdkWindow Registers a window as a potential drop destination. a #GdkWindow. Remove a filter previously added with gdk_window_add_filter(). a #GdkWindow previously-added filter function user data for previously-added filter function Reparents @window into the given @new_parent. The window being reparented will be unmapped as a side effect. a #GdkWindow new parent to move @window into X location inside the new parent Y location inside the new parent Resizes @window; for toplevel windows, asks the window manager to resize the window. The window manager may not allow the resize. When using GTK+, use gtk_window_resize() instead of this low-level GDK function. Windows may not be resized below 1x1. If you’re also planning to move the window, use gdk_window_move_resize() to both move and resize simultaneously, for a nicer visual effect. a #GdkWindow new width of the window new height of the window Changes the position of @window in the Z-order (stacking order), so that it is above @sibling (if @above is %TRUE) or below @sibling (if @above is %FALSE). If @sibling is %NULL, then this either raises (if @above is %TRUE) or lowers the window. If @window is a toplevel, the window manager may choose to deny the request to move the window in the Z-order, gdk_window_restack() only requests the restack, does not guarantee it. a #GdkWindow a #GdkWindow that is a sibling of @window, or %NULL a boolean Scroll the contents of @window, both pixels and children, by the given amount. @window itself does not move. Portions of the window that the scroll operation brings in from offscreen areas are invalidated. The invalidated region may be bigger than what would strictly be necessary. For X11, a minimum area will be invalidated if the window has no subwindows, or if the edges of the window’s parent do not extend beyond the edges of the window. In other cases, a multi-step process is used to scroll the window which may produce temporary visual artifacts and unnecessary invalidations. a #GdkWindow Amount to scroll in the X direction Amount to scroll in the Y direction Setting @accept_focus to %FALSE hints the desktop environment that the window doesn’t want to receive input focus. On X, it is the responsibility of the window manager to interpret this hint. ICCCM-compliant window manager usually respect it. a toplevel #GdkWindow %TRUE if the window should receive input focus Sets the background color of @window. However, when using GTK+, influence the background of a widget using a style class or CSS — if you’re an application — or with gtk_style_context_set_background() — if you're implementing a custom widget. Don't use this function a #GdkWindow a #GdkColor Sets the background of @window. A background of %NULL means that the window won't have any background. On the X11 backend it's also possible to inherit the background from the parent window using gdk_x11_get_parent_relative_pattern(). The windowing system will normally fill a window with its background when the window is obscured then exposed. Don't use this function a #GdkWindow a pattern to use, or %NULL Sets the background color of @window. See also gdk_window_set_background_pattern(). Don't use this function a #GdkWindow a #GdkRGBA color Sets the input shape mask of @window to the union of input shape masks for all children of @window, ignoring the input shape mask of @window itself. Contrast with gdk_window_merge_child_input_shapes() which includes the input shape mask of @window in the masks to be merged. a #GdkWindow Sets the shape mask of @window to the union of shape masks for all children of @window, ignoring the shape mask of @window itself. Contrast with gdk_window_merge_child_shapes() which includes the shape mask of @window in the masks to be merged. a #GdkWindow Sets a #GdkWindow as composited, or unsets it. Composited windows do not automatically have their contents drawn to the screen. Drawing is redirected to an offscreen buffer and an expose event is emitted on the parent of the composited window. It is the responsibility of the parent’s expose handler to manually merge the off-screen content onto the screen in whatever way it sees fit. It only makes sense for child windows to be composited; see gdk_window_set_opacity() if you need translucent toplevel windows. An additional effect of this call is that the area of this window is no longer clipped from regions marked for invalidation on its parent. Draws done on the parent window are also no longer clipped by the child. This call is only supported on some systems (currently, only X11 with new enough Xcomposite and Xdamage extensions). You must call gdk_display_supports_composite() to check if setting a window as composited is supported before attempting to do so. Compositing is an outdated technology that only ever worked on X11. a #GdkWindow %TRUE to set the window as composited Sets the default mouse pointer for a #GdkWindow. Note that @cursor must be for the same display as @window. Use gdk_cursor_new_for_display() or gdk_cursor_new_from_pixbuf() to create the cursor. To make the cursor invisible, use %GDK_BLANK_CURSOR. Passing %NULL for the @cursor argument to gdk_window_set_cursor() means that @window will use the cursor of its parent window. Most windows should use this default. a #GdkWindow a cursor “Decorations” are the features the window manager adds to a toplevel #GdkWindow. This function sets the traditional Motif window manager hints that tell the window manager which decorations you would like your window to have. Usually you should use gtk_window_set_decorated() on a #GtkWindow instead of using the GDK function directly. The @decorations argument is the logical OR of the fields in the #GdkWMDecoration enumeration. If #GDK_DECOR_ALL is included in the mask, the other bits indicate which decorations should be turned off. If #GDK_DECOR_ALL is not included, then the other bits indicate which decorations should be turned on. Most window managers honor a decorations hint of 0 to disable all decorations, but very few honor all possible combinations of bits. a toplevel #GdkWindow decoration hint mask Sets a specific #GdkCursor for a given device when it gets inside @window. Use gdk_cursor_new_for_display() or gdk_cursor_new_from_pixbuf() to create the cursor. To make the cursor invisible, use %GDK_BLANK_CURSOR. Passing %NULL for the @cursor argument to gdk_window_set_cursor() means that @window will use the cursor of its parent window. Most windows should use this default. a #GdkWindow a master, pointer #GdkDevice a #GdkCursor Sets the event mask for a given device (Normally a floating device, not attached to any visible pointer) to @window. For example, an event mask including #GDK_BUTTON_PRESS_MASK means the window should report button press events. The event mask is the bitwise OR of values from the #GdkEventMask enumeration. See the [input handling overview][event-masks] for details. a #GdkWindow #GdkDevice to enable events for. event mask for @window Determines whether or not extra unprocessed motion events in the event queue can be discarded. If %TRUE only the most recent event will be delivered. Some types of applications, e.g. paint programs, need to see all motion events and will benefit from turning off event compression. By default, event compression is enabled. a #GdkWindow %TRUE if motion events should be compressed The event mask for a window determines which events will be reported for that window from all master input devices. For example, an event mask including #GDK_BUTTON_PRESS_MASK means the window should report button press events. The event mask is the bitwise OR of values from the #GdkEventMask enumeration. See the [input handling overview][event-masks] for details. a #GdkWindow event mask for @window Setting @focus_on_map to %FALSE hints the desktop environment that the window doesn’t want to receive input focus when it is mapped. focus_on_map should be turned off for windows that aren’t triggered interactively (such as popups from network activity). On X, it is the responsibility of the window manager to interpret this hint. Window managers following the freedesktop.org window manager extension specification should respect it. a toplevel #GdkWindow %TRUE if the window should receive input focus when mapped Specifies whether the @window should span over all monitors (in a multi-head setup) or only the current monitor when in fullscreen mode. The @mode argument is from the #GdkFullscreenMode enumeration. If #GDK_FULLSCREEN_ON_ALL_MONITORS is specified, the fullscreen @window will span over all monitors from the #GdkScreen. On X11, searches through the list of monitors from the #GdkScreen the ones which delimit the 4 edges of the entire #GdkScreen and will ask the window manager to span the @window over these monitors. If the XINERAMA extension is not available or not usable, this function has no effect. Not all window managers support this, so you can’t rely on the fullscreen window to span over the multiple monitors when #GDK_FULLSCREEN_ON_ALL_MONITORS is specified. a toplevel #GdkWindow fullscreen mode Sets hints about the window management functions to make available via buttons on the window frame. On the X backend, this function sets the traditional Motif window manager hint for this purpose. However, few window managers do anything reliable or interesting with this hint. Many ignore it entirely. The @functions argument is the logical OR of values from the #GdkWMFunction enumeration. If the bitmask includes #GDK_FUNC_ALL, then the other bits indicate which functions to disable; if it doesn’t include #GDK_FUNC_ALL, it indicates which functions to enable. a toplevel #GdkWindow bitmask of operations to allow on @window Sets the geometry hints for @window. Hints flagged in @geom_mask are set, hints not flagged in @geom_mask are unset. To unset all hints, use a @geom_mask of 0 and a @geometry of %NULL. This function provides hints to the windowing system about acceptable sizes for a toplevel window. The purpose of this is to constrain user resizing, but the windowing system will typically (but is not required to) also constrain the current size of the window to the provided values and constrain programatic resizing via gdk_window_resize() or gdk_window_move_resize(). Note that on X11, this effect has no effect on windows of type %GDK_WINDOW_TEMP or windows where override redirect has been turned on via gdk_window_set_override_redirect() since these windows are not resizable by the user. Since you can’t count on the windowing system doing the constraints for programmatic resizes, you should generally call gdk_window_constrain_size() yourself to determine appropriate sizes. a toplevel #GdkWindow geometry hints bitmask indicating fields of @geometry to pay attention to Sets the group leader window for @window. By default, GDK sets the group leader for all toplevel windows to a global window implicitly created by GDK. With this function you can override this default. The group leader window allows the window manager to distinguish all windows that belong to a single application. It may for example allow users to minimize/unminimize all windows belonging to an application at once. You should only set a non-default group window if your application pretends to be multiple applications. a toplevel #GdkWindow group leader window, or %NULL to restore the default group leader window Sets a list of icons for the window. One of these will be used to represent the window when it has been iconified. The icon is usually shown in an icon box or some sort of task bar. Which icon size is shown depends on the window manager. The window manager can scale the icon but setting several size icons can give better image quality since the window manager may only need to scale the icon by a small amount or not at all. Note that some platforms don't support window icons. The #GdkWindow toplevel window to set the icon of. A list of pixbufs, of different sizes. Windows may have a name used while minimized, distinct from the name they display in their titlebar. Most of the time this is a bad idea from a user interface standpoint. But you can set such a name with this function, if you like. After calling this with a non-%NULL @name, calls to gdk_window_set_title() will not update the icon title. Using %NULL for @name unsets the icon title; further calls to gdk_window_set_title() will again update the icon title as well. Note that some platforms don't support window icons. a toplevel #GdkWindow name of window while iconified (minimized) Registers an invalidate handler for a specific window. This will get called whenever a region in the window or its children is invalidated. This can be used to record the invalidated region, which is useful if you are keeping an offscreen copy of some region and want to keep it up to date. You can also modify the invalidated region in case you’re doing some effect where e.g. a child widget appears in multiple places. a #GdkWindow a #GdkWindowInvalidateHandlerFunc callback function Set if @window must be kept above other windows. If the window was already above, then this function does nothing. On X11, asks the window manager to keep @window above, if the window manager supports this operation. Not all window managers support this, and some deliberately ignore it or don’t have a concept of “keep above”; so you can’t rely on the window being kept above. But it will happen with most standard window managers, and GDK makes a best effort to get it to happen. a toplevel #GdkWindow whether to keep @window above other windows Set if @window must be kept below other windows. If the window was already below, then this function does nothing. On X11, asks the window manager to keep @window below, if the window manager supports this operation. Not all window managers support this, and some deliberately ignore it or don’t have a concept of “keep below”; so you can’t rely on the window being kept below. But it will happen with most standard window managers, and GDK makes a best effort to get it to happen. a toplevel #GdkWindow whether to keep @window below other windows The application can use this hint to tell the window manager that a certain window has modal behaviour. The window manager can use this information to handle modal windows in a special way. You should only use this on windows for which you have previously called gdk_window_set_transient_for() A toplevel #GdkWindow %TRUE if the window is modal, %FALSE otherwise. Set @window to render as partially transparent, with opacity 0 being fully transparent and 1 fully opaque. (Values of the opacity parameter are clamped to the [0,1] range.) For toplevel windows this depends on support from the windowing system that may not always be there. For instance, On X11, this works only on X screens with a compositing manager running. On Wayland, there is no per-window opacity value that the compositor would apply. Instead, use `gdk_window_set_opaque_region (window, NULL)` to tell the compositor that the entire window is (potentially) non-opaque, and draw your content with alpha, or use gtk_widget_set_opacity() to set an overall opacity for your widgets. For child windows this function only works for non-native windows. For setting up per-pixel alpha topelevels, see gdk_screen_get_rgba_visual(), and for non-toplevels, see gdk_window_set_composited(). Support for non-toplevel windows was added in 3.8. a top-level or non-native #GdkWindow opacity For optimisation purposes, compositing window managers may like to not draw obscured regions of windows, or turn off blending during for these regions. With RGB windows with no transparency, this is just the shape of the window, but with ARGB32 windows, the compositor does not know what regions of the window are transparent or not. This function only works for toplevel windows. GTK+ will update this property automatically if the @window background is opaque, as we know where the opaque regions are. If your window background is not opaque, please update this property in your #GtkWidget::style-updated handler. a top-level or non-native #GdkWindow a region, or %NULL An override redirect window is not under the control of the window manager. This means it won’t have a titlebar, won’t be minimizable, etc. - it will be entirely under the control of the application. The window manager can’t see the override redirect window at all. Override redirect should only be used for short-lived temporary windows, such as popup menus. #GtkMenu uses an override redirect window in its implementation, for example. a toplevel #GdkWindow %TRUE if window should be override redirect Sets whether input to the window is passed through to the window below. The default value of this is %FALSE, which means that pointer events that happen inside the window are send first to the window, but if the event is not selected by the event mask then the event is sent to the parent window, and so on up the hierarchy. If @pass_through is %TRUE then such pointer events happen as if the window wasn't there at all, and thus will be sent first to any windows below @window. This is useful if the window is used in a transparent fashion. In the terminology of the web this would be called "pointer-events: none". Note that a window with @pass_through %TRUE can still have a subwindow without pass through, so you can get events on a subset of a window. And in that cases you would get the in-between related events such as the pointer enter/leave events on its way to the destination window. a #GdkWindow a boolean When using GTK+, typically you should use gtk_window_set_role() instead of this low-level function. The window manager and session manager use a window’s role to distinguish it from other kinds of window in the same application. When an application is restarted after being saved in a previous session, all windows with the same title and role are treated as interchangeable. So if you have two windows with the same title that should be distinguished for session management purposes, you should set the role on those windows. It doesn’t matter what string you use for the role, as long as you have a different role for each non-interchangeable kind of window. a toplevel #GdkWindow a string indicating its role Newer GTK+ windows using client-side decorations use extra geometry around their frames for effects like shadows and invisible borders. Window managers that want to maximize windows or snap to edges need to know where the extents of the actual frame lie, so that users don’t feel like windows are snapping against random invisible edges. Note that this property is automatically updated by GTK+, so this function should only be used by applications which do not use GTK+ to create toplevel windows. a #GdkWindow The left extent The right extent The top extent The bottom extent Toggles whether a window should appear in a pager (workspace switcher, or other desktop utility program that displays a small thumbnail representation of the windows on the desktop). If a window’s semantic type as specified with gdk_window_set_type_hint() already fully describes the window, this function should not be called in addition, instead you should allow the window to be treated according to standard policy for its semantic type. a toplevel #GdkWindow %TRUE to skip the pager Toggles whether a window should appear in a task list or window list. If a window’s semantic type as specified with gdk_window_set_type_hint() already fully describes the window, this function should not be called in addition, instead you should allow the window to be treated according to standard policy for its semantic type. a toplevel #GdkWindow %TRUE to skip the taskbar Sets the event mask for any floating device (i.e. not attached to any visible pointer) that has the source defined as @source. This event mask will be applied both to currently existing, newly added devices after this call, and devices being attached/detached. a #GdkWindow a #GdkInputSource to define the source class. event mask for @window When using GTK+, typically you should use gtk_window_set_startup_id() instead of this low-level function. a toplevel #GdkWindow a string with startup-notification identifier Used to set the bit gravity of the given window to static, and flag it so all children get static subwindow gravity. This is used if you are implementing scary features that involve deep knowledge of the windowing system. Don’t worry about it. static gravities haven't worked on anything but X11 for a long time. %FALSE a #GdkWindow %TRUE to turn on static gravity This function will enable multidevice features in @window. Multidevice aware windows will need to handle properly multiple, per device enter/leave events, device grabs and grab ownerships. a #GdkWindow. %TRUE to enable multidevice support in @window. Sets the title of a toplevel window, to be displayed in the titlebar. If you haven’t explicitly set the icon name for the window (using gdk_window_set_icon_name()), the icon name will be set to @title as well. @title must be in UTF-8 encoding (as with all user-readable strings in GDK/GTK+). @title may not be %NULL. a toplevel #GdkWindow title of @window Indicates to the window manager that @window is a transient dialog associated with the application window @parent. This allows the window manager to do things like center @window on @parent and keep @window above @parent. See gtk_window_set_transient_for() if you’re using #GtkWindow or #GtkDialog. a toplevel #GdkWindow another toplevel #GdkWindow The application can use this call to provide a hint to the window manager about the functionality of a window. The window manager can use this information when determining the decoration and behaviour of the window. The hint must be set before the window is mapped. A toplevel #GdkWindow A hint of the function this window will have Toggles whether a window needs the user's urgent attention. a toplevel #GdkWindow %TRUE if the window is urgent For most purposes this function is deprecated in favor of g_object_set_data(). However, for historical reasons GTK+ stores the #GtkWidget that owns a #GdkWindow as user data on the #GdkWindow. So, custom widget implementations should use this function for that. If GTK+ receives an event for a #GdkWindow, and the user data for the window is non-%NULL, GTK+ will assume the user data is a #GtkWidget, and forward the event to that widget. a #GdkWindow user data Makes pixels in @window outside @shape_region be transparent, so that the window may be nonrectangular. If @shape_region is %NULL, the shape will be unset, so the whole window will be opaque again. @offset_x and @offset_y are ignored if @shape_region is %NULL. On the X11 platform, this uses an X server extension which is widely available on most common platforms, but not available on very old X servers, and occasionally the implementation will be buggy. On servers without the shape extension, this function will do nothing. This function works on both toplevel and child windows. a #GdkWindow region of window to be non-transparent X position of @shape_region in @window coordinates Y position of @shape_region in @window coordinates Like gdk_window_show_unraised(), but also raises the window to the top of the window stack (moves the window to the front of the Z-order). This function maps a window so it’s visible onscreen. Its opposite is gdk_window_hide(). When implementing a #GtkWidget, you should call this function on the widget's #GdkWindow as part of the “map” method. a #GdkWindow Shows a #GdkWindow onscreen, but does not modify its stacking order. In contrast, gdk_window_show() will raise the window to the top of the window stack. On the X11 platform, in Xlib terms, this function calls XMapWindow() (it also updates some internal GDK state, which means that you can’t really use XMapWindow() directly on a GDK window). a #GdkWindow Asks the windowing system to show the window menu. The window menu is the menu shown when right-clicking the titlebar on traditional windows managed by the window manager. This is useful for windows using client-side decorations, activating it with a right-click on the window decorations. %TRUE if the window menu was shown and %FALSE otherwise. a #GdkWindow a #GdkEvent to show the menu for “Pins” a window such that it’s on all workspaces and does not scroll with viewports, for window managers that have scrollable viewports. (When using #GtkWindow, gtk_window_stick() may be more useful.) On the X11 platform, this function depends on window manager support, so may have no effect with many window managers. However, GDK will do the best it can to convince the window manager to stick the window. For window managers that don’t support this operation, there’s nothing you can do to force it to happen. a toplevel #GdkWindow Thaws a window frozen with gdk_window_freeze_toplevel_updates_libgtk_only(). This function is not part of the GDK public API and is only for use by GTK+. This symbol was never meant to be used outside of GTK+ a #GdkWindow Thaws a window frozen with gdk_window_freeze_updates(). a #GdkWindow Moves the window out of fullscreen mode. If the window was not fullscreen, does nothing. On X11, asks the window manager to move @window out of the fullscreen state, if the window manager supports this operation. Not all window managers support this, and some deliberately ignore it or don’t have a concept of “fullscreen”; so you can’t rely on the unfullscreenification actually happening. But it will happen with most standard window managers, and GDK makes a best effort to get it to happen. a toplevel #GdkWindow Unmaximizes the window. If the window wasn’t maximized, then this function does nothing. On X11, asks the window manager to unmaximize @window, if the window manager supports this operation. Not all window managers support this, and some deliberately ignore it or don’t have a concept of “maximized”; so you can’t rely on the unmaximization actually happening. But it will happen with most standard window managers, and GDK makes a best effort to get it to happen. On Windows, reliably unmaximizes the window. a toplevel #GdkWindow Reverse operation for gdk_window_stick(); see gdk_window_stick(), and gtk_window_unstick(). a toplevel #GdkWindow Withdraws a window (unmaps it and asks the window manager to forget about it). This function is not really useful as gdk_window_hide() automatically withdraws toplevel windows before hiding them. a toplevel #GdkWindow The mouse pointer for a #GdkWindow. See gdk_window_set_cursor() and gdk_window_get_cursor() for details. The ::create-surface signal is emitted when an offscreen window needs its surface (re)created, which happens either when the window is first drawn to, or when the window is being resized. The first signal handler that returns a non-%NULL surface will stop any further signal emission, and its surface will be used. Note that it is not possible to access the window's previous surface from within any callback of this signal. Calling gdk_offscreen_window_get_surface() will lead to a crash. the newly created #cairo_surface_t for the offscreen window the width of the offscreen surface to create the height of the offscreen surface to create The ::from-embedder signal is emitted to translate coordinates in the embedder of an offscreen window to the offscreen window. See also #GdkWindow::to-embedder. x coordinate in the embedder window y coordinate in the embedder window return location for the x coordinate in the offscreen window return location for the y coordinate in the offscreen window Emitted when the position of @window is finalized after being moved to a destination rectangle. @window might be flipped over the destination rectangle in order to keep it on-screen, in which case @flipped_x and @flipped_y will be set to %TRUE accordingly. @flipped_rect is the ideal position of @window after any possible flipping, but before any possible sliding. @final_rect is @flipped_rect, but possibly translated in the case that flipping is still ineffective in keeping @window on-screen. the position of @window after any possible flipping or %NULL if the backend can't obtain it the final position of @window or %NULL if the backend can't obtain it %TRUE if the anchors were flipped horizontally %TRUE if the anchors were flipped vertically The ::pick-embedded-child signal is emitted to find an embedded child at the given position. the #GdkWindow of the embedded child at @x, @y, or %NULL x coordinate in the window y coordinate in the window The ::to-embedder signal is emitted to translate coordinates in an offscreen window to its embedder. See also #GdkWindow::from-embedder. x coordinate in the offscreen window y coordinate in the offscreen window return location for the x coordinate in the embedder window return location for the y coordinate in the embedder window Attributes to use for a newly-created window. title of the window (for toplevel windows) event mask (see gdk_window_set_events()) X coordinate relative to parent window (see gdk_window_move()) Y coordinate relative to parent window (see gdk_window_move()) width of window height of window #GDK_INPUT_OUTPUT (normal window) or #GDK_INPUT_ONLY (invisible window that receives events) #GdkVisual for window type of window cursor for the window (see gdk_window_set_cursor()) don’t use (see gtk_window_set_wmclass()) don’t use (see gtk_window_set_wmclass()) %TRUE to bypass the window manager a hint of the function of the window Used to indicate which fields in the #GdkWindowAttr struct should be honored. For example, if you filled in the “cursor” and “x” fields of #GdkWindowAttr, pass “@GDK_WA_X | @GDK_WA_CURSOR” to gdk_window_new(). Fields in #GdkWindowAttr not covered by a bit in this enum are required; for example, the @width/@height, @wclass, and @window_type fields are required, they have no corresponding flag in #GdkWindowAttributesType. Honor the title field Honor the X coordinate field Honor the Y coordinate field Honor the cursor field Honor the visual field Honor the wmclass_class and wmclass_name fields Honor the override_redirect field Honor the type_hint field A function of this type is passed to gdk_window_invalidate_maybe_recurse(). It gets called for each child of the window to determine whether to recursively invalidate it or now. %TRUE to invalidate @window recursively a #GdkWindow user data Determines a window edge or corner. the top left corner. the top edge. the top right corner. the left edge. the right edge. the lower left corner. the lower edge. the lower right corner. Used to indicate which fields of a #GdkGeometry struct should be paid attention to. Also, the presence/absence of @GDK_HINT_POS, @GDK_HINT_USER_POS, and @GDK_HINT_USER_SIZE is significant, though they don't directly refer to #GdkGeometry fields. @GDK_HINT_USER_POS will be set automatically by #GtkWindow if you call gtk_window_move(). @GDK_HINT_USER_POS and @GDK_HINT_USER_SIZE should be set if the user specified a size/position using a --geometry command-line argument; gtk_window_parse_geometry() automatically sets these flags. indicates that the program has positioned the window min size fields are set max size fields are set base size fields are set aspect ratio fields are set resize increment fields are set window gravity field is set indicates that the window’s position was explicitly set by the user indicates that the window’s size was explicitly set by the user Whenever some area of the window is invalidated (directly in the window or in a child window) this gets called with @region in the coordinate space of @window. You can use @region to just keep track of the dirty region, or you can actually change @region in case you are doing display tricks like showing a child in multiple places. a #GdkWindow a #cairo_region_t Specifies the state of a toplevel window. the window is not shown. the window is minimized. the window is maximized. the window is sticky. the window is maximized without decorations. the window is kept above other windows. the window is kept below other windows. the window is presented as focused (with active decorations). the window is in a tiled state, Since 3.10. Since 3.22.23, this is deprecated in favor of per-edge information. whether the top edge is tiled, Since 3.22.23 whether the top edge is resizable, Since 3.22.23 whether the right edge is tiled, Since 3.22.23 whether the right edge is resizable, Since 3.22.23 whether the bottom edge is tiled, Since 3.22.23 whether the bottom edge is resizable, Since 3.22.23 whether the left edge is tiled, Since 3.22.23 whether the left edge is resizable, Since 3.22.23 Describes the kind of window. root window; this window has no parent, covers the entire screen, and is created by the window system toplevel window (used to implement #GtkWindow) child window (used to implement e.g. #GtkEntry) override redirect temporary window (used to implement #GtkMenu) foreign window (see gdk_window_foreign_new()) offscreen window (see [Offscreen Windows][OFFSCREEN-WINDOWS]). Since 2.18 subsurface-based window; This window is visually tied to a toplevel, and is moved/stacked with it. Currently this window type is only implemented in Wayland. Since 3.14 These are hints for the window manager that indicate what type of function the window has. The window manager can use this when determining decoration and behaviour of the window. The hint must be set before mapping the window. See the [Extended Window Manager Hints](http://www.freedesktop.org/Standards/wm-spec) specification for more details about window types. Normal toplevel window. Dialog window. Window used to implement a menu; GTK+ uses this hint only for torn-off menus, see #GtkTearoffMenuItem. Window used to implement toolbars. Window used to display a splash screen during application startup. Utility windows which are not detached toolbars or dialogs. Used for creating dock or panel windows. Used for creating the desktop background window. A menu that belongs to a menubar. A menu that does not belong to a menubar, e.g. a context menu. A tooltip. A notification - typically a “bubble” that belongs to a status icon. A popup from a combo box. A window that is used to implement a DND cursor. @GDK_INPUT_OUTPUT windows are the standard kind of window you might expect. Such windows receive events and are also displayed on screen. @GDK_INPUT_ONLY windows are invisible; they are usually placed above other windows in order to trap or filter the events. You can’t draw on @GDK_INPUT_ONLY windows. window for graphics and events window for events only Appends gdk option entries to the passed in option group. This is not public API and must not be used by applications. This symbol was never meant to be used outside of GTK+ An option group. Finds or creates an atom corresponding to a given string. the atom corresponding to @atom_name. a string. if %TRUE, GDK is allowed to not create a new atom, but just return %GDK_NONE if the requested atom doesn’t already exists. Currently, the flag is ignored, since checking the existance of an atom is as expensive as creating it. Finds or creates an atom corresponding to a given string. Note that this function is identical to gdk_atom_intern() except that if a new #GdkAtom is created the string itself is used rather than a copy. This saves memory, but can only be used if the string will always exist. It can be used with statically allocated strings in the main program, but not with statically allocated memory in dynamically loaded modules, if you expect to ever unload the module again (e.g. do not use this function in GTK+ theme engines). the atom corresponding to @atom_name a static string Emits a short beep on the default display. Creates a Cairo context for drawing to @window. Note that calling cairo_reset_clip() on the resulting #cairo_t will produce undefined results, so avoid it at all costs. Typically, this function is used to draw on a #GdkWindow out of the paint cycle of the toolkit; this should be avoided, as it breaks various assumptions and optimizations. If you are drawing on a native #GdkWindow in response to a %GDK_EXPOSE event you should use gdk_window_begin_draw_frame() and gdk_drawing_context_get_cairo_context() instead. GTK will automatically do this for you when drawing a widget. Use gdk_window_begin_draw_frame() and gdk_drawing_context_get_cairo_context() instead A newly created Cairo context. Free with cairo_destroy() when you are done drawing. a #GdkWindow This is the main way to draw GL content in GTK+. It takes a render buffer ID (@source_type == #GL_RENDERBUFFER) or a texture id (@source_type == #GL_TEXTURE) and draws it onto @cr with an OVER operation, respecting the current clip. The top left corner of the rectangle specified by @x, @y, @width and @height will be drawn at the current (0,0) position of the cairo_t. This will work for *all* cairo_t, as long as @window is realized, but the fallback implementation that reads back the pixels from the buffer may be used in the general case. In the case of direct drawing to a window with no special effects applied to @cr it will however use a more efficient approach. For #GL_RENDERBUFFER the code will always fall back to software for buffers with alpha components, so make sure you use #GL_TEXTURE if using alpha. Calling this may change the current GL context. a cairo context The window we're rendering for (not necessarily into) The GL ID of the source buffer The type of the @source The scale-factor that the @source buffer is allocated for The source x position in @source to start copying from in GL coordinates The source y position in @source to start copying from in GL coordinates The width of the region to draw The height of the region to draw This is a convenience function around cairo_clip_extents(). It rounds the clip extents to integer coordinates and returns a boolean indicating if a clip area exists. %TRUE if a clip rectangle exists, %FALSE if all of @cr is clipped and all drawing can be skipped a cairo context return location for the clip, or %NULL Retrieves the #GdkDrawingContext that created the Cairo context @cr. a #GdkDrawingContext, if any is set a Cairo context [Cairo](http://cairographics.org) is a graphics library that supports vector graphics and image compositing that can be used with GDK. GTK+ does all of its drawing using cairo. GDK does not wrap the cairo API, instead it allows to create cairo contexts which can be used to draw on #GdkWindows. Additional functions allow use #GdkRectangles with cairo and to use #GdkColors, #GdkRGBAs, #GdkPixbufs and #GdkWindows as sources for drawing operations. Adds the given rectangle to the current path of @cr. a cairo context a #GdkRectangle Adds the given region to the current path of @cr. a cairo context a #cairo_region_t Creates region that describes covers the area where the given @surface is more than 50% opaque. This function takes into account device offsets that might be set with cairo_surface_set_device_offset(). A #cairo_region_t; must be freed with cairo_region_destroy() a cairo surface Sets the specified #GdkColor as the source color of @cr. Use gdk_cairo_set_source_rgba() instead a cairo context a #GdkColor Sets the given pixbuf as the source pattern for @cr. The pattern has an extend mode of %CAIRO_EXTEND_NONE and is aligned so that the origin of @pixbuf is @pixbuf_x, @pixbuf_y. a cairo context a #GdkPixbuf X coordinate of location to place upper left corner of @pixbuf Y coordinate of location to place upper left corner of @pixbuf Sets the specified #GdkRGBA as the source color of @cr. a cairo context a #GdkRGBA Sets the given window as the source pattern for @cr. The pattern has an extend mode of %CAIRO_EXTEND_NONE and is aligned so that the origin of @window is @x, @y. The window contains all its subwindows when rendering. Note that the contents of @window are undefined outside of the visible part of @window, so use this function with care. a cairo context a #GdkWindow X coordinate of location to place upper left corner of @window Y coordinate of location to place upper left corner of @window Creates an image surface with the same contents as the pixbuf. a new cairo surface, must be freed with cairo_surface_destroy() a #GdkPixbuf the scale of the new surface, or 0 to use same as @window The window this will be drawn to, or %NULL Parses a textual specification of a color and fill in the @red, @green, and @blue fields of a #GdkColor. The string can either one of a large set of standard names (taken from the X11 `rgb.txt` file), or it can be a hexadecimal value in the form “\#rgb” “\#rrggbb”, “\#rrrgggbbb” or “\#rrrrggggbbbb” where “r”, “g” and “b” are hex digits of the red, green, and blue components of the color, respectively. (White in the four forms is “\#fff”, “\#ffffff”, “\#fffffffff” and “\#ffffffffffff”). Use #GdkRGBA %TRUE if the parsing succeeded the string specifying the color the #GdkColor to fill in A #GdkColor represents a color. When working with cairo, it is often more convenient to use a #GdkRGBA instead, and #GdkColor has been deprecated in favor of #GdkRGBA. These functions are used to create and destroy cursors. There is a number of standard cursors, but it is also possible to construct new cursors from pixbufs. There may be limitations as to what kinds of cursors can be constructed on a given display, see gdk_display_supports_cursor_alpha(), gdk_display_supports_cursor_color(), gdk_display_get_default_cursor_size() and gdk_display_get_maximal_cursor_size(). Cursors by themselves are not very interesting, they must be be bound to a window for users to see them. This is done with gdk_window_set_cursor() or by setting the cursor member of the #GdkWindowAttr passed to gdk_window_new(). Disables multidevice support in GDK. This call must happen prior to gdk_display_open(), gtk_init(), gtk_init_with_args() or gtk_init_check() in order to take effect. Most common GTK+ applications won’t ever need to call this. Only applications that do mixed GDK/Xlib calls could want to disable multidevice support if such Xlib code deals with input devices in any way and doesn’t observe the presence of XInput 2. These functions provide a low level interface for drag and drop. The X backend of GDK supports both the Xdnd and Motif drag and drop protocols transparently, the Win32 backend supports the WM_DROPFILES protocol. GTK+ provides a higher level abstraction based on top of these functions, and so they are not normally needed in GTK+ applications. See the [Drag and Drop][gtk3-Drag-and-Drop] section of the GTK+ documentation for more information. Aborts a drag without dropping. This function is called by the drag source. This function does not need to be called in managed drag and drop operations. See gdk_drag_context_manage_dnd() for more information. a #GdkDragContext the timestamp for this operation Starts a drag and creates a new drag context for it. This function assumes that the drag is controlled by the client pointer device, use gdk_drag_begin_for_device() to begin a drag with a different device. This function is called by the drag source. a newly created #GdkDragContext the source window for this drag. the offered targets, as list of #GdkAtoms Starts a drag and creates a new drag context for it. This function is called by the drag source. a newly created #GdkDragContext the source window for this drag the device that controls this drag the offered targets, as list of #GdkAtoms Starts a drag and creates a new drag context for it. This function is called by the drag source. a newly created #GdkDragContext the source window for this drag the device that controls this drag the offered targets, as list of #GdkAtoms the x coordinate where the drag nominally started the y coordinate where the drag nominally started Drops on the current destination. This function is called by the drag source. This function does not need to be called in managed drag and drop operations. See gdk_drag_context_manage_dnd() for more information. a #GdkDragContext the timestamp for this operation Inform GDK if the drop ended successfully. Passing %FALSE for @success may trigger a drag cancellation animation. This function is called by the drag source, and should be the last call before dropping the reference to the @context. The #GdkDragContext will only take the first gdk_drag_drop_done() call as effective, if this function is called multiple times, all subsequent calls will be ignored. a #GdkDragContext whether the drag was ultimatively successful Returns whether the dropped data has been successfully transferred. This function is intended to be used while handling a %GDK_DROP_FINISHED event, its return value is meaningless at other times. %TRUE if the drop was successful. a #GdkDragContext Finds the destination window and DND protocol to use at the given pointer position. This function is called by the drag source to obtain the @dest_window and @protocol parameters for gdk_drag_motion(). a #GdkDragContext a window which may be at the pointer position, but should be ignored, since it is put up by the drag source as an icon the screen where the destination window is sought the x position of the pointer in root coordinates the y position of the pointer in root coordinates location to store the destination window in location to store the DND protocol in Returns the selection atom for the current source window. the selection atom, or %GDK_NONE a #GdkDragContext. Updates the drag context when the pointer moves or the set of actions changes. This function is called by the drag source. This function does not need to be called in managed drag and drop operations. See gdk_drag_context_manage_dnd() for more information. a #GdkDragContext the new destination window, obtained by gdk_drag_find_window() the DND protocol in use, obtained by gdk_drag_find_window() the x position of the pointer in root coordinates the y position of the pointer in root coordinates the suggested action the possible actions the timestamp for this operation Selects one of the actions offered by the drag source. This function is called by the drag destination in response to gdk_drag_motion() called by the drag source. a #GdkDragContext the selected action which will be taken when a drop happens, or 0 to indicate that a drop will not be accepted the timestamp for this operation Ends the drag operation after a drop. This function is called by the drag destination. a #GdkDragContext %TRUE if the data was successfully received the timestamp for this operation Accepts or rejects a drop. This function is called by the drag destination in response to a drop initiated by the drag source. a #GdkDragContext %TRUE if the drop is accepted the timestamp for this operation Removes an error trap pushed with gdk_error_trap_push(). May block until an error has been definitively received or not received from the X server. gdk_error_trap_pop_ignored() is preferred if you don’t need to know whether an error occurred, because it never has to block. If you don't need the return value of gdk_error_trap_pop(), use gdk_error_trap_pop_ignored(). Prior to GDK 3.0, this function would not automatically sync for you, so you had to gdk_flush() if your last call to Xlib was not a blocking round trip. X error code or 0 on success Removes an error trap pushed with gdk_error_trap_push(), but without bothering to wait and see whether an error occurred. If an error arrives later asynchronously that was triggered while the trap was pushed, that error will be ignored. This function allows X errors to be trapped instead of the normal behavior of exiting the application. It should only be used if it is not possible to avoid the X error in any other way. Errors are ignored on all #GdkDisplay currently known to the #GdkDisplayManager. If you don’t care which error happens and just want to ignore everything, pop with gdk_error_trap_pop_ignored(). If you need the error code, use gdk_error_trap_pop() which may have to block and wait for the error to arrive from the X server. This API exists on all platforms but only does anything on X. You can use gdk_x11_display_error_trap_push() to ignore errors on only a single display. ## Trapping an X error |[<!-- language="C" --> gdk_error_trap_push (); // ... Call the X function which may cause an error here ... if (gdk_error_trap_pop ()) { // ... Handle the error here ... } ]| Checks all open displays for a #GdkEvent to process,to be processed on, fetching events from the windowing system if necessary. See gdk_display_get_event(). the next #GdkEvent to be processed, or %NULL if no events are pending. The returned #GdkEvent should be freed with gdk_event_free(). Sets the function to call to handle all events from GDK. Note that GTK+ uses this to install its own event handler, so it is usually not useful for GTK+ applications. (Although an application can call this function then call gtk_main_do_event() to pass events to GTK+.) the function to call to handle events from GDK. user data to pass to the function. the function to call when the handler function is removed, i.e. when gdk_event_handler_set() is called with another event handler. If there is an event waiting in the event queue of some open display, returns a copy of it. See gdk_display_peek_event(). a copy of the first #GdkEvent on some event queue, or %NULL if no events are in any queues. The returned #GdkEvent should be freed with gdk_event_free(). Request more motion notifies if @event is a motion notify hint event. This function should be used instead of gdk_window_get_pointer() to request further motion notifies, because it also works for extension events where motion notifies are provided for devices other than the core pointer. Coordinate extraction, processing and requesting more motion events from a %GDK_MOTION_NOTIFY event usually works like this: |[<!-- language="C" --> { // motion_event handler x = motion_event->x; y = motion_event->y; // handle (x,y) motion gdk_event_request_motions (motion_event); // handles is_hint events } ]| a valid #GdkEvent The event structures contain data specific to each type of event in GDK. > A common mistake is to forget to set the event mask of a widget so that > the required events are received. See gtk_widget_set_events(). This section describes functions dealing with events from the window system. In GTK+ applications the events are handled automatically in gtk_main_do_event() and passed on to the appropriate widgets, so these functions are rarely needed. Though some of the fields in the [Event Structures][gdk3-Event-Structures] are useful. If both events contain X/Y information, this function will return %TRUE and return in @angle the relative angle from @event1 to @event2. The rotation direction for positive angles is from the positive X axis towards the positive Y axis. %TRUE if the angle could be calculated. first #GdkEvent second #GdkEvent return location for the relative angle between both events If both events contain X/Y information, the center of both coordinates will be returned in @x and @y. %TRUE if the center could be calculated. first #GdkEvent second #GdkEvent return location for the X coordinate of the center return location for the Y coordinate of the center If both events have X/Y information, the distance between both coordinates (as in a straight line going from @event1 to @event2) will be returned. %TRUE if the distance could be calculated. first #GdkEvent second #GdkEvent return location for the distance Checks if any events are ready to be processed for any display. %TRUE if any events are pending. Flushes the output buffers of all display connections and waits until all requests have been processed. This is rarely needed by applications. The functions in this section are intended to be used in test programs. They allow to simulate some user input. This section describes the GDK initialization functions and miscellaneous utility functions, as well as deprecation facilities. The GDK and GTK+ headers annotate deprecated APIs in a way that produces compiler warnings if these deprecated APIs are used. The warnings can be turned off by defining the macro %GDK_DISABLE_DEPRECATION_WARNINGS before including the glib.h header. GDK and GTK+ also provide support for building applications against defined subsets of deprecated or new APIs. Define the macro %GDK_VERSION_MIN_REQUIRED to specify up to what version you want to receive warnings about deprecated APIs. Define the macro %GDK_VERSION_MAX_ALLOWED to specify the newest version whose API you want to use. Obtains the root window (parent all other windows are inside) for the default display and screen. the default root window Gets the name of the display, which usually comes from the `DISPLAY` environment variable or the `--display` command line option. Call gdk_display_get_name (gdk_display_get_default ())) instead. the name of the display. Gets the display name specified in the command line arguments passed to gdk_init() or gdk_parse_args(), if any. the display name, if specified explicitly, otherwise %NULL this string is owned by GTK+ and must not be modified or freed. Gets the program class. Unless the program class has explicitly been set with gdk_set_program_class() or with the `--class` commandline option, the default value is the program name (determined with g_get_prgname()) with the first character converted to uppercase. the program class. Gets whether event debugging output is enabled. %TRUE if event debugging output is enabled. Initializes the GDK library and connects to the windowing system. If initialization fails, a warning message is output and the application terminates with a call to `exit(1)`. Any arguments used by GDK are removed from the array and @argc and @argv are updated accordingly. GTK+ initializes GDK in gtk_init() and so this function is not usually needed by GTK+ applications. the number of command line arguments. the array of command line arguments. Initializes the GDK library and connects to the windowing system, returning %TRUE on success. Any arguments used by GDK are removed from the array and @argc and @argv are updated accordingly. GTK+ initializes GDK in gtk_init() and so this function is not usually needed by GTK+ applications. %TRUE if initialization succeeded. the number of command line arguments. the array of command line arguments. Grabs the keyboard so that all events are passed to this application until the keyboard is ungrabbed with gdk_keyboard_ungrab(). This overrides any previous keyboard grab by this client. If you set up anything at the time you take the grab that needs to be cleaned up when the grab ends, you should handle the #GdkEventGrabBroken events that are emitted when the grab ends unvoluntarily. Use gdk_device_grab() instead. %GDK_GRAB_SUCCESS if the grab was successful. the #GdkWindow which will own the grab (the grab window). if %FALSE then all keyboard events are reported with respect to @window. If %TRUE then keyboard events for this application are reported as normal, but keyboard events outside this application are reported with respect to @window. Both key press and key release events are always reported, independant of the event mask set by the application. a timestamp from a #GdkEvent, or %GDK_CURRENT_TIME if no timestamp is available. Ungrabs the keyboard on the default display, if it is grabbed by this application. Use gdk_device_ungrab(), together with gdk_device_grab() instead. a timestamp from a #GdkEvent, or %GDK_CURRENT_TIME if no timestamp is available. Key values are the codes which are sent whenever a key is pressed or released. They appear in the #GdkEventKey.keyval field of the #GdkEventKey structure, which is passed to signal handlers for the #GtkWidget::key-press-event and #GtkWidget::key-release-event signals. The complete list of key values can be found in the `gdk/gdkkeysyms.h` header file. Key values are regularly updated from the upstream X.org X11 implementation, so new values are added regularly. They will be prefixed with GDK_KEY_ rather than XF86XK_ or XK_ (for older symbols). Key values can be converted into a string representation using gdk_keyval_name(). The reverse function, converting a string to a key value, is provided by gdk_keyval_from_name(). The case of key values can be determined using gdk_keyval_is_upper() and gdk_keyval_is_lower(). Key values can be converted to upper or lower case using gdk_keyval_to_upper() and gdk_keyval_to_lower(). When it makes sense, key values can be converted to and from Unicode characters with gdk_keyval_to_unicode() and gdk_unicode_to_keyval(). # Groups # {#key-group-explanation} One #GdkKeymap object exists for each user display. gdk_keymap_get_default() returns the #GdkKeymap for the default display; to obtain keymaps for other displays, use gdk_keymap_get_for_display(). A keymap is a mapping from #GdkKeymapKey to key values. You can think of a #GdkKeymapKey as a representation of a symbol printed on a physical keyboard key. That is, it contains three pieces of information. First, it contains the hardware keycode; this is an identifying number for a physical key. Second, it contains the “level” of the key. The level indicates which symbol on the key will be used, in a vertical direction. So on a standard US keyboard, the key with the number “1“ on it also has the exclamation point (”!”) character on it. The level indicates whether to use the “1” or the “!” symbol. The letter keys are considered to have a lowercase letter at level 0, and an uppercase letter at level 1, though only the uppercase letter is printed. Third, the #GdkKeymapKey contains a group; groups are not used on standard US keyboards, but are used in many other countries. On a keyboard with groups, there can be 3 or 4 symbols printed on a single key. The group indicates movement in a horizontal direction. Usually groups are used for two different languages. In group 0, a key might have two English characters, and in group 1 it might have two Hebrew characters. The Hebrew characters will be printed on the key next to the English characters. In order to use a keymap to interpret a key event, it’s necessary to first convert the keyboard state into an effective group and level. This is done via a set of rules that varies widely according to type of keyboard and user configuration. The function gdk_keymap_translate_keyboard_state() accepts a keyboard state -- consisting of hardware keycode pressed, active modifiers, and active group -- applies the appropriate rules, and returns the group/level to be used to index the keymap, along with the modifiers which did not affect the group and level. i.e. it returns “unconsumed modifiers.” The keyboard group may differ from the effective group used for keymap lookups because some keys don't have multiple groups - e.g. the Enter key is always in group 0 regardless of keyboard state. Note that gdk_keymap_translate_keyboard_state() also returns the keyval, i.e. it goes ahead and performs the keymap lookup in addition to telling you which effective group/level values were used for the lookup. #GdkEventKey already contains this keyval, however, so you don’t normally need to call gdk_keymap_translate_keyboard_state() just to get the keyval. Obtains the upper- and lower-case versions of the keyval @symbol. Examples of keyvals are #GDK_KEY_a, #GDK_KEY_Enter, #GDK_KEY_F1, etc. a keyval return location for lowercase version of @symbol return location for uppercase version of @symbol Converts a key name to a key value. The names are the same as those in the `gdk/gdkkeysyms.h` header file but without the leading “GDK_KEY_”. the corresponding key value, or %GDK_KEY_VoidSymbol if the key name is not a valid key a key name Returns %TRUE if the given key value is in lower case. %TRUE if @keyval is in lower case, or if @keyval is not subject to case conversion. a key value. Returns %TRUE if the given key value is in upper case. %TRUE if @keyval is in upper case, or if @keyval is not subject to case conversion. a key value. Converts a key value into a symbolic name. The names are the same as those in the `gdk/gdkkeysyms.h` header file but without the leading “GDK_KEY_”. a string containing the name of the key, or %NULL if @keyval is not a valid key. The string should not be modified. a key value Converts a key value to lower case, if applicable. the lower case form of @keyval, or @keyval itself if it is already in lower case or it is not subject to case conversion. a key value. Convert from a GDK key symbol to the corresponding ISO10646 (Unicode) character. the corresponding unicode character, or 0 if there is no corresponding character. a GDK key symbol Converts a key value to upper case, if applicable. the upper case form of @keyval, or @keyval itself if it is already in upper case or it is not subject to case conversion. a key value. Lists the available visuals for the default screen. (See gdk_screen_list_visuals()) A visual describes a hardware image data format. For example, a visual might support 24-bit color, or 8-bit color, and might expect pixels to be in a certain format. Call g_list_free() on the return value when you’re finished with it. Use gdk_screen_list_visuals (gdk_screen_get_default ()). a list of visuals; the list must be freed, but not its contents Indicates to the GUI environment that the application has finished loading. If the applications opens windows, this function is normally called after opening the application’s initial set of windows. GTK+ will call this function automatically after opening the first #GtkWindow unless gtk_window_set_auto_startup_notification() is called to disable that feature. Indicates to the GUI environment that the application has finished loading, using a given identifier. GTK+ will call this function automatically for #GtkWindow with custom startup-notification identifier unless gtk_window_set_auto_startup_notification() is called to disable that feature. a startup-notification identifier, for which notification process should be completed Gets the window that @window is embedded in. the embedding #GdkWindow, or %NULL if @window is not an mbedded offscreen window a #GdkWindow Gets the offscreen surface that an offscreen window renders into. If you need to keep this around over window resizes, you need to add a reference to it. The offscreen surface, or %NULL if not offscreen a #GdkWindow Sets @window to be embedded in @embedder. To fully embed an offscreen window, in addition to calling this function, it is also necessary to handle the #GdkWindow::pick-embedded-child signal on the @embedder and the #GdkWindow::to-embedder and #GdkWindow::from-embedder signals on @window. a #GdkWindow the #GdkWindow that @window gets embedded in Creates a #PangoContext for the default GDK screen. The context must be freed when you’re finished with it. When using GTK+, normally you should use gtk_widget_get_pango_context() instead of this function, to get the appropriate context for the widget you intend to render text onto. The newly created context will have the default font options (see #cairo_font_options_t) for the default screen; if these options change it will not be updated. Using gtk_widget_get_pango_context() is more convenient if you want to keep a context around and track changes to the screen’s font rendering settings. a new #PangoContext for the default display Creates a #PangoContext for @display. The context must be freed when you’re finished with it. When using GTK+, normally you should use gtk_widget_get_pango_context() instead of this function, to get the appropriate context for the widget you intend to render text onto. The newly created context will have the default font options (see #cairo_font_options_t) for the display; if these options change it will not be updated. Using gtk_widget_get_pango_context() is more convenient if you want to keep a context around and track changes to the font rendering settings. a new #PangoContext for @display the #GdkDisplay for which the context is to be created Creates a #PangoContext for @screen. The context must be freed when you’re finished with it. When using GTK+, normally you should use gtk_widget_get_pango_context() instead of this function, to get the appropriate context for the widget you intend to render text onto. The newly created context will have the default font options (see #cairo_font_options_t) for the screen; if these options change it will not be updated. Using gtk_widget_get_pango_context() is more convenient if you want to keep a context around and track changes to the screen’s font rendering settings. a new #PangoContext for @screen the #GdkScreen for which the context is to be created. Pango is the text layout system used by GDK and GTK+. The functions and types in this section are used to obtain clip regions for #PangoLayouts, and to get #PangoContexts that can be used with GDK. Creating a #PangoLayout object is the first step in rendering text, and requires getting a handle to a #PangoContext. For GTK+ programs, you’ll usually want to use gtk_widget_get_pango_context(), or gtk_widget_create_pango_layout(), rather than using the lowlevel gdk_pango_context_get_for_screen(). Once you have a #PangoLayout, you can set the text and attributes of it with Pango functions like pango_layout_set_text() and get its size with pango_layout_get_size(). (Note that Pango uses a fixed point system internally, so converting between Pango units and pixels using [PANGO_SCALE][PANGO-SCALE-CAPS] or the PANGO_PIXELS() macro.) Rendering a Pango layout is done most simply with pango_cairo_show_layout(); you can also draw pieces of the layout with pango_cairo_show_layout_line(). ## Draw transformed text with Pango and cairo ## {#rotated-example} |[<!-- language="C" --> #define RADIUS 100 #define N_WORDS 10 #define FONT "Sans Bold 18" PangoContext *context; PangoLayout *layout; PangoFontDescription *desc; double radius; int width, height; int i; // Set up a transformation matrix so that the user space coordinates for // where we are drawing are [-RADIUS, RADIUS], [-RADIUS, RADIUS] // We first center, then change the scale width = gdk_window_get_width (window); height = gdk_window_get_height (window); radius = MIN (width, height) / 2.; cairo_translate (cr, radius + (width - 2 * radius) / 2, radius + (height - 2 * radius) / 2); cairo_scale (cr, radius / RADIUS, radius / RADIUS); // Create a PangoLayout, set the font and text context = gdk_pango_context_get_for_screen (screen); layout = pango_layout_new (context); pango_layout_set_text (layout, "Text", -1); desc = pango_font_description_from_string (FONT); pango_layout_set_font_description (layout, desc); pango_font_description_free (desc); // Draw the layout N_WORDS times in a circle for (i = 0; i < N_WORDS; i++) { double red, green, blue; double angle = 2 * G_PI * i / n_words; cairo_save (cr); // Gradient from red at angle == 60 to blue at angle == 300 red = (1 + cos (angle - 60)) / 2; green = 0; blue = 1 - red; cairo_set_source_rgb (cr, red, green, blue); cairo_rotate (cr, angle); // Inform Pango to re-layout the text with the new transformation matrix pango_cairo_update_layout (cr, layout); pango_layout_get_size (layout, &width, &height); cairo_move_to (cr, - width / 2 / PANGO_SCALE, - DEFAULT_TEXT_RADIUS); pango_cairo_show_layout (cr, layout); cairo_restore (cr); } g_object_unref (layout); g_object_unref (context); ]| ## Output of the [example][rotated-example] above. ![](rotated-text.png) Obtains a clip region which contains the areas where the given ranges of text would be drawn. @x_origin and @y_origin are the top left point to center the layout. @index_ranges should contain ranges of bytes in the layout’s text. Note that the regions returned correspond to logical extents of the text ranges, not ink extents. So the drawn layout may in fact touch areas out of the clip region. The clip region is mainly useful for highlightling parts of text, such as when text is selected. a clip region containing the given ranges a #PangoLayout X pixel where you intend to draw the layout with this clip Y pixel where you intend to draw the layout with this clip array of byte indexes into the layout, where even members of array are start indexes and odd elements are end indexes number of ranges in @index_ranges, i.e. half the size of @index_ranges Obtains a clip region which contains the areas where the given ranges of text would be drawn. @x_origin and @y_origin are the top left position of the layout. @index_ranges should contain ranges of bytes in the layout’s text. The clip region will include space to the left or right of the line (to the layout bounding box) if you have indexes above or below the indexes contained inside the line. This is to draw the selection all the way to the side of the layout. However, the clip region is in line coordinates, not layout coordinates. Note that the regions returned correspond to logical extents of the text ranges, not ink extents. So the drawn line may in fact touch areas out of the clip region. The clip region is mainly useful for highlightling parts of text, such as when text is selected. a clip region containing the given ranges a #PangoLayoutLine X pixel where you intend to draw the layout line with this clip baseline pixel where you intend to draw the layout line with this clip array of byte indexes into the layout, where even members of array are start indexes and odd elements are end indexes number of ranges in @index_ranges, i.e. half the size of @index_ranges Parse command line arguments, and store for future use by calls to gdk_display_open(). Any arguments used by GDK are removed from the array and @argc and @argv are updated accordingly. You shouldn’t call this function explicitly if you are using gtk_init(), gtk_init_check(), gdk_init(), or gdk_init_check(). the number of command line arguments. the array of command line arguments. Transfers image data from a #cairo_surface_t and converts it to an RGB(A) representation inside a #GdkPixbuf. This allows you to efficiently read individual pixels from cairo surfaces. For #GdkWindows, use gdk_pixbuf_get_from_window() instead. This function will create an RGB pixbuf with 8 bits per channel. The pixbuf will contain an alpha channel if the @surface contains one. A newly-created pixbuf with a reference count of 1, or %NULL on error surface to copy from Source X coordinate within @surface Source Y coordinate within @surface Width in pixels of region to get Height in pixels of region to get Transfers image data from a #GdkWindow and converts it to an RGB(A) representation inside a #GdkPixbuf. In other words, copies image data from a server-side drawable to a client-side RGB(A) buffer. This allows you to efficiently read individual pixels on the client side. This function will create an RGB pixbuf with 8 bits per channel with the size specified by the @width and @height arguments scaled by the scale factor of @window. The pixbuf will contain an alpha channel if the @window contains one. If the window is off the screen, then there is no image data in the obscured/offscreen regions to be placed in the pixbuf. The contents of portions of the pixbuf corresponding to the offscreen region are undefined. If the window you’re obtaining data from is partially obscured by other windows, then the contents of the pixbuf areas corresponding to the obscured regions are undefined. If the window is not mapped (typically because it’s iconified/minimized or not on the current workspace), then %NULL will be returned. If memory can’t be allocated for the return value, %NULL will be returned instead. (In short, there are several ways this function can fail, and if it fails it returns %NULL; so check the return value.) A newly-created pixbuf with a reference count of 1, or %NULL on error Source window Source X coordinate within @window Source Y coordinate within @window Width in pixels of region to get Height in pixels of region to get Pixbufs are client-side images. For details on how to create and manipulate pixbufs, see the #GdkPixbuf API documentation. The functions described here allow to obtain pixbufs from #GdkWindows and cairo surfaces. Grabs the pointer (usually a mouse) so that all events are passed to this application until the pointer is ungrabbed with gdk_pointer_ungrab(), or the grab window becomes unviewable. This overrides any previous pointer grab by this client. Pointer grabs are used for operations which need complete control over mouse events, even if the mouse leaves the application. For example in GTK+ it is used for Drag and Drop, for dragging the handle in the #GtkHPaned and #GtkVPaned widgets. Note that if the event mask of an X window has selected both button press and button release events, then a button press event will cause an automatic pointer grab until the button is released. X does this automatically since most applications expect to receive button press and release events in pairs. It is equivalent to a pointer grab on the window with @owner_events set to %TRUE. If you set up anything at the time you take the grab that needs to be cleaned up when the grab ends, you should handle the #GdkEventGrabBroken events that are emitted when the grab ends unvoluntarily. Use gdk_device_grab() instead. %GDK_GRAB_SUCCESS if the grab was successful. the #GdkWindow which will own the grab (the grab window). if %FALSE then all pointer events are reported with respect to @window and are only reported if selected by @event_mask. If %TRUE then pointer events for this application are reported as normal, but pointer events outside this application are reported with respect to @window and only if selected by @event_mask. In either mode, unreported events are discarded. specifies the event mask, which is used in accordance with @owner_events. Note that only pointer events (i.e. button and motion events) may be selected. If non-%NULL, the pointer will be confined to this window during the grab. If the pointer is outside @confine_to, it will automatically be moved to the closest edge of @confine_to and enter and leave events will be generated as necessary. the cursor to display while the grab is active. If this is %NULL then the normal cursors are used for @window and its descendants, and the cursor for @window is used for all other windows. the timestamp of the event which led to this pointer grab. This usually comes from a #GdkEventButton struct, though %GDK_CURRENT_TIME can be used if the time isn’t known. Returns %TRUE if the pointer on the default display is currently grabbed by this application. Note that this does not take the inmplicit pointer grab on button presses into account. Use gdk_display_device_is_grabbed() instead. %TRUE if the pointer is currently grabbed by this application. Ungrabs the pointer on the default display, if it is grabbed by this application. Use gdk_device_ungrab(), together with gdk_device_grab() instead. a timestamp from a #GdkEvent, or %GDK_CURRENT_TIME if no timestamp is available. Prepare for parsing command line arguments for GDK. This is not public API and should not be used in application code. This symbol was never meant to be used outside of GTK+ Each window under X can have any number of associated “properties” attached to it. Properties are arbitrary chunks of data identified by “atom”s. (An “atom” is a numeric index into a string table on the X server. They are used to transfer strings efficiently between clients without having to transfer the entire string.) A property has an associated type, which is also identified using an atom. A property has an associated “format”, an integer describing how many bits are in each unit of data inside the property. It must be 8, 16, or 32. When data is transferred between the server and client, if they are of different endianesses it will be byteswapped as necessary according to the format of the property. Note that on the client side, properties of format 32 will be stored with one unit per long, even if a long integer has more than 32 bits on the platform. (This decision was apparently made for Xlib to maintain compatibility with programs that assumed longs were 32 bits, at the expense of programs that knew better.) The functions in this section are used to add, remove and change properties on windows, to convert atoms to and from strings and to manipulate some types of data commonly stored in X window properties. Changes the contents of a property on a window. a #GdkWindow the property to change the new type for the property. If @mode is %GDK_PROP_MODE_PREPEND or %GDK_PROP_MODE_APPEND, then this must match the existing type or an error will occur. the new format for the property. If @mode is %GDK_PROP_MODE_PREPEND or %GDK_PROP_MODE_APPEND, then this must match the existing format or an error will occur. a value describing how the new data is to be combined with the current data. the data (a `guchar *` `gushort *`, or `gulong *`, depending on @format), cast to a `guchar *`. the number of elements of size determined by the format, contained in @data. Deletes a property from a window. a #GdkWindow the property to delete Retrieves a portion of the contents of a property. If the property does not exist, then the function returns %FALSE, and %GDK_NONE will be stored in @actual_property_type. The XGetWindowProperty() function that gdk_property_get() uses has a very confusing and complicated set of semantics. Unfortunately, gdk_property_get() makes the situation worse instead of better (the semantics should be considered undefined), and also prints warnings to stderr in cases where it should return a useful error to the program. You are advised to use XGetWindowProperty() directly until a replacement function for gdk_property_get() is provided. %TRUE if data was successfully received and stored in @data, otherwise %FALSE. a #GdkWindow the property to retrieve the desired property type, or %GDK_NONE, if any type of data is acceptable. If this does not match the actual type, then @actual_format and @actual_length will be filled in, a warning will be printed to stderr and no data will be returned. the offset into the property at which to begin retrieving data, in 4 byte units. the length of the data to retrieve in bytes. Data is considered to be retrieved in 4 byte chunks, so @length will be rounded up to the next highest 4 byte boundary (so be careful not to pass a value that might overflow when rounded up). if %TRUE, delete the property after retrieving the data. location to store the actual type of the property. location to store the actual return format of the data; either 8, 16 or 32 bits. location to store the length of the retrieved data, in bytes. Data returned in the 32 bit format is stored in a long variable, so the actual number of 32 bit elements should be be calculated via @actual_length / sizeof(glong) to ensure portability to 64 bit systems. location to store a pointer to the data. The retrieved data should be freed with g_free() when you are finished using it. This function returns the available bit depths for the default screen. It’s equivalent to listing the visuals (gdk_list_visuals()) and then looking at the depth field in each visual, removing duplicates. The array returned by this function should not be freed. Visual selection should be done using gdk_screen_get_system_visual() and gdk_screen_get_rgba_visual() return location for available depths return location for number of available depths This function returns the available visual types for the default screen. It’s equivalent to listing the visuals (gdk_list_visuals()) and then looking at the type field in each visual, removing duplicates. The array returned by this function should not be freed. Visual selection should be done using gdk_screen_get_system_visual() and gdk_screen_get_rgba_visual() return location for the available visual types return location for the number of available visual types GDK provides the #GdkPoint and #GdkRectangle data types for representing pixels and sets of pixels on the screen. Together with Cairo’s #cairo_region_t data type, they make up the central types for representing graphical data. A #GdkPoint represents an x and y coordinate of a point. A #GdkRectangle represents the position and size of a rectangle. The intersection of two rectangles can be computed with gdk_rectangle_intersect(). To find the union of two rectangles use gdk_rectangle_union(). #cairo_region_t is usually used for managing clipping of graphical operations. #GdkRGBA is a convenient way to pass rgba colors around. It’s based on cairo’s way to deal with colors and mirrors its behavior. All values are in the range from 0.0 to 1.0 inclusive. So the color (0.0, 0.0, 0.0, 0.0) represents transparent black and (1.0, 1.0, 1.0, 1.0) is opaque white. Other values will be clamped to this range when drawing. Retrieves the contents of a selection in a given form. a #GdkWindow. an atom identifying the selection to get the contents of. the form in which to retrieve the selection. the timestamp to use when retrieving the selection. The selection owner may refuse the request if it did not own the selection at the time indicated by the timestamp. Determines the owner of the given selection. if there is a selection owner for this window, and it is a window known to the current process, the #GdkWindow that owns the selection, otherwise %NULL. Note that the return value may be owned by a different process if a foreign window was previously created for that window, but a new foreign window will never be created by this call. an atom indentifying a selection. Determine the owner of the given selection. Note that the return value may be owned by a different process if a foreign window was previously created for that window, but a new foreign window will never be created by this call. if there is a selection owner for this window, and it is a window known to the current process, the #GdkWindow that owns the selection, otherwise %NULL. a #GdkDisplay an atom indentifying a selection Sets the owner of the given selection. %TRUE if the selection owner was successfully changed to @owner, otherwise %FALSE. a #GdkWindow or %NULL to indicate that the the owner for the given should be unset. an atom identifying a selection. timestamp to use when setting the selection. If this is older than the timestamp given last time the owner was set for the given selection, the request will be ignored. if %TRUE, and the new owner is different from the current owner, the current owner will be sent a SelectionClear event. Sets the #GdkWindow @owner as the current owner of the selection @selection. %TRUE if the selection owner was successfully changed to owner, otherwise %FALSE. the #GdkDisplay a #GdkWindow or %NULL to indicate that the owner for the given should be unset an atom identifying a selection timestamp to use when setting the selection If this is older than the timestamp given last time the owner was set for the given selection, the request will be ignored if %TRUE, and the new owner is different from the current owner, the current owner will be sent a SelectionClear event Retrieves selection data that was stored by the selection data in response to a call to gdk_selection_convert(). This function will not be used by applications, who should use the #GtkClipboard API instead. the length of the retrieved data. the window on which the data is stored location to store a pointer to the retrieved data. If the retrieval failed, %NULL we be stored here, otherwise, it will be non-%NULL and the returned data should be freed with g_free() when you are finished using it. The length of the allocated memory is one more than the length of the returned data, and the final byte will always be zero, to ensure nul-termination of strings location to store the type of the property location to store the format of the property Sends a response to SelectionRequest event. window to which to deliver response. selection that was requested. target that was selected. property in which the selection owner stored the data, or %GDK_NONE to indicate that the request was rejected. timestamp. Send a response to SelectionRequest event. the #GdkDisplay where @requestor is realized window to which to deliver response selection that was requested target that was selected property in which the selection owner stored the data, or %GDK_NONE to indicate that the request was rejected timestamp GDK’s selection functions, based on the [X selection mechanism]( https://www.x.org/releases/X11R7.6/doc/xorg-docs/specs/ICCCM/icccm.html), provide a way to transfer arbitrary chunks of data between programs. A “selection” is a essentially a named clipboard, identified by a string interned as a #GdkAtom. By claiming ownership of a selection, an application indicates that it will be responsible for supplying its contents. The most common selections are `PRIMARY` and `CLIPBOARD`. The contents of a selection can be represented in a number of formats, called “targets”. Each target is identified by an atom. A list of all possible targets supported by the selection owner can be retrieved by requesting the special target `TARGETS`. When a selection is retrieved, the data is accompanied by a type (an atom), and a format (an integer, representing the number of bits per item). See [Properties and Atoms][gdk3-Properties-and-Atoms] for more information. The functions in this section only contain the lowlevel parts of the selection protocol. A considerably more complicated implementation is needed on top of this. GTK+ contains such an implementation in the functions in `gtkselection.h` and programmers should use those functions instead of the ones presented here. If you plan to implement selection handling directly on top of the functions here, you should refer to the [X Inter-Client Communication Conventions Manual (ICCCM)]( https://www.x.org/releases/X11R7.6/doc/xorg-docs/specs/ICCCM/icccm.html). Note that although much of the selection API design is based on that of X, it will work on other GDK backends too. Sets a list of backends that GDK should try to use. This can be be useful if your application does not work with certain GDK backends. By default, GDK tries all included backends. For example, |[<!-- language="C" --> gdk_set_allowed_backends ("wayland,quartz,*"); ]| instructs GDK to try the Wayland backend first, followed by the Quartz backend, and then all others. If the `GDK_BACKEND` environment variable is set, it determines what backends are tried in what order, while still respecting the set of allowed backends that are specified by this function. The possible backend names are x11, win32, quartz, broadway, wayland. You can also include a * in the list to try all remaining backends. This call must happen prior to gdk_display_open(), gtk_init(), gtk_init_with_args() or gtk_init_check() in order to take effect. a comma-separated list of backends Set the double click time for the default display. See gdk_display_set_double_click_time(). See also gdk_display_set_double_click_distance(). Applications should not set this, it is a global user-configured setting. double click time in milliseconds (thousandths of a second) Sets the program class. The X11 backend uses the program class to set the class name part of the `WM_CLASS` property on toplevel windows; see the ICCCM. The program class can still be overridden with the --class command line option. a string. Sets whether a trace of received events is output. Note that GTK+ must be compiled with debugging (that is, configured using the `--enable-debug` option) to use this option. %TRUE to output event debugging information. Obtains a desktop-wide setting, such as the double-click time, for the default screen. See gdk_screen_get_setting(). %TRUE if the setting existed and a value was stored in @value, %FALSE otherwise. the name of the setting. location to store the value of the setting. Retrieves a pixel from @window to force the windowing system to carry out any pending rendering commands. This function is intended to be used to synchronize with rendering pipelines, to benchmark windowing system rendering operations. a mapped #GdkWindow This function is intended to be used in GTK+ test programs. It will warp the mouse pointer to the given (@x,@y) coordinates within @window and simulate a button press or release event. Because the mouse pointer needs to be warped to the target location, use of this function outside of test programs that run in their own virtual windowing system (e.g. Xvfb) is not recommended. Also, gdk_test_simulate_button() is a fairly low level function, for most testing purposes, gtk_test_widget_click() is the right function to call which will generate a button press event followed by its accompanying button release event. whether all actions necessary for a button event simulation were carried out successfully a #GdkWindow to simulate a button event for x coordinate within @window for the button event y coordinate within @window for the button event Number of the pointer button for the event, usually 1, 2 or 3 Keyboard modifiers the event is setup with either %GDK_BUTTON_PRESS or %GDK_BUTTON_RELEASE This function is intended to be used in GTK+ test programs. If (@x,@y) are > (-1,-1), it will warp the mouse pointer to the given (@x,@y) coordinates within @window and simulate a key press or release event. When the mouse pointer is warped to the target location, use of this function outside of test programs that run in their own virtual windowing system (e.g. Xvfb) is not recommended. If (@x,@y) are passed as (-1,-1), the mouse pointer will not be warped and @window origin will be used as mouse pointer location for the event. Also, gdk_test_simulate_key() is a fairly low level function, for most testing purposes, gtk_test_widget_send_key() is the right function to call which will generate a key press event followed by its accompanying key release event. whether all actions necessary for a key event simulation were carried out successfully a #GdkWindow to simulate a key event for x coordinate within @window for the key event y coordinate within @window for the key event A GDK keyboard value Keyboard modifiers the event is setup with either %GDK_KEY_PRESS or %GDK_KEY_RELEASE Converts a text property in the given encoding to a list of UTF-8 strings. the number of strings in the resulting list a #GdkDisplay an atom representing the encoding of the text the format of the property the text to convert the length of @text, in bytes location to store the list of strings or %NULL. The list should be freed with g_strfreev(). For thread safety, GDK relies on the thread primitives in GLib, and on the thread-safe GLib main loop. GLib is completely thread safe (all global data is automatically locked), but individual data structure instances are not automatically locked for performance reasons. So e.g. you must coordinate accesses to the same #GHashTable from multiple threads. GTK+, however, is not thread safe. You should only use GTK+ and GDK from the thread gtk_init() and gtk_main() were called on. This is usually referred to as the “main thread”. Signals on GTK+ and GDK types, as well as non-signal callbacks, are emitted in the main thread. You can schedule work in the main thread safely from other threads by using gdk_threads_add_idle() and gdk_threads_add_timeout(): |[<!-- language="C" --> static void worker_thread (void) { ExpensiveData *expensive_data = do_expensive_computation (); gdk_threads_add_idle (got_value, expensive_data); } static gboolean got_value (gpointer user_data) { ExpensiveData *expensive_data = user_data; my_app->expensive_data = expensive_data; gtk_button_set_sensitive (my_app->button, TRUE); gtk_button_set_label (my_app->button, expensive_data->result_label); return G_SOURCE_REMOVE; } ]| You should use gdk_threads_add_idle() and gdk_threads_add_timeout() instead of g_idle_add() and g_timeout_add() since libraries not under your control might be using the deprecated GDK locking mechanism. If you are sure that none of the code in your application and libraries use the deprecated gdk_threads_enter() or gdk_threads_leave() methods, then you can safely use g_idle_add() and g_timeout_add(). For more information on this "worker thread" pattern, you should also look at #GTask, which gives you high-level tools to perform expensive tasks from worker threads, and will handle thread management for you. A wrapper for the common usage of gdk_threads_add_idle_full() assigning the default priority, #G_PRIORITY_DEFAULT_IDLE. See gdk_threads_add_idle_full(). the ID (greater than 0) of the event source. function to call data to pass to @function Adds a function to be called whenever there are no higher priority events pending. If the function returns %FALSE it is automatically removed from the list of event sources and will not be called again. This variant of g_idle_add_full() calls @function with the GDK lock held. It can be thought of a MT-safe version for GTK+ widgets for the following use case, where you have to worry about idle_callback() running in thread A and accessing @self after it has been finalized in thread B: |[<!-- language="C" --> static gboolean idle_callback (gpointer data) { // gdk_threads_enter(); would be needed for g_idle_add() SomeWidget *self = data; // do stuff with self self->idle_id = 0; // gdk_threads_leave(); would be needed for g_idle_add() return FALSE; } static void some_widget_do_stuff_later (SomeWidget *self) { self->idle_id = gdk_threads_add_idle (idle_callback, self) // using g_idle_add() here would require thread protection in the callback } static void some_widget_finalize (GObject *object) { SomeWidget *self = SOME_WIDGET (object); if (self->idle_id) g_source_remove (self->idle_id); G_OBJECT_CLASS (parent_class)->finalize (object); } ]| the ID (greater than 0) of the event source. the priority of the idle source. Typically this will be in the range between #G_PRIORITY_DEFAULT_IDLE and #G_PRIORITY_HIGH_IDLE function to call data to pass to @function function to call when the idle is removed, or %NULL A wrapper for the common usage of gdk_threads_add_timeout_full() assigning the default priority, #G_PRIORITY_DEFAULT. See gdk_threads_add_timeout_full(). the ID (greater than 0) of the event source. the time between calls to the function, in milliseconds (1/1000ths of a second) function to call data to pass to @function Sets a function to be called at regular intervals holding the GDK lock, with the given priority. The function is called repeatedly until it returns %FALSE, at which point the timeout is automatically destroyed and the function will not be called again. The @notify function is called when the timeout is destroyed. The first call to the function will be at the end of the first @interval. Note that timeout functions may be delayed, due to the processing of other event sources. Thus they should not be relied on for precise timing. After each call to the timeout function, the time of the next timeout is recalculated based on the current time and the given interval (it does not try to “catch up” time lost in delays). This variant of g_timeout_add_full() can be thought of a MT-safe version for GTK+ widgets for the following use case: |[<!-- language="C" --> static gboolean timeout_callback (gpointer data) { SomeWidget *self = data; // do stuff with self self->timeout_id = 0; return G_SOURCE_REMOVE; } static void some_widget_do_stuff_later (SomeWidget *self) { self->timeout_id = g_timeout_add (timeout_callback, self) } static void some_widget_finalize (GObject *object) { SomeWidget *self = SOME_WIDGET (object); if (self->timeout_id) g_source_remove (self->timeout_id); G_OBJECT_CLASS (parent_class)->finalize (object); } ]| the ID (greater than 0) of the event source. the priority of the timeout source. Typically this will be in the range between #G_PRIORITY_DEFAULT_IDLE and #G_PRIORITY_HIGH_IDLE. the time between calls to the function, in milliseconds (1/1000ths of a second) function to call data to pass to @function function to call when the timeout is removed, or %NULL A wrapper for the common usage of gdk_threads_add_timeout_seconds_full() assigning the default priority, #G_PRIORITY_DEFAULT. For details, see gdk_threads_add_timeout_full(). the ID (greater than 0) of the event source. the time between calls to the function, in seconds function to call data to pass to @function A variant of gdk_threads_add_timeout_full() with second-granularity. See g_timeout_add_seconds_full() for a discussion of why it is a good idea to use this function if you don’t need finer granularity. the ID (greater than 0) of the event source. the priority of the timeout source. Typically this will be in the range between #G_PRIORITY_DEFAULT_IDLE and #G_PRIORITY_HIGH_IDLE. the time between calls to the function, in seconds function to call data to pass to @function function to call when the timeout is removed, or %NULL This function marks the beginning of a critical section in which GDK and GTK+ functions can be called safely and without causing race conditions. Only one thread at a time can be in such a critial section. All GDK and GTK+ calls should be made from the main thread Initializes GDK so that it can be used from multiple threads in conjunction with gdk_threads_enter() and gdk_threads_leave(). This call must be made before any use of the main loop from GTK+; to be safe, call it before gtk_init(). All GDK and GTK+ calls should be made from the main thread Leaves a critical region begun with gdk_threads_enter(). All GDK and GTK+ calls should be made from the main thread Allows the application to replace the standard method that GDK uses to protect its data structures. Normally, GDK creates a single #GMutex that is locked by gdk_threads_enter(), and released by gdk_threads_leave(); using this function an application provides, instead, a function @enter_fn that is called by gdk_threads_enter() and a function @leave_fn that is called by gdk_threads_leave(). The functions must provide at least same locking functionality as the default implementation, but can also do extra application specific processing. As an example, consider an application that has its own recursive lock that when held, holds the GTK+ lock as well. When GTK+ unlocks the GTK+ lock when entering a recursive main loop, the application must temporarily release its lock as well. Most threaded GTK+ apps won’t need to use this method. This method must be called before gdk_threads_init(), and cannot be called multiple times. All GDK and GTK+ calls should be made from the main thread function called to guard GDK function called to release the guard Convert from a ISO10646 character to a key symbol. the corresponding GDK key symbol, if one exists. or, if there is no corresponding symbol, wc | 0x01000000 a ISO10646 encoded character Converts an UTF-8 string into the best possible representation as a STRING. The representation of characters not in STRING is not specified; it may be as pseudo-escape sequences \x{ABCD}, or it may be in some other form of approximation. the newly-allocated string, or %NULL if the conversion failed. (It should not fail for any properly formed UTF-8 string unless system limits like memory or file descriptors are exceeded.) a UTF-8 string A #GdkVisual describes a particular video hardware display format. It includes information about the number of bits used for each color, the way the bits are translated into an RGB value for display, and the way the bits are stored in memory. For example, a piece of display hardware might support 24-bit color, 16-bit color, or 8-bit color; meaning 24/16/8-bit pixel sizes. For a given pixel size, pixels can be in different formats; for example the “red” element of an RGB pixel may be in the top 8 bits of the pixel, or may be in the lower 4 bits. There are several standard visuals. The visual returned by gdk_screen_get_system_visual() is the system’s default visual, and the visual returned by gdk_screen_get_rgba_visual() should be used for creating windows with an alpha channel. A number of functions are provided for determining the “best” available visual. For the purposes of making this determination, higher bit depths are considered better, and for visuals of the same bit depth, %GDK_VISUAL_PSEUDO_COLOR is preferred at 8bpp, otherwise, the visual types are ranked in the order of(highest to lowest) %GDK_VISUAL_DIRECT_COLOR, %GDK_VISUAL_TRUE_COLOR, %GDK_VISUAL_PSEUDO_COLOR, %GDK_VISUAL_STATIC_COLOR, %GDK_VISUAL_GRAYSCALE, then %GDK_VISUAL_STATIC_GRAY. A #GdkWindow is a (usually) rectangular region on the screen. It’s a low-level object, used to implement high-level objects such as #GtkWidget and #GtkWindow on the GTK+ level. A #GtkWindow is a toplevel window, the thing a user might think of as a “window” with a titlebar and so on; a #GtkWindow may contain many #GdkWindows. For example, each #GtkButton has a #GdkWindow associated with it. # Composited Windows # {#COMPOSITED-WINDOWS} Normally, the windowing system takes care of rendering the contents of a child window onto its parent window. This mechanism can be intercepted by calling gdk_window_set_composited() on the child window. For a “composited” window it is the responsibility of the application to render the window contents at the right spot. # Offscreen Windows # {#OFFSCREEN-WINDOWS} Offscreen windows are more general than composited windows, since they allow not only to modify the rendering of the child window onto its parent, but also to apply coordinate transformations. To integrate an offscreen window into a window hierarchy, one has to call gdk_offscreen_window_set_embedder() and handle a number of signals. The #GdkWindow::pick-embedded-child signal on the embedder window is used to select an offscreen child at given coordinates, and the #GdkWindow::to-embedder and #GdkWindow::from-embedder signals on the offscreen window are used to translate coordinates between the embedder and the offscreen window. For rendering an offscreen window onto its embedder, the contents of the offscreen window are available as a surface, via gdk_offscreen_window_get_surface(). gtkada-24.0.0/contrib/Gio-2.0.gir000066400000000000000000310560751446021174000162260ustar00rootroot00000000000000 #GAction represents a single named action. The main interface to an action is that it can be activated with g_action_activate(). This results in the 'activate' signal being emitted. An activation has a #GVariant parameter (which may be %NULL). The correct type for the parameter is determined by a static parameter type (which is given at construction time). An action may optionally have a state, in which case the state may be set with g_action_change_state(). This call takes a #GVariant. The correct type for the state is determined by a static state type (which is given at construction time). The state may have a hint associated with it, specifying its valid range. #GAction is merely the interface to the concept of an action, as described above. Various implementations of actions exist, including #GSimpleAction. In all cases, the implementing class is responsible for storing the name of the action, the parameter type, the enabled state, the optional state type and the state and emitting the appropriate signals when these change. The implementor is responsible for filtering calls to g_action_activate() and g_action_change_state() for type safety and for the state being enabled. Probably the only useful thing to do with a #GAction is to put it inside of a #GSimpleActionGroup. Checks if @action_name is valid. @action_name is valid if it consists only of alphanumeric characters, plus '-' and '.'. The empty string is not a valid action name. It is an error to call this function with a non-utf8 @action_name. @action_name must not be %NULL. %TRUE if @action_name is valid a potential action name Parses a detailed action name into its separate name and target components. Detailed action names can have three formats. The first format is used to represent an action name with no target value and consists of just an action name containing no whitespace nor the characters ':', '(' or ')'. For example: "app.action". The second format is used to represent an action with a target value that is a non-empty string consisting only of alphanumerics, plus '-' and '.'. In that case, the action name and target value are separated by a double colon ("::"). For example: "app.action::target". The third format is used to represent an action with any type of target value, including strings. The target value follows the action name, surrounded in parens. For example: "app.action(42)". The target value is parsed using g_variant_parse(). If a tuple-typed value is desired, it must be specified in the same way, resulting in two sets of parens, for example: "app.action((1,2,3))". A string target can be specified this way as well: "app.action('target')". For strings, this third format must be used if * target value is empty or contains characters other than alphanumerics, '-' and '.'. %TRUE if successful, else %FALSE with @error set a detailed action name the action name the target value, or %NULL for no target Formats a detailed action name from @action_name and @target_value. It is an error to call this function with an invalid action name. This function is the opposite of g_action_parse_detailed_name(). It will produce a string that can be parsed back to the @action_name and @target_value by that function. See that function for the types of strings that will be printed by this function. a detailed format string a valid action name a #GVariant target value, or %NULL Activates the action. @parameter must be the correct type of parameter for the action (ie: the parameter type given at construction time). If the parameter type was %NULL then @parameter must also be %NULL. If the @parameter GVariant is floating, it is consumed. a #GAction the parameter to the activation Request for the state of @action to be changed to @value. The action must be stateful and @value must be of the correct type. See g_action_get_state_type(). This call merely requests a change. The action may refuse to change its state or may change its state to something other than @value. See g_action_get_state_hint(). If the @value GVariant is floating, it is consumed. a #GAction the new state Checks if @action is currently enabled. An action must be enabled in order to be activated or in order to have its state changed from outside callers. whether the action is enabled a #GAction Queries the name of @action. the name of the action a #GAction Queries the type of the parameter that must be given when activating @action. When activating the action using g_action_activate(), the #GVariant given to that function must be of the type returned by this function. In the case that this function returns %NULL, you must not give any #GVariant, but %NULL instead. the parameter type a #GAction Queries the current state of @action. If the action is not stateful then %NULL will be returned. If the action is stateful then the type of the return value is the type given by g_action_get_state_type(). The return value (if non-%NULL) should be freed with g_variant_unref() when it is no longer required. the current state of the action a #GAction Requests a hint about the valid range of values for the state of @action. If %NULL is returned it either means that the action is not stateful or that there is no hint about the valid range of values for the state of the action. If a #GVariant array is returned then each item in the array is a possible value for the state. If a #GVariant pair (ie: two-tuple) is returned then the tuple specifies the inclusive lower and upper bound of valid values for the state. In any case, the information is merely a hint. It may be possible to have a state value outside of the hinted range and setting a value within the range may fail. The return value (if non-%NULL) should be freed with g_variant_unref() when it is no longer required. the state range hint a #GAction Queries the type of the state of @action. If the action is stateful (e.g. created with g_simple_action_new_stateful()) then this function returns the #GVariantType of the state. This is the type of the initial value given as the state. All calls to g_action_change_state() must give a #GVariant of this type and g_action_get_state() will return a #GVariant of the same type. If the action is not stateful (e.g. created with g_simple_action_new()) then this function will return %NULL. In that case, g_action_get_state() will return %NULL and you must not call g_action_change_state(). the state type, if the action is stateful a #GAction Activates the action. @parameter must be the correct type of parameter for the action (ie: the parameter type given at construction time). If the parameter type was %NULL then @parameter must also be %NULL. If the @parameter GVariant is floating, it is consumed. a #GAction the parameter to the activation Request for the state of @action to be changed to @value. The action must be stateful and @value must be of the correct type. See g_action_get_state_type(). This call merely requests a change. The action may refuse to change its state or may change its state to something other than @value. See g_action_get_state_hint(). If the @value GVariant is floating, it is consumed. a #GAction the new state Checks if @action is currently enabled. An action must be enabled in order to be activated or in order to have its state changed from outside callers. whether the action is enabled a #GAction Queries the name of @action. the name of the action a #GAction Queries the type of the parameter that must be given when activating @action. When activating the action using g_action_activate(), the #GVariant given to that function must be of the type returned by this function. In the case that this function returns %NULL, you must not give any #GVariant, but %NULL instead. the parameter type a #GAction Queries the current state of @action. If the action is not stateful then %NULL will be returned. If the action is stateful then the type of the return value is the type given by g_action_get_state_type(). The return value (if non-%NULL) should be freed with g_variant_unref() when it is no longer required. the current state of the action a #GAction Requests a hint about the valid range of values for the state of @action. If %NULL is returned it either means that the action is not stateful or that there is no hint about the valid range of values for the state of the action. If a #GVariant array is returned then each item in the array is a possible value for the state. If a #GVariant pair (ie: two-tuple) is returned then the tuple specifies the inclusive lower and upper bound of valid values for the state. In any case, the information is merely a hint. It may be possible to have a state value outside of the hinted range and setting a value within the range may fail. The return value (if non-%NULL) should be freed with g_variant_unref() when it is no longer required. the state range hint a #GAction Queries the type of the state of @action. If the action is stateful (e.g. created with g_simple_action_new_stateful()) then this function returns the #GVariantType of the state. This is the type of the initial value given as the state. All calls to g_action_change_state() must give a #GVariant of this type and g_action_get_state() will return a #GVariant of the same type. If the action is not stateful (e.g. created with g_simple_action_new()) then this function will return %NULL. In that case, g_action_get_state() will return %NULL and you must not call g_action_change_state(). the state type, if the action is stateful a #GAction If @action is currently enabled. If the action is disabled then calls to g_action_activate() and g_action_change_state() have no effect. The name of the action. This is mostly meaningful for identifying the action once it has been added to a #GActionGroup. It is immutable. The type of the parameter that must be given when activating the action. This is immutable, and may be %NULL if no parameter is needed when activating the action. The state of the action, or %NULL if the action is stateless. The #GVariantType of the state that the action has, or %NULL if the action is stateless. This is immutable. This struct defines a single action. It is for use with g_action_map_add_action_entries(). The order of the items in the structure are intended to reflect frequency of use. It is permissible to use an incomplete initialiser in order to leave some of the later values as %NULL. All values after @name are optional. Additional optional fields may be added in the future. See g_action_map_add_action_entries() for an example. the name of the action the type of the parameter that must be passed to the activate function for this action, given as a single GVariant type string (or %NULL for no parameter) the initial state for this action, given in [GVariant text format][gvariant-text]. The state is parsed with no extra type information, so type tags must be added to the string if they are necessary. Stateless actions should give %NULL here. #GActionGroup represents a group of actions. Actions can be used to expose functionality in a structured way, either from one part of a program to another, or to the outside world. Action groups are often used together with a #GMenuModel that provides additional representation data for displaying the actions to the user, e.g. in a menu. The main way to interact with the actions in a GActionGroup is to activate them with g_action_group_activate_action(). Activating an action may require a #GVariant parameter. The required type of the parameter can be inquired with g_action_group_get_action_parameter_type(). Actions may be disabled, see g_action_group_get_action_enabled(). Activating a disabled action has no effect. Actions may optionally have a state in the form of a #GVariant. The current state of an action can be inquired with g_action_group_get_action_state(). Activating a stateful action may change its state, but it is also possible to set the state by calling g_action_group_change_action_state(). As typical example, consider a text editing application which has an option to change the current font to 'bold'. A good way to represent this would be a stateful action, with a boolean state. Activating the action would toggle the state. Each action in the group has a unique name (which is a string). All method calls, except g_action_group_list_actions() take the name of an action as an argument. The #GActionGroup API is meant to be the 'public' API to the action group. The calls here are exactly the interaction that 'external forces' (eg: UI, incoming D-Bus messages, etc.) are supposed to have with actions. 'Internal' APIs (ie: ones meant only to be accessed by the action group implementation) are found on subclasses. This is why you will find - for example - g_action_group_get_action_enabled() but not an equivalent set() call. Signals are emitted on the action group in response to state changes on individual actions. Implementations of #GActionGroup should provide implementations for the virtual functions g_action_group_list_actions() and g_action_group_query_action(). The other virtual functions should not be implemented - their "wrappers" are actually implemented with calls to g_action_group_query_action(). Emits the #GActionGroup::action-added signal on @action_group. This function should only be called by #GActionGroup implementations. a #GActionGroup the name of an action in the group Emits the #GActionGroup::action-enabled-changed signal on @action_group. This function should only be called by #GActionGroup implementations. a #GActionGroup the name of an action in the group whether or not the action is now enabled Emits the #GActionGroup::action-removed signal on @action_group. This function should only be called by #GActionGroup implementations. a #GActionGroup the name of an action in the group Emits the #GActionGroup::action-state-changed signal on @action_group. This function should only be called by #GActionGroup implementations. a #GActionGroup the name of an action in the group the new state of the named action Activate the named action within @action_group. If the action is expecting a parameter, then the correct type of parameter must be given as @parameter. If the action is expecting no parameters then @parameter must be %NULL. See g_action_group_get_action_parameter_type(). a #GActionGroup the name of the action to activate parameters to the activation Request for the state of the named action within @action_group to be changed to @value. The action must be stateful and @value must be of the correct type. See g_action_group_get_action_state_type(). This call merely requests a change. The action may refuse to change its state or may change its state to something other than @value. See g_action_group_get_action_state_hint(). If the @value GVariant is floating, it is consumed. a #GActionGroup the name of the action to request the change on the new state Checks if the named action within @action_group is currently enabled. An action must be enabled in order to be activated or in order to have its state changed from outside callers. whether or not the action is currently enabled a #GActionGroup the name of the action to query Queries the type of the parameter that must be given when activating the named action within @action_group. When activating the action using g_action_group_activate_action(), the #GVariant given to that function must be of the type returned by this function. In the case that this function returns %NULL, you must not give any #GVariant, but %NULL instead. The parameter type of a particular action will never change but it is possible for an action to be removed and for a new action to be added with the same name but a different parameter type. the parameter type a #GActionGroup the name of the action to query Queries the current state of the named action within @action_group. If the action is not stateful then %NULL will be returned. If the action is stateful then the type of the return value is the type given by g_action_group_get_action_state_type(). The return value (if non-%NULL) should be freed with g_variant_unref() when it is no longer required. the current state of the action a #GActionGroup the name of the action to query Requests a hint about the valid range of values for the state of the named action within @action_group. If %NULL is returned it either means that the action is not stateful or that there is no hint about the valid range of values for the state of the action. If a #GVariant array is returned then each item in the array is a possible value for the state. If a #GVariant pair (ie: two-tuple) is returned then the tuple specifies the inclusive lower and upper bound of valid values for the state. In any case, the information is merely a hint. It may be possible to have a state value outside of the hinted range and setting a value within the range may fail. The return value (if non-%NULL) should be freed with g_variant_unref() when it is no longer required. the state range hint a #GActionGroup the name of the action to query Queries the type of the state of the named action within @action_group. If the action is stateful then this function returns the #GVariantType of the state. All calls to g_action_group_change_action_state() must give a #GVariant of this type and g_action_group_get_action_state() will return a #GVariant of the same type. If the action is not stateful then this function will return %NULL. In that case, g_action_group_get_action_state() will return %NULL and you must not call g_action_group_change_action_state(). The state type of a particular action will never change but it is possible for an action to be removed and for a new action to be added with the same name but a different state type. the state type, if the action is stateful a #GActionGroup the name of the action to query Checks if the named action exists within @action_group. whether the named action exists a #GActionGroup the name of the action to check for Lists the actions contained within @action_group. The caller is responsible for freeing the list with g_strfreev() when it is no longer required. a %NULL-terminated array of the names of the actions in the group a #GActionGroup Queries all aspects of the named action within an @action_group. This function acquires the information available from g_action_group_has_action(), g_action_group_get_action_enabled(), g_action_group_get_action_parameter_type(), g_action_group_get_action_state_type(), g_action_group_get_action_state_hint() and g_action_group_get_action_state() with a single function call. This provides two main benefits. The first is the improvement in efficiency that comes with not having to perform repeated lookups of the action in order to discover different things about it. The second is that implementing #GActionGroup can now be done by only overriding this one virtual function. The interface provides a default implementation of this function that calls the individual functions, as required, to fetch the information. The interface also provides default implementations of those functions that call this function. All implementations, therefore, must override either this function or all of the others. If the action exists, %TRUE is returned and any of the requested fields (as indicated by having a non-%NULL reference passed in) are filled. If the action doesn't exist, %FALSE is returned and the fields may or may not have been modified. %TRUE if the action exists, else %FALSE a #GActionGroup the name of an action in the group if the action is presently enabled the parameter type, or %NULL if none needed the state type, or %NULL if stateless the state hint, or %NULL if none the current state, or %NULL if stateless Emits the #GActionGroup::action-added signal on @action_group. This function should only be called by #GActionGroup implementations. a #GActionGroup the name of an action in the group Emits the #GActionGroup::action-enabled-changed signal on @action_group. This function should only be called by #GActionGroup implementations. a #GActionGroup the name of an action in the group whether or not the action is now enabled Emits the #GActionGroup::action-removed signal on @action_group. This function should only be called by #GActionGroup implementations. a #GActionGroup the name of an action in the group Emits the #GActionGroup::action-state-changed signal on @action_group. This function should only be called by #GActionGroup implementations. a #GActionGroup the name of an action in the group the new state of the named action Activate the named action within @action_group. If the action is expecting a parameter, then the correct type of parameter must be given as @parameter. If the action is expecting no parameters then @parameter must be %NULL. See g_action_group_get_action_parameter_type(). a #GActionGroup the name of the action to activate parameters to the activation Request for the state of the named action within @action_group to be changed to @value. The action must be stateful and @value must be of the correct type. See g_action_group_get_action_state_type(). This call merely requests a change. The action may refuse to change its state or may change its state to something other than @value. See g_action_group_get_action_state_hint(). If the @value GVariant is floating, it is consumed. a #GActionGroup the name of the action to request the change on the new state Checks if the named action within @action_group is currently enabled. An action must be enabled in order to be activated or in order to have its state changed from outside callers. whether or not the action is currently enabled a #GActionGroup the name of the action to query Queries the type of the parameter that must be given when activating the named action within @action_group. When activating the action using g_action_group_activate_action(), the #GVariant given to that function must be of the type returned by this function. In the case that this function returns %NULL, you must not give any #GVariant, but %NULL instead. The parameter type of a particular action will never change but it is possible for an action to be removed and for a new action to be added with the same name but a different parameter type. the parameter type a #GActionGroup the name of the action to query Queries the current state of the named action within @action_group. If the action is not stateful then %NULL will be returned. If the action is stateful then the type of the return value is the type given by g_action_group_get_action_state_type(). The return value (if non-%NULL) should be freed with g_variant_unref() when it is no longer required. the current state of the action a #GActionGroup the name of the action to query Requests a hint about the valid range of values for the state of the named action within @action_group. If %NULL is returned it either means that the action is not stateful or that there is no hint about the valid range of values for the state of the action. If a #GVariant array is returned then each item in the array is a possible value for the state. If a #GVariant pair (ie: two-tuple) is returned then the tuple specifies the inclusive lower and upper bound of valid values for the state. In any case, the information is merely a hint. It may be possible to have a state value outside of the hinted range and setting a value within the range may fail. The return value (if non-%NULL) should be freed with g_variant_unref() when it is no longer required. the state range hint a #GActionGroup the name of the action to query Queries the type of the state of the named action within @action_group. If the action is stateful then this function returns the #GVariantType of the state. All calls to g_action_group_change_action_state() must give a #GVariant of this type and g_action_group_get_action_state() will return a #GVariant of the same type. If the action is not stateful then this function will return %NULL. In that case, g_action_group_get_action_state() will return %NULL and you must not call g_action_group_change_action_state(). The state type of a particular action will never change but it is possible for an action to be removed and for a new action to be added with the same name but a different state type. the state type, if the action is stateful a #GActionGroup the name of the action to query Checks if the named action exists within @action_group. whether the named action exists a #GActionGroup the name of the action to check for Lists the actions contained within @action_group. The caller is responsible for freeing the list with g_strfreev() when it is no longer required. a %NULL-terminated array of the names of the actions in the group a #GActionGroup Queries all aspects of the named action within an @action_group. This function acquires the information available from g_action_group_has_action(), g_action_group_get_action_enabled(), g_action_group_get_action_parameter_type(), g_action_group_get_action_state_type(), g_action_group_get_action_state_hint() and g_action_group_get_action_state() with a single function call. This provides two main benefits. The first is the improvement in efficiency that comes with not having to perform repeated lookups of the action in order to discover different things about it. The second is that implementing #GActionGroup can now be done by only overriding this one virtual function. The interface provides a default implementation of this function that calls the individual functions, as required, to fetch the information. The interface also provides default implementations of those functions that call this function. All implementations, therefore, must override either this function or all of the others. If the action exists, %TRUE is returned and any of the requested fields (as indicated by having a non-%NULL reference passed in) are filled. If the action doesn't exist, %FALSE is returned and the fields may or may not have been modified. %TRUE if the action exists, else %FALSE a #GActionGroup the name of an action in the group if the action is presently enabled the parameter type, or %NULL if none needed the state type, or %NULL if stateless the state hint, or %NULL if none the current state, or %NULL if stateless Signals that a new action was just added to the group. This signal is emitted after the action has been added and is now visible. the name of the action in @action_group Signals that the enabled status of the named action has changed. the name of the action in @action_group whether the action is enabled or not Signals that an action is just about to be removed from the group. This signal is emitted before the action is removed, so the action is still visible and can be queried from the signal handler. the name of the action in @action_group Signals that the state of the named action has changed. the name of the action in @action_group the new value of the state The virtual function table for #GActionGroup. whether the named action exists a #GActionGroup the name of the action to check for a %NULL-terminated array of the names of the actions in the group a #GActionGroup whether or not the action is currently enabled a #GActionGroup the name of the action to query the parameter type a #GActionGroup the name of the action to query the state type, if the action is stateful a #GActionGroup the name of the action to query the state range hint a #GActionGroup the name of the action to query the current state of the action a #GActionGroup the name of the action to query a #GActionGroup the name of the action to request the change on the new state a #GActionGroup the name of the action to activate parameters to the activation a #GActionGroup the name of an action in the group a #GActionGroup the name of an action in the group a #GActionGroup the name of an action in the group whether or not the action is now enabled a #GActionGroup the name of an action in the group the new state of the named action %TRUE if the action exists, else %FALSE a #GActionGroup the name of an action in the group if the action is presently enabled the parameter type, or %NULL if none needed the state type, or %NULL if stateless the state hint, or %NULL if none the current state, or %NULL if stateless The virtual function table for #GAction. the name of the action a #GAction the parameter type a #GAction the state type, if the action is stateful a #GAction the state range hint a #GAction whether the action is enabled a #GAction the current state of the action a #GAction a #GAction the new state a #GAction the parameter to the activation The GActionMap interface is implemented by #GActionGroup implementations that operate by containing a number of named #GAction instances, such as #GSimpleActionGroup. One useful application of this interface is to map the names of actions from various action groups to unique, prefixed names (e.g. by prepending "app." or "win."). This is the motivation for the 'Map' part of the interface name. Adds an action to the @action_map. If the action map already contains an action with the same name as @action then the old action is dropped from the action map. The action map takes its own reference on @action. a #GActionMap a #GAction Looks up the action with the name @action_name in @action_map. If no such action exists, returns %NULL. a #GAction, or %NULL a #GActionMap the name of an action Removes the named action from the action map. If no action of this name is in the map then nothing happens. a #GActionMap the name of the action Adds an action to the @action_map. If the action map already contains an action with the same name as @action then the old action is dropped from the action map. The action map takes its own reference on @action. a #GActionMap a #GAction A convenience function for creating multiple #GSimpleAction instances and adding them to a #GActionMap. Each action is constructed as per one #GActionEntry. |[<!-- language="C" --> static void activate_quit (GSimpleAction *simple, GVariant *parameter, gpointer user_data) { exit (0); } static void activate_print_string (GSimpleAction *simple, GVariant *parameter, gpointer user_data) { g_print ("%s\n", g_variant_get_string (parameter, NULL)); } static GActionGroup * create_action_group (void) { const GActionEntry entries[] = { { "quit", activate_quit }, { "print-string", activate_print_string, "s" } }; GSimpleActionGroup *group; group = g_simple_action_group_new (); g_action_map_add_action_entries (G_ACTION_MAP (group), entries, G_N_ELEMENTS (entries), NULL); return G_ACTION_GROUP (group); } ]| a #GActionMap a pointer to the first item in an array of #GActionEntry structs the length of @entries, or -1 if @entries is %NULL-terminated the user data for signal connections Looks up the action with the name @action_name in @action_map. If no such action exists, returns %NULL. a #GAction, or %NULL a #GActionMap the name of an action Removes the named action from the action map. If no action of this name is in the map then nothing happens. a #GActionMap the name of the action The virtual function table for #GActionMap. a #GAction, or %NULL a #GActionMap the name of an action a #GActionMap a #GAction a #GActionMap the name of the action #GAppInfo and #GAppLaunchContext are used for describing and launching applications installed on the system. As of GLib 2.20, URIs will always be converted to POSIX paths (using g_file_get_path()) when using g_app_info_launch() even if the application requested an URI and not a POSIX path. For example for a desktop-file based application with Exec key `totem %U` and a single URI, `sftp://foo/file.avi`, then `/home/user/.gvfs/sftp on foo/file.avi` will be passed. This will only work if a set of suitable GIO extensions (such as gvfs 2.26 compiled with FUSE support), is available and operational; if this is not the case, the URI will be passed unmodified to the application. Some URIs, such as `mailto:`, of course cannot be mapped to a POSIX path (in gvfs there's no FUSE mount for it); such URIs will be passed unmodified to the application. Specifically for gvfs 2.26 and later, the POSIX URI will be mapped back to the GIO URI in the #GFile constructors (since gvfs implements the #GVfs extension point). As such, if the application needs to examine the URI, it needs to use g_file_get_uri() or similar on #GFile. In other words, an application cannot assume that the URI passed to e.g. g_file_new_for_commandline_arg() is equal to the result of g_file_get_uri(). The following snippet illustrates this: |[ GFile *f; char *uri; file = g_file_new_for_commandline_arg (uri_from_commandline); uri = g_file_get_uri (file); strcmp (uri, uri_from_commandline) == 0; g_free (uri); if (g_file_has_uri_scheme (file, "cdda")) { // do something special with uri } g_object_unref (file); ]| This code will work when both `cdda://sr0/Track 1.wav` and `/home/user/.gvfs/cdda on sr0/Track 1.wav` is passed to the application. It should be noted that it's generally not safe for applications to rely on the format of a particular URIs. Different launcher applications (e.g. file managers) may have different ideas of what a given URI means. Creates a new #GAppInfo from the given information. Note that for @commandline, the quoting rules of the Exec key of the [freedesktop.org Desktop Entry Specification](http://freedesktop.org/Standards/desktop-entry-spec) are applied. For example, if the @commandline contains percent-encoded URIs, the percent-character must be doubled in order to prevent it from being swallowed by Exec key unquoting. See the specification for exact quoting rules. new #GAppInfo for given command. the commandline to use the application name, or %NULL to use @commandline flags that can specify details of the created #GAppInfo Gets a list of all of the applications currently registered on this system. For desktop files, this includes applications that have `NoDisplay=true` set or are excluded from display by means of `OnlyShowIn` or `NotShowIn`. See g_app_info_should_show(). The returned list does not include applications which have the `Hidden` key set. a newly allocated #GList of references to #GAppInfos. Gets a list of all #GAppInfos for a given content type, including the recommended and fallback #GAppInfos. See g_app_info_get_recommended_for_type() and g_app_info_get_fallback_for_type(). #GList of #GAppInfos for given @content_type or %NULL on error. the content type to find a #GAppInfo for Gets the default #GAppInfo for a given content type. #GAppInfo for given @content_type or %NULL on error. the content type to find a #GAppInfo for if %TRUE, the #GAppInfo is expected to support URIs Gets the default application for handling URIs with the given URI scheme. A URI scheme is the initial part of the URI, up to but not including the ':', e.g. "http", "ftp" or "sip". #GAppInfo for given @uri_scheme or %NULL on error. a string containing a URI scheme. Gets a list of fallback #GAppInfos for a given content type, i.e. those applications which claim to support the given content type by MIME type subclassing and not directly. #GList of #GAppInfos for given @content_type or %NULL on error. the content type to find a #GAppInfo for Gets a list of recommended #GAppInfos for a given content type, i.e. those applications which claim to support the given content type exactly, and not by MIME type subclassing. Note that the first application of the list is the last used one, i.e. the last one for which g_app_info_set_as_last_used_for_type() has been called. #GList of #GAppInfos for given @content_type or %NULL on error. the content type to find a #GAppInfo for Utility function that launches the default application registered to handle the specified uri. Synchronous I/O is done on the uri to detect the type of the file if required. The D-Bus–activated applications don't have to be started if your application terminates too soon after this function. To prevent this, use g_app_info_launch_default_for_uri_async() instead. %TRUE on success, %FALSE on error. the uri to show an optional #GAppLaunchContext Async version of g_app_info_launch_default_for_uri(). This version is useful if you are interested in receiving error information in the case where the application is sandboxed and the portal may present an application chooser dialog to the user. This is also useful if you want to be sure that the D-Bus–activated applications are really started before termination and if you are interested in receiving error information from their activation. the uri to show an optional #GAppLaunchContext a #GCancellable a #GAsyncReadyCallback to call when the request is done data to pass to @callback Finishes an asynchronous launch-default-for-uri operation. %TRUE if the launch was successful, %FALSE if @error is set a #GAsyncResult Removes all changes to the type associations done by g_app_info_set_as_default_for_type(), g_app_info_set_as_default_for_extension(), g_app_info_add_supports_type() or g_app_info_remove_supports_type(). a content type Adds a content type to the application information to indicate the application is capable of opening files with the given content type. %TRUE on success, %FALSE on error. a #GAppInfo. a string. Obtains the information whether the #GAppInfo can be deleted. See g_app_info_delete(). %TRUE if @appinfo can be deleted a #GAppInfo Checks if a supported content type can be removed from an application. %TRUE if it is possible to remove supported content types from a given @appinfo, %FALSE if not. a #GAppInfo. Tries to delete a #GAppInfo. On some platforms, there may be a difference between user-defined #GAppInfos which can be deleted, and system-wide ones which cannot. See g_app_info_can_delete(). %TRUE if @appinfo has been deleted a #GAppInfo Creates a duplicate of a #GAppInfo. a duplicate of @appinfo. a #GAppInfo. Checks if two #GAppInfos are equal. Note that the check <emphasis>may not</emphasis> compare each individual field, and only does an identity check. In case detecting changes in the contents is needed, program code must additionally compare relevant fields. %TRUE if @appinfo1 is equal to @appinfo2. %FALSE otherwise. the first #GAppInfo. the second #GAppInfo. Gets a human-readable description of an installed application. a string containing a description of the application @appinfo, or %NULL if none. a #GAppInfo. Gets the display name of the application. The display name is often more descriptive to the user than the name itself. the display name of the application for @appinfo, or the name if no display name is available. a #GAppInfo. Gets the icon for the application. the default #GIcon for @appinfo or %NULL if there is no default icon. a #GAppInfo. Gets the ID of an application. An id is a string that identifies the application. The exact format of the id is platform dependent. For instance, on Unix this is the desktop file id from the xdg menu specification. Note that the returned ID may be %NULL, depending on how the @appinfo has been constructed. a string containing the application's ID. a #GAppInfo. Gets the installed name of the application. the name of the application for @appinfo. a #GAppInfo. Retrieves the list of content types that @app_info claims to support. If this information is not provided by the environment, this function will return %NULL. This function does not take in consideration associations added with g_app_info_add_supports_type(), but only those exported directly by the application. a list of content types. a #GAppInfo that can handle files Launches the application. Passes @files to the launched application as arguments, using the optional @context to get information about the details of the launcher (like what screen it is on). On error, @error will be set accordingly. To launch the application without arguments pass a %NULL @files list. Note that even if the launch is successful the application launched can fail to start if it runs into problems during startup. There is no way to detect this. Some URIs can be changed when passed through a GFile (for instance unsupported URIs with strange formats like mailto:), so if you have a textual URI you want to pass in as argument, consider using g_app_info_launch_uris() instead. The launched application inherits the environment of the launching process, but it can be modified with g_app_launch_context_setenv() and g_app_launch_context_unsetenv(). On UNIX, this function sets the `GIO_LAUNCHED_DESKTOP_FILE` environment variable with the path of the launched desktop file and `GIO_LAUNCHED_DESKTOP_FILE_PID` to the process id of the launched process. This can be used to ignore `GIO_LAUNCHED_DESKTOP_FILE`, should it be inherited by further processes. The `DISPLAY` and `DESKTOP_STARTUP_ID` environment variables are also set, based on information provided in @context. %TRUE on successful launch, %FALSE otherwise. a #GAppInfo a #GList of #GFile objects a #GAppLaunchContext or %NULL Launches the application. This passes the @uris to the launched application as arguments, using the optional @context to get information about the details of the launcher (like what screen it is on). On error, @error will be set accordingly. To launch the application without arguments pass a %NULL @uris list. Note that even if the launch is successful the application launched can fail to start if it runs into problems during startup. There is no way to detect this. %TRUE on successful launch, %FALSE otherwise. a #GAppInfo a #GList containing URIs to launch. a #GAppLaunchContext or %NULL Async version of g_app_info_launch_uris(). The @callback is invoked immediately after the application launch, but it waits for activation in case of D-Bus–activated applications and also provides extended error information for sandboxed applications, see notes for g_app_info_launch_default_for_uri_async(). a #GAppInfo a #GList containing URIs to launch. a #GAppLaunchContext or %NULL a #GCancellable a #GAsyncReadyCallback to call when the request is done data to pass to @callback Finishes a g_app_info_launch_uris_async() operation. %TRUE on successful launch, %FALSE otherwise. a #GAppInfo a #GAsyncResult Removes a supported type from an application, if possible. %TRUE on success, %FALSE on error. a #GAppInfo. a string. Sets the application as the default handler for the given file extension. %TRUE on success, %FALSE on error. a #GAppInfo. a string containing the file extension (without the dot). Sets the application as the default handler for a given type. %TRUE on success, %FALSE on error. a #GAppInfo. the content type. Sets the application as the last used application for a given type. This will make the application appear as first in the list returned by g_app_info_get_recommended_for_type(), regardless of the default application for that content type. %TRUE on success, %FALSE on error. a #GAppInfo. the content type. Checks if the application info should be shown in menus that list available applications. %TRUE if the @appinfo should be shown, %FALSE otherwise. a #GAppInfo. Checks if the application accepts files as arguments. %TRUE if the @appinfo supports files. a #GAppInfo. Checks if the application supports reading files and directories from URIs. %TRUE if the @appinfo supports URIs. a #GAppInfo. Adds a content type to the application information to indicate the application is capable of opening files with the given content type. %TRUE on success, %FALSE on error. a #GAppInfo. a string. Obtains the information whether the #GAppInfo can be deleted. See g_app_info_delete(). %TRUE if @appinfo can be deleted a #GAppInfo Checks if a supported content type can be removed from an application. %TRUE if it is possible to remove supported content types from a given @appinfo, %FALSE if not. a #GAppInfo. Tries to delete a #GAppInfo. On some platforms, there may be a difference between user-defined #GAppInfos which can be deleted, and system-wide ones which cannot. See g_app_info_can_delete(). %TRUE if @appinfo has been deleted a #GAppInfo Creates a duplicate of a #GAppInfo. a duplicate of @appinfo. a #GAppInfo. Checks if two #GAppInfos are equal. Note that the check <emphasis>may not</emphasis> compare each individual field, and only does an identity check. In case detecting changes in the contents is needed, program code must additionally compare relevant fields. %TRUE if @appinfo1 is equal to @appinfo2. %FALSE otherwise. the first #GAppInfo. the second #GAppInfo. Gets the commandline with which the application will be started. a string containing the @appinfo's commandline, or %NULL if this information is not available a #GAppInfo Gets a human-readable description of an installed application. a string containing a description of the application @appinfo, or %NULL if none. a #GAppInfo. Gets the display name of the application. The display name is often more descriptive to the user than the name itself. the display name of the application for @appinfo, or the name if no display name is available. a #GAppInfo. Gets the executable's name for the installed application. a string containing the @appinfo's application binaries name a #GAppInfo Gets the icon for the application. the default #GIcon for @appinfo or %NULL if there is no default icon. a #GAppInfo. Gets the ID of an application. An id is a string that identifies the application. The exact format of the id is platform dependent. For instance, on Unix this is the desktop file id from the xdg menu specification. Note that the returned ID may be %NULL, depending on how the @appinfo has been constructed. a string containing the application's ID. a #GAppInfo. Gets the installed name of the application. the name of the application for @appinfo. a #GAppInfo. Retrieves the list of content types that @app_info claims to support. If this information is not provided by the environment, this function will return %NULL. This function does not take in consideration associations added with g_app_info_add_supports_type(), but only those exported directly by the application. a list of content types. a #GAppInfo that can handle files Launches the application. Passes @files to the launched application as arguments, using the optional @context to get information about the details of the launcher (like what screen it is on). On error, @error will be set accordingly. To launch the application without arguments pass a %NULL @files list. Note that even if the launch is successful the application launched can fail to start if it runs into problems during startup. There is no way to detect this. Some URIs can be changed when passed through a GFile (for instance unsupported URIs with strange formats like mailto:), so if you have a textual URI you want to pass in as argument, consider using g_app_info_launch_uris() instead. The launched application inherits the environment of the launching process, but it can be modified with g_app_launch_context_setenv() and g_app_launch_context_unsetenv(). On UNIX, this function sets the `GIO_LAUNCHED_DESKTOP_FILE` environment variable with the path of the launched desktop file and `GIO_LAUNCHED_DESKTOP_FILE_PID` to the process id of the launched process. This can be used to ignore `GIO_LAUNCHED_DESKTOP_FILE`, should it be inherited by further processes. The `DISPLAY` and `DESKTOP_STARTUP_ID` environment variables are also set, based on information provided in @context. %TRUE on successful launch, %FALSE otherwise. a #GAppInfo a #GList of #GFile objects a #GAppLaunchContext or %NULL Launches the application. This passes the @uris to the launched application as arguments, using the optional @context to get information about the details of the launcher (like what screen it is on). On error, @error will be set accordingly. To launch the application without arguments pass a %NULL @uris list. Note that even if the launch is successful the application launched can fail to start if it runs into problems during startup. There is no way to detect this. %TRUE on successful launch, %FALSE otherwise. a #GAppInfo a #GList containing URIs to launch. a #GAppLaunchContext or %NULL Async version of g_app_info_launch_uris(). The @callback is invoked immediately after the application launch, but it waits for activation in case of D-Bus–activated applications and also provides extended error information for sandboxed applications, see notes for g_app_info_launch_default_for_uri_async(). a #GAppInfo a #GList containing URIs to launch. a #GAppLaunchContext or %NULL a #GCancellable a #GAsyncReadyCallback to call when the request is done data to pass to @callback Finishes a g_app_info_launch_uris_async() operation. %TRUE on successful launch, %FALSE otherwise. a #GAppInfo a #GAsyncResult Removes a supported type from an application, if possible. %TRUE on success, %FALSE on error. a #GAppInfo. a string. Sets the application as the default handler for the given file extension. %TRUE on success, %FALSE on error. a #GAppInfo. a string containing the file extension (without the dot). Sets the application as the default handler for a given type. %TRUE on success, %FALSE on error. a #GAppInfo. the content type. Sets the application as the last used application for a given type. This will make the application appear as first in the list returned by g_app_info_get_recommended_for_type(), regardless of the default application for that content type. %TRUE on success, %FALSE on error. a #GAppInfo. the content type. Checks if the application info should be shown in menus that list available applications. %TRUE if the @appinfo should be shown, %FALSE otherwise. a #GAppInfo. Checks if the application accepts files as arguments. %TRUE if the @appinfo supports files. a #GAppInfo. Checks if the application supports reading files and directories from URIs. %TRUE if the @appinfo supports URIs. a #GAppInfo. Flags used when creating a #GAppInfo. No flags. Application opens in a terminal window. Application supports URI arguments. Application supports startup notification. Since 2.26 Application Information interface, for operating system portability. The parent interface. a duplicate of @appinfo. a #GAppInfo. %TRUE if @appinfo1 is equal to @appinfo2. %FALSE otherwise. the first #GAppInfo. the second #GAppInfo. a string containing the application's ID. a #GAppInfo. the name of the application for @appinfo. a #GAppInfo. a string containing a description of the application @appinfo, or %NULL if none. a #GAppInfo. the default #GIcon for @appinfo or %NULL if there is no default icon. a #GAppInfo. %TRUE on successful launch, %FALSE otherwise. a #GAppInfo a #GList of #GFile objects a #GAppLaunchContext or %NULL %TRUE if the @appinfo supports URIs. a #GAppInfo. %TRUE if the @appinfo supports files. a #GAppInfo. %TRUE on successful launch, %FALSE otherwise. a #GAppInfo a #GList containing URIs to launch. a #GAppLaunchContext or %NULL %TRUE if the @appinfo should be shown, %FALSE otherwise. a #GAppInfo. %TRUE on success, %FALSE on error. a #GAppInfo. the content type. %TRUE on success, %FALSE on error. a #GAppInfo. a string containing the file extension (without the dot). %TRUE on success, %FALSE on error. a #GAppInfo. a string. %TRUE if it is possible to remove supported content types from a given @appinfo, %FALSE if not. a #GAppInfo. %TRUE on success, %FALSE on error. a #GAppInfo. a string. %TRUE if @appinfo can be deleted a #GAppInfo %TRUE if @appinfo has been deleted a #GAppInfo the display name of the application for @appinfo, or the name if no display name is available. a #GAppInfo. %TRUE on success, %FALSE on error. a #GAppInfo. the content type. a list of content types. a #GAppInfo that can handle files a #GAppInfo a #GList containing URIs to launch. a #GAppLaunchContext or %NULL a #GCancellable a #GAsyncReadyCallback to call when the request is done data to pass to @callback %TRUE on successful launch, %FALSE otherwise. a #GAppInfo a #GAsyncResult #GAppInfoMonitor is a very simple object used for monitoring the app info database for changes (ie: newly installed or removed applications). Call g_app_info_monitor_get() to get a #GAppInfoMonitor and connect to the "changed" signal. In the usual case, applications should try to make note of the change (doing things like invalidating caches) but not act on it. In particular, applications should avoid making calls to #GAppInfo APIs in response to the change signal, deferring these until the time that the data is actually required. The exception to this case is when application information is actually being displayed on the screen (eg: during a search or when the list of all applications is shown). The reason for this is that changes to the list of installed applications often come in groups (like during system updates) and rescanning the list on every change is pointless and expensive. Gets the #GAppInfoMonitor for the current thread-default main context. The #GAppInfoMonitor will emit a "changed" signal in the thread-default main context whenever the list of installed applications (as reported by g_app_info_get_all()) may have changed. You must only call g_object_unref() on the return value from under the same main context as you created it. a reference to a #GAppInfoMonitor Signal emitted when the app info database for changes (ie: newly installed or removed applications). Integrating the launch with the launching application. This is used to handle for instance startup notification and launching the new application on the same screen as the launching window. Creates a new application launch context. This is not normally used, instead you instantiate a subclass of this, such as #GdkAppLaunchContext. a #GAppLaunchContext. Gets the display string for the @context. This is used to ensure new applications are started on the same display as the launching application, by setting the `DISPLAY` environment variable. a display string for the display. a #GAppLaunchContext a #GAppInfo a #GList of #GFile objects Initiates startup notification for the application and returns the `DESKTOP_STARTUP_ID` for the launched operation, if supported. Startup notification IDs are defined in the [FreeDesktop.Org Startup Notifications standard](http://standards.freedesktop.org/startup-notification-spec/startup-notification-latest.txt). a startup notification ID for the application, or %NULL if not supported. a #GAppLaunchContext a #GAppInfo a #GList of of #GFile objects Called when an application has failed to launch, so that it can cancel the application startup notification started in g_app_launch_context_get_startup_notify_id(). a #GAppLaunchContext. the startup notification id that was returned by g_app_launch_context_get_startup_notify_id(). Gets the display string for the @context. This is used to ensure new applications are started on the same display as the launching application, by setting the `DISPLAY` environment variable. a display string for the display. a #GAppLaunchContext a #GAppInfo a #GList of #GFile objects Gets the complete environment variable list to be passed to the child process when @context is used to launch an application. This is a %NULL-terminated array of strings, where each string has the form `KEY=VALUE`. the child's environment a #GAppLaunchContext Initiates startup notification for the application and returns the `DESKTOP_STARTUP_ID` for the launched operation, if supported. Startup notification IDs are defined in the [FreeDesktop.Org Startup Notifications standard](http://standards.freedesktop.org/startup-notification-spec/startup-notification-latest.txt). a startup notification ID for the application, or %NULL if not supported. a #GAppLaunchContext a #GAppInfo a #GList of of #GFile objects Called when an application has failed to launch, so that it can cancel the application startup notification started in g_app_launch_context_get_startup_notify_id(). a #GAppLaunchContext. the startup notification id that was returned by g_app_launch_context_get_startup_notify_id(). Arranges for @variable to be set to @value in the child's environment when @context is used to launch an application. a #GAppLaunchContext the environment variable to set the value for to set the variable to. Arranges for @variable to be unset in the child's environment when @context is used to launch an application. a #GAppLaunchContext the environment variable to remove The ::launch-failed signal is emitted when a #GAppInfo launch fails. The startup notification id is provided, so that the launcher can cancel the startup notification. the startup notification id for the failed launch The ::launched signal is emitted when a #GAppInfo is successfully launched. The @platform_data is an GVariant dictionary mapping strings to variants (ie a{sv}), which contains additional, platform-specific data about this launch. On UNIX, at least the "pid" and "startup-notification-id" keys will be present. the #GAppInfo that was just launched additional platform-specific data for this launch a display string for the display. a #GAppLaunchContext a #GAppInfo a #GList of #GFile objects a startup notification ID for the application, or %NULL if not supported. a #GAppLaunchContext a #GAppInfo a #GList of of #GFile objects a #GAppLaunchContext. the startup notification id that was returned by g_app_launch_context_get_startup_notify_id(). A #GApplication is the foundation of an application. It wraps some low-level platform-specific services and is intended to act as the foundation for higher-level application classes such as #GtkApplication or #MxApplication. In general, you should not use this class outside of a higher level framework. GApplication provides convenient life cycle management by maintaining a "use count" for the primary application instance. The use count can be changed using g_application_hold() and g_application_release(). If it drops to zero, the application exits. Higher-level classes such as #GtkApplication employ the use count to ensure that the application stays alive as long as it has any opened windows. Another feature that GApplication (optionally) provides is process uniqueness. Applications can make use of this functionality by providing a unique application ID. If given, only one application with this ID can be running at a time per session. The session concept is platform-dependent, but corresponds roughly to a graphical desktop login. When your application is launched again, its arguments are passed through platform communication to the already running program. The already running instance of the program is called the "primary instance"; for non-unique applications this is always the current instance. On Linux, the D-Bus session bus is used for communication. The use of #GApplication differs from some other commonly-used uniqueness libraries (such as libunique) in important ways. The application is not expected to manually register itself and check if it is the primary instance. Instead, the main() function of a #GApplication should do very little more than instantiating the application instance, possibly connecting signal handlers, then calling g_application_run(). All checks for uniqueness are done internally. If the application is the primary instance then the startup signal is emitted and the mainloop runs. If the application is not the primary instance then a signal is sent to the primary instance and g_application_run() promptly returns. See the code examples below. If used, the expected form of an application identifier is the same as that of of a [D-Bus well-known bus name](https://dbus.freedesktop.org/doc/dbus-specification.html#message-protocol-names-bus). Examples include: `com.example.MyApp`, `org.example.internal_apps.Calculator`, `org._7_zip.Archiver`. For details on valid application identifiers, see g_application_id_is_valid(). On Linux, the application identifier is claimed as a well-known bus name on the user's session bus. This means that the uniqueness of your application is scoped to the current session. It also means that your application may provide additional services (through registration of other object paths) at that bus name. The registration of these object paths should be done with the shared GDBus session bus. Note that due to the internal architecture of GDBus, method calls can be dispatched at any time (even if a main loop is not running). For this reason, you must ensure that any object paths that you wish to register are registered before #GApplication attempts to acquire the bus name of your application (which happens in g_application_register()). Unfortunately, this means that you cannot use g_application_get_is_remote() to decide if you want to register object paths. GApplication also implements the #GActionGroup and #GActionMap interfaces and lets you easily export actions by adding them with g_action_map_add_action(). When invoking an action by calling g_action_group_activate_action() on the application, it is always invoked in the primary instance. The actions are also exported on the session bus, and GIO provides the #GDBusActionGroup wrapper to conveniently access them remotely. GIO provides a #GDBusMenuModel wrapper for remote access to exported #GMenuModels. There is a number of different entry points into a GApplication: - via 'Activate' (i.e. just starting the application) - via 'Open' (i.e. opening some files) - by handling a command-line - via activating an action The #GApplication::startup signal lets you handle the application initialization for all of these in a single place. Regardless of which of these entry points is used to start the application, GApplication passes some ‘platform data’ from the launching instance to the primary instance, in the form of a #GVariant dictionary mapping strings to variants. To use platform data, override the @before_emit or @after_emit virtual functions in your #GApplication subclass. When dealing with #GApplicationCommandLine objects, the platform data is directly available via g_application_command_line_get_cwd(), g_application_command_line_get_environ() and g_application_command_line_get_platform_data(). As the name indicates, the platform data may vary depending on the operating system, but it always includes the current directory (key "cwd"), and optionally the environment (ie the set of environment variables and their values) of the calling process (key "environ"). The environment is only added to the platform data if the %G_APPLICATION_SEND_ENVIRONMENT flag is set. #GApplication subclasses can add their own platform data by overriding the @add_platform_data virtual function. For instance, #GtkApplication adds startup notification data in this way. To parse commandline arguments you may handle the #GApplication::command-line signal or override the local_command_line() vfunc, to parse them in either the primary instance or the local instance, respectively. For an example of opening files with a GApplication, see [gapplication-example-open.c](https://git.gnome.org/browse/glib/tree/gio/tests/gapplication-example-open.c). For an example of using actions with GApplication, see [gapplication-example-actions.c](https://git.gnome.org/browse/glib/tree/gio/tests/gapplication-example-actions.c). For an example of using extra D-Bus hooks with GApplication, see [gapplication-example-dbushooks.c](https://git.gnome.org/browse/glib/tree/gio/tests/gapplication-example-dbushooks.c). Creates a new #GApplication instance. If non-%NULL, the application id must be valid. See g_application_id_is_valid(). If no application ID is given then some features of #GApplication (most notably application uniqueness) will be disabled. a new #GApplication instance the application id the application flags Returns the default #GApplication instance for this process. Normally there is only one #GApplication per process and it becomes the default when it is created. You can exercise more control over this by using g_application_set_default(). If there is no default application then %NULL is returned. the default application for this process, or %NULL Checks if @application_id is a valid application identifier. A valid ID is required for calls to g_application_new() and g_application_set_application_id(). Application identifiers follow the same format as [D-Bus well-known bus names](https://dbus.freedesktop.org/doc/dbus-specification.html#message-protocol-names-bus). For convenience, the restrictions on application identifiers are reproduced here: - Application identifiers are composed of 1 or more elements separated by a period (`.`) character. All elements must contain at least one character. - Each element must only contain the ASCII characters `[A-Z][a-z][0-9]_-`, with `-` discouraged in new application identifiers. Each element must not begin with a digit. - Application identifiers must contain at least one `.` (period) character (and thus at least two elements). - Application identifiers must not begin with a `.` (period) character. - Application identifiers must not exceed 255 characters. Note that the hyphen (`-`) character is allowed in application identifiers, but is problematic or not allowed in various specifications and APIs that refer to D-Bus, such as [Flatpak application IDs](http://docs.flatpak.org/en/latest/introduction.html#identifiers), the [`DBusActivatable` interface in the Desktop Entry Specification](https://specifications.freedesktop.org/desktop-entry-spec/desktop-entry-spec-latest.html#dbus), and the convention that an application's "main" interface and object path resemble its application identifier and bus name. To avoid situations that require special-case handling, it is recommended that new application identifiers consistently replace hyphens with underscores. Like D-Bus interface names, application identifiers should start with the reversed DNS domain name of the author of the interface (in lower-case), and it is conventional for the rest of the application identifier to consist of words run together, with initial capital letters. As with D-Bus interface names, if the author's DNS domain name contains hyphen/minus characters they should be replaced by underscores, and if it contains leading digits they should be escaped by prepending an underscore. For example, if the owner of 7-zip.org used an application identifier for an archiving application, it might be named `org._7_zip.Archiver`. %TRUE if @application_id is valid a potential application identifier Activates the application. In essence, this results in the #GApplication::activate signal being emitted in the primary instance. The application must be registered before calling this function. a #GApplication This virtual function is always invoked in the local instance. It gets passed a pointer to a %NULL-terminated copy of @argv and is expected to remove arguments that it handled (shifting up remaining arguments). The last argument to local_command_line() is a pointer to the @status variable which can used to set the exit status that is returned from g_application_run(). See g_application_run() for more details on #GApplication startup. %TRUE if the commandline has been completely handled a #GApplication array of command line arguments exit status to fill after processing the command line. Opens the given files. In essence, this results in the #GApplication::open signal being emitted in the primary instance. @n_files must be greater than zero. @hint is simply passed through to the ::open signal. It is intended to be used by applications that have multiple modes for opening files (eg: "view" vs "edit", etc). Unless you have a need for this functionality, you should use "". The application must be registered before calling this function and it must have the %G_APPLICATION_HANDLES_OPEN flag set. a #GApplication an array of #GFiles to open the length of the @files array a hint (or ""), but never %NULL Activates the application. In essence, this results in the #GApplication::activate signal being emitted in the primary instance. The application must be registered before calling this function. a #GApplication Add an option to be handled by @application. Calling this function is the equivalent of calling g_application_add_main_option_entries() with a single #GOptionEntry that has its arg_data member set to %NULL. The parsed arguments will be packed into a #GVariantDict which is passed to #GApplication::handle-local-options. If %G_APPLICATION_HANDLES_COMMAND_LINE is set, then it will also be sent to the primary instance. See g_application_add_main_option_entries() for more details. See #GOptionEntry for more documentation of the arguments. the #GApplication the long name of an option used to specify it in a commandline the short name of an option flags from #GOptionFlags the type of the option, as a #GOptionArg the description for the option in `--help` output the placeholder to use for the extra argument parsed by the option in `--help` output Adds main option entries to be handled by @application. This function is comparable to g_option_context_add_main_entries(). After the commandline arguments are parsed, the #GApplication::handle-local-options signal will be emitted. At this point, the application can inspect the values pointed to by @arg_data in the given #GOptionEntrys. Unlike #GOptionContext, #GApplication supports giving a %NULL @arg_data for a non-callback #GOptionEntry. This results in the argument in question being packed into a #GVariantDict which is also passed to #GApplication::handle-local-options, where it can be inspected and modified. If %G_APPLICATION_HANDLES_COMMAND_LINE is set, then the resulting dictionary is sent to the primary instance, where g_application_command_line_get_options_dict() will return it. This "packing" is done according to the type of the argument -- booleans for normal flags, strings for strings, bytestrings for filenames, etc. The packing only occurs if the flag is given (ie: we do not pack a "false" #GVariant in the case that a flag is missing). In general, it is recommended that all commandline arguments are parsed locally. The options dictionary should then be used to transmit the result of the parsing to the primary instance, where g_variant_dict_lookup() can be used. For local options, it is possible to either use @arg_data in the usual way, or to consult (and potentially remove) the option from the options dictionary. This function is new in GLib 2.40. Before then, the only real choice was to send all of the commandline arguments (options and all) to the primary instance for handling. #GApplication ignored them completely on the local side. Calling this function "opts in" to the new behaviour, and in particular, means that unrecognised options will be treated as errors. Unrecognised options have never been ignored when %G_APPLICATION_HANDLES_COMMAND_LINE is unset. If #GApplication::handle-local-options needs to see the list of filenames, then the use of %G_OPTION_REMAINING is recommended. If @arg_data is %NULL then %G_OPTION_REMAINING can be used as a key into the options dictionary. If you do use %G_OPTION_REMAINING then you need to handle these arguments for yourself because once they are consumed, they will no longer be visible to the default handling (which treats them as filenames to be opened). It is important to use the proper GVariant format when retrieving the options with g_variant_dict_lookup(): - for %G_OPTION_ARG_NONE, use `b` - for %G_OPTION_ARG_STRING, use `&s` - for %G_OPTION_ARG_INT, use `i` - for %G_OPTION_ARG_INT64, use `x` - for %G_OPTION_ARG_DOUBLE, use `d` - for %G_OPTION_ARG_FILENAME, use `^&ay` - for %G_OPTION_ARG_STRING_ARRAY, use `^a&s` - for %G_OPTION_ARG_FILENAME_ARRAY, use `^a&ay` a #GApplication a %NULL-terminated list of #GOptionEntrys Adds a #GOptionGroup to the commandline handling of @application. This function is comparable to g_option_context_add_group(). Unlike g_application_add_main_option_entries(), this function does not deal with %NULL @arg_data and never transmits options to the primary instance. The reason for that is because, by the time the options arrive at the primary instance, it is typically too late to do anything with them. Taking the GTK option group as an example: GTK will already have been initialised by the time the #GApplication::command-line handler runs. In the case that this is not the first-running instance of the application, the existing instance may already have been running for a very long time. This means that the options from #GOptionGroup are only really usable in the case that the instance of the application being run is the first instance. Passing options like `--display=` or `--gdk-debug=` on future runs will have no effect on the existing primary instance. Calling this function will cause the options in the supplied option group to be parsed, but it does not cause you to be "opted in" to the new functionality whereby unrecognised options are rejected even if %G_APPLICATION_HANDLES_COMMAND_LINE was given. the #GApplication a #GOptionGroup Marks @application as busy (see g_application_mark_busy()) while @property on @object is %TRUE. The binding holds a reference to @application while it is active, but not to @object. Instead, the binding is destroyed when @object is finalized. a #GApplication a #GObject the name of a boolean property of @object Gets the unique identifier for @application. the identifier for @application, owned by @application a #GApplication Gets the #GDBusConnection being used by the application, or %NULL. If #GApplication is using its D-Bus backend then this function will return the #GDBusConnection being used for uniqueness and communication with the desktop environment and other instances of the application. If #GApplication is not using D-Bus then this function will return %NULL. This includes the situation where the D-Bus backend would normally be in use but we were unable to connect to the bus. This function must not be called before the application has been registered. See g_application_get_is_registered(). a #GDBusConnection, or %NULL a #GApplication Gets the D-Bus object path being used by the application, or %NULL. If #GApplication is using its D-Bus backend then this function will return the D-Bus object path that #GApplication is using. If the application is the primary instance then there is an object published at this path. If the application is not the primary instance then the result of this function is undefined. If #GApplication is not using D-Bus then this function will return %NULL. This includes the situation where the D-Bus backend would normally be in use but we were unable to connect to the bus. This function must not be called before the application has been registered. See g_application_get_is_registered(). the object path, or %NULL a #GApplication Gets the flags for @application. See #GApplicationFlags. the flags for @application a #GApplication Gets the current inactivity timeout for the application. This is the amount of time (in milliseconds) after the last call to g_application_release() before the application stops running. the timeout, in milliseconds a #GApplication Gets the application's current busy state, as set through g_application_mark_busy() or g_application_bind_busy_property(). %TRUE if @application is currently marked as busy a #GApplication Checks if @application is registered. An application is registered if g_application_register() has been successfully called. %TRUE if @application is registered a #GApplication Checks if @application is remote. If @application is remote then it means that another instance of application already exists (the 'primary' instance). Calls to perform actions on @application will result in the actions being performed by the primary instance. The value of this property cannot be accessed before g_application_register() has been called. See g_application_get_is_registered(). %TRUE if @application is remote a #GApplication Gets the resource base path of @application. See g_application_set_resource_base_path() for more information. the base resource path, if one is set a #GApplication Increases the use count of @application. Use this function to indicate that the application has a reason to continue to run. For example, g_application_hold() is called by GTK+ when a toplevel window is on the screen. To cancel the hold, call g_application_release(). a #GApplication Increases the busy count of @application. Use this function to indicate that the application is busy, for instance while a long running operation is pending. The busy state will be exposed to other processes, so a session shell will use that information to indicate the state to the user (e.g. with a spinner). To cancel the busy indication, use g_application_unmark_busy(). a #GApplication Opens the given files. In essence, this results in the #GApplication::open signal being emitted in the primary instance. @n_files must be greater than zero. @hint is simply passed through to the ::open signal. It is intended to be used by applications that have multiple modes for opening files (eg: "view" vs "edit", etc). Unless you have a need for this functionality, you should use "". The application must be registered before calling this function and it must have the %G_APPLICATION_HANDLES_OPEN flag set. a #GApplication an array of #GFiles to open the length of the @files array a hint (or ""), but never %NULL Immediately quits the application. Upon return to the mainloop, g_application_run() will return, calling only the 'shutdown' function before doing so. The hold count is ignored. Take care if your code has called g_application_hold() on the application and is therefore still expecting it to exist. (Note that you may have called g_application_hold() indirectly, for example through gtk_application_add_window().) The result of calling g_application_run() again after it returns is unspecified. a #GApplication Attempts registration of the application. This is the point at which the application discovers if it is the primary instance or merely acting as a remote for an already-existing primary instance. This is implemented by attempting to acquire the application identifier as a unique bus name on the session bus using GDBus. If there is no application ID or if %G_APPLICATION_NON_UNIQUE was given, then this process will always become the primary instance. Due to the internal architecture of GDBus, method calls can be dispatched at any time (even if a main loop is not running). For this reason, you must ensure that any object paths that you wish to register are registered before calling this function. If the application has already been registered then %TRUE is returned with no work performed. The #GApplication::startup signal is emitted if registration succeeds and @application is the primary instance (including the non-unique case). In the event of an error (such as @cancellable being cancelled, or a failure to connect to the session bus), %FALSE is returned and @error is set appropriately. Note: the return value of this function is not an indicator that this instance is or is not the primary instance of the application. See g_application_get_is_remote() for that. %TRUE if registration succeeded a #GApplication a #GCancellable, or %NULL Decrease the use count of @application. When the use count reaches zero, the application will stop running. Never call this function except to cancel the effect of a previous call to g_application_hold(). a #GApplication Runs the application. This function is intended to be run from main() and its return value is intended to be returned by main(). Although you are expected to pass the @argc, @argv parameters from main() to this function, it is possible to pass %NULL if @argv is not available or commandline handling is not required. Note that on Windows, @argc and @argv are ignored, and g_win32_get_command_line() is called internally (for proper support of Unicode commandline arguments). #GApplication will attempt to parse the commandline arguments. You can add commandline flags to the list of recognised options by way of g_application_add_main_option_entries(). After this, the #GApplication::handle-local-options signal is emitted, from which the application can inspect the values of its #GOptionEntrys. #GApplication::handle-local-options is a good place to handle options such as `--version`, where an immediate reply from the local process is desired (instead of communicating with an already-running instance). A #GApplication::handle-local-options handler can stop further processing by returning a non-negative value, which then becomes the exit status of the process. What happens next depends on the flags: if %G_APPLICATION_HANDLES_COMMAND_LINE was specified then the remaining commandline arguments are sent to the primary instance, where a #GApplication::command-line signal is emitted. Otherwise, the remaining commandline arguments are assumed to be a list of files. If there are no files listed, the application is activated via the #GApplication::activate signal. If there are one or more files, and %G_APPLICATION_HANDLES_OPEN was specified then the files are opened via the #GApplication::open signal. If you are interested in doing more complicated local handling of the commandline then you should implement your own #GApplication subclass and override local_command_line(). In this case, you most likely want to return %TRUE from your local_command_line() implementation to suppress the default handling. See [gapplication-example-cmdline2.c][gapplication-example-cmdline2] for an example. If, after the above is done, the use count of the application is zero then the exit status is returned immediately. If the use count is non-zero then the default main context is iterated until the use count falls to zero, at which point 0 is returned. If the %G_APPLICATION_IS_SERVICE flag is set, then the service will run for as much as 10 seconds with a use count of zero while waiting for the message that caused the activation to arrive. After that, if the use count falls to zero the application will exit immediately, except in the case that g_application_set_inactivity_timeout() is in use. This function sets the prgname (g_set_prgname()), if not already set, to the basename of argv[0]. Much like g_main_loop_run(), this function will acquire the main context for the duration that the application is running. Since 2.40, applications that are not explicitly flagged as services or launchers (ie: neither %G_APPLICATION_IS_SERVICE or %G_APPLICATION_IS_LAUNCHER are given as flags) will check (from the default handler for local_command_line) if "--gapplication-service" was given in the command line. If this flag is present then normal commandline processing is interrupted and the %G_APPLICATION_IS_SERVICE flag is set. This provides a "compromise" solution whereby running an application directly from the commandline will invoke it in the normal way (which can be useful for debugging) while still allowing applications to be D-Bus activated in service mode. The D-Bus service file should invoke the executable with "--gapplication-service" as the sole commandline argument. This approach is suitable for use by most graphical applications but should not be used from applications like editors that need precise control over when processes invoked via the commandline will exit and what their exit status will be. the exit status a #GApplication the argc from main() (or 0 if @argv is %NULL) the argv from main(), or %NULL Sends a notification on behalf of @application to the desktop shell. There is no guarantee that the notification is displayed immediately, or even at all. Notifications may persist after the application exits. It will be D-Bus-activated when the notification or one of its actions is activated. Modifying @notification after this call has no effect. However, the object can be reused for a later call to this function. @id may be any string that uniquely identifies the event for the application. It does not need to be in any special format. For example, "new-message" might be appropriate for a notification about new messages. If a previous notification was sent with the same @id, it will be replaced with @notification and shown again as if it was a new notification. This works even for notifications sent from a previous execution of the application, as long as @id is the same string. @id may be %NULL, but it is impossible to replace or withdraw notifications without an id. If @notification is no longer relevant, it can be withdrawn with g_application_withdraw_notification(). a #GApplication id of the notification, or %NULL the #GNotification to send This used to be how actions were associated with a #GApplication. Now there is #GActionMap for that. Use the #GActionMap interface instead. Never ever mix use of this API with use of #GActionMap on the same @application or things will go very badly wrong. This function is known to introduce buggy behaviour (ie: signals not emitted on changes to the action group), so you should really use #GActionMap instead. a #GApplication a #GActionGroup, or %NULL Sets the unique identifier for @application. The application id can only be modified if @application has not yet been registered. If non-%NULL, the application id must be valid. See g_application_id_is_valid(). a #GApplication the identifier for @application Sets or unsets the default application for the process, as returned by g_application_get_default(). This function does not take its own reference on @application. If @application is destroyed then the default application will revert back to %NULL. the application to set as default, or %NULL Sets the flags for @application. The flags can only be modified if @application has not yet been registered. See #GApplicationFlags. a #GApplication the flags for @application Sets the current inactivity timeout for the application. This is the amount of time (in milliseconds) after the last call to g_application_release() before the application stops running. This call has no side effects of its own. The value set here is only used for next time g_application_release() drops the use count to zero. Any timeouts currently in progress are not impacted. a #GApplication the timeout, in milliseconds Adds a description to the @application option context. See g_option_context_set_description() for more information. the #GApplication a string to be shown in `--help` output after the list of options, or %NULL Sets the parameter string to be used by the commandline handling of @application. This function registers the argument to be passed to g_option_context_new() when the internal #GOptionContext of @application is created. See g_option_context_new() for more information about @parameter_string. the #GApplication a string which is displayed in the first line of `--help` output, after the usage summary `programname [OPTION...]`. Adds a summary to the @application option context. See g_option_context_set_summary() for more information. the #GApplication a string to be shown in `--help` output before the list of options, or %NULL Sets (or unsets) the base resource path of @application. The path is used to automatically load various [application resources][gresource] such as menu layouts and action descriptions. The various types of resources will be found at fixed names relative to the given base path. By default, the resource base path is determined from the application ID by prefixing '/' and replacing each '.' with '/'. This is done at the time that the #GApplication object is constructed. Changes to the application ID after that point will not have an impact on the resource base path. As an example, if the application has an ID of "org.example.app" then the default resource base path will be "/org/example/app". If this is a #GtkApplication (and you have not manually changed the path) then Gtk will then search for the menus of the application at "/org/example/app/gtk/menus.ui". See #GResource for more information about adding resources to your application. You can disable automatic resource loading functionality by setting the path to %NULL. Changing the resource base path once the application is running is not recommended. The point at which the resource path is consulted for forming paths for various purposes is unspecified. When writing a sub-class of #GApplication you should either set the #GApplication:resource-base-path property at construction time, or call this function during the instance initialization. Alternatively, you can call this function in the #GApplicationClass.startup virtual function, before chaining up to the parent implementation. a #GApplication the resource path to use Destroys a binding between @property and the busy state of @application that was previously created with g_application_bind_busy_property(). a #GApplication a #GObject the name of a boolean property of @object Decreases the busy count of @application. When the busy count reaches zero, the new state will be propagated to other processes. This function must only be called to cancel the effect of a previous call to g_application_mark_busy(). a #GApplication Withdraws a notification that was sent with g_application_send_notification(). This call does nothing if a notification with @id doesn't exist or the notification was never sent. This function works even for notifications sent in previous executions of this application, as long @id is the same as it was for the sent notification. Note that notifications are dismissed when the user clicks on one of the buttons in a notification or triggers its default action, so there is no need to explicitly withdraw the notification in that case. a #GApplication id of a previously sent notification Whether the application is currently marked as busy through g_application_mark_busy() or g_application_bind_busy_property(). The ::activate signal is emitted on the primary instance when an activation occurs. See g_application_activate(). The ::command-line signal is emitted on the primary instance when a commandline is not handled locally. See g_application_run() and the #GApplicationCommandLine documentation for more information. An integer that is set as the exit status for the calling process. See g_application_command_line_set_exit_status(). a #GApplicationCommandLine representing the passed commandline The ::handle-local-options signal is emitted on the local instance after the parsing of the commandline options has occurred. You can add options to be recognised during commandline option parsing using g_application_add_main_option_entries() and g_application_add_option_group(). Signal handlers can inspect @options (along with values pointed to from the @arg_data of an installed #GOptionEntrys) in order to decide to perform certain actions, including direct local handling (which may be useful for options like --version). In the event that the application is marked %G_APPLICATION_HANDLES_COMMAND_LINE the "normal processing" will send the @options dictionary to the primary instance where it can be read with g_application_command_line_get_options_dict(). The signal handler can modify the dictionary before returning, and the modified dictionary will be sent. In the event that %G_APPLICATION_HANDLES_COMMAND_LINE is not set, "normal processing" will treat the remaining uncollected command line arguments as filenames or URIs. If there are no arguments, the application is activated by g_application_activate(). One or more arguments results in a call to g_application_open(). If you want to handle the local commandline arguments for yourself by converting them to calls to g_application_open() or g_action_group_activate_action() then you must be sure to register the application first. You should probably not call g_application_activate() for yourself, however: just return -1 and allow the default handler to do it for you. This will ensure that the `--gapplication-service` switch works properly (i.e. no activation in that case). Note that this signal is emitted from the default implementation of local_command_line(). If you override that function and don't chain up then this signal will never be emitted. You can override local_command_line() if you need more powerful capabilities than what is provided here, but this should not normally be required. an exit code. If you have handled your options and want to exit the process, return a non-negative option, 0 for success, and a positive value for failure. To continue, return -1 to let the default option processing continue. the options dictionary The ::name-lost signal is emitted only on the registered primary instance when a new instance has taken over. This can only happen if the application is using the %G_APPLICATION_ALLOW_REPLACEMENT flag. The default handler for this signal calls g_application_quit(). %TRUE if the signal has been handled The ::open signal is emitted on the primary instance when there are files to open. See g_application_open() for more information. an array of #GFiles the length of @files a hint provided by the calling instance The ::shutdown signal is emitted only on the registered primary instance immediately after the main loop terminates. The ::startup signal is emitted on the primary instance immediately after registration. See g_application_register(). Virtual function table for #GApplication. a #GApplication a #GApplication an array of #GFiles to open the length of the @files array a hint (or ""), but never %NULL %TRUE if the commandline has been completely handled a #GApplication array of command line arguments exit status to fill after processing the command line. #GApplicationCommandLine represents a command-line invocation of an application. It is created by #GApplication and emitted in the #GApplication::command-line signal and virtual function. The class contains the list of arguments that the program was invoked with. It is also possible to query if the commandline invocation was local (ie: the current process is running in direct response to the invocation) or remote (ie: some other process forwarded the commandline to this process). The GApplicationCommandLine object can provide the @argc and @argv parameters for use with the #GOptionContext command-line parsing API, with the g_application_command_line_get_arguments() function. See [gapplication-example-cmdline3.c][gapplication-example-cmdline3] for an example. The exit status of the originally-invoked process may be set and messages can be printed to stdout or stderr of that process. The lifecycle of the originally-invoked process is tied to the lifecycle of this object (ie: the process exits when the last reference is dropped). The main use for #GApplicationCommandLine (and the #GApplication::command-line signal) is 'Emacs server' like use cases: You can set the `EDITOR` environment variable to have e.g. git use your favourite editor to edit commit messages, and if you already have an instance of the editor running, the editing will happen in the running instance, instead of opening a new one. An important aspect of this use case is that the process that gets started by git does not return until the editing is done. Normally, the commandline is completely handled in the #GApplication::command-line handler. The launching instance exits once the signal handler in the primary instance has returned, and the return value of the signal handler becomes the exit status of the launching instance. |[<!-- language="C" --> static int command_line (GApplication *application, GApplicationCommandLine *cmdline) { gchar **argv; gint argc; gint i; argv = g_application_command_line_get_arguments (cmdline, &argc); g_application_command_line_print (cmdline, "This text is written back\n" "to stdout of the caller\n"); for (i = 0; i < argc; i++) g_print ("argument %d: %s\n", i, argv[i]); g_strfreev (argv); return 0; } ]| The complete example can be found here: [gapplication-example-cmdline.c](https://git.gnome.org/browse/glib/tree/gio/tests/gapplication-example-cmdline.c) In more complicated cases, the handling of the comandline can be split between the launcher and the primary instance. |[<!-- language="C" --> static gboolean test_local_cmdline (GApplication *application, gchar ***arguments, gint *exit_status) { gint i, j; gchar **argv; argv = *arguments; i = 1; while (argv[i]) { if (g_str_has_prefix (argv[i], "--local-")) { g_print ("handling argument %s locally\n", argv[i]); g_free (argv[i]); for (j = i; argv[j]; j++) argv[j] = argv[j + 1]; } else { g_print ("not handling argument %s locally\n", argv[i]); i++; } } *exit_status = 0; return FALSE; } static void test_application_class_init (TestApplicationClass *class) { G_APPLICATION_CLASS (class)->local_command_line = test_local_cmdline; ... } ]| In this example of split commandline handling, options that start with `--local-` are handled locally, all other options are passed to the #GApplication::command-line handler which runs in the primary instance. The complete example can be found here: [gapplication-example-cmdline2.c](https://git.gnome.org/browse/glib/tree/gio/tests/gapplication-example-cmdline2.c) If handling the commandline requires a lot of work, it may be better to defer it. |[<!-- language="C" --> static gboolean my_cmdline_handler (gpointer data) { GApplicationCommandLine *cmdline = data; // do the heavy lifting in an idle g_application_command_line_set_exit_status (cmdline, 0); g_object_unref (cmdline); // this releases the application return G_SOURCE_REMOVE; } static int command_line (GApplication *application, GApplicationCommandLine *cmdline) { // keep the application running until we are done with this commandline g_application_hold (application); g_object_set_data_full (G_OBJECT (cmdline), "application", application, (GDestroyNotify)g_application_release); g_object_ref (cmdline); g_idle_add (my_cmdline_handler, cmdline); return 0; } ]| In this example the commandline is not completely handled before the #GApplication::command-line handler returns. Instead, we keep a reference to the #GApplicationCommandLine object and handle it later (in this example, in an idle). Note that it is necessary to hold the application until you are done with the commandline. The complete example can be found here: [gapplication-example-cmdline3.c](https://git.gnome.org/browse/glib/tree/gio/tests/gapplication-example-cmdline3.c) Gets the stdin of the invoking process. The #GInputStream can be used to read data passed to the standard input of the invoking process. This doesn't work on all platforms. Presently, it is only available on UNIX when using a DBus daemon capable of passing file descriptors. If stdin is not available then %NULL will be returned. In the future, support may be expanded to other platforms. You must only call this function once per commandline invocation. a #GInputStream for stdin a #GApplicationCommandLine Creates a #GFile corresponding to a filename that was given as part of the invocation of @cmdline. This differs from g_file_new_for_commandline_arg() in that it resolves relative pathnames using the current working directory of the invoking process rather than the local process. a new #GFile a #GApplicationCommandLine an argument from @cmdline Gets the list of arguments that was passed on the command line. The strings in the array may contain non-UTF-8 data on UNIX (such as filenames or arguments given in the system locale) but are always in UTF-8 on Windows. If you wish to use the return value with #GOptionContext, you must use g_option_context_parse_strv(). The return value is %NULL-terminated and should be freed using g_strfreev(). the string array containing the arguments (the argv) a #GApplicationCommandLine the length of the arguments array, or %NULL Gets the working directory of the command line invocation. The string may contain non-utf8 data. It is possible that the remote application did not send a working directory, so this may be %NULL. The return value should not be modified or freed and is valid for as long as @cmdline exists. the current directory, or %NULL a #GApplicationCommandLine Gets the contents of the 'environ' variable of the command line invocation, as would be returned by g_get_environ(), ie as a %NULL-terminated list of strings in the form 'NAME=VALUE'. The strings may contain non-utf8 data. The remote application usually does not send an environment. Use %G_APPLICATION_SEND_ENVIRONMENT to affect that. Even with this flag set it is possible that the environment is still not available (due to invocation messages from other applications). The return value should not be modified or freed and is valid for as long as @cmdline exists. See g_application_command_line_getenv() if you are only interested in the value of a single environment variable. the environment strings, or %NULL if they were not sent a #GApplicationCommandLine Gets the exit status of @cmdline. See g_application_command_line_set_exit_status() for more information. the exit status a #GApplicationCommandLine Determines if @cmdline represents a remote invocation. %TRUE if the invocation was remote a #GApplicationCommandLine Gets the options there were passed to g_application_command_line(). If you did not override local_command_line() then these are the same options that were parsed according to the #GOptionEntrys added to the application with g_application_add_main_option_entries() and possibly modified from your GApplication::handle-local-options handler. If no options were sent then an empty dictionary is returned so that you don't need to check for %NULL. a #GVariantDict with the options a #GApplicationCommandLine Gets the platform data associated with the invocation of @cmdline. This is a #GVariant dictionary containing information about the context in which the invocation occurred. It typically contains information like the current working directory and the startup notification ID. For local invocation, it will be %NULL. the platform data, or %NULL #GApplicationCommandLine Gets the stdin of the invoking process. The #GInputStream can be used to read data passed to the standard input of the invoking process. This doesn't work on all platforms. Presently, it is only available on UNIX when using a DBus daemon capable of passing file descriptors. If stdin is not available then %NULL will be returned. In the future, support may be expanded to other platforms. You must only call this function once per commandline invocation. a #GInputStream for stdin a #GApplicationCommandLine Gets the value of a particular environment variable of the command line invocation, as would be returned by g_getenv(). The strings may contain non-utf8 data. The remote application usually does not send an environment. Use %G_APPLICATION_SEND_ENVIRONMENT to affect that. Even with this flag set it is possible that the environment is still not available (due to invocation messages from other applications). The return value should not be modified or freed and is valid for as long as @cmdline exists. the value of the variable, or %NULL if unset or unsent a #GApplicationCommandLine the environment variable to get Formats a message and prints it using the stdout print handler in the invoking process. If @cmdline is a local invocation then this is exactly equivalent to g_print(). If @cmdline is remote then this is equivalent to calling g_print() in the invoking process. a #GApplicationCommandLine a printf-style format string arguments, as per @format Formats a message and prints it using the stderr print handler in the invoking process. If @cmdline is a local invocation then this is exactly equivalent to g_printerr(). If @cmdline is remote then this is equivalent to calling g_printerr() in the invoking process. a #GApplicationCommandLine a printf-style format string arguments, as per @format Sets the exit status that will be used when the invoking process exits. The return value of the #GApplication::command-line signal is passed to this function when the handler returns. This is the usual way of setting the exit status. In the event that you want the remote invocation to continue running and want to decide on the exit status in the future, you can use this call. For the case of a remote invocation, the remote process will typically exit when the last reference is dropped on @cmdline. The exit status of the remote process will be equal to the last value that was set with this function. In the case that the commandline invocation is local, the situation is slightly more complicated. If the commandline invocation results in the mainloop running (ie: because the use-count of the application increased to a non-zero value) then the application is considered to have been 'successful' in a certain sense, and the exit status is always zero. If the application use count is zero, though, the exit status of the local #GApplicationCommandLine is used. a #GApplicationCommandLine the exit status The #GApplicationCommandLineClass-struct contains private data only. a #GInputStream for stdin a #GApplicationCommandLine Flags used to define the behaviour of a #GApplication. Default Run as a service. In this mode, registration fails if the service is already running, and the application will initially wait up to 10 seconds for an initial activation message to arrive. Don't try to become the primary instance. This application handles opening files (in the primary instance). Note that this flag only affects the default implementation of local_command_line(), and has no effect if %G_APPLICATION_HANDLES_COMMAND_LINE is given. See g_application_run() for details. This application handles command line arguments (in the primary instance). Note that this flag only affect the default implementation of local_command_line(). See g_application_run() for details. Send the environment of the launching process to the primary instance. Set this flag if your application is expected to behave differently depending on certain environment variables. For instance, an editor might be expected to use the `GIT_COMMITTER_NAME` environment variable when editing a git commit message. The environment is available to the #GApplication::command-line signal handler, via g_application_command_line_getenv(). Make no attempts to do any of the typical single-instance application negotiation, even if the application ID is given. The application neither attempts to become the owner of the application ID nor does it check if an existing owner already exists. Everything occurs in the local process. Since: 2.30. Allow users to override the application ID from the command line with `--gapplication-app-id`. Since: 2.48 Allow another instance to take over the bus name. Since: 2.60 Take over from another instance. This flag is usually set by passing `--gapplication-replace` on the commandline. Since: 2.60 #GAskPasswordFlags are used to request specific information from the user, or to notify the user of their choices in an authentication situation. operation requires a password. operation requires a username. operation requires a domain. operation supports saving settings. operation supports anonymous users. operation takes TCRYPT parameters (Since: 2.58) This is the asynchronous version of #GInitable; it behaves the same in all ways except that initialization is asynchronous. For more details see the descriptions on #GInitable. A class may implement both the #GInitable and #GAsyncInitable interfaces. Users of objects implementing this are not intended to use the interface method directly; instead it will be used automatically in various ways. For C applications you generally just call g_async_initable_new_async() directly, or indirectly via a foo_thing_new_async() wrapper. This will call g_async_initable_init_async() under the cover, calling back with %NULL and a set %GError on failure. A typical implementation might look something like this: |[<!-- language="C" --> enum { NOT_INITIALIZED, INITIALIZING, INITIALIZED }; static void _foo_ready_cb (Foo *self) { GList *l; self->priv->state = INITIALIZED; for (l = self->priv->init_results; l != NULL; l = l->next) { GTask *task = l->data; if (self->priv->success) g_task_return_boolean (task, TRUE); else g_task_return_new_error (task, ...); g_object_unref (task); } g_list_free (self->priv->init_results); self->priv->init_results = NULL; } static void foo_init_async (GAsyncInitable *initable, int io_priority, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data) { Foo *self = FOO (initable); GTask *task; task = g_task_new (initable, cancellable, callback, user_data); g_task_set_name (task, G_STRFUNC); switch (self->priv->state) { case NOT_INITIALIZED: _foo_get_ready (self); self->priv->init_results = g_list_append (self->priv->init_results, task); self->priv->state = INITIALIZING; break; case INITIALIZING: self->priv->init_results = g_list_append (self->priv->init_results, task); break; case INITIALIZED: if (!self->priv->success) g_task_return_new_error (task, ...); else g_task_return_boolean (task, TRUE); g_object_unref (task); break; } } static gboolean foo_init_finish (GAsyncInitable *initable, GAsyncResult *result, GError **error) { g_return_val_if_fail (g_task_is_valid (result, initable), FALSE); return g_task_propagate_boolean (G_TASK (result), error); } static void foo_async_initable_iface_init (gpointer g_iface, gpointer data) { GAsyncInitableIface *iface = g_iface; iface->init_async = foo_init_async; iface->init_finish = foo_init_finish; } ]| Helper function for constructing #GAsyncInitable object. This is similar to g_object_new() but also initializes the object asynchronously. When the initialization is finished, @callback will be called. You can then call g_async_initable_new_finish() to get the new object and check for any errors. a #GType supporting #GAsyncInitable. the [I/O priority][io-priority] of the operation optional #GCancellable object, %NULL to ignore. a #GAsyncReadyCallback to call when the initialization is finished the data to pass to callback function the name of the first property, or %NULL if no properties the value of the first property, followed by other property value pairs, and ended by %NULL. Helper function for constructing #GAsyncInitable object. This is similar to g_object_new_valist() but also initializes the object asynchronously. When the initialization is finished, @callback will be called. You can then call g_async_initable_new_finish() to get the new object and check for any errors. a #GType supporting #GAsyncInitable. the name of the first property, followed by the value, and other property value pairs, and ended by %NULL. The var args list generated from @first_property_name. the [I/O priority][io-priority] of the operation optional #GCancellable object, %NULL to ignore. a #GAsyncReadyCallback to call when the initialization is finished the data to pass to callback function Helper function for constructing #GAsyncInitable object. This is similar to g_object_newv() but also initializes the object asynchronously. When the initialization is finished, @callback will be called. You can then call g_async_initable_new_finish() to get the new object and check for any errors. Use g_object_new_with_properties() and g_async_initable_init_async() instead. See #GParameter for more information. a #GType supporting #GAsyncInitable. the number of parameters in @parameters the parameters to use to construct the object the [I/O priority][io-priority] of the operation optional #GCancellable object, %NULL to ignore. a #GAsyncReadyCallback to call when the initialization is finished the data to pass to callback function Starts asynchronous initialization of the object implementing the interface. This must be done before any real use of the object after initial construction. If the object also implements #GInitable you can optionally call g_initable_init() instead. This method is intended for language bindings. If writing in C, g_async_initable_new_async() should typically be used instead. When the initialization is finished, @callback will be called. You can then call g_async_initable_init_finish() to get the result of the initialization. Implementations may also support cancellation. If @cancellable is not %NULL, then initialization can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If @cancellable is not %NULL, and the object doesn't support cancellable initialization, the error %G_IO_ERROR_NOT_SUPPORTED will be returned. As with #GInitable, if the object is not initialized, or initialization returns with an error, then all operations on the object except g_object_ref() and g_object_unref() are considered to be invalid, and have undefined behaviour. They will often fail with g_critical() or g_warning(), but this must not be relied on. Callers should not assume that a class which implements #GAsyncInitable can be initialized multiple times; for more information, see g_initable_init(). If a class explicitly supports being initialized multiple times, implementation requires yielding all subsequent calls to init_async() on the results of the first call. For classes that also support the #GInitable interface, the default implementation of this method will run the g_initable_init() function in a thread, so if you want to support asynchronous initialization via threads, just implement the #GAsyncInitable interface without overriding any interface methods. a #GAsyncInitable. the [I/O priority][io-priority] of the operation optional #GCancellable object, %NULL to ignore. a #GAsyncReadyCallback to call when the request is satisfied the data to pass to callback function Finishes asynchronous initialization and returns the result. See g_async_initable_init_async(). %TRUE if successful. If an error has occurred, this function will return %FALSE and set @error appropriately if present. a #GAsyncInitable. a #GAsyncResult. Starts asynchronous initialization of the object implementing the interface. This must be done before any real use of the object after initial construction. If the object also implements #GInitable you can optionally call g_initable_init() instead. This method is intended for language bindings. If writing in C, g_async_initable_new_async() should typically be used instead. When the initialization is finished, @callback will be called. You can then call g_async_initable_init_finish() to get the result of the initialization. Implementations may also support cancellation. If @cancellable is not %NULL, then initialization can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If @cancellable is not %NULL, and the object doesn't support cancellable initialization, the error %G_IO_ERROR_NOT_SUPPORTED will be returned. As with #GInitable, if the object is not initialized, or initialization returns with an error, then all operations on the object except g_object_ref() and g_object_unref() are considered to be invalid, and have undefined behaviour. They will often fail with g_critical() or g_warning(), but this must not be relied on. Callers should not assume that a class which implements #GAsyncInitable can be initialized multiple times; for more information, see g_initable_init(). If a class explicitly supports being initialized multiple times, implementation requires yielding all subsequent calls to init_async() on the results of the first call. For classes that also support the #GInitable interface, the default implementation of this method will run the g_initable_init() function in a thread, so if you want to support asynchronous initialization via threads, just implement the #GAsyncInitable interface without overriding any interface methods. a #GAsyncInitable. the [I/O priority][io-priority] of the operation optional #GCancellable object, %NULL to ignore. a #GAsyncReadyCallback to call when the request is satisfied the data to pass to callback function Finishes asynchronous initialization and returns the result. See g_async_initable_init_async(). %TRUE if successful. If an error has occurred, this function will return %FALSE and set @error appropriately if present. a #GAsyncInitable. a #GAsyncResult. Finishes the async construction for the various g_async_initable_new calls, returning the created object or %NULL on error. a newly created #GObject, or %NULL on error. Free with g_object_unref(). the #GAsyncInitable from the callback the #GAsyncResult from the callback Provides an interface for asynchronous initializing object such that initialization may fail. The parent interface. a #GAsyncInitable. the [I/O priority][io-priority] of the operation optional #GCancellable object, %NULL to ignore. a #GAsyncReadyCallback to call when the request is satisfied the data to pass to callback function %TRUE if successful. If an error has occurred, this function will return %FALSE and set @error appropriately if present. a #GAsyncInitable. a #GAsyncResult. Type definition for a function that will be called back when an asynchronous operation within GIO has been completed. #GAsyncReadyCallback callbacks from #GTask are guaranteed to be invoked in a later iteration of the [thread-default main context][g-main-context-push-thread-default] where the #GTask was created. All other users of #GAsyncReadyCallback must likewise call it asynchronously in a later iteration of the main context. the object the asynchronous operation was started with. a #GAsyncResult. user data passed to the callback. Provides a base class for implementing asynchronous function results. Asynchronous operations are broken up into two separate operations which are chained together by a #GAsyncReadyCallback. To begin an asynchronous operation, provide a #GAsyncReadyCallback to the asynchronous function. This callback will be triggered when the operation has completed, and must be run in a later iteration of the [thread-default main context][g-main-context-push-thread-default] from where the operation was initiated. It will be passed a #GAsyncResult instance filled with the details of the operation's success or failure, the object the asynchronous function was started for and any error codes returned. The asynchronous callback function is then expected to call the corresponding "_finish()" function, passing the object the function was called for, the #GAsyncResult instance, and (optionally) an @error to grab any error conditions that may have occurred. The "_finish()" function for an operation takes the generic result (of type #GAsyncResult) and returns the specific result that the operation in question yields (e.g. a #GFileEnumerator for a "enumerate children" operation). If the result or error status of the operation is not needed, there is no need to call the "_finish()" function; GIO will take care of cleaning up the result and error information after the #GAsyncReadyCallback returns. You can pass %NULL for the #GAsyncReadyCallback if you don't need to take any action at all after the operation completes. Applications may also take a reference to the #GAsyncResult and call "_finish()" later; however, the "_finish()" function may be called at most once. Example of a typical asynchronous operation flow: |[<!-- language="C" --> void _theoretical_frobnitz_async (Theoretical *t, GCancellable *c, GAsyncReadyCallback cb, gpointer u); gboolean _theoretical_frobnitz_finish (Theoretical *t, GAsyncResult *res, GError **e); static void frobnitz_result_func (GObject *source_object, GAsyncResult *res, gpointer user_data) { gboolean success = FALSE; success = _theoretical_frobnitz_finish (source_object, res, NULL); if (success) g_printf ("Hurray!\n"); else g_printf ("Uh oh!\n"); ... } int main (int argc, void *argv[]) { ... _theoretical_frobnitz_async (theoretical_data, NULL, frobnitz_result_func, NULL); ... } ]| The callback for an asynchronous operation is called only once, and is always called, even in the case of a cancelled operation. On cancellation the result is a %G_IO_ERROR_CANCELLED error. ## I/O Priority # {#io-priority} Many I/O-related asynchronous operations have a priority parameter, which is used in certain cases to determine the order in which operations are executed. They are not used to determine system-wide I/O scheduling. Priorities are integers, with lower numbers indicating higher priority. It is recommended to choose priorities between %G_PRIORITY_LOW and %G_PRIORITY_HIGH, with %G_PRIORITY_DEFAULT as a default. Gets the source object from a #GAsyncResult. a new reference to the source object for the @res, or %NULL if there is none. a #GAsyncResult Gets the user data from a #GAsyncResult. the user data for @res. a #GAsyncResult. Checks if @res has the given @source_tag (generally a function pointer indicating the function @res was created by). %TRUE if @res has the indicated @source_tag, %FALSE if not. a #GAsyncResult an application-defined tag Gets the source object from a #GAsyncResult. a new reference to the source object for the @res, or %NULL if there is none. a #GAsyncResult Gets the user data from a #GAsyncResult. the user data for @res. a #GAsyncResult. Checks if @res has the given @source_tag (generally a function pointer indicating the function @res was created by). %TRUE if @res has the indicated @source_tag, %FALSE if not. a #GAsyncResult an application-defined tag If @res is a #GSimpleAsyncResult, this is equivalent to g_simple_async_result_propagate_error(). Otherwise it returns %FALSE. This can be used for legacy error handling in async *_finish() wrapper functions that traditionally handled #GSimpleAsyncResult error returns themselves rather than calling into the virtual method. This should not be used in new code; #GAsyncResult errors that are set by virtual methods should also be extracted by virtual methods, to enable subclasses to chain up correctly. %TRUE if @error is has been filled in with an error from @res, %FALSE if not. a #GAsyncResult Interface definition for #GAsyncResult. The parent interface. the user data for @res. a #GAsyncResult. a new reference to the source object for the @res, or %NULL if there is none. a #GAsyncResult %TRUE if @res has the indicated @source_tag, %FALSE if not. a #GAsyncResult an application-defined tag Buffered input stream implements #GFilterInputStream and provides for buffered reads. By default, #GBufferedInputStream's buffer size is set at 4 kilobytes. To create a buffered input stream, use g_buffered_input_stream_new(), or g_buffered_input_stream_new_sized() to specify the buffer's size at construction. To get the size of a buffer within a buffered input stream, use g_buffered_input_stream_get_buffer_size(). To change the size of a buffered input stream's buffer, use g_buffered_input_stream_set_buffer_size(). Note that the buffer's size cannot be reduced below the size of the data within the buffer. Creates a new #GInputStream from the given @base_stream, with a buffer set to the default size (4 kilobytes). a #GInputStream for the given @base_stream. a #GInputStream Creates a new #GBufferedInputStream from the given @base_stream, with a buffer set to @size. a #GInputStream. a #GInputStream a #gsize Tries to read @count bytes from the stream into the buffer. Will block during this read. If @count is zero, returns zero and does nothing. A value of @count larger than %G_MAXSSIZE will cause a %G_IO_ERROR_INVALID_ARGUMENT error. On success, the number of bytes read into the buffer is returned. It is not an error if this is not the same as the requested size, as it can happen e.g. near the end of a file. Zero is returned on end of file (or if @count is zero), but never otherwise. If @count is -1 then the attempted read size is equal to the number of bytes that are required to fill the buffer. If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an operation was partially finished when the operation was cancelled the partial result will be returned, without an error. On error -1 is returned and @error is set accordingly. For the asynchronous, non-blocking, version of this function, see g_buffered_input_stream_fill_async(). the number of bytes read into @stream's buffer, up to @count, or -1 on error. a #GBufferedInputStream the number of bytes that will be read from the stream optional #GCancellable object, %NULL to ignore Reads data into @stream's buffer asynchronously, up to @count size. @io_priority can be used to prioritize reads. For the synchronous version of this function, see g_buffered_input_stream_fill(). If @count is -1 then the attempted read size is equal to the number of bytes that are required to fill the buffer. a #GBufferedInputStream the number of bytes that will be read from the stream the [I/O priority][io-priority] of the request optional #GCancellable object a #GAsyncReadyCallback a #gpointer Finishes an asynchronous read. a #gssize of the read stream, or `-1` on an error. a #GBufferedInputStream a #GAsyncResult Tries to read @count bytes from the stream into the buffer. Will block during this read. If @count is zero, returns zero and does nothing. A value of @count larger than %G_MAXSSIZE will cause a %G_IO_ERROR_INVALID_ARGUMENT error. On success, the number of bytes read into the buffer is returned. It is not an error if this is not the same as the requested size, as it can happen e.g. near the end of a file. Zero is returned on end of file (or if @count is zero), but never otherwise. If @count is -1 then the attempted read size is equal to the number of bytes that are required to fill the buffer. If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an operation was partially finished when the operation was cancelled the partial result will be returned, without an error. On error -1 is returned and @error is set accordingly. For the asynchronous, non-blocking, version of this function, see g_buffered_input_stream_fill_async(). the number of bytes read into @stream's buffer, up to @count, or -1 on error. a #GBufferedInputStream the number of bytes that will be read from the stream optional #GCancellable object, %NULL to ignore Reads data into @stream's buffer asynchronously, up to @count size. @io_priority can be used to prioritize reads. For the synchronous version of this function, see g_buffered_input_stream_fill(). If @count is -1 then the attempted read size is equal to the number of bytes that are required to fill the buffer. a #GBufferedInputStream the number of bytes that will be read from the stream the [I/O priority][io-priority] of the request optional #GCancellable object a #GAsyncReadyCallback a #gpointer Finishes an asynchronous read. a #gssize of the read stream, or `-1` on an error. a #GBufferedInputStream a #GAsyncResult Gets the size of the available data within the stream. size of the available stream. #GBufferedInputStream Gets the size of the input buffer. the current buffer size. a #GBufferedInputStream Peeks in the buffer, copying data of size @count into @buffer, offset @offset bytes. a #gsize of the number of bytes peeked, or -1 on error. a #GBufferedInputStream a pointer to an allocated chunk of memory a #gsize a #gsize Returns the buffer with the currently available bytes. The returned buffer must not be modified and will become invalid when reading from the stream or filling the buffer. read-only buffer a #GBufferedInputStream a #gsize to get the number of bytes available in the buffer Tries to read a single byte from the stream or the buffer. Will block during this read. On success, the byte read from the stream is returned. On end of stream -1 is returned but it's not an exceptional error and @error is not set. If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an operation was partially finished when the operation was cancelled the partial result will be returned, without an error. On error -1 is returned and @error is set accordingly. the byte read from the @stream, or -1 on end of stream or error. a #GBufferedInputStream optional #GCancellable object, %NULL to ignore Sets the size of the internal buffer of @stream to @size, or to the size of the contents of the buffer. The buffer can never be resized smaller than its current contents. a #GBufferedInputStream a #gsize the number of bytes read into @stream's buffer, up to @count, or -1 on error. a #GBufferedInputStream the number of bytes that will be read from the stream optional #GCancellable object, %NULL to ignore a #GBufferedInputStream the number of bytes that will be read from the stream the [I/O priority][io-priority] of the request optional #GCancellable object a #GAsyncReadyCallback a #gpointer a #gssize of the read stream, or `-1` on an error. a #GBufferedInputStream a #GAsyncResult Buffered output stream implements #GFilterOutputStream and provides for buffered writes. By default, #GBufferedOutputStream's buffer size is set at 4 kilobytes. To create a buffered output stream, use g_buffered_output_stream_new(), or g_buffered_output_stream_new_sized() to specify the buffer's size at construction. To get the size of a buffer within a buffered input stream, use g_buffered_output_stream_get_buffer_size(). To change the size of a buffered output stream's buffer, use g_buffered_output_stream_set_buffer_size(). Note that the buffer's size cannot be reduced below the size of the data within the buffer. Creates a new buffered output stream for a base stream. a #GOutputStream for the given @base_stream. a #GOutputStream. Creates a new buffered output stream with a given buffer size. a #GOutputStream with an internal buffer set to @size. a #GOutputStream. a #gsize. Checks if the buffer automatically grows as data is added. %TRUE if the @stream's buffer automatically grows, %FALSE otherwise. a #GBufferedOutputStream. Gets the size of the buffer in the @stream. the current size of the buffer. a #GBufferedOutputStream. Sets whether or not the @stream's buffer should automatically grow. If @auto_grow is true, then each write will just make the buffer larger, and you must manually flush the buffer to actually write out the data to the underlying stream. a #GBufferedOutputStream. a #gboolean. Sets the size of the internal buffer to @size. a #GBufferedOutputStream. a #gsize. Invoked when a connection to a message bus has been obtained. The #GDBusConnection to a message bus. The name that is requested to be owned. User data passed to g_bus_own_name(). Invoked when the name is acquired. The #GDBusConnection on which to acquired the name. The name being owned. User data passed to g_bus_own_name() or g_bus_own_name_on_connection(). Invoked when the name being watched is known to have to have an owner. The #GDBusConnection the name is being watched on. The name being watched. Unique name of the owner of the name being watched. User data passed to g_bus_watch_name(). Invoked when the name is lost or @connection has been closed. The #GDBusConnection on which to acquire the name or %NULL if the connection was disconnected. The name being owned. User data passed to g_bus_own_name() or g_bus_own_name_on_connection(). Flags used in g_bus_own_name(). No flags set. Allow another message bus connection to claim the name. If another message bus connection owns the name and have specified #G_BUS_NAME_OWNER_FLAGS_ALLOW_REPLACEMENT, then take the name from the other connection. If another message bus connection owns the name, immediately return an error from g_bus_own_name() rather than entering the waiting queue for that name. (Since 2.54) Invoked when the name being watched is known not to have to have an owner. This is also invoked when the #GDBusConnection on which the watch was established has been closed. In that case, @connection will be %NULL. The #GDBusConnection the name is being watched on, or %NULL. The name being watched. User data passed to g_bus_watch_name(). Flags used in g_bus_watch_name(). No flags set. If no-one owns the name when beginning to watch the name, ask the bus to launch an owner for the name. An enumeration for well-known message buses. An alias for the message bus that activated the process, if any. Not a message bus. The system-wide message bus. The login session message bus. #GBytesIcon specifies an image held in memory in a common format (usually png) to be used as icon. Creates a new icon for a bytes. a #GIcon for the given @bytes, or %NULL on error. a #GBytes. Gets the #GBytes associated with the given @icon. a #GBytes, or %NULL. a #GIcon. The bytes containing the icon. GCancellable is a thread-safe operation cancellation stack used throughout GIO to allow for cancellation of synchronous and asynchronous operations. Creates a new #GCancellable object. Applications that want to start one or more operations that should be cancellable should create a #GCancellable and pass it to the operations. One #GCancellable can be used in multiple consecutive operations or in multiple concurrent operations. a #GCancellable. Gets the top cancellable from the stack. a #GCancellable from the top of the stack, or %NULL if the stack is empty. Will set @cancellable to cancelled, and will emit the #GCancellable::cancelled signal. (However, see the warning about race conditions in the documentation for that signal if you are planning to connect to it.) This function is thread-safe. In other words, you can safely call it from a thread other than the one running the operation that was passed the @cancellable. If @cancellable is %NULL, this function returns immediately for convenience. The convention within GIO is that cancelling an asynchronous operation causes it to complete asynchronously. That is, if you cancel the operation from the same thread in which it is running, then the operation's #GAsyncReadyCallback will not be invoked until the application returns to the main loop. a #GCancellable object. Convenience function to connect to the #GCancellable::cancelled signal. Also handles the race condition that may happen if the cancellable is cancelled right before connecting. @callback is called at most once, either directly at the time of the connect if @cancellable is already cancelled, or when @cancellable is cancelled in some thread. @data_destroy_func will be called when the handler is disconnected, or immediately if the cancellable is already cancelled. See #GCancellable::cancelled for details on how to use this. Since GLib 2.40, the lock protecting @cancellable is not held when @callback is invoked. This lifts a restriction in place for earlier GLib versions which now makes it easier to write cleanup code that unconditionally invokes e.g. g_cancellable_cancel(). The id of the signal handler or 0 if @cancellable has already been cancelled. A #GCancellable. The #GCallback to connect. Data to pass to @callback. Free function for @data or %NULL. Disconnects a handler from a cancellable instance similar to g_signal_handler_disconnect(). Additionally, in the event that a signal handler is currently running, this call will block until the handler has finished. Calling this function from a #GCancellable::cancelled signal handler will therefore result in a deadlock. This avoids a race condition where a thread cancels at the same time as the cancellable operation is finished and the signal handler is removed. See #GCancellable::cancelled for details on how to use this. If @cancellable is %NULL or @handler_id is `0` this function does nothing. A #GCancellable or %NULL. Handler id of the handler to be disconnected, or `0`. Gets the file descriptor for a cancellable job. This can be used to implement cancellable operations on Unix systems. The returned fd will turn readable when @cancellable is cancelled. You are not supposed to read from the fd yourself, just check for readable status. Reading to unset the readable status is done with g_cancellable_reset(). After a successful return from this function, you should use g_cancellable_release_fd() to free up resources allocated for the returned file descriptor. See also g_cancellable_make_pollfd(). A valid file descriptor. `-1` if the file descriptor is not supported, or on errors. a #GCancellable. Checks if a cancellable job has been cancelled. %TRUE if @cancellable is cancelled, FALSE if called with %NULL or if item is not cancelled. a #GCancellable or %NULL Creates a #GPollFD corresponding to @cancellable; this can be passed to g_poll() and used to poll for cancellation. This is useful both for unix systems without a native poll and for portability to windows. When this function returns %TRUE, you should use g_cancellable_release_fd() to free up resources allocated for the @pollfd. After a %FALSE return, do not call g_cancellable_release_fd(). If this function returns %FALSE, either no @cancellable was given or resource limits prevent this function from allocating the necessary structures for polling. (On Linux, you will likely have reached the maximum number of file descriptors.) The suggested way to handle these cases is to ignore the @cancellable. You are not supposed to read from the fd yourself, just check for readable status. Reading to unset the readable status is done with g_cancellable_reset(). %TRUE if @pollfd was successfully initialized, %FALSE on failure to prepare the cancellable. a #GCancellable or %NULL a pointer to a #GPollFD Pops @cancellable off the cancellable stack (verifying that @cancellable is on the top of the stack). a #GCancellable object Pushes @cancellable onto the cancellable stack. The current cancellable can then be received using g_cancellable_get_current(). This is useful when implementing cancellable operations in code that does not allow you to pass down the cancellable object. This is typically called automatically by e.g. #GFile operations, so you rarely have to call this yourself. a #GCancellable object Releases a resources previously allocated by g_cancellable_get_fd() or g_cancellable_make_pollfd(). For compatibility reasons with older releases, calling this function is not strictly required, the resources will be automatically freed when the @cancellable is finalized. However, the @cancellable will block scarce file descriptors until it is finalized if this function is not called. This can cause the application to run out of file descriptors when many #GCancellables are used at the same time. a #GCancellable Resets @cancellable to its uncancelled state. If cancellable is currently in use by any cancellable operation then the behavior of this function is undefined. Note that it is generally not a good idea to reuse an existing cancellable for more operations after it has been cancelled once, as this function might tempt you to do. The recommended practice is to drop the reference to a cancellable after cancelling it, and let it die with the outstanding async operations. You should create a fresh cancellable for further async operations. a #GCancellable object. If the @cancellable is cancelled, sets the error to notify that the operation was cancelled. %TRUE if @cancellable was cancelled, %FALSE if it was not a #GCancellable or %NULL Creates a source that triggers if @cancellable is cancelled and calls its callback of type #GCancellableSourceFunc. This is primarily useful for attaching to another (non-cancellable) source with g_source_add_child_source() to add cancellability to it. For convenience, you can call this with a %NULL #GCancellable, in which case the source will never trigger. The new #GSource will hold a reference to the #GCancellable. the new #GSource. a #GCancellable, or %NULL Emitted when the operation has been cancelled. Can be used by implementations of cancellable operations. If the operation is cancelled from another thread, the signal will be emitted in the thread that cancelled the operation, not the thread that is running the operation. Note that disconnecting from this signal (or any signal) in a multi-threaded program is prone to race conditions. For instance it is possible that a signal handler may be invoked even after a call to g_signal_handler_disconnect() for that handler has already returned. There is also a problem when cancellation happens right before connecting to the signal. If this happens the signal will unexpectedly not be emitted, and checking before connecting to the signal leaves a race condition where this is still happening. In order to make it safe and easy to connect handlers there are two helper functions: g_cancellable_connect() and g_cancellable_disconnect() which protect against problems like this. An example of how to us this: |[<!-- language="C" --> // Make sure we don't do unnecessary work if already cancelled if (g_cancellable_set_error_if_cancelled (cancellable, error)) return; // Set up all the data needed to be able to handle cancellation // of the operation my_data = my_data_new (...); id = 0; if (cancellable) id = g_cancellable_connect (cancellable, G_CALLBACK (cancelled_handler) data, NULL); // cancellable operation here... g_cancellable_disconnect (cancellable, id); // cancelled_handler is never called after this, it is now safe // to free the data my_data_free (my_data); ]| Note that the cancelled signal is emitted in the thread that the user cancelled from, which may be the main thread. So, the cancellable signal should not do something that can block. This is the function type of the callback used for the #GSource returned by g_cancellable_source_new(). it should return %FALSE if the source should be removed. the #GCancellable data passed in by the user. #GCharsetConverter is an implementation of #GConverter based on GIConv. Creates a new #GCharsetConverter. a new #GCharsetConverter or %NULL on error. destination charset source charset Gets the number of fallbacks that @converter has applied so far. the number of fallbacks that @converter has applied a #GCharsetConverter Gets the #GCharsetConverter:use-fallback property. %TRUE if fallbacks are used by @converter a #GCharsetConverter Sets the #GCharsetConverter:use-fallback property. a #GCharsetConverter %TRUE to use fallbacks #GConverter is implemented by objects that convert binary data in various ways. The conversion can be stateful and may fail at any place. Some example conversions are: character set conversion, compression, decompression and regular expression replace. This is the main operation used when converting data. It is to be called multiple times in a loop, and each time it will do some work, i.e. producing some output (in @outbuf) or consuming some input (from @inbuf) or both. If its not possible to do any work an error is returned. Note that a single call may not consume all input (or any input at all). Also a call may produce output even if given no input, due to state stored in the converter producing output. If any data was either produced or consumed, and then an error happens, then only the successful conversion is reported and the error is returned on the next call. A full conversion loop involves calling this method repeatedly, each time giving it new input and space output space. When there is no more input data after the data in @inbuf, the flag %G_CONVERTER_INPUT_AT_END must be set. The loop will be (unless some error happens) returning %G_CONVERTER_CONVERTED each time until all data is consumed and all output is produced, then %G_CONVERTER_FINISHED is returned instead. Note, that %G_CONVERTER_FINISHED may be returned even if %G_CONVERTER_INPUT_AT_END is not set, for instance in a decompression converter where the end of data is detectable from the data (and there might even be other data after the end of the compressed data). When some data has successfully been converted @bytes_read and is set to the number of bytes read from @inbuf, and @bytes_written is set to indicate how many bytes was written to @outbuf. If there are more data to output or consume (i.e. unless the %G_CONVERTER_INPUT_AT_END is specified) then %G_CONVERTER_CONVERTED is returned, and if no more data is to be output then %G_CONVERTER_FINISHED is returned. On error %G_CONVERTER_ERROR is returned and @error is set accordingly. Some errors need special handling: %G_IO_ERROR_NO_SPACE is returned if there is not enough space to write the resulting converted data, the application should call the function again with a larger @outbuf to continue. %G_IO_ERROR_PARTIAL_INPUT is returned if there is not enough input to fully determine what the conversion should produce, and the %G_CONVERTER_INPUT_AT_END flag is not set. This happens for example with an incomplete multibyte sequence when converting text, or when a regexp matches up to the end of the input (and may match further input). It may also happen when @inbuf_size is zero and there is no more data to produce. When this happens the application should read more input and then call the function again. If further input shows that there is no more data call the function again with the same data but with the %G_CONVERTER_INPUT_AT_END flag set. This may cause the conversion to finish as e.g. in the regexp match case (or, to fail again with %G_IO_ERROR_PARTIAL_INPUT in e.g. a charset conversion where the input is actually partial). After g_converter_convert() has returned %G_CONVERTER_FINISHED the converter object is in an invalid state where its not allowed to call g_converter_convert() anymore. At this time you can only free the object or call g_converter_reset() to reset it to the initial state. If the flag %G_CONVERTER_FLUSH is set then conversion is modified to try to write out all internal state to the output. The application has to call the function multiple times with the flag set, and when the available input has been consumed and all internal state has been produced then %G_CONVERTER_FLUSHED (or %G_CONVERTER_FINISHED if really at the end) is returned instead of %G_CONVERTER_CONVERTED. This is somewhat similar to what happens at the end of the input stream, but done in the middle of the data. This has different meanings for different conversions. For instance in a compression converter it would mean that we flush all the compression state into output such that if you uncompress the compressed data you get back all the input data. Doing this may make the final file larger due to padding though. Another example is a regexp conversion, where if you at the end of the flushed data have a match, but there is also a potential longer match. In the non-flushed case we would ask for more input, but when flushing we treat this as the end of input and do the match. Flushing is not always possible (like if a charset converter flushes at a partial multibyte sequence). Converters are supposed to try to produce as much output as possible and then return an error (typically %G_IO_ERROR_PARTIAL_INPUT). a #GConverterResult, %G_CONVERTER_ERROR on error. a #GConverter. the buffer containing the data to convert. the number of bytes in @inbuf a buffer to write converted data in. the number of bytes in @outbuf, must be at least one a #GConverterFlags controlling the conversion details will be set to the number of bytes read from @inbuf on success will be set to the number of bytes written to @outbuf on success Resets all internal state in the converter, making it behave as if it was just created. If the converter has any internal state that would produce output then that output is lost. a #GConverter. This is the main operation used when converting data. It is to be called multiple times in a loop, and each time it will do some work, i.e. producing some output (in @outbuf) or consuming some input (from @inbuf) or both. If its not possible to do any work an error is returned. Note that a single call may not consume all input (or any input at all). Also a call may produce output even if given no input, due to state stored in the converter producing output. If any data was either produced or consumed, and then an error happens, then only the successful conversion is reported and the error is returned on the next call. A full conversion loop involves calling this method repeatedly, each time giving it new input and space output space. When there is no more input data after the data in @inbuf, the flag %G_CONVERTER_INPUT_AT_END must be set. The loop will be (unless some error happens) returning %G_CONVERTER_CONVERTED each time until all data is consumed and all output is produced, then %G_CONVERTER_FINISHED is returned instead. Note, that %G_CONVERTER_FINISHED may be returned even if %G_CONVERTER_INPUT_AT_END is not set, for instance in a decompression converter where the end of data is detectable from the data (and there might even be other data after the end of the compressed data). When some data has successfully been converted @bytes_read and is set to the number of bytes read from @inbuf, and @bytes_written is set to indicate how many bytes was written to @outbuf. If there are more data to output or consume (i.e. unless the %G_CONVERTER_INPUT_AT_END is specified) then %G_CONVERTER_CONVERTED is returned, and if no more data is to be output then %G_CONVERTER_FINISHED is returned. On error %G_CONVERTER_ERROR is returned and @error is set accordingly. Some errors need special handling: %G_IO_ERROR_NO_SPACE is returned if there is not enough space to write the resulting converted data, the application should call the function again with a larger @outbuf to continue. %G_IO_ERROR_PARTIAL_INPUT is returned if there is not enough input to fully determine what the conversion should produce, and the %G_CONVERTER_INPUT_AT_END flag is not set. This happens for example with an incomplete multibyte sequence when converting text, or when a regexp matches up to the end of the input (and may match further input). It may also happen when @inbuf_size is zero and there is no more data to produce. When this happens the application should read more input and then call the function again. If further input shows that there is no more data call the function again with the same data but with the %G_CONVERTER_INPUT_AT_END flag set. This may cause the conversion to finish as e.g. in the regexp match case (or, to fail again with %G_IO_ERROR_PARTIAL_INPUT in e.g. a charset conversion where the input is actually partial). After g_converter_convert() has returned %G_CONVERTER_FINISHED the converter object is in an invalid state where its not allowed to call g_converter_convert() anymore. At this time you can only free the object or call g_converter_reset() to reset it to the initial state. If the flag %G_CONVERTER_FLUSH is set then conversion is modified to try to write out all internal state to the output. The application has to call the function multiple times with the flag set, and when the available input has been consumed and all internal state has been produced then %G_CONVERTER_FLUSHED (or %G_CONVERTER_FINISHED if really at the end) is returned instead of %G_CONVERTER_CONVERTED. This is somewhat similar to what happens at the end of the input stream, but done in the middle of the data. This has different meanings for different conversions. For instance in a compression converter it would mean that we flush all the compression state into output such that if you uncompress the compressed data you get back all the input data. Doing this may make the final file larger due to padding though. Another example is a regexp conversion, where if you at the end of the flushed data have a match, but there is also a potential longer match. In the non-flushed case we would ask for more input, but when flushing we treat this as the end of input and do the match. Flushing is not always possible (like if a charset converter flushes at a partial multibyte sequence). Converters are supposed to try to produce as much output as possible and then return an error (typically %G_IO_ERROR_PARTIAL_INPUT). a #GConverterResult, %G_CONVERTER_ERROR on error. a #GConverter. the buffer containing the data to convert. the number of bytes in @inbuf a buffer to write converted data in. the number of bytes in @outbuf, must be at least one a #GConverterFlags controlling the conversion details will be set to the number of bytes read from @inbuf on success will be set to the number of bytes written to @outbuf on success Resets all internal state in the converter, making it behave as if it was just created. If the converter has any internal state that would produce output then that output is lost. a #GConverter. Flags used when calling a g_converter_convert(). No flags. At end of input data Flush data Provides an interface for converting data from one type to another type. The conversion can be stateful and may fail at any place. The parent interface. a #GConverterResult, %G_CONVERTER_ERROR on error. a #GConverter. the buffer containing the data to convert. the number of bytes in @inbuf a buffer to write converted data in. the number of bytes in @outbuf, must be at least one a #GConverterFlags controlling the conversion details will be set to the number of bytes read from @inbuf on success will be set to the number of bytes written to @outbuf on success a #GConverter. Converter input stream implements #GInputStream and allows conversion of data of various types during reading. As of GLib 2.34, #GConverterInputStream implements #GPollableInputStream. Creates a new converter input stream for the @base_stream. a new #GInputStream. a #GInputStream a #GConverter Gets the #GConverter that is used by @converter_stream. the converter of the converter input stream a #GConverterInputStream Converter output stream implements #GOutputStream and allows conversion of data of various types during reading. As of GLib 2.34, #GConverterOutputStream implements #GPollableOutputStream. Creates a new converter output stream for the @base_stream. a new #GOutputStream. a #GOutputStream a #GConverter Gets the #GConverter that is used by @converter_stream. the converter of the converter output stream a #GConverterOutputStream Results returned from g_converter_convert(). There was an error during conversion. Some data was consumed or produced The conversion is finished Flushing is finished The #GCredentials type is a reference-counted wrapper for native credentials. This information is typically used for identifying, authenticating and authorizing other processes. Some operating systems supports looking up the credentials of the remote peer of a communication endpoint - see e.g. g_socket_get_credentials(). Some operating systems supports securely sending and receiving credentials over a Unix Domain Socket, see #GUnixCredentialsMessage, g_unix_connection_send_credentials() and g_unix_connection_receive_credentials() for details. On Linux, the native credential type is a `struct ucred` - see the unix(7) man page for details. This corresponds to %G_CREDENTIALS_TYPE_LINUX_UCRED. On Apple operating systems (including iOS, tvOS, and macOS), the native credential type is a `struct xucred`. This corresponds to %G_CREDENTIALS_TYPE_APPLE_XUCRED. On FreeBSD, Debian GNU/kFreeBSD, and GNU/Hurd, the native credential type is a `struct cmsgcred`. This corresponds to %G_CREDENTIALS_TYPE_FREEBSD_CMSGCRED. On NetBSD, the native credential type is a `struct unpcbid`. This corresponds to %G_CREDENTIALS_TYPE_NETBSD_UNPCBID. On OpenBSD, the native credential type is a `struct sockpeercred`. This corresponds to %G_CREDENTIALS_TYPE_OPENBSD_SOCKPEERCRED. On Solaris (including OpenSolaris and its derivatives), the native credential type is a `ucred_t`. This corresponds to %G_CREDENTIALS_TYPE_SOLARIS_UCRED. Creates a new #GCredentials object with credentials matching the the current process. A #GCredentials. Free with g_object_unref(). Gets a pointer to native credentials of type @native_type from @credentials. It is a programming error (which will cause a warning to be logged) to use this method if there is no #GCredentials support for the OS or if @native_type isn't supported by the OS. The pointer to native credentials or %NULL if the operation there is no #GCredentials support for the OS or if @native_type isn't supported by the OS. Do not free the returned data, it is owned by @credentials. A #GCredentials. The type of native credentials to get. Tries to get the UNIX process identifier from @credentials. This method is only available on UNIX platforms. This operation can fail if #GCredentials is not supported on the OS or if the native credentials type does not contain information about the UNIX process ID (for example this is the case for %G_CREDENTIALS_TYPE_APPLE_XUCRED). The UNIX process ID, or -1 if @error is set. A #GCredentials Tries to get the UNIX user identifier from @credentials. This method is only available on UNIX platforms. This operation can fail if #GCredentials is not supported on the OS or if the native credentials type does not contain information about the UNIX user. The UNIX user identifier or -1 if @error is set. A #GCredentials Checks if @credentials and @other_credentials is the same user. This operation can fail if #GCredentials is not supported on the the OS. %TRUE if @credentials and @other_credentials has the same user, %FALSE otherwise or if @error is set. A #GCredentials. A #GCredentials. Copies the native credentials of type @native_type from @native into @credentials. It is a programming error (which will cause a warning to be logged) to use this method if there is no #GCredentials support for the OS or if @native_type isn't supported by the OS. A #GCredentials. The type of native credentials to set. A pointer to native credentials. Tries to set the UNIX user identifier on @credentials. This method is only available on UNIX platforms. This operation can fail if #GCredentials is not supported on the OS or if the native credentials type does not contain information about the UNIX user. It can also fail if the OS does not allow the use of "spoofed" credentials. %TRUE if @uid was set, %FALSE if error is set. A #GCredentials. The UNIX user identifier to set. Creates a human-readable textual representation of @credentials that can be used in logging and debug messages. The format of the returned string may change in future GLib release. A string that should be freed with g_free(). A #GCredentials object. Class structure for #GCredentials. Enumeration describing different kinds of native credential types. Indicates an invalid native credential type. The native credentials type is a `struct ucred`. The native credentials type is a `struct cmsgcred`. The native credentials type is a `struct sockpeercred`. Added in 2.30. The native credentials type is a `ucred_t`. Added in 2.40. The native credentials type is a `struct unpcbid`. Added in 2.42. The native credentials type is a `struct xucred`. Added in 2.66. #GDBusActionGroup is an implementation of the #GActionGroup interface that can be used as a proxy for an action group that is exported over D-Bus with g_dbus_connection_export_action_group(). Obtains a #GDBusActionGroup for the action group which is exported at the given @bus_name and @object_path. The thread default main context is taken at the time of this call. All signals on the menu model (and any linked models) are reported with respect to this context. All calls on the returned menu model (and linked models) must also originate from this same context, with the thread default main context unchanged. This call is non-blocking. The returned action group may or may not already be filled in. The correct thing to do is connect the signals for the action group to monitor for changes and then to call g_action_group_list_actions() to get the initial list. a #GDBusActionGroup A #GDBusConnection the bus name which exports the action group or %NULL if @connection is not a message bus connection the object path at which the action group is exported Information about an annotation. The reference count or -1 if statically allocated. The name of the annotation, e.g. "org.freedesktop.DBus.Deprecated". The value of the annotation. A pointer to a %NULL-terminated array of pointers to #GDBusAnnotationInfo structures or %NULL if there are no annotations. If @info is statically allocated does nothing. Otherwise increases the reference count. The same @info. A #GDBusNodeInfo If @info is statically allocated, does nothing. Otherwise decreases the reference count of @info. When its reference count drops to 0, the memory used is freed. A #GDBusAnnotationInfo. Looks up the value of an annotation. The cost of this function is O(n) in number of annotations. The value or %NULL if not found. Do not free, it is owned by @annotations. A %NULL-terminated array of annotations or %NULL. The name of the annotation to look up. Information about an argument for a method or a signal. The reference count or -1 if statically allocated. Name of the argument, e.g. @unix_user_id. D-Bus signature of the argument (a single complete type). A pointer to a %NULL-terminated array of pointers to #GDBusAnnotationInfo structures or %NULL if there are no annotations. If @info is statically allocated does nothing. Otherwise increases the reference count. The same @info. A #GDBusArgInfo If @info is statically allocated, does nothing. Otherwise decreases the reference count of @info. When its reference count drops to 0, the memory used is freed. A #GDBusArgInfo. The #GDBusAuthObserver type provides a mechanism for participating in how a #GDBusServer (or a #GDBusConnection) authenticates remote peers. Simply instantiate a #GDBusAuthObserver and connect to the signals you are interested in. Note that new signals may be added in the future ## Controlling Authentication Mechanisms By default, a #GDBusServer or server-side #GDBusConnection will allow any authentication mechanism to be used. If you only want to allow D-Bus connections with the `EXTERNAL` mechanism, which makes use of credentials passing and is the recommended mechanism for modern Unix platforms such as Linux and the BSD family, you would use a signal handler like this: |[<!-- language="C" --> static gboolean on_allow_mechanism (GDBusAuthObserver *observer, const gchar *mechanism, gpointer user_data) { if (g_strcmp0 (mechanism, "EXTERNAL") == 0) { return TRUE; } return FALSE; } ]| ## Controlling Authorization # {#auth-observer} By default, a #GDBusServer or server-side #GDBusConnection will accept connections from any successfully authenticated user (but not from anonymous connections using the `ANONYMOUS` mechanism). If you only want to allow D-Bus connections from processes owned by the same uid as the server, you would use a signal handler like the following: |[<!-- language="C" --> static gboolean on_authorize_authenticated_peer (GDBusAuthObserver *observer, GIOStream *stream, GCredentials *credentials, gpointer user_data) { gboolean authorized; authorized = FALSE; if (credentials != NULL) { GCredentials *own_credentials; own_credentials = g_credentials_new (); if (g_credentials_is_same_user (credentials, own_credentials, NULL)) authorized = TRUE; g_object_unref (own_credentials); } return authorized; } ]| Creates a new #GDBusAuthObserver object. A #GDBusAuthObserver. Free with g_object_unref(). Emits the #GDBusAuthObserver::allow-mechanism signal on @observer. %TRUE if @mechanism can be used to authenticate the other peer, %FALSE if not. A #GDBusAuthObserver. The name of the mechanism, e.g. `DBUS_COOKIE_SHA1`. Emits the #GDBusAuthObserver::authorize-authenticated-peer signal on @observer. %TRUE if the peer is authorized, %FALSE if not. A #GDBusAuthObserver. A #GIOStream for the #GDBusConnection. Credentials received from the peer or %NULL. Emitted to check if @mechanism is allowed to be used. %TRUE if @mechanism can be used to authenticate the other peer, %FALSE if not. The name of the mechanism, e.g. `DBUS_COOKIE_SHA1`. Emitted to check if a peer that is successfully authenticated is authorized. %TRUE if the peer is authorized, %FALSE if not. A #GIOStream for the #GDBusConnection. Credentials received from the peer or %NULL. Flags used in g_dbus_connection_call() and similar APIs. No flags set. The bus must not launch an owner for the destination name in response to this method invocation. the caller is prepared to wait for interactive authorization. Since 2.46. Capabilities negotiated with the remote peer. No flags set. The connection supports exchanging UNIX file descriptors with the remote peer. The #GDBusConnection type is used for D-Bus connections to remote peers such as a message buses. It is a low-level API that offers a lot of flexibility. For instance, it lets you establish a connection over any transport that can by represented as a #GIOStream. This class is rarely used directly in D-Bus clients. If you are writing a D-Bus client, it is often easier to use the g_bus_own_name(), g_bus_watch_name() or g_dbus_proxy_new_for_bus() APIs. As an exception to the usual GLib rule that a particular object must not be used by two threads at the same time, #GDBusConnection's methods may be called from any thread. This is so that g_bus_get() and g_bus_get_sync() can safely return the same #GDBusConnection when called from any thread. Most of the ways to obtain a #GDBusConnection automatically initialize it (i.e. connect to D-Bus): for instance, g_dbus_connection_new() and g_bus_get(), and the synchronous versions of those methods, give you an initialized connection. Language bindings for GIO should use g_initable_new() or g_async_initable_new_async(), which also initialize the connection. If you construct an uninitialized #GDBusConnection, such as via g_object_new(), you must initialize it via g_initable_init() or g_async_initable_init_async() before using its methods or properties. Calling methods or accessing properties on a #GDBusConnection that has not completed initialization successfully is considered to be invalid, and leads to undefined behaviour. In particular, if initialization fails with a #GError, the only valid thing you can do with that #GDBusConnection is to free it with g_object_unref(). ## An example D-Bus server # {#gdbus-server} Here is an example for a D-Bus server: [gdbus-example-server.c](https://git.gnome.org/browse/glib/tree/gio/tests/gdbus-example-server.c) ## An example for exporting a subtree # {#gdbus-subtree-server} Here is an example for exporting a subtree: [gdbus-example-subtree.c](https://git.gnome.org/browse/glib/tree/gio/tests/gdbus-example-subtree.c) ## An example for file descriptor passing # {#gdbus-unix-fd-client} Here is an example for passing UNIX file descriptors: [gdbus-unix-fd-client.c](https://git.gnome.org/browse/glib/tree/gio/tests/gdbus-example-unix-fd-client.c) ## An example for exporting a GObject # {#gdbus-export} Here is an example for exporting a #GObject: [gdbus-example-export.c](https://git.gnome.org/browse/glib/tree/gio/tests/gdbus-example-export.c) Finishes an operation started with g_dbus_connection_new(). a #GDBusConnection or %NULL if @error is set. Free with g_object_unref(). a #GAsyncResult obtained from the #GAsyncReadyCallback passed to g_dbus_connection_new(). Finishes an operation started with g_dbus_connection_new_for_address(). a #GDBusConnection or %NULL if @error is set. Free with g_object_unref(). a #GAsyncResult obtained from the #GAsyncReadyCallback passed to g_dbus_connection_new() Synchronously connects and sets up a D-Bus client connection for exchanging D-Bus messages with an endpoint specified by @address which must be in the [D-Bus address format](https://dbus.freedesktop.org/doc/dbus-specification.html#addresses). This constructor can only be used to initiate client-side connections - use g_dbus_connection_new_sync() if you need to act as the server. In particular, @flags cannot contain the %G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_SERVER or %G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_ALLOW_ANONYMOUS flags. This is a synchronous failable constructor. See g_dbus_connection_new_for_address() for the asynchronous version. If @observer is not %NULL it may be used to control the authentication process. a #GDBusConnection or %NULL if @error is set. Free with g_object_unref(). a D-Bus address flags describing how to make the connection a #GDBusAuthObserver or %NULL a #GCancellable or %NULL Synchronously sets up a D-Bus connection for exchanging D-Bus messages with the end represented by @stream. If @stream is a #GSocketConnection, then the corresponding #GSocket will be put into non-blocking mode. The D-Bus connection will interact with @stream from a worker thread. As a result, the caller should not interact with @stream after this method has been called, except by calling g_object_unref() on it. If @observer is not %NULL it may be used to control the authentication process. This is a synchronous failable constructor. See g_dbus_connection_new() for the asynchronous version. a #GDBusConnection or %NULL if @error is set. Free with g_object_unref(). a #GIOStream the GUID to use if authenticating as a server or %NULL flags describing how to make the connection a #GDBusAuthObserver or %NULL a #GCancellable or %NULL Asynchronously sets up a D-Bus connection for exchanging D-Bus messages with the end represented by @stream. If @stream is a #GSocketConnection, then the corresponding #GSocket will be put into non-blocking mode. The D-Bus connection will interact with @stream from a worker thread. As a result, the caller should not interact with @stream after this method has been called, except by calling g_object_unref() on it. If @observer is not %NULL it may be used to control the authentication process. When the operation is finished, @callback will be invoked. You can then call g_dbus_connection_new_finish() to get the result of the operation. This is an asynchronous failable constructor. See g_dbus_connection_new_sync() for the synchronous version. a #GIOStream the GUID to use if authenticating as a server or %NULL flags describing how to make the connection a #GDBusAuthObserver or %NULL a #GCancellable or %NULL a #GAsyncReadyCallback to call when the request is satisfied the data to pass to @callback Asynchronously connects and sets up a D-Bus client connection for exchanging D-Bus messages with an endpoint specified by @address which must be in the [D-Bus address format](https://dbus.freedesktop.org/doc/dbus-specification.html#addresses). This constructor can only be used to initiate client-side connections - use g_dbus_connection_new() if you need to act as the server. In particular, @flags cannot contain the %G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_SERVER or %G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_ALLOW_ANONYMOUS flags. When the operation is finished, @callback will be invoked. You can then call g_dbus_connection_new_for_address_finish() to get the result of the operation. If @observer is not %NULL it may be used to control the authentication process. This is an asynchronous failable constructor. See g_dbus_connection_new_for_address_sync() for the synchronous version. a D-Bus address flags describing how to make the connection a #GDBusAuthObserver or %NULL a #GCancellable or %NULL a #GAsyncReadyCallback to call when the request is satisfied the data to pass to @callback Adds a message filter. Filters are handlers that are run on all incoming and outgoing messages, prior to standard dispatch. Filters are run in the order that they were added. The same handler can be added as a filter more than once, in which case it will be run more than once. Filters added during a filter callback won't be run on the message being processed. Filter functions are allowed to modify and even drop messages. Note that filters are run in a dedicated message handling thread so they can't block and, generally, can't do anything but signal a worker thread. Also note that filters are rarely needed - use API such as g_dbus_connection_send_message_with_reply(), g_dbus_connection_signal_subscribe() or g_dbus_connection_call() instead. If a filter consumes an incoming message the message is not dispatched anywhere else - not even the standard dispatch machinery (that API such as g_dbus_connection_signal_subscribe() and g_dbus_connection_send_message_with_reply() relies on) will see the message. Similarly, if a filter consumes an outgoing message, the message will not be sent to the other peer. If @user_data_free_func is non-%NULL, it will be called (in the thread-default main context of the thread you are calling this method from) at some point after @user_data is no longer needed. (It is not guaranteed to be called synchronously when the filter is removed, and may be called after @connection has been destroyed.) a filter identifier that can be used with g_dbus_connection_remove_filter() a #GDBusConnection a filter function user data to pass to @filter_function function to free @user_data with when filter is removed or %NULL Asynchronously invokes the @method_name method on the @interface_name D-Bus interface on the remote object at @object_path owned by @bus_name. If @connection is closed then the operation will fail with %G_IO_ERROR_CLOSED. If @cancellable is canceled, the operation will fail with %G_IO_ERROR_CANCELLED. If @parameters contains a value not compatible with the D-Bus protocol, the operation fails with %G_IO_ERROR_INVALID_ARGUMENT. If @reply_type is non-%NULL then the reply will be checked for having this type and an error will be raised if it does not match. Said another way, if you give a @reply_type then any non-%NULL return value will be of this type. Unless it’s %G_VARIANT_TYPE_UNIT, the @reply_type will be a tuple containing one or more values. If the @parameters #GVariant is floating, it is consumed. This allows convenient 'inline' use of g_variant_new(), e.g.: |[<!-- language="C" --> g_dbus_connection_call (connection, "org.freedesktop.StringThings", "/org/freedesktop/StringThings", "org.freedesktop.StringThings", "TwoStrings", g_variant_new ("(ss)", "Thing One", "Thing Two"), NULL, G_DBUS_CALL_FLAGS_NONE, -1, NULL, (GAsyncReadyCallback) two_strings_done, NULL); ]| This is an asynchronous method. When the operation is finished, @callback will be invoked in the [thread-default main context][g-main-context-push-thread-default] of the thread you are calling this method from. You can then call g_dbus_connection_call_finish() to get the result of the operation. See g_dbus_connection_call_sync() for the synchronous version of this function. If @callback is %NULL then the D-Bus method call message will be sent with the %G_DBUS_MESSAGE_FLAGS_NO_REPLY_EXPECTED flag set. a #GDBusConnection a unique or well-known bus name or %NULL if @connection is not a message bus connection path of remote object D-Bus interface to invoke method on the name of the method to invoke a #GVariant tuple with parameters for the method or %NULL if not passing parameters the expected type of the reply (which will be a tuple), or %NULL flags from the #GDBusCallFlags enumeration the timeout in milliseconds, -1 to use the default timeout or %G_MAXINT for no timeout a #GCancellable or %NULL a #GAsyncReadyCallback to call when the request is satisfied or %NULL if you don't care about the result of the method invocation the data to pass to @callback Finishes an operation started with g_dbus_connection_call(). %NULL if @error is set. Otherwise a #GVariant tuple with return values. Free with g_variant_unref(). a #GDBusConnection a #GAsyncResult obtained from the #GAsyncReadyCallback passed to g_dbus_connection_call() Synchronously invokes the @method_name method on the @interface_name D-Bus interface on the remote object at @object_path owned by @bus_name. If @connection is closed then the operation will fail with %G_IO_ERROR_CLOSED. If @cancellable is canceled, the operation will fail with %G_IO_ERROR_CANCELLED. If @parameters contains a value not compatible with the D-Bus protocol, the operation fails with %G_IO_ERROR_INVALID_ARGUMENT. If @reply_type is non-%NULL then the reply will be checked for having this type and an error will be raised if it does not match. Said another way, if you give a @reply_type then any non-%NULL return value will be of this type. If the @parameters #GVariant is floating, it is consumed. This allows convenient 'inline' use of g_variant_new(), e.g.: |[<!-- language="C" --> g_dbus_connection_call_sync (connection, "org.freedesktop.StringThings", "/org/freedesktop/StringThings", "org.freedesktop.StringThings", "TwoStrings", g_variant_new ("(ss)", "Thing One", "Thing Two"), NULL, G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error); ]| The calling thread is blocked until a reply is received. See g_dbus_connection_call() for the asynchronous version of this method. %NULL if @error is set. Otherwise a #GVariant tuple with return values. Free with g_variant_unref(). a #GDBusConnection a unique or well-known bus name or %NULL if @connection is not a message bus connection path of remote object D-Bus interface to invoke method on the name of the method to invoke a #GVariant tuple with parameters for the method or %NULL if not passing parameters the expected type of the reply, or %NULL flags from the #GDBusCallFlags enumeration the timeout in milliseconds, -1 to use the default timeout or %G_MAXINT for no timeout a #GCancellable or %NULL Like g_dbus_connection_call() but also takes a #GUnixFDList object. This method is only available on UNIX. a #GDBusConnection a unique or well-known bus name or %NULL if @connection is not a message bus connection path of remote object D-Bus interface to invoke method on the name of the method to invoke a #GVariant tuple with parameters for the method or %NULL if not passing parameters the expected type of the reply, or %NULL flags from the #GDBusCallFlags enumeration the timeout in milliseconds, -1 to use the default timeout or %G_MAXINT for no timeout a #GUnixFDList or %NULL a #GCancellable or %NULL a #GAsyncReadyCallback to call when the request is satisfied or %NULL if you don't * care about the result of the method invocation The data to pass to @callback. Finishes an operation started with g_dbus_connection_call_with_unix_fd_list(). %NULL if @error is set. Otherwise a #GVariant tuple with return values. Free with g_variant_unref(). a #GDBusConnection return location for a #GUnixFDList or %NULL a #GAsyncResult obtained from the #GAsyncReadyCallback passed to g_dbus_connection_call_with_unix_fd_list() Like g_dbus_connection_call_sync() but also takes and returns #GUnixFDList objects. This method is only available on UNIX. %NULL if @error is set. Otherwise a #GVariant tuple with return values. Free with g_variant_unref(). a #GDBusConnection a unique or well-known bus name or %NULL if @connection is not a message bus connection path of remote object D-Bus interface to invoke method on the name of the method to invoke a #GVariant tuple with parameters for the method or %NULL if not passing parameters the expected type of the reply, or %NULL flags from the #GDBusCallFlags enumeration the timeout in milliseconds, -1 to use the default timeout or %G_MAXINT for no timeout a #GUnixFDList or %NULL return location for a #GUnixFDList or %NULL a #GCancellable or %NULL Closes @connection. Note that this never causes the process to exit (this might only happen if the other end of a shared message bus connection disconnects, see #GDBusConnection:exit-on-close). Once the connection is closed, operations such as sending a message will return with the error %G_IO_ERROR_CLOSED. Closing a connection will not automatically flush the connection so queued messages may be lost. Use g_dbus_connection_flush() if you need such guarantees. If @connection is already closed, this method fails with %G_IO_ERROR_CLOSED. When @connection has been closed, the #GDBusConnection::closed signal is emitted in the [thread-default main context][g-main-context-push-thread-default] of the thread that @connection was constructed in. This is an asynchronous method. When the operation is finished, @callback will be invoked in the [thread-default main context][g-main-context-push-thread-default] of the thread you are calling this method from. You can then call g_dbus_connection_close_finish() to get the result of the operation. See g_dbus_connection_close_sync() for the synchronous version. a #GDBusConnection a #GCancellable or %NULL a #GAsyncReadyCallback to call when the request is satisfied or %NULL if you don't care about the result The data to pass to @callback Finishes an operation started with g_dbus_connection_close(). %TRUE if the operation succeeded, %FALSE if @error is set a #GDBusConnection a #GAsyncResult obtained from the #GAsyncReadyCallback passed to g_dbus_connection_close() Synchronously closes @connection. The calling thread is blocked until this is done. See g_dbus_connection_close() for the asynchronous version of this method and more details about what it does. %TRUE if the operation succeeded, %FALSE if @error is set a #GDBusConnection a #GCancellable or %NULL Emits a signal. If the parameters GVariant is floating, it is consumed. This can only fail if @parameters is not compatible with the D-Bus protocol (%G_IO_ERROR_INVALID_ARGUMENT), or if @connection has been closed (%G_IO_ERROR_CLOSED). %TRUE unless @error is set a #GDBusConnection the unique bus name for the destination for the signal or %NULL to emit to all listeners path of remote object D-Bus interface to emit a signal on the name of the signal to emit a #GVariant tuple with parameters for the signal or %NULL if not passing parameters Exports @action_group on @connection at @object_path. The implemented D-Bus API should be considered private. It is subject to change in the future. A given object path can only have one action group exported on it. If this constraint is violated, the export will fail and 0 will be returned (with @error set accordingly). You can unexport the action group using g_dbus_connection_unexport_action_group() with the return value of this function. The thread default main context is taken at the time of this call. All incoming action activations and state change requests are reported from this context. Any changes on the action group that cause it to emit signals must also come from this same context. Since incoming action activations and state change requests are rather likely to cause changes on the action group, this effectively limits a given action group to being exported from only one main context. the ID of the export (never zero), or 0 in case of failure a #GDBusConnection a D-Bus object path a #GActionGroup Exports @menu on @connection at @object_path. The implemented D-Bus API should be considered private. It is subject to change in the future. An object path can only have one menu model exported on it. If this constraint is violated, the export will fail and 0 will be returned (with @error set accordingly). You can unexport the menu model using g_dbus_connection_unexport_menu_model() with the return value of this function. the ID of the export (never zero), or 0 in case of failure a #GDBusConnection a D-Bus object path a #GMenuModel Asynchronously flushes @connection, that is, writes all queued outgoing message to the transport and then flushes the transport (using g_output_stream_flush_async()). This is useful in programs that wants to emit a D-Bus signal and then exit immediately. Without flushing the connection, there is no guaranteed that the message has been sent to the networking buffers in the OS kernel. This is an asynchronous method. When the operation is finished, @callback will be invoked in the [thread-default main context][g-main-context-push-thread-default] of the thread you are calling this method from. You can then call g_dbus_connection_flush_finish() to get the result of the operation. See g_dbus_connection_flush_sync() for the synchronous version. a #GDBusConnection a #GCancellable or %NULL a #GAsyncReadyCallback to call when the request is satisfied or %NULL if you don't care about the result The data to pass to @callback Finishes an operation started with g_dbus_connection_flush(). %TRUE if the operation succeeded, %FALSE if @error is set a #GDBusConnection a #GAsyncResult obtained from the #GAsyncReadyCallback passed to g_dbus_connection_flush() Synchronously flushes @connection. The calling thread is blocked until this is done. See g_dbus_connection_flush() for the asynchronous version of this method and more details about what it does. %TRUE if the operation succeeded, %FALSE if @error is set a #GDBusConnection a #GCancellable or %NULL Gets the capabilities negotiated with the remote peer zero or more flags from the #GDBusCapabilityFlags enumeration a #GDBusConnection Gets whether the process is terminated when @connection is closed by the remote peer. See #GDBusConnection:exit-on-close for more details. whether the process is terminated when @connection is closed by the remote peer a #GDBusConnection Gets the flags used to construct this connection zero or more flags from the #GDBusConnectionFlags enumeration a #GDBusConnection The GUID of the peer performing the role of server when authenticating. See #GDBusConnection:guid for more details. The GUID. Do not free this string, it is owned by @connection. a #GDBusConnection Retrieves the last serial number assigned to a #GDBusMessage on the current thread. This includes messages sent via both low-level API such as g_dbus_connection_send_message() as well as high-level API such as g_dbus_connection_emit_signal(), g_dbus_connection_call() or g_dbus_proxy_call(). the last used serial or zero when no message has been sent within the current thread a #GDBusConnection Gets the credentials of the authenticated peer. This will always return %NULL unless @connection acted as a server (e.g. %G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_SERVER was passed) when set up and the client passed credentials as part of the authentication process. In a message bus setup, the message bus is always the server and each application is a client. So this method will always return %NULL for message bus clients. a #GCredentials or %NULL if not available. Do not free this object, it is owned by @connection. a #GDBusConnection Gets the underlying stream used for IO. While the #GDBusConnection is active, it will interact with this stream from a worker thread, so it is not safe to interact with the stream directly. the stream used for IO a #GDBusConnection Gets the unique name of @connection as assigned by the message bus. This can also be used to figure out if @connection is a message bus connection. the unique name or %NULL if @connection is not a message bus connection. Do not free this string, it is owned by @connection. a #GDBusConnection Gets whether @connection is closed. %TRUE if the connection is closed, %FALSE otherwise a #GDBusConnection Registers callbacks for exported objects at @object_path with the D-Bus interface that is described in @interface_info. Calls to functions in @vtable (and @user_data_free_func) will happen in the [thread-default main context][g-main-context-push-thread-default] of the thread you are calling this method from. Note that all #GVariant values passed to functions in @vtable will match the signature given in @interface_info - if a remote caller passes incorrect values, the `org.freedesktop.DBus.Error.InvalidArgs` is returned to the remote caller. Additionally, if the remote caller attempts to invoke methods or access properties not mentioned in @interface_info the `org.freedesktop.DBus.Error.UnknownMethod` resp. `org.freedesktop.DBus.Error.InvalidArgs` errors are returned to the caller. It is considered a programming error if the #GDBusInterfaceGetPropertyFunc function in @vtable returns a #GVariant of incorrect type. If an existing callback is already registered at @object_path and @interface_name, then @error is set to #G_IO_ERROR_EXISTS. GDBus automatically implements the standard D-Bus interfaces org.freedesktop.DBus.Properties, org.freedesktop.DBus.Introspectable and org.freedesktop.Peer, so you don't have to implement those for the objects you export. You can implement org.freedesktop.DBus.Properties yourself, e.g. to handle getting and setting of properties asynchronously. Note that the reference count on @interface_info will be incremented by 1 (unless allocated statically, e.g. if the reference count is -1, see g_dbus_interface_info_ref()) for as long as the object is exported. Also note that @vtable will be copied. See this [server][gdbus-server] for an example of how to use this method. 0 if @error is set, otherwise a registration id (never 0) that can be used with g_dbus_connection_unregister_object() a #GDBusConnection the object path to register at introspection data for the interface a #GDBusInterfaceVTable to call into or %NULL data to pass to functions in @vtable function to call when the object path is unregistered Version of g_dbus_connection_register_object() using closures instead of a #GDBusInterfaceVTable for easier binding in other languages. 0 if @error is set, otherwise a registration id (never 0) that can be used with g_dbus_connection_unregister_object() . A #GDBusConnection. The object path to register at. Introspection data for the interface. #GClosure for handling incoming method calls. #GClosure for getting a property. #GClosure for setting a property. Registers a whole subtree of dynamic objects. The @enumerate and @introspection functions in @vtable are used to convey, to remote callers, what nodes exist in the subtree rooted by @object_path. When handling remote calls into any node in the subtree, first the @enumerate function is used to check if the node exists. If the node exists or the #G_DBUS_SUBTREE_FLAGS_DISPATCH_TO_UNENUMERATED_NODES flag is set the @introspection function is used to check if the node supports the requested method. If so, the @dispatch function is used to determine where to dispatch the call. The collected #GDBusInterfaceVTable and #gpointer will be used to call into the interface vtable for processing the request. All calls into user-provided code will be invoked in the [thread-default main context][g-main-context-push-thread-default] of the thread you are calling this method from. If an existing subtree is already registered at @object_path or then @error is set to #G_IO_ERROR_EXISTS. Note that it is valid to register regular objects (using g_dbus_connection_register_object()) in a subtree registered with g_dbus_connection_register_subtree() - if so, the subtree handler is tried as the last resort. One way to think about a subtree handler is to consider it a fallback handler for object paths not registered via g_dbus_connection_register_object() or other bindings. Note that @vtable will be copied so you cannot change it after registration. See this [server][gdbus-subtree-server] for an example of how to use this method. 0 if @error is set, otherwise a subtree registration id (never 0) that can be used with g_dbus_connection_unregister_subtree() . a #GDBusConnection the object path to register the subtree at a #GDBusSubtreeVTable to enumerate, introspect and dispatch nodes in the subtree flags used to fine tune the behavior of the subtree data to pass to functions in @vtable function to call when the subtree is unregistered Removes a filter. Note that since filters run in a different thread, there is a race condition where it is possible that the filter will be running even after calling g_dbus_connection_remove_filter(), so you cannot just free data that the filter might be using. Instead, you should pass a #GDestroyNotify to g_dbus_connection_add_filter(), which will be called when it is guaranteed that the data is no longer needed. a #GDBusConnection an identifier obtained from g_dbus_connection_add_filter() Asynchronously sends @message to the peer represented by @connection. Unless @flags contain the %G_DBUS_SEND_MESSAGE_FLAGS_PRESERVE_SERIAL flag, the serial number will be assigned by @connection and set on @message via g_dbus_message_set_serial(). If @out_serial is not %NULL, then the serial number used will be written to this location prior to submitting the message to the underlying transport. If @connection is closed then the operation will fail with %G_IO_ERROR_CLOSED. If @message is not well-formed, the operation fails with %G_IO_ERROR_INVALID_ARGUMENT. See this [server][gdbus-server] and [client][gdbus-unix-fd-client] for an example of how to use this low-level API to send and receive UNIX file descriptors. Note that @message must be unlocked, unless @flags contain the %G_DBUS_SEND_MESSAGE_FLAGS_PRESERVE_SERIAL flag. %TRUE if the message was well-formed and queued for transmission, %FALSE if @error is set a #GDBusConnection a #GDBusMessage flags affecting how the message is sent return location for serial number assigned to @message when sending it or %NULL Asynchronously sends @message to the peer represented by @connection. Unless @flags contain the %G_DBUS_SEND_MESSAGE_FLAGS_PRESERVE_SERIAL flag, the serial number will be assigned by @connection and set on @message via g_dbus_message_set_serial(). If @out_serial is not %NULL, then the serial number used will be written to this location prior to submitting the message to the underlying transport. If @connection is closed then the operation will fail with %G_IO_ERROR_CLOSED. If @cancellable is canceled, the operation will fail with %G_IO_ERROR_CANCELLED. If @message is not well-formed, the operation fails with %G_IO_ERROR_INVALID_ARGUMENT. This is an asynchronous method. When the operation is finished, @callback will be invoked in the [thread-default main context][g-main-context-push-thread-default] of the thread you are calling this method from. You can then call g_dbus_connection_send_message_with_reply_finish() to get the result of the operation. See g_dbus_connection_send_message_with_reply_sync() for the synchronous version. Note that @message must be unlocked, unless @flags contain the %G_DBUS_SEND_MESSAGE_FLAGS_PRESERVE_SERIAL flag. See this [server][gdbus-server] and [client][gdbus-unix-fd-client] for an example of how to use this low-level API to send and receive UNIX file descriptors. a #GDBusConnection a #GDBusMessage flags affecting how the message is sent the timeout in milliseconds, -1 to use the default timeout or %G_MAXINT for no timeout return location for serial number assigned to @message when sending it or %NULL a #GCancellable or %NULL a #GAsyncReadyCallback to call when the request is satisfied or %NULL if you don't care about the result The data to pass to @callback Finishes an operation started with g_dbus_connection_send_message_with_reply(). Note that @error is only set if a local in-process error occurred. That is to say that the returned #GDBusMessage object may be of type %G_DBUS_MESSAGE_TYPE_ERROR. Use g_dbus_message_to_gerror() to transcode this to a #GError. See this [server][gdbus-server] and [client][gdbus-unix-fd-client] for an example of how to use this low-level API to send and receive UNIX file descriptors. a locked #GDBusMessage or %NULL if @error is set a #GDBusConnection a #GAsyncResult obtained from the #GAsyncReadyCallback passed to g_dbus_connection_send_message_with_reply() Synchronously sends @message to the peer represented by @connection and blocks the calling thread until a reply is received or the timeout is reached. See g_dbus_connection_send_message_with_reply() for the asynchronous version of this method. Unless @flags contain the %G_DBUS_SEND_MESSAGE_FLAGS_PRESERVE_SERIAL flag, the serial number will be assigned by @connection and set on @message via g_dbus_message_set_serial(). If @out_serial is not %NULL, then the serial number used will be written to this location prior to submitting the message to the underlying transport. If @connection is closed then the operation will fail with %G_IO_ERROR_CLOSED. If @cancellable is canceled, the operation will fail with %G_IO_ERROR_CANCELLED. If @message is not well-formed, the operation fails with %G_IO_ERROR_INVALID_ARGUMENT. Note that @error is only set if a local in-process error occurred. That is to say that the returned #GDBusMessage object may be of type %G_DBUS_MESSAGE_TYPE_ERROR. Use g_dbus_message_to_gerror() to transcode this to a #GError. See this [server][gdbus-server] and [client][gdbus-unix-fd-client] for an example of how to use this low-level API to send and receive UNIX file descriptors. Note that @message must be unlocked, unless @flags contain the %G_DBUS_SEND_MESSAGE_FLAGS_PRESERVE_SERIAL flag. a locked #GDBusMessage that is the reply to @message or %NULL if @error is set a #GDBusConnection a #GDBusMessage flags affecting how the message is sent. the timeout in milliseconds, -1 to use the default timeout or %G_MAXINT for no timeout return location for serial number assigned to @message when sending it or %NULL a #GCancellable or %NULL Sets whether the process should be terminated when @connection is closed by the remote peer. See #GDBusConnection:exit-on-close for more details. Note that this function should be used with care. Most modern UNIX desktops tie the notion of a user session with the session bus, and expect all of a user's applications to quit when their bus connection goes away. If you are setting @exit_on_close to %FALSE for the shared session bus connection, you should make sure that your application exits when the user session ends. a #GDBusConnection whether the process should be terminated when @connection is closed by the remote peer Subscribes to signals on @connection and invokes @callback with a whenever the signal is received. Note that @callback will be invoked in the [thread-default main context][g-main-context-push-thread-default] of the thread you are calling this method from. If @connection is not a message bus connection, @sender must be %NULL. If @sender is a well-known name note that @callback is invoked with the unique name for the owner of @sender, not the well-known name as one would expect. This is because the message bus rewrites the name. As such, to avoid certain race conditions, users should be tracking the name owner of the well-known name and use that when processing the received signal. If one of %G_DBUS_SIGNAL_FLAGS_MATCH_ARG0_NAMESPACE or %G_DBUS_SIGNAL_FLAGS_MATCH_ARG0_PATH are given, @arg0 is interpreted as part of a namespace or path. The first argument of a signal is matched against that part as specified by D-Bus. If @user_data_free_func is non-%NULL, it will be called (in the thread-default main context of the thread you are calling this method from) at some point after @user_data is no longer needed. (It is not guaranteed to be called synchronously when the signal is unsubscribed from, and may be called after @connection has been destroyed.) As @callback is potentially invoked in a different thread from where it’s emitted, it’s possible for this to happen after g_dbus_connection_signal_unsubscribe() has been called in another thread. Due to this, @user_data should have a strong reference which is freed with @user_data_free_func, rather than pointing to data whose lifecycle is tied to the signal subscription. For example, if a #GObject is used to store the subscription ID from g_dbus_connection_signal_subscribe(), a strong reference to that #GObject must be passed to @user_data, and g_object_unref() passed to @user_data_free_func. You are responsible for breaking the resulting reference count cycle by explicitly unsubscribing from the signal when dropping the last external reference to the #GObject. Alternatively, a weak reference may be used. It is guaranteed that if you unsubscribe from a signal using g_dbus_connection_signal_unsubscribe() from the same thread which made the corresponding g_dbus_connection_signal_subscribe() call, @callback will not be invoked after g_dbus_connection_signal_unsubscribe() returns. The returned subscription identifier is an opaque value which is guaranteed to never be zero. This function can never fail. a subscription identifier that can be used with g_dbus_connection_signal_unsubscribe() a #GDBusConnection sender name to match on (unique or well-known name) or %NULL to listen from all senders D-Bus interface name to match on or %NULL to match on all interfaces D-Bus signal name to match on or %NULL to match on all signals object path to match on or %NULL to match on all object paths contents of first string argument to match on or %NULL to match on all kinds of arguments #GDBusSignalFlags describing how arg0 is used in subscribing to the signal callback to invoke when there is a signal matching the requested data user data to pass to @callback function to free @user_data with when subscription is removed or %NULL Unsubscribes from signals. Note that there may still be D-Bus traffic to process (relating to this signal subscription) in the current thread-default #GMainContext after this function has returned. You should continue to iterate the #GMainContext until the #GDestroyNotify function passed to g_dbus_connection_signal_subscribe() is called, in order to avoid memory leaks through callbacks queued on the #GMainContext after it’s stopped being iterated. a #GDBusConnection a subscription id obtained from g_dbus_connection_signal_subscribe() If @connection was created with %G_DBUS_CONNECTION_FLAGS_DELAY_MESSAGE_PROCESSING, this method starts processing messages. Does nothing on if @connection wasn't created with this flag or if the method has already been called. a #GDBusConnection Reverses the effect of a previous call to g_dbus_connection_export_action_group(). It is an error to call this function with an ID that wasn't returned from g_dbus_connection_export_action_group() or to call it with the same ID more than once. a #GDBusConnection the ID from g_dbus_connection_export_action_group() Reverses the effect of a previous call to g_dbus_connection_export_menu_model(). It is an error to call this function with an ID that wasn't returned from g_dbus_connection_export_menu_model() or to call it with the same ID more than once. a #GDBusConnection the ID from g_dbus_connection_export_menu_model() Unregisters an object. %TRUE if the object was unregistered, %FALSE otherwise a #GDBusConnection a registration id obtained from g_dbus_connection_register_object() Unregisters a subtree. %TRUE if the subtree was unregistered, %FALSE otherwise a #GDBusConnection a subtree registration id obtained from g_dbus_connection_register_subtree() A D-Bus address specifying potential endpoints that can be used when establishing the connection. A #GDBusAuthObserver object to assist in the authentication process or %NULL. Flags from the #GDBusCapabilityFlags enumeration representing connection features negotiated with the other peer. A boolean specifying whether the connection has been closed. A boolean specifying whether the process will be terminated (by calling `raise(SIGTERM)`) if the connection is closed by the remote peer. Note that #GDBusConnection objects returned by g_bus_get_finish() and g_bus_get_sync() will (usually) have this property set to %TRUE. Flags from the #GDBusConnectionFlags enumeration. The GUID of the peer performing the role of server when authenticating. If you are constructing a #GDBusConnection and pass %G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_SERVER in the #GDBusConnection:flags property then you MUST also set this property to a valid guid. If you are constructing a #GDBusConnection and pass %G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT in the #GDBusConnection:flags property you will be able to read the GUID of the other peer here after the connection has been successfully initialized. The underlying #GIOStream used for I/O. If this is passed on construction and is a #GSocketConnection, then the corresponding #GSocket will be put into non-blocking mode. While the #GDBusConnection is active, it will interact with this stream from a worker thread, so it is not safe to interact with the stream directly. The unique name as assigned by the message bus or %NULL if the connection is not open or not a message bus connection. Emitted when the connection is closed. The cause of this event can be - If g_dbus_connection_close() is called. In this case @remote_peer_vanished is set to %FALSE and @error is %NULL. - If the remote peer closes the connection. In this case @remote_peer_vanished is set to %TRUE and @error is set. - If the remote peer sends invalid or malformed data. In this case @remote_peer_vanished is set to %FALSE and @error is set. Upon receiving this signal, you should give up your reference to @connection. You are guaranteed that this signal is emitted only once. %TRUE if @connection is closed because the remote peer closed its end of the connection a #GError with more details about the event or %NULL Flags used when creating a new #GDBusConnection. No flags set. Perform authentication against server. Perform authentication against client. When authenticating as a server, allow the anonymous authentication method. Pass this flag if connecting to a peer that is a message bus. This means that the Hello() method will be invoked as part of the connection setup. If set, processing of D-Bus messages is delayed until g_dbus_connection_start_message_processing() is called. Error codes for the %G_DBUS_ERROR error domain. A generic error; "something went wrong" - see the error message for more. There was not enough memory to complete an operation. The bus doesn't know how to launch a service to supply the bus name you wanted. The bus name you referenced doesn't exist (i.e. no application owns it). No reply to a message expecting one, usually means a timeout occurred. Something went wrong reading or writing to a socket, for example. A D-Bus bus address was malformed. Requested operation isn't supported (like ENOSYS on UNIX). Some limited resource is exhausted. Security restrictions don't allow doing what you're trying to do. Authentication didn't work. Unable to connect to server (probably caused by ECONNREFUSED on a socket). Certain timeout errors, possibly ETIMEDOUT on a socket. Note that %G_DBUS_ERROR_NO_REPLY is used for message reply timeouts. Warning: this is confusingly-named given that %G_DBUS_ERROR_TIMED_OUT also exists. We can't fix it for compatibility reasons so just be careful. No network access (probably ENETUNREACH on a socket). Can't bind a socket since its address is in use (i.e. EADDRINUSE). The connection is disconnected and you're trying to use it. Invalid arguments passed to a method call. Missing file. Existing file and the operation you're using does not silently overwrite. Method name you invoked isn't known by the object you invoked it on. Certain timeout errors, e.g. while starting a service. Warning: this is confusingly-named given that %G_DBUS_ERROR_TIMEOUT also exists. We can't fix it for compatibility reasons so just be careful. Tried to remove or modify a match rule that didn't exist. The match rule isn't syntactically valid. While starting a new process, the exec() call failed. While starting a new process, the fork() call failed. While starting a new process, the child exited with a status code. While starting a new process, the child exited on a signal. While starting a new process, something went wrong. We failed to setup the environment correctly. We failed to setup the config parser correctly. Bus name was not valid. Service file not found in system-services directory. Permissions are incorrect on the setuid helper. Service file invalid (Name, User or Exec missing). Tried to get a UNIX process ID and it wasn't available. Tried to get a UNIX process ID and it wasn't available. A type signature is not valid. A file contains invalid syntax or is otherwise broken. Asked for SELinux security context and it wasn't available. Asked for ADT audit data and it wasn't available. There's already an object with the requested object path. Object you invoked a method on isn't known. Since 2.42 Interface you invoked a method on isn't known by the object. Since 2.42 Property you tried to access isn't known by the object. Since 2.42 Property you tried to set is read-only. Since 2.42 Creates a D-Bus error name to use for @error. If @error matches a registered error (cf. g_dbus_error_register_error()), the corresponding D-Bus error name will be returned. Otherwise the a name of the form `org.gtk.GDBus.UnmappedGError.Quark._ESCAPED_QUARK_NAME.Code_ERROR_CODE` will be used. This allows other GDBus applications to map the error on the wire back to a #GError using g_dbus_error_new_for_dbus_error(). This function is typically only used in object mappings to put a #GError on the wire. Regular applications should not use it. A D-Bus error name (never %NULL). Free with g_free(). A #GError. Gets the D-Bus error name used for @error, if any. This function is guaranteed to return a D-Bus error name for all #GErrors returned from functions handling remote method calls (e.g. g_dbus_connection_call_finish()) unless g_dbus_error_strip_remote_error() has been used on @error. an allocated string or %NULL if the D-Bus error name could not be found. Free with g_free(). a #GError Checks if @error represents an error received via D-Bus from a remote peer. If so, use g_dbus_error_get_remote_error() to get the name of the error. %TRUE if @error represents an error from a remote peer, %FALSE otherwise. A #GError. Creates a #GError based on the contents of @dbus_error_name and @dbus_error_message. Errors registered with g_dbus_error_register_error() will be looked up using @dbus_error_name and if a match is found, the error domain and code is used. Applications can use g_dbus_error_get_remote_error() to recover @dbus_error_name. If a match against a registered error is not found and the D-Bus error name is in a form as returned by g_dbus_error_encode_gerror() the error domain and code encoded in the name is used to create the #GError. Also, @dbus_error_name is added to the error message such that it can be recovered with g_dbus_error_get_remote_error(). Otherwise, a #GError with the error code %G_IO_ERROR_DBUS_ERROR in the #G_IO_ERROR error domain is returned. Also, @dbus_error_name is added to the error message such that it can be recovered with g_dbus_error_get_remote_error(). In all three cases, @dbus_error_name can always be recovered from the returned #GError using the g_dbus_error_get_remote_error() function (unless g_dbus_error_strip_remote_error() hasn't been used on the returned error). This function is typically only used in object mappings to prepare #GError instances for applications. Regular applications should not use it. An allocated #GError. Free with g_error_free(). D-Bus error name. D-Bus error message. Creates an association to map between @dbus_error_name and #GErrors specified by @error_domain and @error_code. This is typically done in the routine that returns the #GQuark for an error domain. %TRUE if the association was created, %FALSE if it already exists. A #GQuark for an error domain. An error code. A D-Bus error name. Helper function for associating a #GError error domain with D-Bus error names. The error domain name. A pointer where to store the #GQuark. A pointer to @num_entries #GDBusErrorEntry struct items. Number of items to register. Does nothing if @error is %NULL. Otherwise sets *@error to a new #GError created with g_dbus_error_new_for_dbus_error() with @dbus_error_message prepend with @format (unless %NULL). A pointer to a #GError or %NULL. D-Bus error name. D-Bus error message. printf()-style format to prepend to @dbus_error_message or %NULL. Arguments for @format. Like g_dbus_error_set_dbus_error() but intended for language bindings. A pointer to a #GError or %NULL. D-Bus error name. D-Bus error message. printf()-style format to prepend to @dbus_error_message or %NULL. Arguments for @format. Looks for extra information in the error message used to recover the D-Bus error name and strips it if found. If stripped, the message field in @error will correspond exactly to what was received on the wire. This is typically used when presenting errors to the end user. %TRUE if information was stripped, %FALSE otherwise. A #GError. Destroys an association previously set up with g_dbus_error_register_error(). %TRUE if the association was destroyed, %FALSE if it wasn't found. A #GQuark for an error domain. An error code. A D-Bus error name. Struct used in g_dbus_error_register_error_domain(). An error code. The D-Bus error name to associate with @error_code. The #GDBusInterface type is the base type for D-Bus interfaces both on the service side (see #GDBusInterfaceSkeleton) and client side (see #GDBusProxy). Gets the #GDBusObject that @interface_ belongs to, if any. A #GDBusObject or %NULL. The returned reference should be freed with g_object_unref(). An exported D-Bus interface. Gets D-Bus introspection information for the D-Bus interface implemented by @interface_. A #GDBusInterfaceInfo. Do not free. An exported D-Bus interface. Gets the #GDBusObject that @interface_ belongs to, if any. It is not safe to use the returned object if @interface_ or the returned object is being used from other threads. See g_dbus_interface_dup_object() for a thread-safe alternative. A #GDBusObject or %NULL. The returned reference belongs to @interface_ and should not be freed. An exported D-Bus interface Sets the #GDBusObject for @interface_ to @object. Note that @interface_ will hold a weak reference to @object. An exported D-Bus interface. A #GDBusObject or %NULL. Gets the #GDBusObject that @interface_ belongs to, if any. A #GDBusObject or %NULL. The returned reference should be freed with g_object_unref(). An exported D-Bus interface. Gets D-Bus introspection information for the D-Bus interface implemented by @interface_. A #GDBusInterfaceInfo. Do not free. An exported D-Bus interface. Gets the #GDBusObject that @interface_ belongs to, if any. It is not safe to use the returned object if @interface_ or the returned object is being used from other threads. See g_dbus_interface_dup_object() for a thread-safe alternative. A #GDBusObject or %NULL. The returned reference belongs to @interface_ and should not be freed. An exported D-Bus interface Sets the #GDBusObject for @interface_ to @object. Note that @interface_ will hold a weak reference to @object. An exported D-Bus interface. A #GDBusObject or %NULL. The type of the @get_property function in #GDBusInterfaceVTable. A #GVariant with the value for @property_name or %NULL if @error is set. If the returned #GVariant is floating, it is consumed - otherwise its reference count is decreased by one. A #GDBusConnection. The unique bus name of the remote caller. The object path that the method was invoked on. The D-Bus interface name for the property. The name of the property to get the value of. Return location for error. The @user_data #gpointer passed to g_dbus_connection_register_object(). Base type for D-Bus interfaces. The parent interface. A #GDBusInterfaceInfo. Do not free. An exported D-Bus interface. A #GDBusObject or %NULL. The returned reference belongs to @interface_ and should not be freed. An exported D-Bus interface An exported D-Bus interface. A #GDBusObject or %NULL. A #GDBusObject or %NULL. The returned reference should be freed with g_object_unref(). An exported D-Bus interface. Information about a D-Bus interface. The reference count or -1 if statically allocated. The name of the D-Bus interface, e.g. "org.freedesktop.DBus.Properties". A pointer to a %NULL-terminated array of pointers to #GDBusMethodInfo structures or %NULL if there are no methods. A pointer to a %NULL-terminated array of pointers to #GDBusSignalInfo structures or %NULL if there are no signals. A pointer to a %NULL-terminated array of pointers to #GDBusPropertyInfo structures or %NULL if there are no properties. A pointer to a %NULL-terminated array of pointers to #GDBusAnnotationInfo structures or %NULL if there are no annotations. Builds a lookup-cache to speed up g_dbus_interface_info_lookup_method(), g_dbus_interface_info_lookup_signal() and g_dbus_interface_info_lookup_property(). If this has already been called with @info, the existing cache is used and its use count is increased. Note that @info cannot be modified until g_dbus_interface_info_cache_release() is called. A #GDBusInterfaceInfo. Decrements the usage count for the cache for @info built by g_dbus_interface_info_cache_build() (if any) and frees the resources used by the cache if the usage count drops to zero. A GDBusInterfaceInfo Appends an XML representation of @info (and its children) to @string_builder. This function is typically used for generating introspection XML documents at run-time for handling the `org.freedesktop.DBus.Introspectable.Introspect` method. A #GDBusNodeInfo Indentation level. A #GString to to append XML data to. Looks up information about a method. The cost of this function is O(n) in number of methods unless g_dbus_interface_info_cache_build() has been used on @info. A #GDBusMethodInfo or %NULL if not found. Do not free, it is owned by @info. A #GDBusInterfaceInfo. A D-Bus method name (typically in CamelCase) Looks up information about a property. The cost of this function is O(n) in number of properties unless g_dbus_interface_info_cache_build() has been used on @info. A #GDBusPropertyInfo or %NULL if not found. Do not free, it is owned by @info. A #GDBusInterfaceInfo. A D-Bus property name (typically in CamelCase). Looks up information about a signal. The cost of this function is O(n) in number of signals unless g_dbus_interface_info_cache_build() has been used on @info. A #GDBusSignalInfo or %NULL if not found. Do not free, it is owned by @info. A #GDBusInterfaceInfo. A D-Bus signal name (typically in CamelCase) If @info is statically allocated does nothing. Otherwise increases the reference count. The same @info. A #GDBusInterfaceInfo If @info is statically allocated, does nothing. Otherwise decreases the reference count of @info. When its reference count drops to 0, the memory used is freed. A #GDBusInterfaceInfo. The type of the @method_call function in #GDBusInterfaceVTable. A #GDBusConnection. The unique bus name of the remote caller. The object path that the method was invoked on. The D-Bus interface name the method was invoked on. The name of the method that was invoked. A #GVariant tuple with parameters. A #GDBusMethodInvocation object that must be used to return a value or error. The @user_data #gpointer passed to g_dbus_connection_register_object(). The type of the @set_property function in #GDBusInterfaceVTable. %TRUE if the property was set to @value, %FALSE if @error is set. A #GDBusConnection. The unique bus name of the remote caller. The object path that the method was invoked on. The D-Bus interface name for the property. The name of the property to get the value of. The value to set the property to. Return location for error. The @user_data #gpointer passed to g_dbus_connection_register_object(). Abstract base class for D-Bus interfaces on the service side. If @interface_ has outstanding changes, request for these changes to be emitted immediately. For example, an exported D-Bus interface may queue up property changes and emit the `org.freedesktop.DBus.Properties.PropertiesChanged` signal later (e.g. in an idle handler). This technique is useful for collapsing multiple property changes into one. A #GDBusInterfaceSkeleton. Gets D-Bus introspection information for the D-Bus interface implemented by @interface_. A #GDBusInterfaceInfo (never %NULL). Do not free. A #GDBusInterfaceSkeleton. Gets all D-Bus properties for @interface_. A #GVariant of type ['a{sv}'][G-VARIANT-TYPE-VARDICT:CAPS]. Free with g_variant_unref(). A #GDBusInterfaceSkeleton. Gets the interface vtable for the D-Bus interface implemented by @interface_. The returned function pointers should expect @interface_ itself to be passed as @user_data. A #GDBusInterfaceVTable (never %NULL). A #GDBusInterfaceSkeleton. Exports @interface_ at @object_path on @connection. This can be called multiple times to export the same @interface_ onto multiple connections however the @object_path provided must be the same for all connections. Use g_dbus_interface_skeleton_unexport() to unexport the object. %TRUE if the interface was exported on @connection, otherwise %FALSE with @error set. The D-Bus interface to export. A #GDBusConnection to export @interface_ on. The path to export the interface at. If @interface_ has outstanding changes, request for these changes to be emitted immediately. For example, an exported D-Bus interface may queue up property changes and emit the `org.freedesktop.DBus.Properties.PropertiesChanged` signal later (e.g. in an idle handler). This technique is useful for collapsing multiple property changes into one. A #GDBusInterfaceSkeleton. Gets the first connection that @interface_ is exported on, if any. A #GDBusConnection or %NULL if @interface_ is not exported anywhere. Do not free, the object belongs to @interface_. A #GDBusInterfaceSkeleton. Gets a list of the connections that @interface_ is exported on. A list of all the connections that @interface_ is exported on. The returned list should be freed with g_list_free() after each element has been freed with g_object_unref(). A #GDBusInterfaceSkeleton. Gets the #GDBusInterfaceSkeletonFlags that describes what the behavior of @interface_ One or more flags from the #GDBusInterfaceSkeletonFlags enumeration. A #GDBusInterfaceSkeleton. Gets D-Bus introspection information for the D-Bus interface implemented by @interface_. A #GDBusInterfaceInfo (never %NULL). Do not free. A #GDBusInterfaceSkeleton. Gets the object path that @interface_ is exported on, if any. A string owned by @interface_ or %NULL if @interface_ is not exported anywhere. Do not free, the string belongs to @interface_. A #GDBusInterfaceSkeleton. Gets all D-Bus properties for @interface_. A #GVariant of type ['a{sv}'][G-VARIANT-TYPE-VARDICT:CAPS]. Free with g_variant_unref(). A #GDBusInterfaceSkeleton. Gets the interface vtable for the D-Bus interface implemented by @interface_. The returned function pointers should expect @interface_ itself to be passed as @user_data. A #GDBusInterfaceVTable (never %NULL). A #GDBusInterfaceSkeleton. Checks if @interface_ is exported on @connection. %TRUE if @interface_ is exported on @connection, %FALSE otherwise. A #GDBusInterfaceSkeleton. A #GDBusConnection. Sets flags describing what the behavior of @skeleton should be. A #GDBusInterfaceSkeleton. Flags from the #GDBusInterfaceSkeletonFlags enumeration. Stops exporting @interface_ on all connections it is exported on. To unexport @interface_ from only a single connection, use g_dbus_interface_skeleton_unexport_from_connection() A #GDBusInterfaceSkeleton. Stops exporting @interface_ on @connection. To stop exporting on all connections the interface is exported on, use g_dbus_interface_skeleton_unexport(). A #GDBusInterfaceSkeleton. A #GDBusConnection. Flags from the #GDBusInterfaceSkeletonFlags enumeration. Emitted when a method is invoked by a remote caller and used to determine if the method call is authorized. Note that this signal is emitted in a thread dedicated to handling the method call so handlers are allowed to perform blocking IO. This means that it is appropriate to call e.g. [polkit_authority_check_authorization_sync()](http://hal.freedesktop.org/docs/polkit/PolkitAuthority.html#polkit-authority-check-authorization-sync) with the [POLKIT_CHECK_AUTHORIZATION_FLAGS_ALLOW_USER_INTERACTION](http://hal.freedesktop.org/docs/polkit/PolkitAuthority.html#POLKIT-CHECK-AUTHORIZATION-FLAGS-ALLOW-USER-INTERACTION:CAPS) flag set. If %FALSE is returned then no further handlers are run and the signal handler must take a reference to @invocation and finish handling the call (e.g. return an error via g_dbus_method_invocation_return_error()). Otherwise, if %TRUE is returned, signal emission continues. If no handlers return %FALSE, then the method is dispatched. If @interface has an enclosing #GDBusObjectSkeleton, then the #GDBusObjectSkeleton::authorize-method signal handlers run before the handlers for this signal. The default class handler just returns %TRUE. Please note that the common case is optimized: if no signals handlers are connected and the default class handler isn't overridden (for both @interface and the enclosing #GDBusObjectSkeleton, if any) and #GDBusInterfaceSkeleton:g-flags does not have the %G_DBUS_INTERFACE_SKELETON_FLAGS_HANDLE_METHOD_INVOCATIONS_IN_THREAD flags set, no dedicated thread is ever used and the call will be handled in the same thread as the object that @interface belongs to was exported in. %TRUE if the call is authorized, %FALSE otherwise. A #GDBusMethodInvocation. Class structure for #GDBusInterfaceSkeleton. The parent class. A #GDBusInterfaceInfo (never %NULL). Do not free. A #GDBusInterfaceSkeleton. A #GDBusInterfaceVTable (never %NULL). A #GDBusInterfaceSkeleton. A #GVariant of type ['a{sv}'][G-VARIANT-TYPE-VARDICT:CAPS]. Free with g_variant_unref(). A #GDBusInterfaceSkeleton. A #GDBusInterfaceSkeleton. Flags describing the behavior of a #GDBusInterfaceSkeleton instance. No flags set. Each method invocation is handled in a thread dedicated to the invocation. This means that the method implementation can use blocking IO without blocking any other part of the process. It also means that the method implementation must use locking to access data structures used by other threads. Virtual table for handling properties and method calls for a D-Bus interface. Since 2.38, if you want to handle getting/setting D-Bus properties asynchronously, give %NULL as your get_property() or set_property() function. The D-Bus call will be directed to your @method_call function, with the provided @interface_name set to "org.freedesktop.DBus.Properties". Ownership of the #GDBusMethodInvocation object passed to the method_call() function is transferred to your handler; you must call one of the methods of #GDBusMethodInvocation to return a reply (possibly empty), or an error. These functions also take ownership of the passed-in invocation object, so unless the invocation object has otherwise been referenced, it will be then be freed. Calling one of these functions may be done within your method_call() implementation but it also can be done at a later point to handle the method asynchronously. The usual checks on the validity of the calls is performed. For `Get` calls, an error is automatically returned if the property does not exist or the permissions do not allow access. The same checks are performed for `Set` calls, and the provided value is also checked for being the correct type. For both `Get` and `Set` calls, the #GDBusMethodInvocation passed to the @method_call handler can be queried with g_dbus_method_invocation_get_property_info() to get a pointer to the #GDBusPropertyInfo of the property. If you have readable properties specified in your interface info, you must ensure that you either provide a non-%NULL @get_property() function or provide implementations of both the `Get` and `GetAll` methods on org.freedesktop.DBus.Properties interface in your @method_call function. Note that the required return type of the `Get` call is `(v)`, not the type of the property. `GetAll` expects a return value of type `a{sv}`. If you have writable properties specified in your interface info, you must ensure that you either provide a non-%NULL @set_property() function or provide an implementation of the `Set` call. If implementing the call, you must return the value of type %G_VARIANT_TYPE_UNIT. Function for handling incoming method calls. Function for getting a property. Function for setting a property. #GDBusMenuModel is an implementation of #GMenuModel that can be used as a proxy for a menu model that is exported over D-Bus with g_dbus_connection_export_menu_model(). Obtains a #GDBusMenuModel for the menu model which is exported at the given @bus_name and @object_path. The thread default main context is taken at the time of this call. All signals on the menu model (and any linked models) are reported with respect to this context. All calls on the returned menu model (and linked models) must also originate from this same context, with the thread default main context unchanged. a #GDBusMenuModel object. Free with g_object_unref(). a #GDBusConnection the bus name which exports the menu model or %NULL if @connection is not a message bus connection the object path at which the menu model is exported A type for representing D-Bus messages that can be sent or received on a #GDBusConnection. Creates a new empty #GDBusMessage. A #GDBusMessage. Free with g_object_unref(). Creates a new #GDBusMessage from the data stored at @blob. The byte order that the message was in can be retrieved using g_dbus_message_get_byte_order(). If the @blob cannot be parsed, contains invalid fields, or contains invalid headers, %G_IO_ERROR_INVALID_ARGUMENT will be returned. A new #GDBusMessage or %NULL if @error is set. Free with g_object_unref(). A blob representing a binary D-Bus message. The length of @blob. A #GDBusCapabilityFlags describing what protocol features are supported. Creates a new #GDBusMessage for a method call. A #GDBusMessage. Free with g_object_unref(). A valid D-Bus name or %NULL. A valid object path. A valid D-Bus interface name or %NULL. A valid method name. Creates a new #GDBusMessage for a signal emission. A #GDBusMessage. Free with g_object_unref(). A valid object path. A valid D-Bus interface name. A valid signal name. Utility function to calculate how many bytes are needed to completely deserialize the D-Bus message stored at @blob. Number of bytes needed or -1 if @error is set (e.g. if @blob contains invalid data or not enough data is available to determine the size). A blob representing a binary D-Bus message. The length of @blob (must be at least 16). Copies @message. The copy is a deep copy and the returned #GDBusMessage is completely identical except that it is guaranteed to not be locked. This operation can fail if e.g. @message contains file descriptors and the per-process or system-wide open files limit is reached. A new #GDBusMessage or %NULL if @error is set. Free with g_object_unref(). A #GDBusMessage. Convenience to get the first item in the body of @message. The string item or %NULL if the first item in the body of @message is not a string. A #GDBusMessage. Gets the body of a message. A #GVariant or %NULL if the body is empty. Do not free, it is owned by @message. A #GDBusMessage. Gets the byte order of @message. The byte order. A #GDBusMessage. Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_DESTINATION header field. The value. A #GDBusMessage. Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_ERROR_NAME header field. The value. A #GDBusMessage. Gets the flags for @message. Flags that are set (typically values from the #GDBusMessageFlags enumeration bitwise ORed together). A #GDBusMessage. Gets a header field on @message. The caller is responsible for checking the type of the returned #GVariant matches what is expected. A #GVariant with the value if the header was found, %NULL otherwise. Do not free, it is owned by @message. A #GDBusMessage. A 8-bit unsigned integer (typically a value from the #GDBusMessageHeaderField enumeration) Gets an array of all header fields on @message that are set. An array of header fields terminated by %G_DBUS_MESSAGE_HEADER_FIELD_INVALID. Each element is a #guchar. Free with g_free(). A #GDBusMessage. Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_INTERFACE header field. The value. A #GDBusMessage. Checks whether @message is locked. To monitor changes to this value, conncet to the #GObject::notify signal to listen for changes on the #GDBusMessage:locked property. %TRUE if @message is locked, %FALSE otherwise. A #GDBusMessage. Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_MEMBER header field. The value. A #GDBusMessage. Gets the type of @message. A 8-bit unsigned integer (typically a value from the #GDBusMessageType enumeration). A #GDBusMessage. Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_NUM_UNIX_FDS header field. The value. A #GDBusMessage. Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_PATH header field. The value. A #GDBusMessage. Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_REPLY_SERIAL header field. The value. A #GDBusMessage. Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_SENDER header field. The value. A #GDBusMessage. Gets the serial for @message. A #guint32. A #GDBusMessage. Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_SIGNATURE header field. The value. A #GDBusMessage. Gets the UNIX file descriptors associated with @message, if any. This method is only available on UNIX. A #GUnixFDList or %NULL if no file descriptors are associated. Do not free, this object is owned by @message. A #GDBusMessage. If @message is locked, does nothing. Otherwise locks the message. A #GDBusMessage. Creates a new #GDBusMessage that is an error reply to @method_call_message. A #GDBusMessage. Free with g_object_unref(). A message of type %G_DBUS_MESSAGE_TYPE_METHOD_CALL to create a reply message to. A valid D-Bus error name. The D-Bus error message in a printf() format. Arguments for @error_message_format. Creates a new #GDBusMessage that is an error reply to @method_call_message. A #GDBusMessage. Free with g_object_unref(). A message of type %G_DBUS_MESSAGE_TYPE_METHOD_CALL to create a reply message to. A valid D-Bus error name. The D-Bus error message. Like g_dbus_message_new_method_error() but intended for language bindings. A #GDBusMessage. Free with g_object_unref(). A message of type %G_DBUS_MESSAGE_TYPE_METHOD_CALL to create a reply message to. A valid D-Bus error name. The D-Bus error message in a printf() format. Arguments for @error_message_format. Creates a new #GDBusMessage that is a reply to @method_call_message. #GDBusMessage. Free with g_object_unref(). A message of type %G_DBUS_MESSAGE_TYPE_METHOD_CALL to create a reply message to. Produces a human-readable multi-line description of @message. The contents of the description has no ABI guarantees, the contents and formatting is subject to change at any time. Typical output looks something like this: |[ Flags: none Version: 0 Serial: 4 Headers: path -> objectpath '/org/gtk/GDBus/TestObject' interface -> 'org.gtk.GDBus.TestInterface' member -> 'GimmeStdout' destination -> ':1.146' Body: () UNIX File Descriptors: (none) ]| or |[ Flags: no-reply-expected Version: 0 Serial: 477 Headers: reply-serial -> uint32 4 destination -> ':1.159' sender -> ':1.146' num-unix-fds -> uint32 1 Body: () UNIX File Descriptors: fd 12: dev=0:10,mode=020620,ino=5,uid=500,gid=5,rdev=136:2,size=0,atime=1273085037,mtime=1273085851,ctime=1272982635 ]| A string that should be freed with g_free(). A #GDBusMessage. Indentation level. Sets the body @message. As a side-effect the %G_DBUS_MESSAGE_HEADER_FIELD_SIGNATURE header field is set to the type string of @body (or cleared if @body is %NULL). If @body is floating, @message assumes ownership of @body. A #GDBusMessage. Either %NULL or a #GVariant that is a tuple. Sets the byte order of @message. A #GDBusMessage. The byte order. Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_DESTINATION header field. A #GDBusMessage. The value to set. Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_ERROR_NAME header field. A #GDBusMessage. The value to set. Sets the flags to set on @message. A #GDBusMessage. Flags for @message that are set (typically values from the #GDBusMessageFlags enumeration bitwise ORed together). Sets a header field on @message. If @value is floating, @message assumes ownership of @value. A #GDBusMessage. A 8-bit unsigned integer (typically a value from the #GDBusMessageHeaderField enumeration) A #GVariant to set the header field or %NULL to clear the header field. Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_INTERFACE header field. A #GDBusMessage. The value to set. Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_MEMBER header field. A #GDBusMessage. The value to set. Sets @message to be of @type. A #GDBusMessage. A 8-bit unsigned integer (typically a value from the #GDBusMessageType enumeration). Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_NUM_UNIX_FDS header field. A #GDBusMessage. The value to set. Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_PATH header field. A #GDBusMessage. The value to set. Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_REPLY_SERIAL header field. A #GDBusMessage. The value to set. Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_SENDER header field. A #GDBusMessage. The value to set. Sets the serial for @message. A #GDBusMessage. A #guint32. Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_SIGNATURE header field. A #GDBusMessage. The value to set. Sets the UNIX file descriptors associated with @message. As a side-effect the %G_DBUS_MESSAGE_HEADER_FIELD_NUM_UNIX_FDS header field is set to the number of fds in @fd_list (or cleared if @fd_list is %NULL). This method is only available on UNIX. A #GDBusMessage. A #GUnixFDList or %NULL. Serializes @message to a blob. The byte order returned by g_dbus_message_get_byte_order() will be used. A pointer to a valid binary D-Bus message of @out_size bytes generated by @message or %NULL if @error is set. Free with g_free(). A #GDBusMessage. Return location for size of generated blob. A #GDBusCapabilityFlags describing what protocol features are supported. If @message is not of type %G_DBUS_MESSAGE_TYPE_ERROR does nothing and returns %FALSE. Otherwise this method encodes the error in @message as a #GError using g_dbus_error_set_dbus_error() using the information in the %G_DBUS_MESSAGE_HEADER_FIELD_ERROR_NAME header field of @message as well as the first string item in @message's body. %TRUE if @error was set, %FALSE otherwise. A #GDBusMessage. Enumeration used to describe the byte order of a D-Bus message. The byte order is big endian. The byte order is little endian. Signature for function used in g_dbus_connection_add_filter(). A filter function is passed a #GDBusMessage and expected to return a #GDBusMessage too. Passive filter functions that don't modify the message can simply return the @message object: |[ static GDBusMessage * passive_filter (GDBusConnection *connection GDBusMessage *message, gboolean incoming, gpointer user_data) { // inspect @message return message; } ]| Filter functions that wants to drop a message can simply return %NULL: |[ static GDBusMessage * drop_filter (GDBusConnection *connection GDBusMessage *message, gboolean incoming, gpointer user_data) { if (should_drop_message) { g_object_unref (message); message = NULL; } return message; } ]| Finally, a filter function may modify a message by copying it: |[ static GDBusMessage * modifying_filter (GDBusConnection *connection GDBusMessage *message, gboolean incoming, gpointer user_data) { GDBusMessage *copy; GError *error; error = NULL; copy = g_dbus_message_copy (message, &error); // handle @error being set g_object_unref (message); // modify @copy return copy; } ]| If the returned #GDBusMessage is different from @message and cannot be sent on @connection (it could use features, such as file descriptors, not compatible with @connection), then a warning is logged to standard error. Applications can check this ahead of time using g_dbus_message_to_blob() passing a #GDBusCapabilityFlags value obtained from @connection. A #GDBusMessage that will be freed with g_object_unref() or %NULL to drop the message. Passive filter functions can simply return the passed @message object. A #GDBusConnection. A locked #GDBusMessage that the filter function takes ownership of. %TRUE if it is a message received from the other peer, %FALSE if it is a message to be sent to the other peer. User data passed when adding the filter. Message flags used in #GDBusMessage. No flags set. A reply is not expected. The bus must not launch an owner for the destination name in response to this message. If set on a method call, this flag means that the caller is prepared to wait for interactive authorization. Since 2.46. Header fields used in #GDBusMessage. Not a valid header field. The object path. The interface name. The method or signal name. The name of the error that occurred. The serial number the message is a reply to. The name the message is intended for. Unique name of the sender of the message (filled in by the bus). The signature of the message body. The number of UNIX file descriptors that accompany the message. Message types used in #GDBusMessage. Message is of invalid type. Method call. Method reply. Error reply. Signal emission. Information about a method on an D-Bus interface. The reference count or -1 if statically allocated. The name of the D-Bus method, e.g. @RequestName. A pointer to a %NULL-terminated array of pointers to #GDBusArgInfo structures or %NULL if there are no in arguments. A pointer to a %NULL-terminated array of pointers to #GDBusArgInfo structures or %NULL if there are no out arguments. A pointer to a %NULL-terminated array of pointers to #GDBusAnnotationInfo structures or %NULL if there are no annotations. If @info is statically allocated does nothing. Otherwise increases the reference count. The same @info. A #GDBusMethodInfo If @info is statically allocated, does nothing. Otherwise decreases the reference count of @info. When its reference count drops to 0, the memory used is freed. A #GDBusMethodInfo. Instances of the #GDBusMethodInvocation class are used when handling D-Bus method calls. It provides a way to asynchronously return results and errors. The normal way to obtain a #GDBusMethodInvocation object is to receive it as an argument to the handle_method_call() function in a #GDBusInterfaceVTable that was passed to g_dbus_connection_register_object(). Gets the #GDBusConnection the method was invoked on. A #GDBusConnection. Do not free, it is owned by @invocation. A #GDBusMethodInvocation. Gets the name of the D-Bus interface the method was invoked on. If this method call is a property Get, Set or GetAll call that has been redirected to the method call handler then "org.freedesktop.DBus.Properties" will be returned. See #GDBusInterfaceVTable for more information. A string. Do not free, it is owned by @invocation. A #GDBusMethodInvocation. Gets the #GDBusMessage for the method invocation. This is useful if you need to use low-level protocol features, such as UNIX file descriptor passing, that cannot be properly expressed in the #GVariant API. See this [server][gdbus-server] and [client][gdbus-unix-fd-client] for an example of how to use this low-level API to send and receive UNIX file descriptors. #GDBusMessage. Do not free, it is owned by @invocation. A #GDBusMethodInvocation. Gets information about the method call, if any. If this method invocation is a property Get, Set or GetAll call that has been redirected to the method call handler then %NULL will be returned. See g_dbus_method_invocation_get_property_info() and #GDBusInterfaceVTable for more information. A #GDBusMethodInfo or %NULL. Do not free, it is owned by @invocation. A #GDBusMethodInvocation. Gets the name of the method that was invoked. A string. Do not free, it is owned by @invocation. A #GDBusMethodInvocation. Gets the object path the method was invoked on. A string. Do not free, it is owned by @invocation. A #GDBusMethodInvocation. Gets the parameters of the method invocation. If there are no input parameters then this will return a GVariant with 0 children rather than NULL. A #GVariant tuple. Do not unref this because it is owned by @invocation. A #GDBusMethodInvocation. Gets information about the property that this method call is for, if any. This will only be set in the case of an invocation in response to a property Get or Set call that has been directed to the method call handler for an object on account of its property_get() or property_set() vtable pointers being unset. See #GDBusInterfaceVTable for more information. If the call was GetAll, %NULL will be returned. a #GDBusPropertyInfo or %NULL A #GDBusMethodInvocation Gets the bus name that invoked the method. A string. Do not free, it is owned by @invocation. A #GDBusMethodInvocation. Gets the @user_data #gpointer passed to g_dbus_connection_register_object(). A #gpointer. A #GDBusMethodInvocation. Finishes handling a D-Bus method call by returning an error. This method will take ownership of @invocation. See #GDBusInterfaceVTable for more information about the ownership of @invocation. A #GDBusMethodInvocation. A valid D-Bus error name. A valid D-Bus error message. Finishes handling a D-Bus method call by returning an error. See g_dbus_error_encode_gerror() for details about what error name will be returned on the wire. In a nutshell, if the given error is registered using g_dbus_error_register_error() the name given during registration is used. Otherwise, a name of the form `org.gtk.GDBus.UnmappedGError.Quark...` is used. This provides transparent mapping of #GError between applications using GDBus. If you are writing an application intended to be portable, always register errors with g_dbus_error_register_error() or use g_dbus_method_invocation_return_dbus_error(). This method will take ownership of @invocation. See #GDBusInterfaceVTable for more information about the ownership of @invocation. Since 2.48, if the method call requested for a reply not to be sent then this call will free @invocation but otherwise do nothing (as per the recommendations of the D-Bus specification). A #GDBusMethodInvocation. A #GQuark for the #GError error domain. The error code. printf()-style format. Parameters for @format. Like g_dbus_method_invocation_return_error() but without printf()-style formatting. This method will take ownership of @invocation. See #GDBusInterfaceVTable for more information about the ownership of @invocation. A #GDBusMethodInvocation. A #GQuark for the #GError error domain. The error code. The error message. Like g_dbus_method_invocation_return_error() but intended for language bindings. This method will take ownership of @invocation. See #GDBusInterfaceVTable for more information about the ownership of @invocation. A #GDBusMethodInvocation. A #GQuark for the #GError error domain. The error code. printf()-style format. #va_list of parameters for @format. Like g_dbus_method_invocation_return_error() but takes a #GError instead of the error domain, error code and message. This method will take ownership of @invocation. See #GDBusInterfaceVTable for more information about the ownership of @invocation. A #GDBusMethodInvocation. A #GError. Finishes handling a D-Bus method call by returning @parameters. If the @parameters GVariant is floating, it is consumed. It is an error if @parameters is not of the right format: it must be a tuple containing the out-parameters of the D-Bus method. Even if the method has a single out-parameter, it must be contained in a tuple. If the method has no out-parameters, @parameters may be %NULL or an empty tuple. |[<!-- language="C" --> GDBusMethodInvocation *invocation = some_invocation; g_autofree gchar *result_string = NULL; g_autoptr (GError) error = NULL; result_string = calculate_result (&error); if (error != NULL) g_dbus_method_invocation_return_gerror (invocation, error); else g_dbus_method_invocation_return_value (invocation, g_variant_new ("(s)", result_string)); // Do not free @invocation here; returning a value does that ]| This method will take ownership of @invocation. See #GDBusInterfaceVTable for more information about the ownership of @invocation. Since 2.48, if the method call requested for a reply not to be sent then this call will sink @parameters and free @invocation, but otherwise do nothing (as per the recommendations of the D-Bus specification). A #GDBusMethodInvocation. A #GVariant tuple with out parameters for the method or %NULL if not passing any parameters. Like g_dbus_method_invocation_return_value() but also takes a #GUnixFDList. This method is only available on UNIX. This method will take ownership of @invocation. See #GDBusInterfaceVTable for more information about the ownership of @invocation. A #GDBusMethodInvocation. A #GVariant tuple with out parameters for the method or %NULL if not passing any parameters. A #GUnixFDList or %NULL. Like g_dbus_method_invocation_return_gerror() but takes ownership of @error so the caller does not need to free it. This method will take ownership of @invocation. See #GDBusInterfaceVTable for more information about the ownership of @invocation. A #GDBusMethodInvocation. A #GError. Information about nodes in a remote object hierarchy. The reference count or -1 if statically allocated. 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. A pointer to a %NULL-terminated array of pointers to #GDBusInterfaceInfo structures or %NULL if there are no interfaces. A pointer to a %NULL-terminated array of pointers to #GDBusNodeInfo structures or %NULL if there are no nodes. A pointer to a %NULL-terminated array of pointers to #GDBusAnnotationInfo structures or %NULL if there are no annotations. Parses @xml_data and returns a #GDBusNodeInfo representing the data. The introspection XML must contain exactly one top-level <node> element. Note that this routine is using a [GMarkup][glib-Simple-XML-Subset-Parser.description]-based parser that only accepts a subset of valid XML documents. A #GDBusNodeInfo structure or %NULL if @error is set. Free with g_dbus_node_info_unref(). Valid D-Bus introspection XML. Appends an XML representation of @info (and its children) to @string_builder. This function is typically used for generating introspection XML documents at run-time for handling the `org.freedesktop.DBus.Introspectable.Introspect` method. A #GDBusNodeInfo. Indentation level. A #GString to to append XML data to. Looks up information about an interface. The cost of this function is O(n) in number of interfaces. A #GDBusInterfaceInfo or %NULL if not found. Do not free, it is owned by @info. A #GDBusNodeInfo. A D-Bus interface name. If @info is statically allocated does nothing. Otherwise increases the reference count. The same @info. A #GDBusNodeInfo If @info is statically allocated, does nothing. Otherwise decreases the reference count of @info. When its reference count drops to 0, the memory used is freed. A #GDBusNodeInfo. The #GDBusObject type is the base type for D-Bus objects on both the service side (see #GDBusObjectSkeleton) and the client side (see #GDBusObjectProxy). It is essentially just a container of interfaces. Gets the D-Bus interface with name @interface_name associated with @object, if any. %NULL if not found, otherwise a #GDBusInterface that must be freed with g_object_unref(). A #GDBusObject. A D-Bus interface name. Gets the D-Bus interfaces associated with @object. A list of #GDBusInterface instances. The returned list must be freed by g_list_free() after each element has been freed with g_object_unref(). A #GDBusObject. Gets the object path for @object. A string owned by @object. Do not free. A #GDBusObject. Gets the D-Bus interface with name @interface_name associated with @object, if any. %NULL if not found, otherwise a #GDBusInterface that must be freed with g_object_unref(). A #GDBusObject. A D-Bus interface name. Gets the D-Bus interfaces associated with @object. A list of #GDBusInterface instances. The returned list must be freed by g_list_free() after each element has been freed with g_object_unref(). A #GDBusObject. Gets the object path for @object. A string owned by @object. Do not free. A #GDBusObject. Emitted when @interface is added to @object. The #GDBusInterface that was added. Emitted when @interface is removed from @object. The #GDBusInterface that was removed. Base object type for D-Bus objects. The parent interface. A string owned by @object. Do not free. A #GDBusObject. A list of #GDBusInterface instances. The returned list must be freed by g_list_free() after each element has been freed with g_object_unref(). A #GDBusObject. %NULL if not found, otherwise a #GDBusInterface that must be freed with g_object_unref(). A #GDBusObject. A D-Bus interface name. The #GDBusObjectManager type is the base type for service- and client-side implementations of the standardized [org.freedesktop.DBus.ObjectManager](http://dbus.freedesktop.org/doc/dbus-specification.html#standard-interfaces-objectmanager) interface. See #GDBusObjectManagerClient for the client-side implementation and #GDBusObjectManagerServer for the service-side implementation. Gets the interface proxy for @interface_name at @object_path, if any. A #GDBusInterface instance or %NULL. Free with g_object_unref(). A #GDBusObjectManager. Object path to look up. D-Bus interface name to look up. Gets the #GDBusObjectProxy at @object_path, if any. A #GDBusObject or %NULL. Free with g_object_unref(). A #GDBusObjectManager. Object path to look up. Gets the object path that @manager is for. A string owned by @manager. Do not free. A #GDBusObjectManager. Gets all #GDBusObject objects known to @manager. A list of #GDBusObject objects. The returned list should be freed with g_list_free() after each element has been freed with g_object_unref(). A #GDBusObjectManager. Gets the interface proxy for @interface_name at @object_path, if any. A #GDBusInterface instance or %NULL. Free with g_object_unref(). A #GDBusObjectManager. Object path to look up. D-Bus interface name to look up. Gets the #GDBusObjectProxy at @object_path, if any. A #GDBusObject or %NULL. Free with g_object_unref(). A #GDBusObjectManager. Object path to look up. Gets the object path that @manager is for. A string owned by @manager. Do not free. A #GDBusObjectManager. Gets all #GDBusObject objects known to @manager. A list of #GDBusObject objects. The returned list should be freed with g_list_free() after each element has been freed with g_object_unref(). A #GDBusObjectManager. Emitted when @interface is added to @object. This signal exists purely as a convenience to avoid having to connect signals to all objects managed by @manager. The #GDBusObject on which an interface was added. The #GDBusInterface that was added. Emitted when @interface has been removed from @object. This signal exists purely as a convenience to avoid having to connect signals to all objects managed by @manager. The #GDBusObject on which an interface was removed. The #GDBusInterface that was removed. Emitted when @object is added to @manager. The #GDBusObject that was added. Emitted when @object is removed from @manager. The #GDBusObject that was removed. #GDBusObjectManagerClient is used to create, monitor and delete object proxies for remote objects exported by a #GDBusObjectManagerServer (or any code implementing the [org.freedesktop.DBus.ObjectManager](http://dbus.freedesktop.org/doc/dbus-specification.html#standard-interfaces-objectmanager) interface). Once an instance of this type has been created, you can connect to the #GDBusObjectManager::object-added and #GDBusObjectManager::object-removed signals and inspect the #GDBusObjectProxy objects returned by g_dbus_object_manager_get_objects(). If the name for a #GDBusObjectManagerClient is not owned by anyone at object construction time, the default behavior is to request the message bus to launch an owner for the name. This behavior can be disabled using the %G_DBUS_OBJECT_MANAGER_CLIENT_FLAGS_DO_NOT_AUTO_START flag. It's also worth noting that this only works if the name of interest is activatable in the first place. E.g. in some cases it is not possible to launch an owner for the requested name. In this case, #GDBusObjectManagerClient object construction still succeeds but there will be no object proxies (e.g. g_dbus_object_manager_get_objects() returns the empty list) and the #GDBusObjectManagerClient:name-owner property is %NULL. The owner of the requested name can come and go (for example consider a system service being restarted) – #GDBusObjectManagerClient handles this case too; simply connect to the #GObject::notify signal to watch for changes on the #GDBusObjectManagerClient:name-owner property. When the name owner vanishes, the behavior is that #GDBusObjectManagerClient:name-owner is set to %NULL (this includes emission of the #GObject::notify signal) and then #GDBusObjectManager::object-removed signals are synthesized for all currently existing object proxies. Since #GDBusObjectManagerClient:name-owner is %NULL when this happens, you can use this information to disambiguate a synthesized signal from a genuine signal caused by object removal on the remote #GDBusObjectManager. Similarly, when a new name owner appears, #GDBusObjectManager::object-added signals are synthesized while #GDBusObjectManagerClient:name-owner is still %NULL. Only when all object proxies have been added, the #GDBusObjectManagerClient:name-owner is set to the new name owner (this includes emission of the #GObject::notify signal). Furthermore, you are guaranteed that #GDBusObjectManagerClient:name-owner will alternate between a name owner (e.g. `:1.42`) and %NULL even in the case where the name of interest is atomically replaced Ultimately, #GDBusObjectManagerClient is used to obtain #GDBusProxy instances. All signals (including the org.freedesktop.DBus.Properties::PropertiesChanged signal) delivered to #GDBusProxy instances are guaranteed to originate from the name owner. This guarantee along with the behavior described above, means that certain race conditions including the "half the proxy is from the old owner and the other half is from the new owner" problem cannot happen. To avoid having the application connect to signals on the returned #GDBusObjectProxy and #GDBusProxy objects, the #GDBusObject::interface-added, #GDBusObject::interface-removed, #GDBusProxy::g-properties-changed and #GDBusProxy::g-signal signals are also emitted on the #GDBusObjectManagerClient instance managing these objects. The signals emitted are #GDBusObjectManager::interface-added, #GDBusObjectManager::interface-removed, #GDBusObjectManagerClient::interface-proxy-properties-changed and #GDBusObjectManagerClient::interface-proxy-signal. Note that all callbacks and signals are emitted in the [thread-default main context][g-main-context-push-thread-default] that the #GDBusObjectManagerClient object was constructed in. Additionally, the #GDBusObjectProxy and #GDBusProxy objects originating from the #GDBusObjectManagerClient object will be created in the same context and, consequently, will deliver signals in the same main loop. Finishes an operation started with g_dbus_object_manager_client_new(). A #GDBusObjectManagerClient object or %NULL if @error is set. Free with g_object_unref(). A #GAsyncResult obtained from the #GAsyncReadyCallback passed to g_dbus_object_manager_client_new(). Finishes an operation started with g_dbus_object_manager_client_new_for_bus(). A #GDBusObjectManagerClient object or %NULL if @error is set. Free with g_object_unref(). A #GAsyncResult obtained from the #GAsyncReadyCallback passed to g_dbus_object_manager_client_new_for_bus(). Like g_dbus_object_manager_client_new_sync() but takes a #GBusType instead of a #GDBusConnection. This is a synchronous failable constructor - the calling thread is blocked until a reply is received. See g_dbus_object_manager_client_new_for_bus() for the asynchronous version. A #GDBusObjectManagerClient object or %NULL if @error is set. Free with g_object_unref(). A #GBusType. Zero or more flags from the #GDBusObjectManagerClientFlags enumeration. The owner of the control object (unique or well-known name). The object path of the control object. A #GDBusProxyTypeFunc function or %NULL to always construct #GDBusProxy proxies. User data to pass to @get_proxy_type_func. Free function for @get_proxy_type_user_data or %NULL. A #GCancellable or %NULL Creates a new #GDBusObjectManagerClient object. This is a synchronous failable constructor - the calling thread is blocked until a reply is received. See g_dbus_object_manager_client_new() for the asynchronous version. A #GDBusObjectManagerClient object or %NULL if @error is set. Free with g_object_unref(). A #GDBusConnection. Zero or more flags from the #GDBusObjectManagerClientFlags enumeration. The owner of the control object (unique or well-known name), or %NULL when not using a message bus connection. The object path of the control object. A #GDBusProxyTypeFunc function or %NULL to always construct #GDBusProxy proxies. User data to pass to @get_proxy_type_func. Free function for @get_proxy_type_user_data or %NULL. A #GCancellable or %NULL Asynchronously creates a new #GDBusObjectManagerClient object. This is an asynchronous failable constructor. When the result is ready, @callback will be invoked in the [thread-default main context][g-main-context-push-thread-default] of the thread you are calling this method from. You can then call g_dbus_object_manager_client_new_finish() to get the result. See g_dbus_object_manager_client_new_sync() for the synchronous version. A #GDBusConnection. Zero or more flags from the #GDBusObjectManagerClientFlags enumeration. The owner of the control object (unique or well-known name). The object path of the control object. A #GDBusProxyTypeFunc function or %NULL to always construct #GDBusProxy proxies. User data to pass to @get_proxy_type_func. Free function for @get_proxy_type_user_data or %NULL. A #GCancellable or %NULL A #GAsyncReadyCallback to call when the request is satisfied. The data to pass to @callback. Like g_dbus_object_manager_client_new() but takes a #GBusType instead of a #GDBusConnection. This is an asynchronous failable constructor. When the result is ready, @callback will be invoked in the [thread-default main loop][g-main-context-push-thread-default] of the thread you are calling this method from. You can then call g_dbus_object_manager_client_new_for_bus_finish() to get the result. See g_dbus_object_manager_client_new_for_bus_sync() for the synchronous version. A #GBusType. Zero or more flags from the #GDBusObjectManagerClientFlags enumeration. The owner of the control object (unique or well-known name). The object path of the control object. A #GDBusProxyTypeFunc function or %NULL to always construct #GDBusProxy proxies. User data to pass to @get_proxy_type_func. Free function for @get_proxy_type_user_data or %NULL. A #GCancellable or %NULL A #GAsyncReadyCallback to call when the request is satisfied. The data to pass to @callback. Gets the #GDBusConnection used by @manager. A #GDBusConnection object. Do not free, the object belongs to @manager. A #GDBusObjectManagerClient Gets the flags that @manager was constructed with. Zero of more flags from the #GDBusObjectManagerClientFlags enumeration. A #GDBusObjectManagerClient Gets the name that @manager is for, or %NULL if not a message bus connection. A unique or well-known name. Do not free, the string belongs to @manager. A #GDBusObjectManagerClient The unique name that owns the name that @manager is for or %NULL if no-one currently owns that name. You can connect to the #GObject::notify signal to track changes to the #GDBusObjectManagerClient:name-owner property. The name owner or %NULL if no name owner exists. Free with g_free(). A #GDBusObjectManagerClient. If this property is not %G_BUS_TYPE_NONE, then #GDBusObjectManagerClient:connection must be %NULL and will be set to the #GDBusConnection obtained by calling g_bus_get() with the value of this property. The #GDBusConnection to use. Flags from the #GDBusObjectManagerClientFlags enumeration. A #GDestroyNotify for the #gpointer user_data in #GDBusObjectManagerClient:get-proxy-type-user-data. The #GDBusProxyTypeFunc to use when determining what #GType to use for interface proxies or %NULL. The #gpointer user_data to pass to #GDBusObjectManagerClient:get-proxy-type-func. The well-known name or unique name that the manager is for. The unique name that owns #GDBusObjectManagerClient:name or %NULL if no-one is currently owning the name. Connect to the #GObject::notify signal to track changes to this property. The object path the manager is for. Emitted when one or more D-Bus properties on proxy changes. The local cache has already been updated when this signal fires. Note that both @changed_properties and @invalidated_properties are guaranteed to never be %NULL (either may be empty though). This signal exists purely as a convenience to avoid having to connect signals to all interface proxies managed by @manager. This signal is emitted in the [thread-default main context][g-main-context-push-thread-default] that @manager was constructed in. The #GDBusObjectProxy on which an interface has properties that are changing. The #GDBusProxy that has properties that are changing. A #GVariant containing the properties that changed (type: `a{sv}`). A %NULL terminated array of properties that were invalidated. Emitted when a D-Bus signal is received on @interface_proxy. This signal exists purely as a convenience to avoid having to connect signals to all interface proxies managed by @manager. This signal is emitted in the [thread-default main context][g-main-context-push-thread-default] that @manager was constructed in. The #GDBusObjectProxy on which an interface is emitting a D-Bus signal. The #GDBusProxy that is emitting a D-Bus signal. The sender of the signal or NULL if the connection is not a bus connection. The signal name. A #GVariant tuple with parameters for the signal. Class structure for #GDBusObjectManagerClient. The parent class. Flags used when constructing a #GDBusObjectManagerClient. No flags set. If not set and the manager is for a well-known name, then request the bus to launch an owner for the name if no-one owns the name. This flag can only be used in managers for well-known names. Base type for D-Bus object managers. The parent interface. A string owned by @manager. Do not free. A #GDBusObjectManager. A list of #GDBusObject objects. The returned list should be freed with g_list_free() after each element has been freed with g_object_unref(). A #GDBusObjectManager. A #GDBusObject or %NULL. Free with g_object_unref(). A #GDBusObjectManager. Object path to look up. A #GDBusInterface instance or %NULL. Free with g_object_unref(). A #GDBusObjectManager. Object path to look up. D-Bus interface name to look up. #GDBusObjectManagerServer is used to export #GDBusObject instances using the standardized [org.freedesktop.DBus.ObjectManager](http://dbus.freedesktop.org/doc/dbus-specification.html#standard-interfaces-objectmanager) interface. For example, remote D-Bus clients can get all objects and properties in a single call. Additionally, any change in the object hierarchy is broadcast using signals. This means that D-Bus clients can keep caches up to date by only listening to D-Bus signals. The recommended path to export an object manager at is the path form of the well-known name of a D-Bus service, or below. For example, if a D-Bus service is available at the well-known name `net.example.ExampleService1`, the object manager should typically be exported at `/net/example/ExampleService1`, or below (to allow for multiple object managers in a service). It is supported, but not recommended, to export an object manager at the root path, `/`. See #GDBusObjectManagerClient for the client-side code that is intended to be used with #GDBusObjectManagerServer or any D-Bus object implementing the org.freedesktop.DBus.ObjectManager interface. Creates a new #GDBusObjectManagerServer object. The returned server isn't yet exported on any connection. To do so, use g_dbus_object_manager_server_set_connection(). Normally you want to export all of your objects before doing so to avoid [InterfacesAdded](http://dbus.freedesktop.org/doc/dbus-specification.html#standard-interfaces-objectmanager) signals being emitted. A #GDBusObjectManagerServer object. Free with g_object_unref(). The object path to export the manager object at. Exports @object on @manager. If there is already a #GDBusObject exported at the object path, then the old object is removed. The object path for @object must be in the hierarchy rooted by the object path for @manager. Note that @manager will take a reference on @object for as long as it is exported. A #GDBusObjectManagerServer. A #GDBusObjectSkeleton. Like g_dbus_object_manager_server_export() but appends a string of the form _N (with N being a natural number) to @object's object path if an object with the given path already exists. As such, the #GDBusObjectProxy:g-object-path property of @object may be modified. A #GDBusObjectManagerServer. An object. Gets the #GDBusConnection used by @manager. A #GDBusConnection object or %NULL if @manager isn't exported on a connection. The returned object should be freed with g_object_unref(). A #GDBusObjectManagerServer Returns whether @object is currently exported on @manager. %TRUE if @object is exported A #GDBusObjectManagerServer. An object. Exports all objects managed by @manager on @connection. If @connection is %NULL, stops exporting objects. A #GDBusObjectManagerServer. A #GDBusConnection or %NULL. If @manager has an object at @path, removes the object. Otherwise does nothing. Note that @object_path must be in the hierarchy rooted by the object path for @manager. %TRUE if object at @object_path was removed, %FALSE otherwise. A #GDBusObjectManagerServer. An object path. The #GDBusConnection to export objects on. The object path to register the manager object at. Class structure for #GDBusObjectManagerServer. The parent class. A #GDBusObjectProxy is an object used to represent a remote object with one or more D-Bus interfaces. Normally, you don't instantiate a #GDBusObjectProxy yourself - typically #GDBusObjectManagerClient is used to obtain it. Creates a new #GDBusObjectProxy for the given connection and object path. a new #GDBusObjectProxy a #GDBusConnection the object path Gets the connection that @proxy is for. A #GDBusConnection. Do not free, the object is owned by @proxy. a #GDBusObjectProxy The connection of the proxy. The object path of the proxy. Class structure for #GDBusObjectProxy. The parent class. A #GDBusObjectSkeleton instance is essentially a group of D-Bus interfaces. The set of exported interfaces on the object may be dynamic and change at runtime. This type is intended to be used with #GDBusObjectManager. Creates a new #GDBusObjectSkeleton. A #GDBusObjectSkeleton. Free with g_object_unref(). An object path. Adds @interface_ to @object. If @object already contains a #GDBusInterfaceSkeleton with the same interface name, it is removed before @interface_ is added. Note that @object takes its own reference on @interface_ and holds it until removed. A #GDBusObjectSkeleton. A #GDBusInterfaceSkeleton. This method simply calls g_dbus_interface_skeleton_flush() on all interfaces belonging to @object. See that method for when flushing is useful. A #GDBusObjectSkeleton. Removes @interface_ from @object. A #GDBusObjectSkeleton. A #GDBusInterfaceSkeleton. Removes the #GDBusInterface with @interface_name from @object. If no D-Bus interface of the given interface exists, this function does nothing. A #GDBusObjectSkeleton. A D-Bus interface name. Sets the object path for @object. A #GDBusObjectSkeleton. A valid D-Bus object path. The object path where the object is exported. Emitted when a method is invoked by a remote caller and used to determine if the method call is authorized. This signal is like #GDBusInterfaceSkeleton's #GDBusInterfaceSkeleton::g-authorize-method signal, except that it is for the enclosing object. The default class handler just returns %TRUE. %TRUE if the call is authorized, %FALSE otherwise. The #GDBusInterfaceSkeleton that @invocation is for. A #GDBusMethodInvocation. Class structure for #GDBusObjectSkeleton. The parent class. Information about a D-Bus property on a D-Bus interface. The reference count or -1 if statically allocated. The name of the D-Bus property, e.g. "SupportedFilesystems". The D-Bus signature of the property (a single complete type). Access control flags for the property. A pointer to a %NULL-terminated array of pointers to #GDBusAnnotationInfo structures or %NULL if there are no annotations. If @info is statically allocated does nothing. Otherwise increases the reference count. The same @info. A #GDBusPropertyInfo If @info is statically allocated, does nothing. Otherwise decreases the reference count of @info. When its reference count drops to 0, the memory used is freed. A #GDBusPropertyInfo. Flags describing the access control of a D-Bus property. No flags set. Property is readable. Property is writable. #GDBusProxy is a base class used for proxies to access a D-Bus interface on a remote object. A #GDBusProxy can be constructed for both well-known and unique names. By default, #GDBusProxy will cache all properties (and listen to changes) of the remote object, and proxy all signals that get emitted. This behaviour can be changed by passing suitable #GDBusProxyFlags when the proxy is created. If the proxy is for a well-known name, the property cache is flushed when the name owner vanishes and reloaded when a name owner appears. The unique name owner of the proxy's name is tracked and can be read from #GDBusProxy:g-name-owner. Connect to the #GObject::notify signal to get notified of changes. Additionally, only signals and property changes emitted from the current name owner are considered and calls are always sent to the current name owner. This avoids a number of race conditions when the name is lost by one owner and claimed by another. However, if no name owner currently exists, then calls will be sent to the well-known name which may result in the message bus launching an owner (unless %G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START is set). The generic #GDBusProxy::g-properties-changed and #GDBusProxy::g-signal signals are not very convenient to work with. Therefore, the recommended way of working with proxies is to subclass #GDBusProxy, and have more natural properties and signals in your derived class. This [example][gdbus-example-gdbus-codegen] shows how this can easily be done using the [gdbus-codegen][gdbus-codegen] tool. A #GDBusProxy instance can be used from multiple threads but note that all signals (e.g. #GDBusProxy::g-signal, #GDBusProxy::g-properties-changed and #GObject::notify) are emitted in the [thread-default main context][g-main-context-push-thread-default] of the thread where the instance was constructed. An example using a proxy for a well-known name can be found in [gdbus-example-watch-proxy.c](https://git.gnome.org/browse/glib/tree/gio/tests/gdbus-example-watch-proxy.c) Finishes creating a #GDBusProxy. A #GDBusProxy or %NULL if @error is set. Free with g_object_unref(). A #GAsyncResult obtained from the #GAsyncReadyCallback function passed to g_dbus_proxy_new(). Finishes creating a #GDBusProxy. A #GDBusProxy or %NULL if @error is set. Free with g_object_unref(). A #GAsyncResult obtained from the #GAsyncReadyCallback function passed to g_dbus_proxy_new_for_bus(). Like g_dbus_proxy_new_sync() but takes a #GBusType instead of a #GDBusConnection. #GDBusProxy is used in this [example][gdbus-wellknown-proxy]. A #GDBusProxy or %NULL if error is set. Free with g_object_unref(). A #GBusType. Flags used when constructing the proxy. A #GDBusInterfaceInfo specifying the minimal interface that @proxy conforms to or %NULL. A bus name (well-known or unique). An object path. A D-Bus interface name. A #GCancellable or %NULL. Creates a proxy for accessing @interface_name on the remote object at @object_path owned by @name at @connection and synchronously loads D-Bus properties unless the %G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES flag is used. If the %G_DBUS_PROXY_FLAGS_DO_NOT_CONNECT_SIGNALS flag is not set, also sets up match rules for signals. Connect to the #GDBusProxy::g-signal signal to handle signals from the remote object. If both %G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES and %G_DBUS_PROXY_FLAGS_DO_NOT_CONNECT_SIGNALS are set, this constructor is guaranteed to return immediately without blocking. If @name is a well-known name and the %G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START and %G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START_AT_CONSTRUCTION flags aren't set and no name owner currently exists, the message bus will be requested to launch a name owner for the name. This is a synchronous failable constructor. See g_dbus_proxy_new() and g_dbus_proxy_new_finish() for the asynchronous version. #GDBusProxy is used in this [example][gdbus-wellknown-proxy]. A #GDBusProxy or %NULL if error is set. Free with g_object_unref(). A #GDBusConnection. Flags used when constructing the proxy. A #GDBusInterfaceInfo specifying the minimal interface that @proxy conforms to or %NULL. A bus name (well-known or unique) or %NULL if @connection is not a message bus connection. An object path. A D-Bus interface name. A #GCancellable or %NULL. Creates a proxy for accessing @interface_name on the remote object at @object_path owned by @name at @connection and asynchronously loads D-Bus properties unless the %G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES flag is used. Connect to the #GDBusProxy::g-properties-changed signal to get notified about property changes. If the %G_DBUS_PROXY_FLAGS_DO_NOT_CONNECT_SIGNALS flag is not set, also sets up match rules for signals. Connect to the #GDBusProxy::g-signal signal to handle signals from the remote object. If both %G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES and %G_DBUS_PROXY_FLAGS_DO_NOT_CONNECT_SIGNALS are set, this constructor is guaranteed to complete immediately without blocking. If @name is a well-known name and the %G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START and %G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START_AT_CONSTRUCTION flags aren't set and no name owner currently exists, the message bus will be requested to launch a name owner for the name. This is a failable asynchronous constructor - when the proxy is ready, @callback will be invoked and you can use g_dbus_proxy_new_finish() to get the result. See g_dbus_proxy_new_sync() and for a synchronous version of this constructor. #GDBusProxy is used in this [example][gdbus-wellknown-proxy]. A #GDBusConnection. Flags used when constructing the proxy. A #GDBusInterfaceInfo specifying the minimal interface that @proxy conforms to or %NULL. A bus name (well-known or unique) or %NULL if @connection is not a message bus connection. An object path. A D-Bus interface name. A #GCancellable or %NULL. Callback function to invoke when the proxy is ready. User data to pass to @callback. Like g_dbus_proxy_new() but takes a #GBusType instead of a #GDBusConnection. #GDBusProxy is used in this [example][gdbus-wellknown-proxy]. A #GBusType. Flags used when constructing the proxy. A #GDBusInterfaceInfo specifying the minimal interface that @proxy conforms to or %NULL. A bus name (well-known or unique). An object path. A D-Bus interface name. A #GCancellable or %NULL. Callback function to invoke when the proxy is ready. User data to pass to @callback. Asynchronously invokes the @method_name method on @proxy. If @method_name contains any dots, then @name is split into interface and method name parts. This allows using @proxy for invoking methods on other interfaces. If the #GDBusConnection associated with @proxy is closed then the operation will fail with %G_IO_ERROR_CLOSED. If @cancellable is canceled, the operation will fail with %G_IO_ERROR_CANCELLED. If @parameters contains a value not compatible with the D-Bus protocol, the operation fails with %G_IO_ERROR_INVALID_ARGUMENT. If the @parameters #GVariant is floating, it is consumed. This allows convenient 'inline' use of g_variant_new(), e.g.: |[<!-- language="C" --> g_dbus_proxy_call (proxy, "TwoStrings", g_variant_new ("(ss)", "Thing One", "Thing Two"), G_DBUS_CALL_FLAGS_NONE, -1, NULL, (GAsyncReadyCallback) two_strings_done, &data); ]| If @proxy has an expected interface (see #GDBusProxy:g-interface-info) and @method_name is referenced by it, then the return value is checked against the return type. This is an asynchronous method. When the operation is finished, @callback will be invoked in the [thread-default main context][g-main-context-push-thread-default] of the thread you are calling this method from. You can then call g_dbus_proxy_call_finish() to get the result of the operation. See g_dbus_proxy_call_sync() for the synchronous version of this method. If @callback is %NULL then the D-Bus method call message will be sent with the %G_DBUS_MESSAGE_FLAGS_NO_REPLY_EXPECTED flag set. A #GDBusProxy. Name of method to invoke. A #GVariant tuple with parameters for the signal or %NULL if not passing parameters. Flags from the #GDBusCallFlags enumeration. The timeout in milliseconds (with %G_MAXINT meaning "infinite") or -1 to use the proxy default timeout. A #GCancellable or %NULL. A #GAsyncReadyCallback to call when the request is satisfied or %NULL if you don't care about the result of the method invocation. The data to pass to @callback. Finishes an operation started with g_dbus_proxy_call(). %NULL if @error is set. Otherwise a #GVariant tuple with return values. Free with g_variant_unref(). A #GDBusProxy. A #GAsyncResult obtained from the #GAsyncReadyCallback passed to g_dbus_proxy_call(). Synchronously invokes the @method_name method on @proxy. If @method_name contains any dots, then @name is split into interface and method name parts. This allows using @proxy for invoking methods on other interfaces. If the #GDBusConnection associated with @proxy is disconnected then the operation will fail with %G_IO_ERROR_CLOSED. If @cancellable is canceled, the operation will fail with %G_IO_ERROR_CANCELLED. If @parameters contains a value not compatible with the D-Bus protocol, the operation fails with %G_IO_ERROR_INVALID_ARGUMENT. If the @parameters #GVariant is floating, it is consumed. This allows convenient 'inline' use of g_variant_new(), e.g.: |[<!-- language="C" --> g_dbus_proxy_call_sync (proxy, "TwoStrings", g_variant_new ("(ss)", "Thing One", "Thing Two"), G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error); ]| The calling thread is blocked until a reply is received. See g_dbus_proxy_call() for the asynchronous version of this method. If @proxy has an expected interface (see #GDBusProxy:g-interface-info) and @method_name is referenced by it, then the return value is checked against the return type. %NULL if @error is set. Otherwise a #GVariant tuple with return values. Free with g_variant_unref(). A #GDBusProxy. Name of method to invoke. A #GVariant tuple with parameters for the signal or %NULL if not passing parameters. Flags from the #GDBusCallFlags enumeration. The timeout in milliseconds (with %G_MAXINT meaning "infinite") or -1 to use the proxy default timeout. A #GCancellable or %NULL. Like g_dbus_proxy_call() but also takes a #GUnixFDList object. This method is only available on UNIX. A #GDBusProxy. Name of method to invoke. A #GVariant tuple with parameters for the signal or %NULL if not passing parameters. Flags from the #GDBusCallFlags enumeration. The timeout in milliseconds (with %G_MAXINT meaning "infinite") or -1 to use the proxy default timeout. A #GUnixFDList or %NULL. A #GCancellable or %NULL. A #GAsyncReadyCallback to call when the request is satisfied or %NULL if you don't care about the result of the method invocation. The data to pass to @callback. Finishes an operation started with g_dbus_proxy_call_with_unix_fd_list(). %NULL if @error is set. Otherwise a #GVariant tuple with return values. Free with g_variant_unref(). A #GDBusProxy. Return location for a #GUnixFDList or %NULL. A #GAsyncResult obtained from the #GAsyncReadyCallback passed to g_dbus_proxy_call_with_unix_fd_list(). Like g_dbus_proxy_call_sync() but also takes and returns #GUnixFDList objects. This method is only available on UNIX. %NULL if @error is set. Otherwise a #GVariant tuple with return values. Free with g_variant_unref(). A #GDBusProxy. Name of method to invoke. A #GVariant tuple with parameters for the signal or %NULL if not passing parameters. Flags from the #GDBusCallFlags enumeration. The timeout in milliseconds (with %G_MAXINT meaning "infinite") or -1 to use the proxy default timeout. A #GUnixFDList or %NULL. Return location for a #GUnixFDList or %NULL. A #GCancellable or %NULL. Looks up the value for a property from the cache. This call does no blocking IO. If @proxy has an expected interface (see #GDBusProxy:g-interface-info) and @property_name is referenced by it, then @value is checked against the type of the property. A reference to the #GVariant instance that holds the value for @property_name or %NULL if the value is not in the cache. The returned reference must be freed with g_variant_unref(). A #GDBusProxy. Property name. Gets the names of all cached properties on @proxy. A %NULL-terminated array of strings or %NULL if @proxy has no cached properties. Free the returned array with g_strfreev(). A #GDBusProxy. Gets the connection @proxy is for. A #GDBusConnection owned by @proxy. Do not free. A #GDBusProxy. Gets the timeout to use if -1 (specifying default timeout) is passed as @timeout_msec in the g_dbus_proxy_call() and g_dbus_proxy_call_sync() functions. See the #GDBusProxy:g-default-timeout property for more details. Timeout to use for @proxy. A #GDBusProxy. Gets the flags that @proxy was constructed with. Flags from the #GDBusProxyFlags enumeration. A #GDBusProxy. Returns the #GDBusInterfaceInfo, if any, specifying the interface that @proxy conforms to. See the #GDBusProxy:g-interface-info property for more details. A #GDBusInterfaceInfo or %NULL. Do not unref the returned object, it is owned by @proxy. A #GDBusProxy Gets the D-Bus interface name @proxy is for. A string owned by @proxy. Do not free. A #GDBusProxy. Gets the name that @proxy was constructed for. A string owned by @proxy. Do not free. A #GDBusProxy. The unique name that owns the name that @proxy is for or %NULL if no-one currently owns that name. You may connect to the #GObject::notify signal to track changes to the #GDBusProxy:g-name-owner property. The name owner or %NULL if no name owner exists. Free with g_free(). A #GDBusProxy. Gets the object path @proxy is for. A string owned by @proxy. Do not free. A #GDBusProxy. If @value is not %NULL, sets the cached value for the property with name @property_name to the value in @value. If @value is %NULL, then the cached value is removed from the property cache. If @proxy has an expected interface (see #GDBusProxy:g-interface-info) and @property_name is referenced by it, then @value is checked against the type of the property. If the @value #GVariant is floating, it is consumed. This allows convenient 'inline' use of g_variant_new(), e.g. |[<!-- language="C" --> g_dbus_proxy_set_cached_property (proxy, "SomeProperty", g_variant_new ("(si)", "A String", 42)); ]| Normally you will not need to use this method since @proxy is tracking changes using the `org.freedesktop.DBus.Properties.PropertiesChanged` D-Bus signal. However, for performance reasons an object may decide to not use this signal for some properties and instead use a proprietary out-of-band mechanism to transmit changes. As a concrete example, consider an object with a property `ChatroomParticipants` which is an array of strings. Instead of transmitting the same (long) array every time the property changes, it is more efficient to only transmit the delta using e.g. signals `ChatroomParticipantJoined(String name)` and `ChatroomParticipantParted(String name)`. A #GDBusProxy Property name. Value for the property or %NULL to remove it from the cache. Sets the timeout to use if -1 (specifying default timeout) is passed as @timeout_msec in the g_dbus_proxy_call() and g_dbus_proxy_call_sync() functions. See the #GDBusProxy:g-default-timeout property for more details. A #GDBusProxy. Timeout in milliseconds. Ensure that interactions with @proxy conform to the given interface. See the #GDBusProxy:g-interface-info property for more details. A #GDBusProxy Minimum interface this proxy conforms to or %NULL to unset. If this property is not %G_BUS_TYPE_NONE, then #GDBusProxy:g-connection must be %NULL and will be set to the #GDBusConnection obtained by calling g_bus_get() with the value of this property. The #GDBusConnection the proxy is for. The timeout to use if -1 (specifying default timeout) is passed as @timeout_msec in the g_dbus_proxy_call() and g_dbus_proxy_call_sync() functions. This allows applications to set a proxy-wide timeout for all remote method invocations on the proxy. If this property is -1, the default timeout (typically 25 seconds) is used. If set to %G_MAXINT, then no timeout is used. Flags from the #GDBusProxyFlags enumeration. Ensure that interactions with this proxy conform to the given interface. This is mainly to ensure that malformed data received from the other peer is ignored. The given #GDBusInterfaceInfo is said to be the "expected interface". The checks performed are: - When completing a method call, if the type signature of the reply message isn't what's expected, the reply is discarded and the #GError is set to %G_IO_ERROR_INVALID_ARGUMENT. - Received signals that have a type signature mismatch are dropped and a warning is logged via g_warning(). - Properties received via the initial `GetAll()` call or via the `::PropertiesChanged` signal (on the [org.freedesktop.DBus.Properties](http://dbus.freedesktop.org/doc/dbus-specification.html#standard-interfaces-properties) interface) or set using g_dbus_proxy_set_cached_property() with a type signature mismatch are ignored and a warning is logged via g_warning(). Note that these checks are never done on methods, signals and properties that are not referenced in the given #GDBusInterfaceInfo, since extending a D-Bus interface on the service-side is not considered an ABI break. The D-Bus interface name the proxy is for. The well-known or unique name that the proxy is for. The unique name that owns #GDBusProxy:g-name or %NULL if no-one currently owns that name. You may connect to #GObject::notify signal to track changes to this property. The object path the proxy is for. Emitted when one or more D-Bus properties on @proxy changes. The local cache has already been updated when this signal fires. Note that both @changed_properties and @invalidated_properties are guaranteed to never be %NULL (either may be empty though). If the proxy has the flag %G_DBUS_PROXY_FLAGS_GET_INVALIDATED_PROPERTIES set, then @invalidated_properties will always be empty. This signal corresponds to the `PropertiesChanged` D-Bus signal on the `org.freedesktop.DBus.Properties` interface. A #GVariant containing the properties that changed (type: `a{sv}`) A %NULL terminated array of properties that was invalidated Emitted when a signal from the remote object and interface that @proxy is for, has been received. The sender of the signal or %NULL if the connection is not a bus connection. The name of the signal. A #GVariant tuple with parameters for the signal. Class structure for #GDBusProxy. Flags used when constructing an instance of a #GDBusProxy derived class. No flags set. Don't load properties. Don't connect to signals on the remote object. If the proxy is for a well-known name, do not ask the bus to launch an owner during proxy initialization or a method call. This flag is only meaningful in proxies for well-known names. 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. If the proxy is for a well-known name, do not ask the bus to launch an owner during proxy initialization, but allow it to be autostarted by a method call. This flag is only meaningful in proxies for well-known names, and only if %G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START is not also specified. Function signature for a function used to determine the #GType to use for an interface proxy (if @interface_name is not %NULL) or object proxy (if @interface_name is %NULL). This function is called in the [thread-default main loop][g-main-context-push-thread-default] that @manager was constructed in. A #GType to use for the remote object. The returned type must be a #GDBusProxy or #GDBusObjectProxy -derived type. A #GDBusObjectManagerClient. The object path of the remote object. The interface name of the remote object or %NULL if a #GDBusObjectProxy #GType is requested. User data. Flags used when sending #GDBusMessages on a #GDBusConnection. No flags set. Do not automatically assign a serial number from the #GDBusConnection object when sending a message. #GDBusServer is a helper for listening to and accepting D-Bus connections. This can be used to create a new D-Bus server, allowing two peers to use the D-Bus protocol for their own specialized communication. A server instance provided in this way will not perform message routing or implement the org.freedesktop.DBus interface. To just export an object on a well-known name on a message bus, such as the session or system bus, you should instead use g_bus_own_name(). An example of peer-to-peer communication with G-DBus can be found in [gdbus-example-peer.c](https://git.gnome.org/browse/glib/tree/gio/tests/gdbus-example-peer.c). Note that a minimal #GDBusServer will accept connections from any peer. In many use-cases it will be necessary to add a #GDBusAuthObserver that only accepts connections that have successfully authenticated as the same user that is running the #GDBusServer. Creates a new D-Bus server that listens on the first address in @address that works. Once constructed, you can use g_dbus_server_get_client_address() to get a D-Bus address string that clients can use to connect. To have control over the available authentication mechanisms and the users that are authorized to connect, it is strongly recommended to provide a non-%NULL #GDBusAuthObserver. Connect to the #GDBusServer::new-connection signal to handle incoming connections. The returned #GDBusServer isn't active - you have to start it with g_dbus_server_start(). #GDBusServer is used in this [example][gdbus-peer-to-peer]. This is a synchronous failable constructor. There is currently no asynchronous version. A #GDBusServer or %NULL if @error is set. Free with g_object_unref(). A D-Bus address. Flags from the #GDBusServerFlags enumeration. A D-Bus GUID. A #GDBusAuthObserver or %NULL. A #GCancellable or %NULL. Gets a [D-Bus address](https://dbus.freedesktop.org/doc/dbus-specification.html#addresses) string that can be used by clients to connect to @server. A D-Bus address string. Do not free, the string is owned by @server. A #GDBusServer. Gets the flags for @server. A set of flags from the #GDBusServerFlags enumeration. A #GDBusServer. Gets the GUID for @server. A D-Bus GUID. Do not free this string, it is owned by @server. A #GDBusServer. Gets whether @server is active. %TRUE if server is active, %FALSE otherwise. A #GDBusServer. Starts @server. A #GDBusServer. Stops @server. A #GDBusServer. Whether the server is currently active. The D-Bus address to listen on. A #GDBusAuthObserver object to assist in the authentication process or %NULL. The D-Bus address that clients can use. Flags from the #GDBusServerFlags enumeration. The guid of the server. Emitted when a new authenticated connection has been made. Use g_dbus_connection_get_peer_credentials() to figure out what identity (if any), was authenticated. If you want to accept the connection, take a reference to the @connection object and return %TRUE. When you are done with the connection call g_dbus_connection_close() and give up your reference. Note that the other peer may disconnect at any time - a typical thing to do when accepting a connection is to listen to the #GDBusConnection::closed signal. If #GDBusServer:flags contains %G_DBUS_SERVER_FLAGS_RUN_IN_THREAD then the signal is emitted in a new thread dedicated to the connection. Otherwise the signal is emitted in the [thread-default main context][g-main-context-push-thread-default] of the thread that @server was constructed in. You are guaranteed that signal handlers for this signal runs before incoming messages on @connection are processed. This means that it's suitable to call g_dbus_connection_register_object() or similar from the signal handler. %TRUE to claim @connection, %FALSE to let other handlers run. A #GDBusConnection for the new connection. Flags used when creating a #GDBusServer. No flags set. All #GDBusServer::new-connection signals will run in separated dedicated threads (see signal for details). Allow the anonymous authentication method. Signature for callback function used in g_dbus_connection_signal_subscribe(). A #GDBusConnection. The unique bus name of the sender of the signal, or %NULL on a peer-to-peer D-Bus connection. The object path that the signal was emitted on. The name of the interface. The name of the signal. A #GVariant tuple with parameters for the signal. User data passed when subscribing to the signal. Flags used when subscribing to signals via g_dbus_connection_signal_subscribe(). No flags set. Don't actually send the AddMatch D-Bus call for this signal subscription. This gives you more control over which match rules you add (but you must add them manually). Match first arguments that contain a bus or interface name with the given namespace. Match first arguments that contain an object path that is either equivalent to the given path, or one of the paths is a subpath of the other. Information about a signal on a D-Bus interface. The reference count or -1 if statically allocated. The name of the D-Bus signal, e.g. "NameOwnerChanged". A pointer to a %NULL-terminated array of pointers to #GDBusArgInfo structures or %NULL if there are no arguments. A pointer to a %NULL-terminated array of pointers to #GDBusAnnotationInfo structures or %NULL if there are no annotations. If @info is statically allocated does nothing. Otherwise increases the reference count. The same @info. A #GDBusSignalInfo If @info is statically allocated, does nothing. Otherwise decreases the reference count of @info. When its reference count drops to 0, the memory used is freed. A #GDBusSignalInfo. The type of the @dispatch function in #GDBusSubtreeVTable. Subtrees are flat. @node, if non-%NULL, is always exactly one segment of the object path (ie: it never contains a slash). A #GDBusInterfaceVTable or %NULL if you don't want to handle the methods. A #GDBusConnection. The unique bus name of the remote caller. The object path that was registered with g_dbus_connection_register_subtree(). The D-Bus interface name that the method call or property access is for. A node that is a child of @object_path (relative to @object_path) or %NULL for the root of the subtree. Return location for user data to pass to functions in the returned #GDBusInterfaceVTable. The @user_data #gpointer passed to g_dbus_connection_register_subtree(). The type of the @enumerate function in #GDBusSubtreeVTable. This function is called when generating introspection data and also when preparing to dispatch incoming messages in the event that the %G_DBUS_SUBTREE_FLAGS_DISPATCH_TO_UNENUMERATED_NODES flag is not specified (ie: to verify that the object path is valid). Hierarchies are not supported; the items that you return should not contain the '/' character. The return value will be freed with g_strfreev(). A newly allocated array of strings for node names that are children of @object_path. A #GDBusConnection. The unique bus name of the remote caller. The object path that was registered with g_dbus_connection_register_subtree(). The @user_data #gpointer passed to g_dbus_connection_register_subtree(). Flags passed to g_dbus_connection_register_subtree(). No flags set. Method calls to objects not in the enumerated range will still be dispatched. This is useful if you want to dynamically spawn objects in the subtree. The type of the @introspect function in #GDBusSubtreeVTable. Subtrees are flat. @node, if non-%NULL, is always exactly one segment of the object path (ie: it never contains a slash). This function should return %NULL to indicate that there is no object at this node. If this function returns non-%NULL, the return value is expected to be a %NULL-terminated array of pointers to #GDBusInterfaceInfo structures describing the interfaces implemented by @node. This array will have g_dbus_interface_info_unref() called on each item before being freed with g_free(). The difference between returning %NULL and an array containing zero items is that the standard DBus interfaces will returned to the remote introspector in the empty array case, but not in the %NULL case. A %NULL-terminated array of pointers to #GDBusInterfaceInfo, or %NULL. A #GDBusConnection. The unique bus name of the remote caller. The object path that was registered with g_dbus_connection_register_subtree(). A node that is a child of @object_path (relative to @object_path) or %NULL for the root of the subtree. The @user_data #gpointer passed to g_dbus_connection_register_subtree(). Virtual table for handling subtrees registered with g_dbus_connection_register_subtree(). Function for enumerating child nodes. Function for introspecting a child node. Function for dispatching a remote call on a child node. Extension point for default handler to URI association. See [Extending GIO][extending-gio]. The #GDesktopAppInfoLookup interface is deprecated and unused by GIO. The string used to obtain a Unix device path with g_drive_get_identifier(). Data input stream implements #GInputStream and includes functions for reading structured data directly from a binary input stream. Creates a new data input stream for the @base_stream. a new #GDataInputStream. a #GInputStream. Gets the byte order for the data input stream. the @stream's current #GDataStreamByteOrder. a given #GDataInputStream. Gets the current newline type for the @stream. #GDataStreamNewlineType for the given @stream. a given #GDataInputStream. Reads an unsigned 8-bit/1-byte value from @stream. an unsigned 8-bit/1-byte value read from the @stream or `0` if an error occurred. a given #GDataInputStream. optional #GCancellable object, %NULL to ignore. Reads a 16-bit/2-byte value from @stream. In order to get the correct byte order for this read operation, see g_data_input_stream_get_byte_order() and g_data_input_stream_set_byte_order(). a signed 16-bit/2-byte value read from @stream or `0` if an error occurred. a given #GDataInputStream. optional #GCancellable object, %NULL to ignore. Reads a signed 32-bit/4-byte value from @stream. In order to get the correct byte order for this read operation, see g_data_input_stream_get_byte_order() and g_data_input_stream_set_byte_order(). If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. a signed 32-bit/4-byte value read from the @stream or `0` if an error occurred. a given #GDataInputStream. optional #GCancellable object, %NULL to ignore. Reads a 64-bit/8-byte value from @stream. In order to get the correct byte order for this read operation, see g_data_input_stream_get_byte_order() and g_data_input_stream_set_byte_order(). If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. a signed 64-bit/8-byte value read from @stream or `0` if an error occurred. a given #GDataInputStream. optional #GCancellable object, %NULL to ignore. Reads a line from the data input stream. Note that no encoding checks or conversion is performed; the input is not guaranteed to be UTF-8, and may in fact have embedded NUL characters. If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. a NUL terminated byte array with the line that was read in (without the newlines). Set @length to a #gsize to get the length of the read line. On an error, it will return %NULL and @error will be set. If there's no content to read, it will still return %NULL, but @error won't be set. a given #GDataInputStream. a #gsize to get the length of the data read in. optional #GCancellable object, %NULL to ignore. The asynchronous version of g_data_input_stream_read_line(). It is an error to have two outstanding calls to this function. When the operation is finished, @callback will be called. You can then call g_data_input_stream_read_line_finish() to get the result of the operation. a given #GDataInputStream. the [I/O priority][io-priority] of the request optional #GCancellable object, %NULL to ignore. callback to call when the request is satisfied. the data to pass to callback function. Finish an asynchronous call started by g_data_input_stream_read_line_async(). Note the warning about string encoding in g_data_input_stream_read_line() applies here as well. a NUL-terminated byte array with the line that was read in (without the newlines). Set @length to a #gsize to get the length of the read line. On an error, it will return %NULL and @error will be set. If there's no content to read, it will still return %NULL, but @error won't be set. a given #GDataInputStream. the #GAsyncResult that was provided to the callback. a #gsize to get the length of the data read in. Finish an asynchronous call started by g_data_input_stream_read_line_async(). a string with the line that was read in (without the newlines). Set @length to a #gsize to get the length of the read line. On an error, it will return %NULL and @error will be set. For UTF-8 conversion errors, the set error domain is %G_CONVERT_ERROR. If there's no content to read, it will still return %NULL, but @error won't be set. a given #GDataInputStream. the #GAsyncResult that was provided to the callback. a #gsize to get the length of the data read in. Reads a UTF-8 encoded line from the data input stream. If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. a NUL terminated UTF-8 string with the line that was read in (without the newlines). Set @length to a #gsize to get the length of the read line. On an error, it will return %NULL and @error will be set. For UTF-8 conversion errors, the set error domain is %G_CONVERT_ERROR. If there's no content to read, it will still return %NULL, but @error won't be set. a given #GDataInputStream. a #gsize to get the length of the data read in. optional #GCancellable object, %NULL to ignore. Reads an unsigned 16-bit/2-byte value from @stream. In order to get the correct byte order for this read operation, see g_data_input_stream_get_byte_order() and g_data_input_stream_set_byte_order(). an unsigned 16-bit/2-byte value read from the @stream or `0` if an error occurred. a given #GDataInputStream. optional #GCancellable object, %NULL to ignore. Reads an unsigned 32-bit/4-byte value from @stream. In order to get the correct byte order for this read operation, see g_data_input_stream_get_byte_order() and g_data_input_stream_set_byte_order(). If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. an unsigned 32-bit/4-byte value read from the @stream or `0` if an error occurred. a given #GDataInputStream. optional #GCancellable object, %NULL to ignore. Reads an unsigned 64-bit/8-byte value from @stream. In order to get the correct byte order for this read operation, see g_data_input_stream_get_byte_order(). If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. an unsigned 64-bit/8-byte read from @stream or `0` if an error occurred. a given #GDataInputStream. optional #GCancellable object, %NULL to ignore. Reads a string from the data input stream, up to the first occurrence of any of the stop characters. Note that, in contrast to g_data_input_stream_read_until_async(), this function consumes the stop character that it finds. Don't use this function in new code. Its functionality is inconsistent with g_data_input_stream_read_until_async(). Both functions will be marked as deprecated in a future release. Use g_data_input_stream_read_upto() instead, but note that that function does not consume the stop character. Use g_data_input_stream_read_upto() instead, which has more consistent behaviour regarding the stop character. a string with the data that was read before encountering any of the stop characters. Set @length to a #gsize to get the length of the string. This function will return %NULL on an error. a given #GDataInputStream. characters to terminate the read. a #gsize to get the length of the data read in. optional #GCancellable object, %NULL to ignore. The asynchronous version of g_data_input_stream_read_until(). It is an error to have two outstanding calls to this function. Note that, in contrast to g_data_input_stream_read_until(), this function does not consume the stop character that it finds. You must read it for yourself. When the operation is finished, @callback will be called. You can then call g_data_input_stream_read_until_finish() to get the result of the operation. Don't use this function in new code. Its functionality is inconsistent with g_data_input_stream_read_until(). Both functions will be marked as deprecated in a future release. Use g_data_input_stream_read_upto_async() instead. Use g_data_input_stream_read_upto_async() instead, which has more consistent behaviour regarding the stop character. a given #GDataInputStream. characters to terminate the read. the [I/O priority][io-priority] of the request optional #GCancellable object, %NULL to ignore. callback to call when the request is satisfied. the data to pass to callback function. Finish an asynchronous call started by g_data_input_stream_read_until_async(). Use g_data_input_stream_read_upto_finish() instead, which has more consistent behaviour regarding the stop character. a string with the data that was read before encountering any of the stop characters. Set @length to a #gsize to get the length of the string. This function will return %NULL on an error. a given #GDataInputStream. the #GAsyncResult that was provided to the callback. a #gsize to get the length of the data read in. Reads a string from the data input stream, up to the first occurrence of any of the stop characters. In contrast to g_data_input_stream_read_until(), this function does not consume the stop character. You have to use g_data_input_stream_read_byte() to get it before calling g_data_input_stream_read_upto() again. Note that @stop_chars may contain '\0' if @stop_chars_len is specified. The returned string will always be nul-terminated on success. a string with the data that was read before encountering any of the stop characters. Set @length to a #gsize to get the length of the string. This function will return %NULL on an error a #GDataInputStream characters to terminate the read length of @stop_chars. May be -1 if @stop_chars is nul-terminated a #gsize to get the length of the data read in optional #GCancellable object, %NULL to ignore The asynchronous version of g_data_input_stream_read_upto(). It is an error to have two outstanding calls to this function. In contrast to g_data_input_stream_read_until(), this function does not consume the stop character. You have to use g_data_input_stream_read_byte() to get it before calling g_data_input_stream_read_upto() again. Note that @stop_chars may contain '\0' if @stop_chars_len is specified. When the operation is finished, @callback will be called. You can then call g_data_input_stream_read_upto_finish() to get the result of the operation. a #GDataInputStream characters to terminate the read length of @stop_chars. May be -1 if @stop_chars is nul-terminated the [I/O priority][io-priority] of the request optional #GCancellable object, %NULL to ignore callback to call when the request is satisfied the data to pass to callback function Finish an asynchronous call started by g_data_input_stream_read_upto_async(). Note that this function does not consume the stop character. You have to use g_data_input_stream_read_byte() to get it before calling g_data_input_stream_read_upto_async() again. The returned string will always be nul-terminated on success. a string with the data that was read before encountering any of the stop characters. Set @length to a #gsize to get the length of the string. This function will return %NULL on an error. a #GDataInputStream the #GAsyncResult that was provided to the callback a #gsize to get the length of the data read in This function sets the byte order for the given @stream. All subsequent reads from the @stream will be read in the given @order. a given #GDataInputStream. a #GDataStreamByteOrder to set. Sets the newline type for the @stream. Note that using G_DATA_STREAM_NEWLINE_TYPE_ANY is slightly unsafe. If a read chunk ends in "CR" we must read an additional byte to know if this is "CR" or "CR LF", and this might block if there is no more data available. a #GDataInputStream. the type of new line return as #GDataStreamNewlineType. Data output stream implements #GOutputStream and includes functions for writing data directly to an output stream. Creates a new data output stream for @base_stream. #GDataOutputStream. a #GOutputStream. Gets the byte order for the stream. the #GDataStreamByteOrder for the @stream. a #GDataOutputStream. Puts a byte into the output stream. %TRUE if @data was successfully added to the @stream. a #GDataOutputStream. a #guchar. optional #GCancellable object, %NULL to ignore. Puts a signed 16-bit integer into the output stream. %TRUE if @data was successfully added to the @stream. a #GDataOutputStream. a #gint16. optional #GCancellable object, %NULL to ignore. Puts a signed 32-bit integer into the output stream. %TRUE if @data was successfully added to the @stream. a #GDataOutputStream. a #gint32. optional #GCancellable object, %NULL to ignore. Puts a signed 64-bit integer into the stream. %TRUE if @data was successfully added to the @stream. a #GDataOutputStream. a #gint64. optional #GCancellable object, %NULL to ignore. Puts a string into the output stream. %TRUE if @string was successfully added to the @stream. a #GDataOutputStream. a string. optional #GCancellable object, %NULL to ignore. Puts an unsigned 16-bit integer into the output stream. %TRUE if @data was successfully added to the @stream. a #GDataOutputStream. a #guint16. optional #GCancellable object, %NULL to ignore. Puts an unsigned 32-bit integer into the stream. %TRUE if @data was successfully added to the @stream. a #GDataOutputStream. a #guint32. optional #GCancellable object, %NULL to ignore. Puts an unsigned 64-bit integer into the stream. %TRUE if @data was successfully added to the @stream. a #GDataOutputStream. a #guint64. optional #GCancellable object, %NULL to ignore. Sets the byte order of the data output stream to @order. a #GDataOutputStream. a %GDataStreamByteOrder. Determines the byte ordering that is used when writing multi-byte entities (such as integers) to the stream. #GDataStreamByteOrder is used to ensure proper endianness of streaming data sources across various machine architectures. Selects Big Endian byte order. Selects Little Endian byte order. Selects endianness based on host machine's architecture. #GDataStreamNewlineType is used when checking for or setting the line endings for a given file. Selects "LF" line endings, common on most modern UNIX platforms. Selects "CR" line endings. Selects "CR, LF" line ending, common on Microsoft Windows. Automatically try to handle any line ending type. A #GDatagramBased is a networking interface for representing datagram-based communications. It is a more or less direct mapping of the core parts of the BSD socket API in a portable GObject interface. It is implemented by #GSocket, which wraps the UNIX socket API on UNIX and winsock2 on Windows. #GDatagramBased is entirely platform independent, and is intended to be used alongside higher-level networking APIs such as #GIOStream. It uses vectored scatter/gather I/O by default, allowing for many messages to be sent or received in a single call. Where possible, implementations of the interface should take advantage of vectored I/O to minimise processing or system calls. For example, #GSocket uses recvmmsg() and sendmmsg() where possible. Callers should take advantage of scatter/gather I/O (the use of multiple buffers per message) to avoid unnecessary copying of data to assemble or disassemble a message. Each #GDatagramBased operation has a timeout parameter which may be negative for blocking behaviour, zero for non-blocking behaviour, or positive for timeout behaviour. A blocking operation blocks until finished or there is an error. A non-blocking operation will return immediately with a %G_IO_ERROR_WOULD_BLOCK error if it cannot make progress. A timeout operation will block until the operation is complete or the timeout expires; if the timeout expires it will return what progress it made, or %G_IO_ERROR_TIMED_OUT if no progress was made. To know when a call would successfully run you can call g_datagram_based_condition_check() or g_datagram_based_condition_wait(). You can also use g_datagram_based_create_source() and attach it to a #GMainContext to get callbacks when I/O is possible. When running a non-blocking operation applications should always be able to handle getting a %G_IO_ERROR_WOULD_BLOCK error even when some other function said that I/O was possible. This can easily happen in case of a race condition in the application, but it can also happen for other reasons. For instance, on Windows a socket is always seen as writable until a write returns %G_IO_ERROR_WOULD_BLOCK. As with #GSocket, #GDatagramBaseds can be either connection oriented (for example, SCTP) or connectionless (for example, UDP). #GDatagramBaseds must be datagram-based, not stream-based. The interface does not cover connection establishment — use methods on the underlying type to establish a connection before sending and receiving data through the #GDatagramBased API. For connectionless socket types the target/source address is specified or received in each I/O operation. Like most other APIs in GLib, #GDatagramBased is not inherently thread safe. To use a #GDatagramBased concurrently from multiple threads, you must implement your own locking. Checks on the readiness of @datagram_based to perform operations. The operations specified in @condition are checked for and masked against the currently-satisfied conditions on @datagram_based. The result is returned. %G_IO_IN will be set in the return value if data is available to read with g_datagram_based_receive_messages(), or if the connection is closed remotely (EOS); and if the datagram_based has not been closed locally using some implementation-specific method (such as g_socket_close() or g_socket_shutdown() with @shutdown_read set, if it’s a #GSocket). If the connection is shut down or closed (by calling g_socket_close() or g_socket_shutdown() with @shutdown_read set, if it’s a #GSocket, for example), all calls to this function will return %G_IO_ERROR_CLOSED. %G_IO_OUT will be set if it is expected that at least one byte can be sent using g_datagram_based_send_messages() without blocking. It will not be set if the datagram_based has been closed locally. %G_IO_HUP will be set if the connection has been closed locally. %G_IO_ERR will be set if there was an asynchronous error in transmitting data previously enqueued using g_datagram_based_send_messages(). Note that on Windows, it is possible for an operation to return %G_IO_ERROR_WOULD_BLOCK even immediately after g_datagram_based_condition_check() has claimed that the #GDatagramBased is ready for writing. Rather than calling g_datagram_based_condition_check() and then writing to the #GDatagramBased if it succeeds, it is generally better to simply try writing right away, and try again later if the initial attempt returns %G_IO_ERROR_WOULD_BLOCK. It is meaningless to specify %G_IO_ERR or %G_IO_HUP in @condition; these conditions will always be set in the output if they are true. Apart from these flags, the output is guaranteed to be masked by @condition. This call never blocks. the #GIOCondition mask of the current state a #GDatagramBased a #GIOCondition mask to check Waits for up to @timeout microseconds for condition to become true on @datagram_based. If the condition is met, %TRUE is returned. If @cancellable is cancelled before the condition is met, or if @timeout is reached before the condition is met, then %FALSE is returned and @error is set appropriately (%G_IO_ERROR_CANCELLED or %G_IO_ERROR_TIMED_OUT). %TRUE if the condition was met, %FALSE otherwise a #GDatagramBased a #GIOCondition mask to wait for the maximum time (in microseconds) to wait, 0 to not block, or -1 to block indefinitely a #GCancellable Creates a #GSource that can be attached to a #GMainContext to monitor for the availability of the specified @condition on the #GDatagramBased. The #GSource keeps a reference to the @datagram_based. The callback on the source is of the #GDatagramBasedSourceFunc type. It is meaningless to specify %G_IO_ERR or %G_IO_HUP in @condition; these conditions will always be reported in the callback if they are true. If non-%NULL, @cancellable can be used to cancel the source, which will cause the source to trigger, reporting the current condition (which is likely 0 unless cancellation happened at the same time as a condition change). You can check for this in the callback using g_cancellable_is_cancelled(). a newly allocated #GSource a #GDatagramBased a #GIOCondition mask to monitor a #GCancellable Receive one or more data messages from @datagram_based in one go. @messages must point to an array of #GInputMessage structs and @num_messages must be the length of this array. Each #GInputMessage contains a pointer to an array of #GInputVector structs describing the buffers that the data received in each message will be written to. @flags modify how all messages are received. The commonly available arguments for this are available in the #GSocketMsgFlags enum, but the values there are the same as the system values, and the flags are passed in as-is, so you can pass in system-specific flags too. These flags affect the overall receive operation. Flags affecting individual messages are returned in #GInputMessage.flags. The other members of #GInputMessage are treated as described in its documentation. If @timeout is negative the call will block until @num_messages have been received, the connection is closed remotely (EOS), @cancellable is cancelled, or an error occurs. If @timeout is 0 the call will return up to @num_messages without blocking, or %G_IO_ERROR_WOULD_BLOCK if no messages are queued in the operating system to be received. If @timeout is positive the call will block on the same conditions as if @timeout were negative. If the timeout is reached before any messages are received, %G_IO_ERROR_TIMED_OUT is returned, otherwise it will return the number of messages received before timing out. (Note: This is effectively the behaviour of `MSG_WAITFORONE` with recvmmsg().) To be notified when messages are available, wait for the %G_IO_IN condition. Note though that you may still receive %G_IO_ERROR_WOULD_BLOCK from g_datagram_based_receive_messages() even if you were previously notified of a %G_IO_IN condition. If the remote peer closes the connection, any messages queued in the underlying receive buffer will be returned, and subsequent calls to g_datagram_based_receive_messages() will return 0 (with no error set). If the connection is shut down or closed (by calling g_socket_close() or g_socket_shutdown() with @shutdown_read set, if it’s a #GSocket, for example), all calls to this function will return %G_IO_ERROR_CLOSED. On error -1 is returned and @error is set accordingly. An error will only be returned if zero messages could be received; otherwise the number of messages successfully received before the error will be returned. If @cancellable is cancelled, %G_IO_ERROR_CANCELLED is returned as with any other error. number of messages received, or -1 on error. Note that the number of messages received may be smaller than @num_messages if @timeout is zero or positive, if the peer closed the connection, or if @num_messages was larger than `UIO_MAXIOV` (1024), in which case the caller may re-try to receive the remaining messages. a #GDatagramBased an array of #GInputMessage structs the number of elements in @messages an int containing #GSocketMsgFlags flags for the overall operation the maximum time (in microseconds) to wait, 0 to not block, or -1 to block indefinitely a %GCancellable Send one or more data messages from @datagram_based in one go. @messages must point to an array of #GOutputMessage structs and @num_messages must be the length of this array. Each #GOutputMessage contains an address to send the data to, and a pointer to an array of #GOutputVector structs to describe the buffers that the data to be sent for each message will be gathered from. @flags modify how the message is sent. The commonly available arguments for this are available in the #GSocketMsgFlags enum, but the values there are the same as the system values, and the flags are passed in as-is, so you can pass in system-specific flags too. The other members of #GOutputMessage are treated as described in its documentation. If @timeout is negative the call will block until @num_messages have been sent, @cancellable is cancelled, or an error occurs. If @timeout is 0 the call will send up to @num_messages without blocking, or will return %G_IO_ERROR_WOULD_BLOCK if there is no space to send messages. If @timeout is positive the call will block on the same conditions as if @timeout were negative. If the timeout is reached before any messages are sent, %G_IO_ERROR_TIMED_OUT is returned, otherwise it will return the number of messages sent before timing out. To be notified when messages can be sent, wait for the %G_IO_OUT condition. Note though that you may still receive %G_IO_ERROR_WOULD_BLOCK from g_datagram_based_send_messages() even if you were previously notified of a %G_IO_OUT condition. (On Windows in particular, this is very common due to the way the underlying APIs work.) If the connection is shut down or closed (by calling g_socket_close() or g_socket_shutdown() with @shutdown_write set, if it’s a #GSocket, for example), all calls to this function will return %G_IO_ERROR_CLOSED. On error -1 is returned and @error is set accordingly. An error will only be returned if zero messages could be sent; otherwise the number of messages successfully sent before the error will be returned. If @cancellable is cancelled, %G_IO_ERROR_CANCELLED is returned as with any other error. number of messages sent, or -1 on error. Note that the number of messages sent may be smaller than @num_messages if @timeout is zero or positive, or if @num_messages was larger than `UIO_MAXIOV` (1024), in which case the caller may re-try to send the remaining messages. a #GDatagramBased an array of #GOutputMessage structs the number of elements in @messages an int containing #GSocketMsgFlags flags the maximum time (in microseconds) to wait, 0 to not block, or -1 to block indefinitely a %GCancellable Checks on the readiness of @datagram_based to perform operations. The operations specified in @condition are checked for and masked against the currently-satisfied conditions on @datagram_based. The result is returned. %G_IO_IN will be set in the return value if data is available to read with g_datagram_based_receive_messages(), or if the connection is closed remotely (EOS); and if the datagram_based has not been closed locally using some implementation-specific method (such as g_socket_close() or g_socket_shutdown() with @shutdown_read set, if it’s a #GSocket). If the connection is shut down or closed (by calling g_socket_close() or g_socket_shutdown() with @shutdown_read set, if it’s a #GSocket, for example), all calls to this function will return %G_IO_ERROR_CLOSED. %G_IO_OUT will be set if it is expected that at least one byte can be sent using g_datagram_based_send_messages() without blocking. It will not be set if the datagram_based has been closed locally. %G_IO_HUP will be set if the connection has been closed locally. %G_IO_ERR will be set if there was an asynchronous error in transmitting data previously enqueued using g_datagram_based_send_messages(). Note that on Windows, it is possible for an operation to return %G_IO_ERROR_WOULD_BLOCK even immediately after g_datagram_based_condition_check() has claimed that the #GDatagramBased is ready for writing. Rather than calling g_datagram_based_condition_check() and then writing to the #GDatagramBased if it succeeds, it is generally better to simply try writing right away, and try again later if the initial attempt returns %G_IO_ERROR_WOULD_BLOCK. It is meaningless to specify %G_IO_ERR or %G_IO_HUP in @condition; these conditions will always be set in the output if they are true. Apart from these flags, the output is guaranteed to be masked by @condition. This call never blocks. the #GIOCondition mask of the current state a #GDatagramBased a #GIOCondition mask to check Waits for up to @timeout microseconds for condition to become true on @datagram_based. If the condition is met, %TRUE is returned. If @cancellable is cancelled before the condition is met, or if @timeout is reached before the condition is met, then %FALSE is returned and @error is set appropriately (%G_IO_ERROR_CANCELLED or %G_IO_ERROR_TIMED_OUT). %TRUE if the condition was met, %FALSE otherwise a #GDatagramBased a #GIOCondition mask to wait for the maximum time (in microseconds) to wait, 0 to not block, or -1 to block indefinitely a #GCancellable Creates a #GSource that can be attached to a #GMainContext to monitor for the availability of the specified @condition on the #GDatagramBased. The #GSource keeps a reference to the @datagram_based. The callback on the source is of the #GDatagramBasedSourceFunc type. It is meaningless to specify %G_IO_ERR or %G_IO_HUP in @condition; these conditions will always be reported in the callback if they are true. If non-%NULL, @cancellable can be used to cancel the source, which will cause the source to trigger, reporting the current condition (which is likely 0 unless cancellation happened at the same time as a condition change). You can check for this in the callback using g_cancellable_is_cancelled(). a newly allocated #GSource a #GDatagramBased a #GIOCondition mask to monitor a #GCancellable Receive one or more data messages from @datagram_based in one go. @messages must point to an array of #GInputMessage structs and @num_messages must be the length of this array. Each #GInputMessage contains a pointer to an array of #GInputVector structs describing the buffers that the data received in each message will be written to. @flags modify how all messages are received. The commonly available arguments for this are available in the #GSocketMsgFlags enum, but the values there are the same as the system values, and the flags are passed in as-is, so you can pass in system-specific flags too. These flags affect the overall receive operation. Flags affecting individual messages are returned in #GInputMessage.flags. The other members of #GInputMessage are treated as described in its documentation. If @timeout is negative the call will block until @num_messages have been received, the connection is closed remotely (EOS), @cancellable is cancelled, or an error occurs. If @timeout is 0 the call will return up to @num_messages without blocking, or %G_IO_ERROR_WOULD_BLOCK if no messages are queued in the operating system to be received. If @timeout is positive the call will block on the same conditions as if @timeout were negative. If the timeout is reached before any messages are received, %G_IO_ERROR_TIMED_OUT is returned, otherwise it will return the number of messages received before timing out. (Note: This is effectively the behaviour of `MSG_WAITFORONE` with recvmmsg().) To be notified when messages are available, wait for the %G_IO_IN condition. Note though that you may still receive %G_IO_ERROR_WOULD_BLOCK from g_datagram_based_receive_messages() even if you were previously notified of a %G_IO_IN condition. If the remote peer closes the connection, any messages queued in the underlying receive buffer will be returned, and subsequent calls to g_datagram_based_receive_messages() will return 0 (with no error set). If the connection is shut down or closed (by calling g_socket_close() or g_socket_shutdown() with @shutdown_read set, if it’s a #GSocket, for example), all calls to this function will return %G_IO_ERROR_CLOSED. On error -1 is returned and @error is set accordingly. An error will only be returned if zero messages could be received; otherwise the number of messages successfully received before the error will be returned. If @cancellable is cancelled, %G_IO_ERROR_CANCELLED is returned as with any other error. number of messages received, or -1 on error. Note that the number of messages received may be smaller than @num_messages if @timeout is zero or positive, if the peer closed the connection, or if @num_messages was larger than `UIO_MAXIOV` (1024), in which case the caller may re-try to receive the remaining messages. a #GDatagramBased an array of #GInputMessage structs the number of elements in @messages an int containing #GSocketMsgFlags flags for the overall operation the maximum time (in microseconds) to wait, 0 to not block, or -1 to block indefinitely a %GCancellable Send one or more data messages from @datagram_based in one go. @messages must point to an array of #GOutputMessage structs and @num_messages must be the length of this array. Each #GOutputMessage contains an address to send the data to, and a pointer to an array of #GOutputVector structs to describe the buffers that the data to be sent for each message will be gathered from. @flags modify how the message is sent. The commonly available arguments for this are available in the #GSocketMsgFlags enum, but the values there are the same as the system values, and the flags are passed in as-is, so you can pass in system-specific flags too. The other members of #GOutputMessage are treated as described in its documentation. If @timeout is negative the call will block until @num_messages have been sent, @cancellable is cancelled, or an error occurs. If @timeout is 0 the call will send up to @num_messages without blocking, or will return %G_IO_ERROR_WOULD_BLOCK if there is no space to send messages. If @timeout is positive the call will block on the same conditions as if @timeout were negative. If the timeout is reached before any messages are sent, %G_IO_ERROR_TIMED_OUT is returned, otherwise it will return the number of messages sent before timing out. To be notified when messages can be sent, wait for the %G_IO_OUT condition. Note though that you may still receive %G_IO_ERROR_WOULD_BLOCK from g_datagram_based_send_messages() even if you were previously notified of a %G_IO_OUT condition. (On Windows in particular, this is very common due to the way the underlying APIs work.) If the connection is shut down or closed (by calling g_socket_close() or g_socket_shutdown() with @shutdown_write set, if it’s a #GSocket, for example), all calls to this function will return %G_IO_ERROR_CLOSED. On error -1 is returned and @error is set accordingly. An error will only be returned if zero messages could be sent; otherwise the number of messages successfully sent before the error will be returned. If @cancellable is cancelled, %G_IO_ERROR_CANCELLED is returned as with any other error. number of messages sent, or -1 on error. Note that the number of messages sent may be smaller than @num_messages if @timeout is zero or positive, or if @num_messages was larger than `UIO_MAXIOV` (1024), in which case the caller may re-try to send the remaining messages. a #GDatagramBased an array of #GOutputMessage structs the number of elements in @messages an int containing #GSocketMsgFlags flags the maximum time (in microseconds) to wait, 0 to not block, or -1 to block indefinitely a %GCancellable Provides an interface for socket-like objects which have datagram semantics, following the Berkeley sockets API. The interface methods are thin wrappers around the corresponding virtual methods, and no pre-processing of inputs is implemented — so implementations of this API must handle all functionality documented in the interface methods. The parent interface. number of messages received, or -1 on error. Note that the number of messages received may be smaller than @num_messages if @timeout is zero or positive, if the peer closed the connection, or if @num_messages was larger than `UIO_MAXIOV` (1024), in which case the caller may re-try to receive the remaining messages. a #GDatagramBased an array of #GInputMessage structs the number of elements in @messages an int containing #GSocketMsgFlags flags for the overall operation the maximum time (in microseconds) to wait, 0 to not block, or -1 to block indefinitely a %GCancellable number of messages sent, or -1 on error. Note that the number of messages sent may be smaller than @num_messages if @timeout is zero or positive, or if @num_messages was larger than `UIO_MAXIOV` (1024), in which case the caller may re-try to send the remaining messages. a #GDatagramBased an array of #GOutputMessage structs the number of elements in @messages an int containing #GSocketMsgFlags flags the maximum time (in microseconds) to wait, 0 to not block, or -1 to block indefinitely a %GCancellable a newly allocated #GSource a #GDatagramBased a #GIOCondition mask to monitor a #GCancellable the #GIOCondition mask of the current state a #GDatagramBased a #GIOCondition mask to check %TRUE if the condition was met, %FALSE otherwise a #GDatagramBased a #GIOCondition mask to wait for the maximum time (in microseconds) to wait, 0 to not block, or -1 to block indefinitely a #GCancellable This is the function type of the callback used for the #GSource returned by g_datagram_based_create_source(). %G_SOURCE_REMOVE if the source should be removed, %G_SOURCE_CONTINUE otherwise the #GDatagramBased the current condition at the source fired data passed in by the user #GDesktopAppInfo is an implementation of #GAppInfo based on desktop files. Note that `<gio/gdesktopappinfo.h>` belongs to the UNIX-specific GIO interfaces, thus you have to use the `gio-unix-2.0.pc` pkg-config file when using it. Creates a new #GDesktopAppInfo based on a desktop file id. A desktop file id is the basename of the desktop file, including the .desktop extension. GIO is looking for a desktop file with this name in the `applications` subdirectories of the XDG data directories (i.e. the directories specified in the `XDG_DATA_HOME` and `XDG_DATA_DIRS` environment variables). GIO also supports the prefix-to-subdirectory mapping that is described in the [Menu Spec](http://standards.freedesktop.org/menu-spec/latest/) (i.e. a desktop id of kde-foo.desktop will match `/usr/share/applications/kde/foo.desktop`). a new #GDesktopAppInfo, or %NULL if no desktop file with that id exists. the desktop file id Creates a new #GDesktopAppInfo. a new #GDesktopAppInfo or %NULL on error. the path of a desktop file, in the GLib filename encoding Creates a new #GDesktopAppInfo. a new #GDesktopAppInfo or %NULL on error. an opened #GKeyFile Gets all applications that implement @interface. An application implements an interface if that interface is listed in the Implements= line of the desktop file of the application. a list of #GDesktopAppInfo objects. the name of the interface Searches desktop files for ones that match @search_string. The return value is an array of strvs. Each strv contains a list of applications that matched @search_string with an equal score. The outer list is sorted by score so that the first strv contains the best-matching applications, and so on. The algorithm for determining matches is undefined and may change at any time. None of the search results are subjected to the normal validation checks performed by g_desktop_app_info_new() (for example, checking that the executable referenced by a result exists), and so it is possible for g_desktop_app_info_new() to return %NULL when passed an app ID returned by this function. It is expected that calling code will do this when subsequently creating a #GDesktopAppInfo for each result. a list of strvs. Free each item with g_strfreev() and free the outer list with g_free(). the search string to use Sets the name of the desktop that the application is running in. This is used by g_app_info_should_show() and g_desktop_app_info_get_show_in() to evaluate the `OnlyShowIn` and `NotShowIn` desktop entry fields. Should be called only once; subsequent calls are ignored. do not use this API. Since 2.42 the value of the `XDG_CURRENT_DESKTOP` environment variable will be used. a string specifying what desktop this is Gets the user-visible display name of the "additional application action" specified by @action_name. This corresponds to the "Name" key within the keyfile group for the action. the locale-specific action name a #GDesktopAppInfo the name of the action as from g_desktop_app_info_list_actions() Looks up a boolean value in the keyfile backing @info. The @key is looked up in the "Desktop Entry" group. the boolean value, or %FALSE if the key is not found a #GDesktopAppInfo the key to look up Gets the categories from the desktop file. The unparsed Categories key from the desktop file; i.e. no attempt is made to split it by ';' or validate it. a #GDesktopAppInfo When @info was created from a known filename, return it. In some situations such as the #GDesktopAppInfo returned from g_desktop_app_info_new_from_keyfile(), this function will return %NULL. The full path to the file for @info, or %NULL if not known. a #GDesktopAppInfo Gets the generic name from the destkop file. The value of the GenericName key a #GDesktopAppInfo A desktop file is hidden if the Hidden key in it is set to True. %TRUE if hidden, %FALSE otherwise. a #GDesktopAppInfo. Gets the keywords from the desktop file. The value of the Keywords key a #GDesktopAppInfo Looks up a localized string value in the keyfile backing @info translated to the current locale. The @key is looked up in the "Desktop Entry" group. a newly allocated string, or %NULL if the key is not found a #GDesktopAppInfo the key to look up Gets the value of the NoDisplay key, which helps determine if the application info should be shown in menus. See #G_KEY_FILE_DESKTOP_KEY_NO_DISPLAY and g_app_info_should_show(). The value of the NoDisplay key a #GDesktopAppInfo Checks if the application info should be shown in menus that list available applications for a specific name of the desktop, based on the `OnlyShowIn` and `NotShowIn` keys. @desktop_env should typically be given as %NULL, in which case the `XDG_CURRENT_DESKTOP` environment variable is consulted. If you want to override the default mechanism then you may specify @desktop_env, but this is not recommended. Note that g_app_info_should_show() for @info will include this check (with %NULL for @desktop_env) as well as additional checks. %TRUE if the @info should be shown in @desktop_env according to the `OnlyShowIn` and `NotShowIn` keys, %FALSE otherwise. a #GDesktopAppInfo a string specifying a desktop name Retrieves the StartupWMClass field from @info. This represents the WM_CLASS property of the main window of the application, if launched through @info. the startup WM class, or %NULL if none is set in the desktop file. a #GDesktopAppInfo that supports startup notify Looks up a string value in the keyfile backing @info. The @key is looked up in the "Desktop Entry" group. a newly allocated string, or %NULL if the key is not found a #GDesktopAppInfo the key to look up Looks up a string list value in the keyfile backing @info. The @key is looked up in the "Desktop Entry" group. a %NULL-terminated string array or %NULL if the specified key cannot be found. The array should be freed with g_strfreev(). a #GDesktopAppInfo the key to look up return location for the number of returned strings, or %NULL Returns whether @key exists in the "Desktop Entry" group of the keyfile backing @info. %TRUE if the @key exists a #GDesktopAppInfo the key to look up Activates the named application action. You may only call this function on action names that were returned from g_desktop_app_info_list_actions(). Note that if the main entry of the desktop file indicates that the application supports startup notification, and @launch_context is non-%NULL, then startup notification will be used when activating the action (and as such, invocation of the action on the receiving side must signal the end of startup notification when it is completed). This is the expected behaviour of applications declaring additional actions, as per the desktop file specification. As with g_app_info_launch() there is no way to detect failures that occur while using this function. a #GDesktopAppInfo the name of the action as from g_desktop_app_info_list_actions() a #GAppLaunchContext This function performs the equivalent of g_app_info_launch_uris(), but is intended primarily for operating system components that launch applications. Ordinary applications should use g_app_info_launch_uris(). If the application is launched via GSpawn, then @spawn_flags, @user_setup and @user_setup_data are used for the call to g_spawn_async(). Additionally, @pid_callback (with @pid_callback_data) will be called to inform about the PID of the created process. See g_spawn_async_with_pipes() for information on certain parameter conditions that can enable an optimized posix_spawn() codepath to be used. If application launching occurs via some other mechanism (eg: D-Bus activation) then @spawn_flags, @user_setup, @user_setup_data, @pid_callback and @pid_callback_data are ignored. %TRUE on successful launch, %FALSE otherwise. a #GDesktopAppInfo List of URIs a #GAppLaunchContext #GSpawnFlags, used for each process a #GSpawnChildSetupFunc, used once for each process. User data for @user_setup Callback for child processes User data for @callback Equivalent to g_desktop_app_info_launch_uris_as_manager() but allows you to pass in file descriptors for the stdin, stdout and stderr streams of the launched process. If application launching occurs via some non-spawn mechanism (e.g. D-Bus activation) then @stdin_fd, @stdout_fd and @stderr_fd are ignored. %TRUE on successful launch, %FALSE otherwise. a #GDesktopAppInfo List of URIs a #GAppLaunchContext #GSpawnFlags, used for each process a #GSpawnChildSetupFunc, used once for each process. User data for @user_setup Callback for child processes User data for @callback file descriptor to use for child's stdin, or -1 file descriptor to use for child's stdout, or -1 file descriptor to use for child's stderr, or -1 Returns the list of "additional application actions" supported on the desktop file, as per the desktop file specification. As per the specification, this is the list of actions that are explicitly listed in the "Actions" key of the [Desktop Entry] group. a list of strings, always non-%NULL a #GDesktopAppInfo The origin filename of this #GDesktopAppInfo #GDesktopAppInfoLookup is an opaque data structure and can only be accessed using the following functions. The #GDesktopAppInfoLookup interface is deprecated and unused by GIO. Gets the default application for launching applications using this URI scheme for a particular #GDesktopAppInfoLookup implementation. The #GDesktopAppInfoLookup interface and this function is used to implement g_app_info_get_default_for_uri_scheme() backends in a GIO module. There is no reason for applications to use it directly. Applications should use g_app_info_get_default_for_uri_scheme(). The #GDesktopAppInfoLookup interface is deprecated and unused by GIO. #GAppInfo for given @uri_scheme or %NULL on error. a #GDesktopAppInfoLookup a string containing a URI scheme. Gets the default application for launching applications using this URI scheme for a particular #GDesktopAppInfoLookup implementation. The #GDesktopAppInfoLookup interface and this function is used to implement g_app_info_get_default_for_uri_scheme() backends in a GIO module. There is no reason for applications to use it directly. Applications should use g_app_info_get_default_for_uri_scheme(). The #GDesktopAppInfoLookup interface is deprecated and unused by GIO. #GAppInfo for given @uri_scheme or %NULL on error. a #GDesktopAppInfoLookup a string containing a URI scheme. Interface that is used by backends to associate default handlers with URI schemes. #GAppInfo for given @uri_scheme or %NULL on error. a #GDesktopAppInfoLookup a string containing a URI scheme. During invocation, g_desktop_app_info_launch_uris_as_manager() may create one or more child processes. This callback is invoked once for each, providing the process ID. a #GDesktopAppInfo Process identifier User data #GDrive - this represent a piece of hardware connected to the machine. It's generally only created for removable hardware or hardware with removable media. #GDrive is a container class for #GVolume objects that stem from the same piece of media. As such, #GDrive abstracts a drive with (or without) removable media and provides operations for querying whether media is available, determining whether media change is automatically detected and ejecting the media. If the #GDrive reports that media isn't automatically detected, one can poll for media; typically one should not do this periodically as a poll for media operation is potentially expensive and may spin up the drive creating noise. #GDrive supports starting and stopping drives with authentication support for the former. This can be used to support a diverse set of use cases including connecting/disconnecting iSCSI devices, powering down external disk enclosures and starting/stopping multi-disk devices such as RAID devices. Note that the actual semantics and side-effects of starting/stopping a #GDrive may vary according to implementation. To choose the correct verbs in e.g. a file manager, use g_drive_get_start_stop_type(). For porting from GnomeVFS note that there is no equivalent of #GDrive in that API. Checks if a drive can be ejected. %TRUE if the @drive can be ejected, %FALSE otherwise. a #GDrive. Checks if a drive can be polled for media changes. %TRUE if the @drive can be polled for media changes, %FALSE otherwise. a #GDrive. Checks if a drive can be started. %TRUE if the @drive can be started, %FALSE otherwise. a #GDrive. Checks if a drive can be started degraded. %TRUE if the @drive can be started degraded, %FALSE otherwise. a #GDrive. Checks if a drive can be stopped. %TRUE if the @drive can be stopped, %FALSE otherwise. a #GDrive. Asynchronously ejects a drive. When the operation is finished, @callback will be called. You can then call g_drive_eject_finish() to obtain the result of the operation. Use g_drive_eject_with_operation() instead. a #GDrive. flags affecting the unmount if required for eject optional #GCancellable object, %NULL to ignore. a #GAsyncReadyCallback, or %NULL. user data to pass to @callback Finishes ejecting a drive. Use g_drive_eject_with_operation_finish() instead. %TRUE if the drive has been ejected successfully, %FALSE otherwise. a #GDrive. a #GAsyncResult. Ejects a drive. This is an asynchronous operation, and is finished by calling g_drive_eject_with_operation_finish() with the @drive and #GAsyncResult data returned in the @callback. a #GDrive. flags affecting the unmount if required for eject a #GMountOperation or %NULL to avoid user interaction. optional #GCancellable object, %NULL to ignore. a #GAsyncReadyCallback, or %NULL. user data passed to @callback. Finishes ejecting a drive. If any errors occurred during the operation, @error will be set to contain the errors and %FALSE will be returned. %TRUE if the drive was successfully ejected. %FALSE otherwise. a #GDrive. a #GAsyncResult. Gets the kinds of identifiers that @drive has. Use g_drive_get_identifier() to obtain the identifiers themselves. a %NULL-terminated array of strings containing kinds of identifiers. Use g_strfreev() to free. a #GDrive Gets the icon for @drive. #GIcon for the @drive. Free the returned object with g_object_unref(). a #GDrive. Gets the identifier of the given kind for @drive. The only identifier currently available is #G_DRIVE_IDENTIFIER_KIND_UNIX_DEVICE. a newly allocated string containing the requested identifier, or %NULL if the #GDrive doesn't have this kind of identifier. a #GDrive the kind of identifier to return Gets the name of @drive. a string containing @drive's name. The returned string should be freed when no longer needed. a #GDrive. Gets the sort key for @drive, if any. Sorting key for @drive or %NULL if no such key is available. A #GDrive. Gets a hint about how a drive can be started/stopped. A value from the #GDriveStartStopType enumeration. a #GDrive. Gets the icon for @drive. symbolic #GIcon for the @drive. Free the returned object with g_object_unref(). a #GDrive. Get a list of mountable volumes for @drive. The returned list should be freed with g_list_free(), after its elements have been unreffed with g_object_unref(). #GList containing any #GVolume objects on the given @drive. a #GDrive. Checks if the @drive has media. Note that the OS may not be polling the drive for media changes; see g_drive_is_media_check_automatic() for more details. %TRUE if @drive has media, %FALSE otherwise. a #GDrive. Check if @drive has any mountable volumes. %TRUE if the @drive contains volumes, %FALSE otherwise. a #GDrive. Checks if @drive is capable of automatically detecting media changes. %TRUE if the @drive is capable of automatically detecting media changes, %FALSE otherwise. a #GDrive. Checks if the @drive supports removable media. %TRUE if @drive supports removable media, %FALSE otherwise. a #GDrive. Checks if the #GDrive and/or its media is considered removable by the user. See g_drive_is_media_removable(). %TRUE if @drive and/or its media is considered removable, %FALSE otherwise. a #GDrive. Asynchronously polls @drive to see if media has been inserted or removed. When the operation is finished, @callback will be called. You can then call g_drive_poll_for_media_finish() to obtain the result of the operation. a #GDrive. optional #GCancellable object, %NULL to ignore. a #GAsyncReadyCallback, or %NULL. user data to pass to @callback Finishes an operation started with g_drive_poll_for_media() on a drive. %TRUE if the drive has been poll_for_mediaed successfully, %FALSE otherwise. a #GDrive. a #GAsyncResult. Asynchronously starts a drive. When the operation is finished, @callback will be called. You can then call g_drive_start_finish() to obtain the result of the operation. a #GDrive. flags affecting the start operation. a #GMountOperation or %NULL to avoid user interaction. optional #GCancellable object, %NULL to ignore. a #GAsyncReadyCallback, or %NULL. user data to pass to @callback Finishes starting a drive. %TRUE if the drive has been started successfully, %FALSE otherwise. a #GDrive. a #GAsyncResult. Asynchronously stops a drive. When the operation is finished, @callback will be called. You can then call g_drive_stop_finish() to obtain the result of the operation. a #GDrive. flags affecting the unmount if required for stopping. a #GMountOperation or %NULL to avoid user interaction. optional #GCancellable object, %NULL to ignore. a #GAsyncReadyCallback, or %NULL. user data to pass to @callback Finishes stopping a drive. %TRUE if the drive has been stopped successfully, %FALSE otherwise. a #GDrive. a #GAsyncResult. Checks if a drive can be ejected. %TRUE if the @drive can be ejected, %FALSE otherwise. a #GDrive. Checks if a drive can be polled for media changes. %TRUE if the @drive can be polled for media changes, %FALSE otherwise. a #GDrive. Checks if a drive can be started. %TRUE if the @drive can be started, %FALSE otherwise. a #GDrive. Checks if a drive can be started degraded. %TRUE if the @drive can be started degraded, %FALSE otherwise. a #GDrive. Checks if a drive can be stopped. %TRUE if the @drive can be stopped, %FALSE otherwise. a #GDrive. Asynchronously ejects a drive. When the operation is finished, @callback will be called. You can then call g_drive_eject_finish() to obtain the result of the operation. Use g_drive_eject_with_operation() instead. a #GDrive. flags affecting the unmount if required for eject optional #GCancellable object, %NULL to ignore. a #GAsyncReadyCallback, or %NULL. user data to pass to @callback Finishes ejecting a drive. Use g_drive_eject_with_operation_finish() instead. %TRUE if the drive has been ejected successfully, %FALSE otherwise. a #GDrive. a #GAsyncResult. Ejects a drive. This is an asynchronous operation, and is finished by calling g_drive_eject_with_operation_finish() with the @drive and #GAsyncResult data returned in the @callback. a #GDrive. flags affecting the unmount if required for eject a #GMountOperation or %NULL to avoid user interaction. optional #GCancellable object, %NULL to ignore. a #GAsyncReadyCallback, or %NULL. user data passed to @callback. Finishes ejecting a drive. If any errors occurred during the operation, @error will be set to contain the errors and %FALSE will be returned. %TRUE if the drive was successfully ejected. %FALSE otherwise. a #GDrive. a #GAsyncResult. Gets the kinds of identifiers that @drive has. Use g_drive_get_identifier() to obtain the identifiers themselves. a %NULL-terminated array of strings containing kinds of identifiers. Use g_strfreev() to free. a #GDrive Gets the icon for @drive. #GIcon for the @drive. Free the returned object with g_object_unref(). a #GDrive. Gets the identifier of the given kind for @drive. The only identifier currently available is #G_DRIVE_IDENTIFIER_KIND_UNIX_DEVICE. a newly allocated string containing the requested identifier, or %NULL if the #GDrive doesn't have this kind of identifier. a #GDrive the kind of identifier to return Gets the name of @drive. a string containing @drive's name. The returned string should be freed when no longer needed. a #GDrive. Gets the sort key for @drive, if any. Sorting key for @drive or %NULL if no such key is available. A #GDrive. Gets a hint about how a drive can be started/stopped. A value from the #GDriveStartStopType enumeration. a #GDrive. Gets the icon for @drive. symbolic #GIcon for the @drive. Free the returned object with g_object_unref(). a #GDrive. Get a list of mountable volumes for @drive. The returned list should be freed with g_list_free(), after its elements have been unreffed with g_object_unref(). #GList containing any #GVolume objects on the given @drive. a #GDrive. Checks if the @drive has media. Note that the OS may not be polling the drive for media changes; see g_drive_is_media_check_automatic() for more details. %TRUE if @drive has media, %FALSE otherwise. a #GDrive. Check if @drive has any mountable volumes. %TRUE if the @drive contains volumes, %FALSE otherwise. a #GDrive. Checks if @drive is capable of automatically detecting media changes. %TRUE if the @drive is capable of automatically detecting media changes, %FALSE otherwise. a #GDrive. Checks if the @drive supports removable media. %TRUE if @drive supports removable media, %FALSE otherwise. a #GDrive. Checks if the #GDrive and/or its media is considered removable by the user. See g_drive_is_media_removable(). %TRUE if @drive and/or its media is considered removable, %FALSE otherwise. a #GDrive. Asynchronously polls @drive to see if media has been inserted or removed. When the operation is finished, @callback will be called. You can then call g_drive_poll_for_media_finish() to obtain the result of the operation. a #GDrive. optional #GCancellable object, %NULL to ignore. a #GAsyncReadyCallback, or %NULL. user data to pass to @callback Finishes an operation started with g_drive_poll_for_media() on a drive. %TRUE if the drive has been poll_for_mediaed successfully, %FALSE otherwise. a #GDrive. a #GAsyncResult. Asynchronously starts a drive. When the operation is finished, @callback will be called. You can then call g_drive_start_finish() to obtain the result of the operation. a #GDrive. flags affecting the start operation. a #GMountOperation or %NULL to avoid user interaction. optional #GCancellable object, %NULL to ignore. a #GAsyncReadyCallback, or %NULL. user data to pass to @callback Finishes starting a drive. %TRUE if the drive has been started successfully, %FALSE otherwise. a #GDrive. a #GAsyncResult. Asynchronously stops a drive. When the operation is finished, @callback will be called. You can then call g_drive_stop_finish() to obtain the result of the operation. a #GDrive. flags affecting the unmount if required for stopping. a #GMountOperation or %NULL to avoid user interaction. optional #GCancellable object, %NULL to ignore. a #GAsyncReadyCallback, or %NULL. user data to pass to @callback Finishes stopping a drive. %TRUE if the drive has been stopped successfully, %FALSE otherwise. a #GDrive. a #GAsyncResult. Emitted when the drive's state has changed. This signal is emitted when the #GDrive have been disconnected. If the recipient is holding references to the object they should release them so the object can be finalized. Emitted when the physical eject button (if any) of a drive has been pressed. Emitted when the physical stop button (if any) of a drive has been pressed. Interface for creating #GDrive implementations. The parent interface. a string containing @drive's name. The returned string should be freed when no longer needed. a #GDrive. #GIcon for the @drive. Free the returned object with g_object_unref(). a #GDrive. %TRUE if the @drive contains volumes, %FALSE otherwise. a #GDrive. #GList containing any #GVolume objects on the given @drive. a #GDrive. %TRUE if @drive supports removable media, %FALSE otherwise. a #GDrive. %TRUE if @drive has media, %FALSE otherwise. a #GDrive. %TRUE if the @drive is capable of automatically detecting media changes, %FALSE otherwise. a #GDrive. %TRUE if the @drive can be ejected, %FALSE otherwise. a #GDrive. %TRUE if the @drive can be polled for media changes, %FALSE otherwise. a #GDrive. a #GDrive. flags affecting the unmount if required for eject optional #GCancellable object, %NULL to ignore. a #GAsyncReadyCallback, or %NULL. user data to pass to @callback %TRUE if the drive has been ejected successfully, %FALSE otherwise. a #GDrive. a #GAsyncResult. a #GDrive. optional #GCancellable object, %NULL to ignore. a #GAsyncReadyCallback, or %NULL. user data to pass to @callback %TRUE if the drive has been poll_for_mediaed successfully, %FALSE otherwise. a #GDrive. a #GAsyncResult. a newly allocated string containing the requested identifier, or %NULL if the #GDrive doesn't have this kind of identifier. a #GDrive the kind of identifier to return a %NULL-terminated array of strings containing kinds of identifiers. Use g_strfreev() to free. a #GDrive A value from the #GDriveStartStopType enumeration. a #GDrive. %TRUE if the @drive can be started, %FALSE otherwise. a #GDrive. %TRUE if the @drive can be started degraded, %FALSE otherwise. a #GDrive. a #GDrive. flags affecting the start operation. a #GMountOperation or %NULL to avoid user interaction. optional #GCancellable object, %NULL to ignore. a #GAsyncReadyCallback, or %NULL. user data to pass to @callback %TRUE if the drive has been started successfully, %FALSE otherwise. a #GDrive. a #GAsyncResult. %TRUE if the @drive can be stopped, %FALSE otherwise. a #GDrive. a #GDrive. flags affecting the unmount if required for stopping. a #GMountOperation or %NULL to avoid user interaction. optional #GCancellable object, %NULL to ignore. a #GAsyncReadyCallback, or %NULL. user data to pass to @callback %TRUE if the drive has been stopped successfully, %FALSE otherwise. a #GDrive. a #GAsyncResult. a #GDrive. flags affecting the unmount if required for eject a #GMountOperation or %NULL to avoid user interaction. optional #GCancellable object, %NULL to ignore. a #GAsyncReadyCallback, or %NULL. user data passed to @callback. %TRUE if the drive was successfully ejected. %FALSE otherwise. a #GDrive. a #GAsyncResult. Sorting key for @drive or %NULL if no such key is available. A #GDrive. symbolic #GIcon for the @drive. Free the returned object with g_object_unref(). a #GDrive. %TRUE if @drive and/or its media is considered removable, %FALSE otherwise. a #GDrive. Flags used when starting a drive. No flags set. Enumeration describing how a drive can be started/stopped. Unknown or drive doesn't support start/stop. The stop method will physically shut down the drive and e.g. power down the port the drive is attached to. The start/stop methods are used for connecting/disconnect to the drive over the network. The start/stop methods will assemble/disassemble a virtual drive from several physical drives. The start/stop methods will unlock/lock the disk (for example using the ATA <quote>SECURITY UNLOCK DEVICE</quote> command) #GDtlsClientConnection is the client-side subclass of #GDtlsConnection, representing a client-side DTLS connection. Creates a new #GDtlsClientConnection wrapping @base_socket which is assumed to communicate with the server identified by @server_identity. the new #GDtlsClientConnection, or %NULL on error the #GDatagramBased to wrap the expected identity of the server Gets the list of distinguished names of the Certificate Authorities that the server will accept certificates from. This will be set during the TLS handshake if the server requests a certificate. Otherwise, it will be %NULL. Each item in the list is a #GByteArray which contains the complete subject DN of the certificate authority. the list of CA DNs. You should unref each element with g_byte_array_unref() and then the free the list with g_list_free(). the #GDtlsClientConnection Gets @conn's expected server identity a #GSocketConnectable describing the expected server identity, or %NULL if the expected identity is not known. the #GDtlsClientConnection Gets @conn's validation flags the validation flags the #GDtlsClientConnection Sets @conn's expected server identity, which is used both to tell servers on virtual hosts which certificate to present, and also to let @conn know what name to look for in the certificate when performing %G_TLS_CERTIFICATE_BAD_IDENTITY validation, if enabled. the #GDtlsClientConnection a #GSocketConnectable describing the expected server identity Sets @conn's validation flags, to override the default set of checks performed when validating a server certificate. By default, %G_TLS_CERTIFICATE_VALIDATE_ALL is used. the #GDtlsClientConnection the #GTlsCertificateFlags to use A list of the distinguished names of the Certificate Authorities that the server will accept client certificates signed by. If the server requests a client certificate during the handshake, then this property will be set after the handshake completes. Each item in the list is a #GByteArray which contains the complete subject DN of the certificate authority. A #GSocketConnectable describing the identity of the server that is expected on the other end of the connection. If the %G_TLS_CERTIFICATE_BAD_IDENTITY flag is set in #GDtlsClientConnection:validation-flags, this object will be used to determine the expected identify of the remote end of the connection; if #GDtlsClientConnection:server-identity is not set, or does not match the identity presented by the server, then the %G_TLS_CERTIFICATE_BAD_IDENTITY validation will fail. In addition to its use in verifying the server certificate, this is also used to give a hint to the server about what certificate we expect, which is useful for servers that serve virtual hosts. What steps to perform when validating a certificate received from a server. Server certificates that fail to validate in any of the ways indicated here will be rejected unless the application overrides the default via #GDtlsConnection::accept-certificate. vtable for a #GDtlsClientConnection implementation. The parent interface. #GDtlsConnection is the base DTLS connection class type, which wraps a #GDatagramBased and provides DTLS encryption on top of it. Its subclasses, #GDtlsClientConnection and #GDtlsServerConnection, implement client-side and server-side DTLS, respectively. For TLS support, see #GTlsConnection. As DTLS is datagram based, #GDtlsConnection implements #GDatagramBased, presenting a datagram-socket-like API for the encrypted connection. This operates over a base datagram connection, which is also a #GDatagramBased (#GDtlsConnection:base-socket). To close a DTLS connection, use g_dtls_connection_close(). Neither #GDtlsServerConnection or #GDtlsClientConnection set the peer address on their base #GDatagramBased if it is a #GSocket — it is up to the caller to do that if they wish. If they do not, and g_socket_close() is called on the base socket, the #GDtlsConnection will not raise a %G_IO_ERROR_NOT_CONNECTED error on further I/O. Gets the name of the application-layer protocol negotiated during the handshake. If the peer did not use the ALPN extension, or did not advertise a protocol that matched one of @conn's protocols, or the TLS backend does not support ALPN, then this will be %NULL. See g_dtls_connection_set_advertised_protocols(). the negotiated protocol, or %NULL a #GDtlsConnection Attempts a TLS handshake on @conn. On the client side, it is never necessary to call this method; although the connection needs to perform a handshake after connecting, #GDtlsConnection will handle this for you automatically when you try to send or receive data on the connection. You can call g_dtls_connection_handshake() manually if you want to know whether the initial handshake succeeded or failed (as opposed to just immediately trying to use @conn to read or write, in which case, if it fails, it may not be possible to tell if it failed before or after completing the handshake), but beware that servers may reject client authentication after the handshake has completed, so a successful handshake does not indicate the connection will be usable. Likewise, on the server side, although a handshake is necessary at the beginning of the communication, you do not need to call this function explicitly unless you want clearer error reporting. Previously, calling g_dtls_connection_handshake() after the initial handshake would trigger a rehandshake; however, this usage was deprecated in GLib 2.60 because rehandshaking was removed from the TLS protocol in TLS 1.3. Since GLib 2.64, calling this function after the initial handshake will no longer do anything. #GDtlsConnection::accept_certificate may be emitted during the handshake. success or failure a #GDtlsConnection a #GCancellable, or %NULL Asynchronously performs a TLS handshake on @conn. See g_dtls_connection_handshake() for more information. a #GDtlsConnection the [I/O priority][io-priority] of the request a #GCancellable, or %NULL callback to call when the handshake is complete the data to pass to the callback function Finish an asynchronous TLS handshake operation. See g_dtls_connection_handshake() for more information. %TRUE on success, %FALSE on failure, in which case @error will be set. a #GDtlsConnection a #GAsyncResult. Sets the list of application-layer protocols to advertise that the caller is willing to speak on this connection. The Application-Layer Protocol Negotiation (ALPN) extension will be used to negotiate a compatible protocol with the peer; use g_dtls_connection_get_negotiated_protocol() to find the negotiated protocol after the handshake. Specifying %NULL for the the value of @protocols will disable ALPN negotiation. See [IANA TLS ALPN Protocol IDs](https://www.iana.org/assignments/tls-extensiontype-values/tls-extensiontype-values.xhtml#alpn-protocol-ids) for a list of registered protocol IDs. a #GDtlsConnection a %NULL-terminated array of ALPN protocol names (eg, "http/1.1", "h2"), or %NULL Shut down part or all of a DTLS connection. If @shutdown_read is %TRUE then the receiving side of the connection is shut down, and further reading is disallowed. Subsequent calls to g_datagram_based_receive_messages() will return %G_IO_ERROR_CLOSED. If @shutdown_write is %TRUE then the sending side of the connection is shut down, and further writing is disallowed. Subsequent calls to g_datagram_based_send_messages() will return %G_IO_ERROR_CLOSED. It is allowed for both @shutdown_read and @shutdown_write to be TRUE — this is equivalent to calling g_dtls_connection_close(). If @cancellable is cancelled, the #GDtlsConnection may be left partially-closed and any pending untransmitted data may be lost. Call g_dtls_connection_shutdown() again to complete closing the #GDtlsConnection. %TRUE on success, %FALSE otherwise a #GDtlsConnection %TRUE to stop reception of incoming datagrams %TRUE to stop sending outgoing datagrams a #GCancellable, or %NULL Asynchronously shut down part or all of the DTLS connection. See g_dtls_connection_shutdown() for more information. a #GDtlsConnection %TRUE to stop reception of incoming datagrams %TRUE to stop sending outgoing datagrams the [I/O priority][io-priority] of the request a #GCancellable, or %NULL callback to call when the shutdown operation is complete the data to pass to the callback function Finish an asynchronous TLS shutdown operation. See g_dtls_connection_shutdown() for more information. %TRUE on success, %FALSE on failure, in which case @error will be set a #GDtlsConnection a #GAsyncResult Close the DTLS connection. This is equivalent to calling g_dtls_connection_shutdown() to shut down both sides of the connection. Closing a #GDtlsConnection waits for all buffered but untransmitted data to be sent before it completes. It then sends a `close_notify` DTLS alert to the peer and may wait for a `close_notify` to be received from the peer. It does not close the underlying #GDtlsConnection:base-socket; that must be closed separately. Once @conn is closed, all other operations will return %G_IO_ERROR_CLOSED. Closing a #GDtlsConnection multiple times will not return an error. #GDtlsConnections will be automatically closed when the last reference is dropped, but you might want to call this function to make sure resources are released as early as possible. If @cancellable is cancelled, the #GDtlsConnection may be left partially-closed and any pending untransmitted data may be lost. Call g_dtls_connection_close() again to complete closing the #GDtlsConnection. %TRUE on success, %FALSE otherwise a #GDtlsConnection a #GCancellable, or %NULL Asynchronously close the DTLS connection. See g_dtls_connection_close() for more information. a #GDtlsConnection the [I/O priority][io-priority] of the request a #GCancellable, or %NULL callback to call when the close operation is complete the data to pass to the callback function Finish an asynchronous TLS close operation. See g_dtls_connection_close() for more information. %TRUE on success, %FALSE on failure, in which case @error will be set a #GDtlsConnection a #GAsyncResult Used by #GDtlsConnection implementations to emit the #GDtlsConnection::accept-certificate signal. %TRUE if one of the signal handlers has returned %TRUE to accept @peer_cert a #GDtlsConnection the peer's #GTlsCertificate the problems with @peer_cert Gets @conn's certificate, as set by g_dtls_connection_set_certificate(). @conn's certificate, or %NULL a #GDtlsConnection Query the TLS backend for TLS channel binding data of @type for @conn. This call retrieves TLS channel binding data as specified in RFC [5056](https://tools.ietf.org/html/rfc5056), RFC [5929](https://tools.ietf.org/html/rfc5929), and related RFCs. The binding data is returned in @data. The @data is resized by the callee using #GByteArray buffer management and will be freed when the @data is destroyed by g_byte_array_unref(). If @data is %NULL, it will only check whether TLS backend is able to fetch the data (e.g. whether @type is supported by the TLS backend). It does not guarantee that the data will be available though. That could happen if TLS connection does not support @type or the binding data is not available yet due to additional negotiation or input required. %TRUE on success, %FALSE otherwise a #GDtlsConnection #GTlsChannelBindingType type of data to fetch #GByteArray is filled with the binding data, or %NULL Gets the certificate database that @conn uses to verify peer certificates. See g_dtls_connection_set_database(). the certificate database that @conn uses or %NULL a #GDtlsConnection Get the object that will be used to interact with the user. It will be used for things like prompting the user for passwords. If %NULL is returned, then no user interaction will occur for this connection. The interaction object. a connection Gets the name of the application-layer protocol negotiated during the handshake. If the peer did not use the ALPN extension, or did not advertise a protocol that matched one of @conn's protocols, or the TLS backend does not support ALPN, then this will be %NULL. See g_dtls_connection_set_advertised_protocols(). the negotiated protocol, or %NULL a #GDtlsConnection Gets @conn's peer's certificate after the handshake has completed or failed. (It is not set during the emission of #GDtlsConnection::accept-certificate.) @conn's peer's certificate, or %NULL a #GDtlsConnection Gets the errors associated with validating @conn's peer's certificate, after the handshake has completed or failed. (It is not set during the emission of #GDtlsConnection::accept-certificate.) @conn's peer's certificate errors a #GDtlsConnection Gets @conn rehandshaking mode. See g_dtls_connection_set_rehandshake_mode() for details. Changing the rehandshake mode is no longer required for compatibility. Also, rehandshaking has been removed from the TLS protocol in TLS 1.3. %G_TLS_REHANDSHAKE_SAFELY a #GDtlsConnection Tests whether or not @conn expects a proper TLS close notification when the connection is closed. See g_dtls_connection_set_require_close_notify() for details. %TRUE if @conn requires a proper TLS close notification. a #GDtlsConnection Attempts a TLS handshake on @conn. On the client side, it is never necessary to call this method; although the connection needs to perform a handshake after connecting, #GDtlsConnection will handle this for you automatically when you try to send or receive data on the connection. You can call g_dtls_connection_handshake() manually if you want to know whether the initial handshake succeeded or failed (as opposed to just immediately trying to use @conn to read or write, in which case, if it fails, it may not be possible to tell if it failed before or after completing the handshake), but beware that servers may reject client authentication after the handshake has completed, so a successful handshake does not indicate the connection will be usable. Likewise, on the server side, although a handshake is necessary at the beginning of the communication, you do not need to call this function explicitly unless you want clearer error reporting. Previously, calling g_dtls_connection_handshake() after the initial handshake would trigger a rehandshake; however, this usage was deprecated in GLib 2.60 because rehandshaking was removed from the TLS protocol in TLS 1.3. Since GLib 2.64, calling this function after the initial handshake will no longer do anything. #GDtlsConnection::accept_certificate may be emitted during the handshake. success or failure a #GDtlsConnection a #GCancellable, or %NULL Asynchronously performs a TLS handshake on @conn. See g_dtls_connection_handshake() for more information. a #GDtlsConnection the [I/O priority][io-priority] of the request a #GCancellable, or %NULL callback to call when the handshake is complete the data to pass to the callback function Finish an asynchronous TLS handshake operation. See g_dtls_connection_handshake() for more information. %TRUE on success, %FALSE on failure, in which case @error will be set. a #GDtlsConnection a #GAsyncResult. Sets the list of application-layer protocols to advertise that the caller is willing to speak on this connection. The Application-Layer Protocol Negotiation (ALPN) extension will be used to negotiate a compatible protocol with the peer; use g_dtls_connection_get_negotiated_protocol() to find the negotiated protocol after the handshake. Specifying %NULL for the the value of @protocols will disable ALPN negotiation. See [IANA TLS ALPN Protocol IDs](https://www.iana.org/assignments/tls-extensiontype-values/tls-extensiontype-values.xhtml#alpn-protocol-ids) for a list of registered protocol IDs. a #GDtlsConnection a %NULL-terminated array of ALPN protocol names (eg, "http/1.1", "h2"), or %NULL This sets the certificate that @conn will present to its peer during the TLS handshake. For a #GDtlsServerConnection, it is mandatory to set this, and that will normally be done at construct time. For a #GDtlsClientConnection, this is optional. If a handshake fails with %G_TLS_ERROR_CERTIFICATE_REQUIRED, that means that the server requires a certificate, and if you try connecting again, you should call this method first. You can call g_dtls_client_connection_get_accepted_cas() on the failed connection to get a list of Certificate Authorities that the server will accept certificates from. (It is also possible that a server will allow the connection with or without a certificate; in that case, if you don't provide a certificate, you can tell that the server requested one by the fact that g_dtls_client_connection_get_accepted_cas() will return non-%NULL.) a #GDtlsConnection the certificate to use for @conn Sets the certificate database that is used to verify peer certificates. This is set to the default database by default. See g_tls_backend_get_default_database(). If set to %NULL, then peer certificate validation will always set the %G_TLS_CERTIFICATE_UNKNOWN_CA error (meaning #GDtlsConnection::accept-certificate will always be emitted on client-side connections, unless that bit is not set in #GDtlsClientConnection:validation-flags). a #GDtlsConnection a #GTlsDatabase Set the object that will be used to interact with the user. It will be used for things like prompting the user for passwords. The @interaction argument will normally be a derived subclass of #GTlsInteraction. %NULL can also be provided if no user interaction should occur for this connection. a connection an interaction object, or %NULL Since GLib 2.64, changing the rehandshake mode is no longer supported and will have no effect. With TLS 1.3, rehandshaking has been removed from the TLS protocol, replaced by separate post-handshake authentication and rekey operations. Changing the rehandshake mode is no longer required for compatibility. Also, rehandshaking has been removed from the TLS protocol in TLS 1.3. a #GDtlsConnection the rehandshaking mode Sets whether or not @conn expects a proper TLS close notification before the connection is closed. If this is %TRUE (the default), then @conn will expect to receive a TLS close notification from its peer before the connection is closed, and will return a %G_TLS_ERROR_EOF error if the connection is closed without proper notification (since this may indicate a network error, or man-in-the-middle attack). In some protocols, the application will know whether or not the connection was closed cleanly based on application-level data (because the application-level data includes a length field, or is somehow self-delimiting); in this case, the close notify is redundant and may be omitted. You can use g_dtls_connection_set_require_close_notify() to tell @conn to allow an "unannounced" connection close, in which case the close will show up as a 0-length read, as in a non-TLS #GDatagramBased, and it is up to the application to check that the data has been fully received. Note that this only affects the behavior when the peer closes the connection; when the application calls g_dtls_connection_close_async() on @conn itself, this will send a close notification regardless of the setting of this property. If you explicitly want to do an unclean close, you can close @conn's #GDtlsConnection:base-socket rather than closing @conn itself. a #GDtlsConnection whether or not to require close notification Shut down part or all of a DTLS connection. If @shutdown_read is %TRUE then the receiving side of the connection is shut down, and further reading is disallowed. Subsequent calls to g_datagram_based_receive_messages() will return %G_IO_ERROR_CLOSED. If @shutdown_write is %TRUE then the sending side of the connection is shut down, and further writing is disallowed. Subsequent calls to g_datagram_based_send_messages() will return %G_IO_ERROR_CLOSED. It is allowed for both @shutdown_read and @shutdown_write to be TRUE — this is equivalent to calling g_dtls_connection_close(). If @cancellable is cancelled, the #GDtlsConnection may be left partially-closed and any pending untransmitted data may be lost. Call g_dtls_connection_shutdown() again to complete closing the #GDtlsConnection. %TRUE on success, %FALSE otherwise a #GDtlsConnection %TRUE to stop reception of incoming datagrams %TRUE to stop sending outgoing datagrams a #GCancellable, or %NULL Asynchronously shut down part or all of the DTLS connection. See g_dtls_connection_shutdown() for more information. a #GDtlsConnection %TRUE to stop reception of incoming datagrams %TRUE to stop sending outgoing datagrams the [I/O priority][io-priority] of the request a #GCancellable, or %NULL callback to call when the shutdown operation is complete the data to pass to the callback function Finish an asynchronous TLS shutdown operation. See g_dtls_connection_shutdown() for more information. %TRUE on success, %FALSE on failure, in which case @error will be set a #GDtlsConnection a #GAsyncResult The list of application-layer protocols that the connection advertises that it is willing to speak. See g_dtls_connection_set_advertised_protocols(). The #GDatagramBased that the connection wraps. Note that this may be any implementation of #GDatagramBased, not just a #GSocket. The connection's certificate; see g_dtls_connection_set_certificate(). The certificate database to use when verifying this TLS connection. If no certificate database is set, then the default database will be used. See g_tls_backend_get_default_database(). A #GTlsInteraction object to be used when the connection or certificate database need to interact with the user. This will be used to prompt the user for passwords where necessary. The application-layer protocol negotiated during the TLS handshake. See g_dtls_connection_get_negotiated_protocol(). The connection's peer's certificate, after the TLS handshake has completed or failed. Note in particular that this is not yet set during the emission of #GDtlsConnection::accept-certificate. (You can watch for a #GObject::notify signal on this property to detect when a handshake has occurred.) The errors noticed while verifying #GDtlsConnection:peer-certificate. Normally this should be 0, but it may not be if #GDtlsClientConnection:validation-flags is not %G_TLS_CERTIFICATE_VALIDATE_ALL, or if #GDtlsConnection::accept-certificate overrode the default behavior. The rehandshaking mode. See g_dtls_connection_set_rehandshake_mode(). The rehandshake mode is ignored. Whether or not proper TLS close notification is required. See g_dtls_connection_set_require_close_notify(). Emitted during the TLS handshake after the peer certificate has been received. You can examine @peer_cert's certification path by calling g_tls_certificate_get_issuer() on it. For a client-side connection, @peer_cert is the server's certificate, and the signal will only be emitted if the certificate was not acceptable according to @conn's #GDtlsClientConnection:validation_flags. If you would like the certificate to be accepted despite @errors, return %TRUE from the signal handler. Otherwise, if no handler accepts the certificate, the handshake will fail with %G_TLS_ERROR_BAD_CERTIFICATE. For a server-side connection, @peer_cert is the certificate presented by the client, if this was requested via the server's #GDtlsServerConnection:authentication_mode. On the server side, the signal is always emitted when the client presents a certificate, and the certificate will only be accepted if a handler returns %TRUE. Note that if this signal is emitted as part of asynchronous I/O in the main thread, then you should not attempt to interact with the user before returning from the signal handler. If you want to let the user decide whether or not to accept the certificate, you would have to return %FALSE from the signal handler on the first attempt, and then after the connection attempt returns a %G_TLS_ERROR_BAD_CERTIFICATE, you can interact with the user, and if the user decides to accept the certificate, remember that fact, create a new connection, and return %TRUE from the signal handler the next time. If you are doing I/O in another thread, you do not need to worry about this, and can simply block in the signal handler until the UI thread returns an answer. %TRUE to accept @peer_cert (which will also immediately end the signal emission). %FALSE to allow the signal emission to continue, which will cause the handshake to fail if no one else overrides it. the peer's #GTlsCertificate the problems with @peer_cert. Virtual method table for a #GDtlsConnection implementation. The parent interface. success or failure a #GDtlsConnection a #GCancellable, or %NULL a #GDtlsConnection the [I/O priority][io-priority] of the request a #GCancellable, or %NULL callback to call when the handshake is complete the data to pass to the callback function %TRUE on success, %FALSE on failure, in which case @error will be set. a #GDtlsConnection a #GAsyncResult. %TRUE on success, %FALSE otherwise a #GDtlsConnection %TRUE to stop reception of incoming datagrams %TRUE to stop sending outgoing datagrams a #GCancellable, or %NULL a #GDtlsConnection %TRUE to stop reception of incoming datagrams %TRUE to stop sending outgoing datagrams the [I/O priority][io-priority] of the request a #GCancellable, or %NULL callback to call when the shutdown operation is complete the data to pass to the callback function %TRUE on success, %FALSE on failure, in which case @error will be set a #GDtlsConnection a #GAsyncResult a #GDtlsConnection a %NULL-terminated array of ALPN protocol names (eg, "http/1.1", "h2"), or %NULL the negotiated protocol, or %NULL a #GDtlsConnection #GDtlsServerConnection is the server-side subclass of #GDtlsConnection, representing a server-side DTLS connection. Creates a new #GDtlsServerConnection wrapping @base_socket. the new #GDtlsServerConnection, or %NULL on error the #GDatagramBased to wrap the default server certificate, or %NULL The #GTlsAuthenticationMode for the server. This can be changed before calling g_dtls_connection_handshake() if you want to rehandshake with a different mode from the initial handshake. vtable for a #GDtlsServerConnection implementation. The parent interface. #GEmblem is an implementation of #GIcon that supports having an emblem, which is an icon with additional properties. It can than be added to a #GEmblemedIcon. Currently, only metainformation about the emblem's origin is supported. More may be added in the future. Creates a new emblem for @icon. a new #GEmblem. a GIcon containing the icon. Creates a new emblem for @icon. a new #GEmblem. a GIcon containing the icon. a GEmblemOrigin enum defining the emblem's origin Gives back the icon from @emblem. a #GIcon. The returned object belongs to the emblem and should not be modified or freed. a #GEmblem from which the icon should be extracted. Gets the origin of the emblem. the origin of the emblem a #GEmblem GEmblemOrigin is used to add information about the origin of the emblem to #GEmblem. Emblem of unknown origin Emblem adds device-specific information Emblem depicts live metadata, such as "readonly" Emblem comes from a user-defined tag, e.g. set by nautilus (in the future) #GEmblemedIcon is an implementation of #GIcon that supports adding an emblem to an icon. Adding multiple emblems to an icon is ensured via g_emblemed_icon_add_emblem(). Note that #GEmblemedIcon allows no control over the position of the emblems. See also #GEmblem for more information. Creates a new emblemed icon for @icon with the emblem @emblem. a new #GIcon a #GIcon a #GEmblem, or %NULL Adds @emblem to the #GList of #GEmblems. a #GEmblemedIcon a #GEmblem Removes all the emblems from @icon. a #GEmblemedIcon Gets the list of emblems for the @icon. a #GList of #GEmblems that is owned by @emblemed a #GEmblemedIcon Gets the main icon for @emblemed. a #GIcon that is owned by @emblemed a #GEmblemedIcon A key in the "access" namespace for checking deletion privileges. Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN. This attribute will be %TRUE if the user is able to delete the file. A key in the "access" namespace for getting execution privileges. Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN. This attribute will be %TRUE if the user is able to execute the file. A key in the "access" namespace for getting read privileges. Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN. This attribute will be %TRUE if the user is able to read the file. A key in the "access" namespace for checking renaming privileges. Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN. This attribute will be %TRUE if the user is able to rename the file. A key in the "access" namespace for checking trashing privileges. Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN. This attribute will be %TRUE if the user is able to move the file to the trash. A key in the "access" namespace for getting write privileges. Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN. This attribute will be %TRUE if the user is able to write to the file. A key in the "dos" namespace for checking if the file's archive flag is set. This attribute is %TRUE if the archive flag is set. This attribute is only available for DOS file systems. Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN. A key in the "dos" namespace for checking if the file is a NTFS mount point (a volume mount or a junction point). This attribute is %TRUE if file is a reparse point of type [IO_REPARSE_TAG_MOUNT_POINT](https://msdn.microsoft.com/en-us/library/dd541667.aspx). This attribute is only available for DOS file systems. Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN. A key in the "dos" namespace for checking if the file's backup flag is set. This attribute is %TRUE if the backup flag is set. This attribute is only available for DOS file systems. Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN. A key in the "dos" namespace for getting the file NTFS reparse tag. This value is 0 for files that are not reparse points. See the [Reparse Tags](https://msdn.microsoft.com/en-us/library/dd541667.aspx) page for possible reparse tag values. Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT32. A key in the "etag" namespace for getting the value of the file's entity tag. Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_STRING. A key in the "filesystem" namespace for getting the number of bytes of free space left on the file system. Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT64. A key in the "filesystem" namespace for checking if the file system is read only. Is set to %TRUE if the file system is read only. Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN. A key in the "filesystem" namespace for checking if the file system is remote. Is set to %TRUE if the file system is remote. Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN. A key in the "filesystem" namespace for getting the total size (in bytes) of the file system, used in g_file_query_filesystem_info(). Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT64. A key in the "filesystem" namespace for getting the file system's type. Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_STRING. A key in the "filesystem" namespace for getting the number of bytes of used on the file system. Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT64. A key in the "filesystem" namespace for hinting a file manager application whether it should preview (e.g. thumbnail) files on the file system. The value for this key contain a #GFilesystemPreviewType. A key in the "gvfs" namespace that gets the name of the current GVFS backend in use. Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_STRING. A key in the "id" namespace for getting a file identifier. Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_STRING. An example use would be during listing files, to avoid recursive directory scanning. A key in the "id" namespace for getting the file system identifier. Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_STRING. An example use would be during drag and drop to see if the source and target are on the same filesystem (default to move) or not (default to copy). A key in the "mountable" namespace for checking if a file (of type G_FILE_TYPE_MOUNTABLE) can be ejected. Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN. A key in the "mountable" namespace for checking if a file (of type G_FILE_TYPE_MOUNTABLE) is mountable. Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN. A key in the "mountable" namespace for checking if a file (of type G_FILE_TYPE_MOUNTABLE) can be polled. Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN. A key in the "mountable" namespace for checking if a file (of type G_FILE_TYPE_MOUNTABLE) can be started. Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN. A key in the "mountable" namespace for checking if a file (of type G_FILE_TYPE_MOUNTABLE) can be started degraded. Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN. A key in the "mountable" namespace for checking if a file (of type G_FILE_TYPE_MOUNTABLE) can be stopped. Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN. A key in the "mountable" namespace for checking if a file (of type G_FILE_TYPE_MOUNTABLE) is unmountable. Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN. A key in the "mountable" namespace for getting the HAL UDI for the mountable file. Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_STRING. A key in the "mountable" namespace for checking if a file (of type G_FILE_TYPE_MOUNTABLE) is automatically polled for media. Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN. A key in the "mountable" namespace for getting the #GDriveStartStopType. Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT32. A key in the "mountable" namespace for getting the unix device. Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT32. A key in the "mountable" namespace for getting the unix device file. Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_STRING. A key in the "owner" namespace for getting the file owner's group. Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_STRING. A key in the "owner" namespace for getting the user name of the file's owner. Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_STRING. A key in the "owner" namespace for getting the real name of the user that owns the file. Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_STRING. A key in the "preview" namespace for getting a #GIcon that can be used to get preview of the file. For example, it may be a low resolution thumbnail without metadata. Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_OBJECT. The value for this key should contain a #GIcon. A key in the "recent" namespace for getting time, when the metadata for the file in `recent:///` was last changed. Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_INT64. A key in the "selinux" namespace for getting the file's SELinux context. Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_STRING. Note that this attribute is only available if GLib has been built with SELinux support. A key in the "standard" namespace for getting the amount of disk space that is consumed by the file (in bytes). This will generally be larger than the file size (due to block size overhead) but can occasionally be smaller (for example, for sparse files). Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT64. A key in the "standard" namespace for getting the content type of the file. Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_STRING. The value for this key should contain a valid content type. A key in the "standard" namespace for getting the copy name of the file. The copy name is an optional version of the name. If available it's always in UTF8, and corresponds directly to the original filename (only transcoded to UTF8). This is useful if you want to copy the file to another filesystem that might have a different encoding. If the filename is not a valid string in the encoding selected for the filesystem it is in then the copy name will not be set. Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_STRING. A key in the "standard" namespace for getting the description of the file. The description is a utf8 string that describes the file, generally containing the filename, but can also contain further information. Example descriptions could be "filename (on hostname)" for a remote file or "filename (in trash)" for a file in the trash. This is useful for instance as the window title when displaying a directory or for a bookmarks menu. Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_STRING. A key in the "standard" namespace for getting the display name of the file. A display name is guaranteed to be in UTF-8 and can thus be displayed in the UI. It is guaranteed to be set on every file. Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_STRING. A key in the "standard" namespace for edit name of the file. An edit name is similar to the display name, but it is meant to be used when you want to rename the file in the UI. The display name might contain information you don't want in the new filename (such as "(invalid unicode)" if the filename was in an invalid encoding). Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_STRING. A key in the "standard" namespace for getting the fast content type. The fast content type isn't as reliable as the regular one, as it only uses the filename to guess it, but it is faster to calculate than the regular content type. Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_STRING. A key in the "standard" namespace for getting the icon for the file. Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_OBJECT. The value for this key should contain a #GIcon. A key in the "standard" namespace for checking if a file is a backup file. Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN. A key in the "standard" namespace for checking if a file is hidden. Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN. A key in the "standard" namespace for checking if the file is a symlink. Typically the actual type is something else, if we followed the symlink to get the type. On Windows NTFS mountpoints are considered to be symlinks as well. Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN. A key in the "standard" namespace for checking if a file is virtual. Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN. A key in the "standard" namespace for checking if a file is volatile. This is meant for opaque, non-POSIX-like backends to indicate that the URI is not persistent. Applications should look at #G_FILE_ATTRIBUTE_STANDARD_SYMLINK_TARGET for the persistent URI. Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN. A key in the "standard" namespace for getting the name of the file. The name is the on-disk filename which may not be in any known encoding, and can thus not be generally displayed as is. It is guaranteed to be set on every file. Use #G_FILE_ATTRIBUTE_STANDARD_DISPLAY_NAME if you need to display the name in a user interface. Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BYTE_STRING. A key in the "standard" namespace for getting the file's size (in bytes). Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT64. A key in the "standard" namespace for setting the sort order of a file. Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_INT32. An example use would be in file managers, which would use this key to set the order files are displayed. Files with smaller sort order should be sorted first, and files without sort order as if sort order was zero. A key in the "standard" namespace for getting the symbolic icon for the file. Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_OBJECT. The value for this key should contain a #GIcon. A key in the "standard" namespace for getting the symlink target, if the file is a symlink. Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BYTE_STRING. A key in the "standard" namespace for getting the target URI for the file, in the case of %G_FILE_TYPE_SHORTCUT or %G_FILE_TYPE_MOUNTABLE files. Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_STRING. A key in the "standard" namespace for storing file types. Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT32. The value for this key should contain a #GFileType. A key in the "thumbnail" namespace for checking if thumbnailing failed. This attribute is %TRUE if thumbnailing failed. Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN. A key in the "thumbnail" namespace for checking whether the thumbnail is outdated. This attribute is %TRUE if the thumbnail is up-to-date with the file it represents, and %FALSE if the file has been modified since the thumbnail was generated. If %G_FILE_ATTRIBUTE_THUMBNAILING_FAILED is %TRUE and this attribute is %FALSE, it indicates that thumbnailing may be attempted again and may succeed. Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN. A key in the "thumbnail" namespace for getting the path to the thumbnail image. Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BYTE_STRING. A key in the "time" namespace for getting the time the file was last accessed. Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT64, and contains the time since the file was last accessed, in seconds since the UNIX epoch. A key in the "time" namespace for getting the microseconds of the time the file was last accessed. This should be used in conjunction with #G_FILE_ATTRIBUTE_TIME_ACCESS. Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT32. A key in the "time" namespace for getting the time the file was last changed. Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT64, and contains the time since the file was last changed, in seconds since the UNIX epoch. This corresponds to the traditional UNIX ctime. A key in the "time" namespace for getting the microseconds of the time the file was last changed. This should be used in conjunction with #G_FILE_ATTRIBUTE_TIME_CHANGED. Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT32. A key in the "time" namespace for getting the time the file was created. Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT64, and contains the time since the file was created, in seconds since the UNIX epoch. This may correspond to Linux stx_btime, FreeBSD st_birthtim, NetBSD st_birthtime or NTFS ctime. A key in the "time" namespace for getting the microseconds of the time the file was created. This should be used in conjunction with #G_FILE_ATTRIBUTE_TIME_CREATED. Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT32. A key in the "time" namespace for getting the time the file was last modified. Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT64, and contains the time since the file was modified, in seconds since the UNIX epoch. A key in the "time" namespace for getting the microseconds of the time the file was last modified. This should be used in conjunction with #G_FILE_ATTRIBUTE_TIME_MODIFIED. Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT32. A key in the "trash" namespace. When requested against items in `trash:///`, will return the date and time when the file was trashed. The format of the returned string is YYYY-MM-DDThh:mm:ss. Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_STRING. A key in the "trash" namespace. When requested against `trash:///` returns the number of (toplevel) items in the trash folder. Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT32. A key in the "trash" namespace. When requested against items in `trash:///`, will return the original path to the file before it was trashed. Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BYTE_STRING. A key in the "unix" namespace for getting the number of blocks allocated for the file. This attribute is only available for UNIX file systems. Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT64. A key in the "unix" namespace for getting the block size for the file system. This attribute is only available for UNIX file systems. Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT32. A key in the "unix" namespace for getting the device id of the device the file is located on (see stat() documentation). This attribute is only available for UNIX file systems. Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT32. A key in the "unix" namespace for getting the group ID for the file. This attribute is only available for UNIX file systems. Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT32. A key in the "unix" namespace for getting the inode of the file. This attribute is only available for UNIX file systems. Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT64. A key in the "unix" namespace for checking if the file represents a UNIX mount point. This attribute is %TRUE if the file is a UNIX mount point. Since 2.58, `/` is considered to be a mount point. This attribute is only available for UNIX file systems. Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN. A key in the "unix" namespace for getting the mode of the file (e.g. whether the file is a regular file, symlink, etc). See the documentation for `lstat()`: this attribute is equivalent to the `st_mode` member of `struct stat`, and includes both the file type and permissions. This attribute is only available for UNIX file systems. Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT32. A key in the "unix" namespace for getting the number of hard links for a file. See lstat() documentation. This attribute is only available for UNIX file systems. Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT32. A key in the "unix" namespace for getting the device ID for the file (if it is a special file). See lstat() documentation. This attribute is only available for UNIX file systems. Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT32. A key in the "unix" namespace for getting the user ID for the file. This attribute is only available for UNIX file systems. Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT32. #GFile is a high level abstraction for manipulating files on a virtual file system. #GFiles are lightweight, immutable objects that do no I/O upon creation. It is necessary to understand that #GFile objects do not represent files, merely an identifier for a file. All file content I/O is implemented as streaming operations (see #GInputStream and #GOutputStream). To construct a #GFile, you can use: - g_file_new_for_path() if you have a path. - g_file_new_for_uri() if you have a URI. - g_file_new_for_commandline_arg() for a command line argument. - g_file_new_tmp() to create a temporary file from a template. - g_file_parse_name() from a UTF-8 string gotten from g_file_get_parse_name(). - g_file_new_build_filename() to create a file from path elements. One way to think of a #GFile is as an abstraction of a pathname. For normal files the system pathname is what is stored internally, but as #GFiles are extensible it could also be something else that corresponds to a pathname in a userspace implementation of a filesystem. #GFiles make up hierarchies of directories and files that correspond to the files on a filesystem. You can move through the file system with #GFile using g_file_get_parent() to get an identifier for the parent directory, g_file_get_child() to get a child within a directory, g_file_resolve_relative_path() to resolve a relative path between two #GFiles. There can be multiple hierarchies, so you may not end up at the same root if you repeatedly call g_file_get_parent() on two different files. All #GFiles have a basename (get with g_file_get_basename()). These names are byte strings that are used to identify the file on the filesystem (relative to its parent directory) and there is no guarantees that they have any particular charset encoding or even make any sense at all. If you want to use filenames in a user interface you should use the display name that you can get by requesting the %G_FILE_ATTRIBUTE_STANDARD_DISPLAY_NAME attribute with g_file_query_info(). This is guaranteed to be in UTF-8 and can be used in a user interface. But always store the real basename or the #GFile to use to actually access the file, because there is no way to go from a display name to the actual name. Using #GFile as an identifier has the same weaknesses as using a path in that there may be multiple aliases for the same file. For instance, hard or soft links may cause two different #GFiles to refer to the same file. Other possible causes for aliases are: case insensitive filesystems, short and long names on FAT/NTFS, or bind mounts in Linux. If you want to check if two #GFiles point to the same file you can query for the %G_FILE_ATTRIBUTE_ID_FILE attribute. Note that #GFile does some trivial canonicalization of pathnames passed in, so that trivial differences in the path string used at creation (duplicated slashes, slash at end of path, "." or ".." path segments, etc) does not create different #GFiles. Many #GFile operations have both synchronous and asynchronous versions to suit your application. Asynchronous versions of synchronous functions simply have _async() appended to their function names. The asynchronous I/O functions call a #GAsyncReadyCallback which is then used to finalize the operation, producing a GAsyncResult which is then passed to the function's matching _finish() operation. It is highly recommended to use asynchronous calls when running within a shared main loop, such as in the main thread of an application. This avoids I/O operations blocking other sources on the main loop from being dispatched. Synchronous I/O operations should be performed from worker threads. See the [introduction to asynchronous programming section][async-programming] for more. Some #GFile operations almost always take a noticeable amount of time, and so do not have synchronous analogs. Notable cases include: - g_file_mount_mountable() to mount a mountable file. - g_file_unmount_mountable_with_operation() to unmount a mountable file. - g_file_eject_mountable_with_operation() to eject a mountable file. ## Entity Tags # {#gfile-etag} One notable feature of #GFiles are entity tags, or "etags" for short. Entity tags are somewhat like a more abstract version of the traditional mtime, and can be used to quickly determine if the file has been modified from the version on the file system. See the HTTP 1.1 [specification](http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html) for HTTP Etag headers, which are a very similar concept. Constructs a #GFile from a series of elements using the correct separator for filenames. Using this function is equivalent to calling g_build_filename(), followed by g_file_new_for_path() on the result. a new #GFile the first element in the path remaining elements in path, terminated by %NULL Creates a #GFile with the given argument from the command line. The value of @arg can be either a URI, an absolute path or a relative path resolved relative to the current working directory. This operation never fails, but the returned object might not support any I/O operation if @arg points to a malformed path. Note that on Windows, this function expects its argument to be in UTF-8 -- not the system code page. This means that you should not use this function with string from argv as it is passed to main(). g_win32_get_command_line() will return a UTF-8 version of the commandline. #GApplication also uses UTF-8 but g_application_command_line_create_file_for_arg() may be more useful for you there. It is also always possible to use this function with #GOptionContext arguments of type %G_OPTION_ARG_FILENAME. a new #GFile. Free the returned object with g_object_unref(). a command line string Creates a #GFile with the given argument from the command line. This function is similar to g_file_new_for_commandline_arg() except that it allows for passing the current working directory as an argument instead of using the current working directory of the process. This is useful if the commandline argument was given in a context other than the invocation of the current process. See also g_application_command_line_create_file_for_arg(). a new #GFile a command line string the current working directory of the commandline Constructs a #GFile for a given path. This operation never fails, but the returned object might not support any I/O operation if @path is malformed. a new #GFile for the given @path. Free the returned object with g_object_unref(). a string containing a relative or absolute path. The string must be encoded in the glib filename encoding. Constructs a #GFile for a given URI. This operation never fails, but the returned object might not support any I/O operation if @uri is malformed or if the uri type is not supported. a new #GFile for the given @uri. Free the returned object with g_object_unref(). a UTF-8 string containing a URI Opens a file in the preferred directory for temporary files (as returned by g_get_tmp_dir()) and returns a #GFile and #GFileIOStream pointing to it. @tmpl should be a string in the GLib file name encoding containing a sequence of six 'X' characters, and containing no directory components. If it is %NULL, a default template is used. Unlike the other #GFile constructors, this will return %NULL if a temporary file could not be created. a new #GFile. Free the returned object with g_object_unref(). Template for the file name, as in g_file_open_tmp(), or %NULL for a default template on return, a #GFileIOStream for the created file Constructs a #GFile with the given @parse_name (i.e. something given by g_file_get_parse_name()). This operation never fails, but the returned object might not support any I/O operation if the @parse_name cannot be parsed. a new #GFile. a file name or path to be parsed Gets an output stream for appending data to the file. If the file doesn't already exist it is created. By default files created are generally readable by everyone, but if you pass #G_FILE_CREATE_PRIVATE in @flags the file will be made readable only to the current user, to the level that is supported on the target filesystem. If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. Some file systems don't allow all file names, and may return an %G_IO_ERROR_INVALID_FILENAME error. If the file is a directory the %G_IO_ERROR_IS_DIRECTORY error will be returned. Other errors are possible too, and depend on what kind of filesystem the file is on. a #GFileOutputStream, or %NULL on error. Free the returned object with g_object_unref(). input #GFile a set of #GFileCreateFlags optional #GCancellable object, %NULL to ignore Asynchronously opens @file for appending. For more details, see g_file_append_to() which is the synchronous version of this call. When the operation is finished, @callback will be called. You can then call g_file_append_to_finish() to get the result of the operation. input #GFile a set of #GFileCreateFlags the [I/O priority][io-priority] of the request optional #GCancellable object, %NULL to ignore a #GAsyncReadyCallback to call when the request is satisfied the data to pass to callback function Finishes an asynchronous file append operation started with g_file_append_to_async(). a valid #GFileOutputStream or %NULL on error. Free the returned object with g_object_unref(). input #GFile #GAsyncResult Copies the file @source to the location specified by @destination. Can not handle recursive copies of directories. If the flag #G_FILE_COPY_OVERWRITE is specified an already existing @destination file is overwritten. If the flag #G_FILE_COPY_NOFOLLOW_SYMLINKS is specified then symlinks will be copied as symlinks, otherwise the target of the @source symlink will be copied. If the flag #G_FILE_COPY_ALL_METADATA is specified then all the metadata that is possible to copy is copied, not just the default subset (which, for instance, does not include the owner, see #GFileInfo). If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If @progress_callback is not %NULL, then the operation can be monitored by setting this to a #GFileProgressCallback function. @progress_callback_data will be passed to this function. It is guaranteed that this callback will be called after all data has been transferred with the total number of bytes copied during the operation. If the @source file does not exist, then the %G_IO_ERROR_NOT_FOUND error is returned, independent on the status of the @destination. If #G_FILE_COPY_OVERWRITE is not specified and the target exists, then the error %G_IO_ERROR_EXISTS is returned. If trying to overwrite a file over a directory, the %G_IO_ERROR_IS_DIRECTORY error is returned. If trying to overwrite a directory with a directory the %G_IO_ERROR_WOULD_MERGE error is returned. If the source is a directory and the target does not exist, or #G_FILE_COPY_OVERWRITE is specified and the target is a file, then the %G_IO_ERROR_WOULD_RECURSE error is returned. If you are interested in copying the #GFile object itself (not the on-disk file), see g_file_dup(). %TRUE on success, %FALSE otherwise. input #GFile destination #GFile set of #GFileCopyFlags optional #GCancellable object, %NULL to ignore function to callback with progress information, or %NULL if progress information is not needed user data to pass to @progress_callback Copies the file @source to the location specified by @destination asynchronously. For details of the behaviour, see g_file_copy(). If @progress_callback is not %NULL, then that function that will be called just like in g_file_copy(). The callback will run in the default main context of the thread calling g_file_copy_async() — the same context as @callback is run in. When the operation is finished, @callback will be called. You can then call g_file_copy_finish() to get the result of the operation. input #GFile destination #GFile set of #GFileCopyFlags the [I/O priority][io-priority] of the request optional #GCancellable object, %NULL to ignore function to callback with progress information, or %NULL if progress information is not needed user data to pass to @progress_callback a #GAsyncReadyCallback to call when the request is satisfied the data to pass to callback function Finishes copying the file started with g_file_copy_async(). a %TRUE on success, %FALSE on error. input #GFile a #GAsyncResult Creates a new file and returns an output stream for writing to it. The file must not already exist. By default files created are generally readable by everyone, but if you pass #G_FILE_CREATE_PRIVATE in @flags the file will be made readable only to the current user, to the level that is supported on the target filesystem. If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If a file or directory with this name already exists the %G_IO_ERROR_EXISTS error will be returned. Some file systems don't allow all file names, and may return an %G_IO_ERROR_INVALID_FILENAME error, and if the name is to long %G_IO_ERROR_FILENAME_TOO_LONG will be returned. Other errors are possible too, and depend on what kind of filesystem the file is on. a #GFileOutputStream for the newly created file, or %NULL on error. Free the returned object with g_object_unref(). input #GFile a set of #GFileCreateFlags optional #GCancellable object, %NULL to ignore Asynchronously creates a new file and returns an output stream for writing to it. The file must not already exist. For more details, see g_file_create() which is the synchronous version of this call. When the operation is finished, @callback will be called. You can then call g_file_create_finish() to get the result of the operation. input #GFile a set of #GFileCreateFlags the [I/O priority][io-priority] of the request optional #GCancellable object, %NULL to ignore a #GAsyncReadyCallback to call when the request is satisfied the data to pass to callback function Finishes an asynchronous file create operation started with g_file_create_async(). a #GFileOutputStream or %NULL on error. Free the returned object with g_object_unref(). input #GFile a #GAsyncResult Creates a new file and returns a stream for reading and writing to it. The file must not already exist. By default files created are generally readable by everyone, but if you pass #G_FILE_CREATE_PRIVATE in @flags the file will be made readable only to the current user, to the level that is supported on the target filesystem. If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If a file or directory with this name already exists, the %G_IO_ERROR_EXISTS error will be returned. Some file systems don't allow all file names, and may return an %G_IO_ERROR_INVALID_FILENAME error, and if the name is too long, %G_IO_ERROR_FILENAME_TOO_LONG will be returned. Other errors are possible too, and depend on what kind of filesystem the file is on. Note that in many non-local file cases read and write streams are not supported, so make sure you really need to do read and write streaming, rather than just opening for reading or writing. a #GFileIOStream for the newly created file, or %NULL on error. Free the returned object with g_object_unref(). a #GFile a set of #GFileCreateFlags optional #GCancellable object, %NULL to ignore Asynchronously creates a new file and returns a stream for reading and writing to it. The file must not already exist. For more details, see g_file_create_readwrite() which is the synchronous version of this call. When the operation is finished, @callback will be called. You can then call g_file_create_readwrite_finish() to get the result of the operation. input #GFile a set of #GFileCreateFlags the [I/O priority][io-priority] of the request optional #GCancellable object, %NULL to ignore a #GAsyncReadyCallback to call when the request is satisfied the data to pass to callback function Finishes an asynchronous file create operation started with g_file_create_readwrite_async(). a #GFileIOStream or %NULL on error. Free the returned object with g_object_unref(). input #GFile a #GAsyncResult Deletes a file. If the @file is a directory, it will only be deleted if it is empty. This has the same semantics as g_unlink(). If @file doesn’t exist, %G_IO_ERROR_NOT_FOUND will be returned. This allows for deletion to be implemented avoiding [time-of-check to time-of-use races](https://en.wikipedia.org/wiki/Time-of-check_to_time-of-use): |[ g_autoptr(GError) local_error = NULL; if (!g_file_delete (my_file, my_cancellable, &local_error) && !g_error_matches (local_error, G_IO_ERROR, G_IO_ERROR_NOT_FOUND)) { // deletion failed for some reason other than the file not existing: // so report the error g_warning ("Failed to delete %s: %s", g_file_peek_path (my_file), local_error->message); } ]| If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. %TRUE if the file was deleted. %FALSE otherwise. input #GFile optional #GCancellable object, %NULL to ignore Asynchronously delete a file. If the @file is a directory, it will only be deleted if it is empty. This has the same semantics as g_unlink(). input #GFile the [I/O priority][io-priority] of the request optional #GCancellable object, %NULL to ignore a #GAsyncReadyCallback to call when the request is satisfied the data to pass to callback function Finishes deleting a file started with g_file_delete_async(). %TRUE if the file was deleted. %FALSE otherwise. input #GFile a #GAsyncResult Duplicates a #GFile handle. This operation does not duplicate the actual file or directory represented by the #GFile; see g_file_copy() if attempting to copy a file. g_file_dup() is useful when a second handle is needed to the same underlying file, for use in a separate thread (#GFile is not thread-safe). For use within the same thread, use g_object_ref() to increment the existing object’s reference count. This call does no blocking I/O. a new #GFile that is a duplicate of the given #GFile. input #GFile Starts an asynchronous eject on a mountable. When this operation has completed, @callback will be called with @user_user data, and the operation can be finalized with g_file_eject_mountable_finish(). If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. Use g_file_eject_mountable_with_operation() instead. input #GFile flags affecting the operation optional #GCancellable object, %NULL to ignore a #GAsyncReadyCallback to call when the request is satisfied, or %NULL the data to pass to callback function Finishes an asynchronous eject operation started by g_file_eject_mountable(). Use g_file_eject_mountable_with_operation_finish() instead. %TRUE if the @file was ejected successfully. %FALSE otherwise. input #GFile a #GAsyncResult Starts an asynchronous eject on a mountable. When this operation has completed, @callback will be called with @user_user data, and the operation can be finalized with g_file_eject_mountable_with_operation_finish(). If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. input #GFile flags affecting the operation a #GMountOperation, or %NULL to avoid user interaction optional #GCancellable object, %NULL to ignore a #GAsyncReadyCallback to call when the request is satisfied, or %NULL the data to pass to callback function Finishes an asynchronous eject operation started by g_file_eject_mountable_with_operation(). %TRUE if the @file was ejected successfully. %FALSE otherwise. input #GFile a #GAsyncResult Gets the requested information about the files in a directory. The result is a #GFileEnumerator object that will give out #GFileInfo objects for all the files in the directory. The @attributes value is a string that specifies the file attributes that should be gathered. It is not an error if it's not possible to read a particular requested attribute from a file - it just won't be set. @attributes should be a comma-separated list of attributes or attribute wildcards. The wildcard "*" means all attributes, and a wildcard like "standard::*" means all attributes in the standard namespace. An example attribute query be "standard::*,owner::user". The standard attributes are available as defines, like #G_FILE_ATTRIBUTE_STANDARD_NAME. If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If the file does not exist, the %G_IO_ERROR_NOT_FOUND error will be returned. If the file is not a directory, the %G_IO_ERROR_NOT_DIRECTORY error will be returned. Other errors are possible too. A #GFileEnumerator if successful, %NULL on error. Free the returned object with g_object_unref(). input #GFile an attribute query string a set of #GFileQueryInfoFlags optional #GCancellable object, %NULL to ignore Asynchronously gets the requested information about the files in a directory. The result is a #GFileEnumerator object that will give out #GFileInfo objects for all the files in the directory. For more details, see g_file_enumerate_children() which is the synchronous version of this call. When the operation is finished, @callback will be called. You can then call g_file_enumerate_children_finish() to get the result of the operation. input #GFile an attribute query string a set of #GFileQueryInfoFlags the [I/O priority][io-priority] of the request optional #GCancellable object, %NULL to ignore a #GAsyncReadyCallback to call when the request is satisfied the data to pass to callback function Finishes an async enumerate children operation. See g_file_enumerate_children_async(). a #GFileEnumerator or %NULL if an error occurred. Free the returned object with g_object_unref(). input #GFile a #GAsyncResult Checks if the two given #GFiles refer to the same file. Note that two #GFiles that differ can still refer to the same file on the filesystem due to various forms of filename aliasing. This call does no blocking I/O. %TRUE if @file1 and @file2 are equal. the first #GFile the second #GFile Gets a #GMount for the #GFile. #GMount is returned only for user interesting locations, see #GVolumeMonitor. If the #GFileIface for @file does not have a #mount, @error will be set to %G_IO_ERROR_NOT_FOUND and %NULL #will be returned. If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. a #GMount where the @file is located or %NULL on error. Free the returned object with g_object_unref(). input #GFile optional #GCancellable object, %NULL to ignore Asynchronously gets the mount for the file. For more details, see g_file_find_enclosing_mount() which is the synchronous version of this call. When the operation is finished, @callback will be called. You can then call g_file_find_enclosing_mount_finish() to get the result of the operation. a #GFile the [I/O priority][io-priority] of the request optional #GCancellable object, %NULL to ignore a #GAsyncReadyCallback to call when the request is satisfied the data to pass to callback function Finishes an asynchronous find mount request. See g_file_find_enclosing_mount_async(). #GMount for given @file or %NULL on error. Free the returned object with g_object_unref(). a #GFile a #GAsyncResult Gets the child of @file for a given @display_name (i.e. a UTF-8 version of the name). If this function fails, it returns %NULL and @error will be set. This is very useful when constructing a #GFile for a new file and the user entered the filename in the user interface, for instance when you select a directory and type a filename in the file selector. This call does no blocking I/O. a #GFile to the specified child, or %NULL if the display name couldn't be converted. Free the returned object with g_object_unref(). input #GFile string to a possible child Gets the parent directory for the @file. If the @file represents the root directory of the file system, then %NULL will be returned. This call does no blocking I/O. a #GFile structure to the parent of the given #GFile or %NULL if there is no parent. Free the returned object with g_object_unref(). input #GFile Gets the parse name of the @file. A parse name is a UTF-8 string that describes the file such that one can get the #GFile back using g_file_parse_name(). This is generally used to show the #GFile as a nice full-pathname kind of string in a user interface, like in a location entry. For local files with names that can safely be converted to UTF-8 the pathname is used, otherwise the IRI is used (a form of URI that allows UTF-8 characters unescaped). This call does no blocking I/O. a string containing the #GFile's parse name. The returned string should be freed with g_free() when no longer needed. input #GFile Gets the URI for the @file. This call does no blocking I/O. a string containing the #GFile's URI. The returned string should be freed with g_free() when no longer needed. input #GFile Gets the URI scheme for a #GFile. RFC 3986 decodes the scheme as: |[ URI = scheme ":" hier-part [ "?" query ] [ "#" fragment ] ]| Common schemes include "file", "http", "ftp", etc. This call does no blocking I/O. a string containing the URI scheme for the given #GFile. The returned string should be freed with g_free() when no longer needed. input #GFile Checks to see if a #GFile has a given URI scheme. This call does no blocking I/O. %TRUE if #GFile's backend supports the given URI scheme, %FALSE if URI scheme is %NULL, not supported, or #GFile is invalid. input #GFile a string containing a URI scheme Creates a hash value for a #GFile. This call does no blocking I/O. 0 if @file is not a valid #GFile, otherwise an integer that can be used as hash value for the #GFile. This function is intended for easily hashing a #GFile to add to a #GHashTable or similar data structure. #gconstpointer to a #GFile Checks to see if a file is native to the platform. A native file is one expressed in the platform-native filename format, e.g. "C:\Windows" or "/usr/bin/". This does not mean the file is local, as it might be on a locally mounted remote filesystem. On some systems non-native files may be available using the native filesystem via a userspace filesystem (FUSE), in these cases this call will return %FALSE, but g_file_get_path() will still return a native path. This call does no blocking I/O. %TRUE if @file is native input #GFile Creates a directory. Note that this will only create a child directory of the immediate parent directory of the path or URI given by the #GFile. To recursively create directories, see g_file_make_directory_with_parents(). This function will fail if the parent directory does not exist, setting @error to %G_IO_ERROR_NOT_FOUND. If the file system doesn't support creating directories, this function will fail, setting @error to %G_IO_ERROR_NOT_SUPPORTED. For a local #GFile the newly created directory will have the default (current) ownership and permissions of the current process. If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. %TRUE on successful creation, %FALSE otherwise. input #GFile optional #GCancellable object, %NULL to ignore Asynchronously creates a directory. input #GFile the [I/O priority][io-priority] of the request optional #GCancellable object, %NULL to ignore a #GAsyncReadyCallback to call when the request is satisfied the data to pass to callback function Finishes an asynchronous directory creation, started with g_file_make_directory_async(). %TRUE on successful directory creation, %FALSE otherwise. input #GFile a #GAsyncResult Creates a symbolic link named @file which contains the string @symlink_value. If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. %TRUE on the creation of a new symlink, %FALSE otherwise. a #GFile with the name of the symlink to create a string with the path for the target of the new symlink optional #GCancellable object, %NULL to ignore Recursively measures the disk usage of @file. This is essentially an analog of the 'du' command, but it also reports the number of directories and non-directory files encountered (including things like symbolic links). By default, errors are only reported against the toplevel file itself. Errors found while recursing are silently ignored, unless %G_FILE_MEASURE_REPORT_ANY_ERROR is given in @flags. The returned size, @disk_usage, is in bytes and should be formatted with g_format_size() in order to get something reasonable for showing in a user interface. @progress_callback and @progress_data can be given to request periodic progress updates while scanning. See the documentation for #GFileMeasureProgressCallback for information about when and how the callback will be invoked. %TRUE if successful, with the out parameters set. %FALSE otherwise, with @error set. a #GFile #GFileMeasureFlags optional #GCancellable a #GFileMeasureProgressCallback user_data for @progress_callback the number of bytes of disk space used the number of directories encountered the number of non-directories encountered Recursively measures the disk usage of @file. This is the asynchronous version of g_file_measure_disk_usage(). See there for more information. a #GFile #GFileMeasureFlags the [I/O priority][io-priority] of the request optional #GCancellable a #GFileMeasureProgressCallback user_data for @progress_callback a #GAsyncReadyCallback to call when complete the data to pass to callback function Collects the results from an earlier call to g_file_measure_disk_usage_async(). See g_file_measure_disk_usage() for more information. %TRUE if successful, with the out parameters set. %FALSE otherwise, with @error set. a #GFile the #GAsyncResult passed to your #GAsyncReadyCallback the number of bytes of disk space used the number of directories encountered the number of non-directories encountered Obtains a directory monitor for the given file. This may fail if directory monitoring is not supported. If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. It does not make sense for @flags to contain %G_FILE_MONITOR_WATCH_HARD_LINKS, since hard links can not be made to directories. It is not possible to monitor all the files in a directory for changes made via hard links; if you want to do this then you must register individual watches with g_file_monitor(). a #GFileMonitor for the given @file, or %NULL on error. Free the returned object with g_object_unref(). input #GFile a set of #GFileMonitorFlags optional #GCancellable object, %NULL to ignore Obtains a file monitor for the given file. If no file notification mechanism exists, then regular polling of the file is used. If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If @flags contains %G_FILE_MONITOR_WATCH_HARD_LINKS then the monitor will also attempt to report changes made to the file via another filename (ie, a hard link). Without this flag, you can only rely on changes made through the filename contained in @file to be reported. Using this flag may result in an increase in resource usage, and may not have any effect depending on the #GFileMonitor backend and/or filesystem type. a #GFileMonitor for the given @file, or %NULL on error. Free the returned object with g_object_unref(). input #GFile a set of #GFileMonitorFlags optional #GCancellable object, %NULL to ignore Starts a @mount_operation, mounting the volume that contains the file @location. When this operation has completed, @callback will be called with @user_user data, and the operation can be finalized with g_file_mount_enclosing_volume_finish(). If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. input #GFile flags affecting the operation a #GMountOperation or %NULL to avoid user interaction optional #GCancellable object, %NULL to ignore a #GAsyncReadyCallback to call when the request is satisfied, or %NULL the data to pass to callback function Finishes a mount operation started by g_file_mount_enclosing_volume(). %TRUE if successful. If an error has occurred, this function will return %FALSE and set @error appropriately if present. input #GFile a #GAsyncResult Mounts a file of type G_FILE_TYPE_MOUNTABLE. Using @mount_operation, you can request callbacks when, for instance, passwords are needed during authentication. If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. When the operation is finished, @callback will be called. You can then call g_file_mount_mountable_finish() to get the result of the operation. input #GFile flags affecting the operation a #GMountOperation, or %NULL to avoid user interaction optional #GCancellable object, %NULL to ignore a #GAsyncReadyCallback to call when the request is satisfied, or %NULL the data to pass to callback function Finishes a mount operation. See g_file_mount_mountable() for details. Finish an asynchronous mount operation that was started with g_file_mount_mountable(). a #GFile or %NULL on error. Free the returned object with g_object_unref(). input #GFile a #GAsyncResult Tries to move the file or directory @source to the location specified by @destination. If native move operations are supported then this is used, otherwise a copy + delete fallback is used. The native implementation may support moving directories (for instance on moves inside the same filesystem), but the fallback code does not. If the flag #G_FILE_COPY_OVERWRITE is specified an already existing @destination file is overwritten. If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If @progress_callback is not %NULL, then the operation can be monitored by setting this to a #GFileProgressCallback function. @progress_callback_data will be passed to this function. It is guaranteed that this callback will be called after all data has been transferred with the total number of bytes copied during the operation. If the @source file does not exist, then the %G_IO_ERROR_NOT_FOUND error is returned, independent on the status of the @destination. If #G_FILE_COPY_OVERWRITE is not specified and the target exists, then the error %G_IO_ERROR_EXISTS is returned. If trying to overwrite a file over a directory, the %G_IO_ERROR_IS_DIRECTORY error is returned. If trying to overwrite a directory with a directory the %G_IO_ERROR_WOULD_MERGE error is returned. If the source is a directory and the target does not exist, or #G_FILE_COPY_OVERWRITE is specified and the target is a file, then the %G_IO_ERROR_WOULD_RECURSE error may be returned (if the native move operation isn't available). %TRUE on successful move, %FALSE otherwise. #GFile pointing to the source location #GFile pointing to the destination location set of #GFileCopyFlags optional #GCancellable object, %NULL to ignore #GFileProgressCallback function for updates gpointer to user data for the callback function Opens an existing file for reading and writing. The result is a #GFileIOStream that can be used to read and write the contents of the file. If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If the file does not exist, the %G_IO_ERROR_NOT_FOUND error will be returned. If the file is a directory, the %G_IO_ERROR_IS_DIRECTORY error will be returned. Other errors are possible too, and depend on what kind of filesystem the file is on. Note that in many non-local file cases read and write streams are not supported, so make sure you really need to do read and write streaming, rather than just opening for reading or writing. #GFileIOStream or %NULL on error. Free the returned object with g_object_unref(). #GFile to open a #GCancellable Asynchronously opens @file for reading and writing. For more details, see g_file_open_readwrite() which is the synchronous version of this call. When the operation is finished, @callback will be called. You can then call g_file_open_readwrite_finish() to get the result of the operation. input #GFile the [I/O priority][io-priority] of the request optional #GCancellable object, %NULL to ignore a #GAsyncReadyCallback to call when the request is satisfied the data to pass to callback function Finishes an asynchronous file read operation started with g_file_open_readwrite_async(). a #GFileIOStream or %NULL on error. Free the returned object with g_object_unref(). input #GFile a #GAsyncResult Polls a file of type #G_FILE_TYPE_MOUNTABLE. If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. When the operation is finished, @callback will be called. You can then call g_file_mount_mountable_finish() to get the result of the operation. input #GFile optional #GCancellable object, %NULL to ignore a #GAsyncReadyCallback to call when the request is satisfied, or %NULL the data to pass to callback function Finishes a poll operation. See g_file_poll_mountable() for details. Finish an asynchronous poll operation that was polled with g_file_poll_mountable(). %TRUE if the operation finished successfully. %FALSE otherwise. input #GFile a #GAsyncResult Checks whether @file has the prefix specified by @prefix. In other words, if the names of initial elements of @file's pathname match @prefix. Only full pathname elements are matched, so a path like /foo is not considered a prefix of /foobar, only of /foo/bar. A #GFile is not a prefix of itself. If you want to check for equality, use g_file_equal(). This call does no I/O, as it works purely on names. As such it can sometimes return %FALSE even if @file is inside a @prefix (from a filesystem point of view), because the prefix of @file is an alias of @prefix. %TRUE if the @file's parent, grandparent, etc is @prefix, %FALSE otherwise. input #GFile input #GFile Similar to g_file_query_info(), but obtains information about the filesystem the @file is on, rather than the file itself. For instance the amount of space available and the type of the filesystem. The @attributes value is a string that specifies the attributes that should be gathered. It is not an error if it's not possible to read a particular requested attribute from a file - it just won't be set. @attributes should be a comma-separated list of attributes or attribute wildcards. The wildcard "*" means all attributes, and a wildcard like "filesystem::*" means all attributes in the filesystem namespace. The standard namespace for filesystem attributes is "filesystem". Common attributes of interest are #G_FILE_ATTRIBUTE_FILESYSTEM_SIZE (the total size of the filesystem in bytes), #G_FILE_ATTRIBUTE_FILESYSTEM_FREE (number of bytes available), and #G_FILE_ATTRIBUTE_FILESYSTEM_TYPE (type of the filesystem). If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If the file does not exist, the %G_IO_ERROR_NOT_FOUND error will be returned. Other errors are possible too, and depend on what kind of filesystem the file is on. a #GFileInfo or %NULL if there was an error. Free the returned object with g_object_unref(). input #GFile an attribute query string optional #GCancellable object, %NULL to ignore Asynchronously gets the requested information about the filesystem that the specified @file is on. The result is a #GFileInfo object that contains key-value attributes (such as type or size for the file). For more details, see g_file_query_filesystem_info() which is the synchronous version of this call. When the operation is finished, @callback will be called. You can then call g_file_query_info_finish() to get the result of the operation. input #GFile an attribute query string the [I/O priority][io-priority] of the request optional #GCancellable object, %NULL to ignore a #GAsyncReadyCallback to call when the request is satisfied the data to pass to callback function Finishes an asynchronous filesystem info query. See g_file_query_filesystem_info_async(). #GFileInfo for given @file or %NULL on error. Free the returned object with g_object_unref(). input #GFile a #GAsyncResult Gets the requested information about specified @file. The result is a #GFileInfo object that contains key-value attributes (such as the type or size of the file). The @attributes value is a string that specifies the file attributes that should be gathered. It is not an error if it's not possible to read a particular requested attribute from a file - it just won't be set. @attributes should be a comma-separated list of attributes or attribute wildcards. The wildcard "*" means all attributes, and a wildcard like "standard::*" means all attributes in the standard namespace. An example attribute query be "standard::*,owner::user". The standard attributes are available as defines, like #G_FILE_ATTRIBUTE_STANDARD_NAME. If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. For symlinks, normally the information about the target of the symlink is returned, rather than information about the symlink itself. However if you pass #G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS in @flags the information about the symlink itself will be returned. Also, for symlinks that point to non-existing files the information about the symlink itself will be returned. If the file does not exist, the %G_IO_ERROR_NOT_FOUND error will be returned. Other errors are possible too, and depend on what kind of filesystem the file is on. a #GFileInfo for the given @file, or %NULL on error. Free the returned object with g_object_unref(). input #GFile an attribute query string a set of #GFileQueryInfoFlags optional #GCancellable object, %NULL to ignore Asynchronously gets the requested information about specified @file. The result is a #GFileInfo object that contains key-value attributes (such as type or size for the file). For more details, see g_file_query_info() which is the synchronous version of this call. When the operation is finished, @callback will be called. You can then call g_file_query_info_finish() to get the result of the operation. input #GFile an attribute query string a set of #GFileQueryInfoFlags the [I/O priority][io-priority] of the request optional #GCancellable object, %NULL to ignore a #GAsyncReadyCallback to call when the request is satisfied the data to pass to callback function Finishes an asynchronous file info query. See g_file_query_info_async(). #GFileInfo for given @file or %NULL on error. Free the returned object with g_object_unref(). input #GFile a #GAsyncResult Obtain the list of settable attributes for the file. Returns the type and full attribute name of all the attributes that can be set on this file. This doesn't mean setting it will always succeed though, you might get an access failure, or some specific file may not support a specific attribute. If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. a #GFileAttributeInfoList describing the settable attributes. When you are done with it, release it with g_file_attribute_info_list_unref() input #GFile optional #GCancellable object, %NULL to ignore Obtain the list of attribute namespaces where new attributes can be created by a user. An example of this is extended attributes (in the "xattr" namespace). If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. a #GFileAttributeInfoList describing the writable namespaces. When you are done with it, release it with g_file_attribute_info_list_unref() input #GFile optional #GCancellable object, %NULL to ignore Asynchronously opens @file for reading. For more details, see g_file_read() which is the synchronous version of this call. When the operation is finished, @callback will be called. You can then call g_file_read_finish() to get the result of the operation. input #GFile the [I/O priority][io-priority] of the request optional #GCancellable object, %NULL to ignore a #GAsyncReadyCallback to call when the request is satisfied the data to pass to callback function Finishes an asynchronous file read operation started with g_file_read_async(). a #GFileInputStream or %NULL on error. Free the returned object with g_object_unref(). input #GFile a #GAsyncResult Opens a file for reading. The result is a #GFileInputStream that can be used to read the contents of the file. If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If the file does not exist, the %G_IO_ERROR_NOT_FOUND error will be returned. If the file is a directory, the %G_IO_ERROR_IS_DIRECTORY error will be returned. Other errors are possible too, and depend on what kind of filesystem the file is on. #GFileInputStream or %NULL on error. Free the returned object with g_object_unref(). #GFile to read a #GCancellable Returns an output stream for overwriting the file, possibly creating a backup copy of the file first. If the file doesn't exist, it will be created. This will try to replace the file in the safest way possible so that any errors during the writing will not affect an already existing copy of the file. For instance, for local files it may write to a temporary file and then atomically rename over the destination when the stream is closed. By default files created are generally readable by everyone, but if you pass #G_FILE_CREATE_PRIVATE in @flags the file will be made readable only to the current user, to the level that is supported on the target filesystem. If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If you pass in a non-%NULL @etag value and @file already exists, then this value is compared to the current entity tag of the file, and if they differ an %G_IO_ERROR_WRONG_ETAG error is returned. This generally means that the file has been changed since you last read it. You can get the new etag from g_file_output_stream_get_etag() after you've finished writing and closed the #GFileOutputStream. When you load a new file you can use g_file_input_stream_query_info() to get the etag of the file. If @make_backup is %TRUE, this function will attempt to make a backup of the current file before overwriting it. If this fails a %G_IO_ERROR_CANT_CREATE_BACKUP error will be returned. If you want to replace anyway, try again with @make_backup set to %FALSE. If the file is a directory the %G_IO_ERROR_IS_DIRECTORY error will be returned, and if the file is some other form of non-regular file then a %G_IO_ERROR_NOT_REGULAR_FILE error will be returned. Some file systems don't allow all file names, and may return an %G_IO_ERROR_INVALID_FILENAME error, and if the name is to long %G_IO_ERROR_FILENAME_TOO_LONG will be returned. Other errors are possible too, and depend on what kind of filesystem the file is on. a #GFileOutputStream or %NULL on error. Free the returned object with g_object_unref(). input #GFile an optional [entity tag][gfile-etag] for the current #GFile, or #NULL to ignore %TRUE if a backup should be created a set of #GFileCreateFlags optional #GCancellable object, %NULL to ignore Asynchronously overwrites the file, replacing the contents, possibly creating a backup copy of the file first. For more details, see g_file_replace() which is the synchronous version of this call. When the operation is finished, @callback will be called. You can then call g_file_replace_finish() to get the result of the operation. input #GFile an [entity tag][gfile-etag] for the current #GFile, or %NULL to ignore %TRUE if a backup should be created a set of #GFileCreateFlags the [I/O priority][io-priority] of the request optional #GCancellable object, %NULL to ignore a #GAsyncReadyCallback to call when the request is satisfied the data to pass to callback function Finishes an asynchronous file replace operation started with g_file_replace_async(). a #GFileOutputStream, or %NULL on error. Free the returned object with g_object_unref(). input #GFile a #GAsyncResult Returns an output stream for overwriting the file in readwrite mode, possibly creating a backup copy of the file first. If the file doesn't exist, it will be created. For details about the behaviour, see g_file_replace() which does the same thing but returns an output stream only. Note that in many non-local file cases read and write streams are not supported, so make sure you really need to do read and write streaming, rather than just opening for reading or writing. a #GFileIOStream or %NULL on error. Free the returned object with g_object_unref(). a #GFile an optional [entity tag][gfile-etag] for the current #GFile, or #NULL to ignore %TRUE if a backup should be created a set of #GFileCreateFlags optional #GCancellable object, %NULL to ignore Asynchronously overwrites the file in read-write mode, replacing the contents, possibly creating a backup copy of the file first. For more details, see g_file_replace_readwrite() which is the synchronous version of this call. When the operation is finished, @callback will be called. You can then call g_file_replace_readwrite_finish() to get the result of the operation. input #GFile an [entity tag][gfile-etag] for the current #GFile, or %NULL to ignore %TRUE if a backup should be created a set of #GFileCreateFlags the [I/O priority][io-priority] of the request optional #GCancellable object, %NULL to ignore a #GAsyncReadyCallback to call when the request is satisfied the data to pass to callback function Finishes an asynchronous file replace operation started with g_file_replace_readwrite_async(). a #GFileIOStream, or %NULL on error. Free the returned object with g_object_unref(). input #GFile a #GAsyncResult Resolves a relative path for @file to an absolute path. This call does no blocking I/O. #GFile to the resolved path. %NULL if @relative_path is %NULL or if @file is invalid. Free the returned object with g_object_unref(). input #GFile a given relative path string Sets an attribute in the file with attribute name @attribute to @value_p. Some attributes can be unset by setting @type to %G_FILE_ATTRIBUTE_TYPE_INVALID and @value_p to %NULL. If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. %TRUE if the attribute was set, %FALSE otherwise. input #GFile a string containing the attribute's name The type of the attribute a pointer to the value (or the pointer itself if the type is a pointer type) a set of #GFileQueryInfoFlags optional #GCancellable object, %NULL to ignore Asynchronously sets the attributes of @file with @info. For more details, see g_file_set_attributes_from_info(), which is the synchronous version of this call. When the operation is finished, @callback will be called. You can then call g_file_set_attributes_finish() to get the result of the operation. input #GFile a #GFileInfo a #GFileQueryInfoFlags the [I/O priority][io-priority] of the request optional #GCancellable object, %NULL to ignore a #GAsyncReadyCallback a #gpointer Finishes setting an attribute started in g_file_set_attributes_async(). %TRUE if the attributes were set correctly, %FALSE otherwise. input #GFile a #GAsyncResult a #GFileInfo Tries to set all attributes in the #GFileInfo on the target values, not stopping on the first error. If there is any error during this operation then @error will be set to the first error. Error on particular fields are flagged by setting the "status" field in the attribute value to %G_FILE_ATTRIBUTE_STATUS_ERROR_SETTING, which means you can also detect further errors. If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. %FALSE if there was any error, %TRUE otherwise. input #GFile a #GFileInfo #GFileQueryInfoFlags optional #GCancellable object, %NULL to ignore Renames @file to the specified display name. The display name is converted from UTF-8 to the correct encoding for the target filesystem if possible and the @file is renamed to this. If you want to implement a rename operation in the user interface the edit name (#G_FILE_ATTRIBUTE_STANDARD_EDIT_NAME) should be used as the initial value in the rename widget, and then the result after editing should be passed to g_file_set_display_name(). On success the resulting converted filename is returned. If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. a #GFile specifying what @file was renamed to, or %NULL if there was an error. Free the returned object with g_object_unref(). input #GFile a string optional #GCancellable object, %NULL to ignore Asynchronously sets the display name for a given #GFile. For more details, see g_file_set_display_name() which is the synchronous version of this call. When the operation is finished, @callback will be called. You can then call g_file_set_display_name_finish() to get the result of the operation. input #GFile a string the [I/O priority][io-priority] of the request optional #GCancellable object, %NULL to ignore a #GAsyncReadyCallback to call when the request is satisfied the data to pass to callback function Finishes setting a display name started with g_file_set_display_name_async(). a #GFile or %NULL on error. Free the returned object with g_object_unref(). input #GFile a #GAsyncResult Starts a file of type #G_FILE_TYPE_MOUNTABLE. Using @start_operation, you can request callbacks when, for instance, passwords are needed during authentication. If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. When the operation is finished, @callback will be called. You can then call g_file_mount_mountable_finish() to get the result of the operation. input #GFile flags affecting the operation a #GMountOperation, or %NULL to avoid user interaction optional #GCancellable object, %NULL to ignore a #GAsyncReadyCallback to call when the request is satisfied, or %NULL the data to pass to callback function Finishes a start operation. See g_file_start_mountable() for details. Finish an asynchronous start operation that was started with g_file_start_mountable(). %TRUE if the operation finished successfully. %FALSE otherwise. input #GFile a #GAsyncResult Stops a file of type #G_FILE_TYPE_MOUNTABLE. If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. When the operation is finished, @callback will be called. You can then call g_file_stop_mountable_finish() to get the result of the operation. input #GFile flags affecting the operation a #GMountOperation, or %NULL to avoid user interaction. optional #GCancellable object, %NULL to ignore a #GAsyncReadyCallback to call when the request is satisfied, or %NULL the data to pass to callback function Finishes a stop operation, see g_file_stop_mountable() for details. Finish an asynchronous stop operation that was started with g_file_stop_mountable(). %TRUE if the operation finished successfully. %FALSE otherwise. input #GFile a #GAsyncResult Sends @file to the "Trashcan", if possible. This is similar to deleting it, but the user can recover it before emptying the trashcan. Not all file systems support trashing, so this call can return the %G_IO_ERROR_NOT_SUPPORTED error. Since GLib 2.66, the `x-gvfs-notrash` unix mount option can be used to disable g_file_trash() support for certain mounts, the %G_IO_ERROR_NOT_SUPPORTED error will be returned in that case. If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. %TRUE on successful trash, %FALSE otherwise. #GFile to send to trash optional #GCancellable object, %NULL to ignore Asynchronously sends @file to the Trash location, if possible. input #GFile the [I/O priority][io-priority] of the request optional #GCancellable object, %NULL to ignore a #GAsyncReadyCallback to call when the request is satisfied the data to pass to callback function Finishes an asynchronous file trashing operation, started with g_file_trash_async(). %TRUE on successful trash, %FALSE otherwise. input #GFile a #GAsyncResult Unmounts a file of type G_FILE_TYPE_MOUNTABLE. If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. When the operation is finished, @callback will be called. You can then call g_file_unmount_mountable_finish() to get the result of the operation. Use g_file_unmount_mountable_with_operation() instead. input #GFile flags affecting the operation optional #GCancellable object, %NULL to ignore a #GAsyncReadyCallback to call when the request is satisfied, or %NULL the data to pass to callback function Finishes an unmount operation, see g_file_unmount_mountable() for details. Finish an asynchronous unmount operation that was started with g_file_unmount_mountable(). Use g_file_unmount_mountable_with_operation_finish() instead. %TRUE if the operation finished successfully. %FALSE otherwise. input #GFile a #GAsyncResult Unmounts a file of type #G_FILE_TYPE_MOUNTABLE. If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. When the operation is finished, @callback will be called. You can then call g_file_unmount_mountable_finish() to get the result of the operation. input #GFile flags affecting the operation a #GMountOperation, or %NULL to avoid user interaction optional #GCancellable object, %NULL to ignore a #GAsyncReadyCallback to call when the request is satisfied, or %NULL the data to pass to callback function Finishes an unmount operation, see g_file_unmount_mountable_with_operation() for details. Finish an asynchronous unmount operation that was started with g_file_unmount_mountable_with_operation(). %TRUE if the operation finished successfully. %FALSE otherwise. input #GFile a #GAsyncResult Gets an output stream for appending data to the file. If the file doesn't already exist it is created. By default files created are generally readable by everyone, but if you pass #G_FILE_CREATE_PRIVATE in @flags the file will be made readable only to the current user, to the level that is supported on the target filesystem. If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. Some file systems don't allow all file names, and may return an %G_IO_ERROR_INVALID_FILENAME error. If the file is a directory the %G_IO_ERROR_IS_DIRECTORY error will be returned. Other errors are possible too, and depend on what kind of filesystem the file is on. a #GFileOutputStream, or %NULL on error. Free the returned object with g_object_unref(). input #GFile a set of #GFileCreateFlags optional #GCancellable object, %NULL to ignore Asynchronously opens @file for appending. For more details, see g_file_append_to() which is the synchronous version of this call. When the operation is finished, @callback will be called. You can then call g_file_append_to_finish() to get the result of the operation. input #GFile a set of #GFileCreateFlags the [I/O priority][io-priority] of the request optional #GCancellable object, %NULL to ignore a #GAsyncReadyCallback to call when the request is satisfied the data to pass to callback function Finishes an asynchronous file append operation started with g_file_append_to_async(). a valid #GFileOutputStream or %NULL on error. Free the returned object with g_object_unref(). input #GFile #GAsyncResult Copies the file @source to the location specified by @destination. Can not handle recursive copies of directories. If the flag #G_FILE_COPY_OVERWRITE is specified an already existing @destination file is overwritten. If the flag #G_FILE_COPY_NOFOLLOW_SYMLINKS is specified then symlinks will be copied as symlinks, otherwise the target of the @source symlink will be copied. If the flag #G_FILE_COPY_ALL_METADATA is specified then all the metadata that is possible to copy is copied, not just the default subset (which, for instance, does not include the owner, see #GFileInfo). If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If @progress_callback is not %NULL, then the operation can be monitored by setting this to a #GFileProgressCallback function. @progress_callback_data will be passed to this function. It is guaranteed that this callback will be called after all data has been transferred with the total number of bytes copied during the operation. If the @source file does not exist, then the %G_IO_ERROR_NOT_FOUND error is returned, independent on the status of the @destination. If #G_FILE_COPY_OVERWRITE is not specified and the target exists, then the error %G_IO_ERROR_EXISTS is returned. If trying to overwrite a file over a directory, the %G_IO_ERROR_IS_DIRECTORY error is returned. If trying to overwrite a directory with a directory the %G_IO_ERROR_WOULD_MERGE error is returned. If the source is a directory and the target does not exist, or #G_FILE_COPY_OVERWRITE is specified and the target is a file, then the %G_IO_ERROR_WOULD_RECURSE error is returned. If you are interested in copying the #GFile object itself (not the on-disk file), see g_file_dup(). %TRUE on success, %FALSE otherwise. input #GFile destination #GFile set of #GFileCopyFlags optional #GCancellable object, %NULL to ignore function to callback with progress information, or %NULL if progress information is not needed user data to pass to @progress_callback Copies the file @source to the location specified by @destination asynchronously. For details of the behaviour, see g_file_copy(). If @progress_callback is not %NULL, then that function that will be called just like in g_file_copy(). The callback will run in the default main context of the thread calling g_file_copy_async() — the same context as @callback is run in. When the operation is finished, @callback will be called. You can then call g_file_copy_finish() to get the result of the operation. input #GFile destination #GFile set of #GFileCopyFlags the [I/O priority][io-priority] of the request optional #GCancellable object, %NULL to ignore function to callback with progress information, or %NULL if progress information is not needed user data to pass to @progress_callback a #GAsyncReadyCallback to call when the request is satisfied the data to pass to callback function Copies the file attributes from @source to @destination. Normally only a subset of the file attributes are copied, those that are copies in a normal file copy operation (which for instance does not include e.g. owner). However if #G_FILE_COPY_ALL_METADATA is specified in @flags, then all the metadata that is possible to copy is copied. This is useful when implementing move by copy + delete source. %TRUE if the attributes were copied successfully, %FALSE otherwise. a #GFile with attributes a #GFile to copy attributes to a set of #GFileCopyFlags optional #GCancellable object, %NULL to ignore Finishes copying the file started with g_file_copy_async(). a %TRUE on success, %FALSE on error. input #GFile a #GAsyncResult Creates a new file and returns an output stream for writing to it. The file must not already exist. By default files created are generally readable by everyone, but if you pass #G_FILE_CREATE_PRIVATE in @flags the file will be made readable only to the current user, to the level that is supported on the target filesystem. If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If a file or directory with this name already exists the %G_IO_ERROR_EXISTS error will be returned. Some file systems don't allow all file names, and may return an %G_IO_ERROR_INVALID_FILENAME error, and if the name is to long %G_IO_ERROR_FILENAME_TOO_LONG will be returned. Other errors are possible too, and depend on what kind of filesystem the file is on. a #GFileOutputStream for the newly created file, or %NULL on error. Free the returned object with g_object_unref(). input #GFile a set of #GFileCreateFlags optional #GCancellable object, %NULL to ignore Asynchronously creates a new file and returns an output stream for writing to it. The file must not already exist. For more details, see g_file_create() which is the synchronous version of this call. When the operation is finished, @callback will be called. You can then call g_file_create_finish() to get the result of the operation. input #GFile a set of #GFileCreateFlags the [I/O priority][io-priority] of the request optional #GCancellable object, %NULL to ignore a #GAsyncReadyCallback to call when the request is satisfied the data to pass to callback function Finishes an asynchronous file create operation started with g_file_create_async(). a #GFileOutputStream or %NULL on error. Free the returned object with g_object_unref(). input #GFile a #GAsyncResult Creates a new file and returns a stream for reading and writing to it. The file must not already exist. By default files created are generally readable by everyone, but if you pass #G_FILE_CREATE_PRIVATE in @flags the file will be made readable only to the current user, to the level that is supported on the target filesystem. If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If a file or directory with this name already exists, the %G_IO_ERROR_EXISTS error will be returned. Some file systems don't allow all file names, and may return an %G_IO_ERROR_INVALID_FILENAME error, and if the name is too long, %G_IO_ERROR_FILENAME_TOO_LONG will be returned. Other errors are possible too, and depend on what kind of filesystem the file is on. Note that in many non-local file cases read and write streams are not supported, so make sure you really need to do read and write streaming, rather than just opening for reading or writing. a #GFileIOStream for the newly created file, or %NULL on error. Free the returned object with g_object_unref(). a #GFile a set of #GFileCreateFlags optional #GCancellable object, %NULL to ignore Asynchronously creates a new file and returns a stream for reading and writing to it. The file must not already exist. For more details, see g_file_create_readwrite() which is the synchronous version of this call. When the operation is finished, @callback will be called. You can then call g_file_create_readwrite_finish() to get the result of the operation. input #GFile a set of #GFileCreateFlags the [I/O priority][io-priority] of the request optional #GCancellable object, %NULL to ignore a #GAsyncReadyCallback to call when the request is satisfied the data to pass to callback function Finishes an asynchronous file create operation started with g_file_create_readwrite_async(). a #GFileIOStream or %NULL on error. Free the returned object with g_object_unref(). input #GFile a #GAsyncResult Deletes a file. If the @file is a directory, it will only be deleted if it is empty. This has the same semantics as g_unlink(). If @file doesn’t exist, %G_IO_ERROR_NOT_FOUND will be returned. This allows for deletion to be implemented avoiding [time-of-check to time-of-use races](https://en.wikipedia.org/wiki/Time-of-check_to_time-of-use): |[ g_autoptr(GError) local_error = NULL; if (!g_file_delete (my_file, my_cancellable, &local_error) && !g_error_matches (local_error, G_IO_ERROR, G_IO_ERROR_NOT_FOUND)) { // deletion failed for some reason other than the file not existing: // so report the error g_warning ("Failed to delete %s: %s", g_file_peek_path (my_file), local_error->message); } ]| If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. %TRUE if the file was deleted. %FALSE otherwise. input #GFile optional #GCancellable object, %NULL to ignore Asynchronously delete a file. If the @file is a directory, it will only be deleted if it is empty. This has the same semantics as g_unlink(). input #GFile the [I/O priority][io-priority] of the request optional #GCancellable object, %NULL to ignore a #GAsyncReadyCallback to call when the request is satisfied the data to pass to callback function Finishes deleting a file started with g_file_delete_async(). %TRUE if the file was deleted. %FALSE otherwise. input #GFile a #GAsyncResult Duplicates a #GFile handle. This operation does not duplicate the actual file or directory represented by the #GFile; see g_file_copy() if attempting to copy a file. g_file_dup() is useful when a second handle is needed to the same underlying file, for use in a separate thread (#GFile is not thread-safe). For use within the same thread, use g_object_ref() to increment the existing object’s reference count. This call does no blocking I/O. a new #GFile that is a duplicate of the given #GFile. input #GFile Starts an asynchronous eject on a mountable. When this operation has completed, @callback will be called with @user_user data, and the operation can be finalized with g_file_eject_mountable_finish(). If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. Use g_file_eject_mountable_with_operation() instead. input #GFile flags affecting the operation optional #GCancellable object, %NULL to ignore a #GAsyncReadyCallback to call when the request is satisfied, or %NULL the data to pass to callback function Finishes an asynchronous eject operation started by g_file_eject_mountable(). Use g_file_eject_mountable_with_operation_finish() instead. %TRUE if the @file was ejected successfully. %FALSE otherwise. input #GFile a #GAsyncResult Starts an asynchronous eject on a mountable. When this operation has completed, @callback will be called with @user_user data, and the operation can be finalized with g_file_eject_mountable_with_operation_finish(). If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. input #GFile flags affecting the operation a #GMountOperation, or %NULL to avoid user interaction optional #GCancellable object, %NULL to ignore a #GAsyncReadyCallback to call when the request is satisfied, or %NULL the data to pass to callback function Finishes an asynchronous eject operation started by g_file_eject_mountable_with_operation(). %TRUE if the @file was ejected successfully. %FALSE otherwise. input #GFile a #GAsyncResult Gets the requested information about the files in a directory. The result is a #GFileEnumerator object that will give out #GFileInfo objects for all the files in the directory. The @attributes value is a string that specifies the file attributes that should be gathered. It is not an error if it's not possible to read a particular requested attribute from a file - it just won't be set. @attributes should be a comma-separated list of attributes or attribute wildcards. The wildcard "*" means all attributes, and a wildcard like "standard::*" means all attributes in the standard namespace. An example attribute query be "standard::*,owner::user". The standard attributes are available as defines, like #G_FILE_ATTRIBUTE_STANDARD_NAME. If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If the file does not exist, the %G_IO_ERROR_NOT_FOUND error will be returned. If the file is not a directory, the %G_IO_ERROR_NOT_DIRECTORY error will be returned. Other errors are possible too. A #GFileEnumerator if successful, %NULL on error. Free the returned object with g_object_unref(). input #GFile an attribute query string a set of #GFileQueryInfoFlags optional #GCancellable object, %NULL to ignore Asynchronously gets the requested information about the files in a directory. The result is a #GFileEnumerator object that will give out #GFileInfo objects for all the files in the directory. For more details, see g_file_enumerate_children() which is the synchronous version of this call. When the operation is finished, @callback will be called. You can then call g_file_enumerate_children_finish() to get the result of the operation. input #GFile an attribute query string a set of #GFileQueryInfoFlags the [I/O priority][io-priority] of the request optional #GCancellable object, %NULL to ignore a #GAsyncReadyCallback to call when the request is satisfied the data to pass to callback function Finishes an async enumerate children operation. See g_file_enumerate_children_async(). a #GFileEnumerator or %NULL if an error occurred. Free the returned object with g_object_unref(). input #GFile a #GAsyncResult Checks if the two given #GFiles refer to the same file. Note that two #GFiles that differ can still refer to the same file on the filesystem due to various forms of filename aliasing. This call does no blocking I/O. %TRUE if @file1 and @file2 are equal. the first #GFile the second #GFile Gets a #GMount for the #GFile. #GMount is returned only for user interesting locations, see #GVolumeMonitor. If the #GFileIface for @file does not have a #mount, @error will be set to %G_IO_ERROR_NOT_FOUND and %NULL #will be returned. If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. a #GMount where the @file is located or %NULL on error. Free the returned object with g_object_unref(). input #GFile optional #GCancellable object, %NULL to ignore Asynchronously gets the mount for the file. For more details, see g_file_find_enclosing_mount() which is the synchronous version of this call. When the operation is finished, @callback will be called. You can then call g_file_find_enclosing_mount_finish() to get the result of the operation. a #GFile the [I/O priority][io-priority] of the request optional #GCancellable object, %NULL to ignore a #GAsyncReadyCallback to call when the request is satisfied the data to pass to callback function Finishes an asynchronous find mount request. See g_file_find_enclosing_mount_async(). #GMount for given @file or %NULL on error. Free the returned object with g_object_unref(). a #GFile a #GAsyncResult Gets the base name (the last component of the path) for a given #GFile. If called for the top level of a system (such as the filesystem root or a uri like sftp://host/) it will return a single directory separator (and on Windows, possibly a drive letter). The base name is a byte string (not UTF-8). It has no defined encoding or rules other than it may not contain zero bytes. If you want to use filenames in a user interface you should use the display name that you can get by requesting the %G_FILE_ATTRIBUTE_STANDARD_DISPLAY_NAME attribute with g_file_query_info(). This call does no blocking I/O. string containing the #GFile's base name, or %NULL if given #GFile is invalid. The returned string should be freed with g_free() when no longer needed. input #GFile Gets a child of @file with basename equal to @name. Note that the file with that specific name might not exist, but you can still have a #GFile that points to it. You can use this for instance to create that file. This call does no blocking I/O. a #GFile to a child specified by @name. Free the returned object with g_object_unref(). input #GFile string containing the child's basename Gets the child of @file for a given @display_name (i.e. a UTF-8 version of the name). If this function fails, it returns %NULL and @error will be set. This is very useful when constructing a #GFile for a new file and the user entered the filename in the user interface, for instance when you select a directory and type a filename in the file selector. This call does no blocking I/O. a #GFile to the specified child, or %NULL if the display name couldn't be converted. Free the returned object with g_object_unref(). input #GFile string to a possible child Gets the parent directory for the @file. If the @file represents the root directory of the file system, then %NULL will be returned. This call does no blocking I/O. a #GFile structure to the parent of the given #GFile or %NULL if there is no parent. Free the returned object with g_object_unref(). input #GFile Gets the parse name of the @file. A parse name is a UTF-8 string that describes the file such that one can get the #GFile back using g_file_parse_name(). This is generally used to show the #GFile as a nice full-pathname kind of string in a user interface, like in a location entry. For local files with names that can safely be converted to UTF-8 the pathname is used, otherwise the IRI is used (a form of URI that allows UTF-8 characters unescaped). This call does no blocking I/O. a string containing the #GFile's parse name. The returned string should be freed with g_free() when no longer needed. input #GFile Gets the local pathname for #GFile, if one exists. If non-%NULL, this is guaranteed to be an absolute, canonical path. It might contain symlinks. This call does no blocking I/O. string containing the #GFile's path, or %NULL if no such path exists. The returned string should be freed with g_free() when no longer needed. input #GFile Gets the path for @descendant relative to @parent. This call does no blocking I/O. string with the relative path from @descendant to @parent, or %NULL if @descendant doesn't have @parent as prefix. The returned string should be freed with g_free() when no longer needed. input #GFile input #GFile Gets the URI for the @file. This call does no blocking I/O. a string containing the #GFile's URI. The returned string should be freed with g_free() when no longer needed. input #GFile Gets the URI scheme for a #GFile. RFC 3986 decodes the scheme as: |[ URI = scheme ":" hier-part [ "?" query ] [ "#" fragment ] ]| Common schemes include "file", "http", "ftp", etc. This call does no blocking I/O. a string containing the URI scheme for the given #GFile. The returned string should be freed with g_free() when no longer needed. input #GFile Checks if @file has a parent, and optionally, if it is @parent. If @parent is %NULL then this function returns %TRUE if @file has any parent at all. If @parent is non-%NULL then %TRUE is only returned if @file is an immediate child of @parent. %TRUE if @file is an immediate child of @parent (or any parent in the case that @parent is %NULL). input #GFile the parent to check for, or %NULL Checks whether @file has the prefix specified by @prefix. In other words, if the names of initial elements of @file's pathname match @prefix. Only full pathname elements are matched, so a path like /foo is not considered a prefix of /foobar, only of /foo/bar. A #GFile is not a prefix of itself. If you want to check for equality, use g_file_equal(). This call does no I/O, as it works purely on names. As such it can sometimes return %FALSE even if @file is inside a @prefix (from a filesystem point of view), because the prefix of @file is an alias of @prefix. %TRUE if the @file's parent, grandparent, etc is @prefix, %FALSE otherwise. input #GFile input #GFile Checks to see if a #GFile has a given URI scheme. This call does no blocking I/O. %TRUE if #GFile's backend supports the given URI scheme, %FALSE if URI scheme is %NULL, not supported, or #GFile is invalid. input #GFile a string containing a URI scheme Creates a hash value for a #GFile. This call does no blocking I/O. 0 if @file is not a valid #GFile, otherwise an integer that can be used as hash value for the #GFile. This function is intended for easily hashing a #GFile to add to a #GHashTable or similar data structure. #gconstpointer to a #GFile Checks to see if a file is native to the platform. A native file is one expressed in the platform-native filename format, e.g. "C:\Windows" or "/usr/bin/". This does not mean the file is local, as it might be on a locally mounted remote filesystem. On some systems non-native files may be available using the native filesystem via a userspace filesystem (FUSE), in these cases this call will return %FALSE, but g_file_get_path() will still return a native path. This call does no blocking I/O. %TRUE if @file is native input #GFile Loads the contents of @file and returns it as #GBytes. If @file is a resource:// based URI, the resulting bytes will reference the embedded resource instead of a copy. Otherwise, this is equivalent to calling g_file_load_contents() and g_bytes_new_take(). For resources, @etag_out will be set to %NULL. The data contained in the resulting #GBytes is always zero-terminated, but this is not included in the #GBytes length. The resulting #GBytes should be freed with g_bytes_unref() when no longer in use. a #GBytes or %NULL and @error is set a #GFile a #GCancellable or %NULL a location to place the current entity tag for the file, or %NULL if the entity tag is not needed Asynchronously loads the contents of @file as #GBytes. If @file is a resource:// based URI, the resulting bytes will reference the embedded resource instead of a copy. Otherwise, this is equivalent to calling g_file_load_contents_async() and g_bytes_new_take(). @callback should call g_file_load_bytes_finish() to get the result of this asynchronous operation. See g_file_load_bytes() for more information. a #GFile a #GCancellable or %NULL a #GAsyncReadyCallback to call when the request is satisfied the data to pass to callback function Completes an asynchronous request to g_file_load_bytes_async(). For resources, @etag_out will be set to %NULL. The data contained in the resulting #GBytes is always zero-terminated, but this is not included in the #GBytes length. The resulting #GBytes should be freed with g_bytes_unref() when no longer in use. See g_file_load_bytes() for more information. a #GBytes or %NULL and @error is set a #GFile a #GAsyncResult provided to the callback a location to place the current entity tag for the file, or %NULL if the entity tag is not needed Loads the content of the file into memory. The data is always zero-terminated, but this is not included in the resultant @length. The returned @contents should be freed with g_free() when no longer needed. If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. %TRUE if the @file's contents were successfully loaded. %FALSE if there were errors. input #GFile optional #GCancellable object, %NULL to ignore a location to place the contents of the file a location to place the length of the contents of the file, or %NULL if the length is not needed a location to place the current entity tag for the file, or %NULL if the entity tag is not needed Starts an asynchronous load of the @file's contents. For more details, see g_file_load_contents() which is the synchronous version of this call. When the load operation has completed, @callback will be called with @user data. To finish the operation, call g_file_load_contents_finish() with the #GAsyncResult returned by the @callback. If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. input #GFile optional #GCancellable object, %NULL to ignore a #GAsyncReadyCallback to call when the request is satisfied the data to pass to callback function Finishes an asynchronous load of the @file's contents. The contents are placed in @contents, and @length is set to the size of the @contents string. The @contents should be freed with g_free() when no longer needed. If @etag_out is present, it will be set to the new entity tag for the @file. %TRUE if the load was successful. If %FALSE and @error is present, it will be set appropriately. input #GFile a #GAsyncResult a location to place the contents of the file a location to place the length of the contents of the file, or %NULL if the length is not needed a location to place the current entity tag for the file, or %NULL if the entity tag is not needed Reads the partial contents of a file. A #GFileReadMoreCallback should be used to stop reading from the file when appropriate, else this function will behave exactly as g_file_load_contents_async(). This operation can be finished by g_file_load_partial_contents_finish(). Users of this function should be aware that @user_data is passed to both the @read_more_callback and the @callback. If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. input #GFile optional #GCancellable object, %NULL to ignore a #GFileReadMoreCallback to receive partial data and to specify whether further data should be read a #GAsyncReadyCallback to call when the request is satisfied the data to pass to the callback functions Finishes an asynchronous partial load operation that was started with g_file_load_partial_contents_async(). The data is always zero-terminated, but this is not included in the resultant @length. The returned @contents should be freed with g_free() when no longer needed. %TRUE if the load was successful. If %FALSE and @error is present, it will be set appropriately. input #GFile a #GAsyncResult a location to place the contents of the file a location to place the length of the contents of the file, or %NULL if the length is not needed a location to place the current entity tag for the file, or %NULL if the entity tag is not needed Creates a directory. Note that this will only create a child directory of the immediate parent directory of the path or URI given by the #GFile. To recursively create directories, see g_file_make_directory_with_parents(). This function will fail if the parent directory does not exist, setting @error to %G_IO_ERROR_NOT_FOUND. If the file system doesn't support creating directories, this function will fail, setting @error to %G_IO_ERROR_NOT_SUPPORTED. For a local #GFile the newly created directory will have the default (current) ownership and permissions of the current process. If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. %TRUE on successful creation, %FALSE otherwise. input #GFile optional #GCancellable object, %NULL to ignore Asynchronously creates a directory. input #GFile the [I/O priority][io-priority] of the request optional #GCancellable object, %NULL to ignore a #GAsyncReadyCallback to call when the request is satisfied the data to pass to callback function Finishes an asynchronous directory creation, started with g_file_make_directory_async(). %TRUE on successful directory creation, %FALSE otherwise. input #GFile a #GAsyncResult Creates a directory and any parent directories that may not exist similar to 'mkdir -p'. If the file system does not support creating directories, this function will fail, setting @error to %G_IO_ERROR_NOT_SUPPORTED. If the directory itself already exists, this function will fail setting @error to %G_IO_ERROR_EXISTS, unlike the similar g_mkdir_with_parents(). For a local #GFile the newly created directories will have the default (current) ownership and permissions of the current process. If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. %TRUE if all directories have been successfully created, %FALSE otherwise. input #GFile optional #GCancellable object, %NULL to ignore Creates a symbolic link named @file which contains the string @symlink_value. If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. %TRUE on the creation of a new symlink, %FALSE otherwise. a #GFile with the name of the symlink to create a string with the path for the target of the new symlink optional #GCancellable object, %NULL to ignore Recursively measures the disk usage of @file. This is essentially an analog of the 'du' command, but it also reports the number of directories and non-directory files encountered (including things like symbolic links). By default, errors are only reported against the toplevel file itself. Errors found while recursing are silently ignored, unless %G_FILE_MEASURE_REPORT_ANY_ERROR is given in @flags. The returned size, @disk_usage, is in bytes and should be formatted with g_format_size() in order to get something reasonable for showing in a user interface. @progress_callback and @progress_data can be given to request periodic progress updates while scanning. See the documentation for #GFileMeasureProgressCallback for information about when and how the callback will be invoked. %TRUE if successful, with the out parameters set. %FALSE otherwise, with @error set. a #GFile #GFileMeasureFlags optional #GCancellable a #GFileMeasureProgressCallback user_data for @progress_callback the number of bytes of disk space used the number of directories encountered the number of non-directories encountered Recursively measures the disk usage of @file. This is the asynchronous version of g_file_measure_disk_usage(). See there for more information. a #GFile #GFileMeasureFlags the [I/O priority][io-priority] of the request optional #GCancellable a #GFileMeasureProgressCallback user_data for @progress_callback a #GAsyncReadyCallback to call when complete the data to pass to callback function Collects the results from an earlier call to g_file_measure_disk_usage_async(). See g_file_measure_disk_usage() for more information. %TRUE if successful, with the out parameters set. %FALSE otherwise, with @error set. a #GFile the #GAsyncResult passed to your #GAsyncReadyCallback the number of bytes of disk space used the number of directories encountered the number of non-directories encountered Obtains a file or directory monitor for the given file, depending on the type of the file. If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. a #GFileMonitor for the given @file, or %NULL on error. Free the returned object with g_object_unref(). input #GFile a set of #GFileMonitorFlags optional #GCancellable object, %NULL to ignore Obtains a directory monitor for the given file. This may fail if directory monitoring is not supported. If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. It does not make sense for @flags to contain %G_FILE_MONITOR_WATCH_HARD_LINKS, since hard links can not be made to directories. It is not possible to monitor all the files in a directory for changes made via hard links; if you want to do this then you must register individual watches with g_file_monitor(). a #GFileMonitor for the given @file, or %NULL on error. Free the returned object with g_object_unref(). input #GFile a set of #GFileMonitorFlags optional #GCancellable object, %NULL to ignore Obtains a file monitor for the given file. If no file notification mechanism exists, then regular polling of the file is used. If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If @flags contains %G_FILE_MONITOR_WATCH_HARD_LINKS then the monitor will also attempt to report changes made to the file via another filename (ie, a hard link). Without this flag, you can only rely on changes made through the filename contained in @file to be reported. Using this flag may result in an increase in resource usage, and may not have any effect depending on the #GFileMonitor backend and/or filesystem type. a #GFileMonitor for the given @file, or %NULL on error. Free the returned object with g_object_unref(). input #GFile a set of #GFileMonitorFlags optional #GCancellable object, %NULL to ignore Starts a @mount_operation, mounting the volume that contains the file @location. When this operation has completed, @callback will be called with @user_user data, and the operation can be finalized with g_file_mount_enclosing_volume_finish(). If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. input #GFile flags affecting the operation a #GMountOperation or %NULL to avoid user interaction optional #GCancellable object, %NULL to ignore a #GAsyncReadyCallback to call when the request is satisfied, or %NULL the data to pass to callback function Finishes a mount operation started by g_file_mount_enclosing_volume(). %TRUE if successful. If an error has occurred, this function will return %FALSE and set @error appropriately if present. input #GFile a #GAsyncResult Mounts a file of type G_FILE_TYPE_MOUNTABLE. Using @mount_operation, you can request callbacks when, for instance, passwords are needed during authentication. If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. When the operation is finished, @callback will be called. You can then call g_file_mount_mountable_finish() to get the result of the operation. input #GFile flags affecting the operation a #GMountOperation, or %NULL to avoid user interaction optional #GCancellable object, %NULL to ignore a #GAsyncReadyCallback to call when the request is satisfied, or %NULL the data to pass to callback function Finishes a mount operation. See g_file_mount_mountable() for details. Finish an asynchronous mount operation that was started with g_file_mount_mountable(). a #GFile or %NULL on error. Free the returned object with g_object_unref(). input #GFile a #GAsyncResult Tries to move the file or directory @source to the location specified by @destination. If native move operations are supported then this is used, otherwise a copy + delete fallback is used. The native implementation may support moving directories (for instance on moves inside the same filesystem), but the fallback code does not. If the flag #G_FILE_COPY_OVERWRITE is specified an already existing @destination file is overwritten. If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If @progress_callback is not %NULL, then the operation can be monitored by setting this to a #GFileProgressCallback function. @progress_callback_data will be passed to this function. It is guaranteed that this callback will be called after all data has been transferred with the total number of bytes copied during the operation. If the @source file does not exist, then the %G_IO_ERROR_NOT_FOUND error is returned, independent on the status of the @destination. If #G_FILE_COPY_OVERWRITE is not specified and the target exists, then the error %G_IO_ERROR_EXISTS is returned. If trying to overwrite a file over a directory, the %G_IO_ERROR_IS_DIRECTORY error is returned. If trying to overwrite a directory with a directory the %G_IO_ERROR_WOULD_MERGE error is returned. If the source is a directory and the target does not exist, or #G_FILE_COPY_OVERWRITE is specified and the target is a file, then the %G_IO_ERROR_WOULD_RECURSE error may be returned (if the native move operation isn't available). %TRUE on successful move, %FALSE otherwise. #GFile pointing to the source location #GFile pointing to the destination location set of #GFileCopyFlags optional #GCancellable object, %NULL to ignore #GFileProgressCallback function for updates gpointer to user data for the callback function Opens an existing file for reading and writing. The result is a #GFileIOStream that can be used to read and write the contents of the file. If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If the file does not exist, the %G_IO_ERROR_NOT_FOUND error will be returned. If the file is a directory, the %G_IO_ERROR_IS_DIRECTORY error will be returned. Other errors are possible too, and depend on what kind of filesystem the file is on. Note that in many non-local file cases read and write streams are not supported, so make sure you really need to do read and write streaming, rather than just opening for reading or writing. #GFileIOStream or %NULL on error. Free the returned object with g_object_unref(). #GFile to open a #GCancellable Asynchronously opens @file for reading and writing. For more details, see g_file_open_readwrite() which is the synchronous version of this call. When the operation is finished, @callback will be called. You can then call g_file_open_readwrite_finish() to get the result of the operation. input #GFile the [I/O priority][io-priority] of the request optional #GCancellable object, %NULL to ignore a #GAsyncReadyCallback to call when the request is satisfied the data to pass to callback function Finishes an asynchronous file read operation started with g_file_open_readwrite_async(). a #GFileIOStream or %NULL on error. Free the returned object with g_object_unref(). input #GFile a #GAsyncResult Exactly like g_file_get_path(), but caches the result via g_object_set_qdata_full(). This is useful for example in C applications which mix `g_file_*` APIs with native ones. It also avoids an extra duplicated string when possible, so will be generally more efficient. This call does no blocking I/O. string containing the #GFile's path, or %NULL if no such path exists. The returned string is owned by @file. input #GFile Polls a file of type #G_FILE_TYPE_MOUNTABLE. If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. When the operation is finished, @callback will be called. You can then call g_file_mount_mountable_finish() to get the result of the operation. input #GFile optional #GCancellable object, %NULL to ignore a #GAsyncReadyCallback to call when the request is satisfied, or %NULL the data to pass to callback function Finishes a poll operation. See g_file_poll_mountable() for details. Finish an asynchronous poll operation that was polled with g_file_poll_mountable(). %TRUE if the operation finished successfully. %FALSE otherwise. input #GFile a #GAsyncResult Returns the #GAppInfo that is registered as the default application to handle the file specified by @file. If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. a #GAppInfo if the handle was found, %NULL if there were errors. When you are done with it, release it with g_object_unref() a #GFile to open optional #GCancellable object, %NULL to ignore Async version of g_file_query_default_handler(). a #GFile to open the [I/O priority][io-priority] of the request optional #GCancellable object, %NULL to ignore a #GAsyncReadyCallback to call when the request is done data to pass to @callback Finishes a g_file_query_default_handler_async() operation. a #GAppInfo if the handle was found, %NULL if there were errors. When you are done with it, release it with g_object_unref() a #GFile to open a #GAsyncResult Utility function to check if a particular file exists. This is implemented using g_file_query_info() and as such does blocking I/O. Note that in many cases it is [racy to first check for file existence](https://en.wikipedia.org/wiki/Time_of_check_to_time_of_use) and then execute something based on the outcome of that, because the file might have been created or removed in between the operations. The general approach to handling that is to not check, but just do the operation and handle the errors as they come. As an example of race-free checking, take the case of reading a file, and if it doesn't exist, creating it. There are two racy versions: read it, and on error create it; and: check if it exists, if not create it. These can both result in two processes creating the file (with perhaps a partially written file as the result). The correct approach is to always try to create the file with g_file_create() which will either atomically create the file or fail with a %G_IO_ERROR_EXISTS error. However, in many cases an existence check is useful in a user interface, for instance to make a menu item sensitive/insensitive, so that you don't have to fool users that something is possible and then just show an error dialog. If you do this, you should make sure to also handle the errors that can happen due to races when you execute the operation. %TRUE if the file exists (and can be detected without error), %FALSE otherwise (or if cancelled). input #GFile optional #GCancellable object, %NULL to ignore Utility function to inspect the #GFileType of a file. This is implemented using g_file_query_info() and as such does blocking I/O. The primary use case of this method is to check if a file is a regular file, directory, or symlink. The #GFileType of the file and #G_FILE_TYPE_UNKNOWN if the file does not exist input #GFile a set of #GFileQueryInfoFlags passed to g_file_query_info() optional #GCancellable object, %NULL to ignore Similar to g_file_query_info(), but obtains information about the filesystem the @file is on, rather than the file itself. For instance the amount of space available and the type of the filesystem. The @attributes value is a string that specifies the attributes that should be gathered. It is not an error if it's not possible to read a particular requested attribute from a file - it just won't be set. @attributes should be a comma-separated list of attributes or attribute wildcards. The wildcard "*" means all attributes, and a wildcard like "filesystem::*" means all attributes in the filesystem namespace. The standard namespace for filesystem attributes is "filesystem". Common attributes of interest are #G_FILE_ATTRIBUTE_FILESYSTEM_SIZE (the total size of the filesystem in bytes), #G_FILE_ATTRIBUTE_FILESYSTEM_FREE (number of bytes available), and #G_FILE_ATTRIBUTE_FILESYSTEM_TYPE (type of the filesystem). If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If the file does not exist, the %G_IO_ERROR_NOT_FOUND error will be returned. Other errors are possible too, and depend on what kind of filesystem the file is on. a #GFileInfo or %NULL if there was an error. Free the returned object with g_object_unref(). input #GFile an attribute query string optional #GCancellable object, %NULL to ignore Asynchronously gets the requested information about the filesystem that the specified @file is on. The result is a #GFileInfo object that contains key-value attributes (such as type or size for the file). For more details, see g_file_query_filesystem_info() which is the synchronous version of this call. When the operation is finished, @callback will be called. You can then call g_file_query_info_finish() to get the result of the operation. input #GFile an attribute query string the [I/O priority][io-priority] of the request optional #GCancellable object, %NULL to ignore a #GAsyncReadyCallback to call when the request is satisfied the data to pass to callback function Finishes an asynchronous filesystem info query. See g_file_query_filesystem_info_async(). #GFileInfo for given @file or %NULL on error. Free the returned object with g_object_unref(). input #GFile a #GAsyncResult Gets the requested information about specified @file. The result is a #GFileInfo object that contains key-value attributes (such as the type or size of the file). The @attributes value is a string that specifies the file attributes that should be gathered. It is not an error if it's not possible to read a particular requested attribute from a file - it just won't be set. @attributes should be a comma-separated list of attributes or attribute wildcards. The wildcard "*" means all attributes, and a wildcard like "standard::*" means all attributes in the standard namespace. An example attribute query be "standard::*,owner::user". The standard attributes are available as defines, like #G_FILE_ATTRIBUTE_STANDARD_NAME. If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. For symlinks, normally the information about the target of the symlink is returned, rather than information about the symlink itself. However if you pass #G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS in @flags the information about the symlink itself will be returned. Also, for symlinks that point to non-existing files the information about the symlink itself will be returned. If the file does not exist, the %G_IO_ERROR_NOT_FOUND error will be returned. Other errors are possible too, and depend on what kind of filesystem the file is on. a #GFileInfo for the given @file, or %NULL on error. Free the returned object with g_object_unref(). input #GFile an attribute query string a set of #GFileQueryInfoFlags optional #GCancellable object, %NULL to ignore Asynchronously gets the requested information about specified @file. The result is a #GFileInfo object that contains key-value attributes (such as type or size for the file). For more details, see g_file_query_info() which is the synchronous version of this call. When the operation is finished, @callback will be called. You can then call g_file_query_info_finish() to get the result of the operation. input #GFile an attribute query string a set of #GFileQueryInfoFlags the [I/O priority][io-priority] of the request optional #GCancellable object, %NULL to ignore a #GAsyncReadyCallback to call when the request is satisfied the data to pass to callback function Finishes an asynchronous file info query. See g_file_query_info_async(). #GFileInfo for given @file or %NULL on error. Free the returned object with g_object_unref(). input #GFile a #GAsyncResult Obtain the list of settable attributes for the file. Returns the type and full attribute name of all the attributes that can be set on this file. This doesn't mean setting it will always succeed though, you might get an access failure, or some specific file may not support a specific attribute. If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. a #GFileAttributeInfoList describing the settable attributes. When you are done with it, release it with g_file_attribute_info_list_unref() input #GFile optional #GCancellable object, %NULL to ignore Obtain the list of attribute namespaces where new attributes can be created by a user. An example of this is extended attributes (in the "xattr" namespace). If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. a #GFileAttributeInfoList describing the writable namespaces. When you are done with it, release it with g_file_attribute_info_list_unref() input #GFile optional #GCancellable object, %NULL to ignore Opens a file for reading. The result is a #GFileInputStream that can be used to read the contents of the file. If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If the file does not exist, the %G_IO_ERROR_NOT_FOUND error will be returned. If the file is a directory, the %G_IO_ERROR_IS_DIRECTORY error will be returned. Other errors are possible too, and depend on what kind of filesystem the file is on. #GFileInputStream or %NULL on error. Free the returned object with g_object_unref(). #GFile to read a #GCancellable Asynchronously opens @file for reading. For more details, see g_file_read() which is the synchronous version of this call. When the operation is finished, @callback will be called. You can then call g_file_read_finish() to get the result of the operation. input #GFile the [I/O priority][io-priority] of the request optional #GCancellable object, %NULL to ignore a #GAsyncReadyCallback to call when the request is satisfied the data to pass to callback function Finishes an asynchronous file read operation started with g_file_read_async(). a #GFileInputStream or %NULL on error. Free the returned object with g_object_unref(). input #GFile a #GAsyncResult Returns an output stream for overwriting the file, possibly creating a backup copy of the file first. If the file doesn't exist, it will be created. This will try to replace the file in the safest way possible so that any errors during the writing will not affect an already existing copy of the file. For instance, for local files it may write to a temporary file and then atomically rename over the destination when the stream is closed. By default files created are generally readable by everyone, but if you pass #G_FILE_CREATE_PRIVATE in @flags the file will be made readable only to the current user, to the level that is supported on the target filesystem. If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If you pass in a non-%NULL @etag value and @file already exists, then this value is compared to the current entity tag of the file, and if they differ an %G_IO_ERROR_WRONG_ETAG error is returned. This generally means that the file has been changed since you last read it. You can get the new etag from g_file_output_stream_get_etag() after you've finished writing and closed the #GFileOutputStream. When you load a new file you can use g_file_input_stream_query_info() to get the etag of the file. If @make_backup is %TRUE, this function will attempt to make a backup of the current file before overwriting it. If this fails a %G_IO_ERROR_CANT_CREATE_BACKUP error will be returned. If you want to replace anyway, try again with @make_backup set to %FALSE. If the file is a directory the %G_IO_ERROR_IS_DIRECTORY error will be returned, and if the file is some other form of non-regular file then a %G_IO_ERROR_NOT_REGULAR_FILE error will be returned. Some file systems don't allow all file names, and may return an %G_IO_ERROR_INVALID_FILENAME error, and if the name is to long %G_IO_ERROR_FILENAME_TOO_LONG will be returned. Other errors are possible too, and depend on what kind of filesystem the file is on. a #GFileOutputStream or %NULL on error. Free the returned object with g_object_unref(). input #GFile an optional [entity tag][gfile-etag] for the current #GFile, or #NULL to ignore %TRUE if a backup should be created a set of #GFileCreateFlags optional #GCancellable object, %NULL to ignore Asynchronously overwrites the file, replacing the contents, possibly creating a backup copy of the file first. For more details, see g_file_replace() which is the synchronous version of this call. When the operation is finished, @callback will be called. You can then call g_file_replace_finish() to get the result of the operation. input #GFile an [entity tag][gfile-etag] for the current #GFile, or %NULL to ignore %TRUE if a backup should be created a set of #GFileCreateFlags the [I/O priority][io-priority] of the request optional #GCancellable object, %NULL to ignore a #GAsyncReadyCallback to call when the request is satisfied the data to pass to callback function Replaces the contents of @file with @contents of @length bytes. If @etag is specified (not %NULL), any existing file must have that etag, or the error %G_IO_ERROR_WRONG_ETAG will be returned. If @make_backup is %TRUE, this function will attempt to make a backup of @file. Internally, it uses g_file_replace(), so will try to replace the file contents in the safest way possible. For example, atomic renames are used when replacing local files’ contents. If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. The returned @new_etag can be used to verify that the file hasn't changed the next time it is saved over. %TRUE if successful. If an error has occurred, this function will return %FALSE and set @error appropriately if present. input #GFile a string containing the new contents for @file the length of @contents in bytes the old [entity-tag][gfile-etag] for the document, or %NULL %TRUE if a backup should be created a set of #GFileCreateFlags a location to a new [entity tag][gfile-etag] for the document. This should be freed with g_free() when no longer needed, or %NULL optional #GCancellable object, %NULL to ignore Starts an asynchronous replacement of @file with the given @contents of @length bytes. @etag will replace the document's current entity tag. When this operation has completed, @callback will be called with @user_user data, and the operation can be finalized with g_file_replace_contents_finish(). If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If @make_backup is %TRUE, this function will attempt to make a backup of @file. Note that no copy of @contents will be made, so it must stay valid until @callback is called. See g_file_replace_contents_bytes_async() for a #GBytes version that will automatically hold a reference to the contents (without copying) for the duration of the call. input #GFile string of contents to replace the file with the length of @contents in bytes a new [entity tag][gfile-etag] for the @file, or %NULL %TRUE if a backup should be created a set of #GFileCreateFlags optional #GCancellable object, %NULL to ignore a #GAsyncReadyCallback to call when the request is satisfied the data to pass to callback function Same as g_file_replace_contents_async() but takes a #GBytes input instead. This function will keep a ref on @contents until the operation is done. Unlike g_file_replace_contents_async() this allows forgetting about the content without waiting for the callback. When this operation has completed, @callback will be called with @user_user data, and the operation can be finalized with g_file_replace_contents_finish(). input #GFile a #GBytes a new [entity tag][gfile-etag] for the @file, or %NULL %TRUE if a backup should be created a set of #GFileCreateFlags optional #GCancellable object, %NULL to ignore a #GAsyncReadyCallback to call when the request is satisfied the data to pass to callback function Finishes an asynchronous replace of the given @file. See g_file_replace_contents_async(). Sets @new_etag to the new entity tag for the document, if present. %TRUE on success, %FALSE on failure. input #GFile a #GAsyncResult a location of a new [entity tag][gfile-etag] for the document. This should be freed with g_free() when it is no longer needed, or %NULL Finishes an asynchronous file replace operation started with g_file_replace_async(). a #GFileOutputStream, or %NULL on error. Free the returned object with g_object_unref(). input #GFile a #GAsyncResult Returns an output stream for overwriting the file in readwrite mode, possibly creating a backup copy of the file first. If the file doesn't exist, it will be created. For details about the behaviour, see g_file_replace() which does the same thing but returns an output stream only. Note that in many non-local file cases read and write streams are not supported, so make sure you really need to do read and write streaming, rather than just opening for reading or writing. a #GFileIOStream or %NULL on error. Free the returned object with g_object_unref(). a #GFile an optional [entity tag][gfile-etag] for the current #GFile, or #NULL to ignore %TRUE if a backup should be created a set of #GFileCreateFlags optional #GCancellable object, %NULL to ignore Asynchronously overwrites the file in read-write mode, replacing the contents, possibly creating a backup copy of the file first. For more details, see g_file_replace_readwrite() which is the synchronous version of this call. When the operation is finished, @callback will be called. You can then call g_file_replace_readwrite_finish() to get the result of the operation. input #GFile an [entity tag][gfile-etag] for the current #GFile, or %NULL to ignore %TRUE if a backup should be created a set of #GFileCreateFlags the [I/O priority][io-priority] of the request optional #GCancellable object, %NULL to ignore a #GAsyncReadyCallback to call when the request is satisfied the data to pass to callback function Finishes an asynchronous file replace operation started with g_file_replace_readwrite_async(). a #GFileIOStream, or %NULL on error. Free the returned object with g_object_unref(). input #GFile a #GAsyncResult Resolves a relative path for @file to an absolute path. This call does no blocking I/O. #GFile to the resolved path. %NULL if @relative_path is %NULL or if @file is invalid. Free the returned object with g_object_unref(). input #GFile a given relative path string Sets an attribute in the file with attribute name @attribute to @value_p. Some attributes can be unset by setting @type to %G_FILE_ATTRIBUTE_TYPE_INVALID and @value_p to %NULL. If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. %TRUE if the attribute was set, %FALSE otherwise. input #GFile a string containing the attribute's name The type of the attribute a pointer to the value (or the pointer itself if the type is a pointer type) a set of #GFileQueryInfoFlags optional #GCancellable object, %NULL to ignore Sets @attribute of type %G_FILE_ATTRIBUTE_TYPE_BYTE_STRING to @value. If @attribute is of a different type, this operation will fail, returning %FALSE. If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. %TRUE if the @attribute was successfully set to @value in the @file, %FALSE otherwise. input #GFile a string containing the attribute's name a string containing the attribute's new value a #GFileQueryInfoFlags optional #GCancellable object, %NULL to ignore Sets @attribute of type %G_FILE_ATTRIBUTE_TYPE_INT32 to @value. If @attribute is of a different type, this operation will fail. If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. %TRUE if the @attribute was successfully set to @value in the @file, %FALSE otherwise. input #GFile a string containing the attribute's name a #gint32 containing the attribute's new value a #GFileQueryInfoFlags optional #GCancellable object, %NULL to ignore Sets @attribute of type %G_FILE_ATTRIBUTE_TYPE_INT64 to @value. If @attribute is of a different type, this operation will fail. If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. %TRUE if the @attribute was successfully set, %FALSE otherwise. input #GFile a string containing the attribute's name a #guint64 containing the attribute's new value a #GFileQueryInfoFlags optional #GCancellable object, %NULL to ignore Sets @attribute of type %G_FILE_ATTRIBUTE_TYPE_STRING to @value. If @attribute is of a different type, this operation will fail. If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. %TRUE if the @attribute was successfully set, %FALSE otherwise. input #GFile a string containing the attribute's name a string containing the attribute's value #GFileQueryInfoFlags optional #GCancellable object, %NULL to ignore Sets @attribute of type %G_FILE_ATTRIBUTE_TYPE_UINT32 to @value. If @attribute is of a different type, this operation will fail. If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. %TRUE if the @attribute was successfully set to @value in the @file, %FALSE otherwise. input #GFile a string containing the attribute's name a #guint32 containing the attribute's new value a #GFileQueryInfoFlags optional #GCancellable object, %NULL to ignore Sets @attribute of type %G_FILE_ATTRIBUTE_TYPE_UINT64 to @value. If @attribute is of a different type, this operation will fail. If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. %TRUE if the @attribute was successfully set to @value in the @file, %FALSE otherwise. input #GFile a string containing the attribute's name a #guint64 containing the attribute's new value a #GFileQueryInfoFlags optional #GCancellable object, %NULL to ignore Asynchronously sets the attributes of @file with @info. For more details, see g_file_set_attributes_from_info(), which is the synchronous version of this call. When the operation is finished, @callback will be called. You can then call g_file_set_attributes_finish() to get the result of the operation. input #GFile a #GFileInfo a #GFileQueryInfoFlags the [I/O priority][io-priority] of the request optional #GCancellable object, %NULL to ignore a #GAsyncReadyCallback a #gpointer Finishes setting an attribute started in g_file_set_attributes_async(). %TRUE if the attributes were set correctly, %FALSE otherwise. input #GFile a #GAsyncResult a #GFileInfo Tries to set all attributes in the #GFileInfo on the target values, not stopping on the first error. If there is any error during this operation then @error will be set to the first error. Error on particular fields are flagged by setting the "status" field in the attribute value to %G_FILE_ATTRIBUTE_STATUS_ERROR_SETTING, which means you can also detect further errors. If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. %FALSE if there was any error, %TRUE otherwise. input #GFile a #GFileInfo #GFileQueryInfoFlags optional #GCancellable object, %NULL to ignore Renames @file to the specified display name. The display name is converted from UTF-8 to the correct encoding for the target filesystem if possible and the @file is renamed to this. If you want to implement a rename operation in the user interface the edit name (#G_FILE_ATTRIBUTE_STANDARD_EDIT_NAME) should be used as the initial value in the rename widget, and then the result after editing should be passed to g_file_set_display_name(). On success the resulting converted filename is returned. If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. a #GFile specifying what @file was renamed to, or %NULL if there was an error. Free the returned object with g_object_unref(). input #GFile a string optional #GCancellable object, %NULL to ignore Asynchronously sets the display name for a given #GFile. For more details, see g_file_set_display_name() which is the synchronous version of this call. When the operation is finished, @callback will be called. You can then call g_file_set_display_name_finish() to get the result of the operation. input #GFile a string the [I/O priority][io-priority] of the request optional #GCancellable object, %NULL to ignore a #GAsyncReadyCallback to call when the request is satisfied the data to pass to callback function Finishes setting a display name started with g_file_set_display_name_async(). a #GFile or %NULL on error. Free the returned object with g_object_unref(). input #GFile a #GAsyncResult Starts a file of type #G_FILE_TYPE_MOUNTABLE. Using @start_operation, you can request callbacks when, for instance, passwords are needed during authentication. If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. When the operation is finished, @callback will be called. You can then call g_file_mount_mountable_finish() to get the result of the operation. input #GFile flags affecting the operation a #GMountOperation, or %NULL to avoid user interaction optional #GCancellable object, %NULL to ignore a #GAsyncReadyCallback to call when the request is satisfied, or %NULL the data to pass to callback function Finishes a start operation. See g_file_start_mountable() for details. Finish an asynchronous start operation that was started with g_file_start_mountable(). %TRUE if the operation finished successfully. %FALSE otherwise. input #GFile a #GAsyncResult Stops a file of type #G_FILE_TYPE_MOUNTABLE. If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. When the operation is finished, @callback will be called. You can then call g_file_stop_mountable_finish() to get the result of the operation. input #GFile flags affecting the operation a #GMountOperation, or %NULL to avoid user interaction. optional #GCancellable object, %NULL to ignore a #GAsyncReadyCallback to call when the request is satisfied, or %NULL the data to pass to callback function Finishes a stop operation, see g_file_stop_mountable() for details. Finish an asynchronous stop operation that was started with g_file_stop_mountable(). %TRUE if the operation finished successfully. %FALSE otherwise. input #GFile a #GAsyncResult Checks if @file supports [thread-default contexts][g-main-context-push-thread-default-context]. If this returns %FALSE, you cannot perform asynchronous operations on @file in a thread that has a thread-default context. Whether or not @file supports thread-default contexts. a #GFile Sends @file to the "Trashcan", if possible. This is similar to deleting it, but the user can recover it before emptying the trashcan. Not all file systems support trashing, so this call can return the %G_IO_ERROR_NOT_SUPPORTED error. Since GLib 2.66, the `x-gvfs-notrash` unix mount option can be used to disable g_file_trash() support for certain mounts, the %G_IO_ERROR_NOT_SUPPORTED error will be returned in that case. If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. %TRUE on successful trash, %FALSE otherwise. #GFile to send to trash optional #GCancellable object, %NULL to ignore Asynchronously sends @file to the Trash location, if possible. input #GFile the [I/O priority][io-priority] of the request optional #GCancellable object, %NULL to ignore a #GAsyncReadyCallback to call when the request is satisfied the data to pass to callback function Finishes an asynchronous file trashing operation, started with g_file_trash_async(). %TRUE on successful trash, %FALSE otherwise. input #GFile a #GAsyncResult Unmounts a file of type G_FILE_TYPE_MOUNTABLE. If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. When the operation is finished, @callback will be called. You can then call g_file_unmount_mountable_finish() to get the result of the operation. Use g_file_unmount_mountable_with_operation() instead. input #GFile flags affecting the operation optional #GCancellable object, %NULL to ignore a #GAsyncReadyCallback to call when the request is satisfied, or %NULL the data to pass to callback function Finishes an unmount operation, see g_file_unmount_mountable() for details. Finish an asynchronous unmount operation that was started with g_file_unmount_mountable(). Use g_file_unmount_mountable_with_operation_finish() instead. %TRUE if the operation finished successfully. %FALSE otherwise. input #GFile a #GAsyncResult Unmounts a file of type #G_FILE_TYPE_MOUNTABLE. If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. When the operation is finished, @callback will be called. You can then call g_file_unmount_mountable_finish() to get the result of the operation. input #GFile flags affecting the operation a #GMountOperation, or %NULL to avoid user interaction optional #GCancellable object, %NULL to ignore a #GAsyncReadyCallback to call when the request is satisfied, or %NULL the data to pass to callback function Finishes an unmount operation, see g_file_unmount_mountable_with_operation() for details. Finish an asynchronous unmount operation that was started with g_file_unmount_mountable_with_operation(). %TRUE if the operation finished successfully. %FALSE otherwise. input #GFile a #GAsyncResult Information about a specific attribute. the name of the attribute. the #GFileAttributeType type of the attribute. a set of #GFileAttributeInfoFlags. Flags specifying the behaviour of an attribute. no flags set. copy the attribute values when the file is copied. copy the attribute values when the file is moved. Acts as a lightweight registry for possible valid file attributes. The registry stores Key-Value pair formats as #GFileAttributeInfos. an array of #GFileAttributeInfos. the number of values in the array. Creates a new file attribute info list. a #GFileAttributeInfoList. Adds a new attribute with @name to the @list, setting its @type and @flags. a #GFileAttributeInfoList. the name of the attribute to add. the #GFileAttributeType for the attribute. #GFileAttributeInfoFlags for the attribute. Makes a duplicate of a file attribute info list. a copy of the given @list. a #GFileAttributeInfoList to duplicate. Gets the file attribute with the name @name from @list. a #GFileAttributeInfo for the @name, or %NULL if an attribute isn't found. a #GFileAttributeInfoList. the name of the attribute to look up. References a file attribute info list. #GFileAttributeInfoList or %NULL on error. a #GFileAttributeInfoList to reference. Removes a reference from the given @list. If the reference count falls to zero, the @list is deleted. The #GFileAttributeInfoList to unreference. Determines if a string matches a file attribute. Creates a new file attribute matcher, which matches attributes against a given string. #GFileAttributeMatchers are reference counted structures, and are created with a reference count of 1. If the number of references falls to 0, the #GFileAttributeMatcher is automatically destroyed. The @attributes string should be formatted with specific keys separated from namespaces with a double colon. Several "namespace::key" strings may be concatenated with a single comma (e.g. "standard::type,standard::is-hidden"). The wildcard "*" may be used to match all keys and namespaces, or "namespace::*" will match all keys in a given namespace. ## Examples of file attribute matcher strings and results - `"*"`: matches all attributes. - `"standard::is-hidden"`: matches only the key is-hidden in the standard namespace. - `"standard::type,unix::*"`: matches the type key in the standard namespace and all keys in the unix namespace. a #GFileAttributeMatcher an attribute string to match. Checks if the matcher will match all of the keys in a given namespace. This will always return %TRUE if a wildcard character is in use (e.g. if matcher was created with "standard::*" and @ns is "standard", or if matcher was created using "*" and namespace is anything.) TODO: this is awkwardly worded. %TRUE if the matcher matches all of the entries in the given @ns, %FALSE otherwise. a #GFileAttributeMatcher. a string containing a file attribute namespace. Gets the next matched attribute from a #GFileAttributeMatcher. a string containing the next attribute or, %NULL if no more attribute exist. a #GFileAttributeMatcher. Checks if an attribute will be matched by an attribute matcher. If the matcher was created with the "*" matching string, this function will always return %TRUE. %TRUE if @attribute matches @matcher. %FALSE otherwise. a #GFileAttributeMatcher. a file attribute key. Checks if a attribute matcher only matches a given attribute. Always returns %FALSE if "*" was used when creating the matcher. %TRUE if the matcher only matches @attribute. %FALSE otherwise. a #GFileAttributeMatcher. a file attribute key. References a file attribute matcher. a #GFileAttributeMatcher. a #GFileAttributeMatcher. Subtracts all attributes of @subtract from @matcher and returns a matcher that supports those attributes. Note that currently it is not possible to remove a single attribute when the @matcher matches the whole namespace - or remove a namespace or attribute when the matcher matches everything. This is a limitation of the current implementation, but may be fixed in the future. A file attribute matcher matching all attributes of @matcher that are not matched by @subtract Matcher to subtract from The matcher to subtract Prints what the matcher is matching against. The format will be equal to the format passed to g_file_attribute_matcher_new(). The output however, might not be identical, as the matcher may decide to use a different order or omit needless parts. a string describing the attributes the matcher matches against or %NULL if @matcher was %NULL. a #GFileAttributeMatcher. Unreferences @matcher. If the reference count falls below 1, the @matcher is automatically freed. a #GFileAttributeMatcher. Used by g_file_set_attributes_from_info() when setting file attributes. Attribute value is unset (empty). Attribute value is set. Indicates an error in setting the value. The data types for file attributes. indicates an invalid or uninitialized type. a null terminated UTF8 string. a zero terminated string of non-zero bytes. a boolean value. an unsigned 4-byte/32-bit integer. a signed 4-byte/32-bit integer. an unsigned 8-byte/64-bit integer. a signed 8-byte/64-bit integer. a #GObject. a %NULL terminated char **. Since 2.22 Flags used when copying or moving files. No flags set. Overwrite any existing files Make a backup of any existing files. Don't follow symlinks. Copy all file metadata instead of just default set used for copy (see #GFileInfo). Don't use copy and delete fallback if native move not supported. Leaves target file with default perms, instead of setting the source file perms. Flags used when an operation may create a file. No flags set. Create a file that can only be accessed by the current user. Replace the destination as if it didn't exist before. Don't try to keep any old permissions, replace instead of following links. This is generally useful if you're doing a "copy over" rather than a "save new version of" replace operation. You can think of it as "unlink destination" before writing to it, although the implementation may not be exactly like that. This flag can only be used with g_file_replace() and its variants, including g_file_replace_contents(). Since 2.20 #GFileDescriptorBased is implemented by streams (implementations of #GInputStream or #GOutputStream) that are based on file descriptors. Note that `<gio/gfiledescriptorbased.h>` belongs to the UNIX-specific GIO interfaces, thus you have to use the `gio-unix-2.0.pc` pkg-config file when using it. Gets the underlying file descriptor. The file descriptor a #GFileDescriptorBased. Gets the underlying file descriptor. The file descriptor a #GFileDescriptorBased. An interface for file descriptor based io objects. The parent interface. The file descriptor a #GFileDescriptorBased. #GFileEnumerator allows you to operate on a set of #GFiles, returning a #GFileInfo structure for each file enumerated (e.g. g_file_enumerate_children() will return a #GFileEnumerator for each of the children within a directory). To get the next file's information from a #GFileEnumerator, use g_file_enumerator_next_file() or its asynchronous version, g_file_enumerator_next_files_async(). Note that the asynchronous version will return a list of #GFileInfos, whereas the synchronous will only return the next file in the enumerator. The ordering of returned files is unspecified for non-Unix platforms; for more information, see g_dir_read_name(). On Unix, when operating on local files, returned files will be sorted by inode number. Effectively you can assume that the ordering of returned files will be stable between successive calls (and applications) assuming the directory is unchanged. If your application needs a specific ordering, such as by name or modification time, you will have to implement that in your application code. To close a #GFileEnumerator, use g_file_enumerator_close(), or its asynchronous version, g_file_enumerator_close_async(). Once a #GFileEnumerator is closed, no further actions may be performed on it, and it should be freed with g_object_unref(). Asynchronously closes the file enumerator. If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned in g_file_enumerator_close_finish(). a #GFileEnumerator. the [I/O priority][io-priority] of the request optional #GCancellable object, %NULL to ignore. a #GAsyncReadyCallback to call when the request is satisfied the data to pass to callback function Finishes closing a file enumerator, started from g_file_enumerator_close_async(). If the file enumerator was already closed when g_file_enumerator_close_async() was called, then this function will report %G_IO_ERROR_CLOSED in @error, and return %FALSE. If the file enumerator had pending operation when the close operation was started, then this function will report %G_IO_ERROR_PENDING, and return %FALSE. If @cancellable was not %NULL, then the operation may have been cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be set, and %FALSE will be returned. %TRUE if the close operation has finished successfully. a #GFileEnumerator. a #GAsyncResult. Returns information for the next file in the enumerated object. Will block until the information is available. The #GFileInfo returned from this function will contain attributes that match the attribute string that was passed when the #GFileEnumerator was created. See the documentation of #GFileEnumerator for information about the order of returned files. On error, returns %NULL and sets @error to the error. If the enumerator is at the end, %NULL will be returned and @error will be unset. A #GFileInfo or %NULL on error or end of enumerator. Free the returned object with g_object_unref() when no longer needed. a #GFileEnumerator. optional #GCancellable object, %NULL to ignore. Request information for a number of files from the enumerator asynchronously. When all i/o for the operation is finished the @callback will be called with the requested information. See the documentation of #GFileEnumerator for information about the order of returned files. The callback can be called with less than @num_files files in case of error or at the end of the enumerator. In case of a partial error the callback will be called with any succeeding items and no error, and on the next request the error will be reported. If a request is cancelled the callback will be called with %G_IO_ERROR_CANCELLED. During an async request no other sync and async calls are allowed, and will result in %G_IO_ERROR_PENDING errors. Any outstanding i/o request with higher priority (lower numerical value) will be executed before an outstanding request with lower priority. Default priority is %G_PRIORITY_DEFAULT. a #GFileEnumerator. the number of file info objects to request the [I/O priority][io-priority] of the request optional #GCancellable object, %NULL to ignore. a #GAsyncReadyCallback to call when the request is satisfied the data to pass to callback function Finishes the asynchronous operation started with g_file_enumerator_next_files_async(). a #GList of #GFileInfos. You must free the list with g_list_free() and unref the infos with g_object_unref() when you're done with them. a #GFileEnumerator. a #GAsyncResult. Releases all resources used by this enumerator, making the enumerator return %G_IO_ERROR_CLOSED on all calls. This will be automatically called when the last reference is dropped, but you might want to call this function to make sure resources are released as early as possible. #TRUE on success or #FALSE on error. a #GFileEnumerator. optional #GCancellable object, %NULL to ignore. Asynchronously closes the file enumerator. If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned in g_file_enumerator_close_finish(). a #GFileEnumerator. the [I/O priority][io-priority] of the request optional #GCancellable object, %NULL to ignore. a #GAsyncReadyCallback to call when the request is satisfied the data to pass to callback function Finishes closing a file enumerator, started from g_file_enumerator_close_async(). If the file enumerator was already closed when g_file_enumerator_close_async() was called, then this function will report %G_IO_ERROR_CLOSED in @error, and return %FALSE. If the file enumerator had pending operation when the close operation was started, then this function will report %G_IO_ERROR_PENDING, and return %FALSE. If @cancellable was not %NULL, then the operation may have been cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be set, and %FALSE will be returned. %TRUE if the close operation has finished successfully. a #GFileEnumerator. a #GAsyncResult. Return a new #GFile which refers to the file named by @info in the source directory of @enumerator. This function is primarily intended to be used inside loops with g_file_enumerator_next_file(). This is a convenience method that's equivalent to: |[<!-- language="C" --> gchar *name = g_file_info_get_name (info); GFile *child = g_file_get_child (g_file_enumerator_get_container (enumr), name); ]| a #GFile for the #GFileInfo passed it. a #GFileEnumerator a #GFileInfo gotten from g_file_enumerator_next_file() or the async equivalents. Get the #GFile container which is being enumerated. the #GFile which is being enumerated. a #GFileEnumerator Checks if the file enumerator has pending operations. %TRUE if the @enumerator has pending operations. a #GFileEnumerator. Checks if the file enumerator has been closed. %TRUE if the @enumerator is closed. a #GFileEnumerator. This is a version of g_file_enumerator_next_file() that's easier to use correctly from C programs. With g_file_enumerator_next_file(), the gboolean return value signifies "end of iteration or error", which requires allocation of a temporary #GError. In contrast, with this function, a %FALSE return from g_file_enumerator_iterate() *always* means "error". End of iteration is signaled by @out_info or @out_child being %NULL. Another crucial difference is that the references for @out_info and @out_child are owned by @direnum (they are cached as hidden properties). You must not unref them in your own code. This makes memory management significantly easier for C code in combination with loops. Finally, this function optionally allows retrieving a #GFile as well. You must specify at least one of @out_info or @out_child. The code pattern for correctly using g_file_enumerator_iterate() from C is: |[ direnum = g_file_enumerate_children (file, ...); while (TRUE) { GFileInfo *info; if (!g_file_enumerator_iterate (direnum, &info, NULL, cancellable, error)) goto out; if (!info) break; ... do stuff with "info"; do not unref it! ... } out: g_object_unref (direnum); // Note: frees the last @info ]| an open #GFileEnumerator Output location for the next #GFileInfo, or %NULL Output location for the next #GFile, or %NULL a #GCancellable Returns information for the next file in the enumerated object. Will block until the information is available. The #GFileInfo returned from this function will contain attributes that match the attribute string that was passed when the #GFileEnumerator was created. See the documentation of #GFileEnumerator for information about the order of returned files. On error, returns %NULL and sets @error to the error. If the enumerator is at the end, %NULL will be returned and @error will be unset. A #GFileInfo or %NULL on error or end of enumerator. Free the returned object with g_object_unref() when no longer needed. a #GFileEnumerator. optional #GCancellable object, %NULL to ignore. Request information for a number of files from the enumerator asynchronously. When all i/o for the operation is finished the @callback will be called with the requested information. See the documentation of #GFileEnumerator for information about the order of returned files. The callback can be called with less than @num_files files in case of error or at the end of the enumerator. In case of a partial error the callback will be called with any succeeding items and no error, and on the next request the error will be reported. If a request is cancelled the callback will be called with %G_IO_ERROR_CANCELLED. During an async request no other sync and async calls are allowed, and will result in %G_IO_ERROR_PENDING errors. Any outstanding i/o request with higher priority (lower numerical value) will be executed before an outstanding request with lower priority. Default priority is %G_PRIORITY_DEFAULT. a #GFileEnumerator. the number of file info objects to request the [I/O priority][io-priority] of the request optional #GCancellable object, %NULL to ignore. a #GAsyncReadyCallback to call when the request is satisfied the data to pass to callback function Finishes the asynchronous operation started with g_file_enumerator_next_files_async(). a #GList of #GFileInfos. You must free the list with g_list_free() and unref the infos with g_object_unref() when you're done with them. a #GFileEnumerator. a #GAsyncResult. Sets the file enumerator as having pending operations. a #GFileEnumerator. a boolean value. A #GFileInfo or %NULL on error or end of enumerator. Free the returned object with g_object_unref() when no longer needed. a #GFileEnumerator. optional #GCancellable object, %NULL to ignore. a #GFileEnumerator. the number of file info objects to request the [I/O priority][io-priority] of the request optional #GCancellable object, %NULL to ignore. a #GAsyncReadyCallback to call when the request is satisfied the data to pass to callback function a #GList of #GFileInfos. You must free the list with g_list_free() and unref the infos with g_object_unref() when you're done with them. a #GFileEnumerator. a #GAsyncResult. a #GFileEnumerator. the [I/O priority][io-priority] of the request optional #GCancellable object, %NULL to ignore. a #GAsyncReadyCallback to call when the request is satisfied the data to pass to callback function %TRUE if the close operation has finished successfully. a #GFileEnumerator. a #GAsyncResult. GFileIOStream provides io streams that both read and write to the same file handle. GFileIOStream implements #GSeekable, which allows the io stream to jump to arbitrary positions in the file and to truncate the file, provided the filesystem of the file supports these operations. To find the position of a file io stream, use g_seekable_tell(). To find out if a file io stream supports seeking, use g_seekable_can_seek(). To position a file io stream, use g_seekable_seek(). To find out if a file io stream supports truncating, use g_seekable_can_truncate(). To truncate a file io stream, use g_seekable_truncate(). The default implementation of all the #GFileIOStream operations and the implementation of #GSeekable just call into the same operations on the output stream. Gets the entity tag for the file when it has been written. This must be called after the stream has been written and closed, as the etag can change while writing. the entity tag for the stream. a #GFileIOStream. Queries a file io stream for the given @attributes. This function blocks while querying the stream. For the asynchronous version of this function, see g_file_io_stream_query_info_async(). While the stream is blocked, the stream will set the pending flag internally, and any other operations on the stream will fail with %G_IO_ERROR_PENDING. Can fail if the stream was already closed (with @error being set to %G_IO_ERROR_CLOSED), the stream has pending operations (with @error being set to %G_IO_ERROR_PENDING), or if querying info is not supported for the stream's interface (with @error being set to %G_IO_ERROR_NOT_SUPPORTED). I all cases of failure, %NULL will be returned. If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be set, and %NULL will be returned. a #GFileInfo for the @stream, or %NULL on error. a #GFileIOStream. a file attribute query string. optional #GCancellable object, %NULL to ignore. Asynchronously queries the @stream for a #GFileInfo. When completed, @callback will be called with a #GAsyncResult which can be used to finish the operation with g_file_io_stream_query_info_finish(). For the synchronous version of this function, see g_file_io_stream_query_info(). a #GFileIOStream. a file attribute query string. the [I/O priority][gio-GIOScheduler] of the request optional #GCancellable object, %NULL to ignore. callback to call when the request is satisfied the data to pass to callback function Finalizes the asynchronous query started by g_file_io_stream_query_info_async(). A #GFileInfo for the finished query. a #GFileIOStream. a #GAsyncResult. Gets the entity tag for the file when it has been written. This must be called after the stream has been written and closed, as the etag can change while writing. the entity tag for the stream. a #GFileIOStream. Queries a file io stream for the given @attributes. This function blocks while querying the stream. For the asynchronous version of this function, see g_file_io_stream_query_info_async(). While the stream is blocked, the stream will set the pending flag internally, and any other operations on the stream will fail with %G_IO_ERROR_PENDING. Can fail if the stream was already closed (with @error being set to %G_IO_ERROR_CLOSED), the stream has pending operations (with @error being set to %G_IO_ERROR_PENDING), or if querying info is not supported for the stream's interface (with @error being set to %G_IO_ERROR_NOT_SUPPORTED). I all cases of failure, %NULL will be returned. If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be set, and %NULL will be returned. a #GFileInfo for the @stream, or %NULL on error. a #GFileIOStream. a file attribute query string. optional #GCancellable object, %NULL to ignore. Asynchronously queries the @stream for a #GFileInfo. When completed, @callback will be called with a #GAsyncResult which can be used to finish the operation with g_file_io_stream_query_info_finish(). For the synchronous version of this function, see g_file_io_stream_query_info(). a #GFileIOStream. a file attribute query string. the [I/O priority][gio-GIOScheduler] of the request optional #GCancellable object, %NULL to ignore. callback to call when the request is satisfied the data to pass to callback function Finalizes the asynchronous query started by g_file_io_stream_query_info_async(). A #GFileInfo for the finished query. a #GFileIOStream. a #GAsyncResult. a #GFileInfo for the @stream, or %NULL on error. a #GFileIOStream. a file attribute query string. optional #GCancellable object, %NULL to ignore. a #GFileIOStream. a file attribute query string. the [I/O priority][gio-GIOScheduler] of the request optional #GCancellable object, %NULL to ignore. callback to call when the request is satisfied the data to pass to callback function A #GFileInfo for the finished query. a #GFileIOStream. a #GAsyncResult. the entity tag for the stream. a #GFileIOStream. #GFileIcon specifies an icon by pointing to an image file to be used as icon. Creates a new icon for a file. a #GIcon for the given @file, or %NULL on error. a #GFile. Gets the #GFile associated with the given @icon. a #GFile, or %NULL. a #GIcon. The file containing the icon. An interface for writing VFS file handles. The parent interface. a new #GFile that is a duplicate of the given #GFile. input #GFile 0 if @file is not a valid #GFile, otherwise an integer that can be used as hash value for the #GFile. This function is intended for easily hashing a #GFile to add to a #GHashTable or similar data structure. #gconstpointer to a #GFile %TRUE if @file1 and @file2 are equal. the first #GFile the second #GFile %TRUE if @file is native input #GFile %TRUE if #GFile's backend supports the given URI scheme, %FALSE if URI scheme is %NULL, not supported, or #GFile is invalid. input #GFile a string containing a URI scheme a string containing the URI scheme for the given #GFile. The returned string should be freed with g_free() when no longer needed. input #GFile a string containing the #GFile's URI. The returned string should be freed with g_free() when no longer needed. input #GFile a string containing the #GFile's parse name. The returned string should be freed with g_free() when no longer needed. input #GFile a #GFile structure to the parent of the given #GFile or %NULL if there is no parent. Free the returned object with g_object_unref(). input #GFile %TRUE if the @file's parent, grandparent, etc is @prefix, %FALSE otherwise. input #GFile input #GFile #GFile to the resolved path. %NULL if @relative_path is %NULL or if @file is invalid. Free the returned object with g_object_unref(). input #GFile a given relative path string a #GFile to the specified child, or %NULL if the display name couldn't be converted. Free the returned object with g_object_unref(). input #GFile string to a possible child A #GFileEnumerator if successful, %NULL on error. Free the returned object with g_object_unref(). input #GFile an attribute query string a set of #GFileQueryInfoFlags optional #GCancellable object, %NULL to ignore input #GFile an attribute query string a set of #GFileQueryInfoFlags the [I/O priority][io-priority] of the request optional #GCancellable object, %NULL to ignore a #GAsyncReadyCallback to call when the request is satisfied the data to pass to callback function a #GFileEnumerator or %NULL if an error occurred. Free the returned object with g_object_unref(). input #GFile a #GAsyncResult a #GFileInfo for the given @file, or %NULL on error. Free the returned object with g_object_unref(). input #GFile an attribute query string a set of #GFileQueryInfoFlags optional #GCancellable object, %NULL to ignore input #GFile an attribute query string a set of #GFileQueryInfoFlags the [I/O priority][io-priority] of the request optional #GCancellable object, %NULL to ignore a #GAsyncReadyCallback to call when the request is satisfied the data to pass to callback function #GFileInfo for given @file or %NULL on error. Free the returned object with g_object_unref(). input #GFile a #GAsyncResult a #GFileInfo or %NULL if there was an error. Free the returned object with g_object_unref(). input #GFile an attribute query string optional #GCancellable object, %NULL to ignore input #GFile an attribute query string the [I/O priority][io-priority] of the request optional #GCancellable object, %NULL to ignore a #GAsyncReadyCallback to call when the request is satisfied the data to pass to callback function #GFileInfo for given @file or %NULL on error. Free the returned object with g_object_unref(). input #GFile a #GAsyncResult a #GMount where the @file is located or %NULL on error. Free the returned object with g_object_unref(). input #GFile optional #GCancellable object, %NULL to ignore a #GFile the [I/O priority][io-priority] of the request optional #GCancellable object, %NULL to ignore a #GAsyncReadyCallback to call when the request is satisfied the data to pass to callback function #GMount for given @file or %NULL on error. Free the returned object with g_object_unref(). a #GFile a #GAsyncResult a #GFile specifying what @file was renamed to, or %NULL if there was an error. Free the returned object with g_object_unref(). input #GFile a string optional #GCancellable object, %NULL to ignore input #GFile a string the [I/O priority][io-priority] of the request optional #GCancellable object, %NULL to ignore a #GAsyncReadyCallback to call when the request is satisfied the data to pass to callback function a #GFile or %NULL on error. Free the returned object with g_object_unref(). input #GFile a #GAsyncResult a #GFileAttributeInfoList describing the settable attributes. When you are done with it, release it with g_file_attribute_info_list_unref() input #GFile optional #GCancellable object, %NULL to ignore a #GFileAttributeInfoList describing the writable namespaces. When you are done with it, release it with g_file_attribute_info_list_unref() input #GFile optional #GCancellable object, %NULL to ignore %TRUE if the attribute was set, %FALSE otherwise. input #GFile a string containing the attribute's name The type of the attribute a pointer to the value (or the pointer itself if the type is a pointer type) a set of #GFileQueryInfoFlags optional #GCancellable object, %NULL to ignore %FALSE if there was any error, %TRUE otherwise. input #GFile a #GFileInfo #GFileQueryInfoFlags optional #GCancellable object, %NULL to ignore input #GFile a #GFileInfo a #GFileQueryInfoFlags the [I/O priority][io-priority] of the request optional #GCancellable object, %NULL to ignore a #GAsyncReadyCallback a #gpointer %TRUE if the attributes were set correctly, %FALSE otherwise. input #GFile a #GAsyncResult a #GFileInfo #GFileInputStream or %NULL on error. Free the returned object with g_object_unref(). #GFile to read a #GCancellable input #GFile the [I/O priority][io-priority] of the request optional #GCancellable object, %NULL to ignore a #GAsyncReadyCallback to call when the request is satisfied the data to pass to callback function a #GFileInputStream or %NULL on error. Free the returned object with g_object_unref(). input #GFile a #GAsyncResult a #GFileOutputStream, or %NULL on error. Free the returned object with g_object_unref(). input #GFile a set of #GFileCreateFlags optional #GCancellable object, %NULL to ignore input #GFile a set of #GFileCreateFlags the [I/O priority][io-priority] of the request optional #GCancellable object, %NULL to ignore a #GAsyncReadyCallback to call when the request is satisfied the data to pass to callback function a valid #GFileOutputStream or %NULL on error. Free the returned object with g_object_unref(). input #GFile #GAsyncResult a #GFileOutputStream for the newly created file, or %NULL on error. Free the returned object with g_object_unref(). input #GFile a set of #GFileCreateFlags optional #GCancellable object, %NULL to ignore input #GFile a set of #GFileCreateFlags the [I/O priority][io-priority] of the request optional #GCancellable object, %NULL to ignore a #GAsyncReadyCallback to call when the request is satisfied the data to pass to callback function a #GFileOutputStream or %NULL on error. Free the returned object with g_object_unref(). input #GFile a #GAsyncResult a #GFileOutputStream or %NULL on error. Free the returned object with g_object_unref(). input #GFile an optional [entity tag][gfile-etag] for the current #GFile, or #NULL to ignore %TRUE if a backup should be created a set of #GFileCreateFlags optional #GCancellable object, %NULL to ignore input #GFile an [entity tag][gfile-etag] for the current #GFile, or %NULL to ignore %TRUE if a backup should be created a set of #GFileCreateFlags the [I/O priority][io-priority] of the request optional #GCancellable object, %NULL to ignore a #GAsyncReadyCallback to call when the request is satisfied the data to pass to callback function a #GFileOutputStream, or %NULL on error. Free the returned object with g_object_unref(). input #GFile a #GAsyncResult %TRUE if the file was deleted. %FALSE otherwise. input #GFile optional #GCancellable object, %NULL to ignore input #GFile the [I/O priority][io-priority] of the request optional #GCancellable object, %NULL to ignore a #GAsyncReadyCallback to call when the request is satisfied the data to pass to callback function %TRUE if the file was deleted. %FALSE otherwise. input #GFile a #GAsyncResult %TRUE on successful trash, %FALSE otherwise. #GFile to send to trash optional #GCancellable object, %NULL to ignore input #GFile the [I/O priority][io-priority] of the request optional #GCancellable object, %NULL to ignore a #GAsyncReadyCallback to call when the request is satisfied the data to pass to callback function %TRUE on successful trash, %FALSE otherwise. input #GFile a #GAsyncResult %TRUE on successful creation, %FALSE otherwise. input #GFile optional #GCancellable object, %NULL to ignore input #GFile the [I/O priority][io-priority] of the request optional #GCancellable object, %NULL to ignore a #GAsyncReadyCallback to call when the request is satisfied the data to pass to callback function %TRUE on successful directory creation, %FALSE otherwise. input #GFile a #GAsyncResult %TRUE on the creation of a new symlink, %FALSE otherwise. a #GFile with the name of the symlink to create a string with the path for the target of the new symlink optional #GCancellable object, %NULL to ignore %TRUE on success, %FALSE otherwise. input #GFile destination #GFile set of #GFileCopyFlags optional #GCancellable object, %NULL to ignore function to callback with progress information, or %NULL if progress information is not needed user data to pass to @progress_callback input #GFile destination #GFile set of #GFileCopyFlags the [I/O priority][io-priority] of the request optional #GCancellable object, %NULL to ignore function to callback with progress information, or %NULL if progress information is not needed user data to pass to @progress_callback a #GAsyncReadyCallback to call when the request is satisfied the data to pass to callback function a %TRUE on success, %FALSE on error. input #GFile a #GAsyncResult %TRUE on successful move, %FALSE otherwise. #GFile pointing to the source location #GFile pointing to the destination location set of #GFileCopyFlags optional #GCancellable object, %NULL to ignore #GFileProgressCallback function for updates gpointer to user data for the callback function input #GFile flags affecting the operation a #GMountOperation, or %NULL to avoid user interaction optional #GCancellable object, %NULL to ignore a #GAsyncReadyCallback to call when the request is satisfied, or %NULL the data to pass to callback function a #GFile or %NULL on error. Free the returned object with g_object_unref(). input #GFile a #GAsyncResult input #GFile flags affecting the operation optional #GCancellable object, %NULL to ignore a #GAsyncReadyCallback to call when the request is satisfied, or %NULL the data to pass to callback function %TRUE if the operation finished successfully. %FALSE otherwise. input #GFile a #GAsyncResult input #GFile flags affecting the operation optional #GCancellable object, %NULL to ignore a #GAsyncReadyCallback to call when the request is satisfied, or %NULL the data to pass to callback function %TRUE if the @file was ejected successfully. %FALSE otherwise. input #GFile a #GAsyncResult input #GFile flags affecting the operation a #GMountOperation or %NULL to avoid user interaction optional #GCancellable object, %NULL to ignore a #GAsyncReadyCallback to call when the request is satisfied, or %NULL the data to pass to callback function %TRUE if successful. If an error has occurred, this function will return %FALSE and set @error appropriately if present. input #GFile a #GAsyncResult a #GFileMonitor for the given @file, or %NULL on error. Free the returned object with g_object_unref(). input #GFile a set of #GFileMonitorFlags optional #GCancellable object, %NULL to ignore a #GFileMonitor for the given @file, or %NULL on error. Free the returned object with g_object_unref(). input #GFile a set of #GFileMonitorFlags optional #GCancellable object, %NULL to ignore #GFileIOStream or %NULL on error. Free the returned object with g_object_unref(). #GFile to open a #GCancellable input #GFile the [I/O priority][io-priority] of the request optional #GCancellable object, %NULL to ignore a #GAsyncReadyCallback to call when the request is satisfied the data to pass to callback function a #GFileIOStream or %NULL on error. Free the returned object with g_object_unref(). input #GFile a #GAsyncResult a #GFileIOStream for the newly created file, or %NULL on error. Free the returned object with g_object_unref(). a #GFile a set of #GFileCreateFlags optional #GCancellable object, %NULL to ignore input #GFile a set of #GFileCreateFlags the [I/O priority][io-priority] of the request optional #GCancellable object, %NULL to ignore a #GAsyncReadyCallback to call when the request is satisfied the data to pass to callback function a #GFileIOStream or %NULL on error. Free the returned object with g_object_unref(). input #GFile a #GAsyncResult a #GFileIOStream or %NULL on error. Free the returned object with g_object_unref(). a #GFile an optional [entity tag][gfile-etag] for the current #GFile, or #NULL to ignore %TRUE if a backup should be created a set of #GFileCreateFlags optional #GCancellable object, %NULL to ignore input #GFile an [entity tag][gfile-etag] for the current #GFile, or %NULL to ignore %TRUE if a backup should be created a set of #GFileCreateFlags the [I/O priority][io-priority] of the request optional #GCancellable object, %NULL to ignore a #GAsyncReadyCallback to call when the request is satisfied the data to pass to callback function a #GFileIOStream, or %NULL on error. Free the returned object with g_object_unref(). input #GFile a #GAsyncResult input #GFile flags affecting the operation a #GMountOperation, or %NULL to avoid user interaction optional #GCancellable object, %NULL to ignore a #GAsyncReadyCallback to call when the request is satisfied, or %NULL the data to pass to callback function %TRUE if the operation finished successfully. %FALSE otherwise. input #GFile a #GAsyncResult input #GFile flags affecting the operation a #GMountOperation, or %NULL to avoid user interaction. optional #GCancellable object, %NULL to ignore a #GAsyncReadyCallback to call when the request is satisfied, or %NULL the data to pass to callback function %TRUE if the operation finished successfully. %FALSE otherwise. input #GFile a #GAsyncResult a boolean that indicates whether the #GFile implementation supports thread-default contexts. Since 2.22. input #GFile flags affecting the operation a #GMountOperation, or %NULL to avoid user interaction optional #GCancellable object, %NULL to ignore a #GAsyncReadyCallback to call when the request is satisfied, or %NULL the data to pass to callback function %TRUE if the operation finished successfully. %FALSE otherwise. input #GFile a #GAsyncResult input #GFile flags affecting the operation a #GMountOperation, or %NULL to avoid user interaction optional #GCancellable object, %NULL to ignore a #GAsyncReadyCallback to call when the request is satisfied, or %NULL the data to pass to callback function %TRUE if the @file was ejected successfully. %FALSE otherwise. input #GFile a #GAsyncResult input #GFile optional #GCancellable object, %NULL to ignore a #GAsyncReadyCallback to call when the request is satisfied, or %NULL the data to pass to callback function %TRUE if the operation finished successfully. %FALSE otherwise. input #GFile a #GAsyncResult %TRUE if successful, with the out parameters set. %FALSE otherwise, with @error set. a #GFile #GFileMeasureFlags optional #GCancellable a #GFileMeasureProgressCallback user_data for @progress_callback the number of bytes of disk space used the number of directories encountered the number of non-directories encountered a #GFile #GFileMeasureFlags the [I/O priority][io-priority] of the request optional #GCancellable a #GFileMeasureProgressCallback user_data for @progress_callback a #GAsyncReadyCallback to call when complete the data to pass to callback function %TRUE if successful, with the out parameters set. %FALSE otherwise, with @error set. a #GFile the #GAsyncResult passed to your #GAsyncReadyCallback the number of bytes of disk space used the number of directories encountered the number of non-directories encountered Functionality for manipulating basic metadata for files. #GFileInfo implements methods for getting information that all files should contain, and allows for manipulation of extended attributes. See [GFileAttribute][gio-GFileAttribute] for more information on how GIO handles file attributes. To obtain a #GFileInfo for a #GFile, use g_file_query_info() (or its async variant). To obtain a #GFileInfo for a file input or output stream, use g_file_input_stream_query_info() or g_file_output_stream_query_info() (or their async variants). To change the actual attributes of a file, you should then set the attribute in the #GFileInfo and call g_file_set_attributes_from_info() or g_file_set_attributes_async() on a GFile. However, not all attributes can be changed in the file. For instance, the actual size of a file cannot be changed via g_file_info_set_size(). You may call g_file_query_settable_attributes() and g_file_query_writable_namespaces() to discover the settable attributes of a particular file at runtime. #GFileAttributeMatcher allows for searching through a #GFileInfo for attributes. Creates a new file info structure. a #GFileInfo. Clears the status information from @info. a #GFileInfo. First clears all of the [GFileAttribute][gio-GFileAttribute] of @dest_info, and then copies all of the file attributes from @src_info to @dest_info. source to copy attributes from. destination to copy attributes to. Duplicates a file info structure. a duplicate #GFileInfo of @other. a #GFileInfo. Gets the value of a attribute, formatted as a string. This escapes things as needed to make the string valid UTF-8. a UTF-8 string associated with the given @attribute, or %NULL if the attribute wasn’t set. When you're done with the string it must be freed with g_free(). a #GFileInfo. a file attribute key. Gets the value of a boolean attribute. If the attribute does not contain a boolean value, %FALSE will be returned. the boolean value contained within the attribute. a #GFileInfo. a file attribute key. Gets the value of a byte string attribute. If the attribute does not contain a byte string, %NULL will be returned. the contents of the @attribute value as a byte string, or %NULL otherwise. a #GFileInfo. a file attribute key. Gets the attribute type, value and status for an attribute key. %TRUE if @info has an attribute named @attribute, %FALSE otherwise. a #GFileInfo a file attribute key return location for the attribute type, or %NULL return location for the attribute value, or %NULL; the attribute value will not be %NULL return location for the attribute status, or %NULL Gets a signed 32-bit integer contained within the attribute. If the attribute does not contain a signed 32-bit integer, or is invalid, 0 will be returned. a signed 32-bit integer from the attribute. a #GFileInfo. a file attribute key. Gets a signed 64-bit integer contained within the attribute. If the attribute does not contain a signed 64-bit integer, or is invalid, 0 will be returned. a signed 64-bit integer from the attribute. a #GFileInfo. a file attribute key. Gets the value of a #GObject attribute. If the attribute does not contain a #GObject, %NULL will be returned. a #GObject associated with the given @attribute, or %NULL otherwise. a #GFileInfo. a file attribute key. Gets the attribute status for an attribute key. a #GFileAttributeStatus for the given @attribute, or %G_FILE_ATTRIBUTE_STATUS_UNSET if the key is invalid. a #GFileInfo a file attribute key Gets the value of a string attribute. If the attribute does not contain a string, %NULL will be returned. the contents of the @attribute value as a UTF-8 string, or %NULL otherwise. a #GFileInfo. a file attribute key. Gets the value of a stringv attribute. If the attribute does not contain a stringv, %NULL will be returned. the contents of the @attribute value as a stringv, or %NULL otherwise. Do not free. These returned strings are UTF-8. a #GFileInfo. a file attribute key. Gets the attribute type for an attribute key. a #GFileAttributeType for the given @attribute, or %G_FILE_ATTRIBUTE_TYPE_INVALID if the key is not set. a #GFileInfo. a file attribute key. Gets an unsigned 32-bit integer contained within the attribute. If the attribute does not contain an unsigned 32-bit integer, or is invalid, 0 will be returned. an unsigned 32-bit integer from the attribute. a #GFileInfo. a file attribute key. Gets a unsigned 64-bit integer contained within the attribute. If the attribute does not contain an unsigned 64-bit integer, or is invalid, 0 will be returned. a unsigned 64-bit integer from the attribute. a #GFileInfo. a file attribute key. Gets the file's content type. a string containing the file's content type, or %NULL if unknown. a #GFileInfo. Returns the #GDateTime representing the deletion date of the file, as available in G_FILE_ATTRIBUTE_TRASH_DELETION_DATE. If the G_FILE_ATTRIBUTE_TRASH_DELETION_DATE attribute is unset, %NULL is returned. a #GDateTime, or %NULL. a #GFileInfo. Gets a display name for a file. This is guaranteed to always be set. a string containing the display name. a #GFileInfo. Gets the edit name for a file. a string containing the edit name. a #GFileInfo. Gets the [entity tag][gfile-etag] for a given #GFileInfo. See %G_FILE_ATTRIBUTE_ETAG_VALUE. a string containing the value of the "etag:value" attribute. a #GFileInfo. Gets a file's type (whether it is a regular file, symlink, etc). This is different from the file's content type, see g_file_info_get_content_type(). a #GFileType for the given file. a #GFileInfo. Gets the icon for a file. #GIcon for the given @info. a #GFileInfo. Checks if a file is a backup file. %TRUE if file is a backup file, %FALSE otherwise. a #GFileInfo. Checks if a file is hidden. %TRUE if the file is a hidden file, %FALSE otherwise. a #GFileInfo. Checks if a file is a symlink. %TRUE if the given @info is a symlink. a #GFileInfo. Gets the modification time of the current @info and returns it as a #GDateTime. This requires the %G_FILE_ATTRIBUTE_TIME_MODIFIED attribute. If %G_FILE_ATTRIBUTE_TIME_MODIFIED_USEC is provided, the resulting #GDateTime will have microsecond precision. modification time, or %NULL if unknown a #GFileInfo. Gets the modification time of the current @info and sets it in @result. Use g_file_info_get_modification_date_time() instead, as #GTimeVal is deprecated due to the year 2038 problem. a #GFileInfo. a #GTimeVal. Gets the name for a file. This is guaranteed to always be set. a string containing the file name. a #GFileInfo. Gets the file's size. a #goffset containing the file's size. a #GFileInfo. Gets the value of the sort_order attribute from the #GFileInfo. See %G_FILE_ATTRIBUTE_STANDARD_SORT_ORDER. a #gint32 containing the value of the "standard::sort_order" attribute. a #GFileInfo. Gets the symbolic icon for a file. #GIcon for the given @info. a #GFileInfo. Gets the symlink target for a given #GFileInfo. a string containing the symlink target. a #GFileInfo. Checks if a file info structure has an attribute named @attribute. %TRUE if @info has an attribute named @attribute, %FALSE otherwise. a #GFileInfo. a file attribute key. Checks if a file info structure has an attribute in the specified @name_space. %TRUE if @info has an attribute in @name_space, %FALSE otherwise. a #GFileInfo. a file attribute namespace. Lists the file info structure's attributes. a null-terminated array of strings of all of the possible attribute types for the given @name_space, or %NULL on error. a #GFileInfo. a file attribute key's namespace, or %NULL to list all attributes. Removes all cases of @attribute from @info if it exists. a #GFileInfo. a file attribute key. Sets the @attribute to contain the given value, if possible. To unset the attribute, use %G_FILE_ATTRIBUTE_TYPE_INVALID for @type. a #GFileInfo. a file attribute key. a #GFileAttributeType pointer to the value Sets the @attribute to contain the given @attr_value, if possible. a #GFileInfo. a file attribute key. a boolean value. Sets the @attribute to contain the given @attr_value, if possible. a #GFileInfo. a file attribute key. a byte string. Sets the @attribute to contain the given @attr_value, if possible. a #GFileInfo. a file attribute key. a signed 32-bit integer Sets the @attribute to contain the given @attr_value, if possible. a #GFileInfo. attribute name to set. int64 value to set attribute to. Sets @mask on @info to match specific attribute types. a #GFileInfo. a #GFileAttributeMatcher. Sets the @attribute to contain the given @attr_value, if possible. a #GFileInfo. a file attribute key. a #GObject. Sets the attribute status for an attribute key. This is only needed by external code that implement g_file_set_attributes_from_info() or similar functions. The attribute must exist in @info for this to work. Otherwise %FALSE is returned and @info is unchanged. %TRUE if the status was changed, %FALSE if the key was not set. a #GFileInfo a file attribute key a #GFileAttributeStatus Sets the @attribute to contain the given @attr_value, if possible. a #GFileInfo. a file attribute key. a UTF-8 string. Sets the @attribute to contain the given @attr_value, if possible. Sinze: 2.22 a #GFileInfo. a file attribute key a %NULL terminated array of UTF-8 strings. Sets the @attribute to contain the given @attr_value, if possible. a #GFileInfo. a file attribute key. an unsigned 32-bit integer. Sets the @attribute to contain the given @attr_value, if possible. a #GFileInfo. a file attribute key. an unsigned 64-bit integer. Sets the content type attribute for a given #GFileInfo. See %G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE. a #GFileInfo. a content type. See [GContentType][gio-GContentType] Sets the display name for the current #GFileInfo. See %G_FILE_ATTRIBUTE_STANDARD_DISPLAY_NAME. a #GFileInfo. a string containing a display name. Sets the edit name for the current file. See %G_FILE_ATTRIBUTE_STANDARD_EDIT_NAME. a #GFileInfo. a string containing an edit name. Sets the file type in a #GFileInfo to @type. See %G_FILE_ATTRIBUTE_STANDARD_TYPE. a #GFileInfo. a #GFileType. Sets the icon for a given #GFileInfo. See %G_FILE_ATTRIBUTE_STANDARD_ICON. a #GFileInfo. a #GIcon. Sets the "is_hidden" attribute in a #GFileInfo according to @is_hidden. See %G_FILE_ATTRIBUTE_STANDARD_IS_HIDDEN. a #GFileInfo. a #gboolean. Sets the "is_symlink" attribute in a #GFileInfo according to @is_symlink. See %G_FILE_ATTRIBUTE_STANDARD_IS_SYMLINK. a #GFileInfo. a #gboolean. Sets the %G_FILE_ATTRIBUTE_TIME_MODIFIED and %G_FILE_ATTRIBUTE_TIME_MODIFIED_USEC attributes in the file info to the given date/time value. a #GFileInfo. a #GDateTime. Sets the %G_FILE_ATTRIBUTE_TIME_MODIFIED and %G_FILE_ATTRIBUTE_TIME_MODIFIED_USEC attributes in the file info to the given time value. Use g_file_info_set_modification_date_time() instead, as #GTimeVal is deprecated due to the year 2038 problem. a #GFileInfo. a #GTimeVal. Sets the name attribute for the current #GFileInfo. See %G_FILE_ATTRIBUTE_STANDARD_NAME. a #GFileInfo. a string containing a name. Sets the %G_FILE_ATTRIBUTE_STANDARD_SIZE attribute in the file info to the given size. a #GFileInfo. a #goffset containing the file's size. Sets the sort order attribute in the file info structure. See %G_FILE_ATTRIBUTE_STANDARD_SORT_ORDER. a #GFileInfo. a sort order integer. Sets the symbolic icon for a given #GFileInfo. See %G_FILE_ATTRIBUTE_STANDARD_SYMBOLIC_ICON. a #GFileInfo. a #GIcon. Sets the %G_FILE_ATTRIBUTE_STANDARD_SYMLINK_TARGET attribute in the file info to the given symlink target. a #GFileInfo. a static string containing a path to a symlink target. Unsets a mask set by g_file_info_set_attribute_mask(), if one is set. #GFileInfo. GFileInputStream provides input streams that take their content from a file. GFileInputStream implements #GSeekable, which allows the input stream to jump to arbitrary positions in the file, provided the filesystem of the file allows it. To find the position of a file input stream, use g_seekable_tell(). To find out if a file input stream supports seeking, use g_seekable_can_seek(). To position a file input stream, use g_seekable_seek(). Queries a file input stream the given @attributes. This function blocks while querying the stream. For the asynchronous (non-blocking) version of this function, see g_file_input_stream_query_info_async(). While the stream is blocked, the stream will set the pending flag internally, and any other operations on the stream will fail with %G_IO_ERROR_PENDING. a #GFileInfo, or %NULL on error. a #GFileInputStream. a file attribute query string. optional #GCancellable object, %NULL to ignore. Queries the stream information asynchronously. When the operation is finished @callback will be called. You can then call g_file_input_stream_query_info_finish() to get the result of the operation. For the synchronous version of this function, see g_file_input_stream_query_info(). If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be set a #GFileInputStream. a file attribute query string. the [I/O priority][io-priority] of the request optional #GCancellable object, %NULL to ignore. callback to call when the request is satisfied the data to pass to callback function Finishes an asynchronous info query operation. #GFileInfo. a #GFileInputStream. a #GAsyncResult. Queries a file input stream the given @attributes. This function blocks while querying the stream. For the asynchronous (non-blocking) version of this function, see g_file_input_stream_query_info_async(). While the stream is blocked, the stream will set the pending flag internally, and any other operations on the stream will fail with %G_IO_ERROR_PENDING. a #GFileInfo, or %NULL on error. a #GFileInputStream. a file attribute query string. optional #GCancellable object, %NULL to ignore. Queries the stream information asynchronously. When the operation is finished @callback will be called. You can then call g_file_input_stream_query_info_finish() to get the result of the operation. For the synchronous version of this function, see g_file_input_stream_query_info(). If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be set a #GFileInputStream. a file attribute query string. the [I/O priority][io-priority] of the request optional #GCancellable object, %NULL to ignore. callback to call when the request is satisfied the data to pass to callback function Finishes an asynchronous info query operation. #GFileInfo. a #GFileInputStream. a #GAsyncResult. a #GFileInfo, or %NULL on error. a #GFileInputStream. a file attribute query string. optional #GCancellable object, %NULL to ignore. a #GFileInputStream. a file attribute query string. the [I/O priority][io-priority] of the request optional #GCancellable object, %NULL to ignore. callback to call when the request is satisfied the data to pass to callback function #GFileInfo. a #GFileInputStream. a #GAsyncResult. Flags that can be used with g_file_measure_disk_usage(). No flags set. Report any error encountered while traversing the directory tree. Normally errors are only reported for the toplevel file. Tally usage based on apparent file sizes. Normally, the block-size is used, if available, as this is a more accurate representation of disk space used. Compare with `du --apparent-size`. Do not cross mount point boundaries. Compare with `du -x`. This callback type is used by g_file_measure_disk_usage() to make periodic progress reports when measuring the amount of disk spaced used by a directory. These calls are made on a best-effort basis and not all types of #GFile will support them. At the minimum, however, one call will always be made immediately. In the case that there is no support, @reporting will be set to %FALSE (and the other values undefined) and no further calls will be made. Otherwise, the @reporting will be %TRUE and the other values all-zeros during the first (immediate) call. In this way, you can know which type of progress UI to show without a delay. For g_file_measure_disk_usage() the callback is made directly. For g_file_measure_disk_usage_async() the callback is made via the default main context of the calling thread (ie: the same way that the final async result would be reported). @current_size is in the same units as requested by the operation (see %G_FILE_MEASURE_APPARENT_SIZE). The frequency of the updates is implementation defined, but is ideally about once every 200ms. The last progress callback may or may not be equal to the final result. Always check the async result to get the final value. %TRUE if more reports will come the current cumulative size measurement the number of directories visited so far the number of non-directory files encountered the data passed to the original request for this callback Monitors a file or directory for changes. To obtain a #GFileMonitor for a file or directory, use g_file_monitor(), g_file_monitor_file(), or g_file_monitor_directory(). To get informed about changes to the file or directory you are monitoring, connect to the #GFileMonitor::changed signal. The signal will be emitted in the [thread-default main context][g-main-context-push-thread-default] of the thread that the monitor was created in (though if the global default main context is blocked, this may cause notifications to be blocked even if the thread-default context is still running). Cancels a file monitor. always %TRUE a #GFileMonitor. Cancels a file monitor. always %TRUE a #GFileMonitor. Emits the #GFileMonitor::changed signal if a change has taken place. Should be called from file monitor implementations only. Implementations are responsible to call this method from the [thread-default main context][g-main-context-push-thread-default] of the thread that the monitor was created in. a #GFileMonitor. a #GFile. a #GFile. a set of #GFileMonitorEvent flags. Returns whether the monitor is canceled. %TRUE if monitor is canceled. %FALSE otherwise. a #GFileMonitor Sets the rate limit to which the @monitor will report consecutive change events to the same file. a #GFileMonitor. a non-negative integer with the limit in milliseconds to poll for changes Emitted when @file has been changed. If using %G_FILE_MONITOR_WATCH_MOVES on a directory monitor, and the information is available (and if supported by the backend), @event_type may be %G_FILE_MONITOR_EVENT_RENAMED, %G_FILE_MONITOR_EVENT_MOVED_IN or %G_FILE_MONITOR_EVENT_MOVED_OUT. In all cases @file will be a child of the monitored directory. For renames, @file will be the old name and @other_file is the new name. For "moved in" events, @file is the name of the file that appeared and @other_file is the old name that it was moved from (in another directory). For "moved out" events, @file is the name of the file that used to be in this directory and @other_file is the name of the file at its new location. It makes sense to treat %G_FILE_MONITOR_EVENT_MOVED_IN as equivalent to %G_FILE_MONITOR_EVENT_CREATED and %G_FILE_MONITOR_EVENT_MOVED_OUT as equivalent to %G_FILE_MONITOR_EVENT_DELETED, with extra information. %G_FILE_MONITOR_EVENT_RENAMED is equivalent to a delete/create pair. This is exactly how the events will be reported in the case that the %G_FILE_MONITOR_WATCH_MOVES flag is not in use. If using the deprecated flag %G_FILE_MONITOR_SEND_MOVED flag and @event_type is #G_FILE_MONITOR_EVENT_MOVED, @file will be set to a #GFile containing the old path, and @other_file will be set to a #GFile containing the new path. In all the other cases, @other_file will be set to #NULL. a #GFile. a #GFile or #NULL. a #GFileMonitorEvent. always %TRUE a #GFileMonitor. Specifies what type of event a monitor event is. a file changed. a hint that this was probably the last change in a set of changes. a file was deleted. a file was created. a file attribute was changed. the file location will soon be unmounted. the file location was unmounted. the file was moved -- only sent if the (deprecated) %G_FILE_MONITOR_SEND_MOVED flag is set the file was renamed within the current directory -- only sent if the %G_FILE_MONITOR_WATCH_MOVES flag is set. Since: 2.46. the file was moved into the monitored directory from another location -- only sent if the %G_FILE_MONITOR_WATCH_MOVES flag is set. Since: 2.46. the file was moved out of the monitored directory to another location -- only sent if the %G_FILE_MONITOR_WATCH_MOVES flag is set. Since: 2.46 Flags used to set what a #GFileMonitor will watch for. No flags set. Watch for mount events. Pair DELETED and CREATED events caused by file renames (moves) and send a single G_FILE_MONITOR_EVENT_MOVED event instead (NB: not supported on all backends; the default behaviour -without specifying this flag- is to send single DELETED and CREATED events). Deprecated since 2.46: use %G_FILE_MONITOR_WATCH_MOVES instead. Watch for changes to the file made via another hard link. Since 2.36. Watch for rename operations on a monitored directory. This causes %G_FILE_MONITOR_EVENT_RENAMED, %G_FILE_MONITOR_EVENT_MOVED_IN and %G_FILE_MONITOR_EVENT_MOVED_OUT events to be emitted when possible. Since: 2.46. GFileOutputStream provides output streams that write their content to a file. GFileOutputStream implements #GSeekable, which allows the output stream to jump to arbitrary positions in the file and to truncate the file, provided the filesystem of the file supports these operations. To find the position of a file output stream, use g_seekable_tell(). To find out if a file output stream supports seeking, use g_seekable_can_seek().To position a file output stream, use g_seekable_seek(). To find out if a file output stream supports truncating, use g_seekable_can_truncate(). To truncate a file output stream, use g_seekable_truncate(). Gets the entity tag for the file when it has been written. This must be called after the stream has been written and closed, as the etag can change while writing. the entity tag for the stream. a #GFileOutputStream. Queries a file output stream for the given @attributes. This function blocks while querying the stream. For the asynchronous version of this function, see g_file_output_stream_query_info_async(). While the stream is blocked, the stream will set the pending flag internally, and any other operations on the stream will fail with %G_IO_ERROR_PENDING. Can fail if the stream was already closed (with @error being set to %G_IO_ERROR_CLOSED), the stream has pending operations (with @error being set to %G_IO_ERROR_PENDING), or if querying info is not supported for the stream's interface (with @error being set to %G_IO_ERROR_NOT_SUPPORTED). In all cases of failure, %NULL will be returned. If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be set, and %NULL will be returned. a #GFileInfo for the @stream, or %NULL on error. a #GFileOutputStream. a file attribute query string. optional #GCancellable object, %NULL to ignore. Asynchronously queries the @stream for a #GFileInfo. When completed, @callback will be called with a #GAsyncResult which can be used to finish the operation with g_file_output_stream_query_info_finish(). For the synchronous version of this function, see g_file_output_stream_query_info(). a #GFileOutputStream. a file attribute query string. the [I/O priority][gio-GIOScheduler] of the request optional #GCancellable object, %NULL to ignore. callback to call when the request is satisfied the data to pass to callback function Finalizes the asynchronous query started by g_file_output_stream_query_info_async(). A #GFileInfo for the finished query. a #GFileOutputStream. a #GAsyncResult. Gets the entity tag for the file when it has been written. This must be called after the stream has been written and closed, as the etag can change while writing. the entity tag for the stream. a #GFileOutputStream. Queries a file output stream for the given @attributes. This function blocks while querying the stream. For the asynchronous version of this function, see g_file_output_stream_query_info_async(). While the stream is blocked, the stream will set the pending flag internally, and any other operations on the stream will fail with %G_IO_ERROR_PENDING. Can fail if the stream was already closed (with @error being set to %G_IO_ERROR_CLOSED), the stream has pending operations (with @error being set to %G_IO_ERROR_PENDING), or if querying info is not supported for the stream's interface (with @error being set to %G_IO_ERROR_NOT_SUPPORTED). In all cases of failure, %NULL will be returned. If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be set, and %NULL will be returned. a #GFileInfo for the @stream, or %NULL on error. a #GFileOutputStream. a file attribute query string. optional #GCancellable object, %NULL to ignore. Asynchronously queries the @stream for a #GFileInfo. When completed, @callback will be called with a #GAsyncResult which can be used to finish the operation with g_file_output_stream_query_info_finish(). For the synchronous version of this function, see g_file_output_stream_query_info(). a #GFileOutputStream. a file attribute query string. the [I/O priority][gio-GIOScheduler] of the request optional #GCancellable object, %NULL to ignore. callback to call when the request is satisfied the data to pass to callback function Finalizes the asynchronous query started by g_file_output_stream_query_info_async(). A #GFileInfo for the finished query. a #GFileOutputStream. a #GAsyncResult. a #GFileInfo for the @stream, or %NULL on error. a #GFileOutputStream. a file attribute query string. optional #GCancellable object, %NULL to ignore. a #GFileOutputStream. a file attribute query string. the [I/O priority][gio-GIOScheduler] of the request optional #GCancellable object, %NULL to ignore. callback to call when the request is satisfied the data to pass to callback function A #GFileInfo for the finished query. a #GFileOutputStream. a #GAsyncResult. the entity tag for the stream. a #GFileOutputStream. When doing file operations that may take a while, such as moving a file or copying a file, a progress callback is used to pass how far along that operation is to the application. the current number of bytes in the operation. the total number of bytes in the operation. user data passed to the callback. Flags used when querying a #GFileInfo. No flags set. Don't follow symlinks. When loading the partial contents of a file with g_file_load_partial_contents_async(), it may become necessary to determine if any more data from the file should be loaded. A #GFileReadMoreCallback function facilitates this by returning %TRUE if more data should be read, or %FALSE otherwise. %TRUE if more data should be read back. %FALSE otherwise. the data as currently read. the size of the data currently read. data passed to the callback. Indicates the file's on-disk type. On Windows systems a file will never have %G_FILE_TYPE_SYMBOLIC_LINK type; use #GFileInfo and %G_FILE_ATTRIBUTE_STANDARD_IS_SYMLINK to determine whether a file is a symlink or not. This is due to the fact that NTFS does not have a single filesystem object type for symbolic links - it has files that symlink to files, and directories that symlink to directories. #GFileType enumeration cannot precisely represent this important distinction, which is why all Windows symlinks will continue to be reported as %G_FILE_TYPE_REGULAR or %G_FILE_TYPE_DIRECTORY. File's type is unknown. File handle represents a regular file. File handle represents a directory. File handle represents a symbolic link (Unix systems). File is a "special" file, such as a socket, fifo, block device, or character device. File is a shortcut (Windows systems). File is a mountable location. Completes partial file and directory names given a partial string by looking in the file system for clues. Can return a list of possible completion strings for widget implementations. Creates a new filename completer. a #GFilenameCompleter. Obtains a completion for @initial_text from @completer. a completed string, or %NULL if no completion exists. This string is not owned by GIO, so remember to g_free() it when finished. the filename completer. text to be completed. Gets an array of completion strings for a given initial text. array of strings with possible completions for @initial_text. This array must be freed by g_strfreev() when finished. the filename completer. text to be completed. If @dirs_only is %TRUE, @completer will only complete directory names, and not file names. the filename completer. a #gboolean. Emitted when the file name completion information comes available. Indicates a hint from the file system whether files should be previewed in a file manager. Returned as the value of the key #G_FILE_ATTRIBUTE_FILESYSTEM_USE_PREVIEW. Only preview files if user has explicitly requested it. Preview files if user has requested preview of "local" files. Never preview files. Base class for input stream implementations that perform some kind of filtering operation on a base stream. Typical examples of filtering operations are character set conversion, compression and byte order flipping. Gets the base stream for the filter stream. a #GInputStream. a #GFilterInputStream. Returns whether the base stream will be closed when @stream is closed. %TRUE if the base stream will be closed. a #GFilterInputStream. Sets whether the base stream will be closed when @stream is closed. a #GFilterInputStream. %TRUE to close the base stream. Base class for output stream implementations that perform some kind of filtering operation on a base stream. Typical examples of filtering operations are character set conversion, compression and byte order flipping. Gets the base stream for the filter stream. a #GOutputStream. a #GFilterOutputStream. Returns whether the base stream will be closed when @stream is closed. %TRUE if the base stream will be closed. a #GFilterOutputStream. Sets whether the base stream will be closed when @stream is closed. a #GFilterOutputStream. %TRUE to close the base stream. Error codes returned by GIO functions. Note that this domain may be extended in future GLib releases. In general, new error codes either only apply to new APIs, or else replace %G_IO_ERROR_FAILED in cases that were not explicitly distinguished before. You should therefore avoid writing code like |[<!-- language="C" --> if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_FAILED)) { // Assume that this is EPRINTERONFIRE ... } ]| but should instead treat all unrecognized error codes the same as #G_IO_ERROR_FAILED. See also #GPollableReturn for a cheaper way of returning %G_IO_ERROR_WOULD_BLOCK to callers without allocating a #GError. Generic error condition for when an operation fails and no more specific #GIOErrorEnum value is defined. File not found. File already exists. File is a directory. File is not a directory. File is a directory that isn't empty. File is not a regular file. File is not a symbolic link. File cannot be mounted. Filename is too many characters. Filename is invalid or contains invalid characters. File contains too many symbolic links. No space left on drive. Invalid argument. Permission denied. Operation (or one of its parameters) not supported File isn't mounted. File is already mounted. File was closed. Operation was cancelled. See #GCancellable. Operations are still pending. File is read only. Backup couldn't be created. File's Entity Tag was incorrect. Operation timed out. Operation would be recursive. File is busy. Operation would block. Host couldn't be found (remote operations). Operation would merge files. Operation failed and a helper program has already interacted with the user. Do not display any error dialog. The current process has too many files open and can't open any more. Duplicate descriptors do count toward this limit. Since 2.20 The object has not been initialized. Since 2.22 The requested address is already in use. Since 2.22 Need more input to finish operation. Since 2.24 The input data was invalid. Since 2.24 A remote object generated an error that doesn't correspond to a locally registered #GError error domain. Use g_dbus_error_get_remote_error() to extract the D-Bus error name and g_dbus_error_strip_remote_error() to fix up the message so it matches what was received on the wire. Since 2.26. Host unreachable. Since 2.26 Network unreachable. Since 2.26 Connection refused. Since 2.26 Connection to proxy server failed. Since 2.26 Proxy authentication failed. Since 2.26 Proxy server needs authentication. Since 2.26 Proxy connection is not allowed by ruleset. Since 2.26 Broken pipe. Since 2.36 Connection closed by peer. Note that this is the same code as %G_IO_ERROR_BROKEN_PIPE; before 2.44 some "connection closed" errors returned %G_IO_ERROR_BROKEN_PIPE, but others returned %G_IO_ERROR_FAILED. Now they should all return the same value, which has this more logical name. Since 2.44. Transport endpoint is not connected. Since 2.44 Message too large. Since 2.48. #GIOExtension is an opaque data structure and can only be accessed using the following functions. Gets the name under which @extension was registered. Note that the same type may be registered as extension for multiple extension points, under different names. the name of @extension. a #GIOExtension Gets the priority with which @extension was registered. the priority of @extension a #GIOExtension Gets the type associated with @extension. the type of @extension a #GIOExtension Gets a reference to the class for the type that is associated with @extension. the #GTypeClass for the type of @extension a #GIOExtension #GIOExtensionPoint is an opaque data structure and can only be accessed using the following functions. Finds a #GIOExtension for an extension point by name. the #GIOExtension for @extension_point that has the given name, or %NULL if there is no extension with that name a #GIOExtensionPoint the name of the extension to get Gets a list of all extensions that implement this extension point. The list is sorted by priority, beginning with the highest priority. a #GList of #GIOExtensions. The list is owned by GIO and should not be modified. a #GIOExtensionPoint Gets the required type for @extension_point. the #GType that all implementations must have, or #G_TYPE_INVALID if the extension point has no required type a #GIOExtensionPoint Sets the required type for @extension_point to @type. All implementations must henceforth have this type. a #GIOExtensionPoint the #GType to require Registers @type as extension for the extension point with name @extension_point_name. If @type has already been registered as an extension for this extension point, the existing #GIOExtension object is returned. a #GIOExtension object for #GType the name of the extension point the #GType to register as extension the name for the extension the priority for the extension Looks up an existing extension point. the #GIOExtensionPoint, or %NULL if there is no registered extension point with the given name. the name of the extension point Registers an extension point. the new #GIOExtensionPoint. This object is owned by GIO and should not be freed. The name of the extension point Provides an interface and default functions for loading and unloading modules. This is used internally to make GIO extensible, but can also be used by others to implement module loading. Creates a new GIOModule that will load the specific shared library when in use. a #GIOModule from given @filename, or %NULL on error. filename of the shared library module. Optional API for GIO modules to implement. Should return a list of all the extension points that may be implemented in this module. This method will not be called in normal use, however it may be called when probing existing modules and recording which extension points that this model is used for. This means we won't have to load and initialize this module unless its needed. If this function is not implemented by the module the module will always be loaded, initialized and then unloaded on application startup so that it can register its extension points during init. Note that a module need not actually implement all the extension points that g_io_module_query() returns, since the exact list of extension may depend on runtime issues. However all extension points actually implemented must be returned by g_io_module_query() (if defined). When installing a module that implements g_io_module_query() you must run gio-querymodules in order to build the cache files required for lazy loading. Since 2.56, this function should be named `g_io_<modulename>_query`, where `modulename` is the plugin’s filename with the `lib` or `libgio` prefix and everything after the first dot removed, and with `-` replaced with `_` throughout. For example, `libgiognutls-helper.so` becomes `gnutls_helper`. Using the new symbol names avoids name clashes when building modules statically. The old symbol names continue to be supported, but cannot be used for static builds. A %NULL-terminated array of strings, listing the supported extension points of the module. The array must be suitable for freeing with g_strfreev(). Required API for GIO modules to implement. This function is run after the module has been loaded into GIO, to initialize the module. Typically, this function will call g_io_extension_point_implement(). Since 2.56, this function should be named `g_io_<modulename>_load`, where `modulename` is the plugin’s filename with the `lib` or `libgio` prefix and everything after the first dot removed, and with `-` replaced with `_` throughout. For example, `libgiognutls-helper.so` becomes `gnutls_helper`. Using the new symbol names avoids name clashes when building modules statically. The old symbol names continue to be supported, but cannot be used for static builds. a #GIOModule. Required API for GIO modules to implement. This function is run when the module is being unloaded from GIO, to finalize the module. Since 2.56, this function should be named `g_io_<modulename>_unload`, where `modulename` is the plugin’s filename with the `lib` or `libgio` prefix and everything after the first dot removed, and with `-` replaced with `_` throughout. For example, `libgiognutls-helper.so` becomes `gnutls_helper`. Using the new symbol names avoids name clashes when building modules statically. The old symbol names continue to be supported, but cannot be used for static builds. a #GIOModule. Represents a scope for loading IO modules. A scope can be used for blocking duplicate modules, or blocking a module you don't want to load. The scope can be used with g_io_modules_load_all_in_directory_with_scope() or g_io_modules_scan_all_in_directory_with_scope(). Block modules with the given @basename from being loaded when this scope is used with g_io_modules_scan_all_in_directory_with_scope() or g_io_modules_load_all_in_directory_with_scope(). a module loading scope the basename to block Free a module scope. a module loading scope Create a new scope for loading of IO modules. A scope can be used for blocking duplicate modules, or blocking a module you don't want to load. Specify the %G_IO_MODULE_SCOPE_BLOCK_DUPLICATES flag to block modules which have the same base name as a module that has already been seen in this scope. the new module scope flags for the new scope Flags for use with g_io_module_scope_new(). No module scan flags When using this scope to load or scan modules, automatically block a modules which has the same base basename as previously loaded module. Opaque class for defining and scheduling IO jobs. Used from an I/O job to send a callback to be run in the thread that the job was started from, waiting for the result (and thus blocking the I/O job). Use g_main_context_invoke(). The return value of @func a #GIOSchedulerJob a #GSourceFunc callback that will be called in the original thread data to pass to @func a #GDestroyNotify for @user_data, or %NULL Used from an I/O job to send a callback to be run asynchronously in the thread that the job was started from. The callback will be run when the main loop is available, but at that time the I/O job might have finished. The return value from the callback is ignored. Note that if you are passing the @user_data from g_io_scheduler_push_job() on to this function you have to ensure that it is not freed before @func is called, either by passing %NULL as @notify to g_io_scheduler_push_job() or by using refcounting for @user_data. Use g_main_context_invoke(). a #GIOSchedulerJob a #GSourceFunc callback that will be called in the original thread data to pass to @func a #GDestroyNotify for @user_data, or %NULL I/O Job function. Long-running jobs should periodically check the @cancellable to see if they have been cancelled. %TRUE if this function should be called again to complete the job, %FALSE if the job is complete (or cancelled) a #GIOSchedulerJob. optional #GCancellable object, %NULL to ignore. the data to pass to callback function GIOStream represents an object that has both read and write streams. Generally the two streams act as separate input and output streams, but they share some common resources and state. For instance, for seekable streams, both streams may use the same position. Examples of #GIOStream objects are #GSocketConnection, which represents a two-way network connection; and #GFileIOStream, which represents a file handle opened in read-write mode. To do the actual reading and writing you need to get the substreams with g_io_stream_get_input_stream() and g_io_stream_get_output_stream(). The #GIOStream object owns the input and the output streams, not the other way around, so keeping the substreams alive will not keep the #GIOStream object alive. If the #GIOStream object is freed it will be closed, thus closing the substreams, so even if the substreams stay alive they will always return %G_IO_ERROR_CLOSED for all operations. To close a stream use g_io_stream_close() which will close the common stream object and also the individual substreams. You can also close the substreams themselves. In most cases this only marks the substream as closed, so further I/O on it fails but common state in the #GIOStream may still be open. However, some streams may support "half-closed" states where one direction of the stream is actually shut down. Operations on #GIOStreams cannot be started while another operation on the #GIOStream or its substreams is in progress. Specifically, an application can read from the #GInputStream and write to the #GOutputStream simultaneously (either in separate threads, or as asynchronous operations in the same thread), but an application cannot start any #GIOStream operation while there is a #GIOStream, #GInputStream or #GOutputStream operation in progress, and an application can’t start any #GInputStream or #GOutputStream operation while there is a #GIOStream operation in progress. This is a product of individual stream operations being associated with a given #GMainContext (the thread-default context at the time the operation was started), rather than entire streams being associated with a single #GMainContext. GIO may run operations on #GIOStreams from other (worker) threads, and this may be exposed to application code in the behaviour of wrapper streams, such as #GBufferedInputStream or #GTlsConnection. With such wrapper APIs, application code may only run operations on the base (wrapped) stream when the wrapper stream is idle. Note that the semantics of such operations may not be well-defined due to the state the wrapper stream leaves the base stream in (though they are guaranteed not to crash). Finishes an asynchronous io stream splice operation. %TRUE on success, %FALSE otherwise. a #GAsyncResult. Requests an asynchronous close of the stream, releasing resources related to it. When the operation is finished @callback will be called. You can then call g_io_stream_close_finish() to get the result of the operation. For behaviour details see g_io_stream_close(). The asynchronous methods have a default fallback that uses threads to implement asynchronicity, so they are optional for inheriting classes. However, if you override one you must override all. a #GIOStream the io priority of the request optional cancellable object callback to call when the request is satisfied the data to pass to callback function Closes a stream. %TRUE if stream was successfully closed, %FALSE otherwise. a #GIOStream a #GAsyncResult Gets the input stream for this object. This is used for reading. a #GInputStream, owned by the #GIOStream. Do not free. a #GIOStream Gets the output stream for this object. This is used for writing. a #GOutputStream, owned by the #GIOStream. Do not free. a #GIOStream Clears the pending flag on @stream. a #GIOStream Closes the stream, releasing resources related to it. This will also close the individual input and output streams, if they are not already closed. Once the stream is closed, all other operations will return %G_IO_ERROR_CLOSED. Closing a stream multiple times will not return an error. Closing a stream will automatically flush any outstanding buffers in the stream. Streams will be automatically closed when the last reference is dropped, but you might want to call this function to make sure resources are released as early as possible. Some streams might keep the backing store of the stream (e.g. a file descriptor) open after the stream is closed. See the documentation for the individual stream for details. On failure the first error that happened will be reported, but the close operation will finish as much as possible. A stream that failed to close will still return %G_IO_ERROR_CLOSED for all operations. Still, it is important to check and report the error to the user, otherwise there might be a loss of data as all data might not be written. If @cancellable is not NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. Cancelling a close will still leave the stream closed, but some streams can use a faster close that doesn't block to e.g. check errors. The default implementation of this method just calls close on the individual input/output streams. %TRUE on success, %FALSE on failure a #GIOStream optional #GCancellable object, %NULL to ignore Requests an asynchronous close of the stream, releasing resources related to it. When the operation is finished @callback will be called. You can then call g_io_stream_close_finish() to get the result of the operation. For behaviour details see g_io_stream_close(). The asynchronous methods have a default fallback that uses threads to implement asynchronicity, so they are optional for inheriting classes. However, if you override one you must override all. a #GIOStream the io priority of the request optional cancellable object callback to call when the request is satisfied the data to pass to callback function Closes a stream. %TRUE if stream was successfully closed, %FALSE otherwise. a #GIOStream a #GAsyncResult Gets the input stream for this object. This is used for reading. a #GInputStream, owned by the #GIOStream. Do not free. a #GIOStream Gets the output stream for this object. This is used for writing. a #GOutputStream, owned by the #GIOStream. Do not free. a #GIOStream Checks if a stream has pending actions. %TRUE if @stream has pending actions. a #GIOStream Checks if a stream is closed. %TRUE if the stream is closed. a #GIOStream Sets @stream to have actions pending. If the pending flag is already set or @stream is closed, it will return %FALSE and set @error. %TRUE if pending was previously unset and is now set. a #GIOStream Asynchronously splice the output stream of @stream1 to the input stream of @stream2, and splice the output stream of @stream2 to the input stream of @stream1. When the operation is finished @callback will be called. You can then call g_io_stream_splice_finish() to get the result of the operation. a #GIOStream. a #GIOStream. a set of #GIOStreamSpliceFlags. the io priority of the request. optional #GCancellable object, %NULL to ignore. a #GAsyncReadyCallback. user data passed to @callback. a #GInputStream, owned by the #GIOStream. Do not free. a #GIOStream a #GOutputStream, owned by the #GIOStream. Do not free. a #GIOStream a #GIOStream the io priority of the request optional cancellable object callback to call when the request is satisfied the data to pass to callback function %TRUE if stream was successfully closed, %FALSE otherwise. a #GIOStream a #GAsyncResult GIOStreamSpliceFlags determine how streams should be spliced. Do not close either stream. Close the first stream after the splice. Close the second stream after the splice. Wait for both splice operations to finish before calling the callback. #GIcon is a very minimal interface for icons. It provides functions for checking the equality of two icons, hashing of icons and serializing an icon to and from strings. #GIcon does not provide the actual pixmap for the icon as this is out of GIO's scope, however implementations of #GIcon may contain the name of an icon (see #GThemedIcon), or the path to an icon (see #GLoadableIcon). To obtain a hash of a #GIcon, see g_icon_hash(). To check if two #GIcons are equal, see g_icon_equal(). For serializing a #GIcon, use g_icon_serialize() and g_icon_deserialize(). If you want to consume #GIcon (for example, in a toolkit) you must be prepared to handle at least the three following cases: #GLoadableIcon, #GThemedIcon and #GEmblemedIcon. It may also make sense to have fast-paths for other cases (like handling #GdkPixbuf directly, for example) but all compliant #GIcon implementations outside of GIO must implement #GLoadableIcon. If your application or library provides one or more #GIcon implementations you need to ensure that your new implementation also implements #GLoadableIcon. Additionally, you must provide an implementation of g_icon_serialize() that gives a result that is understood by g_icon_deserialize(), yielding one of the built-in icon types. Deserializes a #GIcon previously serialized using g_icon_serialize(). a #GIcon, or %NULL when deserialization fails. a #GVariant created with g_icon_serialize() Gets a hash for an icon. a #guint containing a hash for the @icon, suitable for use in a #GHashTable or similar data structure. #gconstpointer to an icon object. Generate a #GIcon instance from @str. This function can fail if @str is not valid - see g_icon_to_string() for discussion. If your application or library provides one or more #GIcon implementations you need to ensure that each #GType is registered with the type system prior to calling g_icon_new_for_string(). An object implementing the #GIcon interface or %NULL if @error is set. A string obtained via g_icon_to_string(). Checks if two icons are equal. %TRUE if @icon1 is equal to @icon2. %FALSE otherwise. pointer to the first #GIcon. pointer to the second #GIcon. Gets a hash for an icon. a #guint containing a hash for the @icon, suitable for use in a #GHashTable or similar data structure. #gconstpointer to an icon object. Serializes a #GIcon into a #GVariant. An equivalent #GIcon can be retrieved back by calling g_icon_deserialize() on the returned value. As serialization will avoid using raw icon data when possible, it only makes sense to transfer the #GVariant between processes on the same machine, (as opposed to over the network), and within the same file system namespace. a #GVariant, or %NULL when serialization fails. The #GVariant will not be floating. a #GIcon Generates a textual representation of @icon that can be used for serialization such as when passing @icon to a different process or saving it to persistent storage. Use g_icon_new_for_string() to get @icon back from the returned string. The encoding of the returned string is proprietary to #GIcon except in the following two cases - If @icon is a #GFileIcon, the returned string is a native path (such as `/path/to/my icon.png`) without escaping if the #GFile for @icon is a native file. If the file is not native, the returned string is the result of g_file_get_uri() (such as `sftp://path/to/my%20icon.png`). - If @icon is a #GThemedIcon with exactly one name and no fallbacks, the encoding is simply the name (such as `network-server`). An allocated NUL-terminated UTF8 string or %NULL if @icon can't be serialized. Use g_free() to free. a #GIcon. Checks if two icons are equal. %TRUE if @icon1 is equal to @icon2. %FALSE otherwise. pointer to the first #GIcon. pointer to the second #GIcon. Serializes a #GIcon into a #GVariant. An equivalent #GIcon can be retrieved back by calling g_icon_deserialize() on the returned value. As serialization will avoid using raw icon data when possible, it only makes sense to transfer the #GVariant between processes on the same machine, (as opposed to over the network), and within the same file system namespace. a #GVariant, or %NULL when serialization fails. The #GVariant will not be floating. a #GIcon Generates a textual representation of @icon that can be used for serialization such as when passing @icon to a different process or saving it to persistent storage. Use g_icon_new_for_string() to get @icon back from the returned string. The encoding of the returned string is proprietary to #GIcon except in the following two cases - If @icon is a #GFileIcon, the returned string is a native path (such as `/path/to/my icon.png`) without escaping if the #GFile for @icon is a native file. If the file is not native, the returned string is the result of g_file_get_uri() (such as `sftp://path/to/my%20icon.png`). - If @icon is a #GThemedIcon with exactly one name and no fallbacks, the encoding is simply the name (such as `network-server`). An allocated NUL-terminated UTF8 string or %NULL if @icon can't be serialized. Use g_free() to free. a #GIcon. GIconIface is used to implement GIcon types for various different systems. See #GThemedIcon and #GLoadableIcon for examples of how to implement this interface. The parent interface. a #guint containing a hash for the @icon, suitable for use in a #GHashTable or similar data structure. #gconstpointer to an icon object. %TRUE if @icon1 is equal to @icon2. %FALSE otherwise. pointer to the first #GIcon. pointer to the second #GIcon. An allocated NUL-terminated UTF8 string or %NULL if @icon can't be serialized. Use g_free() to free. a #GIcon. a #GVariant, or %NULL when serialization fails. The #GVariant will not be floating. a #GIcon #GInetAddress represents an IPv4 or IPv6 internet address. Use g_resolver_lookup_by_name() or g_resolver_lookup_by_name_async() to look up the #GInetAddress for a hostname. Use g_resolver_lookup_by_address() or g_resolver_lookup_by_address_async() to look up the hostname for a #GInetAddress. To actually connect to a remote host, you will need a #GInetSocketAddress (which includes a #GInetAddress as well as a port number). Creates a #GInetAddress for the "any" address (unassigned/"don't care") for @family. a new #GInetAddress corresponding to the "any" address for @family. Free the returned object with g_object_unref(). the address family Creates a new #GInetAddress from the given @family and @bytes. @bytes should be 4 bytes for %G_SOCKET_FAMILY_IPV4 and 16 bytes for %G_SOCKET_FAMILY_IPV6. a new #GInetAddress corresponding to @family and @bytes. Free the returned object with g_object_unref(). raw address data the address family of @bytes Parses @string as an IP address and creates a new #GInetAddress. a new #GInetAddress corresponding to @string, or %NULL if @string could not be parsed. Free the returned object with g_object_unref(). a string representation of an IP address Creates a #GInetAddress for the loopback address for @family. a new #GInetAddress corresponding to the loopback address for @family. Free the returned object with g_object_unref(). the address family Gets the raw binary address data from @address. a pointer to an internal array of the bytes in @address, which should not be modified, stored, or freed. The size of this array can be gotten with g_inet_address_get_native_size(). a #GInetAddress Converts @address to string form. a representation of @address as a string, which should be freed after use. a #GInetAddress Checks if two #GInetAddress instances are equal, e.g. the same address. %TRUE if @address and @other_address are equal, %FALSE otherwise. A #GInetAddress. Another #GInetAddress. Gets @address's family @address's family a #GInetAddress Tests whether @address is the "any" address for its family. %TRUE if @address is the "any" address for its family. a #GInetAddress Tests whether @address is a link-local address (that is, if it identifies a host on a local network that is not connected to the Internet). %TRUE if @address is a link-local address. a #GInetAddress Tests whether @address is the loopback address for its family. %TRUE if @address is the loopback address for its family. a #GInetAddress Tests whether @address is a global multicast address. %TRUE if @address is a global multicast address. a #GInetAddress Tests whether @address is a link-local multicast address. %TRUE if @address is a link-local multicast address. a #GInetAddress Tests whether @address is a node-local multicast address. %TRUE if @address is a node-local multicast address. a #GInetAddress Tests whether @address is an organization-local multicast address. %TRUE if @address is an organization-local multicast address. a #GInetAddress Tests whether @address is a site-local multicast address. %TRUE if @address is a site-local multicast address. a #GInetAddress Tests whether @address is a multicast address. %TRUE if @address is a multicast address. a #GInetAddress Tests whether @address is a site-local address such as 10.0.0.1 (that is, the address identifies a host on a local network that can not be reached directly from the Internet, but which may have outgoing Internet connectivity via a NAT or firewall). %TRUE if @address is a site-local address. a #GInetAddress Gets the size of the native raw binary address for @address. This is the size of the data that you get from g_inet_address_to_bytes(). the number of bytes used for the native version of @address. a #GInetAddress Gets the raw binary address data from @address. a pointer to an internal array of the bytes in @address, which should not be modified, stored, or freed. The size of this array can be gotten with g_inet_address_get_native_size(). a #GInetAddress Converts @address to string form. a representation of @address as a string, which should be freed after use. a #GInetAddress Whether this is the "any" address for its family. See g_inet_address_get_is_any(). Whether this is a link-local address. See g_inet_address_get_is_link_local(). Whether this is the loopback address for its family. See g_inet_address_get_is_loopback(). Whether this is a global multicast address. See g_inet_address_get_is_mc_global(). Whether this is a link-local multicast address. See g_inet_address_get_is_mc_link_local(). Whether this is a node-local multicast address. See g_inet_address_get_is_mc_node_local(). Whether this is an organization-local multicast address. See g_inet_address_get_is_mc_org_local(). Whether this is a site-local multicast address. See g_inet_address_get_is_mc_site_local(). Whether this is a multicast address. See g_inet_address_get_is_multicast(). Whether this is a site-local address. See g_inet_address_get_is_loopback(). a representation of @address as a string, which should be freed after use. a #GInetAddress a pointer to an internal array of the bytes in @address, which should not be modified, stored, or freed. The size of this array can be gotten with g_inet_address_get_native_size(). a #GInetAddress #GInetAddressMask represents a range of IPv4 or IPv6 addresses described by a base address and a length indicating how many bits of the base address are relevant for matching purposes. These are often given in string form. Eg, "10.0.0.0/8", or "fe80::/10". Creates a new #GInetAddressMask representing all addresses whose first @length bits match @addr. a new #GInetAddressMask, or %NULL on error a #GInetAddress number of bits of @addr to use Parses @mask_string as an IP address and (optional) length, and creates a new #GInetAddressMask. The length, if present, is delimited by a "/". If it is not present, then the length is assumed to be the full length of the address. a new #GInetAddressMask corresponding to @string, or %NULL on error. an IP address or address/length string Tests if @mask and @mask2 are the same mask. whether @mask and @mask2 are the same mask a #GInetAddressMask another #GInetAddressMask Gets @mask's base address @mask's base address a #GInetAddressMask Gets the #GSocketFamily of @mask's address the #GSocketFamily of @mask's address a #GInetAddressMask Gets @mask's length @mask's length a #GInetAddressMask Tests if @address falls within the range described by @mask. whether @address falls within the range described by @mask. a #GInetAddressMask a #GInetAddress Converts @mask back to its corresponding string form. a string corresponding to @mask. a #GInetAddressMask An IPv4 or IPv6 socket address; that is, the combination of a #GInetAddress and a port number. Creates a new #GInetSocketAddress for @address and @port. a new #GInetSocketAddress a #GInetAddress a port number Creates a new #GInetSocketAddress for @address and @port. If @address is an IPv6 address, it can also contain a scope ID (separated from the address by a `%`). a new #GInetSocketAddress, or %NULL if @address cannot be parsed. the string form of an IP address a port number Gets @address's #GInetAddress. the #GInetAddress for @address, which must be g_object_ref()'d if it will be stored a #GInetSocketAddress Gets the `sin6_flowinfo` field from @address, which must be an IPv6 address. the flowinfo field a %G_SOCKET_FAMILY_IPV6 #GInetSocketAddress Gets @address's port. the port for @address a #GInetSocketAddress Gets the `sin6_scope_id` field from @address, which must be an IPv6 address. the scope id field a %G_SOCKET_FAMILY_IPV6 #GInetAddress The `sin6_flowinfo` field, for IPv6 addresses. #GInitable is implemented by objects that can fail during initialization. If an object implements this interface then it must be initialized as the first thing after construction, either via g_initable_init() or g_async_initable_init_async() (the latter is only available if it also implements #GAsyncInitable). If the object is not initialized, or initialization returns with an error, then all operations on the object except g_object_ref() and g_object_unref() are considered to be invalid, and have undefined behaviour. They will often fail with g_critical() or g_warning(), but this must not be relied on. Users of objects implementing this are not intended to use the interface method directly, instead it will be used automatically in various ways. For C applications you generally just call g_initable_new() directly, or indirectly via a foo_thing_new() wrapper. This will call g_initable_init() under the cover, returning %NULL and setting a #GError on failure (at which point the instance is unreferenced). For bindings in languages where the native constructor supports exceptions the binding could check for objects implementing %GInitable during normal construction and automatically initialize them, throwing an exception on failure. Helper function for constructing #GInitable object. This is similar to g_object_new() but also initializes the object and returns %NULL, setting an error on failure. a newly allocated #GObject, or %NULL on error a #GType supporting #GInitable. optional #GCancellable object, %NULL to ignore. a #GError location to store the error occurring, or %NULL to ignore. the name of the first property, or %NULL if no properties the value if the first property, followed by and other property value pairs, and ended by %NULL. Helper function for constructing #GInitable object. This is similar to g_object_new_valist() but also initializes the object and returns %NULL, setting an error on failure. a newly allocated #GObject, or %NULL on error a #GType supporting #GInitable. the name of the first property, followed by the value, and other property value pairs, and ended by %NULL. The var args list generated from @first_property_name. optional #GCancellable object, %NULL to ignore. Helper function for constructing #GInitable object. This is similar to g_object_newv() but also initializes the object and returns %NULL, setting an error on failure. Use g_object_new_with_properties() and g_initable_init() instead. See #GParameter for more information. a newly allocated #GObject, or %NULL on error a #GType supporting #GInitable. the number of parameters in @parameters the parameters to use to construct the object optional #GCancellable object, %NULL to ignore. Initializes the object implementing the interface. This method is intended for language bindings. If writing in C, g_initable_new() should typically be used instead. The object must be initialized before any real use after initial construction, either with this function or g_async_initable_init_async(). Implementations may also support cancellation. If @cancellable is not %NULL, then initialization can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If @cancellable is not %NULL and the object doesn't support cancellable initialization the error %G_IO_ERROR_NOT_SUPPORTED will be returned. If the object is not initialized, or initialization returns with an error, then all operations on the object except g_object_ref() and g_object_unref() are considered to be invalid, and have undefined behaviour. See the [introduction][ginitable] for more details. Callers should not assume that a class which implements #GInitable can be initialized multiple times, unless the class explicitly documents itself as supporting this. Generally, a class’ implementation of init() can assume (and assert) that it will only be called once. Previously, this documentation recommended all #GInitable implementations should be idempotent; that recommendation was relaxed in GLib 2.54. If a class explicitly supports being initialized multiple times, it is recommended that the method is idempotent: multiple calls with the same arguments should return the same results. Only the first call initializes the object; further calls return the result of the first call. One reason why a class might need to support idempotent initialization is if it is designed to be used via the singleton pattern, with a #GObjectClass.constructor that sometimes returns an existing instance. In this pattern, a caller would expect to be able to call g_initable_init() on the result of g_object_new(), regardless of whether it is in fact a new instance. %TRUE if successful. If an error has occurred, this function will return %FALSE and set @error appropriately if present. a #GInitable. optional #GCancellable object, %NULL to ignore. Initializes the object implementing the interface. This method is intended for language bindings. If writing in C, g_initable_new() should typically be used instead. The object must be initialized before any real use after initial construction, either with this function or g_async_initable_init_async(). Implementations may also support cancellation. If @cancellable is not %NULL, then initialization can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If @cancellable is not %NULL and the object doesn't support cancellable initialization the error %G_IO_ERROR_NOT_SUPPORTED will be returned. If the object is not initialized, or initialization returns with an error, then all operations on the object except g_object_ref() and g_object_unref() are considered to be invalid, and have undefined behaviour. See the [introduction][ginitable] for more details. Callers should not assume that a class which implements #GInitable can be initialized multiple times, unless the class explicitly documents itself as supporting this. Generally, a class’ implementation of init() can assume (and assert) that it will only be called once. Previously, this documentation recommended all #GInitable implementations should be idempotent; that recommendation was relaxed in GLib 2.54. If a class explicitly supports being initialized multiple times, it is recommended that the method is idempotent: multiple calls with the same arguments should return the same results. Only the first call initializes the object; further calls return the result of the first call. One reason why a class might need to support idempotent initialization is if it is designed to be used via the singleton pattern, with a #GObjectClass.constructor that sometimes returns an existing instance. In this pattern, a caller would expect to be able to call g_initable_init() on the result of g_object_new(), regardless of whether it is in fact a new instance. %TRUE if successful. If an error has occurred, this function will return %FALSE and set @error appropriately if present. a #GInitable. optional #GCancellable object, %NULL to ignore. Provides an interface for initializing object such that initialization may fail. The parent interface. %TRUE if successful. If an error has occurred, this function will return %FALSE and set @error appropriately if present. a #GInitable. optional #GCancellable object, %NULL to ignore. Structure used for scatter/gather data input when receiving multiple messages or packets in one go. You generally pass in an array of empty #GInputVectors and the operation will use all the buffers as if they were one buffer, and will set @bytes_received to the total number of bytes received across all #GInputVectors. This structure closely mirrors `struct mmsghdr` and `struct msghdr` from the POSIX sockets API (see `man 2 recvmmsg`). If @address is non-%NULL then it is set to the source address the message was received from, and the caller must free it afterwards. If @control_messages is non-%NULL then it is set to an array of control messages received with the message (if any), and the caller must free it afterwards. @num_control_messages is set to the number of elements in this array, which may be zero. Flags relevant to this message will be returned in @flags. For example, `MSG_EOR` or `MSG_TRUNC`. return location for a #GSocketAddress, or %NULL pointer to an array of input vectors the number of input vectors pointed to by @vectors will be set to the number of bytes that have been received collection of #GSocketMsgFlags for the received message, outputted by the call return location for a caller-allocated array of #GSocketControlMessages, or %NULL return location for the number of elements in @control_messages #GInputStream has functions to read from a stream (g_input_stream_read()), to close a stream (g_input_stream_close()) and to skip some content (g_input_stream_skip()). To copy the content of an input stream to an output stream without manually handling the reads and writes, use g_output_stream_splice(). See the documentation for #GIOStream for details of thread safety of streaming APIs. All of these functions have async variants too. Requests an asynchronous closes of the stream, releasing resources related to it. When the operation is finished @callback will be called. You can then call g_input_stream_close_finish() to get the result of the operation. For behaviour details see g_input_stream_close(). The asynchronous methods have a default fallback that uses threads to implement asynchronicity, so they are optional for inheriting classes. However, if you override one you must override all. A #GInputStream. the [I/O priority][io-priority] of the request optional cancellable object callback to call when the request is satisfied the data to pass to callback function Finishes closing a stream asynchronously, started from g_input_stream_close_async(). %TRUE if the stream was closed successfully. a #GInputStream. a #GAsyncResult. Request an asynchronous read of @count bytes from the stream into the buffer starting at @buffer. When the operation is finished @callback will be called. You can then call g_input_stream_read_finish() to get the result of the operation. During an async request no other sync and async calls are allowed on @stream, and will result in %G_IO_ERROR_PENDING errors. A value of @count larger than %G_MAXSSIZE will cause a %G_IO_ERROR_INVALID_ARGUMENT error. On success, the number of bytes read into the buffer will be passed to the callback. It is not an error if this is not the same as the requested size, as it can happen e.g. near the end of a file, but generally we try to read as many bytes as requested. Zero is returned on end of file (or if @count is zero), but never otherwise. Any outstanding i/o request with higher priority (lower numerical value) will be executed before an outstanding request with lower priority. Default priority is %G_PRIORITY_DEFAULT. The asynchronous methods have a default fallback that uses threads to implement asynchronicity, so they are optional for inheriting classes. However, if you override one you must override all. A #GInputStream. a buffer to read data into (which should be at least count bytes long). the number of bytes that will be read from the stream the [I/O priority][io-priority] of the request. optional #GCancellable object, %NULL to ignore. callback to call when the request is satisfied the data to pass to callback function Finishes an asynchronous stream read operation. number of bytes read in, or -1 on error, or 0 on end of file. a #GInputStream. a #GAsyncResult. Tries to skip @count bytes from the stream. Will block during the operation. This is identical to g_input_stream_read(), from a behaviour standpoint, but the bytes that are skipped are not returned to the user. Some streams have an implementation that is more efficient than reading the data. This function is optional for inherited classes, as the default implementation emulates it using read. If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an operation was partially finished when the operation was cancelled the partial result will be returned, without an error. Number of bytes skipped, or -1 on error a #GInputStream. the number of bytes that will be skipped from the stream optional #GCancellable object, %NULL to ignore. Request an asynchronous skip of @count bytes from the stream. When the operation is finished @callback will be called. You can then call g_input_stream_skip_finish() to get the result of the operation. During an async request no other sync and async calls are allowed, and will result in %G_IO_ERROR_PENDING errors. A value of @count larger than %G_MAXSSIZE will cause a %G_IO_ERROR_INVALID_ARGUMENT error. On success, the number of bytes skipped will be passed to the callback. It is not an error if this is not the same as the requested size, as it can happen e.g. near the end of a file, but generally we try to skip as many bytes as requested. Zero is returned on end of file (or if @count is zero), but never otherwise. Any outstanding i/o request with higher priority (lower numerical value) will be executed before an outstanding request with lower priority. Default priority is %G_PRIORITY_DEFAULT. The asynchronous methods have a default fallback that uses threads to implement asynchronicity, so they are optional for inheriting classes. However, if you override one, you must override all. A #GInputStream. the number of bytes that will be skipped from the stream the [I/O priority][io-priority] of the request optional #GCancellable object, %NULL to ignore. callback to call when the request is satisfied the data to pass to callback function Finishes a stream skip operation. the size of the bytes skipped, or `-1` on error. a #GInputStream. a #GAsyncResult. Clears the pending flag on @stream. input stream Closes the stream, releasing resources related to it. Once the stream is closed, all other operations will return %G_IO_ERROR_CLOSED. Closing a stream multiple times will not return an error. Streams will be automatically closed when the last reference is dropped, but you might want to call this function to make sure resources are released as early as possible. Some streams might keep the backing store of the stream (e.g. a file descriptor) open after the stream is closed. See the documentation for the individual stream for details. On failure the first error that happened will be reported, but the close operation will finish as much as possible. A stream that failed to close will still return %G_IO_ERROR_CLOSED for all operations. Still, it is important to check and report the error to the user. If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. Cancelling a close will still leave the stream closed, but some streams can use a faster close that doesn't block to e.g. check errors. %TRUE on success, %FALSE on failure A #GInputStream. optional #GCancellable object, %NULL to ignore. Requests an asynchronous closes of the stream, releasing resources related to it. When the operation is finished @callback will be called. You can then call g_input_stream_close_finish() to get the result of the operation. For behaviour details see g_input_stream_close(). The asynchronous methods have a default fallback that uses threads to implement asynchronicity, so they are optional for inheriting classes. However, if you override one you must override all. A #GInputStream. the [I/O priority][io-priority] of the request optional cancellable object callback to call when the request is satisfied the data to pass to callback function Finishes closing a stream asynchronously, started from g_input_stream_close_async(). %TRUE if the stream was closed successfully. a #GInputStream. a #GAsyncResult. Checks if an input stream has pending actions. %TRUE if @stream has pending actions. input stream. Checks if an input stream is closed. %TRUE if the stream is closed. input stream. Tries to read @count bytes from the stream into the buffer starting at @buffer. Will block during this read. If count is zero returns zero and does nothing. A value of @count larger than %G_MAXSSIZE will cause a %G_IO_ERROR_INVALID_ARGUMENT error. On success, the number of bytes read into the buffer is returned. It is not an error if this is not the same as the requested size, as it can happen e.g. near the end of a file. Zero is returned on end of file (or if @count is zero), but never otherwise. The returned @buffer is not a nul-terminated string, it can contain nul bytes at any position, and this function doesn't nul-terminate the @buffer. If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an operation was partially finished when the operation was cancelled the partial result will be returned, without an error. On error -1 is returned and @error is set accordingly. Number of bytes read, or -1 on error, or 0 on end of file. a #GInputStream. a buffer to read data into (which should be at least count bytes long). the number of bytes that will be read from the stream optional #GCancellable object, %NULL to ignore. Tries to read @count bytes from the stream into the buffer starting at @buffer. Will block during this read. This function is similar to g_input_stream_read(), except it tries to read as many bytes as requested, only stopping on an error or end of stream. On a successful read of @count bytes, or if we reached the end of the stream, %TRUE is returned, and @bytes_read is set to the number of bytes read into @buffer. If there is an error during the operation %FALSE is returned and @error is set to indicate the error status. As a special exception to the normal conventions for functions that use #GError, if this function returns %FALSE (and sets @error) then @bytes_read will be set to the number of bytes that were successfully read before the error was encountered. This functionality is only available from C. If you need it from another language then you must write your own loop around g_input_stream_read(). %TRUE on success, %FALSE if there was an error a #GInputStream. a buffer to read data into (which should be at least count bytes long). the number of bytes that will be read from the stream location to store the number of bytes that was read from the stream optional #GCancellable object, %NULL to ignore. Request an asynchronous read of @count bytes from the stream into the buffer starting at @buffer. This is the asynchronous equivalent of g_input_stream_read_all(). Call g_input_stream_read_all_finish() to collect the result. Any outstanding I/O request with higher priority (lower numerical value) will be executed before an outstanding request with lower priority. Default priority is %G_PRIORITY_DEFAULT. A #GInputStream a buffer to read data into (which should be at least count bytes long) the number of bytes that will be read from the stream the [I/O priority][io-priority] of the request optional #GCancellable object, %NULL to ignore callback to call when the request is satisfied the data to pass to callback function Finishes an asynchronous stream read operation started with g_input_stream_read_all_async(). As a special exception to the normal conventions for functions that use #GError, if this function returns %FALSE (and sets @error) then @bytes_read will be set to the number of bytes that were successfully read before the error was encountered. This functionality is only available from C. If you need it from another language then you must write your own loop around g_input_stream_read_async(). %TRUE on success, %FALSE if there was an error a #GInputStream a #GAsyncResult location to store the number of bytes that was read from the stream Request an asynchronous read of @count bytes from the stream into the buffer starting at @buffer. When the operation is finished @callback will be called. You can then call g_input_stream_read_finish() to get the result of the operation. During an async request no other sync and async calls are allowed on @stream, and will result in %G_IO_ERROR_PENDING errors. A value of @count larger than %G_MAXSSIZE will cause a %G_IO_ERROR_INVALID_ARGUMENT error. On success, the number of bytes read into the buffer will be passed to the callback. It is not an error if this is not the same as the requested size, as it can happen e.g. near the end of a file, but generally we try to read as many bytes as requested. Zero is returned on end of file (or if @count is zero), but never otherwise. Any outstanding i/o request with higher priority (lower numerical value) will be executed before an outstanding request with lower priority. Default priority is %G_PRIORITY_DEFAULT. The asynchronous methods have a default fallback that uses threads to implement asynchronicity, so they are optional for inheriting classes. However, if you override one you must override all. A #GInputStream. a buffer to read data into (which should be at least count bytes long). the number of bytes that will be read from the stream the [I/O priority][io-priority] of the request. optional #GCancellable object, %NULL to ignore. callback to call when the request is satisfied the data to pass to callback function Like g_input_stream_read(), this tries to read @count bytes from the stream in a blocking fashion. However, rather than reading into a user-supplied buffer, this will create a new #GBytes containing the data that was read. This may be easier to use from language bindings. If count is zero, returns a zero-length #GBytes and does nothing. A value of @count larger than %G_MAXSSIZE will cause a %G_IO_ERROR_INVALID_ARGUMENT error. On success, a new #GBytes is returned. It is not an error if the size of this object is not the same as the requested size, as it can happen e.g. near the end of a file. A zero-length #GBytes is returned on end of file (or if @count is zero), but never otherwise. If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an operation was partially finished when the operation was cancelled the partial result will be returned, without an error. On error %NULL is returned and @error is set accordingly. a new #GBytes, or %NULL on error a #GInputStream. maximum number of bytes that will be read from the stream. Common values include 4096 and 8192. optional #GCancellable object, %NULL to ignore. Request an asynchronous read of @count bytes from the stream into a new #GBytes. When the operation is finished @callback will be called. You can then call g_input_stream_read_bytes_finish() to get the result of the operation. During an async request no other sync and async calls are allowed on @stream, and will result in %G_IO_ERROR_PENDING errors. A value of @count larger than %G_MAXSSIZE will cause a %G_IO_ERROR_INVALID_ARGUMENT error. On success, the new #GBytes will be passed to the callback. It is not an error if this is smaller than the requested size, as it can happen e.g. near the end of a file, but generally we try to read as many bytes as requested. Zero is returned on end of file (or if @count is zero), but never otherwise. Any outstanding I/O request with higher priority (lower numerical value) will be executed before an outstanding request with lower priority. Default priority is %G_PRIORITY_DEFAULT. A #GInputStream. the number of bytes that will be read from the stream the [I/O priority][io-priority] of the request optional #GCancellable object, %NULL to ignore. callback to call when the request is satisfied the data to pass to callback function Finishes an asynchronous stream read-into-#GBytes operation. the newly-allocated #GBytes, or %NULL on error a #GInputStream. a #GAsyncResult. Finishes an asynchronous stream read operation. number of bytes read in, or -1 on error, or 0 on end of file. a #GInputStream. a #GAsyncResult. Sets @stream to have actions pending. If the pending flag is already set or @stream is closed, it will return %FALSE and set @error. %TRUE if pending was previously unset and is now set. input stream Tries to skip @count bytes from the stream. Will block during the operation. This is identical to g_input_stream_read(), from a behaviour standpoint, but the bytes that are skipped are not returned to the user. Some streams have an implementation that is more efficient than reading the data. This function is optional for inherited classes, as the default implementation emulates it using read. If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an operation was partially finished when the operation was cancelled the partial result will be returned, without an error. Number of bytes skipped, or -1 on error a #GInputStream. the number of bytes that will be skipped from the stream optional #GCancellable object, %NULL to ignore. Request an asynchronous skip of @count bytes from the stream. When the operation is finished @callback will be called. You can then call g_input_stream_skip_finish() to get the result of the operation. During an async request no other sync and async calls are allowed, and will result in %G_IO_ERROR_PENDING errors. A value of @count larger than %G_MAXSSIZE will cause a %G_IO_ERROR_INVALID_ARGUMENT error. On success, the number of bytes skipped will be passed to the callback. It is not an error if this is not the same as the requested size, as it can happen e.g. near the end of a file, but generally we try to skip as many bytes as requested. Zero is returned on end of file (or if @count is zero), but never otherwise. Any outstanding i/o request with higher priority (lower numerical value) will be executed before an outstanding request with lower priority. Default priority is %G_PRIORITY_DEFAULT. The asynchronous methods have a default fallback that uses threads to implement asynchronicity, so they are optional for inheriting classes. However, if you override one, you must override all. A #GInputStream. the number of bytes that will be skipped from the stream the [I/O priority][io-priority] of the request optional #GCancellable object, %NULL to ignore. callback to call when the request is satisfied the data to pass to callback function Finishes a stream skip operation. the size of the bytes skipped, or `-1` on error. a #GInputStream. a #GAsyncResult. Number of bytes skipped, or -1 on error a #GInputStream. the number of bytes that will be skipped from the stream optional #GCancellable object, %NULL to ignore. A #GInputStream. a buffer to read data into (which should be at least count bytes long). the number of bytes that will be read from the stream the [I/O priority][io-priority] of the request. optional #GCancellable object, %NULL to ignore. callback to call when the request is satisfied the data to pass to callback function number of bytes read in, or -1 on error, or 0 on end of file. a #GInputStream. a #GAsyncResult. A #GInputStream. the number of bytes that will be skipped from the stream the [I/O priority][io-priority] of the request optional #GCancellable object, %NULL to ignore. callback to call when the request is satisfied the data to pass to callback function the size of the bytes skipped, or `-1` on error. a #GInputStream. a #GAsyncResult. A #GInputStream. the [I/O priority][io-priority] of the request optional cancellable object callback to call when the request is satisfied the data to pass to callback function %TRUE if the stream was closed successfully. a #GInputStream. a #GAsyncResult. Structure used for scatter/gather data input. You generally pass in an array of #GInputVectors and the operation will store the read data starting in the first buffer, switching to the next as needed. Pointer to a buffer where data will be written. the available size in @buffer. #GListModel is an interface that represents a mutable list of #GObjects. Its main intention is as a model for various widgets in user interfaces, such as list views, but it can also be used as a convenient method of returning lists of data, with support for updates. Each object in the list may also report changes in itself via some mechanism (normally the #GObject::notify signal). Taken together with the #GListModel::items-changed signal, this provides for a list that can change its membership, and in which the members can change their individual properties. A good example would be the list of visible wireless network access points, where each access point can report dynamic properties such as signal strength. It is important to note that the #GListModel itself does not report changes to the individual items. It only reports changes to the list membership. If you want to observe changes to the objects themselves then you need to connect signals to the objects that you are interested in. All items in a #GListModel are of (or derived from) the same type. g_list_model_get_item_type() returns that type. The type may be an interface, in which case all objects in the list must implement it. The semantics are close to that of an array: g_list_model_get_n_items() returns the number of items in the list and g_list_model_get_item() returns an item at a (0-based) position. In order to allow implementations to calculate the list length lazily, you can also iterate over items: starting from 0, repeatedly call g_list_model_get_item() until it returns %NULL. An implementation may create objects lazily, but must take care to return the same object for a given position until all references to it are gone. On the other side, a consumer is expected only to hold references on objects that are currently "user visible", in order to facilitate the maximum level of laziness in the implementation of the list and to reduce the required number of signal connections at a given time. This interface is intended only to be used from a single thread. The thread in which it is appropriate to use it depends on the particular implementation, but typically it will be from the thread that owns the [thread-default main context][g-main-context-push-thread-default] in effect at the time that the model was created. Get the item at @position. If @position is greater than the number of items in @list, %NULL is returned. %NULL is never returned for an index that is smaller than the length of the list. See g_list_model_get_n_items(). the object at @position. a #GListModel the position of the item to fetch Gets the type of the items in @list. All items returned from g_list_model_get_type() are of that type or a subtype, or are an implementation of that interface. The item type of a #GListModel can not change during the life of the model. the #GType of the items contained in @list. a #GListModel Gets the number of items in @list. Depending on the model implementation, calling this function may be less efficient than iterating the list with increasing values for @position until g_list_model_get_item() returns %NULL. the number of items in @list. a #GListModel Get the item at @position. If @position is greater than the number of items in @list, %NULL is returned. %NULL is never returned for an index that is smaller than the length of the list. See g_list_model_get_n_items(). the item at @position. a #GListModel the position of the item to fetch Gets the type of the items in @list. All items returned from g_list_model_get_type() are of that type or a subtype, or are an implementation of that interface. The item type of a #GListModel can not change during the life of the model. the #GType of the items contained in @list. a #GListModel Gets the number of items in @list. Depending on the model implementation, calling this function may be less efficient than iterating the list with increasing values for @position until g_list_model_get_item() returns %NULL. the number of items in @list. a #GListModel Get the item at @position. If @position is greater than the number of items in @list, %NULL is returned. %NULL is never returned for an index that is smaller than the length of the list. See g_list_model_get_n_items(). the object at @position. a #GListModel the position of the item to fetch Emits the #GListModel::items-changed signal on @list. This function should only be called by classes implementing #GListModel. It has to be called after the internal representation of @list has been updated, because handlers connected to this signal might query the new state of the list. Implementations must only make changes to the model (as visible to its consumer) in places that will not cause problems for that consumer. For models that are driven directly by a write API (such as #GListStore), changes can be reported in response to uses of that API. For models that represent remote data, changes should only be made from a fresh mainloop dispatch. It is particularly not permitted to make changes in response to a call to the #GListModel consumer API. Stated another way: in general, it is assumed that code making a series of accesses to the model via the API, without returning to the mainloop, and without calling other code, will continue to view the same contents of the model. a #GListModel the position at which @list changed the number of items removed the number of items added This signal is emitted whenever items were added to or removed from @list. At @position, @removed items were removed and @added items were added in their place. Note: If @removed != @added, the positions of all later items in the model change. the position at which @list changed the number of items removed the number of items added The virtual function table for #GListModel. parent #GTypeInterface the #GType of the items contained in @list. a #GListModel the number of items in @list. a #GListModel the object at @position. a #GListModel the position of the item to fetch #GListStore is a simple implementation of #GListModel that stores all items in memory. It provides insertions, deletions, and lookups in logarithmic time with a fast path for the common case of iterating the list linearly. Creates a new #GListStore with items of type @item_type. @item_type must be a subclass of #GObject. a new #GListStore the #GType of items in the list Appends @item to @store. @item must be of type #GListStore:item-type. This function takes a ref on @item. Use g_list_store_splice() to append multiple items at the same time efficiently. a #GListStore the new item Looks up the given @item in the list store by looping over the items until the first occurrence of @item. If @item was not found, then @position will not be set, and this method will return %FALSE. If you need to compare the two items with a custom comparison function, use g_list_store_find_with_equal_func() with a custom #GEqualFunc instead. Whether @store contains @item. If it was found, @position will be set to the position where @item occurred for the first time. a #GListStore an item the first position of @item, if it was found. Looks up the given @item in the list store by looping over the items and comparing them with @compare_func until the first occurrence of @item which matches. If @item was not found, then @position will not be set, and this method will return %FALSE. Whether @store contains @item. If it was found, @position will be set to the position where @item occurred for the first time. a #GListStore an item A custom equality check function the first position of @item, if it was found. Inserts @item into @store at @position. @item must be of type #GListStore:item-type or derived from it. @position must be smaller than the length of the list, or equal to it to append. This function takes a ref on @item. Use g_list_store_splice() to insert multiple items at the same time efficiently. a #GListStore the position at which to insert the new item the new item Inserts @item into @store at a position to be determined by the @compare_func. The list must already be sorted before calling this function or the result is undefined. Usually you would approach this by only ever inserting items by way of this function. This function takes a ref on @item. the position at which @item was inserted a #GListStore the new item pairwise comparison function for sorting user data for @compare_func Removes the item from @store that is at @position. @position must be smaller than the current length of the list. Use g_list_store_splice() to remove multiple items at the same time efficiently. a #GListStore the position of the item that is to be removed Removes all items from @store. a #GListStore Sort the items in @store according to @compare_func. a #GListStore pairwise comparison function for sorting user data for @compare_func Changes @store by removing @n_removals items and adding @n_additions items to it. @additions must contain @n_additions items of type #GListStore:item-type. %NULL is not permitted. This function is more efficient than g_list_store_insert() and g_list_store_remove(), because it only emits #GListModel::items-changed once for the change. This function takes a ref on each item in @additions. The parameters @position and @n_removals must be correct (ie: @position + @n_removals must be less than or equal to the length of the list at the time this function is called). a #GListStore the position at which to make the change the number of items to remove the items to add the number of items to add The type of items contained in this list store. Items must be subclasses of #GObject. Extends the #GIcon interface and adds the ability to load icons from streams. Loads a loadable icon. For the asynchronous version of this function, see g_loadable_icon_load_async(). a #GInputStream to read the icon from. a #GLoadableIcon. an integer. a location to store the type of the loaded icon, %NULL to ignore. optional #GCancellable object, %NULL to ignore. Loads an icon asynchronously. To finish this function, see g_loadable_icon_load_finish(). For the synchronous, blocking version of this function, see g_loadable_icon_load(). a #GLoadableIcon. an integer. optional #GCancellable object, %NULL to ignore. a #GAsyncReadyCallback to call when the request is satisfied the data to pass to callback function Finishes an asynchronous icon load started in g_loadable_icon_load_async(). a #GInputStream to read the icon from. a #GLoadableIcon. a #GAsyncResult. a location to store the type of the loaded icon, %NULL to ignore. Loads a loadable icon. For the asynchronous version of this function, see g_loadable_icon_load_async(). a #GInputStream to read the icon from. a #GLoadableIcon. an integer. a location to store the type of the loaded icon, %NULL to ignore. optional #GCancellable object, %NULL to ignore. Loads an icon asynchronously. To finish this function, see g_loadable_icon_load_finish(). For the synchronous, blocking version of this function, see g_loadable_icon_load(). a #GLoadableIcon. an integer. optional #GCancellable object, %NULL to ignore. a #GAsyncReadyCallback to call when the request is satisfied the data to pass to callback function Finishes an asynchronous icon load started in g_loadable_icon_load_async(). a #GInputStream to read the icon from. a #GLoadableIcon. a #GAsyncResult. a location to store the type of the loaded icon, %NULL to ignore. Interface for icons that can be loaded as a stream. The parent interface. a #GInputStream to read the icon from. a #GLoadableIcon. an integer. a location to store the type of the loaded icon, %NULL to ignore. optional #GCancellable object, %NULL to ignore. a #GLoadableIcon. an integer. optional #GCancellable object, %NULL to ignore. a #GAsyncReadyCallback to call when the request is satisfied the data to pass to callback function a #GInputStream to read the icon from. a #GLoadableIcon. a #GAsyncResult. a location to store the type of the loaded icon, %NULL to ignore. Extension point for memory usage monitoring functionality. See [Extending GIO][extending-gio]. The menu item attribute which holds the action name of the item. Action names are namespaced with an identifier for the action group in which the action resides. For example, "win." for window-specific actions and "app." for application-wide actions. See also g_menu_model_get_item_attribute() and g_menu_item_set_attribute(). The menu item attribute that holds the namespace for all action names in menus that are linked from this item. The menu item attribute which holds the icon of the item. The icon is stored in the format returned by g_icon_serialize(). This attribute is intended only to represent 'noun' icons such as favicons for a webpage, or application icons. It should not be used for 'verbs' (ie: stock icons). The menu item attribute which holds the label of the item. The menu item attribute which holds the target with which the item's action will be activated. See also g_menu_item_set_action_and_target() The name of the link that associates a menu item with a section. The linked menu will usually be shown in place of the menu item, using the item's label as a header. See also g_menu_item_set_link(). The name of the link that associates a menu item with a submenu. See also g_menu_item_set_link(). #GMemoryInputStream is a class for using arbitrary memory chunks as input for GIO streaming input operations. As of GLib 2.34, #GMemoryInputStream implements #GPollableInputStream. Creates a new empty #GMemoryInputStream. a new #GInputStream Creates a new #GMemoryInputStream with data from the given @bytes. new #GInputStream read from @bytes a #GBytes Creates a new #GMemoryInputStream with data in memory of a given size. new #GInputStream read from @data of @len bytes. input data length of the data, may be -1 if @data is a nul-terminated string function that is called to free @data, or %NULL Appends @bytes to data that can be read from the input stream. a #GMemoryInputStream input data Appends @data to data that can be read from the input stream a #GMemoryInputStream input data length of the data, may be -1 if @data is a nul-terminated string function that is called to free @data, or %NULL #GMemoryMonitor will monitor system memory and suggest to the application when to free memory so as to leave more room for other applications. It is implemented on Linux using the [Low Memory Monitor](https://gitlab.freedesktop.org/hadess/low-memory-monitor/) ([API documentation](https://hadess.pages.freedesktop.org/low-memory-monitor/)). There is also an implementation for use inside Flatpak sandboxes. Possible actions to take when the signal is received are: - Free caches - Save files that haven't been looked at in a while to disk, ready to be reopened when needed - Run a garbage collection cycle - Try and compress fragmented allocations - Exit on idle if the process has no reason to stay around - Call [`malloc_trim(3)`](man:malloc_trim) to return cached heap pages to the kernel (if supported by your libc) Note that some actions may not always improve system performance, and so should be profiled for your application. `malloc_trim()`, for example, may make future heap allocations slower (due to releasing cached heap pages back to the kernel). See #GMemoryMonitorWarningLevel for details on the various warning levels. |[<!-- language="C" --> static void warning_cb (GMemoryMonitor *m, GMemoryMonitorWarningLevel level) { g_debug ("Warning level: %d", level); if (warning_level > G_MEMORY_MONITOR_WARNING_LEVEL_LOW) drop_caches (); } static GMemoryMonitor * monitor_low_memory (void) { GMemoryMonitor *m; m = g_memory_monitor_dup_default (); g_signal_connect (G_OBJECT (m), "low-memory-warning", G_CALLBACK (warning_cb), NULL); return m; } ]| Don't forget to disconnect the #GMemoryMonitor::low-memory-warning signal, and unref the #GMemoryMonitor itself when exiting. Gets a reference to the default #GMemoryMonitor for the system. a new reference to the default #GMemoryMonitor Emitted when the system is running low on free memory. The signal handler should then take the appropriate action depending on the warning level. See the #GMemoryMonitorWarningLevel documentation for details. the #GMemoryMonitorWarningLevel warning level The virtual function table for #GMemoryMonitor. The parent interface. Memory availability warning levels. Note that because new values might be added, it is recommended that applications check #GMemoryMonitorWarningLevel as ranges, for example: |[<!-- language="C" --> if (warning_level > G_MEMORY_MONITOR_WARNING_LEVEL_LOW) drop_caches (); ]| Memory on the device is low, processes should free up unneeded resources (for example, in-memory caches) so they can be used elsewhere. Same as @G_MEMORY_MONITOR_WARNING_LEVEL_LOW but the device has even less free memory, so processes should try harder to free up unneeded resources. If your process does not need to stay running, it is a good time for it to quit. The system will soon start terminating processes to reclaim memory, including background processes. #GMemoryOutputStream is a class for using arbitrary memory chunks as output for GIO streaming output operations. As of GLib 2.34, #GMemoryOutputStream trivially implements #GPollableOutputStream: it always polls as ready. Creates a new #GMemoryOutputStream. In most cases this is not the function you want. See g_memory_output_stream_new_resizable() instead. If @data is non-%NULL, the stream will use that for its internal storage. If @realloc_fn is non-%NULL, it will be used for resizing the internal storage when necessary and the stream will be considered resizable. In that case, the stream will start out being (conceptually) empty. @size is used only as a hint for how big @data is. Specifically, seeking to the end of a newly-created stream will seek to zero, not @size. Seeking past the end of the stream and then writing will introduce a zero-filled gap. If @realloc_fn is %NULL then the stream is fixed-sized. Seeking to the end will seek to @size exactly. Writing past the end will give an 'out of space' error. Attempting to seek past the end will fail. Unlike the resizable case, seeking to an offset within the stream and writing will preserve the bytes passed in as @data before that point and will return them as part of g_memory_output_stream_steal_data(). If you intend to seek you should probably therefore ensure that @data is properly initialised. It is probably only meaningful to provide @data and @size in the case that you want a fixed-sized stream. Put another way: if @realloc_fn is non-%NULL then it makes most sense to give @data as %NULL and @size as 0 (allowing #GMemoryOutputStream to do the initial allocation for itself). |[<!-- language="C" --> // a stream that can grow stream = g_memory_output_stream_new (NULL, 0, realloc, free); // another stream that can grow stream2 = g_memory_output_stream_new (NULL, 0, g_realloc, g_free); // a fixed-size stream data = malloc (200); stream3 = g_memory_output_stream_new (data, 200, NULL, free); ]| A newly created #GMemoryOutputStream object. pointer to a chunk of memory to use, or %NULL the size of @data a function with realloc() semantics (like g_realloc()) to be called when @data needs to be grown, or %NULL a function to be called on @data when the stream is finalized, or %NULL Creates a new #GMemoryOutputStream, using g_realloc() and g_free() for memory allocation. Gets any loaded data from the @ostream. Note that the returned pointer may become invalid on the next write or truncate operation on the stream. pointer to the stream's data, or %NULL if the data has been stolen a #GMemoryOutputStream Returns the number of bytes from the start up to including the last byte written in the stream that has not been truncated away. the number of bytes written to the stream a #GMemoryOutputStream Gets the size of the currently allocated data area (available from g_memory_output_stream_get_data()). You probably don't want to use this function on resizable streams. See g_memory_output_stream_get_data_size() instead. For resizable streams the size returned by this function is an implementation detail and may be change at any time in response to operations on the stream. If the stream is fixed-sized (ie: no realloc was passed to g_memory_output_stream_new()) then this is the maximum size of the stream and further writes will return %G_IO_ERROR_NO_SPACE. In any case, if you want the number of bytes currently written to the stream, use g_memory_output_stream_get_data_size(). the number of bytes allocated for the data buffer a #GMemoryOutputStream Returns data from the @ostream as a #GBytes. @ostream must be closed before calling this function. the stream's data a #GMemoryOutputStream Gets any loaded data from the @ostream. Ownership of the data is transferred to the caller; when no longer needed it must be freed using the free function set in @ostream's #GMemoryOutputStream:destroy-function property. @ostream must be closed before calling this function. the stream's data, or %NULL if it has previously been stolen a #GMemoryOutputStream Pointer to buffer where data will be written. Size of data written to the buffer. Function called with the buffer as argument when the stream is destroyed. Function with realloc semantics called to enlarge the buffer. Current size of the data buffer. #GMenu is a simple implementation of #GMenuModel. You populate a #GMenu by adding #GMenuItem instances to it. There are some convenience functions to allow you to directly add items (avoiding #GMenuItem) for the common cases. To add a regular item, use g_menu_insert(). To add a section, use g_menu_insert_section(). To add a submenu, use g_menu_insert_submenu(). Creates a new #GMenu. The new menu has no items. a new #GMenu Convenience function for appending a normal menu item to the end of @menu. Combine g_menu_item_new() and g_menu_insert_item() for a more flexible alternative. a #GMenu the section label, or %NULL the detailed action string, or %NULL Appends @item to the end of @menu. See g_menu_insert_item() for more information. a #GMenu a #GMenuItem to append Convenience function for appending a section menu item to the end of @menu. Combine g_menu_item_new_section() and g_menu_insert_item() for a more flexible alternative. a #GMenu the section label, or %NULL a #GMenuModel with the items of the section Convenience function for appending a submenu menu item to the end of @menu. Combine g_menu_item_new_submenu() and g_menu_insert_item() for a more flexible alternative. a #GMenu the section label, or %NULL a #GMenuModel with the items of the submenu Marks @menu as frozen. After the menu is frozen, it is an error to attempt to make any changes to it. In effect this means that the #GMenu API must no longer be used. This function causes g_menu_model_is_mutable() to begin returning %FALSE, which has some positive performance implications. a #GMenu Convenience function for inserting a normal menu item into @menu. Combine g_menu_item_new() and g_menu_insert_item() for a more flexible alternative. a #GMenu the position at which to insert the item the section label, or %NULL the detailed action string, or %NULL Inserts @item into @menu. The "insertion" is actually done by copying all of the attribute and link values of @item and using them to form a new item within @menu. As such, @item itself is not really inserted, but rather, a menu item that is exactly the same as the one presently described by @item. This means that @item is essentially useless after the insertion occurs. Any changes you make to it are ignored unless it is inserted again (at which point its updated values will be copied). You should probably just free @item once you're done. There are many convenience functions to take care of common cases. See g_menu_insert(), g_menu_insert_section() and g_menu_insert_submenu() as well as "prepend" and "append" variants of each of these functions. a #GMenu the position at which to insert the item the #GMenuItem to insert Convenience function for inserting a section menu item into @menu. Combine g_menu_item_new_section() and g_menu_insert_item() for a more flexible alternative. a #GMenu the position at which to insert the item the section label, or %NULL a #GMenuModel with the items of the section Convenience function for inserting a submenu menu item into @menu. Combine g_menu_item_new_submenu() and g_menu_insert_item() for a more flexible alternative. a #GMenu the position at which to insert the item the section label, or %NULL a #GMenuModel with the items of the submenu Convenience function for prepending a normal menu item to the start of @menu. Combine g_menu_item_new() and g_menu_insert_item() for a more flexible alternative. a #GMenu the section label, or %NULL the detailed action string, or %NULL Prepends @item to the start of @menu. See g_menu_insert_item() for more information. a #GMenu a #GMenuItem to prepend Convenience function for prepending a section menu item to the start of @menu. Combine g_menu_item_new_section() and g_menu_insert_item() for a more flexible alternative. a #GMenu the section label, or %NULL a #GMenuModel with the items of the section Convenience function for prepending a submenu menu item to the start of @menu. Combine g_menu_item_new_submenu() and g_menu_insert_item() for a more flexible alternative. a #GMenu the section label, or %NULL a #GMenuModel with the items of the submenu Removes an item from the menu. @position gives the index of the item to remove. It is an error if position is not in range the range from 0 to one less than the number of items in the menu. It is not possible to remove items by identity since items are added to the menu simply by copying their links and attributes (ie: identity of the item itself is not preserved). a #GMenu the position of the item to remove Removes all items in the menu. a #GMenu #GMenuAttributeIter is an opaque structure type. You must access it using the functions below. This function combines g_menu_attribute_iter_next() with g_menu_attribute_iter_get_name() and g_menu_attribute_iter_get_value(). First the iterator is advanced to the next (possibly first) attribute. If that fails, then %FALSE is returned and there are no other effects. If successful, @name and @value are set to the name and value of the attribute that has just been advanced to. At this point, g_menu_attribute_iter_get_name() and g_menu_attribute_iter_get_value() will return the same values again. The value returned in @name remains valid for as long as the iterator remains at the current position. The value returned in @value must be unreffed using g_variant_unref() when it is no longer in use. %TRUE on success, or %FALSE if there is no additional attribute a #GMenuAttributeIter the type of the attribute the attribute value Gets the name of the attribute at the current iterator position, as a string. The iterator is not advanced. the name of the attribute a #GMenuAttributeIter This function combines g_menu_attribute_iter_next() with g_menu_attribute_iter_get_name() and g_menu_attribute_iter_get_value(). First the iterator is advanced to the next (possibly first) attribute. If that fails, then %FALSE is returned and there are no other effects. If successful, @name and @value are set to the name and value of the attribute that has just been advanced to. At this point, g_menu_attribute_iter_get_name() and g_menu_attribute_iter_get_value() will return the same values again. The value returned in @name remains valid for as long as the iterator remains at the current position. The value returned in @value must be unreffed using g_variant_unref() when it is no longer in use. %TRUE on success, or %FALSE if there is no additional attribute a #GMenuAttributeIter the type of the attribute the attribute value Gets the value of the attribute at the current iterator position. The iterator is not advanced. the value of the current attribute a #GMenuAttributeIter Attempts to advance the iterator to the next (possibly first) attribute. %TRUE is returned on success, or %FALSE if there are no more attributes. You must call this function when you first acquire the iterator to advance it to the first attribute (and determine if the first attribute exists at all). %TRUE on success, or %FALSE when there are no more attributes a #GMenuAttributeIter %TRUE on success, or %FALSE if there is no additional attribute a #GMenuAttributeIter the type of the attribute the attribute value #GMenuItem is an opaque structure type. You must access it using the functions below. Creates a new #GMenuItem. If @label is non-%NULL it is used to set the "label" attribute of the new item. If @detailed_action is non-%NULL it is used to set the "action" and possibly the "target" attribute of the new item. See g_menu_item_set_detailed_action() for more information. a new #GMenuItem the section label, or %NULL the detailed action string, or %NULL Creates a #GMenuItem as an exact copy of an existing menu item in a #GMenuModel. @item_index must be valid (ie: be sure to call g_menu_model_get_n_items() first). a new #GMenuItem. a #GMenuModel the index of an item in @model Creates a new #GMenuItem representing a section. This is a convenience API around g_menu_item_new() and g_menu_item_set_section(). The effect of having one menu appear as a section of another is exactly as it sounds: the items from @section become a direct part of the menu that @menu_item is added to. Visual separation is typically displayed between two non-empty sections. If @label is non-%NULL then it will be encorporated into this visual indication. This allows for labeled subsections of a menu. As a simple example, consider a typical "Edit" menu from a simple program. It probably contains an "Undo" and "Redo" item, followed by a separator, followed by "Cut", "Copy" and "Paste". This would be accomplished by creating three #GMenu instances. The first would be populated with the "Undo" and "Redo" items, and the second with the "Cut", "Copy" and "Paste" items. The first and second menus would then be added as submenus of the third. In XML format, this would look something like the following: |[ <menu id='edit-menu'> <section> <item label='Undo'/> <item label='Redo'/> </section> <section> <item label='Cut'/> <item label='Copy'/> <item label='Paste'/> </section> </menu> ]| The following example is exactly equivalent. It is more illustrative of the exact relationship between the menus and items (keeping in mind that the 'link' element defines a new menu that is linked to the containing one). The style of the second example is more verbose and difficult to read (and therefore not recommended except for the purpose of understanding what is really going on). |[ <menu id='edit-menu'> <item> <link name='section'> <item label='Undo'/> <item label='Redo'/> </link> </item> <item> <link name='section'> <item label='Cut'/> <item label='Copy'/> <item label='Paste'/> </link> </item> </menu> ]| a new #GMenuItem the section label, or %NULL a #GMenuModel with the items of the section Creates a new #GMenuItem representing a submenu. This is a convenience API around g_menu_item_new() and g_menu_item_set_submenu(). a new #GMenuItem the section label, or %NULL a #GMenuModel with the items of the submenu Queries the named @attribute on @menu_item. If the attribute exists and matches the #GVariantType corresponding to @format_string then @format_string is used to deconstruct the value into the positional parameters and %TRUE is returned. If the attribute does not exist, or it does exist but has the wrong type, then the positional parameters are ignored and %FALSE is returned. %TRUE if the named attribute was found with the expected type a #GMenuItem the attribute name to query a #GVariant format string positional parameters, as per @format_string Queries the named @attribute on @menu_item. If @expected_type is specified and the attribute does not have this type, %NULL is returned. %NULL is also returned if the attribute simply does not exist. the attribute value, or %NULL a #GMenuItem the attribute name to query the expected type of the attribute Queries the named @link on @menu_item. the link, or %NULL a #GMenuItem the link name to query Sets or unsets the "action" and "target" attributes of @menu_item. If @action is %NULL then both the "action" and "target" attributes are unset (and @format_string is ignored along with the positional parameters). If @action is non-%NULL then the "action" attribute is set. @format_string is then inspected. If it is non-%NULL then the proper position parameters are collected to create a #GVariant instance to use as the target value. If it is %NULL then the positional parameters are ignored and the "target" attribute is unset. See also g_menu_item_set_action_and_target_value() for an equivalent call that directly accepts a #GVariant. See g_menu_item_set_detailed_action() for a more convenient version that works with string-typed targets. See also g_menu_item_set_action_and_target_value() for a description of the semantics of the action and target attributes. a #GMenuItem the name of the action for this item a GVariant format string positional parameters, as per @format_string Sets or unsets the "action" and "target" attributes of @menu_item. If @action is %NULL then both the "action" and "target" attributes are unset (and @target_value is ignored). If @action is non-%NULL then the "action" attribute is set. The "target" attribute is then set to the value of @target_value if it is non-%NULL or unset otherwise. Normal menu items (ie: not submenu, section or other custom item types) are expected to have the "action" attribute set to identify the action that they are associated with. The state type of the action help to determine the disposition of the menu item. See #GAction and #GActionGroup for an overview of actions. In general, clicking on the menu item will result in activation of the named action with the "target" attribute given as the parameter to the action invocation. If the "target" attribute is not set then the action is invoked with no parameter. If the action has no state then the menu item is usually drawn as a plain menu item (ie: with no additional decoration). If the action has a boolean state then the menu item is usually drawn as a toggle menu item (ie: with a checkmark or equivalent indication). The item should be marked as 'toggled' or 'checked' when the boolean state is %TRUE. If the action has a string state then the menu item is usually drawn as a radio menu item (ie: with a radio bullet or equivalent indication). The item should be marked as 'selected' when the string state is equal to the value of the @target property. See g_menu_item_set_action_and_target() or g_menu_item_set_detailed_action() for two equivalent calls that are probably more convenient for most uses. a #GMenuItem the name of the action for this item a #GVariant to use as the action target Sets or unsets an attribute on @menu_item. The attribute to set or unset is specified by @attribute. This can be one of the standard attribute names %G_MENU_ATTRIBUTE_LABEL, %G_MENU_ATTRIBUTE_ACTION, %G_MENU_ATTRIBUTE_TARGET, or a custom attribute name. Attribute names are restricted to lowercase characters, numbers and '-'. Furthermore, the names must begin with a lowercase character, must not end with a '-', and must not contain consecutive dashes. If @format_string is non-%NULL then the proper position parameters are collected to create a #GVariant instance to use as the attribute value. If it is %NULL then the positional parameterrs are ignored and the named attribute is unset. See also g_menu_item_set_attribute_value() for an equivalent call that directly accepts a #GVariant. a #GMenuItem the attribute to set a #GVariant format string, or %NULL positional parameters, as per @format_string Sets or unsets an attribute on @menu_item. The attribute to set or unset is specified by @attribute. This can be one of the standard attribute names %G_MENU_ATTRIBUTE_LABEL, %G_MENU_ATTRIBUTE_ACTION, %G_MENU_ATTRIBUTE_TARGET, or a custom attribute name. Attribute names are restricted to lowercase characters, numbers and '-'. Furthermore, the names must begin with a lowercase character, must not end with a '-', and must not contain consecutive dashes. must consist only of lowercase ASCII characters, digits and '-'. If @value is non-%NULL then it is used as the new value for the attribute. If @value is %NULL then the attribute is unset. If the @value #GVariant is floating, it is consumed. See also g_menu_item_set_attribute() for a more convenient way to do the same. a #GMenuItem the attribute to set a #GVariant to use as the value, or %NULL Sets the "action" and possibly the "target" attribute of @menu_item. The format of @detailed_action is the same format parsed by g_action_parse_detailed_name(). See g_menu_item_set_action_and_target() or g_menu_item_set_action_and_target_value() for more flexible (but slightly less convenient) alternatives. See also g_menu_item_set_action_and_target_value() for a description of the semantics of the action and target attributes. a #GMenuItem the "detailed" action string Sets (or unsets) the icon on @menu_item. This call is the same as calling g_icon_serialize() and using the result as the value to g_menu_item_set_attribute_value() for %G_MENU_ATTRIBUTE_ICON. This API is only intended for use with "noun" menu items; things like bookmarks or applications in an "Open With" menu. Don't use it on menu items corresponding to verbs (eg: stock icons for 'Save' or 'Quit'). If @icon is %NULL then the icon is unset. a #GMenuItem a #GIcon, or %NULL Sets or unsets the "label" attribute of @menu_item. If @label is non-%NULL it is used as the label for the menu item. If it is %NULL then the label attribute is unset. a #GMenuItem the label to set, or %NULL to unset Creates a link from @menu_item to @model if non-%NULL, or unsets it. Links are used to establish a relationship between a particular menu item and another menu. For example, %G_MENU_LINK_SUBMENU is used to associate a submenu with a particular menu item, and %G_MENU_LINK_SECTION is used to create a section. Other types of link can be used, but there is no guarantee that clients will be able to make sense of them. Link types are restricted to lowercase characters, numbers and '-'. Furthermore, the names must begin with a lowercase character, must not end with a '-', and must not contain consecutive dashes. a #GMenuItem type of link to establish or unset the #GMenuModel to link to (or %NULL to unset) Sets or unsets the "section" link of @menu_item to @section. The effect of having one menu appear as a section of another is exactly as it sounds: the items from @section become a direct part of the menu that @menu_item is added to. See g_menu_item_new_section() for more information about what it means for a menu item to be a section. a #GMenuItem a #GMenuModel, or %NULL Sets or unsets the "submenu" link of @menu_item to @submenu. If @submenu is non-%NULL, it is linked to. If it is %NULL then the link is unset. The effect of having one menu appear as a submenu of another is exactly as it sounds. a #GMenuItem a #GMenuModel, or %NULL #GMenuLinkIter is an opaque structure type. You must access it using the functions below. This function combines g_menu_link_iter_next() with g_menu_link_iter_get_name() and g_menu_link_iter_get_value(). First the iterator is advanced to the next (possibly first) link. If that fails, then %FALSE is returned and there are no other effects. If successful, @out_link and @value are set to the name and #GMenuModel of the link that has just been advanced to. At this point, g_menu_link_iter_get_name() and g_menu_link_iter_get_value() will return the same values again. The value returned in @out_link remains valid for as long as the iterator remains at the current position. The value returned in @value must be unreffed using g_object_unref() when it is no longer in use. %TRUE on success, or %FALSE if there is no additional link a #GMenuLinkIter the name of the link the linked #GMenuModel Gets the name of the link at the current iterator position. The iterator is not advanced. the type of the link a #GMenuLinkIter This function combines g_menu_link_iter_next() with g_menu_link_iter_get_name() and g_menu_link_iter_get_value(). First the iterator is advanced to the next (possibly first) link. If that fails, then %FALSE is returned and there are no other effects. If successful, @out_link and @value are set to the name and #GMenuModel of the link that has just been advanced to. At this point, g_menu_link_iter_get_name() and g_menu_link_iter_get_value() will return the same values again. The value returned in @out_link remains valid for as long as the iterator remains at the current position. The value returned in @value must be unreffed using g_object_unref() when it is no longer in use. %TRUE on success, or %FALSE if there is no additional link a #GMenuLinkIter the name of the link the linked #GMenuModel Gets the linked #GMenuModel at the current iterator position. The iterator is not advanced. the #GMenuModel that is linked to a #GMenuLinkIter Attempts to advance the iterator to the next (possibly first) link. %TRUE is returned on success, or %FALSE if there are no more links. You must call this function when you first acquire the iterator to advance it to the first link (and determine if the first link exists at all). %TRUE on success, or %FALSE when there are no more links a #GMenuLinkIter %TRUE on success, or %FALSE if there is no additional link a #GMenuLinkIter the name of the link the linked #GMenuModel #GMenuModel represents the contents of a menu -- an ordered list of menu items. The items are associated with actions, which can be activated through them. Items can be grouped in sections, and may have submenus associated with them. Both items and sections usually have some representation data, such as labels or icons. The type of the associated action (ie whether it is stateful, and what kind of state it has) can influence the representation of the item. The conceptual model of menus in #GMenuModel is hierarchical: sections and submenus are again represented by #GMenuModels. Menus themselves do not define their own roles. Rather, the role of a particular #GMenuModel is defined by the item that references it (or, in the case of the 'root' menu, is defined by the context in which it is used). As an example, consider the visible portions of this menu: ## An example menu # {#menu-example} ![](menu-example.png) There are 8 "menus" visible in the screenshot: one menubar, two submenus and 5 sections: - the toplevel menubar (containing 4 items) - the View submenu (containing 3 sections) - the first section of the View submenu (containing 2 items) - the second section of the View submenu (containing 1 item) - the final section of the View submenu (containing 1 item) - the Highlight Mode submenu (containing 2 sections) - the Sources section (containing 2 items) - the Markup section (containing 2 items) The [example][menu-model] illustrates the conceptual connection between these 8 menus. Each large block in the figure represents a menu and the smaller blocks within the large block represent items in that menu. Some items contain references to other menus. ## A menu example # {#menu-model} ![](menu-model.png) Notice that the separators visible in the [example][menu-example] appear nowhere in the [menu model][menu-model]. This is because separators are not explicitly represented in the menu model. Instead, a separator is inserted between any two non-empty sections of a menu. Section items can have labels just like any other item. In that case, a display system may show a section header instead of a separator. The motivation for this abstract model of application controls is that modern user interfaces tend to make these controls available outside the application. Examples include global menus, jumplists, dash boards, etc. To support such uses, it is necessary to 'export' information about actions and their representation in menus, which is exactly what the [GActionGroup exporter][gio-GActionGroup-exporter] and the [GMenuModel exporter][gio-GMenuModel-exporter] do for #GActionGroup and #GMenuModel. The client-side counterparts to make use of the exported information are #GDBusActionGroup and #GDBusMenuModel. The API of #GMenuModel is very generic, with iterators for the attributes and links of an item, see g_menu_model_iterate_item_attributes() and g_menu_model_iterate_item_links(). The 'standard' attributes and link types have predefined names: %G_MENU_ATTRIBUTE_LABEL, %G_MENU_ATTRIBUTE_ACTION, %G_MENU_ATTRIBUTE_TARGET, %G_MENU_LINK_SECTION and %G_MENU_LINK_SUBMENU. Items in a #GMenuModel represent active controls if they refer to an action that can get activated when the user interacts with the menu item. The reference to the action is encoded by the string id in the %G_MENU_ATTRIBUTE_ACTION attribute. An action id uniquely identifies an action in an action group. Which action group(s) provide actions depends on the context in which the menu model is used. E.g. when the model is exported as the application menu of a #GtkApplication, actions can be application-wide or window-specific (and thus come from two different action groups). By convention, the application-wide actions have names that start with "app.", while the names of window-specific actions start with "win.". While a wide variety of stateful actions is possible, the following is the minimum that is expected to be supported by all users of exported menu information: - an action with no parameter type and no state - an action with no parameter type and boolean state - an action with string parameter type and string state ## Stateless A stateless action typically corresponds to an ordinary menu item. Selecting such a menu item will activate the action (with no parameter). ## Boolean State An action with a boolean state will most typically be used with a "toggle" or "switch" menu item. The state can be set directly, but activating the action (with no parameter) results in the state being toggled. Selecting a toggle menu item will activate the action. The menu item should be rendered as "checked" when the state is true. ## String Parameter and State Actions with string parameters and state will most typically be used to represent an enumerated choice over the items available for a group of radio menu items. Activating the action with a string parameter is equivalent to setting that parameter as the state. Radio menu items, in addition to being associated with the action, will have a target value. Selecting that menu item will result in activation of the action with the target value as the parameter. The menu item should be rendered as "selected" when the state of the action is equal to the target value of the menu item. Queries the item at position @item_index in @model for the attribute specified by @attribute. If @expected_type is non-%NULL then it specifies the expected type of the attribute. If it is %NULL then any type will be accepted. If the attribute exists and matches @expected_type (or if the expected type is unspecified) then the value is returned. If the attribute does not exist, or does not match the expected type then %NULL is returned. the value of the attribute a #GMenuModel the index of the item the attribute to query the expected type of the attribute, or %NULL Gets all the attributes associated with the item in the menu model. the #GMenuModel to query The #GMenuItem to query Attributes on the item Queries the item at position @item_index in @model for the link specified by @link. If the link exists, the linked #GMenuModel is returned. If the link does not exist, %NULL is returned. the linked #GMenuModel, or %NULL a #GMenuModel the index of the item the link to query Gets all the links associated with the item in the menu model. the #GMenuModel to query The #GMenuItem to query Links from the item Query the number of items in @model. the number of items a #GMenuModel Queries if @model is mutable. An immutable #GMenuModel will never emit the #GMenuModel::items-changed signal. Consumers of the model may make optimisations accordingly. %TRUE if the model is mutable (ie: "items-changed" may be emitted). a #GMenuModel Creates a #GMenuAttributeIter to iterate over the attributes of the item at position @item_index in @model. You must free the iterator with g_object_unref() when you are done. a new #GMenuAttributeIter a #GMenuModel the index of the item Creates a #GMenuLinkIter to iterate over the links of the item at position @item_index in @model. You must free the iterator with g_object_unref() when you are done. a new #GMenuLinkIter a #GMenuModel the index of the item Queries item at position @item_index in @model for the attribute specified by @attribute. If the attribute exists and matches the #GVariantType corresponding to @format_string then @format_string is used to deconstruct the value into the positional parameters and %TRUE is returned. If the attribute does not exist, or it does exist but has the wrong type, then the positional parameters are ignored and %FALSE is returned. This function is a mix of g_menu_model_get_item_attribute_value() and g_variant_get(), followed by a g_variant_unref(). As such, @format_string must make a complete copy of the data (since the #GVariant may go away after the call to g_variant_unref()). In particular, no '&' characters are allowed in @format_string. %TRUE if the named attribute was found with the expected type a #GMenuModel the index of the item the attribute to query a #GVariant format string positional parameters, as per @format_string Queries the item at position @item_index in @model for the attribute specified by @attribute. If @expected_type is non-%NULL then it specifies the expected type of the attribute. If it is %NULL then any type will be accepted. If the attribute exists and matches @expected_type (or if the expected type is unspecified) then the value is returned. If the attribute does not exist, or does not match the expected type then %NULL is returned. the value of the attribute a #GMenuModel the index of the item the attribute to query the expected type of the attribute, or %NULL Queries the item at position @item_index in @model for the link specified by @link. If the link exists, the linked #GMenuModel is returned. If the link does not exist, %NULL is returned. the linked #GMenuModel, or %NULL a #GMenuModel the index of the item the link to query Query the number of items in @model. the number of items a #GMenuModel Queries if @model is mutable. An immutable #GMenuModel will never emit the #GMenuModel::items-changed signal. Consumers of the model may make optimisations accordingly. %TRUE if the model is mutable (ie: "items-changed" may be emitted). a #GMenuModel Requests emission of the #GMenuModel::items-changed signal on @model. This function should never be called except by #GMenuModel subclasses. Any other calls to this function will very likely lead to a violation of the interface of the model. The implementation should update its internal representation of the menu before emitting the signal. The implementation should further expect to receive queries about the new state of the menu (and particularly added menu items) while signal handlers are running. The implementation must dispatch this call directly from a mainloop entry and not in response to calls -- particularly those from the #GMenuModel API. Said another way: the menu must not change while user code is running without returning to the mainloop. a #GMenuModel the position of the change the number of items removed the number of items added Creates a #GMenuAttributeIter to iterate over the attributes of the item at position @item_index in @model. You must free the iterator with g_object_unref() when you are done. a new #GMenuAttributeIter a #GMenuModel the index of the item Creates a #GMenuLinkIter to iterate over the links of the item at position @item_index in @model. You must free the iterator with g_object_unref() when you are done. a new #GMenuLinkIter a #GMenuModel the index of the item Emitted when a change has occurred to the menu. The only changes that can occur to a menu is that items are removed or added. Items may not change (except by being removed and added back in the same location). This signal is capable of describing both of those changes (at the same time). The signal means that starting at the index @position, @removed items were removed and @added items were added in their place. If @removed is zero then only items were added. If @added is zero then only items were removed. As an example, if the menu contains items a, b, c, d (in that order) and the signal (2, 1, 3) occurs then the new composition of the menu will be a, b, _, _, _, d (with each _ representing some new item). Signal handlers may query the model (particularly the added items) and expect to see the results of the modification that is being reported. The signal is emitted after the modification. the position of the change the number of items removed the number of items added %TRUE if the model is mutable (ie: "items-changed" may be emitted). a #GMenuModel the number of items a #GMenuModel the #GMenuModel to query The #GMenuItem to query Attributes on the item a new #GMenuAttributeIter a #GMenuModel the index of the item the value of the attribute a #GMenuModel the index of the item the attribute to query the expected type of the attribute, or %NULL the #GMenuModel to query The #GMenuItem to query Links from the item a new #GMenuLinkIter a #GMenuModel the index of the item the linked #GMenuModel, or %NULL a #GMenuModel the index of the item the link to query The #GMount interface represents user-visible mounts. Note, when porting from GnomeVFS, #GMount is the moral equivalent of #GnomeVFSVolume. #GMount is a "mounted" filesystem that you can access. Mounted is in quotes because it's not the same as a unix mount, it might be a gvfs mount, but you can still access the files on it if you use GIO. Might or might not be related to a volume object. Unmounting a #GMount instance is an asynchronous operation. For more information about asynchronous operations, see #GAsyncResult and #GTask. To unmount a #GMount instance, first call g_mount_unmount_with_operation() with (at least) the #GMount instance and a #GAsyncReadyCallback. The callback will be fired when the operation has resolved (either with success or failure), and a #GAsyncResult structure will be passed to the callback. That callback should then call g_mount_unmount_with_operation_finish() with the #GMount and the #GAsyncResult data to see if the operation was completed successfully. If an @error is present when g_mount_unmount_with_operation_finish() is called, then it will be filled with any error information. Checks if @mount can be ejected. %TRUE if the @mount can be ejected. a #GMount. Checks if @mount can be unmounted. %TRUE if the @mount can be unmounted. a #GMount. Ejects a mount. This is an asynchronous operation, and is finished by calling g_mount_eject_finish() with the @mount and #GAsyncResult data returned in the @callback. Use g_mount_eject_with_operation() instead. a #GMount. flags affecting the unmount if required for eject optional #GCancellable object, %NULL to ignore. a #GAsyncReadyCallback, or %NULL. user data passed to @callback. Finishes ejecting a mount. If any errors occurred during the operation, @error will be set to contain the errors and %FALSE will be returned. Use g_mount_eject_with_operation_finish() instead. %TRUE if the mount was successfully ejected. %FALSE otherwise. a #GMount. a #GAsyncResult. Ejects a mount. This is an asynchronous operation, and is finished by calling g_mount_eject_with_operation_finish() with the @mount and #GAsyncResult data returned in the @callback. a #GMount. flags affecting the unmount if required for eject a #GMountOperation or %NULL to avoid user interaction. optional #GCancellable object, %NULL to ignore. a #GAsyncReadyCallback, or %NULL. user data passed to @callback. Finishes ejecting a mount. If any errors occurred during the operation, @error will be set to contain the errors and %FALSE will be returned. %TRUE if the mount was successfully ejected. %FALSE otherwise. a #GMount. a #GAsyncResult. Gets the default location of @mount. The default location of the given @mount is a path that reflects the main entry point for the user (e.g. the home directory, or the root of the volume). a #GFile. The returned object should be unreffed with g_object_unref() when no longer needed. a #GMount. Gets the drive for the @mount. This is a convenience method for getting the #GVolume and then using that object to get the #GDrive. a #GDrive or %NULL if @mount is not associated with a volume or a drive. The returned object should be unreffed with g_object_unref() when no longer needed. a #GMount. Gets the icon for @mount. a #GIcon. The returned object should be unreffed with g_object_unref() when no longer needed. a #GMount. Gets the name of @mount. the name for the given @mount. The returned string should be freed with g_free() when no longer needed. a #GMount. Gets the root directory on @mount. a #GFile. The returned object should be unreffed with g_object_unref() when no longer needed. a #GMount. Gets the sort key for @mount, if any. Sorting key for @mount or %NULL if no such key is available. A #GMount. Gets the symbolic icon for @mount. a #GIcon. The returned object should be unreffed with g_object_unref() when no longer needed. a #GMount. Gets the UUID for the @mount. The reference is typically based on the file system UUID for the mount in question and should be considered an opaque string. Returns %NULL if there is no UUID available. the UUID for @mount or %NULL if no UUID can be computed. The returned string should be freed with g_free() when no longer needed. a #GMount. Gets the volume for the @mount. a #GVolume or %NULL if @mount is not associated with a volume. The returned object should be unreffed with g_object_unref() when no longer needed. a #GMount. Tries to guess the type of content stored on @mount. Returns one or more textual identifiers of well-known content types (typically prefixed with "x-content/"), e.g. x-content/image-dcf for camera memory cards. See the [shared-mime-info](http://www.freedesktop.org/wiki/Specifications/shared-mime-info-spec) specification for more on x-content types. This is an asynchronous operation (see g_mount_guess_content_type_sync() for the synchronous version), and is finished by calling g_mount_guess_content_type_finish() with the @mount and #GAsyncResult data returned in the @callback. a #GMount Whether to force a rescan of the content. Otherwise a cached result will be used if available optional #GCancellable object, %NULL to ignore a #GAsyncReadyCallback user data passed to @callback Finishes guessing content types of @mount. If any errors occurred during the operation, @error will be set to contain the errors and %FALSE will be returned. In particular, you may get an %G_IO_ERROR_NOT_SUPPORTED if the mount does not support content guessing. a %NULL-terminated array of content types or %NULL on error. Caller should free this array with g_strfreev() when done with it. a #GMount a #GAsyncResult Tries to guess the type of content stored on @mount. Returns one or more textual identifiers of well-known content types (typically prefixed with "x-content/"), e.g. x-content/image-dcf for camera memory cards. See the [shared-mime-info](http://www.freedesktop.org/wiki/Specifications/shared-mime-info-spec) specification for more on x-content types. This is a synchronous operation and as such may block doing IO; see g_mount_guess_content_type() for the asynchronous version. a %NULL-terminated array of content types or %NULL on error. Caller should free this array with g_strfreev() when done with it. a #GMount Whether to force a rescan of the content. Otherwise a cached result will be used if available optional #GCancellable object, %NULL to ignore Remounts a mount. This is an asynchronous operation, and is finished by calling g_mount_remount_finish() with the @mount and #GAsyncResults data returned in the @callback. Remounting is useful when some setting affecting the operation of the volume has been changed, as these may need a remount to take affect. While this is semantically equivalent with unmounting and then remounting not all backends might need to actually be unmounted. a #GMount. flags affecting the operation a #GMountOperation or %NULL to avoid user interaction. optional #GCancellable object, %NULL to ignore. a #GAsyncReadyCallback, or %NULL. user data passed to @callback. Finishes remounting a mount. If any errors occurred during the operation, @error will be set to contain the errors and %FALSE will be returned. %TRUE if the mount was successfully remounted. %FALSE otherwise. a #GMount. a #GAsyncResult. Unmounts a mount. This is an asynchronous operation, and is finished by calling g_mount_unmount_finish() with the @mount and #GAsyncResult data returned in the @callback. Use g_mount_unmount_with_operation() instead. a #GMount. flags affecting the operation optional #GCancellable object, %NULL to ignore. a #GAsyncReadyCallback, or %NULL. user data passed to @callback. Finishes unmounting a mount. If any errors occurred during the operation, @error will be set to contain the errors and %FALSE will be returned. Use g_mount_unmount_with_operation_finish() instead. %TRUE if the mount was successfully unmounted. %FALSE otherwise. a #GMount. a #GAsyncResult. Unmounts a mount. This is an asynchronous operation, and is finished by calling g_mount_unmount_with_operation_finish() with the @mount and #GAsyncResult data returned in the @callback. a #GMount. flags affecting the operation a #GMountOperation or %NULL to avoid user interaction. optional #GCancellable object, %NULL to ignore. a #GAsyncReadyCallback, or %NULL. user data passed to @callback. Finishes unmounting a mount. If any errors occurred during the operation, @error will be set to contain the errors and %FALSE will be returned. %TRUE if the mount was successfully unmounted. %FALSE otherwise. a #GMount. a #GAsyncResult. Checks if @mount can be ejected. %TRUE if the @mount can be ejected. a #GMount. Checks if @mount can be unmounted. %TRUE if the @mount can be unmounted. a #GMount. Ejects a mount. This is an asynchronous operation, and is finished by calling g_mount_eject_finish() with the @mount and #GAsyncResult data returned in the @callback. Use g_mount_eject_with_operation() instead. a #GMount. flags affecting the unmount if required for eject optional #GCancellable object, %NULL to ignore. a #GAsyncReadyCallback, or %NULL. user data passed to @callback. Finishes ejecting a mount. If any errors occurred during the operation, @error will be set to contain the errors and %FALSE will be returned. Use g_mount_eject_with_operation_finish() instead. %TRUE if the mount was successfully ejected. %FALSE otherwise. a #GMount. a #GAsyncResult. Ejects a mount. This is an asynchronous operation, and is finished by calling g_mount_eject_with_operation_finish() with the @mount and #GAsyncResult data returned in the @callback. a #GMount. flags affecting the unmount if required for eject a #GMountOperation or %NULL to avoid user interaction. optional #GCancellable object, %NULL to ignore. a #GAsyncReadyCallback, or %NULL. user data passed to @callback. Finishes ejecting a mount. If any errors occurred during the operation, @error will be set to contain the errors and %FALSE will be returned. %TRUE if the mount was successfully ejected. %FALSE otherwise. a #GMount. a #GAsyncResult. Gets the default location of @mount. The default location of the given @mount is a path that reflects the main entry point for the user (e.g. the home directory, or the root of the volume). a #GFile. The returned object should be unreffed with g_object_unref() when no longer needed. a #GMount. Gets the drive for the @mount. This is a convenience method for getting the #GVolume and then using that object to get the #GDrive. a #GDrive or %NULL if @mount is not associated with a volume or a drive. The returned object should be unreffed with g_object_unref() when no longer needed. a #GMount. Gets the icon for @mount. a #GIcon. The returned object should be unreffed with g_object_unref() when no longer needed. a #GMount. Gets the name of @mount. the name for the given @mount. The returned string should be freed with g_free() when no longer needed. a #GMount. Gets the root directory on @mount. a #GFile. The returned object should be unreffed with g_object_unref() when no longer needed. a #GMount. Gets the sort key for @mount, if any. Sorting key for @mount or %NULL if no such key is available. A #GMount. Gets the symbolic icon for @mount. a #GIcon. The returned object should be unreffed with g_object_unref() when no longer needed. a #GMount. Gets the UUID for the @mount. The reference is typically based on the file system UUID for the mount in question and should be considered an opaque string. Returns %NULL if there is no UUID available. the UUID for @mount or %NULL if no UUID can be computed. The returned string should be freed with g_free() when no longer needed. a #GMount. Gets the volume for the @mount. a #GVolume or %NULL if @mount is not associated with a volume. The returned object should be unreffed with g_object_unref() when no longer needed. a #GMount. Tries to guess the type of content stored on @mount. Returns one or more textual identifiers of well-known content types (typically prefixed with "x-content/"), e.g. x-content/image-dcf for camera memory cards. See the [shared-mime-info](http://www.freedesktop.org/wiki/Specifications/shared-mime-info-spec) specification for more on x-content types. This is an asynchronous operation (see g_mount_guess_content_type_sync() for the synchronous version), and is finished by calling g_mount_guess_content_type_finish() with the @mount and #GAsyncResult data returned in the @callback. a #GMount Whether to force a rescan of the content. Otherwise a cached result will be used if available optional #GCancellable object, %NULL to ignore a #GAsyncReadyCallback user data passed to @callback Finishes guessing content types of @mount. If any errors occurred during the operation, @error will be set to contain the errors and %FALSE will be returned. In particular, you may get an %G_IO_ERROR_NOT_SUPPORTED if the mount does not support content guessing. a %NULL-terminated array of content types or %NULL on error. Caller should free this array with g_strfreev() when done with it. a #GMount a #GAsyncResult Tries to guess the type of content stored on @mount. Returns one or more textual identifiers of well-known content types (typically prefixed with "x-content/"), e.g. x-content/image-dcf for camera memory cards. See the [shared-mime-info](http://www.freedesktop.org/wiki/Specifications/shared-mime-info-spec) specification for more on x-content types. This is a synchronous operation and as such may block doing IO; see g_mount_guess_content_type() for the asynchronous version. a %NULL-terminated array of content types or %NULL on error. Caller should free this array with g_strfreev() when done with it. a #GMount Whether to force a rescan of the content. Otherwise a cached result will be used if available optional #GCancellable object, %NULL to ignore Determines if @mount is shadowed. Applications or libraries should avoid displaying @mount in the user interface if it is shadowed. A mount is said to be shadowed if there exists one or more user visible objects (currently #GMount objects) with a root that is inside the root of @mount. One application of shadow mounts is when exposing a single file system that is used to address several logical volumes. In this situation, a #GVolumeMonitor implementation would create two #GVolume objects (for example, one for the camera functionality of the device and one for a SD card reader on the device) with activation URIs `gphoto2://[usb:001,002]/store1/` and `gphoto2://[usb:001,002]/store2/`. When the underlying mount (with root `gphoto2://[usb:001,002]/`) is mounted, said #GVolumeMonitor implementation would create two #GMount objects (each with their root matching the corresponding volume activation root) that would shadow the original mount. The proxy monitor in GVfs 2.26 and later, automatically creates and manage shadow mounts (and shadows the underlying mount) if the activation root on a #GVolume is set. %TRUE if @mount is shadowed. A #GMount. Remounts a mount. This is an asynchronous operation, and is finished by calling g_mount_remount_finish() with the @mount and #GAsyncResults data returned in the @callback. Remounting is useful when some setting affecting the operation of the volume has been changed, as these may need a remount to take affect. While this is semantically equivalent with unmounting and then remounting not all backends might need to actually be unmounted. a #GMount. flags affecting the operation a #GMountOperation or %NULL to avoid user interaction. optional #GCancellable object, %NULL to ignore. a #GAsyncReadyCallback, or %NULL. user data passed to @callback. Finishes remounting a mount. If any errors occurred during the operation, @error will be set to contain the errors and %FALSE will be returned. %TRUE if the mount was successfully remounted. %FALSE otherwise. a #GMount. a #GAsyncResult. Increments the shadow count on @mount. Usually used by #GVolumeMonitor implementations when creating a shadow mount for @mount, see g_mount_is_shadowed() for more information. The caller will need to emit the #GMount::changed signal on @mount manually. A #GMount. Unmounts a mount. This is an asynchronous operation, and is finished by calling g_mount_unmount_finish() with the @mount and #GAsyncResult data returned in the @callback. Use g_mount_unmount_with_operation() instead. a #GMount. flags affecting the operation optional #GCancellable object, %NULL to ignore. a #GAsyncReadyCallback, or %NULL. user data passed to @callback. Finishes unmounting a mount. If any errors occurred during the operation, @error will be set to contain the errors and %FALSE will be returned. Use g_mount_unmount_with_operation_finish() instead. %TRUE if the mount was successfully unmounted. %FALSE otherwise. a #GMount. a #GAsyncResult. Unmounts a mount. This is an asynchronous operation, and is finished by calling g_mount_unmount_with_operation_finish() with the @mount and #GAsyncResult data returned in the @callback. a #GMount. flags affecting the operation a #GMountOperation or %NULL to avoid user interaction. optional #GCancellable object, %NULL to ignore. a #GAsyncReadyCallback, or %NULL. user data passed to @callback. Finishes unmounting a mount. If any errors occurred during the operation, @error will be set to contain the errors and %FALSE will be returned. %TRUE if the mount was successfully unmounted. %FALSE otherwise. a #GMount. a #GAsyncResult. Decrements the shadow count on @mount. Usually used by #GVolumeMonitor implementations when destroying a shadow mount for @mount, see g_mount_is_shadowed() for more information. The caller will need to emit the #GMount::changed signal on @mount manually. A #GMount. Emitted when the mount has been changed. This signal may be emitted when the #GMount is about to be unmounted. This signal depends on the backend and is only emitted if GIO was used to unmount. This signal is emitted when the #GMount have been unmounted. If the recipient is holding references to the object they should release them so the object can be finalized. Interface for implementing operations for mounts. The parent interface. a #GFile. The returned object should be unreffed with g_object_unref() when no longer needed. a #GMount. the name for the given @mount. The returned string should be freed with g_free() when no longer needed. a #GMount. a #GIcon. The returned object should be unreffed with g_object_unref() when no longer needed. a #GMount. the UUID for @mount or %NULL if no UUID can be computed. The returned string should be freed with g_free() when no longer needed. a #GMount. a #GVolume or %NULL if @mount is not associated with a volume. The returned object should be unreffed with g_object_unref() when no longer needed. a #GMount. a #GDrive or %NULL if @mount is not associated with a volume or a drive. The returned object should be unreffed with g_object_unref() when no longer needed. a #GMount. %TRUE if the @mount can be unmounted. a #GMount. %TRUE if the @mount can be ejected. a #GMount. a #GMount. flags affecting the operation optional #GCancellable object, %NULL to ignore. a #GAsyncReadyCallback, or %NULL. user data passed to @callback. %TRUE if the mount was successfully unmounted. %FALSE otherwise. a #GMount. a #GAsyncResult. a #GMount. flags affecting the unmount if required for eject optional #GCancellable object, %NULL to ignore. a #GAsyncReadyCallback, or %NULL. user data passed to @callback. %TRUE if the mount was successfully ejected. %FALSE otherwise. a #GMount. a #GAsyncResult. a #GMount. flags affecting the operation a #GMountOperation or %NULL to avoid user interaction. optional #GCancellable object, %NULL to ignore. a #GAsyncReadyCallback, or %NULL. user data passed to @callback. %TRUE if the mount was successfully remounted. %FALSE otherwise. a #GMount. a #GAsyncResult. a #GMount Whether to force a rescan of the content. Otherwise a cached result will be used if available optional #GCancellable object, %NULL to ignore a #GAsyncReadyCallback user data passed to @callback a %NULL-terminated array of content types or %NULL on error. Caller should free this array with g_strfreev() when done with it. a #GMount a #GAsyncResult a %NULL-terminated array of content types or %NULL on error. Caller should free this array with g_strfreev() when done with it. a #GMount Whether to force a rescan of the content. Otherwise a cached result will be used if available optional #GCancellable object, %NULL to ignore a #GMount. flags affecting the operation a #GMountOperation or %NULL to avoid user interaction. optional #GCancellable object, %NULL to ignore. a #GAsyncReadyCallback, or %NULL. user data passed to @callback. %TRUE if the mount was successfully unmounted. %FALSE otherwise. a #GMount. a #GAsyncResult. a #GMount. flags affecting the unmount if required for eject a #GMountOperation or %NULL to avoid user interaction. optional #GCancellable object, %NULL to ignore. a #GAsyncReadyCallback, or %NULL. user data passed to @callback. %TRUE if the mount was successfully ejected. %FALSE otherwise. a #GMount. a #GAsyncResult. a #GFile. The returned object should be unreffed with g_object_unref() when no longer needed. a #GMount. Sorting key for @mount or %NULL if no such key is available. A #GMount. a #GIcon. The returned object should be unreffed with g_object_unref() when no longer needed. a #GMount. Flags used when mounting a mount. No flags set. #GMountOperation provides a mechanism for interacting with the user. It can be used for authenticating mountable operations, such as loop mounting files, hard drive partitions or server locations. It can also be used to ask the user questions or show a list of applications preventing unmount or eject operations from completing. Note that #GMountOperation is used for more than just #GMount objects – for example it is also used in g_drive_start() and g_drive_stop(). Users should instantiate a subclass of this that implements all the various callbacks to show the required dialogs, such as #GtkMountOperation. If no user interaction is desired (for example when automounting filesystems at login time), usually %NULL can be passed, see each method taking a #GMountOperation for details. The term ‘TCRYPT’ is used to mean ‘compatible with TrueCrypt and VeraCrypt’. [TrueCrypt](https://en.wikipedia.org/wiki/TrueCrypt) is a discontinued system for encrypting file containers, partitions or whole disks, typically used with Windows. [VeraCrypt](https://www.veracrypt.fr/) is a maintained fork of TrueCrypt with various improvements and auditing fixes. Creates a new mount operation. a #GMountOperation. Virtual implementation of #GMountOperation::ask-question. a #GMountOperation string containing a message to display to the user an array of strings for each possible choice Emits the #GMountOperation::reply signal. a #GMountOperation a #GMountOperationResult Virtual implementation of #GMountOperation::show-processes. a #GMountOperation string containing a message to display to the user an array of #GPid for processes blocking the operation an array of strings for each possible choice Check to see whether the mount operation is being used for an anonymous user. %TRUE if mount operation is anonymous. a #GMountOperation. Gets a choice from the mount operation. an integer containing an index of the user's choice from the choice's list, or `0`. a #GMountOperation. Gets the domain of the mount operation. a string set to the domain. a #GMountOperation. Check to see whether the mount operation is being used for a TCRYPT hidden volume. %TRUE if mount operation is for hidden volume. a #GMountOperation. Check to see whether the mount operation is being used for a TCRYPT system volume. %TRUE if mount operation is for system volume. a #GMountOperation. Gets a password from the mount operation. a string containing the password within @op. a #GMountOperation. Gets the state of saving passwords for the mount operation. a #GPasswordSave flag. a #GMountOperation. Gets a PIM from the mount operation. The VeraCrypt PIM within @op. a #GMountOperation. Get the user name from the mount operation. a string containing the user name. a #GMountOperation. Emits the #GMountOperation::reply signal. a #GMountOperation a #GMountOperationResult Sets the mount operation to use an anonymous user if @anonymous is %TRUE. a #GMountOperation. boolean value. Sets a default choice for the mount operation. a #GMountOperation. an integer. Sets the mount operation's domain. a #GMountOperation. the domain to set. Sets the mount operation to use a hidden volume if @hidden_volume is %TRUE. a #GMountOperation. boolean value. Sets the mount operation to use a system volume if @system_volume is %TRUE. a #GMountOperation. boolean value. Sets the mount operation's password to @password. a #GMountOperation. password to set. Sets the state of saving passwords for the mount operation. a #GMountOperation. a set of #GPasswordSave flags. Sets the mount operation's PIM to @pim. a #GMountOperation. an unsigned integer. Sets the user name within @op to @username. a #GMountOperation. input username. Whether to use an anonymous user when authenticating. The index of the user's choice when a question is asked during the mount operation. See the #GMountOperation::ask-question signal. The domain to use for the mount operation. Whether the device to be unlocked is a TCRYPT hidden volume. See [the VeraCrypt documentation](https://www.veracrypt.fr/en/Hidden%20Volume.html). Whether the device to be unlocked is a TCRYPT system volume. In this context, a system volume is a volume with a bootloader and operating system installed. This is only supported for Windows operating systems. For further documentation, see [the VeraCrypt documentation](https://www.veracrypt.fr/en/System%20Encryption.html). The password that is used for authentication when carrying out the mount operation. Determines if and how the password information should be saved. The VeraCrypt PIM value, when unlocking a VeraCrypt volume. See [the VeraCrypt documentation](https://www.veracrypt.fr/en/Personal%20Iterations%20Multiplier%20(PIM).html). The user name that is used for authentication when carrying out the mount operation. Emitted by the backend when e.g. a device becomes unavailable while a mount operation is in progress. Implementations of GMountOperation should handle this signal by dismissing open password dialogs. Emitted when a mount operation asks the user for a password. If the message contains a line break, the first line should be presented as a heading. For example, it may be used as the primary text in a #GtkMessageDialog. string containing a message to display to the user. string containing the default user name. string containing the default domain. a set of #GAskPasswordFlags. Emitted when asking the user a question and gives a list of choices for the user to choose from. If the message contains a line break, the first line should be presented as a heading. For example, it may be used as the primary text in a #GtkMessageDialog. string containing a message to display to the user. an array of strings for each possible choice. Emitted when the user has replied to the mount operation. a #GMountOperationResult indicating how the request was handled Emitted when one or more processes are blocking an operation e.g. unmounting/ejecting a #GMount or stopping a #GDrive. Note that this signal may be emitted several times to update the list of blocking processes as processes close files. The application should only respond with g_mount_operation_reply() to the latest signal (setting #GMountOperation:choice to the choice the user made). If the message contains a line break, the first line should be presented as a heading. For example, it may be used as the primary text in a #GtkMessageDialog. string containing a message to display to the user. an array of #GPid for processes blocking the operation. an array of strings for each possible choice. Emitted when an unmount operation has been busy for more than some time (typically 1.5 seconds). When unmounting or ejecting a volume, the kernel might need to flush pending data in its buffers to the volume stable storage, and this operation can take a considerable amount of time. This signal may be emitted several times as long as the unmount operation is outstanding, and then one last time when the operation is completed, with @bytes_left set to zero. Implementations of GMountOperation should handle this signal by showing an UI notification, and then dismiss it, or show another notification of completion, when @bytes_left reaches zero. If the message contains a line break, the first line should be presented as a heading. For example, it may be used as the primary text in a #GtkMessageDialog. string containing a message to display to the user the estimated time left before the operation completes, in microseconds, or -1 the amount of bytes to be written before the operation completes (or -1 if such amount is not known), or zero if the operation is completed a #GMountOperation string containing a message to display to the user an array of strings for each possible choice a #GMountOperation a #GMountOperationResult a #GMountOperation string containing a message to display to the user an array of #GPid for processes blocking the operation an array of strings for each possible choice #GMountOperationResult is returned as a result when a request for information is send by the mounting operation. The request was fulfilled and the user specified data is now available The user requested the mount operation to be aborted The request was unhandled (i.e. not implemented) Flags used when an unmounting a mount. No flags set. Unmount even if there are outstanding file operations on the mount. Extension point for network status monitoring functionality. See [Extending GIO][extending-gio]. A socket address of some unknown native type. Creates a new #GNativeSocketAddress for @native and @len. a new #GNativeSocketAddress a native address object the length of @native, in bytes #GNetworkAddress provides an easy way to resolve a hostname and then attempt to connect to that host, handling the possibility of multiple IP addresses and multiple address families. The enumeration results of resolved addresses *may* be cached as long as this object is kept alive which may have unexpected results if alive for too long. See #GSocketConnectable for an example of using the connectable interface. Creates a new #GSocketConnectable for connecting to the given @hostname and @port. Note that depending on the configuration of the machine, a @hostname of `localhost` may refer to the IPv4 loopback address only, or to both IPv4 and IPv6; use g_network_address_new_loopback() to create a #GNetworkAddress that is guaranteed to resolve to both addresses. the new #GNetworkAddress the hostname the port Creates a new #GSocketConnectable for connecting to the local host over a loopback connection to the given @port. This is intended for use in connecting to local services which may be running on IPv4 or IPv6. The connectable will return IPv4 and IPv6 loopback addresses, regardless of how the host resolves `localhost`. By contrast, g_network_address_new() will often only return an IPv4 address when resolving `localhost`, and an IPv6 address for `localhost6`. g_network_address_get_hostname() will always return `localhost` for a #GNetworkAddress created with this constructor. the new #GNetworkAddress the port Creates a new #GSocketConnectable for connecting to the given @hostname and @port. May fail and return %NULL in case parsing @host_and_port fails. @host_and_port may be in any of a number of recognised formats; an IPv6 address, an IPv4 address, or a domain name (in which case a DNS lookup is performed). Quoting with [] is supported for all address types. A port override may be specified in the usual way with a colon. If no port is specified in @host_and_port then @default_port will be used as the port number to connect to. In general, @host_and_port is expected to be provided by the user (allowing them to give the hostname, and a port override if necessary) and @default_port is expected to be provided by the application. (The port component of @host_and_port can also be specified as a service name rather than as a numeric port, but this functionality is deprecated, because it depends on the contents of /etc/services, which is generally quite sparse on platforms other than Linux.) the new #GNetworkAddress, or %NULL on error the hostname and optionally a port the default port if not in @host_and_port Creates a new #GSocketConnectable for connecting to the given @uri. May fail and return %NULL in case parsing @uri fails. Using this rather than g_network_address_new() or g_network_address_parse() allows #GSocketClient to determine when to use application-specific proxy protocols. the new #GNetworkAddress, or %NULL on error the hostname and optionally a port The default port if none is found in the URI Gets @addr's hostname. This might be either UTF-8 or ASCII-encoded, depending on what @addr was created with. @addr's hostname a #GNetworkAddress Gets @addr's port number @addr's port (which may be 0) a #GNetworkAddress Gets @addr's scheme @addr's scheme (%NULL if not built from URI) a #GNetworkAddress The host's network connectivity state, as reported by #GNetworkMonitor. The host is not configured with a route to the Internet; it may or may not be connected to a local network. The host is connected to a network, but does not appear to be able to reach the full Internet, perhaps due to upstream network problems. The host is behind a captive portal and cannot reach the full Internet. The host is connected to a network, and appears to be able to reach the full Internet. #GNetworkMonitor provides an easy-to-use cross-platform API for monitoring network connectivity. On Linux, the available implementations are based on the kernel's netlink interface and on NetworkManager. There is also an implementation for use inside Flatpak sandboxes. Gets the default #GNetworkMonitor for the system. a #GNetworkMonitor Attempts to determine whether or not the host pointed to by @connectable can be reached, without actually trying to connect to it. This may return %TRUE even when #GNetworkMonitor:network-available is %FALSE, if, for example, @monitor can determine that @connectable refers to a host on a local network. If @monitor believes that an attempt to connect to @connectable will succeed, it will return %TRUE. Otherwise, it will return %FALSE and set @error to an appropriate error (such as %G_IO_ERROR_HOST_UNREACHABLE). Note that although this does not attempt to connect to @connectable, it may still block for a brief period of time (eg, trying to do multicast DNS on the local network), so if you do not want to block, you should use g_network_monitor_can_reach_async(). %TRUE if @connectable is reachable, %FALSE if not. a #GNetworkMonitor a #GSocketConnectable a #GCancellable, or %NULL Asynchronously attempts to determine whether or not the host pointed to by @connectable can be reached, without actually trying to connect to it. For more details, see g_network_monitor_can_reach(). When the operation is finished, @callback will be called. You can then call g_network_monitor_can_reach_finish() to get the result of the operation. a #GNetworkMonitor a #GSocketConnectable a #GCancellable, or %NULL a #GAsyncReadyCallback to call when the request is satisfied the data to pass to callback function Finishes an async network connectivity test. See g_network_monitor_can_reach_async(). %TRUE if network is reachable, %FALSE if not. a #GNetworkMonitor a #GAsyncResult Attempts to determine whether or not the host pointed to by @connectable can be reached, without actually trying to connect to it. This may return %TRUE even when #GNetworkMonitor:network-available is %FALSE, if, for example, @monitor can determine that @connectable refers to a host on a local network. If @monitor believes that an attempt to connect to @connectable will succeed, it will return %TRUE. Otherwise, it will return %FALSE and set @error to an appropriate error (such as %G_IO_ERROR_HOST_UNREACHABLE). Note that although this does not attempt to connect to @connectable, it may still block for a brief period of time (eg, trying to do multicast DNS on the local network), so if you do not want to block, you should use g_network_monitor_can_reach_async(). %TRUE if @connectable is reachable, %FALSE if not. a #GNetworkMonitor a #GSocketConnectable a #GCancellable, or %NULL Asynchronously attempts to determine whether or not the host pointed to by @connectable can be reached, without actually trying to connect to it. For more details, see g_network_monitor_can_reach(). When the operation is finished, @callback will be called. You can then call g_network_monitor_can_reach_finish() to get the result of the operation. a #GNetworkMonitor a #GSocketConnectable a #GCancellable, or %NULL a #GAsyncReadyCallback to call when the request is satisfied the data to pass to callback function Finishes an async network connectivity test. See g_network_monitor_can_reach_async(). %TRUE if network is reachable, %FALSE if not. a #GNetworkMonitor a #GAsyncResult Gets a more detailed networking state than g_network_monitor_get_network_available(). If #GNetworkMonitor:network-available is %FALSE, then the connectivity state will be %G_NETWORK_CONNECTIVITY_LOCAL. If #GNetworkMonitor:network-available is %TRUE, then the connectivity state will be %G_NETWORK_CONNECTIVITY_FULL (if there is full Internet connectivity), %G_NETWORK_CONNECTIVITY_LIMITED (if the host has a default route, but appears to be unable to actually reach the full Internet), or %G_NETWORK_CONNECTIVITY_PORTAL (if the host is trapped behind a "captive portal" that requires some sort of login or acknowledgement before allowing full Internet access). Note that in the case of %G_NETWORK_CONNECTIVITY_LIMITED and %G_NETWORK_CONNECTIVITY_PORTAL, it is possible that some sites are reachable but others are not. In this case, applications can attempt to connect to remote servers, but should gracefully fall back to their "offline" behavior if the connection attempt fails. the network connectivity state the #GNetworkMonitor Checks if the network is available. "Available" here means that the system has a default route available for at least one of IPv4 or IPv6. It does not necessarily imply that the public Internet is reachable. See #GNetworkMonitor:network-available for more details. whether the network is available the #GNetworkMonitor Checks if the network is metered. See #GNetworkMonitor:network-metered for more details. whether the connection is metered the #GNetworkMonitor More detailed information about the host's network connectivity. See g_network_monitor_get_connectivity() and #GNetworkConnectivity for more details. Whether the network is considered available. That is, whether the system has a default route for at least one of IPv4 or IPv6. Real-world networks are of course much more complicated than this; the machine may be connected to a wifi hotspot that requires payment before allowing traffic through, or may be connected to a functioning router that has lost its own upstream connectivity. Some hosts might only be accessible when a VPN is active. Other hosts might only be accessible when the VPN is not active. Thus, it is best to use g_network_monitor_can_reach() or g_network_monitor_can_reach_async() to test for reachability on a host-by-host basis. (On the other hand, when the property is %FALSE, the application can reasonably expect that no remote hosts at all are reachable, and should indicate this to the user in its UI.) See also #GNetworkMonitor::network-changed. Whether the network is considered metered. That is, whether the system has traffic flowing through the default connection that is subject to limitations set by service providers. For example, traffic might be billed by the amount of data transmitted, or there might be a quota on the amount of traffic per month. This is typical with tethered connections (3G and 4G) and in such situations, bandwidth intensive applications may wish to avoid network activity where possible if it will cost the user money or use up their limited quota. If more information is required about specific devices then the system network management API should be used instead (for example, NetworkManager or ConnMan). If this information is not available then no networks will be marked as metered. See also #GNetworkMonitor:network-available. Emitted when the network configuration changes. the current value of #GNetworkMonitor:network-available The virtual function table for #GNetworkMonitor. The parent interface. %TRUE if @connectable is reachable, %FALSE if not. a #GNetworkMonitor a #GSocketConnectable a #GCancellable, or %NULL a #GNetworkMonitor a #GSocketConnectable a #GCancellable, or %NULL a #GAsyncReadyCallback to call when the request is satisfied the data to pass to callback function %TRUE if network is reachable, %FALSE if not. a #GNetworkMonitor a #GAsyncResult Like #GNetworkAddress does with hostnames, #GNetworkService provides an easy way to resolve a SRV record, and then attempt to connect to one of the hosts that implements that service, handling service priority/weighting, multiple IP addresses, and multiple address families. See #GSrvTarget for more information about SRV records, and see #GSocketConnectable for an example of using the connectable interface. Creates a new #GNetworkService representing the given @service, @protocol, and @domain. This will initially be unresolved; use the #GSocketConnectable interface to resolve it. a new #GNetworkService the service type to look up (eg, "ldap") the networking protocol to use for @service (eg, "tcp") the DNS domain to look up the service in Gets the domain that @srv serves. This might be either UTF-8 or ASCII-encoded, depending on what @srv was created with. @srv's domain name a #GNetworkService Gets @srv's protocol name (eg, "tcp"). @srv's protocol name a #GNetworkService Gets the URI scheme used to resolve proxies. By default, the service name is used as scheme. @srv's scheme name a #GNetworkService Gets @srv's service name (eg, "ldap"). @srv's service name a #GNetworkService Set's the URI scheme used to resolve proxies. By default, the service name is used as scheme. a #GNetworkService a URI scheme #GNotification is a mechanism for creating a notification to be shown to the user -- typically as a pop-up notification presented by the desktop environment shell. The key difference between #GNotification and other similar APIs is that, if supported by the desktop environment, notifications sent with #GNotification will persist after the application has exited, and even across system reboots. Since the user may click on a notification while the application is not running, applications using #GNotification should be able to be started as a D-Bus service, using #GApplication. User interaction with a notification (either the default action, or buttons) must be associated with actions on the application (ie: "app." actions). It is not possible to route user interaction through the notification itself, because the object will not exist if the application is autostarted as a result of a notification being clicked. A notification can be sent with g_application_send_notification(). Creates a new #GNotification with @title as its title. After populating @notification with more details, it can be sent to the desktop shell with g_application_send_notification(). Changing any properties after this call will not have any effect until resending @notification. a new #GNotification instance the title of the notification Adds a button to @notification that activates the action in @detailed_action when clicked. That action must be an application-wide action (starting with "app."). If @detailed_action contains a target, the action will be activated with that target as its parameter. See g_action_parse_detailed_name() for a description of the format for @detailed_action. a #GNotification label of the button a detailed action name Adds a button to @notification that activates @action when clicked. @action must be an application-wide action (it must start with "app."). If @target_format is given, it is used to collect remaining positional parameters into a #GVariant instance, similar to g_variant_new(). @action will be activated with that #GVariant as its parameter. a #GNotification label of the button an action name a #GVariant format string, or %NULL positional parameters, as determined by @target_format Adds a button to @notification that activates @action when clicked. @action must be an application-wide action (it must start with "app."). If @target is non-%NULL, @action will be activated with @target as its parameter. a #GNotification label of the button an action name a #GVariant to use as @action's parameter, or %NULL Sets the body of @notification to @body. a #GNotification the new body for @notification, or %NULL Sets the default action of @notification to @detailed_action. This action is activated when the notification is clicked on. The action in @detailed_action must be an application-wide action (it must start with "app."). If @detailed_action contains a target, the given action will be activated with that target as its parameter. See g_action_parse_detailed_name() for a description of the format for @detailed_action. When no default action is set, the application that the notification was sent on is activated. a #GNotification a detailed action name Sets the default action of @notification to @action. This action is activated when the notification is clicked on. It must be an application-wide action (it must start with "app."). If @target_format is given, it is used to collect remaining positional parameters into a #GVariant instance, similar to g_variant_new(). @action will be activated with that #GVariant as its parameter. When no default action is set, the application that the notification was sent on is activated. a #GNotification an action name a #GVariant format string, or %NULL positional parameters, as determined by @target_format Sets the default action of @notification to @action. This action is activated when the notification is clicked on. It must be an application-wide action (start with "app."). If @target is non-%NULL, @action will be activated with @target as its parameter. When no default action is set, the application that the notification was sent on is activated. a #GNotification an action name a #GVariant to use as @action's parameter, or %NULL Sets the icon of @notification to @icon. a #GNotification the icon to be shown in @notification, as a #GIcon Sets the priority of @notification to @priority. See #GNotificationPriority for possible values. a #GNotification a #GNotificationPriority Sets the title of @notification to @title. a #GNotification the new title for @notification Deprecated in favor of g_notification_set_priority(). Since 2.42, this has been deprecated in favour of g_notification_set_priority(). a #GNotification %TRUE if @notification is urgent Priority levels for #GNotifications. the default priority, to be used for the majority of notifications (for example email messages, software updates, completed download/sync operations) for notifications that do not require immediate attention - typically used for contextual background information, such as contact birthdays or local weather for events that require more attention, usually because responses are time-sensitive (for example chat and SMS messages or alarms) for urgent notifications, or notifications that require a response in a short space of time (for example phone calls or emergency warnings) Structure used for scatter/gather data output when sending multiple messages or packets in one go. You generally pass in an array of #GOutputVectors and the operation will use all the buffers as if they were one buffer. If @address is %NULL then the message is sent to the default receiver (as previously set by g_socket_connect()). a #GSocketAddress, or %NULL pointer to an array of output vectors the number of output vectors pointed to by @vectors. initialize to 0. Will be set to the number of bytes that have been sent a pointer to an array of #GSocketControlMessages, or %NULL. number of elements in @control_messages. #GOutputStream has functions to write to a stream (g_output_stream_write()), to close a stream (g_output_stream_close()) and to flush pending writes (g_output_stream_flush()). To copy the content of an input stream to an output stream without manually handling the reads and writes, use g_output_stream_splice(). See the documentation for #GIOStream for details of thread safety of streaming APIs. All of these functions have async variants too. Requests an asynchronous close of the stream, releasing resources related to it. When the operation is finished @callback will be called. You can then call g_output_stream_close_finish() to get the result of the operation. For behaviour details see g_output_stream_close(). The asynchronous methods have a default fallback that uses threads to implement asynchronicity, so they are optional for inheriting classes. However, if you override one you must override all. A #GOutputStream. the io priority of the request. optional cancellable object callback to call when the request is satisfied the data to pass to callback function Closes an output stream. %TRUE if stream was successfully closed, %FALSE otherwise. a #GOutputStream. a #GAsyncResult. Forces a write of all user-space buffered data for the given @stream. Will block during the operation. Closing the stream will implicitly cause a flush. This function is optional for inherited classes. If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. %TRUE on success, %FALSE on error a #GOutputStream. optional cancellable object Forces an asynchronous write of all user-space buffered data for the given @stream. For behaviour details see g_output_stream_flush(). When the operation is finished @callback will be called. You can then call g_output_stream_flush_finish() to get the result of the operation. a #GOutputStream. the io priority of the request. optional #GCancellable object, %NULL to ignore. a #GAsyncReadyCallback to call when the request is satisfied the data to pass to callback function Finishes flushing an output stream. %TRUE if flush operation succeeded, %FALSE otherwise. a #GOutputStream. a GAsyncResult. Splices an input stream into an output stream. a #gssize containing the size of the data spliced, or -1 if an error occurred. Note that if the number of bytes spliced is greater than %G_MAXSSIZE, then that will be returned, and there is no way to determine the actual number of bytes spliced. a #GOutputStream. a #GInputStream. a set of #GOutputStreamSpliceFlags. optional #GCancellable object, %NULL to ignore. Splices a stream asynchronously. When the operation is finished @callback will be called. You can then call g_output_stream_splice_finish() to get the result of the operation. For the synchronous, blocking version of this function, see g_output_stream_splice(). a #GOutputStream. a #GInputStream. a set of #GOutputStreamSpliceFlags. the io priority of the request. optional #GCancellable object, %NULL to ignore. a #GAsyncReadyCallback. user data passed to @callback. Finishes an asynchronous stream splice operation. a #gssize of the number of bytes spliced. Note that if the number of bytes spliced is greater than %G_MAXSSIZE, then that will be returned, and there is no way to determine the actual number of bytes spliced. a #GOutputStream. a #GAsyncResult. Request an asynchronous write of @count bytes from @buffer into the stream. When the operation is finished @callback will be called. You can then call g_output_stream_write_finish() to get the result of the operation. During an async request no other sync and async calls are allowed, and will result in %G_IO_ERROR_PENDING errors. A value of @count larger than %G_MAXSSIZE will cause a %G_IO_ERROR_INVALID_ARGUMENT error. On success, the number of bytes written will be passed to the @callback. It is not an error if this is not the same as the requested size, as it can happen e.g. on a partial I/O error, but generally we try to write as many bytes as requested. You are guaranteed that this method will never fail with %G_IO_ERROR_WOULD_BLOCK - if @stream can't accept more data, the method will just wait until this changes. Any outstanding I/O request with higher priority (lower numerical value) will be executed before an outstanding request with lower priority. Default priority is %G_PRIORITY_DEFAULT. The asynchronous methods have a default fallback that uses threads to implement asynchronicity, so they are optional for inheriting classes. However, if you override one you must override all. For the synchronous, blocking version of this function, see g_output_stream_write(). Note that no copy of @buffer will be made, so it must stay valid until @callback is called. See g_output_stream_write_bytes_async() for a #GBytes version that will automatically hold a reference to the contents (without copying) for the duration of the call. A #GOutputStream. the buffer containing the data to write. the number of bytes to write the io priority of the request. optional #GCancellable object, %NULL to ignore. callback to call when the request is satisfied the data to pass to callback function Finishes a stream write operation. a #gssize containing the number of bytes written to the stream. a #GOutputStream. a #GAsyncResult. Tries to write @count bytes from @buffer into the stream. Will block during the operation. If count is 0, returns 0 and does nothing. A value of @count larger than %G_MAXSSIZE will cause a %G_IO_ERROR_INVALID_ARGUMENT error. On success, the number of bytes written to the stream is returned. It is not an error if this is not the same as the requested size, as it can happen e.g. on a partial I/O error, or if there is not enough storage in the stream. All writes block until at least one byte is written or an error occurs; 0 is never returned (unless @count is 0). If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an operation was partially finished when the operation was cancelled the partial result will be returned, without an error. On error -1 is returned and @error is set accordingly. Number of bytes written, or -1 on error a #GOutputStream. the buffer containing the data to write. the number of bytes to write optional cancellable object Request an asynchronous write of the bytes contained in @n_vectors @vectors into the stream. When the operation is finished @callback will be called. You can then call g_output_stream_writev_finish() to get the result of the operation. During an async request no other sync and async calls are allowed, and will result in %G_IO_ERROR_PENDING errors. On success, the number of bytes written will be passed to the @callback. It is not an error if this is not the same as the requested size, as it can happen e.g. on a partial I/O error, but generally we try to write as many bytes as requested. You are guaranteed that this method will never fail with %G_IO_ERROR_WOULD_BLOCK — if @stream can't accept more data, the method will just wait until this changes. Any outstanding I/O request with higher priority (lower numerical value) will be executed before an outstanding request with lower priority. Default priority is %G_PRIORITY_DEFAULT. The asynchronous methods have a default fallback that uses threads to implement asynchronicity, so they are optional for inheriting classes. However, if you override one you must override all. For the synchronous, blocking version of this function, see g_output_stream_writev(). Note that no copy of @vectors will be made, so it must stay valid until @callback is called. A #GOutputStream. the buffer containing the #GOutputVectors to write. the number of vectors to write the I/O priority of the request. optional #GCancellable object, %NULL to ignore. callback to call when the request is satisfied the data to pass to callback function Finishes a stream writev operation. %TRUE on success, %FALSE if there was an error a #GOutputStream. a #GAsyncResult. location to store the number of bytes that were written to the stream Tries to write the bytes contained in the @n_vectors @vectors into the stream. Will block during the operation. If @n_vectors is 0 or the sum of all bytes in @vectors is 0, returns 0 and does nothing. On success, the number of bytes written to the stream is returned. It is not an error if this is not the same as the requested size, as it can happen e.g. on a partial I/O error, or if there is not enough storage in the stream. All writes block until at least one byte is written or an error occurs; 0 is never returned (unless @n_vectors is 0 or the sum of all bytes in @vectors is 0). If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an operation was partially finished when the operation was cancelled the partial result will be returned, without an error. Some implementations of g_output_stream_writev() may have limitations on the aggregate buffer size, and will return %G_IO_ERROR_INVALID_ARGUMENT if these are exceeded. For example, when writing to a local file on UNIX platforms, the aggregate buffer size must not exceed %G_MAXSSIZE bytes. %TRUE on success, %FALSE if there was an error a #GOutputStream. the buffer containing the #GOutputVectors to write. the number of vectors to write location to store the number of bytes that were written to the stream optional cancellable object Clears the pending flag on @stream. output stream Closes the stream, releasing resources related to it. Once the stream is closed, all other operations will return %G_IO_ERROR_CLOSED. Closing a stream multiple times will not return an error. Closing a stream will automatically flush any outstanding buffers in the stream. Streams will be automatically closed when the last reference is dropped, but you might want to call this function to make sure resources are released as early as possible. Some streams might keep the backing store of the stream (e.g. a file descriptor) open after the stream is closed. See the documentation for the individual stream for details. On failure the first error that happened will be reported, but the close operation will finish as much as possible. A stream that failed to close will still return %G_IO_ERROR_CLOSED for all operations. Still, it is important to check and report the error to the user, otherwise there might be a loss of data as all data might not be written. If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. Cancelling a close will still leave the stream closed, but there some streams can use a faster close that doesn't block to e.g. check errors. On cancellation (as with any error) there is no guarantee that all written data will reach the target. %TRUE on success, %FALSE on failure A #GOutputStream. optional cancellable object Requests an asynchronous close of the stream, releasing resources related to it. When the operation is finished @callback will be called. You can then call g_output_stream_close_finish() to get the result of the operation. For behaviour details see g_output_stream_close(). The asynchronous methods have a default fallback that uses threads to implement asynchronicity, so they are optional for inheriting classes. However, if you override one you must override all. A #GOutputStream. the io priority of the request. optional cancellable object callback to call when the request is satisfied the data to pass to callback function Closes an output stream. %TRUE if stream was successfully closed, %FALSE otherwise. a #GOutputStream. a #GAsyncResult. Forces a write of all user-space buffered data for the given @stream. Will block during the operation. Closing the stream will implicitly cause a flush. This function is optional for inherited classes. If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. %TRUE on success, %FALSE on error a #GOutputStream. optional cancellable object Forces an asynchronous write of all user-space buffered data for the given @stream. For behaviour details see g_output_stream_flush(). When the operation is finished @callback will be called. You can then call g_output_stream_flush_finish() to get the result of the operation. a #GOutputStream. the io priority of the request. optional #GCancellable object, %NULL to ignore. a #GAsyncReadyCallback to call when the request is satisfied the data to pass to callback function Finishes flushing an output stream. %TRUE if flush operation succeeded, %FALSE otherwise. a #GOutputStream. a GAsyncResult. Checks if an output stream has pending actions. %TRUE if @stream has pending actions. a #GOutputStream. Checks if an output stream has already been closed. %TRUE if @stream is closed. %FALSE otherwise. a #GOutputStream. Checks if an output stream is being closed. This can be used inside e.g. a flush implementation to see if the flush (or other i/o operation) is called from within the closing operation. %TRUE if @stream is being closed. %FALSE otherwise. a #GOutputStream. This is a utility function around g_output_stream_write_all(). It uses g_strdup_vprintf() to turn @format and @... into a string that is then written to @stream. See the documentation of g_output_stream_write_all() about the behavior of the actual write operation. Note that partial writes cannot be properly checked with this function due to the variable length of the written string, if you need precise control over partial write failures, you need to create you own printf()-like wrapper around g_output_stream_write() or g_output_stream_write_all(). %TRUE on success, %FALSE if there was an error a #GOutputStream. location to store the number of bytes that was written to the stream optional #GCancellable object, %NULL to ignore. location to store the error occurring, or %NULL to ignore the format string. See the printf() documentation the parameters to insert into the format string Sets @stream to have actions pending. If the pending flag is already set or @stream is closed, it will return %FALSE and set @error. %TRUE if pending was previously unset and is now set. a #GOutputStream. Splices an input stream into an output stream. a #gssize containing the size of the data spliced, or -1 if an error occurred. Note that if the number of bytes spliced is greater than %G_MAXSSIZE, then that will be returned, and there is no way to determine the actual number of bytes spliced. a #GOutputStream. a #GInputStream. a set of #GOutputStreamSpliceFlags. optional #GCancellable object, %NULL to ignore. Splices a stream asynchronously. When the operation is finished @callback will be called. You can then call g_output_stream_splice_finish() to get the result of the operation. For the synchronous, blocking version of this function, see g_output_stream_splice(). a #GOutputStream. a #GInputStream. a set of #GOutputStreamSpliceFlags. the io priority of the request. optional #GCancellable object, %NULL to ignore. a #GAsyncReadyCallback. user data passed to @callback. Finishes an asynchronous stream splice operation. a #gssize of the number of bytes spliced. Note that if the number of bytes spliced is greater than %G_MAXSSIZE, then that will be returned, and there is no way to determine the actual number of bytes spliced. a #GOutputStream. a #GAsyncResult. This is a utility function around g_output_stream_write_all(). It uses g_strdup_vprintf() to turn @format and @args into a string that is then written to @stream. See the documentation of g_output_stream_write_all() about the behavior of the actual write operation. Note that partial writes cannot be properly checked with this function due to the variable length of the written string, if you need precise control over partial write failures, you need to create you own printf()-like wrapper around g_output_stream_write() or g_output_stream_write_all(). %TRUE on success, %FALSE if there was an error a #GOutputStream. location to store the number of bytes that was written to the stream optional #GCancellable object, %NULL to ignore. location to store the error occurring, or %NULL to ignore the format string. See the printf() documentation the parameters to insert into the format string Tries to write @count bytes from @buffer into the stream. Will block during the operation. If count is 0, returns 0 and does nothing. A value of @count larger than %G_MAXSSIZE will cause a %G_IO_ERROR_INVALID_ARGUMENT error. On success, the number of bytes written to the stream is returned. It is not an error if this is not the same as the requested size, as it can happen e.g. on a partial I/O error, or if there is not enough storage in the stream. All writes block until at least one byte is written or an error occurs; 0 is never returned (unless @count is 0). If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an operation was partially finished when the operation was cancelled the partial result will be returned, without an error. On error -1 is returned and @error is set accordingly. Number of bytes written, or -1 on error a #GOutputStream. the buffer containing the data to write. the number of bytes to write optional cancellable object Tries to write @count bytes from @buffer into the stream. Will block during the operation. This function is similar to g_output_stream_write(), except it tries to write as many bytes as requested, only stopping on an error. On a successful write of @count bytes, %TRUE is returned, and @bytes_written is set to @count. If there is an error during the operation %FALSE is returned and @error is set to indicate the error status. As a special exception to the normal conventions for functions that use #GError, if this function returns %FALSE (and sets @error) then @bytes_written will be set to the number of bytes that were successfully written before the error was encountered. This functionality is only available from C. If you need it from another language then you must write your own loop around g_output_stream_write(). %TRUE on success, %FALSE if there was an error a #GOutputStream. the buffer containing the data to write. the number of bytes to write location to store the number of bytes that was written to the stream optional #GCancellable object, %NULL to ignore. Request an asynchronous write of @count bytes from @buffer into the stream. When the operation is finished @callback will be called. You can then call g_output_stream_write_all_finish() to get the result of the operation. This is the asynchronous version of g_output_stream_write_all(). Call g_output_stream_write_all_finish() to collect the result. Any outstanding I/O request with higher priority (lower numerical value) will be executed before an outstanding request with lower priority. Default priority is %G_PRIORITY_DEFAULT. Note that no copy of @buffer will be made, so it must stay valid until @callback is called. A #GOutputStream the buffer containing the data to write the number of bytes to write the io priority of the request optional #GCancellable object, %NULL to ignore callback to call when the request is satisfied the data to pass to callback function Finishes an asynchronous stream write operation started with g_output_stream_write_all_async(). As a special exception to the normal conventions for functions that use #GError, if this function returns %FALSE (and sets @error) then @bytes_written will be set to the number of bytes that were successfully written before the error was encountered. This functionality is only available from C. If you need it from another language then you must write your own loop around g_output_stream_write_async(). %TRUE on success, %FALSE if there was an error a #GOutputStream a #GAsyncResult location to store the number of bytes that was written to the stream Request an asynchronous write of @count bytes from @buffer into the stream. When the operation is finished @callback will be called. You can then call g_output_stream_write_finish() to get the result of the operation. During an async request no other sync and async calls are allowed, and will result in %G_IO_ERROR_PENDING errors. A value of @count larger than %G_MAXSSIZE will cause a %G_IO_ERROR_INVALID_ARGUMENT error. On success, the number of bytes written will be passed to the @callback. It is not an error if this is not the same as the requested size, as it can happen e.g. on a partial I/O error, but generally we try to write as many bytes as requested. You are guaranteed that this method will never fail with %G_IO_ERROR_WOULD_BLOCK - if @stream can't accept more data, the method will just wait until this changes. Any outstanding I/O request with higher priority (lower numerical value) will be executed before an outstanding request with lower priority. Default priority is %G_PRIORITY_DEFAULT. The asynchronous methods have a default fallback that uses threads to implement asynchronicity, so they are optional for inheriting classes. However, if you override one you must override all. For the synchronous, blocking version of this function, see g_output_stream_write(). Note that no copy of @buffer will be made, so it must stay valid until @callback is called. See g_output_stream_write_bytes_async() for a #GBytes version that will automatically hold a reference to the contents (without copying) for the duration of the call. A #GOutputStream. the buffer containing the data to write. the number of bytes to write the io priority of the request. optional #GCancellable object, %NULL to ignore. callback to call when the request is satisfied the data to pass to callback function A wrapper function for g_output_stream_write() which takes a #GBytes as input. This can be more convenient for use by language bindings or in other cases where the refcounted nature of #GBytes is helpful over a bare pointer interface. However, note that this function may still perform partial writes, just like g_output_stream_write(). If that occurs, to continue writing, you will need to create a new #GBytes containing just the remaining bytes, using g_bytes_new_from_bytes(). Passing the same #GBytes instance multiple times potentially can result in duplicated data in the output stream. Number of bytes written, or -1 on error a #GOutputStream. the #GBytes to write optional cancellable object This function is similar to g_output_stream_write_async(), but takes a #GBytes as input. Due to the refcounted nature of #GBytes, this allows the stream to avoid taking a copy of the data. However, note that this function may still perform partial writes, just like g_output_stream_write_async(). If that occurs, to continue writing, you will need to create a new #GBytes containing just the remaining bytes, using g_bytes_new_from_bytes(). Passing the same #GBytes instance multiple times potentially can result in duplicated data in the output stream. For the synchronous, blocking version of this function, see g_output_stream_write_bytes(). A #GOutputStream. The bytes to write the io priority of the request. optional #GCancellable object, %NULL to ignore. callback to call when the request is satisfied the data to pass to callback function Finishes a stream write-from-#GBytes operation. a #gssize containing the number of bytes written to the stream. a #GOutputStream. a #GAsyncResult. Finishes a stream write operation. a #gssize containing the number of bytes written to the stream. a #GOutputStream. a #GAsyncResult. Tries to write the bytes contained in the @n_vectors @vectors into the stream. Will block during the operation. If @n_vectors is 0 or the sum of all bytes in @vectors is 0, returns 0 and does nothing. On success, the number of bytes written to the stream is returned. It is not an error if this is not the same as the requested size, as it can happen e.g. on a partial I/O error, or if there is not enough storage in the stream. All writes block until at least one byte is written or an error occurs; 0 is never returned (unless @n_vectors is 0 or the sum of all bytes in @vectors is 0). If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an operation was partially finished when the operation was cancelled the partial result will be returned, without an error. Some implementations of g_output_stream_writev() may have limitations on the aggregate buffer size, and will return %G_IO_ERROR_INVALID_ARGUMENT if these are exceeded. For example, when writing to a local file on UNIX platforms, the aggregate buffer size must not exceed %G_MAXSSIZE bytes. %TRUE on success, %FALSE if there was an error a #GOutputStream. the buffer containing the #GOutputVectors to write. the number of vectors to write location to store the number of bytes that were written to the stream optional cancellable object Tries to write the bytes contained in the @n_vectors @vectors into the stream. Will block during the operation. This function is similar to g_output_stream_writev(), except it tries to write as many bytes as requested, only stopping on an error. On a successful write of all @n_vectors vectors, %TRUE is returned, and @bytes_written is set to the sum of all the sizes of @vectors. If there is an error during the operation %FALSE is returned and @error is set to indicate the error status. As a special exception to the normal conventions for functions that use #GError, if this function returns %FALSE (and sets @error) then @bytes_written will be set to the number of bytes that were successfully written before the error was encountered. This functionality is only available from C. If you need it from another language then you must write your own loop around g_output_stream_write(). The content of the individual elements of @vectors might be changed by this function. %TRUE on success, %FALSE if there was an error a #GOutputStream. the buffer containing the #GOutputVectors to write. the number of vectors to write location to store the number of bytes that were written to the stream optional #GCancellable object, %NULL to ignore. Request an asynchronous write of the bytes contained in the @n_vectors @vectors into the stream. When the operation is finished @callback will be called. You can then call g_output_stream_writev_all_finish() to get the result of the operation. This is the asynchronous version of g_output_stream_writev_all(). Call g_output_stream_writev_all_finish() to collect the result. Any outstanding I/O request with higher priority (lower numerical value) will be executed before an outstanding request with lower priority. Default priority is %G_PRIORITY_DEFAULT. Note that no copy of @vectors will be made, so it must stay valid until @callback is called. The content of the individual elements of @vectors might be changed by this function. A #GOutputStream the buffer containing the #GOutputVectors to write. the number of vectors to write the I/O priority of the request optional #GCancellable object, %NULL to ignore callback to call when the request is satisfied the data to pass to callback function Finishes an asynchronous stream write operation started with g_output_stream_writev_all_async(). As a special exception to the normal conventions for functions that use #GError, if this function returns %FALSE (and sets @error) then @bytes_written will be set to the number of bytes that were successfully written before the error was encountered. This functionality is only available from C. If you need it from another language then you must write your own loop around g_output_stream_writev_async(). %TRUE on success, %FALSE if there was an error a #GOutputStream a #GAsyncResult location to store the number of bytes that were written to the stream Request an asynchronous write of the bytes contained in @n_vectors @vectors into the stream. When the operation is finished @callback will be called. You can then call g_output_stream_writev_finish() to get the result of the operation. During an async request no other sync and async calls are allowed, and will result in %G_IO_ERROR_PENDING errors. On success, the number of bytes written will be passed to the @callback. It is not an error if this is not the same as the requested size, as it can happen e.g. on a partial I/O error, but generally we try to write as many bytes as requested. You are guaranteed that this method will never fail with %G_IO_ERROR_WOULD_BLOCK — if @stream can't accept more data, the method will just wait until this changes. Any outstanding I/O request with higher priority (lower numerical value) will be executed before an outstanding request with lower priority. Default priority is %G_PRIORITY_DEFAULT. The asynchronous methods have a default fallback that uses threads to implement asynchronicity, so they are optional for inheriting classes. However, if you override one you must override all. For the synchronous, blocking version of this function, see g_output_stream_writev(). Note that no copy of @vectors will be made, so it must stay valid until @callback is called. A #GOutputStream. the buffer containing the #GOutputVectors to write. the number of vectors to write the I/O priority of the request. optional #GCancellable object, %NULL to ignore. callback to call when the request is satisfied the data to pass to callback function Finishes a stream writev operation. %TRUE on success, %FALSE if there was an error a #GOutputStream. a #GAsyncResult. location to store the number of bytes that were written to the stream Number of bytes written, or -1 on error a #GOutputStream. the buffer containing the data to write. the number of bytes to write optional cancellable object a #gssize containing the size of the data spliced, or -1 if an error occurred. Note that if the number of bytes spliced is greater than %G_MAXSSIZE, then that will be returned, and there is no way to determine the actual number of bytes spliced. a #GOutputStream. a #GInputStream. a set of #GOutputStreamSpliceFlags. optional #GCancellable object, %NULL to ignore. %TRUE on success, %FALSE on error a #GOutputStream. optional cancellable object A #GOutputStream. the buffer containing the data to write. the number of bytes to write the io priority of the request. optional #GCancellable object, %NULL to ignore. callback to call when the request is satisfied the data to pass to callback function a #gssize containing the number of bytes written to the stream. a #GOutputStream. a #GAsyncResult. a #GOutputStream. a #GInputStream. a set of #GOutputStreamSpliceFlags. the io priority of the request. optional #GCancellable object, %NULL to ignore. a #GAsyncReadyCallback. user data passed to @callback. a #gssize of the number of bytes spliced. Note that if the number of bytes spliced is greater than %G_MAXSSIZE, then that will be returned, and there is no way to determine the actual number of bytes spliced. a #GOutputStream. a #GAsyncResult. a #GOutputStream. the io priority of the request. optional #GCancellable object, %NULL to ignore. a #GAsyncReadyCallback to call when the request is satisfied the data to pass to callback function %TRUE if flush operation succeeded, %FALSE otherwise. a #GOutputStream. a GAsyncResult. A #GOutputStream. the io priority of the request. optional cancellable object callback to call when the request is satisfied the data to pass to callback function %TRUE if stream was successfully closed, %FALSE otherwise. a #GOutputStream. a #GAsyncResult. %TRUE on success, %FALSE if there was an error a #GOutputStream. the buffer containing the #GOutputVectors to write. the number of vectors to write location to store the number of bytes that were written to the stream optional cancellable object A #GOutputStream. the buffer containing the #GOutputVectors to write. the number of vectors to write the I/O priority of the request. optional #GCancellable object, %NULL to ignore. callback to call when the request is satisfied the data to pass to callback function %TRUE on success, %FALSE if there was an error a #GOutputStream. a #GAsyncResult. location to store the number of bytes that were written to the stream GOutputStreamSpliceFlags determine how streams should be spliced. Do not close either stream. Close the source stream after the splice. Close the target stream after the splice. Structure used for scatter/gather data output. You generally pass in an array of #GOutputVectors and the operation will use all the buffers as if they were one buffer. Pointer to a buffer of data to read. the size of @buffer. Extension point for proxy functionality. See [Extending GIO][extending-gio]. Extension point for proxy resolving functionality. See [Extending GIO][extending-gio]. #GPasswordSave is used to indicate the lifespan of a saved password. #Gvfs stores passwords in the Gnome keyring when this flag allows it to, and later retrieves it again from there. never save a password. save a password for the session. save a password permanently. A #GPermission represents the status of the caller's permission to perform a certain action. You can query if the action is currently allowed and if it is possible to acquire the permission so that the action will be allowed in the future. There is also an API to actually acquire the permission and one to release it. As an example, a #GPermission might represent the ability for the user to write to a #GSettings object. This #GPermission object could then be used to decide if it is appropriate to show a "Click here to unlock" button in a dialog and to provide the mechanism to invoke when that button is clicked. Attempts to acquire the permission represented by @permission. The precise method by which this happens depends on the permission and the underlying authentication mechanism. A simple example is that a dialog may appear asking the user to enter their password. You should check with g_permission_get_can_acquire() before calling this function. If the permission is acquired then %TRUE is returned. Otherwise, %FALSE is returned and @error is set appropriately. This call is blocking, likely for a very long time (in the case that user interaction is required). See g_permission_acquire_async() for the non-blocking version. %TRUE if the permission was successfully acquired a #GPermission instance a #GCancellable, or %NULL Attempts to acquire the permission represented by @permission. This is the first half of the asynchronous version of g_permission_acquire(). a #GPermission instance a #GCancellable, or %NULL the #GAsyncReadyCallback to call when done the user data to pass to @callback Collects the result of attempting to acquire the permission represented by @permission. This is the second half of the asynchronous version of g_permission_acquire(). %TRUE if the permission was successfully acquired a #GPermission instance the #GAsyncResult given to the #GAsyncReadyCallback Attempts to release the permission represented by @permission. The precise method by which this happens depends on the permission and the underlying authentication mechanism. In most cases the permission will be dropped immediately without further action. You should check with g_permission_get_can_release() before calling this function. If the permission is released then %TRUE is returned. Otherwise, %FALSE is returned and @error is set appropriately. This call is blocking, likely for a very long time (in the case that user interaction is required). See g_permission_release_async() for the non-blocking version. %TRUE if the permission was successfully released a #GPermission instance a #GCancellable, or %NULL Attempts to release the permission represented by @permission. This is the first half of the asynchronous version of g_permission_release(). a #GPermission instance a #GCancellable, or %NULL the #GAsyncReadyCallback to call when done the user data to pass to @callback Collects the result of attempting to release the permission represented by @permission. This is the second half of the asynchronous version of g_permission_release(). %TRUE if the permission was successfully released a #GPermission instance the #GAsyncResult given to the #GAsyncReadyCallback Attempts to acquire the permission represented by @permission. The precise method by which this happens depends on the permission and the underlying authentication mechanism. A simple example is that a dialog may appear asking the user to enter their password. You should check with g_permission_get_can_acquire() before calling this function. If the permission is acquired then %TRUE is returned. Otherwise, %FALSE is returned and @error is set appropriately. This call is blocking, likely for a very long time (in the case that user interaction is required). See g_permission_acquire_async() for the non-blocking version. %TRUE if the permission was successfully acquired a #GPermission instance a #GCancellable, or %NULL Attempts to acquire the permission represented by @permission. This is the first half of the asynchronous version of g_permission_acquire(). a #GPermission instance a #GCancellable, or %NULL the #GAsyncReadyCallback to call when done the user data to pass to @callback Collects the result of attempting to acquire the permission represented by @permission. This is the second half of the asynchronous version of g_permission_acquire(). %TRUE if the permission was successfully acquired a #GPermission instance the #GAsyncResult given to the #GAsyncReadyCallback Gets the value of the 'allowed' property. This property is %TRUE if the caller currently has permission to perform the action that @permission represents the permission to perform. the value of the 'allowed' property a #GPermission instance Gets the value of the 'can-acquire' property. This property is %TRUE if it is generally possible to acquire the permission by calling g_permission_acquire(). the value of the 'can-acquire' property a #GPermission instance Gets the value of the 'can-release' property. This property is %TRUE if it is generally possible to release the permission by calling g_permission_release(). the value of the 'can-release' property a #GPermission instance This function is called by the #GPermission implementation to update the properties of the permission. You should never call this function except from a #GPermission implementation. GObject notify signals are generated, as appropriate. a #GPermission instance the new value for the 'allowed' property the new value for the 'can-acquire' property the new value for the 'can-release' property Attempts to release the permission represented by @permission. The precise method by which this happens depends on the permission and the underlying authentication mechanism. In most cases the permission will be dropped immediately without further action. You should check with g_permission_get_can_release() before calling this function. If the permission is released then %TRUE is returned. Otherwise, %FALSE is returned and @error is set appropriately. This call is blocking, likely for a very long time (in the case that user interaction is required). See g_permission_release_async() for the non-blocking version. %TRUE if the permission was successfully released a #GPermission instance a #GCancellable, or %NULL Attempts to release the permission represented by @permission. This is the first half of the asynchronous version of g_permission_release(). a #GPermission instance a #GCancellable, or %NULL the #GAsyncReadyCallback to call when done the user data to pass to @callback Collects the result of attempting to release the permission represented by @permission. This is the second half of the asynchronous version of g_permission_release(). %TRUE if the permission was successfully released a #GPermission instance the #GAsyncResult given to the #GAsyncReadyCallback %TRUE if the caller currently has permission to perform the action that @permission represents the permission to perform. %TRUE if it is generally possible to acquire the permission by calling g_permission_acquire(). %TRUE if it is generally possible to release the permission by calling g_permission_release(). %TRUE if the permission was successfully acquired a #GPermission instance a #GCancellable, or %NULL a #GPermission instance a #GCancellable, or %NULL the #GAsyncReadyCallback to call when done the user data to pass to @callback %TRUE if the permission was successfully acquired a #GPermission instance the #GAsyncResult given to the #GAsyncReadyCallback %TRUE if the permission was successfully released a #GPermission instance a #GCancellable, or %NULL a #GPermission instance a #GCancellable, or %NULL the #GAsyncReadyCallback to call when done the user data to pass to @callback %TRUE if the permission was successfully released a #GPermission instance the #GAsyncResult given to the #GAsyncReadyCallback #GPollableInputStream is implemented by #GInputStreams that can be polled for readiness to read. This can be used when interfacing with a non-GIO API that expects UNIX-file-descriptor-style asynchronous I/O rather than GIO-style. Checks if @stream is actually pollable. Some classes may implement #GPollableInputStream but have only certain instances of that class be pollable. If this method returns %FALSE, then the behavior of other #GPollableInputStream methods is undefined. For any given stream, the value returned by this method is constant; a stream cannot switch from pollable to non-pollable or vice versa. %TRUE if @stream is pollable, %FALSE if not. a #GPollableInputStream. Creates a #GSource that triggers when @stream can be read, or @cancellable is triggered or an error occurs. The callback on the source is of the #GPollableSourceFunc type. As with g_pollable_input_stream_is_readable(), it is possible that the stream may not actually be readable even after the source triggers, so you should use g_pollable_input_stream_read_nonblocking() rather than g_input_stream_read() from the callback. a new #GSource a #GPollableInputStream. a #GCancellable, or %NULL Checks if @stream can be read. Note that some stream types may not be able to implement this 100% reliably, and it is possible that a call to g_input_stream_read() after this returns %TRUE would still block. To guarantee non-blocking behavior, you should always use g_pollable_input_stream_read_nonblocking(), which will return a %G_IO_ERROR_WOULD_BLOCK error rather than blocking. %TRUE if @stream is readable, %FALSE if not. If an error has occurred on @stream, this will result in g_pollable_input_stream_is_readable() returning %TRUE, and the next attempt to read will return the error. a #GPollableInputStream. Attempts to read up to @count bytes from @stream into @buffer, as with g_input_stream_read(). If @stream is not currently readable, this will immediately return %G_IO_ERROR_WOULD_BLOCK, and you can use g_pollable_input_stream_create_source() to create a #GSource that will be triggered when @stream is readable. Note that since this method never blocks, you cannot actually use @cancellable to cancel it. However, it will return an error if @cancellable has already been cancelled when you call, which may happen if you call this method after a source triggers due to having been cancelled. the number of bytes read, or -1 on error (including %G_IO_ERROR_WOULD_BLOCK). a #GPollableInputStream a buffer to read data into (which should be at least @count bytes long). the number of bytes you want to read Checks if @stream is actually pollable. Some classes may implement #GPollableInputStream but have only certain instances of that class be pollable. If this method returns %FALSE, then the behavior of other #GPollableInputStream methods is undefined. For any given stream, the value returned by this method is constant; a stream cannot switch from pollable to non-pollable or vice versa. %TRUE if @stream is pollable, %FALSE if not. a #GPollableInputStream. Creates a #GSource that triggers when @stream can be read, or @cancellable is triggered or an error occurs. The callback on the source is of the #GPollableSourceFunc type. As with g_pollable_input_stream_is_readable(), it is possible that the stream may not actually be readable even after the source triggers, so you should use g_pollable_input_stream_read_nonblocking() rather than g_input_stream_read() from the callback. a new #GSource a #GPollableInputStream. a #GCancellable, or %NULL Checks if @stream can be read. Note that some stream types may not be able to implement this 100% reliably, and it is possible that a call to g_input_stream_read() after this returns %TRUE would still block. To guarantee non-blocking behavior, you should always use g_pollable_input_stream_read_nonblocking(), which will return a %G_IO_ERROR_WOULD_BLOCK error rather than blocking. %TRUE if @stream is readable, %FALSE if not. If an error has occurred on @stream, this will result in g_pollable_input_stream_is_readable() returning %TRUE, and the next attempt to read will return the error. a #GPollableInputStream. Attempts to read up to @count bytes from @stream into @buffer, as with g_input_stream_read(). If @stream is not currently readable, this will immediately return %G_IO_ERROR_WOULD_BLOCK, and you can use g_pollable_input_stream_create_source() to create a #GSource that will be triggered when @stream is readable. Note that since this method never blocks, you cannot actually use @cancellable to cancel it. However, it will return an error if @cancellable has already been cancelled when you call, which may happen if you call this method after a source triggers due to having been cancelled. the number of bytes read, or -1 on error (including %G_IO_ERROR_WOULD_BLOCK). a #GPollableInputStream a buffer to read data into (which should be at least @count bytes long). the number of bytes you want to read a #GCancellable, or %NULL The interface for pollable input streams. The default implementation of @can_poll always returns %TRUE. The default implementation of @read_nonblocking calls g_pollable_input_stream_is_readable(), and then calls g_input_stream_read() if it returns %TRUE. This means you only need to override it if it is possible that your @is_readable implementation may return %TRUE when the stream is not actually readable. The parent interface. %TRUE if @stream is pollable, %FALSE if not. a #GPollableInputStream. %TRUE if @stream is readable, %FALSE if not. If an error has occurred on @stream, this will result in g_pollable_input_stream_is_readable() returning %TRUE, and the next attempt to read will return the error. a #GPollableInputStream. a new #GSource a #GPollableInputStream. a #GCancellable, or %NULL the number of bytes read, or -1 on error (including %G_IO_ERROR_WOULD_BLOCK). a #GPollableInputStream a buffer to read data into (which should be at least @count bytes long). the number of bytes you want to read #GPollableOutputStream is implemented by #GOutputStreams that can be polled for readiness to write. This can be used when interfacing with a non-GIO API that expects UNIX-file-descriptor-style asynchronous I/O rather than GIO-style. Checks if @stream is actually pollable. Some classes may implement #GPollableOutputStream but have only certain instances of that class be pollable. If this method returns %FALSE, then the behavior of other #GPollableOutputStream methods is undefined. For any given stream, the value returned by this method is constant; a stream cannot switch from pollable to non-pollable or vice versa. %TRUE if @stream is pollable, %FALSE if not. a #GPollableOutputStream. Creates a #GSource that triggers when @stream can be written, or @cancellable is triggered or an error occurs. The callback on the source is of the #GPollableSourceFunc type. As with g_pollable_output_stream_is_writable(), it is possible that the stream may not actually be writable even after the source triggers, so you should use g_pollable_output_stream_write_nonblocking() rather than g_output_stream_write() from the callback. a new #GSource a #GPollableOutputStream. a #GCancellable, or %NULL Checks if @stream can be written. Note that some stream types may not be able to implement this 100% reliably, and it is possible that a call to g_output_stream_write() after this returns %TRUE would still block. To guarantee non-blocking behavior, you should always use g_pollable_output_stream_write_nonblocking(), which will return a %G_IO_ERROR_WOULD_BLOCK error rather than blocking. %TRUE if @stream is writable, %FALSE if not. If an error has occurred on @stream, this will result in g_pollable_output_stream_is_writable() returning %TRUE, and the next attempt to write will return the error. a #GPollableOutputStream. Attempts to write up to @count bytes from @buffer to @stream, as with g_output_stream_write(). If @stream is not currently writable, this will immediately return %G_IO_ERROR_WOULD_BLOCK, and you can use g_pollable_output_stream_create_source() to create a #GSource that will be triggered when @stream is writable. Note that since this method never blocks, you cannot actually use @cancellable to cancel it. However, it will return an error if @cancellable has already been cancelled when you call, which may happen if you call this method after a source triggers due to having been cancelled. Also note that if %G_IO_ERROR_WOULD_BLOCK is returned some underlying transports like D/TLS require that you re-send the same @buffer and @count in the next write call. the number of bytes written, or -1 on error (including %G_IO_ERROR_WOULD_BLOCK). a #GPollableOutputStream a buffer to write data from the number of bytes you want to write Attempts to write the bytes contained in the @n_vectors @vectors to @stream, as with g_output_stream_writev(). If @stream is not currently writable, this will immediately return %@G_POLLABLE_RETURN_WOULD_BLOCK, and you can use g_pollable_output_stream_create_source() to create a #GSource that will be triggered when @stream is writable. @error will *not* be set in that case. Note that since this method never blocks, you cannot actually use @cancellable to cancel it. However, it will return an error if @cancellable has already been cancelled when you call, which may happen if you call this method after a source triggers due to having been cancelled. Also note that if %G_POLLABLE_RETURN_WOULD_BLOCK is returned some underlying transports like D/TLS require that you re-send the same @vectors and @n_vectors in the next write call. %@G_POLLABLE_RETURN_OK on success, %G_POLLABLE_RETURN_WOULD_BLOCK if the stream is not currently writable (and @error is *not* set), or %G_POLLABLE_RETURN_FAILED if there was an error in which case @error will be set. a #GPollableOutputStream the buffer containing the #GOutputVectors to write. the number of vectors to write location to store the number of bytes that were written to the stream Checks if @stream is actually pollable. Some classes may implement #GPollableOutputStream but have only certain instances of that class be pollable. If this method returns %FALSE, then the behavior of other #GPollableOutputStream methods is undefined. For any given stream, the value returned by this method is constant; a stream cannot switch from pollable to non-pollable or vice versa. %TRUE if @stream is pollable, %FALSE if not. a #GPollableOutputStream. Creates a #GSource that triggers when @stream can be written, or @cancellable is triggered or an error occurs. The callback on the source is of the #GPollableSourceFunc type. As with g_pollable_output_stream_is_writable(), it is possible that the stream may not actually be writable even after the source triggers, so you should use g_pollable_output_stream_write_nonblocking() rather than g_output_stream_write() from the callback. a new #GSource a #GPollableOutputStream. a #GCancellable, or %NULL Checks if @stream can be written. Note that some stream types may not be able to implement this 100% reliably, and it is possible that a call to g_output_stream_write() after this returns %TRUE would still block. To guarantee non-blocking behavior, you should always use g_pollable_output_stream_write_nonblocking(), which will return a %G_IO_ERROR_WOULD_BLOCK error rather than blocking. %TRUE if @stream is writable, %FALSE if not. If an error has occurred on @stream, this will result in g_pollable_output_stream_is_writable() returning %TRUE, and the next attempt to write will return the error. a #GPollableOutputStream. Attempts to write up to @count bytes from @buffer to @stream, as with g_output_stream_write(). If @stream is not currently writable, this will immediately return %G_IO_ERROR_WOULD_BLOCK, and you can use g_pollable_output_stream_create_source() to create a #GSource that will be triggered when @stream is writable. Note that since this method never blocks, you cannot actually use @cancellable to cancel it. However, it will return an error if @cancellable has already been cancelled when you call, which may happen if you call this method after a source triggers due to having been cancelled. Also note that if %G_IO_ERROR_WOULD_BLOCK is returned some underlying transports like D/TLS require that you re-send the same @buffer and @count in the next write call. the number of bytes written, or -1 on error (including %G_IO_ERROR_WOULD_BLOCK). a #GPollableOutputStream a buffer to write data from the number of bytes you want to write a #GCancellable, or %NULL Attempts to write the bytes contained in the @n_vectors @vectors to @stream, as with g_output_stream_writev(). If @stream is not currently writable, this will immediately return %@G_POLLABLE_RETURN_WOULD_BLOCK, and you can use g_pollable_output_stream_create_source() to create a #GSource that will be triggered when @stream is writable. @error will *not* be set in that case. Note that since this method never blocks, you cannot actually use @cancellable to cancel it. However, it will return an error if @cancellable has already been cancelled when you call, which may happen if you call this method after a source triggers due to having been cancelled. Also note that if %G_POLLABLE_RETURN_WOULD_BLOCK is returned some underlying transports like D/TLS require that you re-send the same @vectors and @n_vectors in the next write call. %@G_POLLABLE_RETURN_OK on success, %G_POLLABLE_RETURN_WOULD_BLOCK if the stream is not currently writable (and @error is *not* set), or %G_POLLABLE_RETURN_FAILED if there was an error in which case @error will be set. a #GPollableOutputStream the buffer containing the #GOutputVectors to write. the number of vectors to write location to store the number of bytes that were written to the stream a #GCancellable, or %NULL The interface for pollable output streams. The default implementation of @can_poll always returns %TRUE. The default implementation of @write_nonblocking calls g_pollable_output_stream_is_writable(), and then calls g_output_stream_write() if it returns %TRUE. This means you only need to override it if it is possible that your @is_writable implementation may return %TRUE when the stream is not actually writable. The default implementation of @writev_nonblocking calls g_pollable_output_stream_write_nonblocking() for each vector, and converts its return value and error (if set) to a #GPollableReturn. You should override this where possible to avoid having to allocate a #GError to return %G_IO_ERROR_WOULD_BLOCK. The parent interface. %TRUE if @stream is pollable, %FALSE if not. a #GPollableOutputStream. %TRUE if @stream is writable, %FALSE if not. If an error has occurred on @stream, this will result in g_pollable_output_stream_is_writable() returning %TRUE, and the next attempt to write will return the error. a #GPollableOutputStream. a new #GSource a #GPollableOutputStream. a #GCancellable, or %NULL the number of bytes written, or -1 on error (including %G_IO_ERROR_WOULD_BLOCK). a #GPollableOutputStream a buffer to write data from the number of bytes you want to write %@G_POLLABLE_RETURN_OK on success, %G_POLLABLE_RETURN_WOULD_BLOCK if the stream is not currently writable (and @error is *not* set), or %G_POLLABLE_RETURN_FAILED if there was an error in which case @error will be set. a #GPollableOutputStream the buffer containing the #GOutputVectors to write. the number of vectors to write location to store the number of bytes that were written to the stream Return value for various IO operations that signal errors via the return value and not necessarily via a #GError. This enum exists to be able to return errors to callers without having to allocate a #GError. Allocating #GErrors can be quite expensive for regularly happening errors like %G_IO_ERROR_WOULD_BLOCK. In case of %G_POLLABLE_RETURN_FAILED a #GError should be set for the operation to give details about the error that happened. Generic error condition for when an operation fails. The operation was successfully finished. The operation would block. This is the function type of the callback used for the #GSource returned by g_pollable_input_stream_create_source() and g_pollable_output_stream_create_source(). it should return %FALSE if the source should be removed. the #GPollableInputStream or #GPollableOutputStream data passed in by the user. A #GPropertyAction is a way to get a #GAction with a state value reflecting and controlling the value of a #GObject property. The state of the action will correspond to the value of the property. Changing it will change the property (assuming the requested value matches the requirements as specified in the #GParamSpec). Only the most common types are presently supported. Booleans are mapped to booleans, strings to strings, signed/unsigned integers to int32/uint32 and floats and doubles to doubles. If the property is an enum then the state will be string-typed and conversion will automatically be performed between the enum value and "nick" string as per the #GEnumValue table. Flags types are not currently supported. Properties of object types, boxed types and pointer types are not supported and probably never will be. Properties of #GVariant types are not currently supported. If the property is boolean-valued then the action will have a NULL parameter type, and activating the action (with no parameter) will toggle the value of the property. In all other cases, the parameter type will correspond to the type of the property. The general idea here is to reduce the number of locations where a particular piece of state is kept (and therefore has to be synchronised between). #GPropertyAction does not have a separate state that is kept in sync with the property value -- its state is the property value. For example, it might be useful to create a #GAction corresponding to the "visible-child-name" property of a #GtkStack so that the current page can be switched from a menu. The active radio indication in the menu is then directly determined from the active page of the #GtkStack. An anti-example would be binding the "active-id" property on a #GtkComboBox. This is because the state of the combobox itself is probably uninteresting and is actually being used to control something else. Another anti-example would be to bind to the "visible-child-name" property of a #GtkStack if this value is actually stored in #GSettings. In that case, the real source of the value is #GSettings. If you want a #GAction to control a setting stored in #GSettings, see g_settings_create_action() instead, and possibly combine its use with g_settings_bind(). Creates a #GAction corresponding to the value of property @property_name on @object. The property must be existent and readable and writable (and not construct-only). This function takes a reference on @object and doesn't release it until the action is destroyed. a new #GPropertyAction the name of the action to create the object that has the property to wrap the name of the property If @action is currently enabled. If the action is disabled then calls to g_action_activate() and g_action_change_state() have no effect. If %TRUE, the state of the action will be the negation of the property value, provided the property is boolean. The name of the action. This is mostly meaningful for identifying the action once it has been added to a #GActionMap. The object to wrap a property on. The object must be a non-%NULL #GObject with properties. The type of the parameter that must be given when activating the action. The name of the property to wrap on the object. The property must exist on the passed-in object and it must be readable and writable (and not construct-only). The state of the action, or %NULL if the action is stateless. The #GVariantType of the state that the action has, or %NULL if the action is stateless. A #GProxy handles connecting to a remote host via a given type of proxy server. It is implemented by the 'gio-proxy' extension point. The extensions are named after their proxy protocol name. As an example, a SOCKS5 proxy implementation can be retrieved with the name 'socks5' using the function g_io_extension_point_get_extension_by_name(). Find the `gio-proxy` extension point for a proxy implementation that supports the specified protocol. return a #GProxy or NULL if protocol is not supported. the proxy protocol name (e.g. http, socks, etc) Given @connection to communicate with a proxy (eg, a #GSocketConnection that is connected to the proxy server), this does the necessary handshake to connect to @proxy_address, and if required, wraps the #GIOStream to handle proxy payload. a #GIOStream that will replace @connection. This might be the same as @connection, in which case a reference will be added. a #GProxy a #GIOStream a #GProxyAddress a #GCancellable Asynchronous version of g_proxy_connect(). a #GProxy a #GIOStream a #GProxyAddress a #GCancellable a #GAsyncReadyCallback callback data See g_proxy_connect(). a #GIOStream. a #GProxy a #GAsyncResult Some proxy protocols expect to be passed a hostname, which they will resolve to an IP address themselves. Others, like SOCKS4, do not allow this. This function will return %FALSE if @proxy is implementing such a protocol. When %FALSE is returned, the caller should resolve the destination hostname first, and then pass a #GProxyAddress containing the stringified IP address to g_proxy_connect() or g_proxy_connect_async(). %TRUE if hostname resolution is supported. a #GProxy Given @connection to communicate with a proxy (eg, a #GSocketConnection that is connected to the proxy server), this does the necessary handshake to connect to @proxy_address, and if required, wraps the #GIOStream to handle proxy payload. a #GIOStream that will replace @connection. This might be the same as @connection, in which case a reference will be added. a #GProxy a #GIOStream a #GProxyAddress a #GCancellable Asynchronous version of g_proxy_connect(). a #GProxy a #GIOStream a #GProxyAddress a #GCancellable a #GAsyncReadyCallback callback data See g_proxy_connect(). a #GIOStream. a #GProxy a #GAsyncResult Some proxy protocols expect to be passed a hostname, which they will resolve to an IP address themselves. Others, like SOCKS4, do not allow this. This function will return %FALSE if @proxy is implementing such a protocol. When %FALSE is returned, the caller should resolve the destination hostname first, and then pass a #GProxyAddress containing the stringified IP address to g_proxy_connect() or g_proxy_connect_async(). %TRUE if hostname resolution is supported. a #GProxy Support for proxied #GInetSocketAddress. Creates a new #GProxyAddress for @inetaddr with @protocol that should tunnel through @dest_hostname and @dest_port. (Note that this method doesn't set the #GProxyAddress:uri or #GProxyAddress:destination-protocol fields; use g_object_new() directly if you want to set those.) a new #GProxyAddress The proxy server #GInetAddress. The proxy server port. The proxy protocol to support, in lower case (e.g. socks, http). The destination hostname the proxy should tunnel to. The destination port to tunnel to. The username to authenticate to the proxy server (or %NULL). The password to authenticate to the proxy server (or %NULL). Gets @proxy's destination hostname; that is, the name of the host that will be connected to via the proxy, not the name of the proxy itself. the @proxy's destination hostname a #GProxyAddress Gets @proxy's destination port; that is, the port on the destination host that will be connected to via the proxy, not the port number of the proxy itself. the @proxy's destination port a #GProxyAddress Gets the protocol that is being spoken to the destination server; eg, "http" or "ftp". the @proxy's destination protocol a #GProxyAddress Gets @proxy's password. the @proxy's password a #GProxyAddress Gets @proxy's protocol. eg, "socks" or "http" the @proxy's protocol a #GProxyAddress Gets the proxy URI that @proxy was constructed from. the @proxy's URI, or %NULL if unknown a #GProxyAddress Gets @proxy's username. the @proxy's username a #GProxyAddress The protocol being spoke to the destination host, or %NULL if the #GProxyAddress doesn't know. The URI string that the proxy was constructed from (or %NULL if the creator didn't specify this). Class structure for #GProxyAddress. #GProxyAddressEnumerator is a wrapper around #GSocketAddressEnumerator which takes the #GSocketAddress instances returned by the #GSocketAddressEnumerator and wraps them in #GProxyAddress instances, using the given #GProxyAddressEnumerator:proxy-resolver. This enumerator will be returned (for example, by g_socket_connectable_enumerate()) as appropriate when a proxy is configured; there should be no need to manually wrap a #GSocketAddressEnumerator instance with one. The default port to use if #GProxyAddressEnumerator:uri does not specify one. The proxy resolver to use. Class structure for #GProxyAddressEnumerator. Provides an interface for handling proxy connection and payload. The parent interface. a #GIOStream that will replace @connection. This might be the same as @connection, in which case a reference will be added. a #GProxy a #GIOStream a #GProxyAddress a #GCancellable a #GProxy a #GIOStream a #GProxyAddress a #GCancellable a #GAsyncReadyCallback callback data a #GIOStream. a #GProxy a #GAsyncResult %TRUE if hostname resolution is supported. a #GProxy #GProxyResolver provides synchronous and asynchronous network proxy resolution. #GProxyResolver is used within #GSocketClient through the method g_socket_connectable_proxy_enumerate(). Implementations of #GProxyResolver based on libproxy and GNOME settings can be found in glib-networking. GIO comes with an implementation for use inside Flatpak portals. Gets the default #GProxyResolver for the system. the default #GProxyResolver. Checks if @resolver can be used on this system. (This is used internally; g_proxy_resolver_get_default() will only return a proxy resolver that returns %TRUE for this method.) %TRUE if @resolver is supported. a #GProxyResolver Looks into the system proxy configuration to determine what proxy, if any, to use to connect to @uri. The returned proxy URIs are of the form `<protocol>://[user[:password]@]host:port` or `direct://`, where <protocol> could be http, rtsp, socks or other proxying protocol. If you don't know what network protocol is being used on the socket, you should use `none` as the URI protocol. In this case, the resolver might still return a generic proxy type (such as SOCKS), but would not return protocol-specific proxy types (such as http). `direct://` is used when no proxy is needed. Direct connection should not be attempted unless it is part of the returned array of proxies. A NULL-terminated array of proxy URIs. Must be freed with g_strfreev(). a #GProxyResolver a URI representing the destination to connect to a #GCancellable, or %NULL Asynchronous lookup of proxy. See g_proxy_resolver_lookup() for more details. a #GProxyResolver a URI representing the destination to connect to a #GCancellable, or %NULL callback to call after resolution completes data for @callback Call this function to obtain the array of proxy URIs when g_proxy_resolver_lookup_async() is complete. See g_proxy_resolver_lookup() for more details. A NULL-terminated array of proxy URIs. Must be freed with g_strfreev(). a #GProxyResolver the result passed to your #GAsyncReadyCallback Checks if @resolver can be used on this system. (This is used internally; g_proxy_resolver_get_default() will only return a proxy resolver that returns %TRUE for this method.) %TRUE if @resolver is supported. a #GProxyResolver Looks into the system proxy configuration to determine what proxy, if any, to use to connect to @uri. The returned proxy URIs are of the form `<protocol>://[user[:password]@]host:port` or `direct://`, where <protocol> could be http, rtsp, socks or other proxying protocol. If you don't know what network protocol is being used on the socket, you should use `none` as the URI protocol. In this case, the resolver might still return a generic proxy type (such as SOCKS), but would not return protocol-specific proxy types (such as http). `direct://` is used when no proxy is needed. Direct connection should not be attempted unless it is part of the returned array of proxies. A NULL-terminated array of proxy URIs. Must be freed with g_strfreev(). a #GProxyResolver a URI representing the destination to connect to a #GCancellable, or %NULL Asynchronous lookup of proxy. See g_proxy_resolver_lookup() for more details. a #GProxyResolver a URI representing the destination to connect to a #GCancellable, or %NULL callback to call after resolution completes data for @callback Call this function to obtain the array of proxy URIs when g_proxy_resolver_lookup_async() is complete. See g_proxy_resolver_lookup() for more details. A NULL-terminated array of proxy URIs. Must be freed with g_strfreev(). a #GProxyResolver the result passed to your #GAsyncReadyCallback The virtual function table for #GProxyResolver. The parent interface. %TRUE if @resolver is supported. a #GProxyResolver A NULL-terminated array of proxy URIs. Must be freed with g_strfreev(). a #GProxyResolver a URI representing the destination to connect to a #GCancellable, or %NULL a #GProxyResolver a URI representing the destination to connect to a #GCancellable, or %NULL callback to call after resolution completes data for @callback A NULL-terminated array of proxy URIs. Must be freed with g_strfreev(). a #GProxyResolver the result passed to your #GAsyncReadyCallback Changes the size of the memory block pointed to by @data to @size bytes. The function should have the same semantics as realloc(). a pointer to the reallocated memory memory block to reallocate size to reallocate @data to The GRemoteActionGroup interface is implemented by #GActionGroup instances that either transmit action invocations to other processes or receive action invocations in the local process from other processes. The interface has `_full` variants of the two methods on #GActionGroup used to activate actions: g_action_group_activate_action() and g_action_group_change_action_state(). These variants allow a "platform data" #GVariant to be specified: a dictionary providing context for the action invocation (for example: timestamps, startup notification IDs, etc). #GDBusActionGroup implements #GRemoteActionGroup. This provides a mechanism to send platform data for action invocations over D-Bus. Additionally, g_dbus_connection_export_action_group() will check if the exported #GActionGroup implements #GRemoteActionGroup and use the `_full` variants of the calls if available. This provides a mechanism by which to receive platform data for action invocations that arrive by way of D-Bus. Activates the remote action. This is the same as g_action_group_activate_action() except that it allows for provision of "platform data" to be sent along with the activation request. This typically contains details such as the user interaction timestamp or startup notification information. @platform_data must be non-%NULL and must have the type %G_VARIANT_TYPE_VARDICT. If it is floating, it will be consumed. a #GDBusActionGroup the name of the action to activate the optional parameter to the activation the platform data to send Changes the state of a remote action. This is the same as g_action_group_change_action_state() except that it allows for provision of "platform data" to be sent along with the state change request. This typically contains details such as the user interaction timestamp or startup notification information. @platform_data must be non-%NULL and must have the type %G_VARIANT_TYPE_VARDICT. If it is floating, it will be consumed. a #GRemoteActionGroup the name of the action to change the state of the new requested value for the state the platform data to send Activates the remote action. This is the same as g_action_group_activate_action() except that it allows for provision of "platform data" to be sent along with the activation request. This typically contains details such as the user interaction timestamp or startup notification information. @platform_data must be non-%NULL and must have the type %G_VARIANT_TYPE_VARDICT. If it is floating, it will be consumed. a #GDBusActionGroup the name of the action to activate the optional parameter to the activation the platform data to send Changes the state of a remote action. This is the same as g_action_group_change_action_state() except that it allows for provision of "platform data" to be sent along with the state change request. This typically contains details such as the user interaction timestamp or startup notification information. @platform_data must be non-%NULL and must have the type %G_VARIANT_TYPE_VARDICT. If it is floating, it will be consumed. a #GRemoteActionGroup the name of the action to change the state of the new requested value for the state the platform data to send The virtual function table for #GRemoteActionGroup. a #GDBusActionGroup the name of the action to activate the optional parameter to the activation the platform data to send a #GRemoteActionGroup the name of the action to change the state of the new requested value for the state the platform data to send #GResolver provides cancellable synchronous and asynchronous DNS resolution, for hostnames (g_resolver_lookup_by_address(), g_resolver_lookup_by_name() and their async variants) and SRV (service) records (g_resolver_lookup_service()). #GNetworkAddress and #GNetworkService provide wrappers around #GResolver functionality that also implement #GSocketConnectable, making it easy to connect to a remote host/service. Frees @addresses (which should be the return value from g_resolver_lookup_by_name() or g_resolver_lookup_by_name_finish()). (This is a convenience method; you can also simply free the results by hand.) a #GList of #GInetAddress Frees @targets (which should be the return value from g_resolver_lookup_service() or g_resolver_lookup_service_finish()). (This is a convenience method; you can also simply free the results by hand.) a #GList of #GSrvTarget Gets the default #GResolver. You should unref it when you are done with it. #GResolver may use its reference count as a hint about how many threads it should allocate for concurrent DNS resolutions. the default #GResolver. Synchronously reverse-resolves @address to determine its associated hostname. If the DNS resolution fails, @error (if non-%NULL) will be set to a value from #GResolverError. If @cancellable is non-%NULL, it can be used to cancel the operation, in which case @error (if non-%NULL) will be set to %G_IO_ERROR_CANCELLED. a hostname (either ASCII-only, or in ASCII-encoded form), or %NULL on error. a #GResolver the address to reverse-resolve a #GCancellable, or %NULL Begins asynchronously reverse-resolving @address to determine its associated hostname, and eventually calls @callback, which must call g_resolver_lookup_by_address_finish() to get the final result. a #GResolver the address to reverse-resolve a #GCancellable, or %NULL callback to call after resolution completes data for @callback Retrieves the result of a previous call to g_resolver_lookup_by_address_async(). If the DNS resolution failed, @error (if non-%NULL) will be set to a value from #GResolverError. If the operation was cancelled, @error will be set to %G_IO_ERROR_CANCELLED. a hostname (either ASCII-only, or in ASCII-encoded form), or %NULL on error. a #GResolver the result passed to your #GAsyncReadyCallback Synchronously resolves @hostname to determine its associated IP address(es). @hostname may be an ASCII-only or UTF-8 hostname, or the textual form of an IP address (in which case this just becomes a wrapper around g_inet_address_new_from_string()). On success, g_resolver_lookup_by_name() will return a non-empty #GList of #GInetAddress, sorted in order of preference and guaranteed to not contain duplicates. That is, if using the result to connect to @hostname, you should attempt to connect to the first address first, then the second if the first fails, etc. If you are using the result to listen on a socket, it is appropriate to add each result using e.g. g_socket_listener_add_address(). If the DNS resolution fails, @error (if non-%NULL) will be set to a value from #GResolverError and %NULL will be returned. If @cancellable is non-%NULL, it can be used to cancel the operation, in which case @error (if non-%NULL) will be set to %G_IO_ERROR_CANCELLED. If you are planning to connect to a socket on the resolved IP address, it may be easier to create a #GNetworkAddress and use its #GSocketConnectable interface. a non-empty #GList of #GInetAddress, or %NULL on error. You must unref each of the addresses and free the list when you are done with it. (You can use g_resolver_free_addresses() to do this.) a #GResolver the hostname to look up a #GCancellable, or %NULL Begins asynchronously resolving @hostname to determine its associated IP address(es), and eventually calls @callback, which must call g_resolver_lookup_by_name_finish() to get the result. See g_resolver_lookup_by_name() for more details. a #GResolver the hostname to look up the address of a #GCancellable, or %NULL callback to call after resolution completes data for @callback Retrieves the result of a call to g_resolver_lookup_by_name_async(). If the DNS resolution failed, @error (if non-%NULL) will be set to a value from #GResolverError. If the operation was cancelled, @error will be set to %G_IO_ERROR_CANCELLED. a #GList of #GInetAddress, or %NULL on error. See g_resolver_lookup_by_name() for more details. a #GResolver the result passed to your #GAsyncReadyCallback This differs from g_resolver_lookup_by_name() in that you can modify the lookup behavior with @flags. For example this can be used to limit results with #G_RESOLVER_NAME_LOOKUP_FLAGS_IPV4_ONLY. a non-empty #GList of #GInetAddress, or %NULL on error. You must unref each of the addresses and free the list when you are done with it. (You can use g_resolver_free_addresses() to do this.) a #GResolver the hostname to look up extra #GResolverNameLookupFlags for the lookup a #GCancellable, or %NULL Begins asynchronously resolving @hostname to determine its associated IP address(es), and eventually calls @callback, which must call g_resolver_lookup_by_name_with_flags_finish() to get the result. See g_resolver_lookup_by_name() for more details. a #GResolver the hostname to look up the address of extra #GResolverNameLookupFlags for the lookup a #GCancellable, or %NULL callback to call after resolution completes data for @callback Retrieves the result of a call to g_resolver_lookup_by_name_with_flags_async(). If the DNS resolution failed, @error (if non-%NULL) will be set to a value from #GResolverError. If the operation was cancelled, @error will be set to %G_IO_ERROR_CANCELLED. a #GList of #GInetAddress, or %NULL on error. See g_resolver_lookup_by_name() for more details. a #GResolver the result passed to your #GAsyncReadyCallback Synchronously performs a DNS record lookup for the given @rrname and returns a list of records as #GVariant tuples. See #GResolverRecordType for information on what the records contain for each @record_type. If the DNS resolution fails, @error (if non-%NULL) will be set to a value from #GResolverError and %NULL will be returned. If @cancellable is non-%NULL, it can be used to cancel the operation, in which case @error (if non-%NULL) will be set to %G_IO_ERROR_CANCELLED. a non-empty #GList of #GVariant, or %NULL on error. You must free each of the records and the list when you are done with it. (You can use g_list_free_full() with g_variant_unref() to do this.) a #GResolver the DNS name to look up the record for the type of DNS record to look up a #GCancellable, or %NULL Begins asynchronously performing a DNS lookup for the given @rrname, and eventually calls @callback, which must call g_resolver_lookup_records_finish() to get the final result. See g_resolver_lookup_records() for more details. a #GResolver the DNS name to look up the record for the type of DNS record to look up a #GCancellable, or %NULL callback to call after resolution completes data for @callback Retrieves the result of a previous call to g_resolver_lookup_records_async(). Returns a non-empty list of records as #GVariant tuples. See #GResolverRecordType for information on what the records contain. If the DNS resolution failed, @error (if non-%NULL) will be set to a value from #GResolverError. If the operation was cancelled, @error will be set to %G_IO_ERROR_CANCELLED. a non-empty #GList of #GVariant, or %NULL on error. You must free each of the records and the list when you are done with it. (You can use g_list_free_full() with g_variant_unref() to do this.) a #GResolver the result passed to your #GAsyncReadyCallback Retrieves the result of a previous call to g_resolver_lookup_service_async(). If the DNS resolution failed, @error (if non-%NULL) will be set to a value from #GResolverError. If the operation was cancelled, @error will be set to %G_IO_ERROR_CANCELLED. a non-empty #GList of #GSrvTarget, or %NULL on error. See g_resolver_lookup_service() for more details. a #GResolver the result passed to your #GAsyncReadyCallback Synchronously reverse-resolves @address to determine its associated hostname. If the DNS resolution fails, @error (if non-%NULL) will be set to a value from #GResolverError. If @cancellable is non-%NULL, it can be used to cancel the operation, in which case @error (if non-%NULL) will be set to %G_IO_ERROR_CANCELLED. a hostname (either ASCII-only, or in ASCII-encoded form), or %NULL on error. a #GResolver the address to reverse-resolve a #GCancellable, or %NULL Begins asynchronously reverse-resolving @address to determine its associated hostname, and eventually calls @callback, which must call g_resolver_lookup_by_address_finish() to get the final result. a #GResolver the address to reverse-resolve a #GCancellable, or %NULL callback to call after resolution completes data for @callback Retrieves the result of a previous call to g_resolver_lookup_by_address_async(). If the DNS resolution failed, @error (if non-%NULL) will be set to a value from #GResolverError. If the operation was cancelled, @error will be set to %G_IO_ERROR_CANCELLED. a hostname (either ASCII-only, or in ASCII-encoded form), or %NULL on error. a #GResolver the result passed to your #GAsyncReadyCallback Synchronously resolves @hostname to determine its associated IP address(es). @hostname may be an ASCII-only or UTF-8 hostname, or the textual form of an IP address (in which case this just becomes a wrapper around g_inet_address_new_from_string()). On success, g_resolver_lookup_by_name() will return a non-empty #GList of #GInetAddress, sorted in order of preference and guaranteed to not contain duplicates. That is, if using the result to connect to @hostname, you should attempt to connect to the first address first, then the second if the first fails, etc. If you are using the result to listen on a socket, it is appropriate to add each result using e.g. g_socket_listener_add_address(). If the DNS resolution fails, @error (if non-%NULL) will be set to a value from #GResolverError and %NULL will be returned. If @cancellable is non-%NULL, it can be used to cancel the operation, in which case @error (if non-%NULL) will be set to %G_IO_ERROR_CANCELLED. If you are planning to connect to a socket on the resolved IP address, it may be easier to create a #GNetworkAddress and use its #GSocketConnectable interface. a non-empty #GList of #GInetAddress, or %NULL on error. You must unref each of the addresses and free the list when you are done with it. (You can use g_resolver_free_addresses() to do this.) a #GResolver the hostname to look up a #GCancellable, or %NULL Begins asynchronously resolving @hostname to determine its associated IP address(es), and eventually calls @callback, which must call g_resolver_lookup_by_name_finish() to get the result. See g_resolver_lookup_by_name() for more details. a #GResolver the hostname to look up the address of a #GCancellable, or %NULL callback to call after resolution completes data for @callback Retrieves the result of a call to g_resolver_lookup_by_name_async(). If the DNS resolution failed, @error (if non-%NULL) will be set to a value from #GResolverError. If the operation was cancelled, @error will be set to %G_IO_ERROR_CANCELLED. a #GList of #GInetAddress, or %NULL on error. See g_resolver_lookup_by_name() for more details. a #GResolver the result passed to your #GAsyncReadyCallback This differs from g_resolver_lookup_by_name() in that you can modify the lookup behavior with @flags. For example this can be used to limit results with #G_RESOLVER_NAME_LOOKUP_FLAGS_IPV4_ONLY. a non-empty #GList of #GInetAddress, or %NULL on error. You must unref each of the addresses and free the list when you are done with it. (You can use g_resolver_free_addresses() to do this.) a #GResolver the hostname to look up extra #GResolverNameLookupFlags for the lookup a #GCancellable, or %NULL Begins asynchronously resolving @hostname to determine its associated IP address(es), and eventually calls @callback, which must call g_resolver_lookup_by_name_with_flags_finish() to get the result. See g_resolver_lookup_by_name() for more details. a #GResolver the hostname to look up the address of extra #GResolverNameLookupFlags for the lookup a #GCancellable, or %NULL callback to call after resolution completes data for @callback Retrieves the result of a call to g_resolver_lookup_by_name_with_flags_async(). If the DNS resolution failed, @error (if non-%NULL) will be set to a value from #GResolverError. If the operation was cancelled, @error will be set to %G_IO_ERROR_CANCELLED. a #GList of #GInetAddress, or %NULL on error. See g_resolver_lookup_by_name() for more details. a #GResolver the result passed to your #GAsyncReadyCallback Synchronously performs a DNS record lookup for the given @rrname and returns a list of records as #GVariant tuples. See #GResolverRecordType for information on what the records contain for each @record_type. If the DNS resolution fails, @error (if non-%NULL) will be set to a value from #GResolverError and %NULL will be returned. If @cancellable is non-%NULL, it can be used to cancel the operation, in which case @error (if non-%NULL) will be set to %G_IO_ERROR_CANCELLED. a non-empty #GList of #GVariant, or %NULL on error. You must free each of the records and the list when you are done with it. (You can use g_list_free_full() with g_variant_unref() to do this.) a #GResolver the DNS name to look up the record for the type of DNS record to look up a #GCancellable, or %NULL Begins asynchronously performing a DNS lookup for the given @rrname, and eventually calls @callback, which must call g_resolver_lookup_records_finish() to get the final result. See g_resolver_lookup_records() for more details. a #GResolver the DNS name to look up the record for the type of DNS record to look up a #GCancellable, or %NULL callback to call after resolution completes data for @callback Retrieves the result of a previous call to g_resolver_lookup_records_async(). Returns a non-empty list of records as #GVariant tuples. See #GResolverRecordType for information on what the records contain. If the DNS resolution failed, @error (if non-%NULL) will be set to a value from #GResolverError. If the operation was cancelled, @error will be set to %G_IO_ERROR_CANCELLED. a non-empty #GList of #GVariant, or %NULL on error. You must free each of the records and the list when you are done with it. (You can use g_list_free_full() with g_variant_unref() to do this.) a #GResolver the result passed to your #GAsyncReadyCallback Synchronously performs a DNS SRV lookup for the given @service and @protocol in the given @domain and returns an array of #GSrvTarget. @domain may be an ASCII-only or UTF-8 hostname. Note also that the @service and @protocol arguments do not include the leading underscore that appears in the actual DNS entry. On success, g_resolver_lookup_service() will return a non-empty #GList of #GSrvTarget, sorted in order of preference. (That is, you should attempt to connect to the first target first, then the second if the first fails, etc.) If the DNS resolution fails, @error (if non-%NULL) will be set to a value from #GResolverError and %NULL will be returned. If @cancellable is non-%NULL, it can be used to cancel the operation, in which case @error (if non-%NULL) will be set to %G_IO_ERROR_CANCELLED. If you are planning to connect to the service, it is usually easier to create a #GNetworkService and use its #GSocketConnectable interface. a non-empty #GList of #GSrvTarget, or %NULL on error. You must free each of the targets and the list when you are done with it. (You can use g_resolver_free_targets() to do this.) a #GResolver the service type to look up (eg, "ldap") the networking protocol to use for @service (eg, "tcp") the DNS domain to look up the service in a #GCancellable, or %NULL Begins asynchronously performing a DNS SRV lookup for the given @service and @protocol in the given @domain, and eventually calls @callback, which must call g_resolver_lookup_service_finish() to get the final result. See g_resolver_lookup_service() for more details. a #GResolver the service type to look up (eg, "ldap") the networking protocol to use for @service (eg, "tcp") the DNS domain to look up the service in a #GCancellable, or %NULL callback to call after resolution completes data for @callback Retrieves the result of a previous call to g_resolver_lookup_service_async(). If the DNS resolution failed, @error (if non-%NULL) will be set to a value from #GResolverError. If the operation was cancelled, @error will be set to %G_IO_ERROR_CANCELLED. a non-empty #GList of #GSrvTarget, or %NULL on error. See g_resolver_lookup_service() for more details. a #GResolver the result passed to your #GAsyncReadyCallback Sets @resolver to be the application's default resolver (reffing @resolver, and unreffing the previous default resolver, if any). Future calls to g_resolver_get_default() will return this resolver. This can be used if an application wants to perform any sort of DNS caching or "pinning"; it can implement its own #GResolver that calls the original default resolver for DNS operations, and implements its own cache policies on top of that, and then set itself as the default resolver for all later code to use. the new default #GResolver Emitted when the resolver notices that the system resolver configuration has changed. a non-empty #GList of #GInetAddress, or %NULL on error. You must unref each of the addresses and free the list when you are done with it. (You can use g_resolver_free_addresses() to do this.) a #GResolver the hostname to look up a #GCancellable, or %NULL a #GResolver the hostname to look up the address of a #GCancellable, or %NULL callback to call after resolution completes data for @callback a #GList of #GInetAddress, or %NULL on error. See g_resolver_lookup_by_name() for more details. a #GResolver the result passed to your #GAsyncReadyCallback a hostname (either ASCII-only, or in ASCII-encoded form), or %NULL on error. a #GResolver the address to reverse-resolve a #GCancellable, or %NULL a #GResolver the address to reverse-resolve a #GCancellable, or %NULL callback to call after resolution completes data for @callback a hostname (either ASCII-only, or in ASCII-encoded form), or %NULL on error. a #GResolver the result passed to your #GAsyncReadyCallback a non-empty #GList of #GSrvTarget, or %NULL on error. See g_resolver_lookup_service() for more details. a #GResolver the result passed to your #GAsyncReadyCallback a non-empty #GList of #GVariant, or %NULL on error. You must free each of the records and the list when you are done with it. (You can use g_list_free_full() with g_variant_unref() to do this.) a #GResolver the DNS name to look up the record for the type of DNS record to look up a #GCancellable, or %NULL a #GResolver the DNS name to look up the record for the type of DNS record to look up a #GCancellable, or %NULL callback to call after resolution completes data for @callback a non-empty #GList of #GVariant, or %NULL on error. You must free each of the records and the list when you are done with it. (You can use g_list_free_full() with g_variant_unref() to do this.) a #GResolver the result passed to your #GAsyncReadyCallback a #GResolver the hostname to look up the address of extra #GResolverNameLookupFlags for the lookup a #GCancellable, or %NULL callback to call after resolution completes data for @callback a #GList of #GInetAddress, or %NULL on error. See g_resolver_lookup_by_name() for more details. a #GResolver the result passed to your #GAsyncReadyCallback a non-empty #GList of #GInetAddress, or %NULL on error. You must unref each of the addresses and free the list when you are done with it. (You can use g_resolver_free_addresses() to do this.) a #GResolver the hostname to look up extra #GResolverNameLookupFlags for the lookup a #GCancellable, or %NULL An error code used with %G_RESOLVER_ERROR in a #GError returned from a #GResolver routine. the requested name/address/service was not found the requested information could not be looked up due to a network error or similar problem unknown error Gets the #GResolver Error Quark. a #GQuark. Flags to modify lookup behavior. default behavior (same as g_resolver_lookup_by_name()) only resolve ipv4 addresses only resolve ipv6 addresses The type of record that g_resolver_lookup_records() or g_resolver_lookup_records_async() should retrieve. The records are returned as lists of #GVariant tuples. Each record type has different values in the variant tuples returned. %G_RESOLVER_RECORD_SRV records are returned as variants with the signature `(qqqs)`, containing a `guint16` with the priority, a `guint16` with the weight, a `guint16` with the port, and a string of the hostname. %G_RESOLVER_RECORD_MX records are returned as variants with the signature `(qs)`, representing a `guint16` with the preference, and a string containing the mail exchanger hostname. %G_RESOLVER_RECORD_TXT records are returned as variants with the signature `(as)`, representing an array of the strings in the text record. Note: Most TXT records only contain a single string, but [RFC 1035](https://tools.ietf.org/html/rfc1035#section-3.3.14) does allow a record to contain multiple strings. The RFC which defines the interpretation of a specific TXT record will likely require concatenation of multiple strings if they are present, as with [RFC 7208](https://tools.ietf.org/html/rfc7208#section-3.3). %G_RESOLVER_RECORD_SOA records are returned as variants with the signature `(ssuuuuu)`, representing a string containing the primary name server, a string containing the administrator, the serial as a `guint32`, the refresh interval as a `guint32`, the retry interval as a `guint32`, the expire timeout as a `guint32`, and the TTL as a `guint32`. %G_RESOLVER_RECORD_NS records are returned as variants with the signature `(s)`, representing a string of the hostname of the name server. look up DNS SRV records for a domain look up DNS MX records for a domain look up DNS TXT records for a name look up DNS SOA records for a zone look up DNS NS records for a domain Applications and libraries often contain binary or textual data that is really part of the application, rather than user data. For instance #GtkBuilder .ui files, splashscreen images, GMenu markup XML, CSS files, icons, etc. These are often shipped as files in `$datadir/appname`, or manually included as literal strings in the code. The #GResource API and the [glib-compile-resources][glib-compile-resources] program provide a convenient and efficient alternative to this which has some nice properties. You maintain the files as normal files, so its easy to edit them, but during the build the files are combined into a binary bundle that is linked into the executable. This means that loading the resource files are efficient (as they are already in memory, shared with other instances) and simple (no need to check for things like I/O errors or locate the files in the filesystem). It also makes it easier to create relocatable applications. Resource files can also be marked as compressed. Such files will be included in the resource bundle in a compressed form, but will be automatically uncompressed when the resource is used. This is very useful e.g. for larger text files that are parsed once (or rarely) and then thrown away. Resource files can also be marked to be preprocessed, by setting the value of the `preprocess` attribute to a comma-separated list of preprocessing options. The only options currently supported are: `xml-stripblanks` which will use the xmllint command to strip ignorable whitespace from the XML file. For this to work, the `XMLLINT` environment variable must be set to the full path to the xmllint executable, or xmllint must be in the `PATH`; otherwise the preprocessing step is skipped. `to-pixdata` which will use the gdk-pixbuf-pixdata command to convert images to the GdkPixdata format, which allows you to create pixbufs directly using the data inside the resource file, rather than an (uncompressed) copy of it. For this, the gdk-pixbuf-pixdata program must be in the PATH, or the `GDK_PIXBUF_PIXDATA` environment variable must be set to the full path to the gdk-pixbuf-pixdata executable; otherwise the resource compiler will abort. `json-stripblanks` which will use the `json-glib-format` command to strip ignorable whitespace from the JSON file. For this to work, the `JSON_GLIB_FORMAT` environment variable must be set to the full path to the `json-glib-format` executable, or it must be in the `PATH`; otherwise the preprocessing step is skipped. In addition, at least version 1.6 of `json-glib-format` is required. Resource files will be exported in the GResource namespace using the combination of the given `prefix` and the filename from the `file` element. The `alias` attribute can be used to alter the filename to expose them at a different location in the resource namespace. Typically, this is used to include files from a different source directory without exposing the source directory in the resource namespace, as in the example below. Resource bundles are created by the [glib-compile-resources][glib-compile-resources] program which takes an XML file that describes the bundle, and a set of files that the XML references. These are combined into a binary resource bundle. An example resource description: |[ <?xml version="1.0" encoding="UTF-8"?> <gresources> <gresource prefix="/org/gtk/Example"> <file>data/splashscreen.png</file> <file compressed="true">dialog.ui</file> <file preprocess="xml-stripblanks">menumarkup.xml</file> <file alias="example.css">data/example.css</file> </gresource> </gresources> ]| This will create a resource bundle with the following files: |[ /org/gtk/Example/data/splashscreen.png /org/gtk/Example/dialog.ui /org/gtk/Example/menumarkup.xml /org/gtk/Example/example.css ]| Note that all resources in the process share the same namespace, so use Java-style path prefixes (like in the above example) to avoid conflicts. You can then use [glib-compile-resources][glib-compile-resources] to compile the XML to a binary bundle that you can load with g_resource_load(). However, its more common to use the --generate-source and --generate-header arguments to create a source file and header to link directly into your application. This will generate `get_resource()`, `register_resource()` and `unregister_resource()` functions, prefixed by the `--c-name` argument passed to [glib-compile-resources][glib-compile-resources]. `get_resource()` returns the generated #GResource object. The register and unregister functions register the resource so its files can be accessed using g_resources_lookup_data(). Once a #GResource has been created and registered all the data in it can be accessed globally in the process by using API calls like g_resources_open_stream() to stream the data or g_resources_lookup_data() to get a direct pointer to the data. You can also use URIs like "resource:///org/gtk/Example/data/splashscreen.png" with #GFile to access the resource data. Some higher-level APIs, such as #GtkApplication, will automatically load resources from certain well-known paths in the resource namespace as a convenience. See the documentation for those APIs for details. There are two forms of the generated source, the default version uses the compiler support for constructor and destructor functions (where available) to automatically create and register the #GResource on startup or library load time. If you pass `--manual-register`, two functions to register/unregister the resource are created instead. This requires an explicit initialization call in your application/library, but it works on all platforms, even on the minor ones where constructors are not supported. (Constructor support is available for at least Win32, Mac OS and Linux.) Note that resource data can point directly into the data segment of e.g. a library, so if you are unloading libraries during runtime you need to be very careful with keeping around pointers to data from a resource, as this goes away when the library is unloaded. However, in practice this is not generally a problem, since most resource accesses are for your own resources, and resource data is often used once, during parsing, and then released. When debugging a program or testing a change to an installed version, it is often useful to be able to replace resources in the program or library, without recompiling, for debugging or quick hacking and testing purposes. Since GLib 2.50, it is possible to use the `G_RESOURCE_OVERLAYS` environment variable to selectively overlay resources with replacements from the filesystem. It is a %G_SEARCHPATH_SEPARATOR-separated list of substitutions to perform during resource lookups. A substitution has the form |[ /org/gtk/libgtk=/home/desrt/gtk-overlay ]| The part before the `=` is the resource subpath for which the overlay applies. The part after is a filesystem path which contains files and subdirectories as you would like to be loaded as resources with the equivalent names. In the example above, if an application tried to load a resource with the resource path `/org/gtk/libgtk/ui/gtkdialog.ui` then GResource would check the filesystem path `/home/desrt/gtk-overlay/ui/gtkdialog.ui`. If a file was found there, it would be used instead. This is an overlay, not an outright replacement, which means that if a file is not found at that path, the built-in version will be used instead. Whiteouts are not currently supported. Substitutions must start with a slash, and must not contain a trailing slash before the '='. The path after the slash should ideally be absolute, but this is not strictly required. It is possible to overlay the location of a single resource with an individual file. Creates a GResource from a reference to the binary resource bundle. This will keep a reference to @data while the resource lives, so the data should not be modified or freed. If you want to use this resource in the global resource namespace you need to register it with g_resources_register(). Note: @data must be backed by memory that is at least pointer aligned. Otherwise this function will internally create a copy of the memory since GLib 2.56, or in older versions fail and exit the process. If @data is empty or corrupt, %G_RESOURCE_ERROR_INTERNAL will be returned. a new #GResource, or %NULL on error A #GBytes Registers the resource with the process-global set of resources. Once a resource is registered the files in it can be accessed with the global resource lookup functions like g_resources_lookup_data(). A #GResource Unregisters the resource from the process-global set of resources. A #GResource Returns all the names of children at the specified @path in the resource. The return result is a %NULL terminated list of strings which should be released with g_strfreev(). If @path is invalid or does not exist in the #GResource, %G_RESOURCE_ERROR_NOT_FOUND will be returned. @lookup_flags controls the behaviour of the lookup. an array of constant strings A #GResource A pathname inside the resource A #GResourceLookupFlags Looks for a file at the specified @path in the resource and if found returns information about it. @lookup_flags controls the behaviour of the lookup. %TRUE if the file was found. %FALSE if there were errors A #GResource A pathname inside the resource A #GResourceLookupFlags a location to place the length of the contents of the file, or %NULL if the length is not needed a location to place the flags about the file, or %NULL if the length is not needed Looks for a file at the specified @path in the resource and returns a #GBytes that lets you directly access the data in memory. The data is always followed by a zero byte, so you can safely use the data as a C string. However, that byte is not included in the size of the GBytes. For uncompressed resource files this is a pointer directly into the resource bundle, which is typically in some readonly data section in the program binary. For compressed files we allocate memory on the heap and automatically uncompress the data. @lookup_flags controls the behaviour of the lookup. #GBytes or %NULL on error. Free the returned object with g_bytes_unref() A #GResource A pathname inside the resource A #GResourceLookupFlags Looks for a file at the specified @path in the resource and returns a #GInputStream that lets you read the data. @lookup_flags controls the behaviour of the lookup. #GInputStream or %NULL on error. Free the returned object with g_object_unref() A #GResource A pathname inside the resource A #GResourceLookupFlags Atomically increments the reference count of @resource by one. This function is MT-safe and may be called from any thread. The passed in #GResource A #GResource Atomically decrements the reference count of @resource by one. If the reference count drops to 0, all memory allocated by the resource is released. This function is MT-safe and may be called from any thread. A #GResource Loads a binary resource bundle and creates a #GResource representation of it, allowing you to query it for data. If you want to use this resource in the global resource namespace you need to register it with g_resources_register(). If @filename is empty or the data in it is corrupt, %G_RESOURCE_ERROR_INTERNAL will be returned. If @filename doesn’t exist, or there is an error in reading it, an error from g_mapped_file_new() will be returned. a new #GResource, or %NULL on error the path of a filename to load, in the GLib filename encoding An error code used with %G_RESOURCE_ERROR in a #GError returned from a #GResource routine. no file was found at the requested path unknown error Gets the #GResource Error Quark. a #GQuark GResourceFlags give information about a particular file inside a resource bundle. No flags set. The file is compressed. GResourceLookupFlags determine how resource path lookups are handled. No flags set. Extension point for #GSettingsBackend functionality. #GSeekable is implemented by streams (implementations of #GInputStream or #GOutputStream) that support seeking. Seekable streams largely fall into two categories: resizable and fixed-size. #GSeekable on fixed-sized streams is approximately the same as POSIX lseek() on a block device (for example: attempting to seek past the end of the device is an error). Fixed streams typically cannot be truncated. #GSeekable on resizable streams is approximately the same as POSIX lseek() on a normal file. Seeking past the end and writing data will usually cause the stream to resize by introducing zero bytes. Tests if the stream supports the #GSeekableIface. %TRUE if @seekable can be seeked. %FALSE otherwise. a #GSeekable. Tests if the length of the stream can be adjusted with g_seekable_truncate(). %TRUE if the stream can be truncated, %FALSE otherwise. a #GSeekable. Seeks in the stream by the given @offset, modified by @type. Attempting to seek past the end of the stream will have different results depending on if the stream is fixed-sized or resizable. If the stream is resizable then seeking past the end and then writing will result in zeros filling the empty space. Seeking past the end of a resizable stream and reading will result in EOF. Seeking past the end of a fixed-sized stream will fail. Any operation that would result in a negative offset will fail. If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. %TRUE if successful. If an error has occurred, this function will return %FALSE and set @error appropriately if present. a #GSeekable. a #goffset. a #GSeekType. optional #GCancellable object, %NULL to ignore. Tells the current position within the stream. the offset from the beginning of the buffer. a #GSeekable. Sets the length of the stream to @offset. If the stream was previously larger than @offset, the extra data is discarded. If the stream was previously shorter than @offset, it is extended with NUL ('\0') bytes. If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an operation was partially finished when the operation was cancelled the partial result will be returned, without an error. %TRUE if successful. If an error has occurred, this function will return %FALSE and set @error appropriately if present. a #GSeekable. new length for @seekable, in bytes. optional #GCancellable object, %NULL to ignore. Tests if the stream supports the #GSeekableIface. %TRUE if @seekable can be seeked. %FALSE otherwise. a #GSeekable. Tests if the length of the stream can be adjusted with g_seekable_truncate(). %TRUE if the stream can be truncated, %FALSE otherwise. a #GSeekable. Seeks in the stream by the given @offset, modified by @type. Attempting to seek past the end of the stream will have different results depending on if the stream is fixed-sized or resizable. If the stream is resizable then seeking past the end and then writing will result in zeros filling the empty space. Seeking past the end of a resizable stream and reading will result in EOF. Seeking past the end of a fixed-sized stream will fail. Any operation that would result in a negative offset will fail. If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. %TRUE if successful. If an error has occurred, this function will return %FALSE and set @error appropriately if present. a #GSeekable. a #goffset. a #GSeekType. optional #GCancellable object, %NULL to ignore. Tells the current position within the stream. the offset from the beginning of the buffer. a #GSeekable. Sets the length of the stream to @offset. If the stream was previously larger than @offset, the extra data is discarded. If the stream was previously shorter than @offset, it is extended with NUL ('\0') bytes. If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an operation was partially finished when the operation was cancelled the partial result will be returned, without an error. %TRUE if successful. If an error has occurred, this function will return %FALSE and set @error appropriately if present. a #GSeekable. new length for @seekable, in bytes. optional #GCancellable object, %NULL to ignore. Provides an interface for implementing seekable functionality on I/O Streams. The parent interface. the offset from the beginning of the buffer. a #GSeekable. %TRUE if @seekable can be seeked. %FALSE otherwise. a #GSeekable. %TRUE if successful. If an error has occurred, this function will return %FALSE and set @error appropriately if present. a #GSeekable. a #goffset. a #GSeekType. optional #GCancellable object, %NULL to ignore. %TRUE if the stream can be truncated, %FALSE otherwise. a #GSeekable. %TRUE if successful. If an error has occurred, this function will return %FALSE and set @error appropriately if present. a #GSeekable. new length for @seekable, in bytes. optional #GCancellable object, %NULL to ignore. The #GSettings class provides a convenient API for storing and retrieving application settings. Reads and writes can be considered to be non-blocking. Reading settings with #GSettings is typically extremely fast: on approximately the same order of magnitude (but slower than) a #GHashTable lookup. Writing settings is also extremely fast in terms of time to return to your application, but can be extremely expensive for other threads and other processes. Many settings backends (including dconf) have lazy initialisation which means in the common case of the user using their computer without modifying any settings a lot of work can be avoided. For dconf, the D-Bus service doesn't even need to be started in this case. For this reason, you should only ever modify #GSettings keys in response to explicit user action. Particular care should be paid to ensure that modifications are not made during startup -- for example, when setting the initial value of preferences widgets. The built-in g_settings_bind() functionality is careful not to write settings in response to notify signals as a result of modifications that it makes to widgets. When creating a GSettings instance, you have to specify a schema that describes the keys in your settings and their types and default values, as well as some other information. Normally, a schema has a fixed path that determines where the settings are stored in the conceptual global tree of settings. However, schemas can also be '[relocatable][gsettings-relocatable]', i.e. not equipped with a fixed path. This is useful e.g. when the schema describes an 'account', and you want to be able to store a arbitrary number of accounts. Paths must start with and end with a forward slash character ('/') and must not contain two sequential slash characters. Paths should be chosen based on a domain name associated with the program or library to which the settings belong. Examples of paths are "/org/gtk/settings/file-chooser/" and "/ca/desrt/dconf-editor/". Paths should not start with "/apps/", "/desktop/" or "/system/" as they often did in GConf. Unlike other configuration systems (like GConf), GSettings does not restrict keys to basic types like strings and numbers. GSettings stores values as #GVariant, and allows any #GVariantType for keys. Key names are restricted to lowercase characters, numbers and '-'. Furthermore, the names must begin with a lowercase character, must not end with a '-', and must not contain consecutive dashes. Similar to GConf, the default values in GSettings schemas can be localized, but the localized values are stored in gettext catalogs and looked up with the domain that is specified in the `gettext-domain` attribute of the <schemalist> or <schema> elements and the category that is specified in the `l10n` attribute of the <default> element. The string which is translated includes all text in the <default> element, including any surrounding quotation marks. The `l10n` attribute must be set to `messages` or `time`, and sets the [locale category for translation](https://www.gnu.org/software/gettext/manual/html_node/Aspects.html#index-locale-categories-1). The `messages` category should be used by default; use `time` for translatable date or time formats. A translation comment can be added as an XML comment immediately above the <default> element — it is recommended to add these comments to aid translators understand the meaning and implications of the default value. An optional translation `context` attribute can be set on the <default> element to disambiguate multiple defaults which use the same string. For example: |[ <!-- Translators: A list of words which are not allowed to be typed, in GVariant serialization syntax. See: https://developer.gnome.org/glib/stable/gvariant-text.html --> <default l10n='messages' context='Banned words'>['bad', 'words']</default> ]| Translations of default values must remain syntactically valid serialized #GVariants (e.g. retaining any surrounding quotation marks) or runtime errors will occur. GSettings uses schemas in a compact binary form that is created by the [glib-compile-schemas][glib-compile-schemas] utility. The input is a schema description in an XML format. A DTD for the gschema XML format can be found here: [gschema.dtd](https://git.gnome.org/browse/glib/tree/gio/gschema.dtd) The [glib-compile-schemas][glib-compile-schemas] tool expects schema files to have the extension `.gschema.xml`. At runtime, schemas are identified by their id (as specified in the id attribute of the <schema> element). The convention for schema ids is to use a dotted name, similar in style to a D-Bus bus name, e.g. "org.gnome.SessionManager". In particular, if the settings are for a specific service that owns a D-Bus bus name, the D-Bus bus name and schema id should match. For schemas which deal with settings not associated with one named application, the id should not use StudlyCaps, e.g. "org.gnome.font-rendering". In addition to #GVariant types, keys can have types that have enumerated types. These can be described by a <choice>, <enum> or <flags> element, as seen in the [example][schema-enumerated]. The underlying type of such a key is string, but you can use g_settings_get_enum(), g_settings_set_enum(), g_settings_get_flags(), g_settings_set_flags() access the numeric values corresponding to the string value of enum and flags keys. An example for default value: |[ <schemalist> <schema id="org.gtk.Test" path="/org/gtk/Test/" gettext-domain="test"> <key name="greeting" type="s"> <default l10n="messages">"Hello, earthlings"</default> <summary>A greeting</summary> <description> Greeting of the invading martians </description> </key> <key name="box" type="(ii)"> <default>(20,30)</default> </key> <key name="empty-string" type="s"> <default>""</default> <summary>Empty strings have to be provided in GVariant form</summary> </key> </schema> </schemalist> ]| An example for ranges, choices and enumerated types: |[ <schemalist> <enum id="org.gtk.Test.myenum"> <value nick="first" value="1"/> <value nick="second" value="2"/> </enum> <flags id="org.gtk.Test.myflags"> <value nick="flag1" value="1"/> <value nick="flag2" value="2"/> <value nick="flag3" value="4"/> </flags> <schema id="org.gtk.Test"> <key name="key-with-range" type="i"> <range min="1" max="100"/> <default>10</default> </key> <key name="key-with-choices" type="s"> <choices> <choice value='Elisabeth'/> <choice value='Annabeth'/> <choice value='Joe'/> </choices> <aliases> <alias value='Anna' target='Annabeth'/> <alias value='Beth' target='Elisabeth'/> </aliases> <default>'Joe'</default> </key> <key name='enumerated-key' enum='org.gtk.Test.myenum'> <default>'first'</default> </key> <key name='flags-key' flags='org.gtk.Test.myflags'> <default>["flag1","flag2"]</default> </key> </schema> </schemalist> ]| ## Vendor overrides Default values are defined in the schemas that get installed by an application. Sometimes, it is necessary for a vendor or distributor to adjust these defaults. Since patching the XML source for the schema is inconvenient and error-prone, [glib-compile-schemas][glib-compile-schemas] reads so-called vendor override' files. These are keyfiles in the same directory as the XML schema sources which can override default values. The schema id serves as the group name in the key file, and the values are expected in serialized GVariant form, as in the following example: |[ [org.gtk.Example] key1='string' key2=1.5 ]| glib-compile-schemas expects schema files to have the extension `.gschema.override`. ## Binding A very convenient feature of GSettings lets you bind #GObject properties directly to settings, using g_settings_bind(). Once a GObject property has been bound to a setting, changes on either side are automatically propagated to the other side. GSettings handles details like mapping between GObject and GVariant types, and preventing infinite cycles. This makes it very easy to hook up a preferences dialog to the underlying settings. To make this even more convenient, GSettings looks for a boolean property with the name "sensitivity" and automatically binds it to the writability of the bound setting. If this 'magic' gets in the way, it can be suppressed with the #G_SETTINGS_BIND_NO_SENSITIVITY flag. ## Relocatable schemas # {#gsettings-relocatable} A relocatable schema is one with no `path` attribute specified on its <schema> element. By using g_settings_new_with_path(), a #GSettings object can be instantiated for a relocatable schema, assigning a path to the instance. Paths passed to g_settings_new_with_path() will typically be constructed dynamically from a constant prefix plus some form of instance identifier; but they must still be valid GSettings paths. Paths could also be constant and used with a globally installed schema originating from a dependency library. For example, a relocatable schema could be used to store geometry information for different windows in an application. If the schema ID was `org.foo.MyApp.Window`, it could be instantiated for paths `/org/foo/MyApp/main/`, `/org/foo/MyApp/document-1/`, `/org/foo/MyApp/document-2/`, etc. If any of the paths are well-known they can be specified as <child> elements in the parent schema, e.g.: |[ <schema id="org.foo.MyApp" path="/org/foo/MyApp/"> <child name="main" schema="org.foo.MyApp.Window"/> </schema> ]| ## Build system integration # {#gsettings-build-system} GSettings comes with autotools integration to simplify compiling and installing schemas. To add GSettings support to an application, add the following to your `configure.ac`: |[ GLIB_GSETTINGS ]| In the appropriate `Makefile.am`, use the following snippet to compile and install the named schema: |[ gsettings_SCHEMAS = org.foo.MyApp.gschema.xml EXTRA_DIST = $(gsettings_SCHEMAS) @GSETTINGS_RULES@ ]| No changes are needed to the build system to mark a schema XML file for translation. Assuming it sets the `gettext-domain` attribute, a schema may be marked for translation by adding it to `POTFILES.in`, assuming gettext 0.19 is in use (the preferred method for translation): |[ data/org.foo.MyApp.gschema.xml ]| Alternatively, if intltool 0.50.1 is in use: |[ [type: gettext/gsettings]data/org.foo.MyApp.gschema.xml ]| GSettings will use gettext to look up translations for the <summary> and <description> elements, and also any <default> elements which have a `l10n` attribute set. Translations must not be included in the `.gschema.xml` file by the build system, for example by using intltool XML rules with a `.gschema.xml.in` template. If an enumerated type defined in a C header file is to be used in a GSettings schema, it can either be defined manually using an <enum> element in the schema XML, or it can be extracted automatically from the C header. This approach is preferred, as it ensures the two representations are always synchronised. To do so, add the following to the relevant `Makefile.am`: |[ gsettings_ENUM_NAMESPACE = org.foo.MyApp gsettings_ENUM_FILES = my-app-enums.h my-app-misc.h ]| `gsettings_ENUM_NAMESPACE` specifies the schema namespace for the enum files, which are specified in `gsettings_ENUM_FILES`. This will generate a `org.foo.MyApp.enums.xml` file containing the extracted enums, which will be automatically included in the schema compilation, install and uninstall rules. It should not be committed to version control or included in `EXTRA_DIST`. Creates a new #GSettings object with the schema specified by @schema_id. It is an error for the schema to not exist: schemas are an essential part of a program, as they provide type information. If schemas need to be dynamically loaded (for example, from an optional runtime dependency), g_settings_schema_source_lookup() can be used to test for their existence before loading them. Signals on the newly created #GSettings object will be dispatched via the thread-default #GMainContext in effect at the time of the call to g_settings_new(). The new #GSettings will hold a reference on the context. See g_main_context_push_thread_default(). a new #GSettings object the id of the schema Creates a new #GSettings object with a given schema, backend and path. It should be extremely rare that you ever want to use this function. It is made available for advanced use-cases (such as plugin systems that want to provide access to schemas loaded from custom locations, etc). At the most basic level, a #GSettings object is a pure composition of 4 things: a #GSettingsSchema, a #GSettingsBackend, a path within that backend, and a #GMainContext to which signals are dispatched. This constructor therefore gives you full control over constructing #GSettings instances. The first 3 parameters are given directly as @schema, @backend and @path, and the main context is taken from the thread-default (as per g_settings_new()). If @backend is %NULL then the default backend is used. If @path is %NULL then the path from the schema is used. It is an error if @path is %NULL and the schema has no path of its own or if @path is non-%NULL and not equal to the path that the schema does have. a new #GSettings object a #GSettingsSchema a #GSettingsBackend the path to use Creates a new #GSettings object with the schema specified by @schema_id and a given #GSettingsBackend. Creating a #GSettings object with a different backend allows accessing settings from a database other than the usual one. For example, it may make sense to pass a backend corresponding to the "defaults" settings database on the system to get a settings object that modifies the system default settings instead of the settings for this user. a new #GSettings object the id of the schema the #GSettingsBackend to use Creates a new #GSettings object with the schema specified by @schema_id and a given #GSettingsBackend and path. This is a mix of g_settings_new_with_backend() and g_settings_new_with_path(). a new #GSettings object the id of the schema the #GSettingsBackend to use the path to use Creates a new #GSettings object with the relocatable schema specified by @schema_id and a given path. You only need to do this if you want to directly create a settings object with a schema that doesn't have a specified path of its own. That's quite rare. It is a programmer error to call this function for a schema that has an explicitly specified path. It is a programmer error if @path is not a valid path. A valid path begins and ends with '/' and does not contain two consecutive '/' characters. a new #GSettings object the id of the schema the path to use Deprecated. Use g_settings_schema_source_list_schemas() instead a list of relocatable #GSettings schemas that are available, in no defined order. The list must not be modified or freed. Deprecated. Use g_settings_schema_source_list_schemas() instead. If you used g_settings_list_schemas() to check for the presence of a particular schema, use g_settings_schema_source_lookup() instead of your whole loop. a list of #GSettings schemas that are available, in no defined order. The list must not be modified or freed. Ensures that all pending operations are complete for the default backend. Writes made to a #GSettings are handled asynchronously. For this reason, it is very unlikely that the changes have it to disk by the time g_settings_set() returns. This call will block until all of the writes have made it to the backend. Since the mainloop is not running, no change notifications will be dispatched during this call (but some may be queued by the time the call is done). Removes an existing binding for @property on @object. Note that bindings are automatically removed when the object is finalized, so it is rarely necessary to call this function. the object the property whose binding is removed Applies any changes that have been made to the settings. This function does nothing unless @settings is in 'delay-apply' mode; see g_settings_delay(). In the normal case settings are always applied immediately. a #GSettings instance Create a binding between the @key in the @settings object and the property @property of @object. The binding uses the default GIO mapping functions to map between the settings and property values. These functions handle booleans, numeric types and string types in a straightforward way. Use g_settings_bind_with_mapping() if you need a custom mapping, or map between types that are not supported by the default mapping functions. Unless the @flags include %G_SETTINGS_BIND_NO_SENSITIVITY, this function also establishes a binding between the writability of @key and the "sensitive" property of @object (if @object has a boolean property by that name). See g_settings_bind_writable() for more details about writable bindings. Note that the lifecycle of the binding is tied to @object, and that you can have only one binding per object property. If you bind the same property twice on the same object, the second binding overrides the first one. a #GSettings object the key to bind a #GObject the name of the property to bind flags for the binding Create a binding between the @key in the @settings object and the property @property of @object. The binding uses the provided mapping functions to map between settings and property values. Note that the lifecycle of the binding is tied to @object, and that you can have only one binding per object property. If you bind the same property twice on the same object, the second binding overrides the first one. a #GSettings object the key to bind a #GObject the name of the property to bind flags for the binding a function that gets called to convert values from @settings to @object, or %NULL to use the default GIO mapping a function that gets called to convert values from @object to @settings, or %NULL to use the default GIO mapping data that gets passed to @get_mapping and @set_mapping #GDestroyNotify function for @user_data Create a binding between the writability of @key in the @settings object and the property @property of @object. The property must be boolean; "sensitive" or "visible" properties of widgets are the most likely candidates. Writable bindings are always uni-directional; changes of the writability of the setting will be propagated to the object property, not the other way. When the @inverted argument is %TRUE, the binding inverts the value as it passes from the setting to the object, i.e. @property will be set to %TRUE if the key is not writable. Note that the lifecycle of the binding is tied to @object, and that you can have only one binding per object property. If you bind the same property twice on the same object, the second binding overrides the first one. a #GSettings object the key to bind a #GObject the name of a boolean property to bind whether to 'invert' the value Creates a #GAction corresponding to a given #GSettings key. The action has the same name as the key. The value of the key becomes the state of the action and the action is enabled when the key is writable. Changing the state of the action results in the key being written to. Changes to the value or writability of the key cause appropriate change notifications to be emitted for the action. For boolean-valued keys, action activations take no parameter and result in the toggling of the value. For all other types, activations take the new value for the key (which must have the correct type). a new #GAction a #GSettings the name of a key in @settings Changes the #GSettings object into 'delay-apply' mode. In this mode, changes to @settings are not immediately propagated to the backend, but kept locally until g_settings_apply() is called. a #GSettings object Gets the value that is stored at @key in @settings. A convenience function that combines g_settings_get_value() with g_variant_get(). It is a programmer error to give a @key that isn't contained in the schema for @settings or for the #GVariantType of @format to mismatch the type given in the schema. a #GSettings object the key to get the value for a #GVariant format string arguments as per @format Gets the value that is stored at @key in @settings. A convenience variant of g_settings_get() for booleans. It is a programmer error to give a @key that isn't specified as having a boolean type in the schema for @settings. a boolean a #GSettings object the key to get the value for Creates a child settings object which has a base path of `base-path/@name`, where `base-path` is the base path of @settings. The schema for the child settings object must have been declared in the schema of @settings using a <child> element. a 'child' settings object a #GSettings object the name of the child schema Gets the "default value" of a key. This is the value that would be read if g_settings_reset() were to be called on the key. Note that this may be a different value than returned by g_settings_schema_key_get_default_value() if the system administrator has provided a default value. Comparing the return values of g_settings_get_default_value() and g_settings_get_value() is not sufficient for determining if a value has been set because the user may have explicitly set the value to something that happens to be equal to the default. The difference here is that if the default changes in the future, the user's key will still be set. This function may be useful for adding an indication to a UI of what the default value was before the user set it. It is a programmer error to give a @key that isn't contained in the schema for @settings. the default value a #GSettings object the key to get the default value for Gets the value that is stored at @key in @settings. A convenience variant of g_settings_get() for doubles. It is a programmer error to give a @key that isn't specified as having a 'double' type in the schema for @settings. a double a #GSettings object the key to get the value for Gets the value that is stored in @settings for @key and converts it to the enum value that it represents. In order to use this function the type of the value must be a string and it must be marked in the schema file as an enumerated type. It is a programmer error to give a @key that isn't contained in the schema for @settings or is not marked as an enumerated type. If the value stored in the configuration database is not a valid value for the enumerated type then this function will return the default value. the enum value a #GSettings object the key to get the value for Gets the value that is stored in @settings for @key and converts it to the flags value that it represents. In order to use this function the type of the value must be an array of strings and it must be marked in the schema file as a flags type. It is a programmer error to give a @key that isn't contained in the schema for @settings or is not marked as a flags type. If the value stored in the configuration database is not a valid value for the flags type then this function will return the default value. the flags value a #GSettings object the key to get the value for Returns whether the #GSettings object has any unapplied changes. This can only be the case if it is in 'delayed-apply' mode. %TRUE if @settings has unapplied changes a #GSettings object Gets the value that is stored at @key in @settings. A convenience variant of g_settings_get() for 32-bit integers. It is a programmer error to give a @key that isn't specified as having a int32 type in the schema for @settings. an integer a #GSettings object the key to get the value for Gets the value that is stored at @key in @settings. A convenience variant of g_settings_get() for 64-bit integers. It is a programmer error to give a @key that isn't specified as having a int64 type in the schema for @settings. a 64-bit integer a #GSettings object the key to get the value for Gets the value that is stored at @key in @settings, subject to application-level validation/mapping. You should use this function when the application needs to perform some processing on the value of the key (for example, parsing). The @mapping function performs that processing. If the function indicates that the processing was unsuccessful (due to a parse error, for example) then the mapping is tried again with another value. This allows a robust 'fall back to defaults' behaviour to be implemented somewhat automatically. The first value that is tried is the user's setting for the key. If the mapping function fails to map this value, other values may be tried in an unspecified order (system or site defaults, translated schema default values, untranslated schema default values, etc). If the mapping function fails for all possible values, one additional attempt is made: the mapping function is called with a %NULL value. If the mapping function still indicates failure at this point then the application will be aborted. The result parameter for the @mapping function is pointed to a #gpointer which is initially set to %NULL. The same pointer is given to each invocation of @mapping. The final value of that #gpointer is what is returned by this function. %NULL is valid; it is returned just as any other value would be. the result, which may be %NULL a #GSettings object the key to get the value for the function to map the value in the settings database to the value used by the application user data for @mapping Queries the range of a key. Use g_settings_schema_key_get_range() instead. a #GSettings the key to query the range of Gets the value that is stored at @key in @settings. A convenience variant of g_settings_get() for strings. It is a programmer error to give a @key that isn't specified as having a string type in the schema for @settings. a newly-allocated string a #GSettings object the key to get the value for A convenience variant of g_settings_get() for string arrays. It is a programmer error to give a @key that isn't specified as having an array of strings type in the schema for @settings. a newly-allocated, %NULL-terminated array of strings, the value that is stored at @key in @settings. a #GSettings object the key to get the value for Gets the value that is stored at @key in @settings. A convenience variant of g_settings_get() for 32-bit unsigned integers. It is a programmer error to give a @key that isn't specified as having a uint32 type in the schema for @settings. an unsigned integer a #GSettings object the key to get the value for Gets the value that is stored at @key in @settings. A convenience variant of g_settings_get() for 64-bit unsigned integers. It is a programmer error to give a @key that isn't specified as having a uint64 type in the schema for @settings. a 64-bit unsigned integer a #GSettings object the key to get the value for Checks the "user value" of a key, if there is one. The user value of a key is the last value that was set by the user. After calling g_settings_reset() this function should always return %NULL (assuming something is not wrong with the system configuration). It is possible that g_settings_get_value() will return a different value than this function. This can happen in the case that the user set a value for a key that was subsequently locked down by the system administrator -- this function will return the user's old value. This function may be useful for adding a "reset" option to a UI or for providing indication that a particular value has been changed. It is a programmer error to give a @key that isn't contained in the schema for @settings. the user's value, if set a #GSettings object the key to get the user value for Gets the value that is stored in @settings for @key. It is a programmer error to give a @key that isn't contained in the schema for @settings. a new #GVariant a #GSettings object the key to get the value for Finds out if a key can be written or not %TRUE if the key @name is writable a #GSettings object the name of a key Gets the list of children on @settings. The list is exactly the list of strings for which it is not an error to call g_settings_get_child(). There is little reason to call this function from "normal" code, since you should already know what children are in your schema. This function may still be useful there for introspection reasons, however. You should free the return value with g_strfreev() when you are done with it. a list of the children on @settings, in no defined order a #GSettings object Introspects the list of keys on @settings. You should probably not be calling this function from "normal" code (since you should already know what keys are in your schema). This function is intended for introspection reasons. You should free the return value with g_strfreev() when you are done with it. Use g_settings_schema_list_keys() instead. a list of the keys on @settings, in no defined order a #GSettings object Checks if the given @value is of the correct type and within the permitted range for @key. Use g_settings_schema_key_range_check() instead. %TRUE if @value is valid for @key a #GSettings the key to check the value to check Resets @key to its default value. This call resets the key, as much as possible, to its default value. That might be the value specified in the schema or the one set by the administrator. a #GSettings object the name of a key Reverts all non-applied changes to the settings. This function does nothing unless @settings is in 'delay-apply' mode; see g_settings_delay(). In the normal case settings are always applied immediately. Change notifications will be emitted for affected keys. a #GSettings instance Sets @key in @settings to @value. A convenience function that combines g_settings_set_value() with g_variant_new(). It is a programmer error to give a @key that isn't contained in the schema for @settings or for the #GVariantType of @format to mismatch the type given in the schema. %TRUE if setting the key succeeded, %FALSE if the key was not writable a #GSettings object the name of the key to set a #GVariant format string arguments as per @format Sets @key in @settings to @value. A convenience variant of g_settings_set() for booleans. It is a programmer error to give a @key that isn't specified as having a boolean type in the schema for @settings. %TRUE if setting the key succeeded, %FALSE if the key was not writable a #GSettings object the name of the key to set the value to set it to Sets @key in @settings to @value. A convenience variant of g_settings_set() for doubles. It is a programmer error to give a @key that isn't specified as having a 'double' type in the schema for @settings. %TRUE if setting the key succeeded, %FALSE if the key was not writable a #GSettings object the name of the key to set the value to set it to Looks up the enumerated type nick for @value and writes it to @key, within @settings. It is a programmer error to give a @key that isn't contained in the schema for @settings or is not marked as an enumerated type, or for @value not to be a valid value for the named type. After performing the write, accessing @key directly with g_settings_get_string() will return the 'nick' associated with @value. %TRUE, if the set succeeds a #GSettings object a key, within @settings an enumerated value Looks up the flags type nicks for the bits specified by @value, puts them in an array of strings and writes the array to @key, within @settings. It is a programmer error to give a @key that isn't contained in the schema for @settings or is not marked as a flags type, or for @value to contain any bits that are not value for the named type. After performing the write, accessing @key directly with g_settings_get_strv() will return an array of 'nicks'; one for each bit in @value. %TRUE, if the set succeeds a #GSettings object a key, within @settings a flags value Sets @key in @settings to @value. A convenience variant of g_settings_set() for 32-bit integers. It is a programmer error to give a @key that isn't specified as having a int32 type in the schema for @settings. %TRUE if setting the key succeeded, %FALSE if the key was not writable a #GSettings object the name of the key to set the value to set it to Sets @key in @settings to @value. A convenience variant of g_settings_set() for 64-bit integers. It is a programmer error to give a @key that isn't specified as having a int64 type in the schema for @settings. %TRUE if setting the key succeeded, %FALSE if the key was not writable a #GSettings object the name of the key to set the value to set it to Sets @key in @settings to @value. A convenience variant of g_settings_set() for strings. It is a programmer error to give a @key that isn't specified as having a string type in the schema for @settings. %TRUE if setting the key succeeded, %FALSE if the key was not writable a #GSettings object the name of the key to set the value to set it to Sets @key in @settings to @value. A convenience variant of g_settings_set() for string arrays. If @value is %NULL, then @key is set to be the empty array. It is a programmer error to give a @key that isn't specified as having an array of strings type in the schema for @settings. %TRUE if setting the key succeeded, %FALSE if the key was not writable a #GSettings object the name of the key to set the value to set it to, or %NULL Sets @key in @settings to @value. A convenience variant of g_settings_set() for 32-bit unsigned integers. It is a programmer error to give a @key that isn't specified as having a uint32 type in the schema for @settings. %TRUE if setting the key succeeded, %FALSE if the key was not writable a #GSettings object the name of the key to set the value to set it to Sets @key in @settings to @value. A convenience variant of g_settings_set() for 64-bit unsigned integers. It is a programmer error to give a @key that isn't specified as having a uint64 type in the schema for @settings. %TRUE if setting the key succeeded, %FALSE if the key was not writable a #GSettings object the name of the key to set the value to set it to Sets @key in @settings to @value. It is a programmer error to give a @key that isn't contained in the schema for @settings or for @value to have the incorrect type, per the schema. If @value is floating then this function consumes the reference. %TRUE if setting the key succeeded, %FALSE if the key was not writable a #GSettings object the name of the key to set a #GVariant of the correct type The name of the context that the settings are stored in. Whether the #GSettings object is in 'delay-apply' mode. See g_settings_delay() for details. If this property is %TRUE, the #GSettings object has outstanding changes that will be applied when g_settings_apply() is called. The path within the backend where the settings are stored. The name of the schema that describes the types of keys for this #GSettings object. The type of this property is *not* #GSettingsSchema. #GSettingsSchema has only existed since version 2.32 and unfortunately this name was used in previous versions to refer to the schema ID rather than the schema itself. Take care to use the 'settings-schema' property if you wish to pass in a #GSettingsSchema. Use the 'schema-id' property instead. In a future version, this property may instead refer to a #GSettingsSchema. The name of the schema that describes the types of keys for this #GSettings object. The #GSettingsSchema describing the types of keys for this #GSettings object. Ideally, this property would be called 'schema'. #GSettingsSchema has only existed since version 2.32, however, and before then the 'schema' property was used to refer to the ID of the schema rather than the schema itself. Take care. The "change-event" signal is emitted once per change event that affects this settings object. You should connect to this signal only if you are interested in viewing groups of changes before they are split out into multiple emissions of the "changed" signal. For most use cases it is more appropriate to use the "changed" signal. In the event that the change event applies to one or more specified keys, @keys will be an array of #GQuark of length @n_keys. In the event that the change event applies to the #GSettings object as a whole (ie: potentially every key has been changed) then @keys will be %NULL and @n_keys will be 0. The default handler for this signal invokes the "changed" signal for each affected key. If any other connected handler returns %TRUE then this default functionality will be suppressed. %TRUE to stop other handlers from being invoked for the event. FALSE to propagate the event further. an array of #GQuarks for the changed keys, or %NULL the length of the @keys array, or 0 The "changed" signal is emitted when a key has potentially changed. You should call one of the g_settings_get() calls to check the new value. This signal supports detailed connections. You can connect to the detailed signal "changed::x" in order to only receive callbacks when key "x" changes. Note that @settings only emits this signal if you have read @key at least once while a signal handler was already connected for @key. the name of the key that changed The "writable-change-event" signal is emitted once per writability change event that affects this settings object. You should connect to this signal if you are interested in viewing groups of changes before they are split out into multiple emissions of the "writable-changed" signal. For most use cases it is more appropriate to use the "writable-changed" signal. In the event that the writability change applies only to a single key, @key will be set to the #GQuark for that key. In the event that the writability change affects the entire settings object, @key will be 0. The default handler for this signal invokes the "writable-changed" and "changed" signals for each affected key. This is done because changes in writability might also imply changes in value (if for example, a new mandatory setting is introduced). If any other connected handler returns %TRUE then this default functionality will be suppressed. %TRUE to stop other handlers from being invoked for the event. FALSE to propagate the event further. the quark of the key, or 0 The "writable-changed" signal is emitted when the writability of a key has potentially changed. You should call g_settings_is_writable() in order to determine the new status. This signal supports detailed connections. You can connect to the detailed signal "writable-changed::x" in order to only receive callbacks when the writability of "x" changes. the key The #GSettingsBackend interface defines a generic interface for non-strictly-typed data that is stored in a hierarchy. To implement an alternative storage backend for #GSettings, you need to implement the #GSettingsBackend interface and then make it implement the extension point #G_SETTINGS_BACKEND_EXTENSION_POINT_NAME. The interface defines methods for reading and writing values, a method for determining if writing of certain values will fail (lockdown) and a change notification mechanism. The semantics of the interface are very precisely defined and implementations must carefully adhere to the expectations of callers that are documented on each of the interface methods. Some of the #GSettingsBackend functions accept or return a #GTree. These trees always have strings as keys and #GVariant as values. g_settings_backend_create_tree() is a convenience function to create suitable trees. The #GSettingsBackend API is exported to allow third-party implementations, but does not carry the same stability guarantees as the public GIO API. For this reason, you have to define the C preprocessor symbol %G_SETTINGS_ENABLE_BACKEND before including `gio/gsettingsbackend.h`. Calculate the longest common prefix of all keys in a tree and write out an array of the key names relative to that prefix and, optionally, the value to store at each of those keys. You must free the value returned in @path, @keys and @values using g_free(). You should not attempt to free or unref the contents of @keys or @values. a #GTree containing the changes the location to save the path the location to save the relative keys the location to save the values, or %NULL Returns the default #GSettingsBackend. It is possible to override the default by setting the `GSETTINGS_BACKEND` environment variable to the name of a settings backend. The user gets a reference to the backend. the default #GSettingsBackend Signals that a single key has possibly changed. Backend implementations should call this if a key has possibly changed its value. @key must be a valid key (ie starting with a slash, not containing '//', and not ending with a slash). The implementation must call this function during any call to g_settings_backend_write(), before the call returns (except in the case that no keys are actually changed and it cares to detect this fact). It may not rely on the existence of a mainloop for dispatching the signal later. The implementation may call this function at any other time it likes in response to other events (such as changes occurring outside of the program). These calls may originate from a mainloop or may originate in response to any other action (including from calls to g_settings_backend_write()). In the case that this call is in response to a call to g_settings_backend_write() then @origin_tag must be set to the same value that was passed to that call. a #GSettingsBackend implementation the name of the key the origin tag This call is a convenience wrapper. It gets the list of changes from @tree, computes the longest common prefix and calls g_settings_backend_changed(). a #GSettingsBackend implementation a #GTree containing the changes the origin tag Signals that a list of keys have possibly changed. Backend implementations should call this if keys have possibly changed their values. @path must be a valid path (ie starting and ending with a slash and not containing '//'). Each string in @items must form a valid key name when @path is prefixed to it (ie: each item must not start or end with '/' and must not contain '//'). The meaning of this signal is that any of the key names resulting from the contatenation of @path with each item in @items may have changed. The same rules for when notifications must occur apply as per g_settings_backend_changed(). These two calls can be used interchangeably if exactly one item has changed (although in that case g_settings_backend_changed() is definitely preferred). For efficiency reasons, the implementation should strive for @path to be as long as possible (ie: the longest common prefix of all of the keys that were changed) but this is not strictly required. a #GSettingsBackend implementation the path containing the changes the %NULL-terminated list of changed keys the origin tag Signals that all keys below a given path may have possibly changed. Backend implementations should call this if an entire path of keys have possibly changed their values. @path must be a valid path (ie starting and ending with a slash and not containing '//'). The meaning of this signal is that any of the key which has a name starting with @path may have changed. The same rules for when notifications must occur apply as per g_settings_backend_changed(). This call might be an appropriate reasponse to a 'reset' call but implementations are also free to explicitly list the keys that were affected by that call if they can easily do so. For efficiency reasons, the implementation should strive for @path to be as long as possible (ie: the longest common prefix of all of the keys that were changed) but this is not strictly required. As an example, if this function is called with the path of "/" then every single key in the application will be notified of a possible change. a #GSettingsBackend implementation the path containing the changes the origin tag Signals that the writability of all keys below a given path may have changed. Since GSettings performs no locking operations for itself, this call will always be made in response to external events. a #GSettingsBackend implementation the name of the path Signals that the writability of a single key has possibly changed. Since GSettings performs no locking operations for itself, this call will always be made in response to external events. a #GSettingsBackend implementation the name of the key Class structure for #GSettingsBackend. Flags used when creating a binding. These flags determine in which direction the binding works. The default is to synchronize in both directions. Equivalent to `G_SETTINGS_BIND_GET|G_SETTINGS_BIND_SET` Update the #GObject property when the setting changes. It is an error to use this flag if the property is not writable. Update the setting when the #GObject property changes. It is an error to use this flag if the property is not readable. Do not try to bind a "sensitivity" property to the writability of the setting When set in addition to #G_SETTINGS_BIND_GET, set the #GObject property value initially from the setting, but do not listen for changes of the setting When passed to g_settings_bind(), uses a pair of mapping functions that invert the boolean value when mapping between the setting and the property. The setting and property must both be booleans. You cannot pass this flag to g_settings_bind_with_mapping(). The type for the function that is used to convert from #GSettings to an object property. The @value is already initialized to hold values of the appropriate type. %TRUE if the conversion succeeded, %FALSE in case of an error return location for the property value the #GVariant user data that was specified when the binding was created The type for the function that is used to convert an object property value to a #GVariant for storing it in #GSettings. a new #GVariant holding the data from @value, or %NULL in case of an error a #GValue containing the property value to map the #GVariantType to create user data that was specified when the binding was created The type of the function that is used to convert from a value stored in a #GSettings to a value that is useful to the application. If the value is successfully mapped, the result should be stored at @result and %TRUE returned. If mapping fails (for example, if @value is not in the right format) then %FALSE should be returned. If @value is %NULL then it means that the mapping function is being given a "last chance" to successfully return a valid value. %TRUE must be returned in this case. %TRUE if the conversion succeeded, %FALSE in case of an error the #GVariant to map, or %NULL the result of the mapping the user data that was passed to g_settings_get_mapped() The #GSettingsSchemaSource and #GSettingsSchema APIs provide a mechanism for advanced control over the loading of schemas and a mechanism for introspecting their content. Plugin loading systems that wish to provide plugins a way to access settings face the problem of how to make the schemas for these settings visible to GSettings. Typically, a plugin will want to ship the schema along with itself and it won't be installed into the standard system directories for schemas. #GSettingsSchemaSource provides a mechanism for dealing with this by allowing the creation of a new 'schema source' from which schemas can be acquired. This schema source can then become part of the metadata associated with the plugin and queried whenever the plugin requires access to some settings. Consider the following example: |[<!-- language="C" --> typedef struct { ... GSettingsSchemaSource *schema_source; ... } Plugin; Plugin * initialise_plugin (const gchar *dir) { Plugin *plugin; ... plugin->schema_source = g_settings_schema_source_new_from_directory (dir, g_settings_schema_source_get_default (), FALSE, NULL); ... return plugin; } ... GSettings * plugin_get_settings (Plugin *plugin, const gchar *schema_id) { GSettingsSchema *schema; if (schema_id == NULL) schema_id = plugin->identifier; schema = g_settings_schema_source_lookup (plugin->schema_source, schema_id, FALSE); if (schema == NULL) { ... disable the plugin or abort, etc ... } return g_settings_new_full (schema, NULL, NULL); } ]| The code above shows how hooks should be added to the code that initialises (or enables) the plugin to create the schema source and how an API can be added to the plugin system to provide a convenient way for the plugin to access its settings, using the schemas that it ships. From the standpoint of the plugin, it would need to ensure that it ships a gschemas.compiled file as part of itself, and then simply do the following: |[<!-- language="C" --> { GSettings *settings; gint some_value; settings = plugin_get_settings (self, NULL); some_value = g_settings_get_int (settings, "some-value"); ... } ]| It's also possible that the plugin system expects the schema source files (ie: .gschema.xml files) instead of a gschemas.compiled file. In that case, the plugin loading system must compile the schemas for itself before attempting to create the settings source. Get the ID of @schema. the ID a #GSettingsSchema Gets the key named @name from @schema. It is a programmer error to request a key that does not exist. See g_settings_schema_list_keys(). the #GSettingsSchemaKey for @name a #GSettingsSchema the name of a key Gets the path associated with @schema, or %NULL. Schemas may be single-instance or relocatable. Single-instance schemas correspond to exactly one set of keys in the backend database: those located at the path returned by this function. Relocatable schemas can be referenced by other schemas and can therefore describe multiple sets of keys at different locations. For relocatable schemas, this function will return %NULL. the path of the schema, or %NULL a #GSettingsSchema Checks if @schema has a key named @name. %TRUE if such a key exists a #GSettingsSchema the name of a key Gets the list of children in @schema. You should free the return value with g_strfreev() when you are done with it. a list of the children on @settings, in no defined order a #GSettingsSchema Introspects the list of keys on @schema. You should probably not be calling this function from "normal" code (since you should already know what keys are in your schema). This function is intended for introspection reasons. a list of the keys on @schema, in no defined order a #GSettingsSchema Increase the reference count of @schema, returning a new reference. a new reference to @schema a #GSettingsSchema Decrease the reference count of @schema, possibly freeing it. a #GSettingsSchema #GSettingsSchemaKey is an opaque data structure and can only be accessed using the following functions. Gets the default value for @key. Note that this is the default value according to the schema. System administrator defaults and lockdown are not visible via this API. the default value for the key a #GSettingsSchemaKey Gets the description for @key. If no description has been provided in the schema for @key, returns %NULL. The description can be one sentence to several paragraphs in length. Paragraphs are delimited with a double newline. Descriptions can be translated and the value returned from this function is is the current locale. This function is slow. The summary and description information for the schemas is not stored in the compiled schema database so this function has to parse all of the source XML files in the schema directory. the description for @key, or %NULL a #GSettingsSchemaKey Gets the name of @key. the name of @key. a #GSettingsSchemaKey Queries the range of a key. This function will return a #GVariant that fully describes the range of values that are valid for @key. The type of #GVariant returned is `(sv)`. The string describes the type of range restriction in effect. The type and meaning of the value contained in the variant depends on the string. If the string is `'type'` then the variant contains an empty array. The element type of that empty array is the expected type of value and all values of that type are valid. If the string is `'enum'` then the variant contains an array enumerating the possible values. Each item in the array is a possible valid value and no other values are valid. If the string is `'flags'` then the variant contains an array. Each item in the array is a value that may appear zero or one times in an array to be used as the value for this key. For example, if the variant contained the array `['x', 'y']` then the valid values for the key would be `[]`, `['x']`, `['y']`, `['x', 'y']` and `['y', 'x']`. Finally, if the string is `'range'` then the variant contains a pair of like-typed values -- the minimum and maximum permissible values for this key. This information should not be used by normal programs. It is considered to be a hint for introspection purposes. Normal programs should already know what is permitted by their own schema. The format may change in any way in the future -- but particularly, new forms may be added to the possibilities described above. You should free the returned value with g_variant_unref() when it is no longer needed. a #GVariant describing the range a #GSettingsSchemaKey Gets the summary for @key. If no summary has been provided in the schema for @key, returns %NULL. The summary is a short description of the purpose of the key; usually one short sentence. Summaries can be translated and the value returned from this function is is the current locale. This function is slow. The summary and description information for the schemas is not stored in the compiled schema database so this function has to parse all of the source XML files in the schema directory. the summary for @key, or %NULL a #GSettingsSchemaKey Gets the #GVariantType of @key. the type of @key a #GSettingsSchemaKey Checks if the given @value is of the correct type and within the permitted range for @key. It is a programmer error if @value is not of the correct type -- you must check for this first. %TRUE if @value is valid for @key a #GSettingsSchemaKey the value to check Increase the reference count of @key, returning a new reference. a new reference to @key a #GSettingsSchemaKey Decrease the reference count of @key, possibly freeing it. a #GSettingsSchemaKey This is an opaque structure type. You may not access it directly. Attempts to create a new schema source corresponding to the contents of the given directory. This function is not required for normal uses of #GSettings but it may be useful to authors of plugin management systems. The directory should contain a file called `gschemas.compiled` as produced by the [glib-compile-schemas][glib-compile-schemas] tool. If @trusted is %TRUE then `gschemas.compiled` is trusted not to be corrupted. This assumption has a performance advantage, but can result in crashes or inconsistent behaviour in the case of a corrupted file. Generally, you should set @trusted to %TRUE for files installed by the system and to %FALSE for files in the home directory. In either case, an empty file or some types of corruption in the file will result in %G_FILE_ERROR_INVAL being returned. If @parent is non-%NULL then there are two effects. First, if g_settings_schema_source_lookup() is called with the @recursive flag set to %TRUE and the schema can not be found in the source, the lookup will recurse to the parent. Second, any references to other schemas specified within this source (ie: `child` or `extends`) references may be resolved from the @parent. For this second reason, except in very unusual situations, the @parent should probably be given as the default schema source, as returned by g_settings_schema_source_get_default(). the filename of a directory a #GSettingsSchemaSource, or %NULL %TRUE, if the directory is trusted Lists the schemas in a given source. If @recursive is %TRUE then include parent sources. If %FALSE then only include the schemas from one source (ie: one directory). You probably want %TRUE. Non-relocatable schemas are those for which you can call g_settings_new(). Relocatable schemas are those for which you must use g_settings_new_with_path(). Do not call this function from normal programs. This is designed for use by database editors, commandline tools, etc. a #GSettingsSchemaSource if we should recurse the list of non-relocatable schemas, in no defined order the list of relocatable schemas, in no defined order Looks up a schema with the identifier @schema_id in @source. This function is not required for normal uses of #GSettings but it may be useful to authors of plugin management systems or to those who want to introspect the content of schemas. If the schema isn't found directly in @source and @recursive is %TRUE then the parent sources will also be checked. If the schema isn't found, %NULL is returned. a new #GSettingsSchema a #GSettingsSchemaSource a schema ID %TRUE if the lookup should be recursive Increase the reference count of @source, returning a new reference. a new reference to @source a #GSettingsSchemaSource Decrease the reference count of @source, possibly freeing it. a #GSettingsSchemaSource Gets the default system schema source. This function is not required for normal uses of #GSettings but it may be useful to authors of plugin management systems or to those who want to introspect the content of schemas. If no schemas are installed, %NULL will be returned. The returned source may actually consist of multiple schema sources from different directories, depending on which directories were given in `XDG_DATA_DIRS` and `GSETTINGS_SCHEMA_DIR`. For this reason, all lookups performed against the default source should probably be done recursively. the default schema source A #GSimpleAction is the obvious simple implementation of the #GAction interface. This is the easiest way to create an action for purposes of adding it to a #GSimpleActionGroup. See also #GtkAction. Creates a new action. The created action is stateless. See g_simple_action_new_stateful() to create an action that has state. a new #GSimpleAction the name of the action the type of parameter that will be passed to handlers for the #GSimpleAction::activate signal, or %NULL for no parameter Creates a new stateful action. All future state values must have the same #GVariantType as the initial @state. If the @state #GVariant is floating, it is consumed. a new #GSimpleAction the name of the action the type of the parameter that will be passed to handlers for the #GSimpleAction::activate signal, or %NULL for no parameter the initial state of the action Sets the action as enabled or not. An action must be enabled in order to be activated or in order to have its state changed from outside callers. This should only be called by the implementor of the action. Users of the action should not attempt to modify its enabled flag. a #GSimpleAction whether the action is enabled Sets the state of the action. This directly updates the 'state' property to the given value. This should only be called by the implementor of the action. Users of the action should not attempt to directly modify the 'state' property. Instead, they should call g_action_change_state() to request the change. If the @value GVariant is floating, it is consumed. a #GSimpleAction the new #GVariant for the state Sets the state hint for the action. See g_action_get_state_hint() for more information about action state hints. a #GSimpleAction a #GVariant representing the state hint If @action is currently enabled. If the action is disabled then calls to g_action_activate() and g_action_change_state() have no effect. The name of the action. This is mostly meaningful for identifying the action once it has been added to a #GSimpleActionGroup. The type of the parameter that must be given when activating the action. The state of the action, or %NULL if the action is stateless. The #GVariantType of the state that the action has, or %NULL if the action is stateless. Indicates that the action was just activated. @parameter will always be of the expected type, i.e. the parameter type specified when the action was created. If an incorrect type is given when activating the action, this signal is not emitted. Since GLib 2.40, if no handler is connected to this signal then the default behaviour for boolean-stated actions with a %NULL parameter type is to toggle them via the #GSimpleAction::change-state signal. For stateful actions where the state type is equal to the parameter type, the default is to forward them directly to #GSimpleAction::change-state. This should allow almost all users of #GSimpleAction to connect only one handler or the other. the parameter to the activation, or %NULL if it has no parameter Indicates that the action just received a request to change its state. @value will always be of the correct state type, i.e. the type of the initial state passed to g_simple_action_new_stateful(). If an incorrect type is given when requesting to change the state, this signal is not emitted. If no handler is connected to this signal then the default behaviour is to call g_simple_action_set_state() to set the state to the requested value. If you connect a signal handler then no default action is taken. If the state should change then you must call g_simple_action_set_state() from the handler. An example of a 'change-state' handler: |[<!-- language="C" --> static void change_volume_state (GSimpleAction *action, GVariant *value, gpointer user_data) { gint requested; requested = g_variant_get_int32 (value); // Volume only goes from 0 to 10 if (0 <= requested && requested <= 10) g_simple_action_set_state (action, value); } ]| The handler need not set the state to the requested value. It could set it to any value at all, or take some other action. the requested value for the state #GSimpleActionGroup is a hash table filled with #GAction objects, implementing the #GActionGroup and #GActionMap interfaces. Creates a new, empty, #GSimpleActionGroup. a new #GSimpleActionGroup A convenience function for creating multiple #GSimpleAction instances and adding them to the action group. Use g_action_map_add_action_entries() a #GSimpleActionGroup a pointer to the first item in an array of #GActionEntry structs the length of @entries, or -1 the user data for signal connections Adds an action to the action group. If the action group already contains an action with the same name as @action then the old action is dropped from the group. The action group takes its own reference on @action. Use g_action_map_add_action() a #GSimpleActionGroup a #GAction Looks up the action with the name @action_name in the group. If no such action exists, returns %NULL. Use g_action_map_lookup_action() a #GAction, or %NULL a #GSimpleActionGroup the name of an action Removes the named action from the action group. If no action of this name is in the group then nothing happens. Use g_action_map_remove_action() a #GSimpleActionGroup the name of the action As of GLib 2.46, #GSimpleAsyncResult is deprecated in favor of #GTask, which provides a simpler API. #GSimpleAsyncResult implements #GAsyncResult. GSimpleAsyncResult handles #GAsyncReadyCallbacks, error reporting, operation cancellation and the final state of an operation, completely transparent to the application. Results can be returned as a pointer e.g. for functions that return data that is collected asynchronously, a boolean value for checking the success or failure of an operation, or a #gssize for operations which return the number of bytes modified by the operation; all of the simple return cases are covered. Most of the time, an application will not need to know of the details of this API; it is handled transparently, and any necessary operations are handled by #GAsyncResult's interface. However, if implementing a new GIO module, for writing language bindings, or for complex applications that need better control of how asynchronous operations are completed, it is important to understand this functionality. GSimpleAsyncResults are tagged with the calling function to ensure that asynchronous functions and their finishing functions are used together correctly. To create a new #GSimpleAsyncResult, call g_simple_async_result_new(). If the result needs to be created for a #GError, use g_simple_async_result_new_from_error() or g_simple_async_result_new_take_error(). If a #GError is not available (e.g. the asynchronous operation's doesn't take a #GError argument), but the result still needs to be created for an error condition, use g_simple_async_result_new_error() (or g_simple_async_result_set_error_va() if your application or binding requires passing a variable argument list directly), and the error can then be propagated through the use of g_simple_async_result_propagate_error(). An asynchronous operation can be made to ignore a cancellation event by calling g_simple_async_result_set_handle_cancellation() with a #GSimpleAsyncResult for the operation and %FALSE. This is useful for operations that are dangerous to cancel, such as close (which would cause a leak if cancelled before being run). GSimpleAsyncResult can integrate into GLib's event loop, #GMainLoop, or it can use #GThreads. g_simple_async_result_complete() will finish an I/O task directly from the point where it is called. g_simple_async_result_complete_in_idle() will finish it from an idle handler in the [thread-default main context][g-main-context-push-thread-default] where the #GSimpleAsyncResult was created. g_simple_async_result_run_in_thread() will run the job in a separate thread and then use g_simple_async_result_complete_in_idle() to deliver the result. To set the results of an asynchronous function, g_simple_async_result_set_op_res_gpointer(), g_simple_async_result_set_op_res_gboolean(), and g_simple_async_result_set_op_res_gssize() are provided, setting the operation's result to a gpointer, gboolean, or gssize, respectively. Likewise, to get the result of an asynchronous function, g_simple_async_result_get_op_res_gpointer(), g_simple_async_result_get_op_res_gboolean(), and g_simple_async_result_get_op_res_gssize() are provided, getting the operation's result as a gpointer, gboolean, and gssize, respectively. For the details of the requirements implementations must respect, see #GAsyncResult. A typical implementation of an asynchronous operation using GSimpleAsyncResult looks something like this: |[<!-- language="C" --> static void baked_cb (Cake *cake, gpointer user_data) { // In this example, this callback is not given a reference to the cake, // so the GSimpleAsyncResult has to take a reference to it. GSimpleAsyncResult *result = user_data; if (cake == NULL) g_simple_async_result_set_error (result, BAKER_ERRORS, BAKER_ERROR_NO_FLOUR, "Go to the supermarket"); else g_simple_async_result_set_op_res_gpointer (result, g_object_ref (cake), g_object_unref); // In this example, we assume that baked_cb is called as a callback from // the mainloop, so it's safe to complete the operation synchronously here. // If, however, _baker_prepare_cake () might call its callback without // first returning to the mainloop — inadvisable, but some APIs do so — // we would need to use g_simple_async_result_complete_in_idle(). g_simple_async_result_complete (result); g_object_unref (result); } void baker_bake_cake_async (Baker *self, guint radius, GAsyncReadyCallback callback, gpointer user_data) { GSimpleAsyncResult *simple; Cake *cake; if (radius < 3) { g_simple_async_report_error_in_idle (G_OBJECT (self), callback, user_data, BAKER_ERRORS, BAKER_ERROR_TOO_SMALL, "%ucm radius cakes are silly", radius); return; } simple = g_simple_async_result_new (G_OBJECT (self), callback, user_data, baker_bake_cake_async); cake = _baker_get_cached_cake (self, radius); if (cake != NULL) { g_simple_async_result_set_op_res_gpointer (simple, g_object_ref (cake), g_object_unref); g_simple_async_result_complete_in_idle (simple); g_object_unref (simple); // Drop the reference returned by _baker_get_cached_cake(); // the GSimpleAsyncResult has taken its own reference. g_object_unref (cake); return; } _baker_prepare_cake (self, radius, baked_cb, simple); } Cake * baker_bake_cake_finish (Baker *self, GAsyncResult *result, GError **error) { GSimpleAsyncResult *simple; Cake *cake; g_return_val_if_fail (g_simple_async_result_is_valid (result, G_OBJECT (self), baker_bake_cake_async), NULL); simple = (GSimpleAsyncResult *) result; if (g_simple_async_result_propagate_error (simple, error)) return NULL; cake = CAKE (g_simple_async_result_get_op_res_gpointer (simple)); return g_object_ref (cake); } ]| Creates a #GSimpleAsyncResult. The common convention is to create the #GSimpleAsyncResult in the function that starts the asynchronous operation and use that same function as the @source_tag. If your operation supports cancellation with #GCancellable (which it probably should) then you should provide the user's cancellable to g_simple_async_result_set_check_cancellable() immediately after this function returns. Use g_task_new() instead. a #GSimpleAsyncResult. a #GObject, or %NULL. a #GAsyncReadyCallback. user data passed to @callback. the asynchronous function. Creates a new #GSimpleAsyncResult with a set error. Use g_task_new() and g_task_return_new_error() instead. a #GSimpleAsyncResult. a #GObject, or %NULL. a #GAsyncReadyCallback. user data passed to @callback. a #GQuark. an error code. a string with format characters. a list of values to insert into @format. Creates a #GSimpleAsyncResult from an error condition. Use g_task_new() and g_task_return_error() instead. a #GSimpleAsyncResult. a #GObject, or %NULL. a #GAsyncReadyCallback. user data passed to @callback. a #GError Creates a #GSimpleAsyncResult from an error condition, and takes over the caller's ownership of @error, so the caller does not need to free it anymore. Use g_task_new() and g_task_return_error() instead. a #GSimpleAsyncResult a #GObject, or %NULL a #GAsyncReadyCallback user data passed to @callback a #GError Ensures that the data passed to the _finish function of an async operation is consistent. Three checks are performed. First, @result is checked to ensure that it is really a #GSimpleAsyncResult. Second, @source is checked to ensure that it matches the source object of @result. Third, @source_tag is checked to ensure that it is equal to the @source_tag argument given to g_simple_async_result_new() (which, by convention, is a pointer to the _async function corresponding to the _finish function from which this function is called). (Alternatively, if either @source_tag or @result's source tag is %NULL, then the source tag check is skipped.) Use #GTask and g_task_is_valid() instead. #TRUE if all checks passed or #FALSE if any failed. the #GAsyncResult passed to the _finish function. the #GObject passed to the _finish function. the asynchronous function. Completes an asynchronous I/O job immediately. Must be called in the thread where the asynchronous result was to be delivered, as it invokes the callback directly. If you are in a different thread use g_simple_async_result_complete_in_idle(). Calling this function takes a reference to @simple for as long as is needed to complete the call. Use #GTask instead. a #GSimpleAsyncResult. Completes an asynchronous function in an idle handler in the [thread-default main context][g-main-context-push-thread-default] of the thread that @simple was initially created in (and re-pushes that context around the invocation of the callback). Calling this function takes a reference to @simple for as long as is needed to complete the call. Use #GTask instead. a #GSimpleAsyncResult. Gets the operation result boolean from within the asynchronous result. Use #GTask and g_task_propagate_boolean() instead. %TRUE if the operation's result was %TRUE, %FALSE if the operation's result was %FALSE. a #GSimpleAsyncResult. Gets a pointer result as returned by the asynchronous function. Use #GTask and g_task_propagate_pointer() instead. a pointer from the result. a #GSimpleAsyncResult. Gets a gssize from the asynchronous result. Use #GTask and g_task_propagate_int() instead. a gssize returned from the asynchronous function. a #GSimpleAsyncResult. Gets the source tag for the #GSimpleAsyncResult. Use #GTask and g_task_get_source_tag() instead. a #gpointer to the source object for the #GSimpleAsyncResult. a #GSimpleAsyncResult. Propagates an error from within the simple asynchronous result to a given destination. If the #GCancellable given to a prior call to g_simple_async_result_set_check_cancellable() is cancelled then this function will return %TRUE with @dest set appropriately. Use #GTask instead. %TRUE if the error was propagated to @dest. %FALSE otherwise. a #GSimpleAsyncResult. Runs the asynchronous job in a separate thread and then calls g_simple_async_result_complete_in_idle() on @simple to return the result to the appropriate main loop. Calling this function takes a reference to @simple for as long as is needed to run the job and report its completion. Use #GTask and g_task_run_in_thread() instead. a #GSimpleAsyncResult. a #GSimpleAsyncThreadFunc. the io priority of the request. optional #GCancellable object, %NULL to ignore. Sets a #GCancellable to check before dispatching results. This function has one very specific purpose: the provided cancellable is checked at the time of g_simple_async_result_propagate_error() If it is cancelled, these functions will return an "Operation was cancelled" error (%G_IO_ERROR_CANCELLED). Implementors of cancellable asynchronous functions should use this in order to provide a guarantee to their callers that cancelling an async operation will reliably result in an error being returned for that operation (even if a positive result for the operation has already been sent as an idle to the main context to be dispatched). The checking described above is done regardless of any call to the unrelated g_simple_async_result_set_handle_cancellation() function. Use #GTask instead. a #GSimpleAsyncResult a #GCancellable to check, or %NULL to unset Sets an error within the asynchronous result without a #GError. Use #GTask and g_task_return_new_error() instead. a #GSimpleAsyncResult. a #GQuark (usually #G_IO_ERROR). an error code. a formatted error reporting string. a list of variables to fill in @format. Sets an error within the asynchronous result without a #GError. Unless writing a binding, see g_simple_async_result_set_error(). Use #GTask and g_task_return_error() instead. a #GSimpleAsyncResult. a #GQuark (usually #G_IO_ERROR). an error code. a formatted error reporting string. va_list of arguments. Sets the result from a #GError. Use #GTask and g_task_return_error() instead. a #GSimpleAsyncResult. #GError. Sets whether to handle cancellation within the asynchronous operation. This function has nothing to do with g_simple_async_result_set_check_cancellable(). It only refers to the #GCancellable passed to g_simple_async_result_run_in_thread(). a #GSimpleAsyncResult. a #gboolean. Sets the operation result to a boolean within the asynchronous result. Use #GTask and g_task_return_boolean() instead. a #GSimpleAsyncResult. a #gboolean. Sets the operation result within the asynchronous result to a pointer. Use #GTask and g_task_return_pointer() instead. a #GSimpleAsyncResult. a pointer result from an asynchronous function. a #GDestroyNotify function. Sets the operation result within the asynchronous result to the given @op_res. Use #GTask and g_task_return_int() instead. a #GSimpleAsyncResult. a #gssize. Sets the result from @error, and takes over the caller's ownership of @error, so the caller does not need to free it any more. Use #GTask and g_task_return_error() instead. a #GSimpleAsyncResult a #GError Simple thread function that runs an asynchronous operation and checks for cancellation. a #GSimpleAsyncResult. a #GObject. optional #GCancellable object, %NULL to ignore. GSimpleIOStream creates a #GIOStream from an arbitrary #GInputStream and #GOutputStream. This allows any pair of input and output streams to be used with #GIOStream methods. This is useful when you obtained a #GInputStream and a #GOutputStream by other means, for instance creating them with platform specific methods as g_unix_input_stream_new() or g_win32_input_stream_new(), and you want to take advantage of the methods provided by #GIOStream. Creates a new #GSimpleIOStream wrapping @input_stream and @output_stream. See also #GIOStream. a new #GSimpleIOStream instance. a #GInputStream. a #GOutputStream. #GSimplePermission is a trivial implementation of #GPermission that represents a permission that is either always or never allowed. The value is given at construction and doesn't change. Calling request or release will result in errors. Creates a new #GPermission instance that represents an action that is either always or never allowed. the #GSimplePermission, as a #GPermission %TRUE if the action is allowed #GSimpleProxyResolver is a simple #GProxyResolver implementation that handles a single default proxy, multiple URI-scheme-specific proxies, and a list of hosts that proxies should not be used for. #GSimpleProxyResolver is never the default proxy resolver, but it can be used as the base class for another proxy resolver implementation, or it can be created and used manually, such as with g_socket_client_set_proxy_resolver(). Creates a new #GSimpleProxyResolver. See #GSimpleProxyResolver:default-proxy and #GSimpleProxyResolver:ignore-hosts for more details on how the arguments are interpreted. a new #GSimpleProxyResolver the default proxy to use, eg "socks://192.168.1.1" an optional list of hosts/IP addresses to not use a proxy for. Sets the default proxy on @resolver, to be used for any URIs that don't match #GSimpleProxyResolver:ignore-hosts or a proxy set via g_simple_proxy_resolver_set_uri_proxy(). If @default_proxy starts with "socks://", #GSimpleProxyResolver will treat it as referring to all three of the socks5, socks4a, and socks4 proxy types. a #GSimpleProxyResolver the default proxy to use Sets the list of ignored hosts. See #GSimpleProxyResolver:ignore-hosts for more details on how the @ignore_hosts argument is interpreted. a #GSimpleProxyResolver %NULL-terminated list of hosts/IP addresses to not use a proxy for Adds a URI-scheme-specific proxy to @resolver; URIs whose scheme matches @uri_scheme (and which don't match #GSimpleProxyResolver:ignore-hosts) will be proxied via @proxy. As with #GSimpleProxyResolver:default-proxy, if @proxy starts with "socks://", #GSimpleProxyResolver will treat it as referring to all three of the socks5, socks4a, and socks4 proxy types. a #GSimpleProxyResolver the URI scheme to add a proxy for the proxy to use for @uri_scheme The default proxy URI that will be used for any URI that doesn't match #GSimpleProxyResolver:ignore-hosts, and doesn't match any of the schemes set with g_simple_proxy_resolver_set_uri_proxy(). Note that as a special case, if this URI starts with "socks://", #GSimpleProxyResolver will treat it as referring to all three of the socks5, socks4a, and socks4 proxy types. A list of hostnames and IP addresses that the resolver should allow direct connections to. Entries can be in one of 4 formats: - A hostname, such as "example.com", ".example.com", or "*.example.com", any of which match "example.com" or any subdomain of it. - An IPv4 or IPv6 address, such as "192.168.1.1", which matches only that address. - A hostname or IP address followed by a port, such as "example.com:80", which matches whatever the hostname or IP address would match, but only for URLs with the (explicitly) indicated port. In the case of an IPv6 address, the address part must appear in brackets: "[::1]:443" - An IP address range, given by a base address and prefix length, such as "fe80::/10", which matches any address in that range. Note that when dealing with Unicode hostnames, the matching is done against the ASCII form of the name. Also note that hostname exclusions apply only to connections made to hosts identified by name, and IP address exclusions apply only to connections made to hosts identified by address. That is, if example.com has an address of 192.168.1.1, and the :ignore-hosts list contains only "192.168.1.1", then a connection to "example.com" (eg, via a #GNetworkAddress) will use the proxy, and a connection to "192.168.1.1" (eg, via a #GInetSocketAddress) will not. These rules match the "ignore-hosts"/"noproxy" rules most commonly used by other applications. A #GSocket is a low-level networking primitive. It is a more or less direct mapping of the BSD socket API in a portable GObject based API. It supports both the UNIX socket implementations and winsock2 on Windows. #GSocket is the platform independent base upon which the higher level network primitives are based. Applications are not typically meant to use it directly, but rather through classes like #GSocketClient, #GSocketService and #GSocketConnection. However there may be cases where direct use of #GSocket is useful. #GSocket implements the #GInitable interface, so if it is manually constructed by e.g. g_object_new() you must call g_initable_init() and check the results before using the object. This is done automatically in g_socket_new() and g_socket_new_from_fd(), so these functions can return %NULL. Sockets operate in two general modes, blocking or non-blocking. When in blocking mode all operations (which don’t take an explicit blocking parameter) block until the requested operation is finished or there is an error. In non-blocking mode all calls that would block return immediately with a %G_IO_ERROR_WOULD_BLOCK error. To know when a call would successfully run you can call g_socket_condition_check(), or g_socket_condition_wait(). You can also use g_socket_create_source() and attach it to a #GMainContext to get callbacks when I/O is possible. Note that all sockets are always set to non blocking mode in the system, and blocking mode is emulated in GSocket. When working in non-blocking mode applications should always be able to handle getting a %G_IO_ERROR_WOULD_BLOCK error even when some other function said that I/O was possible. This can easily happen in case of a race condition in the application, but it can also happen for other reasons. For instance, on Windows a socket is always seen as writable until a write returns %G_IO_ERROR_WOULD_BLOCK. #GSockets can be either connection oriented or datagram based. For connection oriented types you must first establish a connection by either connecting to an address or accepting a connection from another address. For connectionless socket types the target/source address is specified or received in each I/O operation. All socket file descriptors are set to be close-on-exec. Note that creating a #GSocket causes the signal %SIGPIPE to be ignored for the remainder of the program. If you are writing a command-line utility that uses #GSocket, you may need to take into account the fact that your program will not automatically be killed if it tries to write to %stdout after it has been closed. Like most other APIs in GLib, #GSocket is not inherently thread safe. To use a #GSocket concurrently from multiple threads, you must implement your own locking. Creates a new #GSocket with the defined family, type and protocol. If @protocol is 0 (%G_SOCKET_PROTOCOL_DEFAULT) the default protocol type for the family and type is used. The @protocol is a family and type specific int that specifies what kind of protocol to use. #GSocketProtocol lists several common ones. Many families only support one protocol, and use 0 for this, others support several and using 0 means to use the default protocol for the family and type. The protocol id is passed directly to the operating system, so you can use protocols not listed in #GSocketProtocol if you know the protocol number used for it. a #GSocket or %NULL on error. Free the returned object with g_object_unref(). the socket family to use, e.g. %G_SOCKET_FAMILY_IPV4. the socket type to use. the id of the protocol to use, or 0 for default. Creates a new #GSocket from a native file descriptor or winsock SOCKET handle. This reads all the settings from the file descriptor so that all properties should work. Note that the file descriptor will be set to non-blocking mode, independent on the blocking mode of the #GSocket. On success, the returned #GSocket takes ownership of @fd. On failure, the caller must close @fd themselves. Since GLib 2.46, it is no longer a fatal error to call this on a non-socket descriptor. Instead, a GError will be set with code %G_IO_ERROR_FAILED a #GSocket or %NULL on error. Free the returned object with g_object_unref(). a native socket file descriptor. Accept incoming connections on a connection-based socket. This removes the first outstanding connection request from the listening socket and creates a #GSocket object for it. The @socket must be bound to a local address with g_socket_bind() and must be listening for incoming connections (g_socket_listen()). If there are no outstanding connections then the operation will block or return %G_IO_ERROR_WOULD_BLOCK if non-blocking I/O is enabled. To be notified of an incoming connection, wait for the %G_IO_IN condition. a new #GSocket, or %NULL on error. Free the returned object with g_object_unref(). a #GSocket. a %GCancellable or %NULL When a socket is created it is attached to an address family, but it doesn't have an address in this family. g_socket_bind() assigns the address (sometimes called name) of the socket. It is generally required to bind to a local address before you can receive connections. (See g_socket_listen() and g_socket_accept() ). In certain situations, you may also want to bind a socket that will be used to initiate connections, though this is not normally required. If @socket is a TCP socket, then @allow_reuse controls the setting of the `SO_REUSEADDR` socket option; normally it should be %TRUE for server sockets (sockets that you will eventually call g_socket_accept() on), and %FALSE for client sockets. (Failing to set this flag on a server socket may cause g_socket_bind() to return %G_IO_ERROR_ADDRESS_IN_USE if the server program is stopped and then immediately restarted.) If @socket is a UDP socket, then @allow_reuse determines whether or not other UDP sockets can be bound to the same address at the same time. In particular, you can have several UDP sockets bound to the same address, and they will all receive all of the multicast and broadcast packets sent to that address. (The behavior of unicast UDP packets to an address with multiple listeners is not defined.) %TRUE on success, %FALSE on error. a #GSocket. a #GSocketAddress specifying the local address. whether to allow reusing this address Checks and resets the pending connect error for the socket. This is used to check for errors when g_socket_connect() is used in non-blocking mode. %TRUE if no error, %FALSE otherwise, setting @error to the error a #GSocket Closes the socket, shutting down any active connection. Closing a socket does not wait for all outstanding I/O operations to finish, so the caller should not rely on them to be guaranteed to complete even if the close returns with no error. Once the socket is closed, all other operations will return %G_IO_ERROR_CLOSED. Closing a socket multiple times will not return an error. Sockets will be automatically closed when the last reference is dropped, but you might want to call this function to make sure resources are released as early as possible. Beware that due to the way that TCP works, it is possible for recently-sent data to be lost if either you close a socket while the %G_IO_IN condition is set, or else if the remote connection tries to send something to you after you close the socket but before it has finished reading all of the data you sent. There is no easy generic way to avoid this problem; the easiest fix is to design the network protocol such that the client will never send data "out of turn". Another solution is for the server to half-close the connection by calling g_socket_shutdown() with only the @shutdown_write flag set, and then wait for the client to notice this and close its side of the connection, after which the server can safely call g_socket_close(). (This is what #GTcpConnection does if you call g_tcp_connection_set_graceful_disconnect(). But of course, this only works if the client will close its connection after the server does.) %TRUE on success, %FALSE on error a #GSocket Checks on the readiness of @socket to perform operations. The operations specified in @condition are checked for and masked against the currently-satisfied conditions on @socket. The result is returned. Note that on Windows, it is possible for an operation to return %G_IO_ERROR_WOULD_BLOCK even immediately after g_socket_condition_check() has claimed that the socket is ready for writing. Rather than calling g_socket_condition_check() and then writing to the socket if it succeeds, it is generally better to simply try writing to the socket right away, and try again later if the initial attempt returns %G_IO_ERROR_WOULD_BLOCK. It is meaningless to specify %G_IO_ERR or %G_IO_HUP in condition; these conditions will always be set in the output if they are true. This call never blocks. the @GIOCondition mask of the current state a #GSocket a #GIOCondition mask to check Waits for up to @timeout_us microseconds for @condition to become true on @socket. If the condition is met, %TRUE is returned. If @cancellable is cancelled before the condition is met, or if @timeout_us (or the socket's #GSocket:timeout) is reached before the condition is met, then %FALSE is returned and @error, if non-%NULL, is set to the appropriate value (%G_IO_ERROR_CANCELLED or %G_IO_ERROR_TIMED_OUT). If you don't want a timeout, use g_socket_condition_wait(). (Alternatively, you can pass -1 for @timeout_us.) Note that although @timeout_us is in microseconds for consistency with other GLib APIs, this function actually only has millisecond resolution, and the behavior is undefined if @timeout_us is not an exact number of milliseconds. %TRUE if the condition was met, %FALSE otherwise a #GSocket a #GIOCondition mask to wait for the maximum time (in microseconds) to wait, or -1 a #GCancellable, or %NULL Waits for @condition to become true on @socket. When the condition is met, %TRUE is returned. If @cancellable is cancelled before the condition is met, or if the socket has a timeout set and it is reached before the condition is met, then %FALSE is returned and @error, if non-%NULL, is set to the appropriate value (%G_IO_ERROR_CANCELLED or %G_IO_ERROR_TIMED_OUT). See also g_socket_condition_timed_wait(). %TRUE if the condition was met, %FALSE otherwise a #GSocket a #GIOCondition mask to wait for a #GCancellable, or %NULL Connect the socket to the specified remote address. For connection oriented socket this generally means we attempt to make a connection to the @address. For a connection-less socket it sets the default address for g_socket_send() and discards all incoming datagrams from other sources. Generally connection oriented sockets can only connect once, but connection-less sockets can connect multiple times to change the default address. If the connect call needs to do network I/O it will block, unless non-blocking I/O is enabled. Then %G_IO_ERROR_PENDING is returned and the user can be notified of the connection finishing by waiting for the G_IO_OUT condition. The result of the connection must then be checked with g_socket_check_connect_result(). %TRUE if connected, %FALSE on error. a #GSocket. a #GSocketAddress specifying the remote address. a %GCancellable or %NULL Creates a #GSocketConnection subclass of the right type for @socket. a #GSocketConnection a #GSocket Creates a #GSource that can be attached to a %GMainContext to monitor for the availability of the specified @condition on the socket. The #GSource keeps a reference to the @socket. The callback on the source is of the #GSocketSourceFunc type. It is meaningless to specify %G_IO_ERR or %G_IO_HUP in @condition; these conditions will always be reported output if they are true. @cancellable if not %NULL can be used to cancel the source, which will cause the source to trigger, reporting the current condition (which is likely 0 unless cancellation happened at the same time as a condition change). You can check for this in the callback using g_cancellable_is_cancelled(). If @socket has a timeout set, and it is reached before @condition occurs, the source will then trigger anyway, reporting %G_IO_IN or %G_IO_OUT depending on @condition. However, @socket will have been marked as having had a timeout, and so the next #GSocket I/O method you call will then fail with a %G_IO_ERROR_TIMED_OUT. a newly allocated %GSource, free with g_source_unref(). a #GSocket a #GIOCondition mask to monitor a %GCancellable or %NULL Get the amount of data pending in the OS input buffer, without blocking. If @socket is a UDP or SCTP socket, this will return the size of just the next packet, even if additional packets are buffered after that one. Note that on Windows, this function is rather inefficient in the UDP case, and so if you know any plausible upper bound on the size of the incoming packet, it is better to just do a g_socket_receive() with a buffer of that size, rather than calling g_socket_get_available_bytes() first and then doing a receive of exactly the right size. the number of bytes that can be read from the socket without blocking or truncating, or -1 on error. a #GSocket Gets the blocking mode of the socket. For details on blocking I/O, see g_socket_set_blocking(). %TRUE if blocking I/O is used, %FALSE otherwise. a #GSocket. Gets the broadcast setting on @socket; if %TRUE, it is possible to send packets to broadcast addresses. the broadcast setting on @socket a #GSocket. Returns the credentials of the foreign process connected to this socket, if any (e.g. it is only supported for %G_SOCKET_FAMILY_UNIX sockets). If this operation isn't supported on the OS, the method fails with the %G_IO_ERROR_NOT_SUPPORTED error. On Linux this is implemented by reading the %SO_PEERCRED option on the underlying socket. This method can be expected to be available on the following platforms: - Linux since GLib 2.26 - OpenBSD since GLib 2.30 - Solaris, Illumos and OpenSolaris since GLib 2.40 - NetBSD since GLib 2.42 - macOS, tvOS, iOS since GLib 2.66 Other ways to obtain credentials from a foreign peer includes the #GUnixCredentialsMessage type and g_unix_connection_send_credentials() / g_unix_connection_receive_credentials() functions. %NULL if @error is set, otherwise a #GCredentials object that must be freed with g_object_unref(). a #GSocket. Gets the socket family of the socket. a #GSocketFamily a #GSocket. Returns the underlying OS socket object. On unix this is a socket file descriptor, and on Windows this is a Winsock2 SOCKET handle. This may be useful for doing platform specific or otherwise unusual operations on the socket. the file descriptor of the socket. a #GSocket. Gets the keepalive mode of the socket. For details on this, see g_socket_set_keepalive(). %TRUE if keepalive is active, %FALSE otherwise. a #GSocket. Gets the listen backlog setting of the socket. For details on this, see g_socket_set_listen_backlog(). the maximum number of pending connections. a #GSocket. Try to get the local address of a bound socket. This is only useful if the socket has been bound to a local address, either explicitly or implicitly when connecting. a #GSocketAddress or %NULL on error. Free the returned object with g_object_unref(). a #GSocket. Gets the multicast loopback setting on @socket; if %TRUE (the default), outgoing multicast packets will be looped back to multicast listeners on the same host. the multicast loopback setting on @socket a #GSocket. Gets the multicast time-to-live setting on @socket; see g_socket_set_multicast_ttl() for more details. the multicast time-to-live setting on @socket a #GSocket. Gets the value of an integer-valued option on @socket, as with getsockopt(). (If you need to fetch a non-integer-valued option, you will need to call getsockopt() directly.) The [<gio/gnetworking.h>][gio-gnetworking.h] header pulls in system headers that will define most of the standard/portable socket options. For unusual socket protocols or platform-dependent options, you may need to include additional headers. Note that even for socket options that are a single byte in size, @value is still a pointer to a #gint variable, not a #guchar; g_socket_get_option() will handle the conversion internally. success or failure. On failure, @error will be set, and the system error value (`errno` or WSAGetLastError()) will still be set to the result of the getsockopt() call. a #GSocket the "API level" of the option (eg, `SOL_SOCKET`) the "name" of the option (eg, `SO_BROADCAST`) return location for the option value Gets the socket protocol id the socket was created with. In case the protocol is unknown, -1 is returned. a protocol id, or -1 if unknown a #GSocket. Try to get the remote address of a connected socket. This is only useful for connection oriented sockets that have been connected. a #GSocketAddress or %NULL on error. Free the returned object with g_object_unref(). a #GSocket. Gets the socket type of the socket. a #GSocketType a #GSocket. Gets the timeout setting of the socket. For details on this, see g_socket_set_timeout(). the timeout in seconds a #GSocket. Gets the unicast time-to-live setting on @socket; see g_socket_set_ttl() for more details. the time-to-live setting on @socket a #GSocket. Checks whether a socket is closed. %TRUE if socket is closed, %FALSE otherwise a #GSocket Check whether the socket is connected. This is only useful for connection-oriented sockets. If using g_socket_shutdown(), this function will return %TRUE until the socket has been shut down for reading and writing. If you do a non-blocking connect, this function will not return %TRUE until after you call g_socket_check_connect_result(). %TRUE if socket is connected, %FALSE otherwise. a #GSocket. Registers @socket to receive multicast messages sent to @group. @socket must be a %G_SOCKET_TYPE_DATAGRAM socket, and must have been bound to an appropriate interface and port with g_socket_bind(). If @iface is %NULL, the system will automatically pick an interface to bind to based on @group. If @source_specific is %TRUE, source-specific multicast as defined in RFC 4604 is used. Note that on older platforms this may fail with a %G_IO_ERROR_NOT_SUPPORTED error. To bind to a given source-specific multicast address, use g_socket_join_multicast_group_ssm() instead. %TRUE on success, %FALSE on error. a #GSocket. a #GInetAddress specifying the group address to join. %TRUE if source-specific multicast should be used Name of the interface to use, or %NULL Registers @socket to receive multicast messages sent to @group. @socket must be a %G_SOCKET_TYPE_DATAGRAM socket, and must have been bound to an appropriate interface and port with g_socket_bind(). If @iface is %NULL, the system will automatically pick an interface to bind to based on @group. If @source_specific is not %NULL, use source-specific multicast as defined in RFC 4604. Note that on older platforms this may fail with a %G_IO_ERROR_NOT_SUPPORTED error. Note that this function can be called multiple times for the same @group with different @source_specific in order to receive multicast packets from more than one source. %TRUE on success, %FALSE on error. a #GSocket. a #GInetAddress specifying the group address to join. a #GInetAddress specifying the source-specific multicast address or %NULL to ignore. Name of the interface to use, or %NULL Removes @socket from the multicast group defined by @group, @iface, and @source_specific (which must all have the same values they had when you joined the group). @socket remains bound to its address and port, and can still receive unicast messages after calling this. To unbind to a given source-specific multicast address, use g_socket_leave_multicast_group_ssm() instead. %TRUE on success, %FALSE on error. a #GSocket. a #GInetAddress specifying the group address to leave. %TRUE if source-specific multicast was used Interface used Removes @socket from the multicast group defined by @group, @iface, and @source_specific (which must all have the same values they had when you joined the group). @socket remains bound to its address and port, and can still receive unicast messages after calling this. %TRUE on success, %FALSE on error. a #GSocket. a #GInetAddress specifying the group address to leave. a #GInetAddress specifying the source-specific multicast address or %NULL to ignore. Name of the interface to use, or %NULL Marks the socket as a server socket, i.e. a socket that is used to accept incoming requests using g_socket_accept(). Before calling this the socket must be bound to a local address using g_socket_bind(). To set the maximum amount of outstanding clients, use g_socket_set_listen_backlog(). %TRUE on success, %FALSE on error. a #GSocket. Receive data (up to @size bytes) from a socket. This is mainly used by connection-oriented sockets; it is identical to g_socket_receive_from() with @address set to %NULL. For %G_SOCKET_TYPE_DATAGRAM and %G_SOCKET_TYPE_SEQPACKET sockets, g_socket_receive() will always read either 0 or 1 complete messages from the socket. If the received message is too large to fit in @buffer, then the data beyond @size bytes will be discarded, without any explicit indication that this has occurred. For %G_SOCKET_TYPE_STREAM sockets, g_socket_receive() can return any number of bytes, up to @size. If more than @size bytes have been received, the additional data will be returned in future calls to g_socket_receive(). If the socket is in blocking mode the call will block until there is some data to receive, the connection is closed, or there is an error. If there is no data available and the socket is in non-blocking mode, a %G_IO_ERROR_WOULD_BLOCK error will be returned. To be notified when data is available, wait for the %G_IO_IN condition. On error -1 is returned and @error is set accordingly. Number of bytes read, or 0 if the connection was closed by the peer, or -1 on error a #GSocket a buffer to read data into (which should be at least @size bytes long). the number of bytes you want to read from the socket a %GCancellable or %NULL Receive data (up to @size bytes) from a socket. If @address is non-%NULL then @address will be set equal to the source address of the received packet. @address is owned by the caller. See g_socket_receive() for additional information. Number of bytes read, or 0 if the connection was closed by the peer, or -1 on error a #GSocket a pointer to a #GSocketAddress pointer, or %NULL a buffer to read data into (which should be at least @size bytes long). the number of bytes you want to read from the socket a %GCancellable or %NULL Receive data from a socket. For receiving multiple messages, see g_socket_receive_messages(); for easier use, see g_socket_receive() and g_socket_receive_from(). If @address is non-%NULL then @address will be set equal to the source address of the received packet. @address is owned by the caller. @vector must point to an array of #GInputVector structs and @num_vectors must be the length of this array. These structs describe the buffers that received data will be scattered into. If @num_vectors is -1, then @vectors is assumed to be terminated by a #GInputVector with a %NULL buffer pointer. As a special case, if @num_vectors is 0 (in which case, @vectors may of course be %NULL), then a single byte is received and discarded. This is to facilitate the common practice of sending a single '\0' byte for the purposes of transferring ancillary data. @messages, if non-%NULL, will be set to point to a newly-allocated array of #GSocketControlMessage instances or %NULL if no such messages was received. These correspond to the control messages received from the kernel, one #GSocketControlMessage per message from the kernel. This array is %NULL-terminated and must be freed by the caller using g_free() after calling g_object_unref() on each element. If @messages is %NULL, any control messages received will be discarded. @num_messages, if non-%NULL, will be set to the number of control messages received. If both @messages and @num_messages are non-%NULL, then @num_messages gives the number of #GSocketControlMessage instances in @messages (ie: not including the %NULL terminator). @flags is an in/out parameter. The commonly available arguments for this are available in the #GSocketMsgFlags enum, but the values there are the same as the system values, and the flags are passed in as-is, so you can pass in system-specific flags too (and g_socket_receive_message() may pass system-specific flags out). Flags passed in to the parameter affect the receive operation; flags returned out of it are relevant to the specific returned message. As with g_socket_receive(), data may be discarded if @socket is %G_SOCKET_TYPE_DATAGRAM or %G_SOCKET_TYPE_SEQPACKET and you do not provide enough buffer space to read a complete message. You can pass %G_SOCKET_MSG_PEEK in @flags to peek at the current message without removing it from the receive queue, but there is no portable way to find out the length of the message other than by reading it into a sufficiently-large buffer. If the socket is in blocking mode the call will block until there is some data to receive, the connection is closed, or there is an error. If there is no data available and the socket is in non-blocking mode, a %G_IO_ERROR_WOULD_BLOCK error will be returned. To be notified when data is available, wait for the %G_IO_IN condition. On error -1 is returned and @error is set accordingly. Number of bytes read, or 0 if the connection was closed by the peer, or -1 on error a #GSocket a pointer to a #GSocketAddress pointer, or %NULL an array of #GInputVector structs the number of elements in @vectors, or -1 a pointer which may be filled with an array of #GSocketControlMessages, or %NULL a pointer which will be filled with the number of elements in @messages, or %NULL a pointer to an int containing #GSocketMsgFlags flags, which may additionally contain [other platform specific flags](http://man7.org/linux/man-pages/man2/recv.2.html) a %GCancellable or %NULL Receive multiple data messages from @socket in one go. This is the most complicated and fully-featured version of this call. For easier use, see g_socket_receive(), g_socket_receive_from(), and g_socket_receive_message(). @messages must point to an array of #GInputMessage structs and @num_messages must be the length of this array. Each #GInputMessage contains a pointer to an array of #GInputVector structs describing the buffers that the data received in each message will be written to. Using multiple #GInputVectors is more memory-efficient than manually copying data out of a single buffer to multiple sources, and more system-call-efficient than making multiple calls to g_socket_receive(), such as in scenarios where a lot of data packets need to be received (e.g. high-bandwidth video streaming over RTP/UDP). @flags modify how all messages are received. The commonly available arguments for this are available in the #GSocketMsgFlags enum, but the values there are the same as the system values, and the flags are passed in as-is, so you can pass in system-specific flags too. These flags affect the overall receive operation. Flags affecting individual messages are returned in #GInputMessage.flags. The other members of #GInputMessage are treated as described in its documentation. If #GSocket:blocking is %TRUE the call will block until @num_messages have been received, or the end of the stream is reached. If #GSocket:blocking is %FALSE the call will return up to @num_messages without blocking, or %G_IO_ERROR_WOULD_BLOCK if no messages are queued in the operating system to be received. In blocking mode, if #GSocket:timeout is positive and is reached before any messages are received, %G_IO_ERROR_TIMED_OUT is returned, otherwise up to @num_messages are returned. (Note: This is effectively the behaviour of `MSG_WAITFORONE` with recvmmsg().) To be notified when messages are available, wait for the %G_IO_IN condition. Note though that you may still receive %G_IO_ERROR_WOULD_BLOCK from g_socket_receive_messages() even if you were previously notified of a %G_IO_IN condition. If the remote peer closes the connection, any messages queued in the operating system will be returned, and subsequent calls to g_socket_receive_messages() will return 0 (with no error set). On error -1 is returned and @error is set accordingly. An error will only be returned if zero messages could be received; otherwise the number of messages successfully received before the error will be returned. number of messages received, or -1 on error. Note that the number of messages received may be smaller than @num_messages if in non-blocking mode, if the peer closed the connection, or if @num_messages was larger than `UIO_MAXIOV` (1024), in which case the caller may re-try to receive the remaining messages. a #GSocket an array of #GInputMessage structs the number of elements in @messages an int containing #GSocketMsgFlags flags for the overall operation, which may additionally contain [other platform specific flags](http://man7.org/linux/man-pages/man2/recv.2.html) a %GCancellable or %NULL This behaves exactly the same as g_socket_receive(), except that the choice of blocking or non-blocking behavior is determined by the @blocking argument rather than by @socket's properties. Number of bytes read, or 0 if the connection was closed by the peer, or -1 on error a #GSocket a buffer to read data into (which should be at least @size bytes long). the number of bytes you want to read from the socket whether to do blocking or non-blocking I/O a %GCancellable or %NULL Tries to send @size bytes from @buffer on the socket. This is mainly used by connection-oriented sockets; it is identical to g_socket_send_to() with @address set to %NULL. If the socket is in blocking mode the call will block until there is space for the data in the socket queue. If there is no space available and the socket is in non-blocking mode a %G_IO_ERROR_WOULD_BLOCK error will be returned. To be notified when space is available, wait for the %G_IO_OUT condition. Note though that you may still receive %G_IO_ERROR_WOULD_BLOCK from g_socket_send() even if you were previously notified of a %G_IO_OUT condition. (On Windows in particular, this is very common due to the way the underlying APIs work.) On error -1 is returned and @error is set accordingly. Number of bytes written (which may be less than @size), or -1 on error a #GSocket the buffer containing the data to send. the number of bytes to send a %GCancellable or %NULL Send data to @address on @socket. For sending multiple messages see g_socket_send_messages(); for easier use, see g_socket_send() and g_socket_send_to(). If @address is %NULL then the message is sent to the default receiver (set by g_socket_connect()). @vectors must point to an array of #GOutputVector structs and @num_vectors must be the length of this array. (If @num_vectors is -1, then @vectors is assumed to be terminated by a #GOutputVector with a %NULL buffer pointer.) The #GOutputVector structs describe the buffers that the sent data will be gathered from. Using multiple #GOutputVectors is more memory-efficient than manually copying data from multiple sources into a single buffer, and more network-efficient than making multiple calls to g_socket_send(). @messages, if non-%NULL, is taken to point to an array of @num_messages #GSocketControlMessage instances. These correspond to the control messages to be sent on the socket. If @num_messages is -1 then @messages is treated as a %NULL-terminated array. @flags modify how the message is sent. The commonly available arguments for this are available in the #GSocketMsgFlags enum, but the values there are the same as the system values, and the flags are passed in as-is, so you can pass in system-specific flags too. If the socket is in blocking mode the call will block until there is space for the data in the socket queue. If there is no space available and the socket is in non-blocking mode a %G_IO_ERROR_WOULD_BLOCK error will be returned. To be notified when space is available, wait for the %G_IO_OUT condition. Note though that you may still receive %G_IO_ERROR_WOULD_BLOCK from g_socket_send() even if you were previously notified of a %G_IO_OUT condition. (On Windows in particular, this is very common due to the way the underlying APIs work.) On error -1 is returned and @error is set accordingly. Number of bytes written (which may be less than @size), or -1 on error a #GSocket a #GSocketAddress, or %NULL an array of #GOutputVector structs the number of elements in @vectors, or -1 a pointer to an array of #GSocketControlMessages, or %NULL. number of elements in @messages, or -1. an int containing #GSocketMsgFlags flags, which may additionally contain [other platform specific flags](http://man7.org/linux/man-pages/man2/recv.2.html) a %GCancellable or %NULL This behaves exactly the same as g_socket_send_message(), except that the choice of timeout behavior is determined by the @timeout_us argument rather than by @socket's properties. On error %G_POLLABLE_RETURN_FAILED is returned and @error is set accordingly, or if the socket is currently not writable %G_POLLABLE_RETURN_WOULD_BLOCK is returned. @bytes_written will contain 0 in both cases. %G_POLLABLE_RETURN_OK if all data was successfully written, %G_POLLABLE_RETURN_WOULD_BLOCK if the socket is currently not writable, or %G_POLLABLE_RETURN_FAILED if an error happened and @error is set. a #GSocket a #GSocketAddress, or %NULL an array of #GOutputVector structs the number of elements in @vectors, or -1 a pointer to an array of #GSocketControlMessages, or %NULL. number of elements in @messages, or -1. an int containing #GSocketMsgFlags flags, which may additionally contain [other platform specific flags](http://man7.org/linux/man-pages/man2/recv.2.html) the maximum time (in microseconds) to wait, or -1 location to store the number of bytes that were written to the socket a %GCancellable or %NULL Send multiple data messages from @socket in one go. This is the most complicated and fully-featured version of this call. For easier use, see g_socket_send(), g_socket_send_to(), and g_socket_send_message(). @messages must point to an array of #GOutputMessage structs and @num_messages must be the length of this array. Each #GOutputMessage contains an address to send the data to, and a pointer to an array of #GOutputVector structs to describe the buffers that the data to be sent for each message will be gathered from. Using multiple #GOutputVectors is more memory-efficient than manually copying data from multiple sources into a single buffer, and more network-efficient than making multiple calls to g_socket_send(). Sending multiple messages in one go avoids the overhead of making a lot of syscalls in scenarios where a lot of data packets need to be sent (e.g. high-bandwidth video streaming over RTP/UDP), or where the same data needs to be sent to multiple recipients. @flags modify how the message is sent. The commonly available arguments for this are available in the #GSocketMsgFlags enum, but the values there are the same as the system values, and the flags are passed in as-is, so you can pass in system-specific flags too. If the socket is in blocking mode the call will block until there is space for all the data in the socket queue. If there is no space available and the socket is in non-blocking mode a %G_IO_ERROR_WOULD_BLOCK error will be returned if no data was written at all, otherwise the number of messages sent will be returned. To be notified when space is available, wait for the %G_IO_OUT condition. Note though that you may still receive %G_IO_ERROR_WOULD_BLOCK from g_socket_send() even if you were previously notified of a %G_IO_OUT condition. (On Windows in particular, this is very common due to the way the underlying APIs work.) On error -1 is returned and @error is set accordingly. An error will only be returned if zero messages could be sent; otherwise the number of messages successfully sent before the error will be returned. number of messages sent, or -1 on error. Note that the number of messages sent may be smaller than @num_messages if the socket is non-blocking or if @num_messages was larger than UIO_MAXIOV (1024), in which case the caller may re-try to send the remaining messages. a #GSocket an array of #GOutputMessage structs the number of elements in @messages an int containing #GSocketMsgFlags flags, which may additionally contain [other platform specific flags](http://man7.org/linux/man-pages/man2/recv.2.html) a %GCancellable or %NULL Tries to send @size bytes from @buffer to @address. If @address is %NULL then the message is sent to the default receiver (set by g_socket_connect()). See g_socket_send() for additional information. Number of bytes written (which may be less than @size), or -1 on error a #GSocket a #GSocketAddress, or %NULL the buffer containing the data to send. the number of bytes to send a %GCancellable or %NULL This behaves exactly the same as g_socket_send(), except that the choice of blocking or non-blocking behavior is determined by the @blocking argument rather than by @socket's properties. Number of bytes written (which may be less than @size), or -1 on error a #GSocket the buffer containing the data to send. the number of bytes to send whether to do blocking or non-blocking I/O a %GCancellable or %NULL Sets the blocking mode of the socket. In blocking mode all operations (which don’t take an explicit blocking parameter) block until they succeed or there is an error. In non-blocking mode all functions return results immediately or with a %G_IO_ERROR_WOULD_BLOCK error. All sockets are created in blocking mode. However, note that the platform level socket is always non-blocking, and blocking mode is a GSocket level feature. a #GSocket. Whether to use blocking I/O or not. Sets whether @socket should allow sending to broadcast addresses. This is %FALSE by default. a #GSocket. whether @socket should allow sending to broadcast addresses Sets or unsets the %SO_KEEPALIVE flag on the underlying socket. When this flag is set on a socket, the system will attempt to verify that the remote socket endpoint is still present if a sufficiently long period of time passes with no data being exchanged. If the system is unable to verify the presence of the remote endpoint, it will automatically close the connection. This option is only functional on certain kinds of sockets. (Notably, %G_SOCKET_PROTOCOL_TCP sockets.) The exact time between pings is system- and protocol-dependent, but will normally be at least two hours. Most commonly, you would set this flag on a server socket if you want to allow clients to remain idle for long periods of time, but also want to ensure that connections are eventually garbage-collected if clients crash or become unreachable. a #GSocket. Value for the keepalive flag Sets the maximum number of outstanding connections allowed when listening on this socket. If more clients than this are connecting to the socket and the application is not handling them on time then the new connections will be refused. Note that this must be called before g_socket_listen() and has no effect if called after that. a #GSocket. the maximum number of pending connections. Sets whether outgoing multicast packets will be received by sockets listening on that multicast address on the same host. This is %TRUE by default. a #GSocket. whether @socket should receive messages sent to its multicast groups from the local host Sets the time-to-live for outgoing multicast datagrams on @socket. By default, this is 1, meaning that multicast packets will not leave the local network. a #GSocket. the time-to-live value for all multicast datagrams on @socket Sets the value of an integer-valued option on @socket, as with setsockopt(). (If you need to set a non-integer-valued option, you will need to call setsockopt() directly.) The [<gio/gnetworking.h>][gio-gnetworking.h] header pulls in system headers that will define most of the standard/portable socket options. For unusual socket protocols or platform-dependent options, you may need to include additional headers. success or failure. On failure, @error will be set, and the system error value (`errno` or WSAGetLastError()) will still be set to the result of the setsockopt() call. a #GSocket the "API level" of the option (eg, `SOL_SOCKET`) the "name" of the option (eg, `SO_BROADCAST`) the value to set the option to Sets the time in seconds after which I/O operations on @socket will time out if they have not yet completed. On a blocking socket, this means that any blocking #GSocket operation will time out after @timeout seconds of inactivity, returning %G_IO_ERROR_TIMED_OUT. On a non-blocking socket, calls to g_socket_condition_wait() will also fail with %G_IO_ERROR_TIMED_OUT after the given time. Sources created with g_socket_create_source() will trigger after @timeout seconds of inactivity, with the requested condition set, at which point calling g_socket_receive(), g_socket_send(), g_socket_check_connect_result(), etc, will fail with %G_IO_ERROR_TIMED_OUT. If @timeout is 0 (the default), operations will never time out on their own. Note that if an I/O operation is interrupted by a signal, this may cause the timeout to be reset. a #GSocket. the timeout for @socket, in seconds, or 0 for none Sets the time-to-live for outgoing unicast packets on @socket. By default the platform-specific default value is used. a #GSocket. the time-to-live value for all unicast packets on @socket Shut down part or all of a full-duplex connection. If @shutdown_read is %TRUE then the receiving side of the connection is shut down, and further reading is disallowed. If @shutdown_write is %TRUE then the sending side of the connection is shut down, and further writing is disallowed. It is allowed for both @shutdown_read and @shutdown_write to be %TRUE. One example where it is useful to shut down only one side of a connection is graceful disconnect for TCP connections where you close the sending side, then wait for the other side to close the connection, thus ensuring that the other side saw all sent data. %TRUE on success, %FALSE on error a #GSocket whether to shut down the read side whether to shut down the write side Checks if a socket is capable of speaking IPv4. IPv4 sockets are capable of speaking IPv4. On some operating systems and under some combinations of circumstances IPv6 sockets are also capable of speaking IPv4. See RFC 3493 section 3.7 for more information. No other types of sockets are currently considered as being capable of speaking IPv4. %TRUE if this socket can be used with IPv4. a #GSocket Whether the socket should allow sending to broadcast addresses. Whether outgoing multicast packets loop back to the local host. Time-to-live out outgoing multicast packets The timeout in seconds on socket I/O Time-to-live for outgoing unicast packets #GSocketAddress is the equivalent of struct sockaddr in the BSD sockets API. This is an abstract class; use #GInetSocketAddress for internet sockets, or #GUnixSocketAddress for UNIX domain sockets. Creates a #GSocketAddress subclass corresponding to the native struct sockaddr @native. a new #GSocketAddress if @native could successfully be converted, otherwise %NULL a pointer to a struct sockaddr the size of the memory location pointed to by @native Gets the socket family type of @address. the socket family type of @address a #GSocketAddress Gets the size of @address's native struct sockaddr. You can use this to allocate memory to pass to g_socket_address_to_native(). the size of the native struct sockaddr that @address represents a #GSocketAddress Converts a #GSocketAddress to a native struct sockaddr, which can be passed to low-level functions like connect() or bind(). If not enough space is available, a %G_IO_ERROR_NO_SPACE error is returned. If the address type is not known on the system then a %G_IO_ERROR_NOT_SUPPORTED error is returned. %TRUE if @dest was filled in, %FALSE on error a #GSocketAddress a pointer to a memory location that will contain the native struct sockaddr the size of @dest. Must be at least as large as g_socket_address_get_native_size() Gets the socket family type of @address. the socket family type of @address a #GSocketAddress Gets the size of @address's native struct sockaddr. You can use this to allocate memory to pass to g_socket_address_to_native(). the size of the native struct sockaddr that @address represents a #GSocketAddress Converts a #GSocketAddress to a native struct sockaddr, which can be passed to low-level functions like connect() or bind(). If not enough space is available, a %G_IO_ERROR_NO_SPACE error is returned. If the address type is not known on the system then a %G_IO_ERROR_NOT_SUPPORTED error is returned. %TRUE if @dest was filled in, %FALSE on error a #GSocketAddress a pointer to a memory location that will contain the native struct sockaddr the size of @dest. Must be at least as large as g_socket_address_get_native_size() the socket family type of @address a #GSocketAddress the size of the native struct sockaddr that @address represents a #GSocketAddress %TRUE if @dest was filled in, %FALSE on error a #GSocketAddress a pointer to a memory location that will contain the native struct sockaddr the size of @dest. Must be at least as large as g_socket_address_get_native_size() #GSocketAddressEnumerator is an enumerator type for #GSocketAddress instances. It is returned by enumeration functions such as g_socket_connectable_enumerate(), which returns a #GSocketAddressEnumerator to list each #GSocketAddress which could be used to connect to that #GSocketConnectable. Enumeration is typically a blocking operation, so the asynchronous methods g_socket_address_enumerator_next_async() and g_socket_address_enumerator_next_finish() should be used where possible. Each #GSocketAddressEnumerator can only be enumerated once. Once g_socket_address_enumerator_next() has returned %NULL, further enumeration with that #GSocketAddressEnumerator is not possible, and it can be unreffed. Retrieves the next #GSocketAddress from @enumerator. Note that this may block for some amount of time. (Eg, a #GNetworkAddress may need to do a DNS lookup before it can return an address.) Use g_socket_address_enumerator_next_async() if you need to avoid blocking. If @enumerator is expected to yield addresses, but for some reason is unable to (eg, because of a DNS error), then the first call to g_socket_address_enumerator_next() will return an appropriate error in *@error. However, if the first call to g_socket_address_enumerator_next() succeeds, then any further internal errors (other than @cancellable being triggered) will be ignored. a #GSocketAddress (owned by the caller), or %NULL on error (in which case *@error will be set) or if there are no more addresses. a #GSocketAddressEnumerator optional #GCancellable object, %NULL to ignore. Asynchronously retrieves the next #GSocketAddress from @enumerator and then calls @callback, which must call g_socket_address_enumerator_next_finish() to get the result. It is an error to call this multiple times before the previous callback has finished. a #GSocketAddressEnumerator optional #GCancellable object, %NULL to ignore. a #GAsyncReadyCallback to call when the request is satisfied the data to pass to callback function Retrieves the result of a completed call to g_socket_address_enumerator_next_async(). See g_socket_address_enumerator_next() for more information about error handling. a #GSocketAddress (owned by the caller), or %NULL on error (in which case *@error will be set) or if there are no more addresses. a #GSocketAddressEnumerator a #GAsyncResult Retrieves the next #GSocketAddress from @enumerator. Note that this may block for some amount of time. (Eg, a #GNetworkAddress may need to do a DNS lookup before it can return an address.) Use g_socket_address_enumerator_next_async() if you need to avoid blocking. If @enumerator is expected to yield addresses, but for some reason is unable to (eg, because of a DNS error), then the first call to g_socket_address_enumerator_next() will return an appropriate error in *@error. However, if the first call to g_socket_address_enumerator_next() succeeds, then any further internal errors (other than @cancellable being triggered) will be ignored. a #GSocketAddress (owned by the caller), or %NULL on error (in which case *@error will be set) or if there are no more addresses. a #GSocketAddressEnumerator optional #GCancellable object, %NULL to ignore. Asynchronously retrieves the next #GSocketAddress from @enumerator and then calls @callback, which must call g_socket_address_enumerator_next_finish() to get the result. It is an error to call this multiple times before the previous callback has finished. a #GSocketAddressEnumerator optional #GCancellable object, %NULL to ignore. a #GAsyncReadyCallback to call when the request is satisfied the data to pass to callback function Retrieves the result of a completed call to g_socket_address_enumerator_next_async(). See g_socket_address_enumerator_next() for more information about error handling. a #GSocketAddress (owned by the caller), or %NULL on error (in which case *@error will be set) or if there are no more addresses. a #GSocketAddressEnumerator a #GAsyncResult Class structure for #GSocketAddressEnumerator. a #GSocketAddress (owned by the caller), or %NULL on error (in which case *@error will be set) or if there are no more addresses. a #GSocketAddressEnumerator optional #GCancellable object, %NULL to ignore. a #GSocketAddressEnumerator optional #GCancellable object, %NULL to ignore. a #GAsyncReadyCallback to call when the request is satisfied the data to pass to callback function a #GSocketAddress (owned by the caller), or %NULL on error (in which case *@error will be set) or if there are no more addresses. a #GSocketAddressEnumerator a #GAsyncResult #GSocketClient is a lightweight high-level utility class for connecting to a network host using a connection oriented socket type. You create a #GSocketClient object, set any options you want, and then call a sync or async connect operation, which returns a #GSocketConnection subclass on success. The type of the #GSocketConnection object returned depends on the type of the underlying socket that is in use. For instance, for a TCP/IP connection it will be a #GTcpConnection. As #GSocketClient is a lightweight object, you don't need to cache it. You can just create a new one any time you need one. Creates a new #GSocketClient with the default options. a #GSocketClient. Free the returned object with g_object_unref(). Enable proxy protocols to be handled by the application. When the indicated proxy protocol is returned by the #GProxyResolver, #GSocketClient will consider this protocol as supported but will not try to find a #GProxy instance to handle handshaking. The application must check for this case by calling g_socket_connection_get_remote_address() on the returned #GSocketConnection, and seeing if it's a #GProxyAddress of the appropriate type, to determine whether or not it needs to handle the proxy handshaking itself. This should be used for proxy protocols that are dialects of another protocol such as HTTP proxy. It also allows cohabitation of proxy protocols that are reused between protocols. A good example is HTTP. It can be used to proxy HTTP, FTP and Gopher and can also be use as generic socket proxy through the HTTP CONNECT method. When the proxy is detected as being an application proxy, TLS handshake will be skipped. This is required to let the application do the proxy specific handshake. a #GSocketClient The proxy protocol Tries to resolve the @connectable and make a network connection to it. Upon a successful connection, a new #GSocketConnection is constructed and returned. The caller owns this new object and must drop their reference to it when finished with it. The type of the #GSocketConnection object returned depends on the type of the underlying socket that is used. For instance, for a TCP/IP connection it will be a #GTcpConnection. The socket created will be the same family as the address that the @connectable resolves to, unless family is set with g_socket_client_set_family() or indirectly via g_socket_client_set_local_address(). The socket type defaults to %G_SOCKET_TYPE_STREAM but can be set with g_socket_client_set_socket_type(). If a local address is specified with g_socket_client_set_local_address() the socket will be bound to this address before connecting. a #GSocketConnection on success, %NULL on error. a #GSocketClient. a #GSocketConnectable specifying the remote address. optional #GCancellable object, %NULL to ignore. This is the asynchronous version of g_socket_client_connect(). When the operation is finished @callback will be called. You can then call g_socket_client_connect_finish() to get the result of the operation. a #GSocketClient a #GSocketConnectable specifying the remote address. a #GCancellable, or %NULL a #GAsyncReadyCallback user data for the callback Finishes an async connect operation. See g_socket_client_connect_async() a #GSocketConnection on success, %NULL on error. a #GSocketClient. a #GAsyncResult. This is a helper function for g_socket_client_connect(). Attempts to create a TCP connection to the named host. @host_and_port may be in any of a number of recognized formats; an IPv6 address, an IPv4 address, or a domain name (in which case a DNS lookup is performed). Quoting with [] is supported for all address types. A port override may be specified in the usual way with a colon. Ports may be given as decimal numbers or symbolic names (in which case an /etc/services lookup is performed). If no port override is given in @host_and_port then @default_port will be used as the port number to connect to. In general, @host_and_port is expected to be provided by the user (allowing them to give the hostname, and a port override if necessary) and @default_port is expected to be provided by the application. In the case that an IP address is given, a single connection attempt is made. In the case that a name is given, multiple connection attempts may be made, in turn and according to the number of address records in DNS, until a connection succeeds. Upon a successful connection, a new #GSocketConnection is constructed and returned. The caller owns this new object and must drop their reference to it when finished with it. In the event of any failure (DNS error, service not found, no hosts connectable) %NULL is returned and @error (if non-%NULL) is set accordingly. a #GSocketConnection on success, %NULL on error. a #GSocketClient the name and optionally port of the host to connect to the default port to connect to a #GCancellable, or %NULL This is the asynchronous version of g_socket_client_connect_to_host(). When the operation is finished @callback will be called. You can then call g_socket_client_connect_to_host_finish() to get the result of the operation. a #GSocketClient the name and optionally the port of the host to connect to the default port to connect to a #GCancellable, or %NULL a #GAsyncReadyCallback user data for the callback Finishes an async connect operation. See g_socket_client_connect_to_host_async() a #GSocketConnection on success, %NULL on error. a #GSocketClient. a #GAsyncResult. Attempts to create a TCP connection to a service. This call looks up the SRV record for @service at @domain for the "tcp" protocol. It then attempts to connect, in turn, to each of the hosts providing the service until either a connection succeeds or there are no hosts remaining. Upon a successful connection, a new #GSocketConnection is constructed and returned. The caller owns this new object and must drop their reference to it when finished with it. In the event of any failure (DNS error, service not found, no hosts connectable) %NULL is returned and @error (if non-%NULL) is set accordingly. a #GSocketConnection if successful, or %NULL on error a #GSocketConnection a domain name the name of the service to connect to a #GCancellable, or %NULL This is the asynchronous version of g_socket_client_connect_to_service(). a #GSocketClient a domain name the name of the service to connect to a #GCancellable, or %NULL a #GAsyncReadyCallback user data for the callback Finishes an async connect operation. See g_socket_client_connect_to_service_async() a #GSocketConnection on success, %NULL on error. a #GSocketClient. a #GAsyncResult. This is a helper function for g_socket_client_connect(). Attempts to create a TCP connection with a network URI. @uri may be any valid URI containing an "authority" (hostname/port) component. If a port is not specified in the URI, @default_port will be used. TLS will be negotiated if #GSocketClient:tls is %TRUE. (#GSocketClient does not know to automatically assume TLS for certain URI schemes.) Using this rather than g_socket_client_connect() or g_socket_client_connect_to_host() allows #GSocketClient to determine when to use application-specific proxy protocols. Upon a successful connection, a new #GSocketConnection is constructed and returned. The caller owns this new object and must drop their reference to it when finished with it. In the event of any failure (DNS error, service not found, no hosts connectable) %NULL is returned and @error (if non-%NULL) is set accordingly. a #GSocketConnection on success, %NULL on error. a #GSocketClient A network URI the default port to connect to a #GCancellable, or %NULL This is the asynchronous version of g_socket_client_connect_to_uri(). When the operation is finished @callback will be called. You can then call g_socket_client_connect_to_uri_finish() to get the result of the operation. a #GSocketClient a network uri the default port to connect to a #GCancellable, or %NULL a #GAsyncReadyCallback user data for the callback Finishes an async connect operation. See g_socket_client_connect_to_uri_async() a #GSocketConnection on success, %NULL on error. a #GSocketClient. a #GAsyncResult. Gets the proxy enable state; see g_socket_client_set_enable_proxy() whether proxying is enabled a #GSocketClient. Gets the socket family of the socket client. See g_socket_client_set_family() for details. a #GSocketFamily a #GSocketClient. Gets the local address of the socket client. See g_socket_client_set_local_address() for details. a #GSocketAddress or %NULL. Do not free. a #GSocketClient. Gets the protocol name type of the socket client. See g_socket_client_set_protocol() for details. a #GSocketProtocol a #GSocketClient Gets the #GProxyResolver being used by @client. Normally, this will be the resolver returned by g_proxy_resolver_get_default(), but you can override it with g_socket_client_set_proxy_resolver(). The #GProxyResolver being used by @client. a #GSocketClient. Gets the socket type of the socket client. See g_socket_client_set_socket_type() for details. a #GSocketFamily a #GSocketClient. Gets the I/O timeout time for sockets created by @client. See g_socket_client_set_timeout() for details. the timeout in seconds a #GSocketClient Gets whether @client creates TLS connections. See g_socket_client_set_tls() for details. whether @client uses TLS a #GSocketClient. Gets the TLS validation flags used creating TLS connections via @client. the TLS validation flags a #GSocketClient. Sets whether or not @client attempts to make connections via a proxy server. When enabled (the default), #GSocketClient will use a #GProxyResolver to determine if a proxy protocol such as SOCKS is needed, and automatically do the necessary proxy negotiation. See also g_socket_client_set_proxy_resolver(). a #GSocketClient. whether to enable proxies Sets the socket family of the socket client. If this is set to something other than %G_SOCKET_FAMILY_INVALID then the sockets created by this object will be of the specified family. This might be useful for instance if you want to force the local connection to be an ipv4 socket, even though the address might be an ipv6 mapped to ipv4 address. a #GSocketClient. a #GSocketFamily Sets the local address of the socket client. The sockets created by this object will bound to the specified address (if not %NULL) before connecting. This is useful if you want to ensure that the local side of the connection is on a specific port, or on a specific interface. a #GSocketClient. a #GSocketAddress, or %NULL Sets the protocol of the socket client. The sockets created by this object will use of the specified protocol. If @protocol is %G_SOCKET_PROTOCOL_DEFAULT that means to use the default protocol for the socket family and type. a #GSocketClient. a #GSocketProtocol Overrides the #GProxyResolver used by @client. You can call this if you want to use specific proxies, rather than using the system default proxy settings. Note that whether or not the proxy resolver is actually used depends on the setting of #GSocketClient:enable-proxy, which is not changed by this function (but which is %TRUE by default) a #GSocketClient. a #GProxyResolver, or %NULL for the default. Sets the socket type of the socket client. The sockets created by this object will be of the specified type. It doesn't make sense to specify a type of %G_SOCKET_TYPE_DATAGRAM, as GSocketClient is used for connection oriented services. a #GSocketClient. a #GSocketType Sets the I/O timeout for sockets created by @client. @timeout is a time in seconds, or 0 for no timeout (the default). The timeout value affects the initial connection attempt as well, so setting this may cause calls to g_socket_client_connect(), etc, to fail with %G_IO_ERROR_TIMED_OUT. a #GSocketClient. the timeout Sets whether @client creates TLS (aka SSL) connections. If @tls is %TRUE, @client will wrap its connections in a #GTlsClientConnection and perform a TLS handshake when connecting. Note that since #GSocketClient must return a #GSocketConnection, but #GTlsClientConnection is not a #GSocketConnection, this actually wraps the resulting #GTlsClientConnection in a #GTcpWrapperConnection when returning it. You can use g_tcp_wrapper_connection_get_base_io_stream() on the return value to extract the #GTlsClientConnection. If you need to modify the behavior of the TLS handshake (eg, by setting a client-side certificate to use, or connecting to the #GTlsConnection::accept-certificate signal), you can connect to @client's #GSocketClient::event signal and wait for it to be emitted with %G_SOCKET_CLIENT_TLS_HANDSHAKING, which will give you a chance to see the #GTlsClientConnection before the handshake starts. a #GSocketClient. whether to use TLS Sets the TLS validation flags used when creating TLS connections via @client. The default value is %G_TLS_CERTIFICATE_VALIDATE_ALL. a #GSocketClient. the validation flags The proxy resolver to use Emitted when @client's activity on @connectable changes state. Among other things, this can be used to provide progress information about a network connection in the UI. The meanings of the different @event values are as follows: - %G_SOCKET_CLIENT_RESOLVING: @client is about to look up @connectable in DNS. @connection will be %NULL. - %G_SOCKET_CLIENT_RESOLVED: @client has successfully resolved @connectable in DNS. @connection will be %NULL. - %G_SOCKET_CLIENT_CONNECTING: @client is about to make a connection to a remote host; either a proxy server or the destination server itself. @connection is the #GSocketConnection, which is not yet connected. Since GLib 2.40, you can access the remote address via g_socket_connection_get_remote_address(). - %G_SOCKET_CLIENT_CONNECTED: @client has successfully connected to a remote host. @connection is the connected #GSocketConnection. - %G_SOCKET_CLIENT_PROXY_NEGOTIATING: @client is about to negotiate with a proxy to get it to connect to @connectable. @connection is the #GSocketConnection to the proxy server. - %G_SOCKET_CLIENT_PROXY_NEGOTIATED: @client has negotiated a connection to @connectable through a proxy server. @connection is the stream returned from g_proxy_connect(), which may or may not be a #GSocketConnection. - %G_SOCKET_CLIENT_TLS_HANDSHAKING: @client is about to begin a TLS handshake. @connection is a #GTlsClientConnection. - %G_SOCKET_CLIENT_TLS_HANDSHAKED: @client has successfully completed the TLS handshake. @connection is a #GTlsClientConnection. - %G_SOCKET_CLIENT_COMPLETE: @client has either successfully connected to @connectable (in which case @connection is the #GSocketConnection that it will be returning to the caller) or has failed (in which case @connection is %NULL and the client is about to return an error). Each event except %G_SOCKET_CLIENT_COMPLETE may be emitted multiple times (or not at all) for a given connectable (in particular, if @client ends up attempting to connect to more than one address). However, if @client emits the #GSocketClient::event signal at all for a given connectable, that it will always emit it with %G_SOCKET_CLIENT_COMPLETE when it is done. Note that there may be additional #GSocketClientEvent values in the future; unrecognized @event values should be ignored. the event that is occurring the #GSocketConnectable that @event is occurring on the current representation of the connection Describes an event occurring on a #GSocketClient. See the #GSocketClient::event signal for more details. Additional values may be added to this type in the future. The client is doing a DNS lookup. The client has completed a DNS lookup. The client is connecting to a remote host (either a proxy or the destination server). The client has connected to a remote host. The client is negotiating with a proxy to connect to the destination server. The client has negotiated with the proxy server. The client is performing a TLS handshake. The client has performed a TLS handshake. The client is done with a particular #GSocketConnectable. Objects that describe one or more potential socket endpoints implement #GSocketConnectable. Callers can then use g_socket_connectable_enumerate() to get a #GSocketAddressEnumerator to try out each socket address in turn until one succeeds, as shown in the sample code below. |[<!-- language="C" --> MyConnectionType * connect_to_host (const char *hostname, guint16 port, GCancellable *cancellable, GError **error) { MyConnection *conn = NULL; GSocketConnectable *addr; GSocketAddressEnumerator *enumerator; GSocketAddress *sockaddr; GError *conn_error = NULL; addr = g_network_address_new (hostname, port); enumerator = g_socket_connectable_enumerate (addr); g_object_unref (addr); // Try each sockaddr until we succeed. Record the first connection error, // but not any further ones (since they'll probably be basically the same // as the first). while (!conn && (sockaddr = g_socket_address_enumerator_next (enumerator, cancellable, error)) { conn = connect_to_sockaddr (sockaddr, conn_error ? NULL : &conn_error); g_object_unref (sockaddr); } g_object_unref (enumerator); if (conn) { if (conn_error) { // We couldn't connect to the first address, but we succeeded // in connecting to a later address. g_error_free (conn_error); } return conn; } else if (error) { /// Either initial lookup failed, or else the caller cancelled us. if (conn_error) g_error_free (conn_error); return NULL; } else { g_error_propagate (error, conn_error); return NULL; } } ]| Creates a #GSocketAddressEnumerator for @connectable. a new #GSocketAddressEnumerator. a #GSocketConnectable Creates a #GSocketAddressEnumerator for @connectable that will return a #GProxyAddress for each of its addresses that you must connect to via a proxy. If @connectable does not implement g_socket_connectable_proxy_enumerate(), this will fall back to calling g_socket_connectable_enumerate(). a new #GSocketAddressEnumerator. a #GSocketConnectable Format a #GSocketConnectable as a string. This is a human-readable format for use in debugging output, and is not a stable serialization format. It is not suitable for use in user interfaces as it exposes too much information for a user. If the #GSocketConnectable implementation does not support string formatting, the implementation’s type name will be returned as a fallback. the formatted string a #GSocketConnectable Creates a #GSocketAddressEnumerator for @connectable. a new #GSocketAddressEnumerator. a #GSocketConnectable Creates a #GSocketAddressEnumerator for @connectable that will return a #GProxyAddress for each of its addresses that you must connect to via a proxy. If @connectable does not implement g_socket_connectable_proxy_enumerate(), this will fall back to calling g_socket_connectable_enumerate(). a new #GSocketAddressEnumerator. a #GSocketConnectable Format a #GSocketConnectable as a string. This is a human-readable format for use in debugging output, and is not a stable serialization format. It is not suitable for use in user interfaces as it exposes too much information for a user. If the #GSocketConnectable implementation does not support string formatting, the implementation’s type name will be returned as a fallback. the formatted string a #GSocketConnectable Provides an interface for returning a #GSocketAddressEnumerator and #GProxyAddressEnumerator The parent interface. a new #GSocketAddressEnumerator. a #GSocketConnectable a new #GSocketAddressEnumerator. a #GSocketConnectable the formatted string a #GSocketConnectable #GSocketConnection is a #GIOStream for a connected socket. They can be created either by #GSocketClient when connecting to a host, or by #GSocketListener when accepting a new client. The type of the #GSocketConnection object returned from these calls depends on the type of the underlying socket that is in use. For instance, for a TCP/IP connection it will be a #GTcpConnection. Choosing what type of object to construct is done with the socket connection factory, and it is possible for 3rd parties to register custom socket connection types for specific combination of socket family/type/protocol using g_socket_connection_factory_register_type(). To close a #GSocketConnection, use g_io_stream_close(). Closing both substreams of the #GIOStream separately will not close the underlying #GSocket. Looks up the #GType to be used when creating socket connections on sockets with the specified @family, @type and @protocol_id. If no type is registered, the #GSocketConnection base type is returned. a #GType a #GSocketFamily a #GSocketType a protocol id Looks up the #GType to be used when creating socket connections on sockets with the specified @family, @type and @protocol. If no type is registered, the #GSocketConnection base type is returned. a #GType, inheriting from %G_TYPE_SOCKET_CONNECTION a #GSocketFamily a #GSocketType a protocol id Connect @connection to the specified remote address. %TRUE if the connection succeeded, %FALSE on error a #GSocketConnection a #GSocketAddress specifying the remote address. a %GCancellable or %NULL Asynchronously connect @connection to the specified remote address. This clears the #GSocket:blocking flag on @connection's underlying socket if it is currently set. Use g_socket_connection_connect_finish() to retrieve the result. a #GSocketConnection a #GSocketAddress specifying the remote address. a %GCancellable or %NULL a #GAsyncReadyCallback user data for the callback Gets the result of a g_socket_connection_connect_async() call. %TRUE if the connection succeeded, %FALSE on error a #GSocketConnection the #GAsyncResult Try to get the local address of a socket connection. a #GSocketAddress or %NULL on error. Free the returned object with g_object_unref(). a #GSocketConnection Try to get the remote address of a socket connection. Since GLib 2.40, when used with g_socket_client_connect() or g_socket_client_connect_async(), during emission of %G_SOCKET_CLIENT_CONNECTING, this function will return the remote address that will be used for the connection. This allows applications to print e.g. "Connecting to example.com (10.42.77.3)...". a #GSocketAddress or %NULL on error. Free the returned object with g_object_unref(). a #GSocketConnection Gets the underlying #GSocket object of the connection. This can be useful if you want to do something unusual on it not supported by the #GSocketConnection APIs. a #GSocket or %NULL on error. a #GSocketConnection Checks if @connection is connected. This is equivalent to calling g_socket_is_connected() on @connection's underlying #GSocket. whether @connection is connected a #GSocketConnection A #GSocketControlMessage is a special-purpose utility message that can be sent to or received from a #GSocket. These types of messages are often called "ancillary data". The message can represent some sort of special instruction to or information from the socket or can represent a special kind of transfer to the peer (for example, sending a file descriptor over a UNIX socket). These messages are sent with g_socket_send_message() and received with g_socket_receive_message(). To extend the set of control message that can be sent, subclass this class and override the get_size, get_level, get_type and serialize methods. To extend the set of control messages that can be received, subclass this class and implement the deserialize method. Also, make sure your class is registered with the GType typesystem before calling g_socket_receive_message() to read such a message. Tries to deserialize a socket control message of a given @level and @type. This will ask all known (to GType) subclasses of #GSocketControlMessage if they can understand this kind of message and if so deserialize it into a #GSocketControlMessage. If there is no implementation for this kind of control message, %NULL will be returned. the deserialized message or %NULL a socket level a socket control message type for the given @level the size of the data in bytes pointer to the message data Returns the "level" (i.e. the originating protocol) of the control message. This is often SOL_SOCKET. an integer describing the level a #GSocketControlMessage Returns the space required for the control message, not including headers or alignment. The number of bytes required. a #GSocketControlMessage Converts the data in the message to bytes placed in the message. @data is guaranteed to have enough space to fit the size returned by g_socket_control_message_get_size() on this object. a #GSocketControlMessage A buffer to write data to Returns the "level" (i.e. the originating protocol) of the control message. This is often SOL_SOCKET. an integer describing the level a #GSocketControlMessage Returns the protocol specific type of the control message. For instance, for UNIX fd passing this would be SCM_RIGHTS. an integer describing the type of control message a #GSocketControlMessage Returns the space required for the control message, not including headers or alignment. The number of bytes required. a #GSocketControlMessage Converts the data in the message to bytes placed in the message. @data is guaranteed to have enough space to fit the size returned by g_socket_control_message_get_size() on this object. a #GSocketControlMessage A buffer to write data to Class structure for #GSocketControlMessage. The number of bytes required. a #GSocketControlMessage an integer describing the level a #GSocketControlMessage a #GSocketControlMessage A buffer to write data to The protocol family of a #GSocketAddress. (These values are identical to the system defines %AF_INET, %AF_INET6 and %AF_UNIX, if available.) no address family the UNIX domain family the IPv4 family the IPv6 family A #GSocketListener is an object that keeps track of a set of server sockets and helps you accept sockets from any of the socket, either sync or async. Add addresses and ports to listen on using g_socket_listener_add_address() and g_socket_listener_add_inet_port(). These will be listened on until g_socket_listener_close() is called. Dropping your final reference to the #GSocketListener will not cause g_socket_listener_close() to be called implicitly, as some references to the #GSocketListener may be held internally. If you want to implement a network server, also look at #GSocketService and #GThreadedSocketService which are subclasses of #GSocketListener that make this even easier. Creates a new #GSocketListener with no sockets to listen for. New listeners can be added with e.g. g_socket_listener_add_address() or g_socket_listener_add_inet_port(). a new #GSocketListener. Blocks waiting for a client to connect to any of the sockets added to the listener. Returns a #GSocketConnection for the socket that was accepted. If @source_object is not %NULL it will be filled out with the source object specified when the corresponding socket or address was added to the listener. If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. a #GSocketConnection on success, %NULL on error. a #GSocketListener location where #GObject pointer will be stored, or %NULL optional #GCancellable object, %NULL to ignore. This is the asynchronous version of g_socket_listener_accept(). When the operation is finished @callback will be called. You can then call g_socket_listener_accept_socket() to get the result of the operation. a #GSocketListener a #GCancellable, or %NULL a #GAsyncReadyCallback user data for the callback Finishes an async accept operation. See g_socket_listener_accept_async() a #GSocketConnection on success, %NULL on error. a #GSocketListener a #GAsyncResult. Optional #GObject identifying this source Blocks waiting for a client to connect to any of the sockets added to the listener. Returns the #GSocket that was accepted. If you want to accept the high-level #GSocketConnection, not a #GSocket, which is often the case, then you should use g_socket_listener_accept() instead. If @source_object is not %NULL it will be filled out with the source object specified when the corresponding socket or address was added to the listener. If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. a #GSocket on success, %NULL on error. a #GSocketListener location where #GObject pointer will be stored, or %NULL. optional #GCancellable object, %NULL to ignore. This is the asynchronous version of g_socket_listener_accept_socket(). When the operation is finished @callback will be called. You can then call g_socket_listener_accept_socket_finish() to get the result of the operation. a #GSocketListener a #GCancellable, or %NULL a #GAsyncReadyCallback user data for the callback Finishes an async accept operation. See g_socket_listener_accept_socket_async() a #GSocket on success, %NULL on error. a #GSocketListener a #GAsyncResult. Optional #GObject identifying this source Creates a socket of type @type and protocol @protocol, binds it to @address and adds it to the set of sockets we're accepting sockets from. Note that adding an IPv6 address, depending on the platform, may or may not result in a listener that also accepts IPv4 connections. For more deterministic behavior, see g_socket_listener_add_inet_port(). @source_object will be passed out in the various calls to accept to identify this particular source, which is useful if you're listening on multiple addresses and do different things depending on what address is connected to. If successful and @effective_address is non-%NULL then it will be set to the address that the binding actually occurred at. This is helpful for determining the port number that was used for when requesting a binding to port 0 (ie: "any port"). This address, if requested, belongs to the caller and must be freed. Call g_socket_listener_close() to stop listening on @address; this will not be done automatically when you drop your final reference to @listener, as references may be held internally. %TRUE on success, %FALSE on error. a #GSocketListener a #GSocketAddress a #GSocketType a #GSocketProtocol Optional #GObject identifying this source location to store the address that was bound to, or %NULL. Listens for TCP connections on any available port number for both IPv6 and IPv4 (if each is available). This is useful if you need to have a socket for incoming connections but don't care about the specific port number. @source_object will be passed out in the various calls to accept to identify this particular source, which is useful if you're listening on multiple addresses and do different things depending on what address is connected to. the port number, or 0 in case of failure. a #GSocketListener Optional #GObject identifying this source Helper function for g_socket_listener_add_address() that creates a TCP/IP socket listening on IPv4 and IPv6 (if supported) on the specified port on all interfaces. @source_object will be passed out in the various calls to accept to identify this particular source, which is useful if you're listening on multiple addresses and do different things depending on what address is connected to. Call g_socket_listener_close() to stop listening on @port; this will not be done automatically when you drop your final reference to @listener, as references may be held internally. %TRUE on success, %FALSE on error. a #GSocketListener an IP port number (non-zero) Optional #GObject identifying this source Adds @socket to the set of sockets that we try to accept new clients from. The socket must be bound to a local address and listened to. @source_object will be passed out in the various calls to accept to identify this particular source, which is useful if you're listening on multiple addresses and do different things depending on what address is connected to. The @socket will not be automatically closed when the @listener is finalized unless the listener held the final reference to the socket. Before GLib 2.42, the @socket was automatically closed on finalization of the @listener, even if references to it were held elsewhere. %TRUE on success, %FALSE on error. a #GSocketListener a listening #GSocket Optional #GObject identifying this source Closes all the sockets in the listener. a #GSocketListener Sets the listen backlog on the sockets in the listener. This must be called before adding any sockets, addresses or ports to the #GSocketListener (for example, by calling g_socket_listener_add_inet_port()) to be effective. See g_socket_set_listen_backlog() for details a #GSocketListener an integer Emitted when @listener's activity on @socket changes state. Note that when @listener is used to listen on both IPv4 and IPv6, a separate set of signals will be emitted for each, and the order they happen in is undefined. the event that is occurring the #GSocket the event is occurring on Class structure for #GSocketListener. Describes an event occurring on a #GSocketListener. See the #GSocketListener::event signal for more details. Additional values may be added to this type in the future. The listener is about to bind a socket. The listener has bound a socket. The listener is about to start listening on this socket. The listener is now listening on this socket. Flags used in g_socket_receive_message() and g_socket_send_message(). The flags listed in the enum are some commonly available flags, but the values used for them are the same as on the platform, and any other flags are passed in/out as is. So to use a platform specific flag, just include the right system header and pass in the flag. No flags. Request to send/receive out of band data. Read data from the socket without removing it from the queue. Don't use a gateway to send out the packet, only send to hosts on directly connected networks. A protocol identifier is specified when creating a #GSocket, which is a family/type specific identifier, where 0 means the default protocol for the particular family/type. This enum contains a set of commonly available and used protocols. You can also pass any other identifiers handled by the platform in order to use protocols not listed here. The protocol type is unknown The default protocol for the family/type TCP over IP UDP over IP SCTP over IP A #GSocketService is an object that represents a service that is provided to the network or over local sockets. When a new connection is made to the service the #GSocketService::incoming signal is emitted. A #GSocketService is a subclass of #GSocketListener and you need to add the addresses you want to accept connections on with the #GSocketListener APIs. There are two options for implementing a network service based on #GSocketService. The first is to create the service using g_socket_service_new() and to connect to the #GSocketService::incoming signal. The second is to subclass #GSocketService and override the default signal handler implementation. In either case, the handler must immediately return, or else it will block additional incoming connections from being serviced. If you are interested in writing connection handlers that contain blocking code then see #GThreadedSocketService. The socket service runs on the main loop of the [thread-default context][g-main-context-push-thread-default-context] of the thread it is created in, and is not threadsafe in general. However, the calls to start and stop the service are thread-safe so these can be used from threads that handle incoming clients. Creates a new #GSocketService with no sockets to listen for. New listeners can be added with e.g. g_socket_listener_add_address() or g_socket_listener_add_inet_port(). New services are created active, there is no need to call g_socket_service_start(), unless g_socket_service_stop() has been called before. a new #GSocketService. Check whether the service is active or not. An active service will accept new clients that connect, while a non-active service will let connecting clients queue up until the service is started. %TRUE if the service is active, %FALSE otherwise a #GSocketService Restarts the service, i.e. start accepting connections from the added sockets when the mainloop runs. This only needs to be called after the service has been stopped from g_socket_service_stop(). This call is thread-safe, so it may be called from a thread handling an incoming client request. a #GSocketService Stops the service, i.e. stops accepting connections from the added sockets when the mainloop runs. This call is thread-safe, so it may be called from a thread handling an incoming client request. Note that this only stops accepting new connections; it does not close the listening sockets, and you can call g_socket_service_start() again later to begin listening again. To close the listening sockets, call g_socket_listener_close(). (This will happen automatically when the #GSocketService is finalized.) This must be called before calling g_socket_listener_close() as the socket service will start accepting connections immediately when a new socket is added. a #GSocketService Whether the service is currently accepting connections. The ::incoming signal is emitted when a new incoming connection to @service needs to be handled. The handler must initiate the handling of @connection, but may not block; in essence, asynchronous operations must be used. @connection will be unreffed once the signal handler returns, so you need to ref it yourself if you are planning to use it. %TRUE to stop other handlers from being called a new #GSocketConnection object the source_object passed to g_socket_listener_add_address() Class structure for #GSocketService. This is the function type of the callback used for the #GSource returned by g_socket_create_source(). it should return %FALSE if the source should be removed. the #GSocket the current condition at the source fired. data passed in by the user. Flags used when creating a #GSocket. Some protocols may not implement all the socket types. Type unknown or wrong Reliable connection-based byte streams (e.g. TCP). Connectionless, unreliable datagram passing. (e.g. UDP) Reliable connection-based passing of datagrams of fixed maximum length (e.g. SCTP). SRV (service) records are used by some network protocols to provide service-specific aliasing and load-balancing. For example, XMPP (Jabber) uses SRV records to locate the XMPP server for a domain; rather than connecting directly to "example.com" or assuming a specific server hostname like "xmpp.example.com", an XMPP client would look up the "xmpp-client" SRV record for "example.com", and then connect to whatever host was pointed to by that record. You can use g_resolver_lookup_service() or g_resolver_lookup_service_async() to find the #GSrvTargets for a given service. However, if you are simply planning to connect to the remote service, you can use #GNetworkService's #GSocketConnectable interface and not need to worry about #GSrvTarget at all. Creates a new #GSrvTarget with the given parameters. You should not need to use this; normally #GSrvTargets are created by #GResolver. a new #GSrvTarget. the host that the service is running on the port that the service is running on the target's priority the target's weight Copies @target a copy of @target a #GSrvTarget Frees @target a #GSrvTarget Gets @target's hostname (in ASCII form; if you are going to present this to the user, you should use g_hostname_is_ascii_encoded() to check if it contains encoded Unicode segments, and use g_hostname_to_unicode() to convert it if it does.) @target's hostname a #GSrvTarget Gets @target's port @target's port a #GSrvTarget Gets @target's priority. You should not need to look at this; #GResolver already sorts the targets according to the algorithm in RFC 2782. @target's priority a #GSrvTarget Gets @target's weight. You should not need to look at this; #GResolver already sorts the targets according to the algorithm in RFC 2782. @target's weight a #GSrvTarget Sorts @targets in place according to the algorithm in RFC 2782. the head of the sorted list. a #GList of #GSrvTarget #GStaticResource is an opaque data structure and can only be accessed using the following functions. Finalized a GResource initialized by g_static_resource_init(). This is normally used by code generated by [glib-compile-resources][glib-compile-resources] and is not typically used by other code. pointer to a static #GStaticResource Gets the GResource that was registered by a call to g_static_resource_init(). This is normally used by code generated by [glib-compile-resources][glib-compile-resources] and is not typically used by other code. a #GResource pointer to a static #GStaticResource Initializes a GResource from static data using a GStaticResource. This is normally used by code generated by [glib-compile-resources][glib-compile-resources] and is not typically used by other code. pointer to a static #GStaticResource #GSubprocess allows the creation of and interaction with child processes. Processes can be communicated with using standard GIO-style APIs (ie: #GInputStream, #GOutputStream). There are GIO-style APIs to wait for process termination (ie: cancellable and with an asynchronous variant). There is an API to force a process to terminate, as well as a race-free API for sending UNIX signals to a subprocess. One major advantage that GIO brings over the core GLib library is comprehensive API for asynchronous I/O, such g_output_stream_splice_async(). This makes GSubprocess significantly more powerful and flexible than equivalent APIs in some other languages such as the `subprocess.py` included with Python. For example, using #GSubprocess one could create two child processes, reading standard output from the first, processing it, and writing to the input stream of the second, all without blocking the main loop. A powerful g_subprocess_communicate() API is provided similar to the `communicate()` method of `subprocess.py`. This enables very easy interaction with a subprocess that has been opened with pipes. #GSubprocess defaults to tight control over the file descriptors open in the child process, avoiding dangling-fd issues that are caused by a simple fork()/exec(). The only open file descriptors in the spawned process are ones that were explicitly specified by the #GSubprocess API (unless %G_SUBPROCESS_FLAGS_INHERIT_FDS was specified). #GSubprocess will quickly reap all child processes as they exit, avoiding "zombie processes" remaining around for long periods of time. g_subprocess_wait() can be used to wait for this to happen, but it will happen even without the call being explicitly made. As a matter of principle, #GSubprocess has no API that accepts shell-style space-separated strings. It will, however, match the typical shell behaviour of searching the PATH for executables that do not contain a directory separator in their name. #GSubprocess attempts to have a very simple API for most uses (ie: spawning a subprocess with arguments and support for most typical kinds of input and output redirection). See g_subprocess_new(). The #GSubprocessLauncher API is provided for more complicated cases (advanced types of redirection, environment variable manipulation, change of working directory, child setup functions, etc). A typical use of #GSubprocess will involve calling g_subprocess_new(), followed by g_subprocess_wait_async() or g_subprocess_wait(). After the process exits, the status can be checked using functions such as g_subprocess_get_if_exited() (which are similar to the familiar WIFEXITED-style POSIX macros). Create a new process with the given flags and varargs argument list. By default, matching the g_spawn_async() defaults, the child's stdin will be set to the system null device, and stdout/stderr will be inherited from the parent. You can use @flags to control this behavior. The argument list must be terminated with %NULL. A newly created #GSubprocess, or %NULL on error (and @error will be set) flags that define the behaviour of the subprocess return location for an error, or %NULL first commandline argument to pass to the subprocess more commandline arguments, followed by %NULL Create a new process with the given flags and argument list. The argument list is expected to be %NULL-terminated. A newly created #GSubprocess, or %NULL on error (and @error will be set) commandline arguments for the subprocess flags that define the behaviour of the subprocess Communicate with the subprocess until it terminates, and all input and output has been completed. If @stdin_buf is given, the subprocess must have been created with %G_SUBPROCESS_FLAGS_STDIN_PIPE. The given data is fed to the stdin of the subprocess and the pipe is closed (ie: EOF). At the same time (as not to cause blocking when dealing with large amounts of data), if %G_SUBPROCESS_FLAGS_STDOUT_PIPE or %G_SUBPROCESS_FLAGS_STDERR_PIPE were used, reads from those streams. The data that was read is returned in @stdout and/or the @stderr. If the subprocess was created with %G_SUBPROCESS_FLAGS_STDOUT_PIPE, @stdout_buf will contain the data read from stdout. Otherwise, for subprocesses not created with %G_SUBPROCESS_FLAGS_STDOUT_PIPE, @stdout_buf will be set to %NULL. Similar provisions apply to @stderr_buf and %G_SUBPROCESS_FLAGS_STDERR_PIPE. As usual, any output variable may be given as %NULL to ignore it. If you desire the stdout and stderr data to be interleaved, create the subprocess with %G_SUBPROCESS_FLAGS_STDOUT_PIPE and %G_SUBPROCESS_FLAGS_STDERR_MERGE. The merged result will be returned in @stdout_buf and @stderr_buf will be set to %NULL. In case of any error (including cancellation), %FALSE will be returned with @error set. Some or all of the stdin data may have been written. Any stdout or stderr data that has been read will be discarded. None of the out variables (aside from @error) will have been set to anything in particular and should not be inspected. In the case that %TRUE is returned, the subprocess has exited and the exit status inspection APIs (eg: g_subprocess_get_if_exited(), g_subprocess_get_exit_status()) may be used. You should not attempt to use any of the subprocess pipes after starting this function, since they may be left in strange states, even if the operation was cancelled. You should especially not attempt to interact with the pipes while the operation is in progress (either from another thread or if using the asynchronous version). %TRUE if successful a #GSubprocess data to send to the stdin of the subprocess, or %NULL a #GCancellable data read from the subprocess stdout data read from the subprocess stderr Asynchronous version of g_subprocess_communicate(). Complete invocation with g_subprocess_communicate_finish(). Self Input data, or %NULL Cancellable Callback User data Complete an invocation of g_subprocess_communicate_async(). Self Result Return location for stdout data Return location for stderr data Like g_subprocess_communicate(), but validates the output of the process as UTF-8, and returns it as a regular NUL terminated string. On error, @stdout_buf and @stderr_buf will be set to undefined values and should not be used. a #GSubprocess data to send to the stdin of the subprocess, or %NULL a #GCancellable data read from the subprocess stdout data read from the subprocess stderr Asynchronous version of g_subprocess_communicate_utf8(). Complete invocation with g_subprocess_communicate_utf8_finish(). Self Input data, or %NULL Cancellable Callback User data Complete an invocation of g_subprocess_communicate_utf8_async(). Self Result Return location for stdout data Return location for stderr data Use an operating-system specific method to attempt an immediate, forceful termination of the process. There is no mechanism to determine whether or not the request itself was successful; however, you can use g_subprocess_wait() to monitor the status of the process after calling this function. On Unix, this function sends %SIGKILL. a #GSubprocess Check the exit status of the subprocess, given that it exited normally. This is the value passed to the exit() system call or the return value from main. This is equivalent to the system WEXITSTATUS macro. It is an error to call this function before g_subprocess_wait() and unless g_subprocess_get_if_exited() returned %TRUE. the exit status a #GSubprocess On UNIX, returns the process ID as a decimal string. On Windows, returns the result of GetProcessId() also as a string. If the subprocess has terminated, this will return %NULL. the subprocess identifier, or %NULL if the subprocess has terminated a #GSubprocess Check if the given subprocess exited normally (ie: by way of exit() or return from main()). This is equivalent to the system WIFEXITED macro. It is an error to call this function before g_subprocess_wait() has returned. %TRUE if the case of a normal exit a #GSubprocess Check if the given subprocess terminated in response to a signal. This is equivalent to the system WIFSIGNALED macro. It is an error to call this function before g_subprocess_wait() has returned. %TRUE if the case of termination due to a signal a #GSubprocess Gets the raw status code of the process, as from waitpid(). This value has no particular meaning, but it can be used with the macros defined by the system headers such as WIFEXITED. It can also be used with g_spawn_check_exit_status(). It is more likely that you want to use g_subprocess_get_if_exited() followed by g_subprocess_get_exit_status(). It is an error to call this function before g_subprocess_wait() has returned. the (meaningless) waitpid() exit status from the kernel a #GSubprocess Gets the #GInputStream from which to read the stderr output of @subprocess. The process must have been created with %G_SUBPROCESS_FLAGS_STDERR_PIPE. the stderr pipe a #GSubprocess Gets the #GOutputStream that you can write to in order to give data to the stdin of @subprocess. The process must have been created with %G_SUBPROCESS_FLAGS_STDIN_PIPE. the stdout pipe a #GSubprocess Gets the #GInputStream from which to read the stdout output of @subprocess. The process must have been created with %G_SUBPROCESS_FLAGS_STDOUT_PIPE. the stdout pipe a #GSubprocess Checks if the process was "successful". A process is considered successful if it exited cleanly with an exit status of 0, either by way of the exit() system call or return from main(). It is an error to call this function before g_subprocess_wait() has returned. %TRUE if the process exited cleanly with a exit status of 0 a #GSubprocess Get the signal number that caused the subprocess to terminate, given that it terminated due to a signal. This is equivalent to the system WTERMSIG macro. It is an error to call this function before g_subprocess_wait() and unless g_subprocess_get_if_signaled() returned %TRUE. the signal causing termination a #GSubprocess Sends the UNIX signal @signal_num to the subprocess, if it is still running. This API is race-free. If the subprocess has terminated, it will not be signalled. This API is not available on Windows. a #GSubprocess the signal number to send Synchronously wait for the subprocess to terminate. After the process terminates you can query its exit status with functions such as g_subprocess_get_if_exited() and g_subprocess_get_exit_status(). This function does not fail in the case of the subprocess having abnormal termination. See g_subprocess_wait_check() for that. Cancelling @cancellable doesn't kill the subprocess. Call g_subprocess_force_exit() if it is desirable. %TRUE on success, %FALSE if @cancellable was cancelled a #GSubprocess a #GCancellable Wait for the subprocess to terminate. This is the asynchronous version of g_subprocess_wait(). a #GSubprocess a #GCancellable, or %NULL a #GAsyncReadyCallback to call when the operation is complete user_data for @callback Combines g_subprocess_wait() with g_spawn_check_exit_status(). %TRUE on success, %FALSE if process exited abnormally, or @cancellable was cancelled a #GSubprocess a #GCancellable Combines g_subprocess_wait_async() with g_spawn_check_exit_status(). This is the asynchronous version of g_subprocess_wait_check(). a #GSubprocess a #GCancellable, or %NULL a #GAsyncReadyCallback to call when the operation is complete user_data for @callback Collects the result of a previous call to g_subprocess_wait_check_async(). %TRUE if successful, or %FALSE with @error set a #GSubprocess the #GAsyncResult passed to your #GAsyncReadyCallback Collects the result of a previous call to g_subprocess_wait_async(). %TRUE if successful, or %FALSE with @error set a #GSubprocess the #GAsyncResult passed to your #GAsyncReadyCallback Flags to define the behaviour of a #GSubprocess. Note that the default for stdin is to redirect from `/dev/null`. For stdout and stderr the default are for them to inherit the corresponding descriptor from the calling process. Note that it is a programmer error to mix 'incompatible' flags. For example, you may not request both %G_SUBPROCESS_FLAGS_STDOUT_PIPE and %G_SUBPROCESS_FLAGS_STDOUT_SILENCE. No flags. create a pipe for the stdin of the spawned process that can be accessed with g_subprocess_get_stdin_pipe(). stdin is inherited from the calling process. create a pipe for the stdout of the spawned process that can be accessed with g_subprocess_get_stdout_pipe(). silence the stdout of the spawned process (ie: redirect to `/dev/null`). create a pipe for the stderr of the spawned process that can be accessed with g_subprocess_get_stderr_pipe(). silence the stderr of the spawned process (ie: redirect to `/dev/null`). merge the stderr of the spawned process with whatever the stdout happens to be. This is a good way of directing both streams to a common log file, for example. spawned processes will inherit the file descriptors of their parent, unless those descriptors have been explicitly marked as close-on-exec. This flag has no effect over the "standard" file descriptors (stdin, stdout, stderr). This class contains a set of options for launching child processes, such as where its standard input and output will be directed, the argument list, the environment, and more. While the #GSubprocess class has high level functions covering popular cases, use of this class allows access to more advanced options. It can also be used to launch multiple subprocesses with a similar configuration. Creates a new #GSubprocessLauncher. The launcher is created with the default options. A copy of the environment of the calling process is made at the time of this call and will be used as the environment that the process is launched in. #GSubprocessFlags Returns the value of the environment variable @variable in the environment of processes launched from this launcher. On UNIX, the returned string can be an arbitrary byte string. On Windows, it will be UTF-8. the value of the environment variable, %NULL if unset a #GSubprocessLauncher the environment variable to get Sets up a child setup function. The child setup function will be called after fork() but before exec() on the child's side. @destroy_notify will not be automatically called on the child's side of the fork(). It will only be called when the last reference on the #GSubprocessLauncher is dropped or when a new child setup function is given. %NULL can be given as @child_setup to disable the functionality. Child setup functions are only available on UNIX. a #GSubprocessLauncher a #GSpawnChildSetupFunc to use as the child setup function user data for @child_setup a #GDestroyNotify for @user_data Sets the current working directory that processes will be launched with. By default processes are launched with the current working directory of the launching process at the time of launch. a #GSubprocessLauncher the cwd for launched processes Replace the entire environment of processes launched from this launcher with the given 'environ' variable. Typically you will build this variable by using g_listenv() to copy the process 'environ' and using the functions g_environ_setenv(), g_environ_unsetenv(), etc. As an alternative, you can use g_subprocess_launcher_setenv(), g_subprocess_launcher_unsetenv(), etc. Pass an empty array to set an empty environment. Pass %NULL to inherit the parent process’ environment. As of GLib 2.54, the parent process’ environment will be copied when g_subprocess_launcher_set_environ() is called. Previously, it was copied when the subprocess was executed. This means the copied environment may now be modified (using g_subprocess_launcher_setenv(), etc.) before launching the subprocess. On UNIX, all strings in this array can be arbitrary byte strings. On Windows, they should be in UTF-8. a #GSubprocessLauncher the replacement environment Sets the flags on the launcher. The default flags are %G_SUBPROCESS_FLAGS_NONE. You may not set flags that specify conflicting options for how to handle a particular stdio stream (eg: specifying both %G_SUBPROCESS_FLAGS_STDIN_PIPE and %G_SUBPROCESS_FLAGS_STDIN_INHERIT). You may also not set a flag that conflicts with a previous call to a function like g_subprocess_launcher_set_stdin_file_path() or g_subprocess_launcher_take_stdout_fd(). a #GSubprocessLauncher #GSubprocessFlags Sets the file path to use as the stderr for spawned processes. If @path is %NULL then any previously given path is unset. The file will be created or truncated when the process is spawned, as would be the case if using '2>' at the shell. If you want to send both stdout and stderr to the same file then use %G_SUBPROCESS_FLAGS_STDERR_MERGE. You may not set a stderr file path if a stderr fd is already set or if the launcher flags contain any flags directing stderr elsewhere. This feature is only available on UNIX. a #GSubprocessLauncher a filename or %NULL Sets the file path to use as the stdin for spawned processes. If @path is %NULL then any previously given path is unset. The file must exist or spawning the process will fail. You may not set a stdin file path if a stdin fd is already set or if the launcher flags contain any flags directing stdin elsewhere. This feature is only available on UNIX. a #GSubprocessLauncher Sets the file path to use as the stdout for spawned processes. If @path is %NULL then any previously given path is unset. The file will be created or truncated when the process is spawned, as would be the case if using '>' at the shell. You may not set a stdout file path if a stdout fd is already set or if the launcher flags contain any flags directing stdout elsewhere. This feature is only available on UNIX. a #GSubprocessLauncher a filename or %NULL Sets the environment variable @variable in the environment of processes launched from this launcher. On UNIX, both the variable's name and value can be arbitrary byte strings, except that the variable's name cannot contain '='. On Windows, they should be in UTF-8. a #GSubprocessLauncher the environment variable to set, must not contain '=' the new value for the variable whether to change the variable if it already exists Creates a #GSubprocess given a provided varargs list of arguments. A new #GSubprocess, or %NULL on error (and @error will be set) a #GSubprocessLauncher Error Command line arguments Continued arguments, %NULL terminated Creates a #GSubprocess given a provided array of arguments. A new #GSubprocess, or %NULL on error (and @error will be set) a #GSubprocessLauncher Command line arguments Transfer an arbitrary file descriptor from parent process to the child. This function takes "ownership" of the fd; it will be closed in the parent when @self is freed. By default, all file descriptors from the parent will be closed. This function allows you to create (for example) a custom pipe() or socketpair() before launching the process, and choose the target descriptor in the child. An example use case is GNUPG, which has a command line argument --passphrase-fd providing a file descriptor number where it expects the passphrase to be written. a #GSubprocessLauncher File descriptor in parent process Target descriptor for child process Sets the file descriptor to use as the stderr for spawned processes. If @fd is -1 then any previously given fd is unset. Note that the default behaviour is to pass stderr through to the stderr of the parent process. The passed @fd belongs to the #GSubprocessLauncher. It will be automatically closed when the launcher is finalized. The file descriptor will also be closed on the child side when executing the spawned process. You may not set a stderr fd if a stderr file path is already set or if the launcher flags contain any flags directing stderr elsewhere. This feature is only available on UNIX. a #GSubprocessLauncher a file descriptor, or -1 Sets the file descriptor to use as the stdin for spawned processes. If @fd is -1 then any previously given fd is unset. Note that if your intention is to have the stdin of the calling process inherited by the child then %G_SUBPROCESS_FLAGS_STDIN_INHERIT is a better way to go about doing that. The passed @fd is noted but will not be touched in the current process. It is therefore necessary that it be kept open by the caller until the subprocess is spawned. The file descriptor will also not be explicitly closed on the child side, so it must be marked O_CLOEXEC if that's what you want. You may not set a stdin fd if a stdin file path is already set or if the launcher flags contain any flags directing stdin elsewhere. This feature is only available on UNIX. a #GSubprocessLauncher a file descriptor, or -1 Sets the file descriptor to use as the stdout for spawned processes. If @fd is -1 then any previously given fd is unset. Note that the default behaviour is to pass stdout through to the stdout of the parent process. The passed @fd is noted but will not be touched in the current process. It is therefore necessary that it be kept open by the caller until the subprocess is spawned. The file descriptor will also not be explicitly closed on the child side, so it must be marked O_CLOEXEC if that's what you want. You may not set a stdout fd if a stdout file path is already set or if the launcher flags contain any flags directing stdout elsewhere. This feature is only available on UNIX. a #GSubprocessLauncher a file descriptor, or -1 Removes the environment variable @variable from the environment of processes launched from this launcher. On UNIX, the variable's name can be an arbitrary byte string not containing '='. On Windows, it should be in UTF-8. a #GSubprocessLauncher the environment variable to unset, must not contain '=' Extension point for TLS functionality via #GTlsBackend. See [Extending GIO][extending-gio]. The purpose used to verify the client certificate in a TLS connection. Used by TLS servers. The purpose used to verify the server certificate in a TLS connection. This is the most common purpose in use. Used by TLS clients. A #GTask represents and manages a cancellable "task". ## Asynchronous operations The most common usage of #GTask is as a #GAsyncResult, to manage data during an asynchronous operation. You call g_task_new() in the "start" method, followed by g_task_set_task_data() and the like if you need to keep some additional data associated with the task, and then pass the task object around through your asynchronous operation. Eventually, you will call a method such as g_task_return_pointer() or g_task_return_error(), which will save the value you give it and then invoke the task's callback function in the [thread-default main context][g-main-context-push-thread-default] where it was created (waiting until the next iteration of the main loop first, if necessary). The caller will pass the #GTask back to the operation's finish function (as a #GAsyncResult), and you can use g_task_propagate_pointer() or the like to extract the return value. Here is an example for using GTask as a GAsyncResult: |[<!-- language="C" --> typedef struct { CakeFrostingType frosting; char *message; } DecorationData; static void decoration_data_free (DecorationData *decoration) { g_free (decoration->message); g_slice_free (DecorationData, decoration); } static void baked_cb (Cake *cake, gpointer user_data) { GTask *task = user_data; DecorationData *decoration = g_task_get_task_data (task); GError *error = NULL; if (cake == NULL) { g_task_return_new_error (task, BAKER_ERROR, BAKER_ERROR_NO_FLOUR, "Go to the supermarket"); g_object_unref (task); return; } if (!cake_decorate (cake, decoration->frosting, decoration->message, &error)) { g_object_unref (cake); // g_task_return_error() takes ownership of error g_task_return_error (task, error); g_object_unref (task); return; } g_task_return_pointer (task, cake, g_object_unref); g_object_unref (task); } void baker_bake_cake_async (Baker *self, guint radius, CakeFlavor flavor, CakeFrostingType frosting, const char *message, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data) { GTask *task; DecorationData *decoration; Cake *cake; task = g_task_new (self, cancellable, callback, user_data); if (radius < 3) { g_task_return_new_error (task, BAKER_ERROR, BAKER_ERROR_TOO_SMALL, "%ucm radius cakes are silly", radius); g_object_unref (task); return; } cake = _baker_get_cached_cake (self, radius, flavor, frosting, message); if (cake != NULL) { // _baker_get_cached_cake() returns a reffed cake g_task_return_pointer (task, cake, g_object_unref); g_object_unref (task); return; } decoration = g_slice_new (DecorationData); decoration->frosting = frosting; decoration->message = g_strdup (message); g_task_set_task_data (task, decoration, (GDestroyNotify) decoration_data_free); _baker_begin_cake (self, radius, flavor, cancellable, baked_cb, task); } Cake * baker_bake_cake_finish (Baker *self, GAsyncResult *result, GError **error) { g_return_val_if_fail (g_task_is_valid (result, self), NULL); return g_task_propagate_pointer (G_TASK (result), error); } ]| ## Chained asynchronous operations #GTask also tries to simplify asynchronous operations that internally chain together several smaller asynchronous operations. g_task_get_cancellable(), g_task_get_context(), and g_task_get_priority() allow you to get back the task's #GCancellable, #GMainContext, and [I/O priority][io-priority] when starting a new subtask, so you don't have to keep track of them yourself. g_task_attach_source() simplifies the case of waiting for a source to fire (automatically using the correct #GMainContext and priority). Here is an example for chained asynchronous operations: |[<!-- language="C" --> typedef struct { Cake *cake; CakeFrostingType frosting; char *message; } BakingData; static void decoration_data_free (BakingData *bd) { if (bd->cake) g_object_unref (bd->cake); g_free (bd->message); g_slice_free (BakingData, bd); } static void decorated_cb (Cake *cake, GAsyncResult *result, gpointer user_data) { GTask *task = user_data; GError *error = NULL; if (!cake_decorate_finish (cake, result, &error)) { g_object_unref (cake); g_task_return_error (task, error); g_object_unref (task); return; } // baking_data_free() will drop its ref on the cake, so we have to // take another here to give to the caller. g_task_return_pointer (task, g_object_ref (cake), g_object_unref); g_object_unref (task); } static gboolean decorator_ready (gpointer user_data) { GTask *task = user_data; BakingData *bd = g_task_get_task_data (task); cake_decorate_async (bd->cake, bd->frosting, bd->message, g_task_get_cancellable (task), decorated_cb, task); return G_SOURCE_REMOVE; } static void baked_cb (Cake *cake, gpointer user_data) { GTask *task = user_data; BakingData *bd = g_task_get_task_data (task); GError *error = NULL; if (cake == NULL) { g_task_return_new_error (task, BAKER_ERROR, BAKER_ERROR_NO_FLOUR, "Go to the supermarket"); g_object_unref (task); return; } bd->cake = cake; // Bail out now if the user has already cancelled if (g_task_return_error_if_cancelled (task)) { g_object_unref (task); return; } if (cake_decorator_available (cake)) decorator_ready (task); else { GSource *source; source = cake_decorator_wait_source_new (cake); // Attach @source to @task's GMainContext and have it call // decorator_ready() when it is ready. g_task_attach_source (task, source, decorator_ready); g_source_unref (source); } } void baker_bake_cake_async (Baker *self, guint radius, CakeFlavor flavor, CakeFrostingType frosting, const char *message, gint priority, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data) { GTask *task; BakingData *bd; task = g_task_new (self, cancellable, callback, user_data); g_task_set_priority (task, priority); bd = g_slice_new0 (BakingData); bd->frosting = frosting; bd->message = g_strdup (message); g_task_set_task_data (task, bd, (GDestroyNotify) baking_data_free); _baker_begin_cake (self, radius, flavor, cancellable, baked_cb, task); } Cake * baker_bake_cake_finish (Baker *self, GAsyncResult *result, GError **error) { g_return_val_if_fail (g_task_is_valid (result, self), NULL); return g_task_propagate_pointer (G_TASK (result), error); } ]| ## Asynchronous operations from synchronous ones You can use g_task_run_in_thread() to turn a synchronous operation into an asynchronous one, by running it in a thread. When it completes, the result will be dispatched to the [thread-default main context][g-main-context-push-thread-default] where the #GTask was created. Running a task in a thread: |[<!-- language="C" --> typedef struct { guint radius; CakeFlavor flavor; CakeFrostingType frosting; char *message; } CakeData; static void cake_data_free (CakeData *cake_data) { g_free (cake_data->message); g_slice_free (CakeData, cake_data); } static void bake_cake_thread (GTask *task, gpointer source_object, gpointer task_data, GCancellable *cancellable) { Baker *self = source_object; CakeData *cake_data = task_data; Cake *cake; GError *error = NULL; cake = bake_cake (baker, cake_data->radius, cake_data->flavor, cake_data->frosting, cake_data->message, cancellable, &error); if (cake) g_task_return_pointer (task, cake, g_object_unref); else g_task_return_error (task, error); } void baker_bake_cake_async (Baker *self, guint radius, CakeFlavor flavor, CakeFrostingType frosting, const char *message, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data) { CakeData *cake_data; GTask *task; cake_data = g_slice_new (CakeData); cake_data->radius = radius; cake_data->flavor = flavor; cake_data->frosting = frosting; cake_data->message = g_strdup (message); task = g_task_new (self, cancellable, callback, user_data); g_task_set_task_data (task, cake_data, (GDestroyNotify) cake_data_free); g_task_run_in_thread (task, bake_cake_thread); g_object_unref (task); } Cake * baker_bake_cake_finish (Baker *self, GAsyncResult *result, GError **error) { g_return_val_if_fail (g_task_is_valid (result, self), NULL); return g_task_propagate_pointer (G_TASK (result), error); } ]| ## Adding cancellability to uncancellable tasks Finally, g_task_run_in_thread() and g_task_run_in_thread_sync() can be used to turn an uncancellable operation into a cancellable one. If you call g_task_set_return_on_cancel(), passing %TRUE, then if the task's #GCancellable is cancelled, it will return control back to the caller immediately, while allowing the task thread to continue running in the background (and simply discarding its result when it finally does finish). Provided that the task thread is careful about how it uses locks and other externally-visible resources, this allows you to make "GLib-friendly" asynchronous and cancellable synchronous variants of blocking APIs. Cancelling a task: |[<!-- language="C" --> static void bake_cake_thread (GTask *task, gpointer source_object, gpointer task_data, GCancellable *cancellable) { Baker *self = source_object; CakeData *cake_data = task_data; Cake *cake; GError *error = NULL; cake = bake_cake (baker, cake_data->radius, cake_data->flavor, cake_data->frosting, cake_data->message, &error); if (error) { g_task_return_error (task, error); return; } // If the task has already been cancelled, then we don't want to add // the cake to the cake cache. Likewise, we don't want to have the // task get cancelled in the middle of updating the cache. // g_task_set_return_on_cancel() will return %TRUE here if it managed // to disable return-on-cancel, or %FALSE if the task was cancelled // before it could. if (g_task_set_return_on_cancel (task, FALSE)) { // If the caller cancels at this point, their // GAsyncReadyCallback won't be invoked until we return, // so we don't have to worry that this code will run at // the same time as that code does. But if there were // other functions that might look at the cake cache, // then we'd probably need a GMutex here as well. baker_add_cake_to_cache (baker, cake); g_task_return_pointer (task, cake, g_object_unref); } } void baker_bake_cake_async (Baker *self, guint radius, CakeFlavor flavor, CakeFrostingType frosting, const char *message, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data) { CakeData *cake_data; GTask *task; cake_data = g_slice_new (CakeData); ... task = g_task_new (self, cancellable, callback, user_data); g_task_set_task_data (task, cake_data, (GDestroyNotify) cake_data_free); g_task_set_return_on_cancel (task, TRUE); g_task_run_in_thread (task, bake_cake_thread); } Cake * baker_bake_cake_sync (Baker *self, guint radius, CakeFlavor flavor, CakeFrostingType frosting, const char *message, GCancellable *cancellable, GError **error) { CakeData *cake_data; GTask *task; Cake *cake; cake_data = g_slice_new (CakeData); ... task = g_task_new (self, cancellable, NULL, NULL); g_task_set_task_data (task, cake_data, (GDestroyNotify) cake_data_free); g_task_set_return_on_cancel (task, TRUE); g_task_run_in_thread_sync (task, bake_cake_thread); cake = g_task_propagate_pointer (task, error); g_object_unref (task); return cake; } ]| ## Porting from GSimpleAsyncResult #GTask's API attempts to be simpler than #GSimpleAsyncResult's in several ways: - You can save task-specific data with g_task_set_task_data(), and retrieve it later with g_task_get_task_data(). This replaces the abuse of g_simple_async_result_set_op_res_gpointer() for the same purpose with #GSimpleAsyncResult. - In addition to the task data, #GTask also keeps track of the [priority][io-priority], #GCancellable, and #GMainContext associated with the task, so tasks that consist of a chain of simpler asynchronous operations will have easy access to those values when starting each sub-task. - g_task_return_error_if_cancelled() provides simplified handling for cancellation. In addition, cancellation overrides any other #GTask return value by default, like #GSimpleAsyncResult does when g_simple_async_result_set_check_cancellable() is called. (You can use g_task_set_check_cancellable() to turn off that behavior.) On the other hand, g_task_run_in_thread() guarantees that it will always run your `task_func`, even if the task's #GCancellable is already cancelled before the task gets a chance to run; you can start your `task_func` with a g_task_return_error_if_cancelled() check if you need the old behavior. - The "return" methods (eg, g_task_return_pointer()) automatically cause the task to be "completed" as well, and there is no need to worry about the "complete" vs "complete in idle" distinction. (#GTask automatically figures out whether the task's callback can be invoked directly, or if it needs to be sent to another #GMainContext, or delayed until the next iteration of the current #GMainContext.) - The "finish" functions for #GTask based operations are generally much simpler than #GSimpleAsyncResult ones, normally consisting of only a single call to g_task_propagate_pointer() or the like. Since g_task_propagate_pointer() "steals" the return value from the #GTask, it is not necessary to juggle pointers around to prevent it from being freed twice. - With #GSimpleAsyncResult, it was common to call g_simple_async_result_propagate_error() from the `_finish()` wrapper function, and have virtual method implementations only deal with successful returns. This behavior is deprecated, because it makes it difficult for a subclass to chain to a parent class's async methods. Instead, the wrapper function should just be a simple wrapper, and the virtual method should call an appropriate `g_task_propagate_` function. Note that wrapper methods can now use g_async_result_legacy_propagate_error() to do old-style #GSimpleAsyncResult error-returning behavior, and g_async_result_is_tagged() to check if a result is tagged as having come from the `_async()` wrapper function (for "short-circuit" results, such as when passing 0 to g_input_stream_read_async()). Creates a #GTask acting on @source_object, which will eventually be used to invoke @callback in the current [thread-default main context][g-main-context-push-thread-default]. Call this in the "start" method of your asynchronous method, and pass the #GTask around throughout the asynchronous operation. You can use g_task_set_task_data() to attach task-specific data to the object, which you can retrieve later via g_task_get_task_data(). By default, if @cancellable is cancelled, then the return value of the task will always be %G_IO_ERROR_CANCELLED, even if the task had already completed before the cancellation. This allows for simplified handling in cases where cancellation may imply that other objects that the task depends on have been destroyed. If you do not want this behavior, you can use g_task_set_check_cancellable() to change it. a #GTask. the #GObject that owns this task, or %NULL. optional #GCancellable object, %NULL to ignore. a #GAsyncReadyCallback. user data passed to @callback. Checks that @result is a #GTask, and that @source_object is its source object (or that @source_object is %NULL and @result has no source object). This can be used in g_return_if_fail() checks. %TRUE if @result and @source_object are valid, %FALSE if not A #GAsyncResult the source object expected to be associated with the task Creates a #GTask and then immediately calls g_task_return_error() on it. Use this in the wrapper function of an asynchronous method when you want to avoid even calling the virtual method. You can then use g_async_result_is_tagged() in the finish method wrapper to check if the result there is tagged as having been created by the wrapper method, and deal with it appropriately if so. See also g_task_report_new_error(). the #GObject that owns this task, or %NULL. a #GAsyncReadyCallback. user data passed to @callback. an opaque pointer indicating the source of this task error to report Creates a #GTask and then immediately calls g_task_return_new_error() on it. Use this in the wrapper function of an asynchronous method when you want to avoid even calling the virtual method. You can then use g_async_result_is_tagged() in the finish method wrapper to check if the result there is tagged as having been created by the wrapper method, and deal with it appropriately if so. See also g_task_report_error(). the #GObject that owns this task, or %NULL. a #GAsyncReadyCallback. user data passed to @callback. an opaque pointer indicating the source of this task a #GQuark. an error code. a string with format characters. a list of values to insert into @format. A utility function for dealing with async operations where you need to wait for a #GSource to trigger. Attaches @source to @task's #GMainContext with @task's [priority][io-priority], and sets @source's callback to @callback, with @task as the callback's `user_data`. It will set the @source’s name to the task’s name (as set with g_task_set_name()), if one has been set. This takes a reference on @task until @source is destroyed. a #GTask the source to attach the callback to invoke when @source triggers Gets @task's #GCancellable @task's #GCancellable a #GTask Gets @task's check-cancellable flag. See g_task_set_check_cancellable() for more details. the #GTask Gets the value of #GTask:completed. This changes from %FALSE to %TRUE after the task’s callback is invoked, and will return %FALSE if called from inside the callback. %TRUE if the task has completed, %FALSE otherwise. a #GTask. Gets the #GMainContext that @task will return its result in (that is, the context that was the [thread-default main context][g-main-context-push-thread-default] at the point when @task was created). This will always return a non-%NULL value, even if the task's context is the default #GMainContext. @task's #GMainContext a #GTask Gets @task’s name. See g_task_set_name(). @task’s name, or %NULL a #GTask Gets @task's priority @task's priority a #GTask Gets @task's return-on-cancel flag. See g_task_set_return_on_cancel() for more details. the #GTask Gets the source object from @task. Like g_async_result_get_source_object(), but does not ref the object. @task's source object, or %NULL a #GTask Gets @task's source tag. See g_task_set_source_tag(). @task's source tag a #GTask Gets @task's `task_data`. @task's `task_data`. a #GTask Tests if @task resulted in an error. %TRUE if the task resulted in an error, %FALSE otherwise. a #GTask. Gets the result of @task as a #gboolean. If the task resulted in an error, or was cancelled, then this will instead return %FALSE and set @error. Since this method transfers ownership of the return value (or error) to the caller, you may only call it once. the task result, or %FALSE on error a #GTask. Gets the result of @task as an integer (#gssize). If the task resulted in an error, or was cancelled, then this will instead return -1 and set @error. Since this method transfers ownership of the return value (or error) to the caller, you may only call it once. the task result, or -1 on error a #GTask. Gets the result of @task as a pointer, and transfers ownership of that value to the caller. If the task resulted in an error, or was cancelled, then this will instead return %NULL and set @error. Since this method transfers ownership of the return value (or error) to the caller, you may only call it once. the task result, or %NULL on error a #GTask Gets the result of @task as a #GValue, and transfers ownership of that value to the caller. As with g_task_return_value(), this is a generic low-level method; g_task_propagate_pointer() and the like will usually be more useful for C code. If the task resulted in an error, or was cancelled, then this will instead set @error and return %FALSE. Since this method transfers ownership of the return value (or error) to the caller, you may only call it once. %TRUE if @task succeeded, %FALSE on error. a #GTask return location for the #GValue Sets @task's result to @result and completes the task (see g_task_return_pointer() for more discussion of exactly what this means). a #GTask. the #gboolean result of a task function. Sets @task's result to @error (which @task assumes ownership of) and completes the task (see g_task_return_pointer() for more discussion of exactly what this means). Note that since the task takes ownership of @error, and since the task may be completed before returning from g_task_return_error(), you cannot assume that @error is still valid after calling this. Call g_error_copy() on the error if you need to keep a local copy as well. See also g_task_return_new_error(). a #GTask. the #GError result of a task function. Checks if @task's #GCancellable has been cancelled, and if so, sets @task's error accordingly and completes the task (see g_task_return_pointer() for more discussion of exactly what this means). %TRUE if @task has been cancelled, %FALSE if not a #GTask Sets @task's result to @result and completes the task (see g_task_return_pointer() for more discussion of exactly what this means). a #GTask. the integer (#gssize) result of a task function. Sets @task's result to a new #GError created from @domain, @code, @format, and the remaining arguments, and completes the task (see g_task_return_pointer() for more discussion of exactly what this means). See also g_task_return_error(). a #GTask. a #GQuark. an error code. a string with format characters. a list of values to insert into @format. Sets @task's result to @result and completes the task. If @result is not %NULL, then @result_destroy will be used to free @result if the caller does not take ownership of it with g_task_propagate_pointer(). "Completes the task" means that for an ordinary asynchronous task it will either invoke the task's callback, or else queue that callback to be invoked in the proper #GMainContext, or in the next iteration of the current #GMainContext. For a task run via g_task_run_in_thread() or g_task_run_in_thread_sync(), calling this method will save @result to be returned to the caller later, but the task will not actually be completed until the #GTaskThreadFunc exits. Note that since the task may be completed before returning from g_task_return_pointer(), you cannot assume that @result is still valid after calling this, unless you are still holding another reference on it. a #GTask the pointer result of a task function a #GDestroyNotify function. Sets @task's result to @result (by copying it) and completes the task. If @result is %NULL then a #GValue of type #G_TYPE_POINTER with a value of %NULL will be used for the result. This is a very generic low-level method intended primarily for use by language bindings; for C code, g_task_return_pointer() and the like will normally be much easier to use. a #GTask the #GValue result of a task function Runs @task_func in another thread. When @task_func returns, @task's #GAsyncReadyCallback will be invoked in @task's #GMainContext. This takes a ref on @task until the task completes. See #GTaskThreadFunc for more details about how @task_func is handled. Although GLib currently rate-limits the tasks queued via g_task_run_in_thread(), you should not assume that it will always do this. If you have a very large number of tasks to run, but don't want them to all run at once, you should only queue a limited number of them at a time. a #GTask a #GTaskThreadFunc Runs @task_func in another thread, and waits for it to return or be cancelled. You can use g_task_propagate_pointer(), etc, afterward to get the result of @task_func. See #GTaskThreadFunc for more details about how @task_func is handled. Normally this is used with tasks created with a %NULL `callback`, but note that even if the task does have a callback, it will not be invoked when @task_func returns. #GTask:completed will be set to %TRUE just before this function returns. Although GLib currently rate-limits the tasks queued via g_task_run_in_thread_sync(), you should not assume that it will always do this. If you have a very large number of tasks to run, but don't want them to all run at once, you should only queue a limited number of them at a time. a #GTask a #GTaskThreadFunc Sets or clears @task's check-cancellable flag. If this is %TRUE (the default), then g_task_propagate_pointer(), etc, and g_task_had_error() will check the task's #GCancellable first, and if it has been cancelled, then they will consider the task to have returned an "Operation was cancelled" error (%G_IO_ERROR_CANCELLED), regardless of any other error or return value the task may have had. If @check_cancellable is %FALSE, then the #GTask will not check the cancellable itself, and it is up to @task's owner to do this (eg, via g_task_return_error_if_cancelled()). If you are using g_task_set_return_on_cancel() as well, then you must leave check-cancellable set %TRUE. the #GTask whether #GTask will check the state of its #GCancellable for you. Sets @task’s name, used in debugging and profiling. The name defaults to %NULL. The task name should describe in a human readable way what the task does. For example, ‘Open file’ or ‘Connect to network host’. It is used to set the name of the #GSource used for idle completion of the task. This function may only be called before the @task is first used in a thread other than the one it was constructed in. a #GTask a human readable name for the task, or %NULL to unset it Sets @task's priority. If you do not call this, it will default to %G_PRIORITY_DEFAULT. This will affect the priority of #GSources created with g_task_attach_source() and the scheduling of tasks run in threads, and can also be explicitly retrieved later via g_task_get_priority(). the #GTask the [priority][io-priority] of the request Sets or clears @task's return-on-cancel flag. This is only meaningful for tasks run via g_task_run_in_thread() or g_task_run_in_thread_sync(). If @return_on_cancel is %TRUE, then cancelling @task's #GCancellable will immediately cause it to return, as though the task's #GTaskThreadFunc had called g_task_return_error_if_cancelled() and then returned. This allows you to create a cancellable wrapper around an uninterruptible function. The #GTaskThreadFunc just needs to be careful that it does not modify any externally-visible state after it has been cancelled. To do that, the thread should call g_task_set_return_on_cancel() again to (atomically) set return-on-cancel %FALSE before making externally-visible changes; if the task gets cancelled before the return-on-cancel flag could be changed, g_task_set_return_on_cancel() will indicate this by returning %FALSE. You can disable and re-enable this flag multiple times if you wish. If the task's #GCancellable is cancelled while return-on-cancel is %FALSE, then calling g_task_set_return_on_cancel() to set it %TRUE again will cause the task to be cancelled at that point. If the task's #GCancellable is already cancelled before you call g_task_run_in_thread()/g_task_run_in_thread_sync(), then the #GTaskThreadFunc will still be run (for consistency), but the task will also be completed right away. %TRUE if @task's return-on-cancel flag was changed to match @return_on_cancel. %FALSE if @task has already been cancelled. the #GTask whether the task returns automatically when it is cancelled. Sets @task's source tag. You can use this to tag a task return value with a particular pointer (usually a pointer to the function doing the tagging) and then later check it using g_task_get_source_tag() (or g_async_result_is_tagged()) in the task's "finish" function, to figure out if the response came from a particular place. the #GTask an opaque pointer indicating the source of this task Sets @task's task data (freeing the existing task data, if any). the #GTask task-specific data #GDestroyNotify for @task_data Whether the task has completed, meaning its callback (if set) has been invoked. This can only happen after g_task_return_pointer(), g_task_return_error() or one of the other return functions have been called on the task. This property is guaranteed to change from %FALSE to %TRUE exactly once. The #GObject::notify signal for this change is emitted in the same main context as the task’s callback, immediately after that callback is invoked. The prototype for a task function to be run in a thread via g_task_run_in_thread() or g_task_run_in_thread_sync(). If the return-on-cancel flag is set on @task, and @cancellable gets cancelled, then the #GTask will be completed immediately (as though g_task_return_error_if_cancelled() had been called), without waiting for the task function to complete. However, the task function will continue running in its thread in the background. The function therefore needs to be careful about how it uses externally-visible state in this case. See g_task_set_return_on_cancel() for more details. Other than in that case, @task will be completed when the #GTaskThreadFunc returns, not when it calls a `g_task_return_` function. the #GTask @task's source object @task's task data @task's #GCancellable, or %NULL This is the subclass of #GSocketConnection that is created for TCP/IP sockets. Checks if graceful disconnects are used. See g_tcp_connection_set_graceful_disconnect(). %TRUE if graceful disconnect is used on close, %FALSE otherwise a #GTcpConnection This enables graceful disconnects on close. A graceful disconnect means that we signal the receiving end that the connection is terminated and wait for it to close the connection before closing the connection. A graceful disconnect means that we can be sure that we successfully sent all the outstanding data to the other end, or get an error reported. However, it also means we have to wait for all the data to reach the other side and for it to acknowledge this by closing the socket, which may take a while. For this reason it is disabled by default. a #GTcpConnection Whether to do graceful disconnects or not A #GTcpWrapperConnection can be used to wrap a #GIOStream that is based on a #GSocket, but which is not actually a #GSocketConnection. This is used by #GSocketClient so that it can always return a #GSocketConnection, even when the connection it has actually created is not directly a #GSocketConnection. Wraps @base_io_stream and @socket together as a #GSocketConnection. the new #GSocketConnection. the #GIOStream to wrap the #GSocket associated with @base_io_stream Gets @conn's base #GIOStream @conn's base #GIOStream a #GTcpWrapperConnection A helper class for testing code which uses D-Bus without touching the user's session bus. Note that #GTestDBus modifies the user’s environment, calling setenv(). This is not thread-safe, so all #GTestDBus calls should be completed before threads are spawned, or should have appropriate locking to ensure no access conflicts to environment variables shared between #GTestDBus and other threads. ## Creating unit tests using GTestDBus Testing of D-Bus services can be tricky because normally we only ever run D-Bus services over an existing instance of the D-Bus daemon thus we usually don't activate D-Bus services that are not yet installed into the target system. The #GTestDBus object makes this easier for us by taking care of the lower level tasks such as running a private D-Bus daemon and looking up uninstalled services in customizable locations, typically in your source code tree. The first thing you will need is a separate service description file for the D-Bus daemon. Typically a `services` subdirectory of your `tests` directory is a good place to put this file. The service file should list your service along with an absolute path to the uninstalled service executable in your source tree. Using autotools we would achieve this by adding a file such as `my-server.service.in` in the services directory and have it processed by configure. |[ [D-BUS Service] Name=org.gtk.GDBus.Examples.ObjectManager Exec=@abs_top_builddir@/gio/tests/gdbus-example-objectmanager-server ]| You will also need to indicate this service directory in your test fixtures, so you will need to pass the path while compiling your test cases. Typically this is done with autotools with an added preprocessor flag specified to compile your tests such as: |[ -DTEST_SERVICES=\""$(abs_top_builddir)/tests/services"\" ]| Once you have a service definition file which is local to your source tree, you can proceed to set up a GTest fixture using the #GTestDBus scaffolding. An example of a test fixture for D-Bus services can be found here: [gdbus-test-fixture.c](https://git.gnome.org/browse/glib/tree/gio/tests/gdbus-test-fixture.c) Note that these examples only deal with isolating the D-Bus aspect of your service. To successfully run isolated unit tests on your service you may need some additional modifications to your test case fixture. For example; if your service uses GSettings and installs a schema then it is important that your test service not load the schema in the ordinary installed location (chances are that your service and schema files are not yet installed, or worse; there is an older version of the schema file sitting in the install location). Most of the time we can work around these obstacles using the environment. Since the environment is inherited by the D-Bus daemon created by #GTestDBus and then in turn inherited by any services the D-Bus daemon activates, using the setup routine for your fixture is a practical place to help sandbox your runtime environment. For the rather typical GSettings case we can work around this by setting `GSETTINGS_SCHEMA_DIR` to the in tree directory holding your schemas in the above fixture_setup() routine. The GSettings schemas need to be locally pre-compiled for this to work. This can be achieved by compiling the schemas locally as a step before running test cases, an autotools setup might do the following in the directory holding schemas: |[ all-am: $(GLIB_COMPILE_SCHEMAS) . CLEANFILES += gschemas.compiled ]| Create a new #GTestDBus object. a new #GTestDBus. a #GTestDBusFlags Unset DISPLAY and DBUS_SESSION_BUS_ADDRESS env variables to ensure the test won't use user's session bus. This is useful for unit tests that want to verify behaviour when no session bus is running. It is not necessary to call this if unit test already calls g_test_dbus_up() before acquiring the session bus. Add a path where dbus-daemon will look up .service files. This can't be called after g_test_dbus_up(). a #GTestDBus path to a directory containing .service files Stop the session bus started by g_test_dbus_up(). This will wait for the singleton returned by g_bus_get() or g_bus_get_sync() to be destroyed. This is done to ensure that the next unit test won't get a leaked singleton from this test. a #GTestDBus Get the address on which dbus-daemon is running. If g_test_dbus_up() has not been called yet, %NULL is returned. This can be used with g_dbus_connection_new_for_address(). the address of the bus, or %NULL. a #GTestDBus Get the flags of the #GTestDBus object. the value of #GTestDBus:flags property a #GTestDBus Stop the session bus started by g_test_dbus_up(). Unlike g_test_dbus_down(), this won't verify the #GDBusConnection singleton returned by g_bus_get() or g_bus_get_sync() is destroyed. Unit tests wanting to verify behaviour after the session bus has been stopped can use this function but should still call g_test_dbus_down() when done. a #GTestDBus Start a dbus-daemon instance and set DBUS_SESSION_BUS_ADDRESS. After this call, it is safe for unit tests to start sending messages on the session bus. If this function is called from setup callback of g_test_add(), g_test_dbus_down() must be called in its teardown callback. If this function is called from unit test's main(), then g_test_dbus_down() must be called after g_test_run(). a #GTestDBus #GTestDBusFlags specifying the behaviour of the D-Bus session. Flags to define future #GTestDBus behaviour. No flags. #GThemedIcon is an implementation of #GIcon that supports icon themes. #GThemedIcon contains a list of all of the icons present in an icon theme, so that icons can be looked up quickly. #GThemedIcon does not provide actual pixmaps for icons, just the icon names. Ideally something like gtk_icon_theme_choose_icon() should be used to resolve the list of names so that fallback icons work nicely with themes that inherit other themes. Creates a new themed icon for @iconname. a new #GThemedIcon. a string containing an icon name. Creates a new themed icon for @iconnames. a new #GThemedIcon an array of strings containing icon names. the length of the @iconnames array, or -1 if @iconnames is %NULL-terminated Creates a new themed icon for @iconname, and all the names that can be created by shortening @iconname at '-' characters. In the following example, @icon1 and @icon2 are equivalent: |[<!-- language="C" --> const char *names[] = { "gnome-dev-cdrom-audio", "gnome-dev-cdrom", "gnome-dev", "gnome" }; icon1 = g_themed_icon_new_from_names (names, 4); icon2 = g_themed_icon_new_with_default_fallbacks ("gnome-dev-cdrom-audio"); ]| a new #GThemedIcon. a string containing an icon name Append a name to the list of icons from within @icon. Note that doing so invalidates the hash computed by prior calls to g_icon_hash(). a #GThemedIcon name of icon to append to list of icons from within @icon. Gets the names of icons from within @icon. a list of icon names. a #GThemedIcon. Prepend a name to the list of icons from within @icon. Note that doing so invalidates the hash computed by prior calls to g_icon_hash(). a #GThemedIcon name of icon to prepend to list of icons from within @icon. The icon name. A %NULL-terminated array of icon names. Whether to use the default fallbacks found by shortening the icon name at '-' characters. If the "names" array has more than one element, ignores any past the first. For example, if the icon name was "gnome-dev-cdrom-audio", the array would become |[<!-- language="C" --> { "gnome-dev-cdrom-audio", "gnome-dev-cdrom", "gnome-dev", "gnome", NULL }; ]| A #GThreadedSocketService is a simple subclass of #GSocketService that handles incoming connections by creating a worker thread and dispatching the connection to it by emitting the #GThreadedSocketService::run signal in the new thread. The signal handler may perform blocking IO and need not return until the connection is closed. The service is implemented using a thread pool, so there is a limited amount of threads available to serve incoming requests. The service automatically stops the #GSocketService from accepting new connections when all threads are busy. As with #GSocketService, you may connect to #GThreadedSocketService::run, or subclass and override the default handler. Creates a new #GThreadedSocketService with no listeners. Listeners must be added with one of the #GSocketListener "add" methods. a new #GSocketService. the maximal number of threads to execute concurrently handling incoming clients, -1 means no limit The ::run signal is emitted in a worker thread in response to an incoming connection. This thread is dedicated to handling @connection and may perform blocking IO. The signal handler need not return until the connection is closed. %TRUE to stop further signal handlers from being called a new #GSocketConnection object. the source_object passed to g_socket_listener_add_address(). The client authentication mode for a #GTlsServerConnection. client authentication not required client authentication is requested client authentication is required TLS (Transport Layer Security, aka SSL) and DTLS backend. Gets the default #GTlsBackend for the system. a #GTlsBackend Gets the default #GTlsDatabase used to verify TLS connections. the default database, which should be unreffed when done. the #GTlsBackend Checks if DTLS is supported. DTLS support may not be available even if TLS support is available, and vice-versa. whether DTLS is supported the #GTlsBackend Checks if TLS is supported; if this returns %FALSE for the default #GTlsBackend, it means no "real" TLS backend is available. whether or not TLS is supported the #GTlsBackend Gets the #GType of @backend's #GTlsCertificate implementation. the #GType of @backend's #GTlsCertificate implementation. the #GTlsBackend Gets the #GType of @backend's #GTlsClientConnection implementation. the #GType of @backend's #GTlsClientConnection implementation. the #GTlsBackend Gets the default #GTlsDatabase used to verify TLS connections. the default database, which should be unreffed when done. the #GTlsBackend Gets the #GType of @backend’s #GDtlsClientConnection implementation. the #GType of @backend’s #GDtlsClientConnection implementation, or %G_TYPE_INVALID if this backend doesn’t support DTLS. the #GTlsBackend Gets the #GType of @backend’s #GDtlsServerConnection implementation. the #GType of @backend’s #GDtlsServerConnection implementation, or %G_TYPE_INVALID if this backend doesn’t support DTLS. the #GTlsBackend Gets the #GType of @backend's #GTlsFileDatabase implementation. the #GType of backend's #GTlsFileDatabase implementation. the #GTlsBackend Gets the #GType of @backend's #GTlsServerConnection implementation. the #GType of @backend's #GTlsServerConnection implementation. the #GTlsBackend Set the default #GTlsDatabase used to verify TLS connections Any subsequent call to g_tls_backend_get_default_database() will return the database set in this call. Existing databases and connections are not modified. Setting a %NULL default database will reset to using the system default database as if g_tls_backend_set_default_database() had never been called. the #GTlsBackend the #GTlsDatabase Checks if DTLS is supported. DTLS support may not be available even if TLS support is available, and vice-versa. whether DTLS is supported the #GTlsBackend Checks if TLS is supported; if this returns %FALSE for the default #GTlsBackend, it means no "real" TLS backend is available. whether or not TLS is supported the #GTlsBackend Provides an interface for describing TLS-related types. The parent interface. whether or not TLS is supported the #GTlsBackend the default database, which should be unreffed when done. the #GTlsBackend whether DTLS is supported the #GTlsBackend A certificate used for TLS authentication and encryption. This can represent either a certificate only (eg, the certificate received by a client from a server), or the combination of a certificate and a private key (which is needed when acting as a #GTlsServerConnection). Creates a #GTlsCertificate from the PEM-encoded data in @file. The returned certificate will be the first certificate found in @file. As of GLib 2.44, if @file contains more certificates it will try to load a certificate chain. All certificates will be verified in the order found (top-level certificate should be the last one in the file) and the #GTlsCertificate:issuer property of each certificate will be set accordingly if the verification succeeds. If any certificate in the chain cannot be verified, the first certificate in the file will still be returned. If @file cannot be read or parsed, the function will return %NULL and set @error. Otherwise, this behaves like g_tls_certificate_new_from_pem(). the new certificate, or %NULL on error file containing a PEM-encoded certificate to import Creates a #GTlsCertificate from the PEM-encoded data in @cert_file and @key_file. The returned certificate will be the first certificate found in @cert_file. As of GLib 2.44, if @cert_file contains more certificates it will try to load a certificate chain. All certificates will be verified in the order found (top-level certificate should be the last one in the file) and the #GTlsCertificate:issuer property of each certificate will be set accordingly if the verification succeeds. If any certificate in the chain cannot be verified, the first certificate in the file will still be returned. If either file cannot be read or parsed, the function will return %NULL and set @error. Otherwise, this behaves like g_tls_certificate_new_from_pem(). the new certificate, or %NULL on error file containing one or more PEM-encoded certificates to import file containing a PEM-encoded private key to import Creates a #GTlsCertificate from the PEM-encoded data in @data. If @data includes both a certificate and a private key, then the returned certificate will include the private key data as well. (See the #GTlsCertificate:private-key-pem property for information about supported formats.) The returned certificate will be the first certificate found in @data. As of GLib 2.44, if @data contains more certificates it will try to load a certificate chain. All certificates will be verified in the order found (top-level certificate should be the last one in the file) and the #GTlsCertificate:issuer property of each certificate will be set accordingly if the verification succeeds. If any certificate in the chain cannot be verified, the first certificate in the file will still be returned. the new certificate, or %NULL if @data is invalid PEM-encoded certificate data the length of @data, or -1 if it's 0-terminated. Creates one or more #GTlsCertificates from the PEM-encoded data in @file. If @file cannot be read or parsed, the function will return %NULL and set @error. If @file does not contain any PEM-encoded certificates, this will return an empty list and not set @error. a #GList containing #GTlsCertificate objects. You must free the list and its contents when you are done with it. file containing PEM-encoded certificates to import This verifies @cert and returns a set of #GTlsCertificateFlags indicating any problems found with it. This can be used to verify a certificate outside the context of making a connection, or to check a certificate against a CA that is not part of the system CA database. If @identity is not %NULL, @cert's name(s) will be compared against it, and %G_TLS_CERTIFICATE_BAD_IDENTITY will be set in the return value if it does not match. If @identity is %NULL, that bit will never be set in the return value. If @trusted_ca is not %NULL, then @cert (or one of the certificates in its chain) must be signed by it, or else %G_TLS_CERTIFICATE_UNKNOWN_CA will be set in the return value. If @trusted_ca is %NULL, that bit will never be set in the return value. (All other #GTlsCertificateFlags values will always be set or unset as appropriate.) the appropriate #GTlsCertificateFlags a #GTlsCertificate the expected peer identity the certificate of a trusted authority Gets the #GTlsCertificate representing @cert's issuer, if known The certificate of @cert's issuer, or %NULL if @cert is self-signed or signed with an unknown certificate. a #GTlsCertificate Check if two #GTlsCertificate objects represent the same certificate. The raw DER byte data of the two certificates are checked for equality. This has the effect that two certificates may compare equal even if their #GTlsCertificate:issuer, #GTlsCertificate:private-key, or #GTlsCertificate:private-key-pem properties differ. whether the same or not first certificate to compare second certificate to compare This verifies @cert and returns a set of #GTlsCertificateFlags indicating any problems found with it. This can be used to verify a certificate outside the context of making a connection, or to check a certificate against a CA that is not part of the system CA database. If @identity is not %NULL, @cert's name(s) will be compared against it, and %G_TLS_CERTIFICATE_BAD_IDENTITY will be set in the return value if it does not match. If @identity is %NULL, that bit will never be set in the return value. If @trusted_ca is not %NULL, then @cert (or one of the certificates in its chain) must be signed by it, or else %G_TLS_CERTIFICATE_UNKNOWN_CA will be set in the return value. If @trusted_ca is %NULL, that bit will never be set in the return value. (All other #GTlsCertificateFlags values will always be set or unset as appropriate.) the appropriate #GTlsCertificateFlags a #GTlsCertificate the expected peer identity the certificate of a trusted authority The DER (binary) encoded representation of the certificate. This property and the #GTlsCertificate:certificate-pem property represent the same data, just in different forms. The PEM (ASCII) encoded representation of the certificate. This property and the #GTlsCertificate:certificate property represent the same data, just in different forms. A #GTlsCertificate representing the entity that issued this certificate. If %NULL, this means that the certificate is either self-signed, or else the certificate of the issuer is not available. The DER (binary) encoded representation of the certificate's private key, in either PKCS#1 format or unencrypted PKCS#8 format. This property (or the #GTlsCertificate:private-key-pem property) can be set when constructing a key (eg, from a file), but cannot be read. PKCS#8 format is supported since 2.32; earlier releases only support PKCS#1. You can use the `openssl rsa` tool to convert PKCS#8 keys to PKCS#1. The PEM (ASCII) encoded representation of the certificate's private key in either PKCS#1 format ("`BEGIN RSA PRIVATE KEY`") or unencrypted PKCS#8 format ("`BEGIN PRIVATE KEY`"). This property (or the #GTlsCertificate:private-key property) can be set when constructing a key (eg, from a file), but cannot be read. PKCS#8 format is supported since 2.32; earlier releases only support PKCS#1. You can use the `openssl rsa` tool to convert PKCS#8 keys to PKCS#1. the appropriate #GTlsCertificateFlags a #GTlsCertificate the expected peer identity the certificate of a trusted authority A set of flags describing TLS certification validation. This can be used to set which validation steps to perform (eg, with g_tls_client_connection_set_validation_flags()), or to describe why a particular certificate was rejected (eg, in #GTlsConnection::accept-certificate). The signing certificate authority is not known. The certificate does not match the expected identity of the site that it was retrieved from. The certificate's activation time is still in the future The certificate has expired The certificate has been revoked according to the #GTlsConnection's certificate revocation list. The certificate's algorithm is considered insecure. Some other error occurred validating the certificate the combination of all of the above flags Flags for g_tls_interaction_request_certificate(), g_tls_interaction_request_certificate_async(), and g_tls_interaction_invoke_request_certificate(). No flags An error code used with %G_TLS_CHANNEL_BINDING_ERROR in a #GError to indicate a TLS channel binding retrieval error. Either entire binding retrieval facility or specific binding type is not implemented in the TLS backend. The handshake is not yet complete on the connection which is a strong requirement for any existing binding type. Handshake is complete but binding data is not available. That normally indicates the TLS implementation failed to provide the binding data. For example, some implementations do not provide a peer certificate for resumed connections. Binding type is not supported on the current connection. This error could be triggered when requesting `tls-server-end-point` binding data for a certificate which has no hash function or uses multiple hash functions. Any other backend error preventing binding data retrieval. Gets the TLS channel binding error quark. a #GQuark. The type of TLS channel binding data to retrieve from #GTlsConnection or #GDtlsConnection, as documented by RFC 5929. The [`tls-unique-for-telnet`](https://tools.ietf.org/html/rfc5929#section-5) binding type is not currently implemented. [`tls-unique`](https://tools.ietf.org/html/rfc5929#section-3) binding type [`tls-server-end-point`](https://tools.ietf.org/html/rfc5929#section-4) binding type #GTlsClientConnection is the client-side subclass of #GTlsConnection, representing a client-side TLS connection. Creates a new #GTlsClientConnection wrapping @base_io_stream (which must have pollable input and output streams) which is assumed to communicate with the server identified by @server_identity. See the documentation for #GTlsConnection:base-io-stream for restrictions on when application code can run operations on the @base_io_stream after this function has returned. the new #GTlsClientConnection, or %NULL on error the #GIOStream to wrap the expected identity of the server Possibly copies session state from one connection to another, for use in TLS session resumption. This is not normally needed, but may be used when the same session needs to be used between different endpoints, as is required by some protocols, such as FTP over TLS. @source should have already completed a handshake and, since TLS 1.3, it should have been used to read data at least once. @conn should not have completed a handshake. It is not possible to know whether a call to this function will actually do anything. Because session resumption is normally used only for performance benefit, the TLS backend might not implement this function. Even if implemented, it may not actually succeed in allowing @conn to resume @source's TLS session, because the server may not have sent a session resumption token to @source, or it may refuse to accept the token from @conn. There is no way to know whether a call to this function is actually successful. Using this function is not required to benefit from session resumption. If the TLS backend supports session resumption, the session will be resumed automatically if it is possible to do so without weakening the privacy guarantees normally provided by TLS, without need to call this function. For example, with TLS 1.3, a session ticket will be automatically copied from any #GTlsClientConnection that has previously received session tickets from the server, provided a ticket is available that has not previously been used for session resumption, since session ticket reuse would be a privacy weakness. Using this function causes the ticket to be copied without regard for privacy considerations. a #GTlsClientConnection a #GTlsClientConnection Possibly copies session state from one connection to another, for use in TLS session resumption. This is not normally needed, but may be used when the same session needs to be used between different endpoints, as is required by some protocols, such as FTP over TLS. @source should have already completed a handshake and, since TLS 1.3, it should have been used to read data at least once. @conn should not have completed a handshake. It is not possible to know whether a call to this function will actually do anything. Because session resumption is normally used only for performance benefit, the TLS backend might not implement this function. Even if implemented, it may not actually succeed in allowing @conn to resume @source's TLS session, because the server may not have sent a session resumption token to @source, or it may refuse to accept the token from @conn. There is no way to know whether a call to this function is actually successful. Using this function is not required to benefit from session resumption. If the TLS backend supports session resumption, the session will be resumed automatically if it is possible to do so without weakening the privacy guarantees normally provided by TLS, without need to call this function. For example, with TLS 1.3, a session ticket will be automatically copied from any #GTlsClientConnection that has previously received session tickets from the server, provided a ticket is available that has not previously been used for session resumption, since session ticket reuse would be a privacy weakness. Using this function causes the ticket to be copied without regard for privacy considerations. a #GTlsClientConnection a #GTlsClientConnection Gets the list of distinguished names of the Certificate Authorities that the server will accept certificates from. This will be set during the TLS handshake if the server requests a certificate. Otherwise, it will be %NULL. Each item in the list is a #GByteArray which contains the complete subject DN of the certificate authority. the list of CA DNs. You should unref each element with g_byte_array_unref() and then the free the list with g_list_free(). the #GTlsClientConnection Gets @conn's expected server identity a #GSocketConnectable describing the expected server identity, or %NULL if the expected identity is not known. the #GTlsClientConnection SSL 3.0 is no longer supported. See g_tls_client_connection_set_use_ssl3() for details. SSL 3.0 is insecure. %FALSE the #GTlsClientConnection Gets @conn's validation flags the validation flags the #GTlsClientConnection Sets @conn's expected server identity, which is used both to tell servers on virtual hosts which certificate to present, and also to let @conn know what name to look for in the certificate when performing %G_TLS_CERTIFICATE_BAD_IDENTITY validation, if enabled. the #GTlsClientConnection a #GSocketConnectable describing the expected server identity Since GLib 2.42.1, SSL 3.0 is no longer supported. From GLib 2.42.1 through GLib 2.62, this function could be used to force use of TLS 1.0, the lowest-supported TLS protocol version at the time. In the past, this was needed to connect to broken TLS servers that exhibited protocol version intolerance. Such servers are no longer common, and using TLS 1.0 is no longer considered acceptable. Since GLib 2.64, this function does nothing. SSL 3.0 is insecure. the #GTlsClientConnection a #gboolean, ignored Sets @conn's validation flags, to override the default set of checks performed when validating a server certificate. By default, %G_TLS_CERTIFICATE_VALIDATE_ALL is used. the #GTlsClientConnection the #GTlsCertificateFlags to use A list of the distinguished names of the Certificate Authorities that the server will accept client certificates signed by. If the server requests a client certificate during the handshake, then this property will be set after the handshake completes. Each item in the list is a #GByteArray which contains the complete subject DN of the certificate authority. A #GSocketConnectable describing the identity of the server that is expected on the other end of the connection. If the %G_TLS_CERTIFICATE_BAD_IDENTITY flag is set in #GTlsClientConnection:validation-flags, this object will be used to determine the expected identify of the remote end of the connection; if #GTlsClientConnection:server-identity is not set, or does not match the identity presented by the server, then the %G_TLS_CERTIFICATE_BAD_IDENTITY validation will fail. In addition to its use in verifying the server certificate, this is also used to give a hint to the server about what certificate we expect, which is useful for servers that serve virtual hosts. SSL 3.0 is no longer supported. See g_tls_client_connection_set_use_ssl3() for details. SSL 3.0 is insecure. What steps to perform when validating a certificate received from a server. Server certificates that fail to validate in any of the ways indicated here will be rejected unless the application overrides the default via #GTlsConnection::accept-certificate. vtable for a #GTlsClientConnection implementation. The parent interface. a #GTlsClientConnection a #GTlsClientConnection #GTlsConnection is the base TLS connection class type, which wraps a #GIOStream and provides TLS encryption on top of it. Its subclasses, #GTlsClientConnection and #GTlsServerConnection, implement client-side and server-side TLS, respectively. For DTLS (Datagram TLS) support, see #GDtlsConnection. Attempts a TLS handshake on @conn. On the client side, it is never necessary to call this method; although the connection needs to perform a handshake after connecting (or after sending a "STARTTLS"-type command), #GTlsConnection will handle this for you automatically when you try to send or receive data on the connection. You can call g_tls_connection_handshake() manually if you want to know whether the initial handshake succeeded or failed (as opposed to just immediately trying to use @conn to read or write, in which case, if it fails, it may not be possible to tell if it failed before or after completing the handshake), but beware that servers may reject client authentication after the handshake has completed, so a successful handshake does not indicate the connection will be usable. Likewise, on the server side, although a handshake is necessary at the beginning of the communication, you do not need to call this function explicitly unless you want clearer error reporting. Previously, calling g_tls_connection_handshake() after the initial handshake would trigger a rehandshake; however, this usage was deprecated in GLib 2.60 because rehandshaking was removed from the TLS protocol in TLS 1.3. Since GLib 2.64, calling this function after the initial handshake will no longer do anything. When using a #GTlsConnection created by #GSocketClient, the #GSocketClient performs the initial handshake, so calling this function manually is not recommended. #GTlsConnection::accept_certificate may be emitted during the handshake. success or failure a #GTlsConnection a #GCancellable, or %NULL Asynchronously performs a TLS handshake on @conn. See g_tls_connection_handshake() for more information. a #GTlsConnection the [I/O priority][io-priority] of the request a #GCancellable, or %NULL callback to call when the handshake is complete the data to pass to the callback function Finish an asynchronous TLS handshake operation. See g_tls_connection_handshake() for more information. %TRUE on success, %FALSE on failure, in which case @error will be set. a #GTlsConnection a #GAsyncResult. Used by #GTlsConnection implementations to emit the #GTlsConnection::accept-certificate signal. %TRUE if one of the signal handlers has returned %TRUE to accept @peer_cert a #GTlsConnection the peer's #GTlsCertificate the problems with @peer_cert Gets @conn's certificate, as set by g_tls_connection_set_certificate(). @conn's certificate, or %NULL a #GTlsConnection Query the TLS backend for TLS channel binding data of @type for @conn. This call retrieves TLS channel binding data as specified in RFC [5056](https://tools.ietf.org/html/rfc5056), RFC [5929](https://tools.ietf.org/html/rfc5929), and related RFCs. The binding data is returned in @data. The @data is resized by the callee using #GByteArray buffer management and will be freed when the @data is destroyed by g_byte_array_unref(). If @data is %NULL, it will only check whether TLS backend is able to fetch the data (e.g. whether @type is supported by the TLS backend). It does not guarantee that the data will be available though. That could happen if TLS connection does not support @type or the binding data is not available yet due to additional negotiation or input required. %TRUE on success, %FALSE otherwise a #GTlsConnection #GTlsChannelBindingType type of data to fetch #GByteArray is filled with the binding data, or %NULL Gets the certificate database that @conn uses to verify peer certificates. See g_tls_connection_set_database(). the certificate database that @conn uses or %NULL a #GTlsConnection Get the object that will be used to interact with the user. It will be used for things like prompting the user for passwords. If %NULL is returned, then no user interaction will occur for this connection. The interaction object. a connection Gets the name of the application-layer protocol negotiated during the handshake. If the peer did not use the ALPN extension, or did not advertise a protocol that matched one of @conn's protocols, or the TLS backend does not support ALPN, then this will be %NULL. See g_tls_connection_set_advertised_protocols(). the negotiated protocol, or %NULL a #GTlsConnection Gets @conn's peer's certificate after the handshake has completed or failed. (It is not set during the emission of #GTlsConnection::accept-certificate.) @conn's peer's certificate, or %NULL a #GTlsConnection Gets the errors associated with validating @conn's peer's certificate, after the handshake has completed or failed. (It is not set during the emission of #GTlsConnection::accept-certificate.) @conn's peer's certificate errors a #GTlsConnection Gets @conn rehandshaking mode. See g_tls_connection_set_rehandshake_mode() for details. Changing the rehandshake mode is no longer required for compatibility. Also, rehandshaking has been removed from the TLS protocol in TLS 1.3. %G_TLS_REHANDSHAKE_SAFELY a #GTlsConnection Tests whether or not @conn expects a proper TLS close notification when the connection is closed. See g_tls_connection_set_require_close_notify() for details. %TRUE if @conn requires a proper TLS close notification. a #GTlsConnection Gets whether @conn uses the system certificate database to verify peer certificates. See g_tls_connection_set_use_system_certdb(). Use g_tls_connection_get_database() instead whether @conn uses the system certificate database a #GTlsConnection Attempts a TLS handshake on @conn. On the client side, it is never necessary to call this method; although the connection needs to perform a handshake after connecting (or after sending a "STARTTLS"-type command), #GTlsConnection will handle this for you automatically when you try to send or receive data on the connection. You can call g_tls_connection_handshake() manually if you want to know whether the initial handshake succeeded or failed (as opposed to just immediately trying to use @conn to read or write, in which case, if it fails, it may not be possible to tell if it failed before or after completing the handshake), but beware that servers may reject client authentication after the handshake has completed, so a successful handshake does not indicate the connection will be usable. Likewise, on the server side, although a handshake is necessary at the beginning of the communication, you do not need to call this function explicitly unless you want clearer error reporting. Previously, calling g_tls_connection_handshake() after the initial handshake would trigger a rehandshake; however, this usage was deprecated in GLib 2.60 because rehandshaking was removed from the TLS protocol in TLS 1.3. Since GLib 2.64, calling this function after the initial handshake will no longer do anything. When using a #GTlsConnection created by #GSocketClient, the #GSocketClient performs the initial handshake, so calling this function manually is not recommended. #GTlsConnection::accept_certificate may be emitted during the handshake. success or failure a #GTlsConnection a #GCancellable, or %NULL Asynchronously performs a TLS handshake on @conn. See g_tls_connection_handshake() for more information. a #GTlsConnection the [I/O priority][io-priority] of the request a #GCancellable, or %NULL callback to call when the handshake is complete the data to pass to the callback function Finish an asynchronous TLS handshake operation. See g_tls_connection_handshake() for more information. %TRUE on success, %FALSE on failure, in which case @error will be set. a #GTlsConnection a #GAsyncResult. Sets the list of application-layer protocols to advertise that the caller is willing to speak on this connection. The Application-Layer Protocol Negotiation (ALPN) extension will be used to negotiate a compatible protocol with the peer; use g_tls_connection_get_negotiated_protocol() to find the negotiated protocol after the handshake. Specifying %NULL for the the value of @protocols will disable ALPN negotiation. See [IANA TLS ALPN Protocol IDs](https://www.iana.org/assignments/tls-extensiontype-values/tls-extensiontype-values.xhtml#alpn-protocol-ids) for a list of registered protocol IDs. a #GTlsConnection a %NULL-terminated array of ALPN protocol names (eg, "http/1.1", "h2"), or %NULL This sets the certificate that @conn will present to its peer during the TLS handshake. For a #GTlsServerConnection, it is mandatory to set this, and that will normally be done at construct time. For a #GTlsClientConnection, this is optional. If a handshake fails with %G_TLS_ERROR_CERTIFICATE_REQUIRED, that means that the server requires a certificate, and if you try connecting again, you should call this method first. You can call g_tls_client_connection_get_accepted_cas() on the failed connection to get a list of Certificate Authorities that the server will accept certificates from. (It is also possible that a server will allow the connection with or without a certificate; in that case, if you don't provide a certificate, you can tell that the server requested one by the fact that g_tls_client_connection_get_accepted_cas() will return non-%NULL.) a #GTlsConnection the certificate to use for @conn Sets the certificate database that is used to verify peer certificates. This is set to the default database by default. See g_tls_backend_get_default_database(). If set to %NULL, then peer certificate validation will always set the %G_TLS_CERTIFICATE_UNKNOWN_CA error (meaning #GTlsConnection::accept-certificate will always be emitted on client-side connections, unless that bit is not set in #GTlsClientConnection:validation-flags). a #GTlsConnection a #GTlsDatabase Set the object that will be used to interact with the user. It will be used for things like prompting the user for passwords. The @interaction argument will normally be a derived subclass of #GTlsInteraction. %NULL can also be provided if no user interaction should occur for this connection. a connection an interaction object, or %NULL Since GLib 2.64, changing the rehandshake mode is no longer supported and will have no effect. With TLS 1.3, rehandshaking has been removed from the TLS protocol, replaced by separate post-handshake authentication and rekey operations. Changing the rehandshake mode is no longer required for compatibility. Also, rehandshaking has been removed from the TLS protocol in TLS 1.3. a #GTlsConnection the rehandshaking mode Sets whether or not @conn expects a proper TLS close notification before the connection is closed. If this is %TRUE (the default), then @conn will expect to receive a TLS close notification from its peer before the connection is closed, and will return a %G_TLS_ERROR_EOF error if the connection is closed without proper notification (since this may indicate a network error, or man-in-the-middle attack). In some protocols, the application will know whether or not the connection was closed cleanly based on application-level data (because the application-level data includes a length field, or is somehow self-delimiting); in this case, the close notify is redundant and sometimes omitted. (TLS 1.1 explicitly allows this; in TLS 1.0 it is technically an error, but often done anyway.) You can use g_tls_connection_set_require_close_notify() to tell @conn to allow an "unannounced" connection close, in which case the close will show up as a 0-length read, as in a non-TLS #GSocketConnection, and it is up to the application to check that the data has been fully received. Note that this only affects the behavior when the peer closes the connection; when the application calls g_io_stream_close() itself on @conn, this will send a close notification regardless of the setting of this property. If you explicitly want to do an unclean close, you can close @conn's #GTlsConnection:base-io-stream rather than closing @conn itself, but note that this may only be done when no other operations are pending on @conn or the base I/O stream. a #GTlsConnection whether or not to require close notification Sets whether @conn uses the system certificate database to verify peer certificates. This is %TRUE by default. If set to %FALSE, then peer certificate validation will always set the %G_TLS_CERTIFICATE_UNKNOWN_CA error (meaning #GTlsConnection::accept-certificate will always be emitted on client-side connections, unless that bit is not set in #GTlsClientConnection:validation-flags). Use g_tls_connection_set_database() instead a #GTlsConnection whether to use the system certificate database The list of application-layer protocols that the connection advertises that it is willing to speak. See g_tls_connection_set_advertised_protocols(). The #GIOStream that the connection wraps. The connection holds a reference to this stream, and may run operations on the stream from other threads throughout its lifetime. Consequently, after the #GIOStream has been constructed, application code may only run its own operations on this stream when no #GIOStream operations are running. The connection's certificate; see g_tls_connection_set_certificate(). The certificate database to use when verifying this TLS connection. If no certificate database is set, then the default database will be used. See g_tls_backend_get_default_database(). A #GTlsInteraction object to be used when the connection or certificate database need to interact with the user. This will be used to prompt the user for passwords where necessary. The application-layer protocol negotiated during the TLS handshake. See g_tls_connection_get_negotiated_protocol(). The connection's peer's certificate, after the TLS handshake has completed or failed. Note in particular that this is not yet set during the emission of #GTlsConnection::accept-certificate. (You can watch for a #GObject::notify signal on this property to detect when a handshake has occurred.) The errors noticed while verifying #GTlsConnection:peer-certificate. Normally this should be 0, but it may not be if #GTlsClientConnection:validation-flags is not %G_TLS_CERTIFICATE_VALIDATE_ALL, or if #GTlsConnection::accept-certificate overrode the default behavior. The rehandshaking mode. See g_tls_connection_set_rehandshake_mode(). The rehandshake mode is ignored. Whether or not proper TLS close notification is required. See g_tls_connection_set_require_close_notify(). Whether or not the system certificate database will be used to verify peer certificates. See g_tls_connection_set_use_system_certdb(). Use GTlsConnection:database instead Emitted during the TLS handshake after the peer certificate has been received. You can examine @peer_cert's certification path by calling g_tls_certificate_get_issuer() on it. For a client-side connection, @peer_cert is the server's certificate, and the signal will only be emitted if the certificate was not acceptable according to @conn's #GTlsClientConnection:validation_flags. If you would like the certificate to be accepted despite @errors, return %TRUE from the signal handler. Otherwise, if no handler accepts the certificate, the handshake will fail with %G_TLS_ERROR_BAD_CERTIFICATE. For a server-side connection, @peer_cert is the certificate presented by the client, if this was requested via the server's #GTlsServerConnection:authentication_mode. On the server side, the signal is always emitted when the client presents a certificate, and the certificate will only be accepted if a handler returns %TRUE. Note that if this signal is emitted as part of asynchronous I/O in the main thread, then you should not attempt to interact with the user before returning from the signal handler. If you want to let the user decide whether or not to accept the certificate, you would have to return %FALSE from the signal handler on the first attempt, and then after the connection attempt returns a %G_TLS_ERROR_BAD_CERTIFICATE, you can interact with the user, and if the user decides to accept the certificate, remember that fact, create a new connection, and return %TRUE from the signal handler the next time. If you are doing I/O in another thread, you do not need to worry about this, and can simply block in the signal handler until the UI thread returns an answer. %TRUE to accept @peer_cert (which will also immediately end the signal emission). %FALSE to allow the signal emission to continue, which will cause the handshake to fail if no one else overrides it. the peer's #GTlsCertificate the problems with @peer_cert. success or failure a #GTlsConnection a #GCancellable, or %NULL a #GTlsConnection the [I/O priority][io-priority] of the request a #GCancellable, or %NULL callback to call when the handshake is complete the data to pass to the callback function %TRUE on success, %FALSE on failure, in which case @error will be set. a #GTlsConnection a #GAsyncResult. #GTlsDatabase is used to look up certificates and other information from a certificate or key store. It is an abstract base class which TLS library specific subtypes override. A #GTlsDatabase may be accessed from multiple threads by the TLS backend. All implementations are required to be fully thread-safe. Most common client applications will not directly interact with #GTlsDatabase. It is used internally by #GTlsConnection. Create a handle string for the certificate. The database will only be able to create a handle for certificates that originate from the database. In cases where the database cannot create a handle for a certificate, %NULL will be returned. This handle should be stable across various instances of the application, and between applications. If a certificate is modified in the database, then it is not guaranteed that this handle will continue to point to it. a newly allocated string containing the handle. a #GTlsDatabase certificate for which to create a handle. Look up a certificate by its handle. The handle should have been created by calling g_tls_database_create_certificate_handle() on a #GTlsDatabase object of the same TLS backend. The handle is designed to remain valid across instantiations of the database. If the handle is no longer valid, or does not point to a certificate in this database, then %NULL will be returned. This function can block, use g_tls_database_lookup_certificate_for_handle_async() to perform the lookup operation asynchronously. a newly allocated #GTlsCertificate, or %NULL. Use g_object_unref() to release the certificate. a #GTlsDatabase a certificate handle used to interact with the user if necessary Flags which affect the lookup. a #GCancellable, or %NULL Asynchronously look up a certificate by its handle in the database. See g_tls_database_lookup_certificate_for_handle() for more information. a #GTlsDatabase a certificate handle used to interact with the user if necessary Flags which affect the lookup. a #GCancellable, or %NULL callback to call when the operation completes the data to pass to the callback function Finish an asynchronous lookup of a certificate by its handle. See g_tls_database_lookup_certificate_for_handle() for more information. If the handle is no longer valid, or does not point to a certificate in this database, then %NULL will be returned. a newly allocated #GTlsCertificate object. Use g_object_unref() to release the certificate. a #GTlsDatabase a #GAsyncResult. Look up the issuer of @certificate in the database. The #GTlsCertificate:issuer property of @certificate is not modified, and the two certificates are not hooked into a chain. This function can block, use g_tls_database_lookup_certificate_issuer_async() to perform the lookup operation asynchronously. a newly allocated issuer #GTlsCertificate, or %NULL. Use g_object_unref() to release the certificate. a #GTlsDatabase a #GTlsCertificate used to interact with the user if necessary flags which affect the lookup operation a #GCancellable, or %NULL Asynchronously look up the issuer of @certificate in the database. See g_tls_database_lookup_certificate_issuer() for more information. a #GTlsDatabase a #GTlsCertificate used to interact with the user if necessary flags which affect the lookup operation a #GCancellable, or %NULL callback to call when the operation completes the data to pass to the callback function Finish an asynchronous lookup issuer operation. See g_tls_database_lookup_certificate_issuer() for more information. a newly allocated issuer #GTlsCertificate, or %NULL. Use g_object_unref() to release the certificate. a #GTlsDatabase a #GAsyncResult. Look up certificates issued by this issuer in the database. This function can block, use g_tls_database_lookup_certificates_issued_by_async() to perform the lookup operation asynchronously. a newly allocated list of #GTlsCertificate objects. Use g_object_unref() on each certificate, and g_list_free() on the release the list. a #GTlsDatabase a #GByteArray which holds the DER encoded issuer DN. used to interact with the user if necessary Flags which affect the lookup operation. a #GCancellable, or %NULL Asynchronously look up certificates issued by this issuer in the database. See g_tls_database_lookup_certificates_issued_by() for more information. The database may choose to hold a reference to the issuer byte array for the duration of of this asynchronous operation. The byte array should not be modified during this time. a #GTlsDatabase a #GByteArray which holds the DER encoded issuer DN. used to interact with the user if necessary Flags which affect the lookup operation. a #GCancellable, or %NULL callback to call when the operation completes the data to pass to the callback function Finish an asynchronous lookup of certificates. See g_tls_database_lookup_certificates_issued_by() for more information. a newly allocated list of #GTlsCertificate objects. Use g_object_unref() on each certificate, and g_list_free() on the release the list. a #GTlsDatabase a #GAsyncResult. Determines the validity of a certificate chain after looking up and adding any missing certificates to the chain. @chain is a chain of #GTlsCertificate objects each pointing to the next certificate in the chain by its #GTlsCertificate:issuer property. The chain may initially consist of one or more certificates. After the verification process is complete, @chain may be modified by adding missing certificates, or removing extra certificates. If a certificate anchor was found, then it is added to the @chain. @purpose describes the purpose (or usage) for which the certificate is being used. Typically @purpose will be set to #G_TLS_DATABASE_PURPOSE_AUTHENTICATE_SERVER which means that the certificate is being used to authenticate a server (and we are acting as the client). The @identity is used to ensure the server certificate is valid for the expected peer identity. If the identity does not match the certificate, %G_TLS_CERTIFICATE_BAD_IDENTITY will be set in the return value. If @identity is %NULL, that bit will never be set in the return value. The peer identity may also be used to check for pinned certificates (trust exceptions) in the database. These may override the normal verification process on a host-by-host basis. Currently there are no @flags, and %G_TLS_DATABASE_VERIFY_NONE should be used. If @chain is found to be valid, then the return value will be 0. If @chain is found to be invalid, then the return value will indicate the problems found. If the function is unable to determine whether @chain is valid or not (eg, because @cancellable is triggered before it completes) then the return value will be %G_TLS_CERTIFICATE_GENERIC_ERROR and @error will be set accordingly. @error is not set when @chain is successfully analyzed but found to be invalid. This function can block, use g_tls_database_verify_chain_async() to perform the verification operation asynchronously. the appropriate #GTlsCertificateFlags which represents the result of verification. a #GTlsDatabase a #GTlsCertificate chain the purpose that this certificate chain will be used for. the expected peer identity used to interact with the user if necessary additional verify flags a #GCancellable, or %NULL Asynchronously determines the validity of a certificate chain after looking up and adding any missing certificates to the chain. See g_tls_database_verify_chain() for more information. a #GTlsDatabase a #GTlsCertificate chain the purpose that this certificate chain will be used for. the expected peer identity used to interact with the user if necessary additional verify flags a #GCancellable, or %NULL callback to call when the operation completes the data to pass to the callback function Finish an asynchronous verify chain operation. See g_tls_database_verify_chain() for more information. If @chain is found to be valid, then the return value will be 0. If @chain is found to be invalid, then the return value will indicate the problems found. If the function is unable to determine whether @chain is valid or not (eg, because @cancellable is triggered before it completes) then the return value will be %G_TLS_CERTIFICATE_GENERIC_ERROR and @error will be set accordingly. @error is not set when @chain is successfully analyzed but found to be invalid. the appropriate #GTlsCertificateFlags which represents the result of verification. a #GTlsDatabase a #GAsyncResult. Create a handle string for the certificate. The database will only be able to create a handle for certificates that originate from the database. In cases where the database cannot create a handle for a certificate, %NULL will be returned. This handle should be stable across various instances of the application, and between applications. If a certificate is modified in the database, then it is not guaranteed that this handle will continue to point to it. a newly allocated string containing the handle. a #GTlsDatabase certificate for which to create a handle. Look up a certificate by its handle. The handle should have been created by calling g_tls_database_create_certificate_handle() on a #GTlsDatabase object of the same TLS backend. The handle is designed to remain valid across instantiations of the database. If the handle is no longer valid, or does not point to a certificate in this database, then %NULL will be returned. This function can block, use g_tls_database_lookup_certificate_for_handle_async() to perform the lookup operation asynchronously. a newly allocated #GTlsCertificate, or %NULL. Use g_object_unref() to release the certificate. a #GTlsDatabase a certificate handle used to interact with the user if necessary Flags which affect the lookup. a #GCancellable, or %NULL Asynchronously look up a certificate by its handle in the database. See g_tls_database_lookup_certificate_for_handle() for more information. a #GTlsDatabase a certificate handle used to interact with the user if necessary Flags which affect the lookup. a #GCancellable, or %NULL callback to call when the operation completes the data to pass to the callback function Finish an asynchronous lookup of a certificate by its handle. See g_tls_database_lookup_certificate_for_handle() for more information. If the handle is no longer valid, or does not point to a certificate in this database, then %NULL will be returned. a newly allocated #GTlsCertificate object. Use g_object_unref() to release the certificate. a #GTlsDatabase a #GAsyncResult. Look up the issuer of @certificate in the database. The #GTlsCertificate:issuer property of @certificate is not modified, and the two certificates are not hooked into a chain. This function can block, use g_tls_database_lookup_certificate_issuer_async() to perform the lookup operation asynchronously. a newly allocated issuer #GTlsCertificate, or %NULL. Use g_object_unref() to release the certificate. a #GTlsDatabase a #GTlsCertificate used to interact with the user if necessary flags which affect the lookup operation a #GCancellable, or %NULL Asynchronously look up the issuer of @certificate in the database. See g_tls_database_lookup_certificate_issuer() for more information. a #GTlsDatabase a #GTlsCertificate used to interact with the user if necessary flags which affect the lookup operation a #GCancellable, or %NULL callback to call when the operation completes the data to pass to the callback function Finish an asynchronous lookup issuer operation. See g_tls_database_lookup_certificate_issuer() for more information. a newly allocated issuer #GTlsCertificate, or %NULL. Use g_object_unref() to release the certificate. a #GTlsDatabase a #GAsyncResult. Look up certificates issued by this issuer in the database. This function can block, use g_tls_database_lookup_certificates_issued_by_async() to perform the lookup operation asynchronously. a newly allocated list of #GTlsCertificate objects. Use g_object_unref() on each certificate, and g_list_free() on the release the list. a #GTlsDatabase a #GByteArray which holds the DER encoded issuer DN. used to interact with the user if necessary Flags which affect the lookup operation. a #GCancellable, or %NULL Asynchronously look up certificates issued by this issuer in the database. See g_tls_database_lookup_certificates_issued_by() for more information. The database may choose to hold a reference to the issuer byte array for the duration of of this asynchronous operation. The byte array should not be modified during this time. a #GTlsDatabase a #GByteArray which holds the DER encoded issuer DN. used to interact with the user if necessary Flags which affect the lookup operation. a #GCancellable, or %NULL callback to call when the operation completes the data to pass to the callback function Finish an asynchronous lookup of certificates. See g_tls_database_lookup_certificates_issued_by() for more information. a newly allocated list of #GTlsCertificate objects. Use g_object_unref() on each certificate, and g_list_free() on the release the list. a #GTlsDatabase a #GAsyncResult. Determines the validity of a certificate chain after looking up and adding any missing certificates to the chain. @chain is a chain of #GTlsCertificate objects each pointing to the next certificate in the chain by its #GTlsCertificate:issuer property. The chain may initially consist of one or more certificates. After the verification process is complete, @chain may be modified by adding missing certificates, or removing extra certificates. If a certificate anchor was found, then it is added to the @chain. @purpose describes the purpose (or usage) for which the certificate is being used. Typically @purpose will be set to #G_TLS_DATABASE_PURPOSE_AUTHENTICATE_SERVER which means that the certificate is being used to authenticate a server (and we are acting as the client). The @identity is used to ensure the server certificate is valid for the expected peer identity. If the identity does not match the certificate, %G_TLS_CERTIFICATE_BAD_IDENTITY will be set in the return value. If @identity is %NULL, that bit will never be set in the return value. The peer identity may also be used to check for pinned certificates (trust exceptions) in the database. These may override the normal verification process on a host-by-host basis. Currently there are no @flags, and %G_TLS_DATABASE_VERIFY_NONE should be used. If @chain is found to be valid, then the return value will be 0. If @chain is found to be invalid, then the return value will indicate the problems found. If the function is unable to determine whether @chain is valid or not (eg, because @cancellable is triggered before it completes) then the return value will be %G_TLS_CERTIFICATE_GENERIC_ERROR and @error will be set accordingly. @error is not set when @chain is successfully analyzed but found to be invalid. This function can block, use g_tls_database_verify_chain_async() to perform the verification operation asynchronously. the appropriate #GTlsCertificateFlags which represents the result of verification. a #GTlsDatabase a #GTlsCertificate chain the purpose that this certificate chain will be used for. the expected peer identity used to interact with the user if necessary additional verify flags a #GCancellable, or %NULL Asynchronously determines the validity of a certificate chain after looking up and adding any missing certificates to the chain. See g_tls_database_verify_chain() for more information. a #GTlsDatabase a #GTlsCertificate chain the purpose that this certificate chain will be used for. the expected peer identity used to interact with the user if necessary additional verify flags a #GCancellable, or %NULL callback to call when the operation completes the data to pass to the callback function Finish an asynchronous verify chain operation. See g_tls_database_verify_chain() for more information. If @chain is found to be valid, then the return value will be 0. If @chain is found to be invalid, then the return value will indicate the problems found. If the function is unable to determine whether @chain is valid or not (eg, because @cancellable is triggered before it completes) then the return value will be %G_TLS_CERTIFICATE_GENERIC_ERROR and @error will be set accordingly. @error is not set when @chain is successfully analyzed but found to be invalid. the appropriate #GTlsCertificateFlags which represents the result of verification. a #GTlsDatabase a #GAsyncResult. The class for #GTlsDatabase. Derived classes should implement the various virtual methods. _async and _finish methods have a default implementation that runs the corresponding sync method in a thread. the appropriate #GTlsCertificateFlags which represents the result of verification. a #GTlsDatabase a #GTlsCertificate chain the purpose that this certificate chain will be used for. the expected peer identity used to interact with the user if necessary additional verify flags a #GCancellable, or %NULL a #GTlsDatabase a #GTlsCertificate chain the purpose that this certificate chain will be used for. the expected peer identity used to interact with the user if necessary additional verify flags a #GCancellable, or %NULL callback to call when the operation completes the data to pass to the callback function the appropriate #GTlsCertificateFlags which represents the result of verification. a #GTlsDatabase a #GAsyncResult. a newly allocated string containing the handle. a #GTlsDatabase certificate for which to create a handle. a newly allocated #GTlsCertificate, or %NULL. Use g_object_unref() to release the certificate. a #GTlsDatabase a certificate handle used to interact with the user if necessary Flags which affect the lookup. a #GCancellable, or %NULL a #GTlsDatabase a certificate handle used to interact with the user if necessary Flags which affect the lookup. a #GCancellable, or %NULL callback to call when the operation completes the data to pass to the callback function a newly allocated #GTlsCertificate object. Use g_object_unref() to release the certificate. a #GTlsDatabase a #GAsyncResult. a newly allocated issuer #GTlsCertificate, or %NULL. Use g_object_unref() to release the certificate. a #GTlsDatabase a #GTlsCertificate used to interact with the user if necessary flags which affect the lookup operation a #GCancellable, or %NULL a #GTlsDatabase a #GTlsCertificate used to interact with the user if necessary flags which affect the lookup operation a #GCancellable, or %NULL callback to call when the operation completes the data to pass to the callback function a newly allocated issuer #GTlsCertificate, or %NULL. Use g_object_unref() to release the certificate. a #GTlsDatabase a #GAsyncResult. a newly allocated list of #GTlsCertificate objects. Use g_object_unref() on each certificate, and g_list_free() on the release the list. a #GTlsDatabase a #GByteArray which holds the DER encoded issuer DN. used to interact with the user if necessary Flags which affect the lookup operation. a #GCancellable, or %NULL a #GTlsDatabase a #GByteArray which holds the DER encoded issuer DN. used to interact with the user if necessary Flags which affect the lookup operation. a #GCancellable, or %NULL callback to call when the operation completes the data to pass to the callback function a newly allocated list of #GTlsCertificate objects. Use g_object_unref() on each certificate, and g_list_free() on the release the list. a #GTlsDatabase a #GAsyncResult. Flags for g_tls_database_lookup_certificate_for_handle(), g_tls_database_lookup_certificate_issuer(), and g_tls_database_lookup_certificates_issued_by(). No lookup flags Restrict lookup to certificates that have a private key. Flags for g_tls_database_verify_chain(). No verification flags An error code used with %G_TLS_ERROR in a #GError returned from a TLS-related routine. No TLS provider is available Miscellaneous TLS error The certificate presented could not be parsed or failed validation. The TLS handshake failed because the peer does not seem to be a TLS server. The TLS handshake failed because the peer's certificate was not acceptable. The TLS handshake failed because the server requested a client-side certificate, but none was provided. See g_tls_connection_set_certificate(). The TLS connection was closed without proper notice, which may indicate an attack. See g_tls_connection_set_require_close_notify(). The TLS handshake failed because the client sent the fallback SCSV, indicating a protocol downgrade attack. Since: 2.60 Gets the TLS error quark. a #GQuark. #GTlsFileDatabase is implemented by #GTlsDatabase objects which load their certificate information from a file. It is an interface which TLS library specific subtypes implement. Creates a new #GTlsFileDatabase which uses anchor certificate authorities in @anchors to verify certificate chains. The certificates in @anchors must be PEM encoded. the new #GTlsFileDatabase, or %NULL on error filename of anchor certificate authorities. The path to a file containing PEM encoded certificate authority root anchors. The certificates in this file will be treated as root authorities for the purpose of verifying other certificates via the g_tls_database_verify_chain() operation. Provides an interface for #GTlsFileDatabase implementations. The parent interface. #GTlsInteraction provides a mechanism for the TLS connection and database code to interact with the user. It can be used to ask the user for passwords. To use a #GTlsInteraction with a TLS connection use g_tls_connection_set_interaction(). Callers should instantiate a derived class that implements the various interaction methods to show the required dialogs. Callers should use the 'invoke' functions like g_tls_interaction_invoke_ask_password() to run interaction methods. These functions make sure that the interaction is invoked in the main loop and not in the current thread, if the current thread is not running the main loop. Derived classes can choose to implement whichever interactions methods they'd like to support by overriding those virtual methods in their class initialization function. Any interactions not implemented will return %G_TLS_INTERACTION_UNHANDLED. If a derived class implements an async method, it must also implement the corresponding finish method. Run synchronous interaction to ask the user for a password. In general, g_tls_interaction_invoke_ask_password() should be used instead of this function. Derived subclasses usually implement a password prompt, although they may also choose to provide a password from elsewhere. The @password value will be filled in and then @callback will be called. Alternatively the user may abort this password request, which will usually abort the TLS connection. If the interaction is cancelled by the cancellation object, or by the user then %G_TLS_INTERACTION_FAILED will be returned with an error that contains a %G_IO_ERROR_CANCELLED error code. Certain implementations may not support immediate cancellation. The status of the ask password interaction. a #GTlsInteraction object a #GTlsPassword object an optional #GCancellable cancellation object Run asynchronous interaction to ask the user for a password. In general, g_tls_interaction_invoke_ask_password() should be used instead of this function. Derived subclasses usually implement a password prompt, although they may also choose to provide a password from elsewhere. The @password value will be filled in and then @callback will be called. Alternatively the user may abort this password request, which will usually abort the TLS connection. If the interaction is cancelled by the cancellation object, or by the user then %G_TLS_INTERACTION_FAILED will be returned with an error that contains a %G_IO_ERROR_CANCELLED error code. Certain implementations may not support immediate cancellation. Certain implementations may not support immediate cancellation. a #GTlsInteraction object a #GTlsPassword object an optional #GCancellable cancellation object will be called when the interaction completes data to pass to the @callback Complete an ask password user interaction request. This should be once the g_tls_interaction_ask_password_async() completion callback is called. If %G_TLS_INTERACTION_HANDLED is returned, then the #GTlsPassword passed to g_tls_interaction_ask_password() will have its password filled in. If the interaction is cancelled by the cancellation object, or by the user then %G_TLS_INTERACTION_FAILED will be returned with an error that contains a %G_IO_ERROR_CANCELLED error code. The status of the ask password interaction. a #GTlsInteraction object the result passed to the callback Run synchronous interaction to ask the user to choose a certificate to use with the connection. In general, g_tls_interaction_invoke_request_certificate() should be used instead of this function. Derived subclasses usually implement a certificate selector, although they may also choose to provide a certificate from elsewhere. Alternatively the user may abort this certificate request, which will usually abort the TLS connection. If %G_TLS_INTERACTION_HANDLED is returned, then the #GTlsConnection passed to g_tls_interaction_request_certificate() will have had its #GTlsConnection:certificate filled in. If the interaction is cancelled by the cancellation object, or by the user then %G_TLS_INTERACTION_FAILED will be returned with an error that contains a %G_IO_ERROR_CANCELLED error code. Certain implementations may not support immediate cancellation. The status of the request certificate interaction. a #GTlsInteraction object a #GTlsConnection object flags providing more information about the request an optional #GCancellable cancellation object Run asynchronous interaction to ask the user for a certificate to use with the connection. In general, g_tls_interaction_invoke_request_certificate() should be used instead of this function. Derived subclasses usually implement a certificate selector, although they may also choose to provide a certificate from elsewhere. @callback will be called when the operation completes. Alternatively the user may abort this certificate request, which will usually abort the TLS connection. a #GTlsInteraction object a #GTlsConnection object flags providing more information about the request an optional #GCancellable cancellation object will be called when the interaction completes data to pass to the @callback Complete a request certificate user interaction request. This should be once the g_tls_interaction_request_certificate_async() completion callback is called. If %G_TLS_INTERACTION_HANDLED is returned, then the #GTlsConnection passed to g_tls_interaction_request_certificate_async() will have had its #GTlsConnection:certificate filled in. If the interaction is cancelled by the cancellation object, or by the user then %G_TLS_INTERACTION_FAILED will be returned with an error that contains a %G_IO_ERROR_CANCELLED error code. The status of the request certificate interaction. a #GTlsInteraction object the result passed to the callback Run synchronous interaction to ask the user for a password. In general, g_tls_interaction_invoke_ask_password() should be used instead of this function. Derived subclasses usually implement a password prompt, although they may also choose to provide a password from elsewhere. The @password value will be filled in and then @callback will be called. Alternatively the user may abort this password request, which will usually abort the TLS connection. If the interaction is cancelled by the cancellation object, or by the user then %G_TLS_INTERACTION_FAILED will be returned with an error that contains a %G_IO_ERROR_CANCELLED error code. Certain implementations may not support immediate cancellation. The status of the ask password interaction. a #GTlsInteraction object a #GTlsPassword object an optional #GCancellable cancellation object Run asynchronous interaction to ask the user for a password. In general, g_tls_interaction_invoke_ask_password() should be used instead of this function. Derived subclasses usually implement a password prompt, although they may also choose to provide a password from elsewhere. The @password value will be filled in and then @callback will be called. Alternatively the user may abort this password request, which will usually abort the TLS connection. If the interaction is cancelled by the cancellation object, or by the user then %G_TLS_INTERACTION_FAILED will be returned with an error that contains a %G_IO_ERROR_CANCELLED error code. Certain implementations may not support immediate cancellation. Certain implementations may not support immediate cancellation. a #GTlsInteraction object a #GTlsPassword object an optional #GCancellable cancellation object will be called when the interaction completes data to pass to the @callback Complete an ask password user interaction request. This should be once the g_tls_interaction_ask_password_async() completion callback is called. If %G_TLS_INTERACTION_HANDLED is returned, then the #GTlsPassword passed to g_tls_interaction_ask_password() will have its password filled in. If the interaction is cancelled by the cancellation object, or by the user then %G_TLS_INTERACTION_FAILED will be returned with an error that contains a %G_IO_ERROR_CANCELLED error code. The status of the ask password interaction. a #GTlsInteraction object the result passed to the callback Invoke the interaction to ask the user for a password. It invokes this interaction in the main loop, specifically the #GMainContext returned by g_main_context_get_thread_default() when the interaction is created. This is called by called by #GTlsConnection or #GTlsDatabase to ask the user for a password. Derived subclasses usually implement a password prompt, although they may also choose to provide a password from elsewhere. The @password value will be filled in and then @callback will be called. Alternatively the user may abort this password request, which will usually abort the TLS connection. The implementation can either be a synchronous (eg: modal dialog) or an asynchronous one (eg: modeless dialog). This function will take care of calling which ever one correctly. If the interaction is cancelled by the cancellation object, or by the user then %G_TLS_INTERACTION_FAILED will be returned with an error that contains a %G_IO_ERROR_CANCELLED error code. Certain implementations may not support immediate cancellation. The status of the ask password interaction. a #GTlsInteraction object a #GTlsPassword object an optional #GCancellable cancellation object Invoke the interaction to ask the user to choose a certificate to use with the connection. It invokes this interaction in the main loop, specifically the #GMainContext returned by g_main_context_get_thread_default() when the interaction is created. This is called by called by #GTlsConnection when the peer requests a certificate during the handshake. Derived subclasses usually implement a certificate selector, although they may also choose to provide a certificate from elsewhere. Alternatively the user may abort this certificate request, which may or may not abort the TLS connection. The implementation can either be a synchronous (eg: modal dialog) or an asynchronous one (eg: modeless dialog). This function will take care of calling which ever one correctly. If the interaction is cancelled by the cancellation object, or by the user then %G_TLS_INTERACTION_FAILED will be returned with an error that contains a %G_IO_ERROR_CANCELLED error code. Certain implementations may not support immediate cancellation. The status of the certificate request interaction. a #GTlsInteraction object a #GTlsConnection object flags providing more information about the request an optional #GCancellable cancellation object Run synchronous interaction to ask the user to choose a certificate to use with the connection. In general, g_tls_interaction_invoke_request_certificate() should be used instead of this function. Derived subclasses usually implement a certificate selector, although they may also choose to provide a certificate from elsewhere. Alternatively the user may abort this certificate request, which will usually abort the TLS connection. If %G_TLS_INTERACTION_HANDLED is returned, then the #GTlsConnection passed to g_tls_interaction_request_certificate() will have had its #GTlsConnection:certificate filled in. If the interaction is cancelled by the cancellation object, or by the user then %G_TLS_INTERACTION_FAILED will be returned with an error that contains a %G_IO_ERROR_CANCELLED error code. Certain implementations may not support immediate cancellation. The status of the request certificate interaction. a #GTlsInteraction object a #GTlsConnection object flags providing more information about the request an optional #GCancellable cancellation object Run asynchronous interaction to ask the user for a certificate to use with the connection. In general, g_tls_interaction_invoke_request_certificate() should be used instead of this function. Derived subclasses usually implement a certificate selector, although they may also choose to provide a certificate from elsewhere. @callback will be called when the operation completes. Alternatively the user may abort this certificate request, which will usually abort the TLS connection. a #GTlsInteraction object a #GTlsConnection object flags providing more information about the request an optional #GCancellable cancellation object will be called when the interaction completes data to pass to the @callback Complete a request certificate user interaction request. This should be once the g_tls_interaction_request_certificate_async() completion callback is called. If %G_TLS_INTERACTION_HANDLED is returned, then the #GTlsConnection passed to g_tls_interaction_request_certificate_async() will have had its #GTlsConnection:certificate filled in. If the interaction is cancelled by the cancellation object, or by the user then %G_TLS_INTERACTION_FAILED will be returned with an error that contains a %G_IO_ERROR_CANCELLED error code. The status of the request certificate interaction. a #GTlsInteraction object the result passed to the callback The class for #GTlsInteraction. Derived classes implement the various virtual interaction methods to handle TLS interactions. Derived classes can choose to implement whichever interactions methods they'd like to support by overriding those virtual methods in their class initialization function. If a derived class implements an async method, it must also implement the corresponding finish method. The synchronous interaction methods should implement to display modal dialogs, and the asynchronous methods to display modeless dialogs. If the user cancels an interaction, then the result should be %G_TLS_INTERACTION_FAILED and the error should be set with a domain of %G_IO_ERROR and code of %G_IO_ERROR_CANCELLED. The status of the ask password interaction. a #GTlsInteraction object a #GTlsPassword object an optional #GCancellable cancellation object a #GTlsInteraction object a #GTlsPassword object an optional #GCancellable cancellation object will be called when the interaction completes data to pass to the @callback The status of the ask password interaction. a #GTlsInteraction object the result passed to the callback The status of the request certificate interaction. a #GTlsInteraction object a #GTlsConnection object flags providing more information about the request an optional #GCancellable cancellation object a #GTlsInteraction object a #GTlsConnection object flags providing more information about the request an optional #GCancellable cancellation object will be called when the interaction completes data to pass to the @callback The status of the request certificate interaction. a #GTlsInteraction object the result passed to the callback #GTlsInteractionResult is returned by various functions in #GTlsInteraction when finishing an interaction request. The interaction was unhandled (i.e. not implemented). The interaction completed, and resulting data is available. The interaction has failed, or was cancelled. and the operation should be aborted. Holds a password used in TLS. Create a new #GTlsPassword object. The newly allocated password object the password flags description of what the password is for Get the password value. If @length is not %NULL then it will be filled in with the length of the password value. (Note that the password value is not nul-terminated, so you can only pass %NULL for @length in contexts where you know the password will have a certain fixed length.) The password value (owned by the password object). a #GTlsPassword object location to place the length of the password. Provide the value for this password. The @value will be owned by the password object, and later freed using the @destroy function callback. Specify the @length, for a non-nul-terminated password. Pass -1 as @length if using a nul-terminated password, and @length will be calculated automatically. (Note that the terminating nul is not considered part of the password in this case.) a #GTlsPassword object the value for the password the length of the password, or -1 a function to use to free the password. Get a description string about what the password will be used for. The description of the password. a #GTlsPassword object Get flags about the password. The flags about the password. a #GTlsPassword object Get the password value. If @length is not %NULL then it will be filled in with the length of the password value. (Note that the password value is not nul-terminated, so you can only pass %NULL for @length in contexts where you know the password will have a certain fixed length.) The password value (owned by the password object). a #GTlsPassword object location to place the length of the password. Get a user readable translated warning. Usually this warning is a representation of the password flags returned from g_tls_password_get_flags(). The warning. a #GTlsPassword object Set a description string about what the password will be used for. a #GTlsPassword object The description of the password Set flags about the password. a #GTlsPassword object The flags about the password Set the value for this password. The @value will be copied by the password object. Specify the @length, for a non-nul-terminated password. Pass -1 as @length if using a nul-terminated password, and @length will be calculated automatically. (Note that the terminating nul is not considered part of the password in this case.) a #GTlsPassword object the new password value the length of the password, or -1 Provide the value for this password. The @value will be owned by the password object, and later freed using the @destroy function callback. Specify the @length, for a non-nul-terminated password. Pass -1 as @length if using a nul-terminated password, and @length will be calculated automatically. (Note that the terminating nul is not considered part of the password in this case.) a #GTlsPassword object the value for the password the length of the password, or -1 a function to use to free the password. Set a user readable translated warning. Usually this warning is a representation of the password flags returned from g_tls_password_get_flags(). a #GTlsPassword object The user readable warning Class structure for #GTlsPassword. The password value (owned by the password object). a #GTlsPassword object location to place the length of the password. a #GTlsPassword object the value for the password the length of the password, or -1 a function to use to free the password. Various flags for the password. No flags The password was wrong, and the user should retry. Hint to the user that the password has been wrong many times, and the user may not have many chances left. Hint to the user that this is the last try to get this password right. When to allow rehandshaking. See g_tls_connection_set_rehandshake_mode(). Changing the rehandshake mode is no longer required for compatibility. Also, rehandshaking has been removed from the TLS protocol in TLS 1.3. Never allow rehandshaking Allow safe rehandshaking only Allow unsafe rehandshaking #GTlsServerConnection is the server-side subclass of #GTlsConnection, representing a server-side TLS connection. Creates a new #GTlsServerConnection wrapping @base_io_stream (which must have pollable input and output streams). See the documentation for #GTlsConnection:base-io-stream for restrictions on when application code can run operations on the @base_io_stream after this function has returned. the new #GTlsServerConnection, or %NULL on error the #GIOStream to wrap the default server certificate, or %NULL The #GTlsAuthenticationMode for the server. This can be changed before calling g_tls_connection_handshake() if you want to rehandshake with a different mode from the initial handshake. vtable for a #GTlsServerConnection implementation. The parent interface. This is the subclass of #GSocketConnection that is created for UNIX domain sockets. It contains functions to do some of the UNIX socket specific functionality like passing file descriptors. Note that `<gio/gunixconnection.h>` belongs to the UNIX-specific GIO interfaces, thus you have to use the `gio-unix-2.0.pc` pkg-config file when using it. Receives credentials from the sending end of the connection. The sending end has to call g_unix_connection_send_credentials() (or similar) for this to work. As well as reading the credentials this also reads (and discards) a single byte from the stream, as this is required for credentials passing to work on some implementations. This method can be expected to be available on the following platforms: - Linux since GLib 2.26 - FreeBSD since GLib 2.26 - GNU/kFreeBSD since GLib 2.36 - Solaris, Illumos and OpenSolaris since GLib 2.40 - GNU/Hurd since GLib 2.40 Other ways to exchange credentials with a foreign peer includes the #GUnixCredentialsMessage type and g_socket_get_credentials() function. Received credentials on success (free with g_object_unref()), %NULL if @error is set. A #GUnixConnection. A #GCancellable or %NULL. Asynchronously receive credentials. For more details, see g_unix_connection_receive_credentials() which is the synchronous version of this call. When the operation is finished, @callback will be called. You can then call g_unix_connection_receive_credentials_finish() to get the result of the operation. A #GUnixConnection. optional #GCancellable object, %NULL to ignore. a #GAsyncReadyCallback to call when the request is satisfied the data to pass to callback function Finishes an asynchronous receive credentials operation started with g_unix_connection_receive_credentials_async(). a #GCredentials, or %NULL on error. Free the returned object with g_object_unref(). A #GUnixConnection. a #GAsyncResult. Receives a file descriptor from the sending end of the connection. The sending end has to call g_unix_connection_send_fd() for this to work. As well as reading the fd this also reads a single byte from the stream, as this is required for fd passing to work on some implementations. a file descriptor on success, -1 on error. a #GUnixConnection optional #GCancellable object, %NULL to ignore Passes the credentials of the current user the receiving side of the connection. The receiving end has to call g_unix_connection_receive_credentials() (or similar) to accept the credentials. As well as sending the credentials this also writes a single NUL byte to the stream, as this is required for credentials passing to work on some implementations. This method can be expected to be available on the following platforms: - Linux since GLib 2.26 - FreeBSD since GLib 2.26 - GNU/kFreeBSD since GLib 2.36 - Solaris, Illumos and OpenSolaris since GLib 2.40 - GNU/Hurd since GLib 2.40 Other ways to exchange credentials with a foreign peer includes the #GUnixCredentialsMessage type and g_socket_get_credentials() function. %TRUE on success, %FALSE if @error is set. A #GUnixConnection. A #GCancellable or %NULL. Asynchronously send credentials. For more details, see g_unix_connection_send_credentials() which is the synchronous version of this call. When the operation is finished, @callback will be called. You can then call g_unix_connection_send_credentials_finish() to get the result of the operation. A #GUnixConnection. optional #GCancellable object, %NULL to ignore. a #GAsyncReadyCallback to call when the request is satisfied the data to pass to callback function Finishes an asynchronous send credentials operation started with g_unix_connection_send_credentials_async(). %TRUE if the operation was successful, otherwise %FALSE. A #GUnixConnection. a #GAsyncResult. Passes a file descriptor to the receiving side of the connection. The receiving end has to call g_unix_connection_receive_fd() to accept the file descriptor. As well as sending the fd this also writes a single byte to the stream, as this is required for fd passing to work on some implementations. a %TRUE on success, %NULL on error. a #GUnixConnection a file descriptor optional #GCancellable object, %NULL to ignore. This #GSocketControlMessage contains a #GCredentials instance. It may be sent using g_socket_send_message() and received using g_socket_receive_message() over UNIX sockets (ie: sockets in the %G_SOCKET_FAMILY_UNIX family). For an easier way to send and receive credentials over stream-oriented UNIX sockets, see g_unix_connection_send_credentials() and g_unix_connection_receive_credentials(). To receive credentials of a foreign process connected to a socket, use g_socket_get_credentials(). Creates a new #GUnixCredentialsMessage with credentials matching the current processes. a new #GUnixCredentialsMessage Creates a new #GUnixCredentialsMessage holding @credentials. a new #GUnixCredentialsMessage A #GCredentials object. Checks if passing #GCredentials on a #GSocket is supported on this platform. %TRUE if supported, %FALSE otherwise Gets the credentials stored in @message. A #GCredentials instance. Do not free, it is owned by @message. A #GUnixCredentialsMessage. The credentials stored in the message. Class structure for #GUnixCredentialsMessage. A #GUnixFDList contains a list of file descriptors. It owns the file descriptors that it contains, closing them when finalized. It may be wrapped in a #GUnixFDMessage and sent over a #GSocket in the %G_SOCKET_FAMILY_UNIX family by using g_socket_send_message() and received using g_socket_receive_message(). Note that `<gio/gunixfdlist.h>` belongs to the UNIX-specific GIO interfaces, thus you have to use the `gio-unix-2.0.pc` pkg-config file when using it. Creates a new #GUnixFDList containing no file descriptors. a new #GUnixFDList Creates a new #GUnixFDList containing the file descriptors given in @fds. The file descriptors become the property of the new list and may no longer be used by the caller. The array itself is owned by the caller. Each file descriptor in the array should be set to close-on-exec. If @n_fds is -1 then @fds must be terminated with -1. a new #GUnixFDList the initial list of file descriptors the length of #fds, or -1 Adds a file descriptor to @list. The file descriptor is duplicated using dup(). You keep your copy of the descriptor and the copy contained in @list will be closed when @list is finalized. A possible cause of failure is exceeding the per-process or system-wide file descriptor limit. The index of the file descriptor in the list is returned. If you use this index with g_unix_fd_list_get() then you will receive back a duplicated copy of the same file descriptor. the index of the appended fd in case of success, else -1 (and @error is set) a #GUnixFDList a valid open file descriptor Gets a file descriptor out of @list. @index_ specifies the index of the file descriptor to get. It is a programmer error for @index_ to be out of range; see g_unix_fd_list_get_length(). The file descriptor is duplicated using dup() and set as close-on-exec before being returned. You must call close() on it when you are done. A possible cause of failure is exceeding the per-process or system-wide file descriptor limit. the file descriptor, or -1 in case of error a #GUnixFDList the index into the list Gets the length of @list (ie: the number of file descriptors contained within). the length of @list a #GUnixFDList Returns the array of file descriptors that is contained in this object. After this call, the descriptors remain the property of @list. The caller must not close them and must not free the array. The array is valid only until @list is changed in any way. If @length is non-%NULL then it is set to the number of file descriptors in the returned array. The returned array is also terminated with -1. This function never returns %NULL. In case there are no file descriptors contained in @list, an empty array is returned. an array of file descriptors a #GUnixFDList pointer to the length of the returned array, or %NULL Returns the array of file descriptors that is contained in this object. After this call, the descriptors are no longer contained in @list. Further calls will return an empty list (unless more descriptors have been added). The return result of this function must be freed with g_free(). The caller is also responsible for closing all of the file descriptors. The file descriptors in the array are set to close-on-exec. If @length is non-%NULL then it is set to the number of file descriptors in the returned array. The returned array is also terminated with -1. This function never returns %NULL. In case there are no file descriptors contained in @list, an empty array is returned. an array of file descriptors a #GUnixFDList pointer to the length of the returned array, or %NULL This #GSocketControlMessage contains a #GUnixFDList. It may be sent using g_socket_send_message() and received using g_socket_receive_message() over UNIX sockets (ie: sockets in the %G_SOCKET_FAMILY_UNIX family). The file descriptors are copied between processes by the kernel. For an easier way to send and receive file descriptors over stream-oriented UNIX sockets, see g_unix_connection_send_fd() and g_unix_connection_receive_fd(). Note that `<gio/gunixfdmessage.h>` belongs to the UNIX-specific GIO interfaces, thus you have to use the `gio-unix-2.0.pc` pkg-config file when using it. Creates a new #GUnixFDMessage containing an empty file descriptor list. a new #GUnixFDMessage Creates a new #GUnixFDMessage containing @list. a new #GUnixFDMessage a #GUnixFDList Adds a file descriptor to @message. The file descriptor is duplicated using dup(). You keep your copy of the descriptor and the copy contained in @message will be closed when @message is finalized. A possible cause of failure is exceeding the per-process or system-wide file descriptor limit. %TRUE in case of success, else %FALSE (and @error is set) a #GUnixFDMessage a valid open file descriptor Gets the #GUnixFDList contained in @message. This function does not return a reference to the caller, but the returned list is valid for the lifetime of @message. the #GUnixFDList from @message a #GUnixFDMessage Returns the array of file descriptors that is contained in this object. After this call, the descriptors are no longer contained in @message. Further calls will return an empty list (unless more descriptors have been added). The return result of this function must be freed with g_free(). The caller is also responsible for closing all of the file descriptors. If @length is non-%NULL then it is set to the number of file descriptors in the returned array. The returned array is also terminated with -1. This function never returns %NULL. In case there are no file descriptors contained in @message, an empty array is returned. an array of file descriptors a #GUnixFDMessage pointer to the length of the returned array, or %NULL #GUnixInputStream implements #GInputStream for reading from a UNIX file descriptor, including asynchronous operations. (If the file descriptor refers to a socket or pipe, this will use poll() to do asynchronous I/O. If it refers to a regular file, it will fall back to doing asynchronous I/O in another thread.) Note that `<gio/gunixinputstream.h>` belongs to the UNIX-specific GIO interfaces, thus you have to use the `gio-unix-2.0.pc` pkg-config file when using it. Creates a new #GUnixInputStream for the given @fd. If @close_fd is %TRUE, the file descriptor will be closed when the stream is closed. a new #GUnixInputStream a UNIX file descriptor %TRUE to close the file descriptor when done Returns whether the file descriptor of @stream will be closed when the stream is closed. %TRUE if the file descriptor is closed when done a #GUnixInputStream Return the UNIX file descriptor that the stream reads from. The file descriptor of @stream a #GUnixInputStream Sets whether the file descriptor of @stream shall be closed when the stream is closed. a #GUnixInputStream %TRUE to close the file descriptor when done Whether to close the file descriptor when the stream is closed. The file descriptor that the stream reads from. Defines a Unix mount entry (e.g. <filename>/media/cdrom</filename>). This corresponds roughly to a mtab entry. Watches #GUnixMounts for changes. Deprecated alias for g_unix_mount_monitor_get(). This function was never a true constructor, which is why it was renamed. Use g_unix_mount_monitor_get() instead. a #GUnixMountMonitor. Gets the #GUnixMountMonitor for the current thread-default main context. The mount monitor can be used to monitor for changes to the list of mounted filesystems as well as the list of mount points (ie: fstab entries). You must only call g_object_unref() on the return value from under the same main context as you called this function. the #GUnixMountMonitor. This function does nothing. Before 2.44, this was a partially-effective way of controlling the rate at which events would be reported under some uncommon circumstances. Since @mount_monitor is a singleton, it also meant that calling this function would have side effects for other users of the monitor. This function does nothing. Don't call it. a #GUnixMountMonitor a integer with the limit in milliseconds to poll for changes. Emitted when the unix mount points have changed. Emitted when the unix mounts have changed. Defines a Unix mount point (e.g. <filename>/dev</filename>). This corresponds roughly to a fstab entry. Compares two unix mount points. 1, 0 or -1 if @mount1 is greater than, equal to, or less than @mount2, respectively. a #GUnixMount. a #GUnixMount. Makes a copy of @mount_point. a new #GUnixMountPoint a #GUnixMountPoint. Frees a unix mount point. unix mount point to free. Gets the device path for a unix mount point. a string containing the device path. a #GUnixMountPoint. Gets the file system type for the mount point. a string containing the file system type. a #GUnixMountPoint. Gets the mount path for a unix mount point. a string containing the mount path. a #GUnixMountPoint. Gets the options for the mount point. a string containing the options. a #GUnixMountPoint. Guesses whether a Unix mount point can be ejected. %TRUE if @mount_point is deemed to be ejectable. a #GUnixMountPoint Guesses the icon of a Unix mount point. a #GIcon a #GUnixMountPoint Guesses the name of a Unix mount point. The result is a translated string. A newly allocated string that must be freed with g_free() a #GUnixMountPoint Guesses the symbolic icon of a Unix mount point. a #GIcon a #GUnixMountPoint Checks if a unix mount point is a loopback device. %TRUE if the mount point is a loopback. %FALSE otherwise. a #GUnixMountPoint. Checks if a unix mount point is read only. %TRUE if a mount point is read only. a #GUnixMountPoint. Checks if a unix mount point is mountable by the user. %TRUE if the mount point is user mountable. a #GUnixMountPoint. Gets a #GUnixMountPoint for a given mount path. If @time_read is set, it will be filled with a unix timestamp for checking if the mount points have changed since with g_unix_mount_points_changed_since(). If more mount points have the same mount path, the last matching mount point is returned. a #GUnixMountPoint, or %NULL if no match is found. path for a possible unix mount point. guint64 to contain a timestamp. #GUnixOutputStream implements #GOutputStream for writing to a UNIX file descriptor, including asynchronous operations. (If the file descriptor refers to a socket or pipe, this will use poll() to do asynchronous I/O. If it refers to a regular file, it will fall back to doing asynchronous I/O in another thread.) Note that `<gio/gunixoutputstream.h>` belongs to the UNIX-specific GIO interfaces, thus you have to use the `gio-unix-2.0.pc` pkg-config file when using it. Creates a new #GUnixOutputStream for the given @fd. If @close_fd, is %TRUE, the file descriptor will be closed when the output stream is destroyed. a new #GOutputStream a UNIX file descriptor %TRUE to close the file descriptor when done Returns whether the file descriptor of @stream will be closed when the stream is closed. %TRUE if the file descriptor is closed when done a #GUnixOutputStream Return the UNIX file descriptor that the stream writes to. The file descriptor of @stream a #GUnixOutputStream Sets whether the file descriptor of @stream shall be closed when the stream is closed. a #GUnixOutputStream %TRUE to close the file descriptor when done Whether to close the file descriptor when the stream is closed. The file descriptor that the stream writes to. Support for UNIX-domain (also known as local) sockets. UNIX domain sockets are generally visible in the filesystem. However, some systems support abstract socket names which are not visible in the filesystem and not affected by the filesystem permissions, visibility, etc. Currently this is only supported under Linux. If you attempt to use abstract sockets on other systems, function calls may return %G_IO_ERROR_NOT_SUPPORTED errors. You can use g_unix_socket_address_abstract_names_supported() to see if abstract names are supported. Note that `<gio/gunixsocketaddress.h>` belongs to the UNIX-specific GIO interfaces, thus you have to use the `gio-unix-2.0.pc` pkg-config file when using it. Creates a new #GUnixSocketAddress for @path. To create abstract socket addresses, on systems that support that, use g_unix_socket_address_new_abstract(). a new #GUnixSocketAddress the socket path Creates a new %G_UNIX_SOCKET_ADDRESS_ABSTRACT_PADDED #GUnixSocketAddress for @path. Use g_unix_socket_address_new_with_type(). a new #GUnixSocketAddress the abstract name the length of @path, or -1 Creates a new #GUnixSocketAddress of type @type with name @path. If @type is %G_UNIX_SOCKET_ADDRESS_PATH, this is equivalent to calling g_unix_socket_address_new(). If @type is %G_UNIX_SOCKET_ADDRESS_ANONYMOUS, @path and @path_len will be ignored. If @path_type is %G_UNIX_SOCKET_ADDRESS_ABSTRACT, then @path_len bytes of @path will be copied to the socket's path, and only those bytes will be considered part of the name. (If @path_len is -1, then @path is assumed to be NUL-terminated.) For example, if @path was "test", then calling g_socket_address_get_native_size() on the returned socket would return 7 (2 bytes of overhead, 1 byte for the abstract-socket indicator byte, and 4 bytes for the name "test"). If @path_type is %G_UNIX_SOCKET_ADDRESS_ABSTRACT_PADDED, then @path_len bytes of @path will be copied to the socket's path, the rest of the path will be padded with 0 bytes, and the entire zero-padded buffer will be considered the name. (As above, if @path_len is -1, then @path is assumed to be NUL-terminated.) In this case, g_socket_address_get_native_size() will always return the full size of a `struct sockaddr_un`, although g_unix_socket_address_get_path_len() will still return just the length of @path. %G_UNIX_SOCKET_ADDRESS_ABSTRACT is preferred over %G_UNIX_SOCKET_ADDRESS_ABSTRACT_PADDED for new programs. Of course, when connecting to a server created by another process, you must use the appropriate type corresponding to how that process created its listening socket. a new #GUnixSocketAddress the name the length of @path, or -1 a #GUnixSocketAddressType Checks if abstract UNIX domain socket names are supported. %TRUE if supported, %FALSE otherwise Gets @address's type. a #GUnixSocketAddressType a #GInetSocketAddress Tests if @address is abstract. Use g_unix_socket_address_get_address_type() %TRUE if the address is abstract, %FALSE otherwise a #GInetSocketAddress Gets @address's path, or for abstract sockets the "name". Guaranteed to be zero-terminated, but an abstract socket may contain embedded zeros, and thus you should use g_unix_socket_address_get_path_len() to get the true length of this string. the path for @address a #GInetSocketAddress Gets the length of @address's path. For details, see g_unix_socket_address_get_path(). the length of the path a #GInetSocketAddress Whether or not this is an abstract address Use #GUnixSocketAddress:address-type, which distinguishes between zero-padded and non-zero-padded abstract addresses. The type of name used by a #GUnixSocketAddress. %G_UNIX_SOCKET_ADDRESS_PATH indicates a traditional unix domain socket bound to a filesystem path. %G_UNIX_SOCKET_ADDRESS_ANONYMOUS indicates a socket not bound to any name (eg, a client-side socket, or a socket created with socketpair()). For abstract sockets, there are two incompatible ways of naming them; the man pages suggest using the entire `struct sockaddr_un` as the name, padding the unused parts of the %sun_path field with zeroes; this corresponds to %G_UNIX_SOCKET_ADDRESS_ABSTRACT_PADDED. However, many programs instead just use a portion of %sun_path, and pass an appropriate smaller length to bind() or connect(). This is %G_UNIX_SOCKET_ADDRESS_ABSTRACT. invalid anonymous a filesystem path an abstract name an abstract name, 0-padded to the full length of a unix socket name Extension point for #GVfs functionality. See [Extending GIO][extending-gio]. The string used to obtain the volume class with g_volume_get_identifier(). Known volume classes include `device`, `network`, and `loop`. Other classes may be added in the future. This is intended to be used by applications to classify #GVolume instances into different sections - for example a file manager or file chooser can use this information to show `network` volumes under a "Network" heading and `device` volumes under a "Devices" heading. The string used to obtain a Hal UDI with g_volume_get_identifier(). Do not use, HAL is deprecated. The string used to obtain a filesystem label with g_volume_get_identifier(). The string used to obtain a NFS mount with g_volume_get_identifier(). The string used to obtain a Unix device path with g_volume_get_identifier(). The string used to obtain a UUID with g_volume_get_identifier(). Extension point for volume monitor functionality. See [Extending GIO][extending-gio]. Entry point for using GIO functionality. Gets the default #GVfs for the system. a #GVfs. Gets the local #GVfs for the system. a #GVfs. Gets a #GFile for @path. a #GFile. Free the returned object with g_object_unref(). a #GVfs. a string containing a VFS path. Gets a #GFile for @uri. This operation never fails, but the returned object might not support any I/O operation if the URI is malformed or if the URI scheme is not supported. a #GFile. Free the returned object with g_object_unref(). a#GVfs. a string containing a URI Gets a list of URI schemes supported by @vfs. a %NULL-terminated array of strings. The returned array belongs to GIO and must not be freed or modified. a #GVfs. Checks if the VFS is active. %TRUE if construction of the @vfs was successful and it is now active. a #GVfs. This operation never fails, but the returned object might not support any I/O operations if the @parse_name cannot be parsed by the #GVfs module. a #GFile for the given @parse_name. Free the returned object with g_object_unref(). a #GVfs. a string to be parsed by the VFS module. Gets a #GFile for @path. a #GFile. Free the returned object with g_object_unref(). a #GVfs. a string containing a VFS path. Gets a #GFile for @uri. This operation never fails, but the returned object might not support any I/O operation if the URI is malformed or if the URI scheme is not supported. a #GFile. Free the returned object with g_object_unref(). a#GVfs. a string containing a URI Gets a list of URI schemes supported by @vfs. a %NULL-terminated array of strings. The returned array belongs to GIO and must not be freed or modified. a #GVfs. Checks if the VFS is active. %TRUE if construction of the @vfs was successful and it is now active. a #GVfs. This operation never fails, but the returned object might not support any I/O operations if the @parse_name cannot be parsed by the #GVfs module. a #GFile for the given @parse_name. Free the returned object with g_object_unref(). a #GVfs. a string to be parsed by the VFS module. Registers @uri_func and @parse_name_func as the #GFile URI and parse name lookup functions for URIs with a scheme matching @scheme. Note that @scheme is registered only within the running application, as opposed to desktop-wide as it happens with GVfs backends. When a #GFile is requested with an URI containing @scheme (e.g. through g_file_new_for_uri()), @uri_func will be called to allow a custom constructor. The implementation of @uri_func should not be blocking, and must not call g_vfs_register_uri_scheme() or g_vfs_unregister_uri_scheme(). When g_file_parse_name() is called with a parse name obtained from such file, @parse_name_func will be called to allow the #GFile to be created again. In that case, it's responsibility of @parse_name_func to make sure the parse name matches what the custom #GFile implementation returned when g_file_get_parse_name() was previously called. The implementation of @parse_name_func should not be blocking, and must not call g_vfs_register_uri_scheme() or g_vfs_unregister_uri_scheme(). It's an error to call this function twice with the same scheme. To unregister a custom URI scheme, use g_vfs_unregister_uri_scheme(). %TRUE if @scheme was successfully registered, or %FALSE if a handler for @scheme already exists. a #GVfs an URI scheme, e.g. "http" a #GVfsFileLookupFunc custom data passed to be passed to @uri_func, or %NULL function to be called when unregistering the URI scheme, or when @vfs is disposed, to free the resources used by the URI lookup function a #GVfsFileLookupFunc custom data passed to be passed to @parse_name_func, or %NULL function to be called when unregistering the URI scheme, or when @vfs is disposed, to free the resources used by the parse name lookup function Unregisters the URI handler for @scheme previously registered with g_vfs_register_uri_scheme(). %TRUE if @scheme was successfully unregistered, or %FALSE if a handler for @scheme does not exist. a #GVfs an URI scheme, e.g. "http" %TRUE if construction of the @vfs was successful and it is now active. a #GVfs. a #GFile. Free the returned object with g_object_unref(). a #GVfs. a string containing a VFS path. a #GFile. Free the returned object with g_object_unref(). a#GVfs. a string containing a URI a %NULL-terminated array of strings. The returned array belongs to GIO and must not be freed or modified. a #GVfs. a #GFile for the given @parse_name. Free the returned object with g_object_unref(). a #GVfs. a string to be parsed by the VFS module. This function type is used by g_vfs_register_uri_scheme() to make it possible for a client to associate an URI scheme to a different #GFile implementation. The client should return a reference to the new file that has been created for @uri, or %NULL to continue with the default implementation. a #GFile for @identifier. a #GVfs the identifier to look up a #GFile for. This can either be an URI or a parse name as returned by g_file_get_parse_name() user data passed to the function The #GVolume interface represents user-visible objects that can be mounted. Note, when porting from GnomeVFS, #GVolume is the moral equivalent of #GnomeVFSDrive. Mounting a #GVolume instance is an asynchronous operation. For more information about asynchronous operations, see #GAsyncResult and #GTask. To mount a #GVolume, first call g_volume_mount() with (at least) the #GVolume instance, optionally a #GMountOperation object and a #GAsyncReadyCallback. Typically, one will only want to pass %NULL for the #GMountOperation if automounting all volumes when a desktop session starts since it's not desirable to put up a lot of dialogs asking for credentials. The callback will be fired when the operation has resolved (either with success or failure), and a #GAsyncResult instance will be passed to the callback. That callback should then call g_volume_mount_finish() with the #GVolume instance and the #GAsyncResult data to see if the operation was completed successfully. If an @error is present when g_volume_mount_finish() is called, then it will be filled with any error information. ## Volume Identifiers # {#volume-identifier} It is sometimes necessary to directly access the underlying operating system object behind a volume (e.g. for passing a volume to an application via the commandline). For this purpose, GIO allows to obtain an 'identifier' for the volume. There can be different kinds of identifiers, such as Hal UDIs, filesystem labels, traditional Unix devices (e.g. `/dev/sda2`), UUIDs. GIO uses predefined strings as names for the different kinds of identifiers: #G_VOLUME_IDENTIFIER_KIND_UUID, #G_VOLUME_IDENTIFIER_KIND_LABEL, etc. Use g_volume_get_identifier() to obtain an identifier for a volume. Note that #G_VOLUME_IDENTIFIER_KIND_HAL_UDI will only be available when the gvfs hal volume monitor is in use. Other volume monitors will generally be able to provide the #G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE identifier, which can be used to obtain a hal device by means of libhal_manager_find_device_string_match(). Checks if a volume can be ejected. %TRUE if the @volume can be ejected. %FALSE otherwise a #GVolume Checks if a volume can be mounted. %TRUE if the @volume can be mounted. %FALSE otherwise a #GVolume Ejects a volume. This is an asynchronous operation, and is finished by calling g_volume_eject_finish() with the @volume and #GAsyncResult returned in the @callback. Use g_volume_eject_with_operation() instead. a #GVolume flags affecting the unmount if required for eject optional #GCancellable object, %NULL to ignore a #GAsyncReadyCallback, or %NULL user data that gets passed to @callback Finishes ejecting a volume. If any errors occurred during the operation, @error will be set to contain the errors and %FALSE will be returned. Use g_volume_eject_with_operation_finish() instead. %TRUE, %FALSE if operation failed pointer to a #GVolume a #GAsyncResult Ejects a volume. This is an asynchronous operation, and is finished by calling g_volume_eject_with_operation_finish() with the @volume and #GAsyncResult data returned in the @callback. a #GVolume flags affecting the unmount if required for eject a #GMountOperation or %NULL to avoid user interaction optional #GCancellable object, %NULL to ignore a #GAsyncReadyCallback, or %NULL user data passed to @callback Finishes ejecting a volume. If any errors occurred during the operation, @error will be set to contain the errors and %FALSE will be returned. %TRUE if the volume was successfully ejected. %FALSE otherwise a #GVolume a #GAsyncResult Gets the kinds of [identifiers][volume-identifier] that @volume has. Use g_volume_get_identifier() to obtain the identifiers themselves. a %NULL-terminated array of strings containing kinds of identifiers. Use g_strfreev() to free. a #GVolume Gets the activation root for a #GVolume if it is known ahead of mount time. Returns %NULL otherwise. If not %NULL and if @volume is mounted, then the result of g_mount_get_root() on the #GMount object obtained from g_volume_get_mount() will always either be equal or a prefix of what this function returns. In other words, in code |[<!-- language="C" --> GMount *mount; GFile *mount_root GFile *volume_activation_root; mount = g_volume_get_mount (volume); // mounted, so never NULL mount_root = g_mount_get_root (mount); volume_activation_root = g_volume_get_activation_root (volume); // assume not NULL ]| then the expression |[<!-- language="C" --> (g_file_has_prefix (volume_activation_root, mount_root) || g_file_equal (volume_activation_root, mount_root)) ]| will always be %TRUE. Activation roots are typically used in #GVolumeMonitor implementations to find the underlying mount to shadow, see g_mount_is_shadowed() for more details. the activation root of @volume or %NULL. Use g_object_unref() to free. a #GVolume Gets the drive for the @volume. a #GDrive or %NULL if @volume is not associated with a drive. The returned object should be unreffed with g_object_unref() when no longer needed. a #GVolume Gets the icon for @volume. a #GIcon. The returned object should be unreffed with g_object_unref() when no longer needed. a #GVolume Gets the identifier of the given kind for @volume. See the [introduction][volume-identifier] for more information about volume identifiers. a newly allocated string containing the requested identifier, or %NULL if the #GVolume doesn't have this kind of identifier a #GVolume the kind of identifier to return Gets the mount for the @volume. a #GMount or %NULL if @volume isn't mounted. The returned object should be unreffed with g_object_unref() when no longer needed. a #GVolume Gets the name of @volume. the name for the given @volume. The returned string should be freed with g_free() when no longer needed. a #GVolume Gets the sort key for @volume, if any. Sorting key for @volume or %NULL if no such key is available a #GVolume Gets the symbolic icon for @volume. a #GIcon. The returned object should be unreffed with g_object_unref() when no longer needed. a #GVolume Gets the UUID for the @volume. The reference is typically based on the file system UUID for the volume in question and should be considered an opaque string. Returns %NULL if there is no UUID available. the UUID for @volume or %NULL if no UUID can be computed. The returned string should be freed with g_free() when no longer needed. a #GVolume Finishes mounting a volume. If any errors occurred during the operation, @error will be set to contain the errors and %FALSE will be returned. If the mount operation succeeded, g_volume_get_mount() on @volume is guaranteed to return the mount right after calling this function; there's no need to listen for the 'mount-added' signal on #GVolumeMonitor. %TRUE, %FALSE if operation failed a #GVolume a #GAsyncResult Mounts a volume. This is an asynchronous operation, and is finished by calling g_volume_mount_finish() with the @volume and #GAsyncResult returned in the @callback. a #GVolume flags affecting the operation a #GMountOperation or %NULL to avoid user interaction optional #GCancellable object, %NULL to ignore a #GAsyncReadyCallback, or %NULL user data that gets passed to @callback Returns whether the volume should be automatically mounted. %TRUE if the volume should be automatically mounted a #GVolume Checks if a volume can be ejected. %TRUE if the @volume can be ejected. %FALSE otherwise a #GVolume Checks if a volume can be mounted. %TRUE if the @volume can be mounted. %FALSE otherwise a #GVolume Ejects a volume. This is an asynchronous operation, and is finished by calling g_volume_eject_finish() with the @volume and #GAsyncResult returned in the @callback. Use g_volume_eject_with_operation() instead. a #GVolume flags affecting the unmount if required for eject optional #GCancellable object, %NULL to ignore a #GAsyncReadyCallback, or %NULL user data that gets passed to @callback Finishes ejecting a volume. If any errors occurred during the operation, @error will be set to contain the errors and %FALSE will be returned. Use g_volume_eject_with_operation_finish() instead. %TRUE, %FALSE if operation failed pointer to a #GVolume a #GAsyncResult Ejects a volume. This is an asynchronous operation, and is finished by calling g_volume_eject_with_operation_finish() with the @volume and #GAsyncResult data returned in the @callback. a #GVolume flags affecting the unmount if required for eject a #GMountOperation or %NULL to avoid user interaction optional #GCancellable object, %NULL to ignore a #GAsyncReadyCallback, or %NULL user data passed to @callback Finishes ejecting a volume. If any errors occurred during the operation, @error will be set to contain the errors and %FALSE will be returned. %TRUE if the volume was successfully ejected. %FALSE otherwise a #GVolume a #GAsyncResult Gets the kinds of [identifiers][volume-identifier] that @volume has. Use g_volume_get_identifier() to obtain the identifiers themselves. a %NULL-terminated array of strings containing kinds of identifiers. Use g_strfreev() to free. a #GVolume Gets the activation root for a #GVolume if it is known ahead of mount time. Returns %NULL otherwise. If not %NULL and if @volume is mounted, then the result of g_mount_get_root() on the #GMount object obtained from g_volume_get_mount() will always either be equal or a prefix of what this function returns. In other words, in code |[<!-- language="C" --> GMount *mount; GFile *mount_root GFile *volume_activation_root; mount = g_volume_get_mount (volume); // mounted, so never NULL mount_root = g_mount_get_root (mount); volume_activation_root = g_volume_get_activation_root (volume); // assume not NULL ]| then the expression |[<!-- language="C" --> (g_file_has_prefix (volume_activation_root, mount_root) || g_file_equal (volume_activation_root, mount_root)) ]| will always be %TRUE. Activation roots are typically used in #GVolumeMonitor implementations to find the underlying mount to shadow, see g_mount_is_shadowed() for more details. the activation root of @volume or %NULL. Use g_object_unref() to free. a #GVolume Gets the drive for the @volume. a #GDrive or %NULL if @volume is not associated with a drive. The returned object should be unreffed with g_object_unref() when no longer needed. a #GVolume Gets the icon for @volume. a #GIcon. The returned object should be unreffed with g_object_unref() when no longer needed. a #GVolume Gets the identifier of the given kind for @volume. See the [introduction][volume-identifier] for more information about volume identifiers. a newly allocated string containing the requested identifier, or %NULL if the #GVolume doesn't have this kind of identifier a #GVolume the kind of identifier to return Gets the mount for the @volume. a #GMount or %NULL if @volume isn't mounted. The returned object should be unreffed with g_object_unref() when no longer needed. a #GVolume Gets the name of @volume. the name for the given @volume. The returned string should be freed with g_free() when no longer needed. a #GVolume Gets the sort key for @volume, if any. Sorting key for @volume or %NULL if no such key is available a #GVolume Gets the symbolic icon for @volume. a #GIcon. The returned object should be unreffed with g_object_unref() when no longer needed. a #GVolume Gets the UUID for the @volume. The reference is typically based on the file system UUID for the volume in question and should be considered an opaque string. Returns %NULL if there is no UUID available. the UUID for @volume or %NULL if no UUID can be computed. The returned string should be freed with g_free() when no longer needed. a #GVolume Mounts a volume. This is an asynchronous operation, and is finished by calling g_volume_mount_finish() with the @volume and #GAsyncResult returned in the @callback. a #GVolume flags affecting the operation a #GMountOperation or %NULL to avoid user interaction optional #GCancellable object, %NULL to ignore a #GAsyncReadyCallback, or %NULL user data that gets passed to @callback Finishes mounting a volume. If any errors occurred during the operation, @error will be set to contain the errors and %FALSE will be returned. If the mount operation succeeded, g_volume_get_mount() on @volume is guaranteed to return the mount right after calling this function; there's no need to listen for the 'mount-added' signal on #GVolumeMonitor. %TRUE, %FALSE if operation failed a #GVolume a #GAsyncResult Returns whether the volume should be automatically mounted. %TRUE if the volume should be automatically mounted a #GVolume Emitted when the volume has been changed. This signal is emitted when the #GVolume have been removed. If the recipient is holding references to the object they should release them so the object can be finalized. Interface for implementing operations for mountable volumes. The parent interface. the name for the given @volume. The returned string should be freed with g_free() when no longer needed. a #GVolume a #GIcon. The returned object should be unreffed with g_object_unref() when no longer needed. a #GVolume the UUID for @volume or %NULL if no UUID can be computed. The returned string should be freed with g_free() when no longer needed. a #GVolume a #GDrive or %NULL if @volume is not associated with a drive. The returned object should be unreffed with g_object_unref() when no longer needed. a #GVolume a #GMount or %NULL if @volume isn't mounted. The returned object should be unreffed with g_object_unref() when no longer needed. a #GVolume %TRUE if the @volume can be mounted. %FALSE otherwise a #GVolume %TRUE if the @volume can be ejected. %FALSE otherwise a #GVolume a #GVolume flags affecting the operation a #GMountOperation or %NULL to avoid user interaction optional #GCancellable object, %NULL to ignore a #GAsyncReadyCallback, or %NULL user data that gets passed to @callback %TRUE, %FALSE if operation failed a #GVolume a #GAsyncResult a #GVolume flags affecting the unmount if required for eject optional #GCancellable object, %NULL to ignore a #GAsyncReadyCallback, or %NULL user data that gets passed to @callback %TRUE, %FALSE if operation failed pointer to a #GVolume a #GAsyncResult a newly allocated string containing the requested identifier, or %NULL if the #GVolume doesn't have this kind of identifier a #GVolume the kind of identifier to return a %NULL-terminated array of strings containing kinds of identifiers. Use g_strfreev() to free. a #GVolume %TRUE if the volume should be automatically mounted a #GVolume the activation root of @volume or %NULL. Use g_object_unref() to free. a #GVolume a #GVolume flags affecting the unmount if required for eject a #GMountOperation or %NULL to avoid user interaction optional #GCancellable object, %NULL to ignore a #GAsyncReadyCallback, or %NULL user data passed to @callback %TRUE if the volume was successfully ejected. %FALSE otherwise a #GVolume a #GAsyncResult Sorting key for @volume or %NULL if no such key is available a #GVolume a #GIcon. The returned object should be unreffed with g_object_unref() when no longer needed. a #GVolume #GVolumeMonitor is for listing the user interesting devices and volumes on the computer. In other words, what a file selector or file manager would show in a sidebar. #GVolumeMonitor is not [thread-default-context aware][g-main-context-push-thread-default], and so should not be used other than from the main thread, with no thread-default-context active. In order to receive updates about volumes and mounts monitored through GVFS, a main loop must be running. This function should be called by any #GVolumeMonitor implementation when a new #GMount object is created that is not associated with a #GVolume object. It must be called just before emitting the @mount_added signal. If the return value is not %NULL, the caller must associate the returned #GVolume object with the #GMount. This involves returning it in its g_mount_get_volume() implementation. The caller must also listen for the "removed" signal on the returned object and give up its reference when handling that signal Similarly, if implementing g_volume_monitor_adopt_orphan_mount(), the implementor must take a reference to @mount and return it in its g_volume_get_mount() implemented. Also, the implementor must listen for the "unmounted" signal on @mount and give up its reference upon handling that signal. There are two main use cases for this function. One is when implementing a user space file system driver that reads blocks of a block device that is already represented by the native volume monitor (for example a CD Audio file system driver). Such a driver will generate its own #GMount object that needs to be associated with the #GVolume object that represents the volume. The other is for implementing a #GVolumeMonitor whose sole purpose is to return #GVolume objects representing entries in the users "favorite servers" list or similar. Instead of using this function, #GVolumeMonitor implementations should instead create shadow mounts with the URI of the mount they intend to adopt. See the proxy volume monitor in gvfs for an example of this. Also see g_mount_is_shadowed(), g_mount_shadow() and g_mount_unshadow() functions. the #GVolume object that is the parent for @mount or %NULL if no wants to adopt the #GMount. a #GMount object to find a parent for Gets the volume monitor used by gio. a reference to the #GVolumeMonitor used by gio. Call g_object_unref() when done with it. Gets a list of drives connected to the system. The returned list should be freed with g_list_free(), after its elements have been unreffed with g_object_unref(). a #GList of connected #GDrive objects. a #GVolumeMonitor. Finds a #GMount object by its UUID (see g_mount_get_uuid()) a #GMount or %NULL if no such mount is available. Free the returned object with g_object_unref(). a #GVolumeMonitor. the UUID to look for Gets a list of the mounts on the system. The returned list should be freed with g_list_free(), after its elements have been unreffed with g_object_unref(). a #GList of #GMount objects. a #GVolumeMonitor. Finds a #GVolume object by its UUID (see g_volume_get_uuid()) a #GVolume or %NULL if no such volume is available. Free the returned object with g_object_unref(). a #GVolumeMonitor. the UUID to look for Gets a list of the volumes on the system. The returned list should be freed with g_list_free(), after its elements have been unreffed with g_object_unref(). a #GList of #GVolume objects. a #GVolumeMonitor. Gets a list of drives connected to the system. The returned list should be freed with g_list_free(), after its elements have been unreffed with g_object_unref(). a #GList of connected #GDrive objects. a #GVolumeMonitor. Finds a #GMount object by its UUID (see g_mount_get_uuid()) a #GMount or %NULL if no such mount is available. Free the returned object with g_object_unref(). a #GVolumeMonitor. the UUID to look for Gets a list of the mounts on the system. The returned list should be freed with g_list_free(), after its elements have been unreffed with g_object_unref(). a #GList of #GMount objects. a #GVolumeMonitor. Finds a #GVolume object by its UUID (see g_volume_get_uuid()) a #GVolume or %NULL if no such volume is available. Free the returned object with g_object_unref(). a #GVolumeMonitor. the UUID to look for Gets a list of the volumes on the system. The returned list should be freed with g_list_free(), after its elements have been unreffed with g_object_unref(). a #GList of #GVolume objects. a #GVolumeMonitor. Emitted when a drive changes. the drive that changed Emitted when a drive is connected to the system. a #GDrive that was connected. Emitted when a drive is disconnected from the system. a #GDrive that was disconnected. Emitted when the eject button is pressed on @drive. the drive where the eject button was pressed Emitted when the stop button is pressed on @drive. the drive where the stop button was pressed Emitted when a mount is added. a #GMount that was added. Emitted when a mount changes. a #GMount that changed. May be emitted when a mount is about to be removed. This signal depends on the backend and is only emitted if GIO was used to unmount. a #GMount that is being unmounted. Emitted when a mount is removed. a #GMount that was removed. Emitted when a mountable volume is added to the system. a #GVolume that was added. Emitted when mountable volume is changed. a #GVolume that changed. Emitted when a mountable volume is removed from the system. a #GVolume that was removed. a #GList of connected #GDrive objects. a #GVolumeMonitor. a #GList of #GVolume objects. a #GVolumeMonitor. a #GList of #GMount objects. a #GVolumeMonitor. a #GVolume or %NULL if no such volume is available. Free the returned object with g_object_unref(). a #GVolumeMonitor. the UUID to look for a #GMount or %NULL if no such mount is available. Free the returned object with g_object_unref(). a #GVolumeMonitor. the UUID to look for Zlib decompression Creates a new #GZlibCompressor. a new #GZlibCompressor The format to use for the compressed data compression level (0-9), -1 for default Returns the #GZlibCompressor:file-info property. a #GFileInfo, or %NULL a #GZlibCompressor Sets @file_info in @compressor. If non-%NULL, and @compressor's #GZlibCompressor:format property is %G_ZLIB_COMPRESSOR_FORMAT_GZIP, it will be used to set the file name and modification time in the GZIP header of the compressed data. Note: it is an error to call this function while a compression is in progress; it may only be called immediately after creation of @compressor, or after resetting it with g_converter_reset(). a #GZlibCompressor a #GFileInfo If set to a non-%NULL #GFileInfo object, and #GZlibCompressor:format is %G_ZLIB_COMPRESSOR_FORMAT_GZIP, the compressor will write the file name and modification time from the file info to the GZIP header. Used to select the type of data format to use for #GZlibDecompressor and #GZlibCompressor. deflate compression with zlib header gzip file format deflate compression with no header Zlib decompression Creates a new #GZlibDecompressor. a new #GZlibDecompressor The format to use for the compressed data Retrieves the #GFileInfo constructed from the GZIP header data of compressed data processed by @compressor, or %NULL if @decompressor's #GZlibDecompressor:format property is not %G_ZLIB_COMPRESSOR_FORMAT_GZIP, or the header data was not fully processed yet, or it not present in the data stream at all. a #GFileInfo, or %NULL a #GZlibDecompressor A #GFileInfo containing the information found in the GZIP header of the data stream processed, or %NULL if the header was not yet fully processed, is not present at all, or the compressor's #GZlibDecompressor:format property is not %G_ZLIB_COMPRESSOR_FORMAT_GZIP. Checks if @action_name is valid. @action_name is valid if it consists only of alphanumeric characters, plus '-' and '.'. The empty string is not a valid action name. It is an error to call this function with a non-utf8 @action_name. @action_name must not be %NULL. %TRUE if @action_name is valid a potential action name Parses a detailed action name into its separate name and target components. Detailed action names can have three formats. The first format is used to represent an action name with no target value and consists of just an action name containing no whitespace nor the characters ':', '(' or ')'. For example: "app.action". The second format is used to represent an action with a target value that is a non-empty string consisting only of alphanumerics, plus '-' and '.'. In that case, the action name and target value are separated by a double colon ("::"). For example: "app.action::target". The third format is used to represent an action with any type of target value, including strings. The target value follows the action name, surrounded in parens. For example: "app.action(42)". The target value is parsed using g_variant_parse(). If a tuple-typed value is desired, it must be specified in the same way, resulting in two sets of parens, for example: "app.action((1,2,3))". A string target can be specified this way as well: "app.action('target')". For strings, this third format must be used if * target value is empty or contains characters other than alphanumerics, '-' and '.'. %TRUE if successful, else %FALSE with @error set a detailed action name the action name the target value, or %NULL for no target Formats a detailed action name from @action_name and @target_value. It is an error to call this function with an invalid action name. This function is the opposite of g_action_parse_detailed_name(). It will produce a string that can be parsed back to the @action_name and @target_value by that function. See that function for the types of strings that will be printed by this function. a detailed format string a valid action name a #GVariant target value, or %NULL Creates a new #GAppInfo from the given information. Note that for @commandline, the quoting rules of the Exec key of the [freedesktop.org Desktop Entry Specification](http://freedesktop.org/Standards/desktop-entry-spec) are applied. For example, if the @commandline contains percent-encoded URIs, the percent-character must be doubled in order to prevent it from being swallowed by Exec key unquoting. See the specification for exact quoting rules. new #GAppInfo for given command. the commandline to use the application name, or %NULL to use @commandline flags that can specify details of the created #GAppInfo Gets a list of all of the applications currently registered on this system. For desktop files, this includes applications that have `NoDisplay=true` set or are excluded from display by means of `OnlyShowIn` or `NotShowIn`. See g_app_info_should_show(). The returned list does not include applications which have the `Hidden` key set. a newly allocated #GList of references to #GAppInfos. Gets a list of all #GAppInfos for a given content type, including the recommended and fallback #GAppInfos. See g_app_info_get_recommended_for_type() and g_app_info_get_fallback_for_type(). #GList of #GAppInfos for given @content_type or %NULL on error. the content type to find a #GAppInfo for Gets the default #GAppInfo for a given content type. #GAppInfo for given @content_type or %NULL on error. the content type to find a #GAppInfo for if %TRUE, the #GAppInfo is expected to support URIs Gets the default application for handling URIs with the given URI scheme. A URI scheme is the initial part of the URI, up to but not including the ':', e.g. "http", "ftp" or "sip". #GAppInfo for given @uri_scheme or %NULL on error. a string containing a URI scheme. Gets a list of fallback #GAppInfos for a given content type, i.e. those applications which claim to support the given content type by MIME type subclassing and not directly. #GList of #GAppInfos for given @content_type or %NULL on error. the content type to find a #GAppInfo for Gets a list of recommended #GAppInfos for a given content type, i.e. those applications which claim to support the given content type exactly, and not by MIME type subclassing. Note that the first application of the list is the last used one, i.e. the last one for which g_app_info_set_as_last_used_for_type() has been called. #GList of #GAppInfos for given @content_type or %NULL on error. the content type to find a #GAppInfo for Utility function that launches the default application registered to handle the specified uri. Synchronous I/O is done on the uri to detect the type of the file if required. The D-Bus–activated applications don't have to be started if your application terminates too soon after this function. To prevent this, use g_app_info_launch_default_for_uri_async() instead. %TRUE on success, %FALSE on error. the uri to show an optional #GAppLaunchContext Async version of g_app_info_launch_default_for_uri(). This version is useful if you are interested in receiving error information in the case where the application is sandboxed and the portal may present an application chooser dialog to the user. This is also useful if you want to be sure that the D-Bus–activated applications are really started before termination and if you are interested in receiving error information from their activation. the uri to show an optional #GAppLaunchContext a #GCancellable a #GAsyncReadyCallback to call when the request is done data to pass to @callback Finishes an asynchronous launch-default-for-uri operation. %TRUE if the launch was successful, %FALSE if @error is set a #GAsyncResult Removes all changes to the type associations done by g_app_info_set_as_default_for_type(), g_app_info_set_as_default_for_extension(), g_app_info_add_supports_type() or g_app_info_remove_supports_type(). a content type Helper function for constructing #GAsyncInitable object. This is similar to g_object_newv() but also initializes the object asynchronously. When the initialization is finished, @callback will be called. You can then call g_async_initable_new_finish() to get the new object and check for any errors. Use g_object_new_with_properties() and g_async_initable_init_async() instead. See #GParameter for more information. a #GType supporting #GAsyncInitable. the number of parameters in @parameters the parameters to use to construct the object the [I/O priority][io-priority] of the operation optional #GCancellable object, %NULL to ignore. a #GAsyncReadyCallback to call when the initialization is finished the data to pass to callback function Asynchronously connects to the message bus specified by @bus_type. When the operation is finished, @callback will be invoked. You can then call g_bus_get_finish() to get the result of the operation. This is an asynchronous failable function. See g_bus_get_sync() for the synchronous version. a #GBusType a #GCancellable or %NULL a #GAsyncReadyCallback to call when the request is satisfied the data to pass to @callback Finishes an operation started with g_bus_get(). The returned object is a singleton, that is, shared with other callers of g_bus_get() and g_bus_get_sync() for @bus_type. In the event that you need a private message bus connection, use g_dbus_address_get_for_bus_sync() and g_dbus_connection_new_for_address(). Note that the returned #GDBusConnection object will (usually) have the #GDBusConnection:exit-on-close property set to %TRUE. a #GDBusConnection or %NULL if @error is set. Free with g_object_unref(). a #GAsyncResult obtained from the #GAsyncReadyCallback passed to g_bus_get() Synchronously connects to the message bus specified by @bus_type. Note that the returned object may shared with other callers, e.g. if two separate parts of a process calls this function with the same @bus_type, they will share the same object. This is a synchronous failable function. See g_bus_get() and g_bus_get_finish() for the asynchronous version. The returned object is a singleton, that is, shared with other callers of g_bus_get() and g_bus_get_sync() for @bus_type. In the event that you need a private message bus connection, use g_dbus_address_get_for_bus_sync() and g_dbus_connection_new_for_address(). Note that the returned #GDBusConnection object will (usually) have the #GDBusConnection:exit-on-close property set to %TRUE. a #GDBusConnection or %NULL if @error is set. Free with g_object_unref(). a #GBusType a #GCancellable or %NULL Starts acquiring @name on the bus specified by @bus_type and calls @name_acquired_handler and @name_lost_handler when the name is acquired respectively lost. Callbacks will be invoked in the [thread-default main context][g-main-context-push-thread-default] of the thread you are calling this function from. You are guaranteed that one of the @name_acquired_handler and @name_lost_handler callbacks will be invoked after calling this function - there are three possible cases: - @name_lost_handler with a %NULL connection (if a connection to the bus can't be made). - @bus_acquired_handler then @name_lost_handler (if the name can't be obtained) - @bus_acquired_handler then @name_acquired_handler (if the name was obtained). When you are done owning the name, just call g_bus_unown_name() with the owner id this function returns. If the name is acquired or lost (for example another application could acquire the name if you allow replacement or the application currently owning the name exits), the handlers are also invoked. If the #GDBusConnection that is used for attempting to own the name closes, then @name_lost_handler is invoked since it is no longer possible for other processes to access the process. You cannot use g_bus_own_name() several times for the same name (unless interleaved with calls to g_bus_unown_name()) - only the first call will work. Another guarantee is that invocations of @name_acquired_handler and @name_lost_handler are guaranteed to alternate; that is, if @name_acquired_handler is invoked then you are guaranteed that the next time one of the handlers is invoked, it will be @name_lost_handler. The reverse is also true. If you plan on exporting objects (using e.g. g_dbus_connection_register_object()), note that it is generally too late to export the objects in @name_acquired_handler. Instead, you can do this in @bus_acquired_handler since you are guaranteed that this will run before @name is requested from the bus. This behavior makes it very simple to write applications that wants to [own names][gdbus-owning-names] and export objects. Simply register objects to be exported in @bus_acquired_handler and unregister the objects (if any) in @name_lost_handler. an identifier (never 0) that can be used with g_bus_unown_name() to stop owning the name. the type of bus to own a name on the well-known name to own a set of flags from the #GBusNameOwnerFlags enumeration handler to invoke when connected to the bus of type @bus_type or %NULL handler to invoke when @name is acquired or %NULL handler to invoke when @name is lost or %NULL user data to pass to handlers function for freeing @user_data or %NULL Like g_bus_own_name() but takes a #GDBusConnection instead of a #GBusType. an identifier (never 0) that can be used with g_bus_unown_name() to stop owning the name a #GDBusConnection the well-known name to own a set of flags from the #GBusNameOwnerFlags enumeration handler to invoke when @name is acquired or %NULL handler to invoke when @name is lost or %NULL user data to pass to handlers function for freeing @user_data or %NULL Version of g_bus_own_name_on_connection() using closures instead of callbacks for easier binding in other languages. an identifier (never 0) that can be used with g_bus_unown_name() to stop owning the name. a #GDBusConnection the well-known name to own a set of flags from the #GBusNameOwnerFlags enumeration #GClosure to invoke when @name is acquired or %NULL #GClosure to invoke when @name is lost or %NULL Version of g_bus_own_name() using closures instead of callbacks for easier binding in other languages. an identifier (never 0) that can be used with g_bus_unown_name() to stop owning the name. the type of bus to own a name on the well-known name to own a set of flags from the #GBusNameOwnerFlags enumeration #GClosure to invoke when connected to the bus of type @bus_type or %NULL #GClosure to invoke when @name is acquired or %NULL #GClosure to invoke when @name is lost or %NULL Stops owning a name. Note that there may still be D-Bus traffic to process (relating to owning and unowning the name) in the current thread-default #GMainContext after this function has returned. You should continue to iterate the #GMainContext until the #GDestroyNotify function passed to g_bus_own_name() is called, in order to avoid memory leaks through callbacks queued on the #GMainContext after it’s stopped being iterated. an identifier obtained from g_bus_own_name() Stops watching a name. Note that there may still be D-Bus traffic to process (relating to watching and unwatching the name) in the current thread-default #GMainContext after this function has returned. You should continue to iterate the #GMainContext until the #GDestroyNotify function passed to g_bus_watch_name() is called, in order to avoid memory leaks through callbacks queued on the #GMainContext after it’s stopped being iterated. An identifier obtained from g_bus_watch_name() Starts watching @name on the bus specified by @bus_type and calls @name_appeared_handler and @name_vanished_handler when the name is known to have an owner respectively known to lose its owner. Callbacks will be invoked in the [thread-default main context][g-main-context-push-thread-default] of the thread you are calling this function from. You are guaranteed that one of the handlers will be invoked after calling this function. When you are done watching the name, just call g_bus_unwatch_name() with the watcher id this function returns. If the name vanishes or appears (for example the application owning the name could restart), the handlers are also invoked. If the #GDBusConnection that is used for watching the name disconnects, then @name_vanished_handler is invoked since it is no longer possible to access the name. Another guarantee is that invocations of @name_appeared_handler and @name_vanished_handler are guaranteed to alternate; that is, if @name_appeared_handler is invoked then you are guaranteed that the next time one of the handlers is invoked, it will be @name_vanished_handler. The reverse is also true. This behavior makes it very simple to write applications that want to take action when a certain [name exists][gdbus-watching-names]. Basically, the application should create object proxies in @name_appeared_handler and destroy them again (if any) in @name_vanished_handler. An identifier (never 0) that can be used with g_bus_unwatch_name() to stop watching the name. The type of bus to watch a name on. The name (well-known or unique) to watch. Flags from the #GBusNameWatcherFlags enumeration. Handler to invoke when @name is known to exist or %NULL. Handler to invoke when @name is known to not exist or %NULL. User data to pass to handlers. Function for freeing @user_data or %NULL. Like g_bus_watch_name() but takes a #GDBusConnection instead of a #GBusType. An identifier (never 0) that can be used with g_bus_unwatch_name() to stop watching the name. A #GDBusConnection. The name (well-known or unique) to watch. Flags from the #GBusNameWatcherFlags enumeration. Handler to invoke when @name is known to exist or %NULL. Handler to invoke when @name is known to not exist or %NULL. User data to pass to handlers. Function for freeing @user_data or %NULL. Version of g_bus_watch_name_on_connection() using closures instead of callbacks for easier binding in other languages. An identifier (never 0) that can be used with g_bus_unwatch_name() to stop watching the name. A #GDBusConnection. The name (well-known or unique) to watch. Flags from the #GBusNameWatcherFlags enumeration. #GClosure to invoke when @name is known to exist or %NULL. #GClosure to invoke when @name is known to not exist or %NULL. Version of g_bus_watch_name() using closures instead of callbacks for easier binding in other languages. An identifier (never 0) that can be used with g_bus_unwatch_name() to stop watching the name. The type of bus to watch a name on. The name (well-known or unique) to watch. Flags from the #GBusNameWatcherFlags enumeration. #GClosure to invoke when @name is known to exist or %NULL. #GClosure to invoke when @name is known to not exist or %NULL. Checks if a content type can be executable. Note that for instance things like text files can be executables (i.e. scripts and batch files). %TRUE if the file type corresponds to a type that can be executable, %FALSE otherwise. a content type string Compares two content types for equality. %TRUE if the two strings are identical or equivalent, %FALSE otherwise. a content type string a content type string Tries to find a content type based on the mime type name. Newly allocated string with content type or %NULL. Free with g_free() a mime type string Gets the human readable description of the content type. a short description of the content type @type. Free the returned string with g_free() a content type string Gets the generic icon name for a content type. See the [shared-mime-info](http://www.freedesktop.org/wiki/Specifications/shared-mime-info-spec) specification for more on the generic icon name. the registered generic icon name for the given @type, or %NULL if unknown. Free with g_free() a content type string Gets the icon for a content type. #GIcon corresponding to the content type. Free the returned object with g_object_unref() a content type string Get the list of directories which MIME data is loaded from. See g_content_type_set_mime_dirs() for details. %NULL-terminated list of directories to load MIME data from, including any `mime/` subdirectory, and with the first directory to try listed first Gets the mime type for the content type, if one is registered. the registered mime type for the given @type, or %NULL if unknown; free with g_free(). a content type string Gets the symbolic icon for a content type. symbolic #GIcon corresponding to the content type. Free the returned object with g_object_unref() a content type string Guesses the content type based on example data. If the function is uncertain, @result_uncertain will be set to %TRUE. Either @filename or @data may be %NULL, in which case the guess will be based solely on the other argument. a string indicating a guessed content type for the given data. Free with g_free() a string, or %NULL a stream of data, or %NULL the size of @data return location for the certainty of the result, or %NULL Tries to guess the type of the tree with root @root, by looking at the files it contains. The result is an array of content types, with the best guess coming first. The types returned all have the form x-content/foo, e.g. x-content/audio-cdda (for audio CDs) or x-content/image-dcf (for a camera memory card). See the [shared-mime-info](http://www.freedesktop.org/wiki/Specifications/shared-mime-info-spec) specification for more on x-content types. This function is useful in the implementation of g_mount_guess_content_type(). an %NULL-terminated array of zero or more content types. Free with g_strfreev() the root of the tree to guess a type for Determines if @type is a subset of @supertype. %TRUE if @type is a kind of @supertype, %FALSE otherwise. a content type string a content type string Determines if @type is a subset of @mime_type. Convenience wrapper around g_content_type_is_a(). %TRUE if @type is a kind of @mime_type, %FALSE otherwise. a content type string a mime type string Checks if the content type is the generic "unknown" type. On UNIX this is the "application/octet-stream" mimetype, while on win32 it is "*" and on OSX it is a dynamic type or octet-stream. %TRUE if the type is the unknown type. a content type string Set the list of directories used by GIO to load the MIME database. If @dirs is %NULL, the directories used are the default: - the `mime` subdirectory of the directory in `$XDG_DATA_HOME` - the `mime` subdirectory of every directory in `$XDG_DATA_DIRS` This function is intended to be used when writing tests that depend on information stored in the MIME database, in order to control the data. Typically, in case your tests use %G_TEST_OPTION_ISOLATE_DIRS, but they depend on the system’s MIME database, you should call this function with @dirs set to %NULL before calling g_test_init(), for instance: |[<!-- language="C" --> // Load MIME data from the system g_content_type_set_mime_dirs (NULL); // Isolate the environment g_test_init (&argc, &argv, G_TEST_OPTION_ISOLATE_DIRS, NULL); … return g_test_run (); ]| %NULL-terminated list of directories to load MIME data from, including any `mime/` subdirectory, and with the first directory to try listed first Gets a list of strings containing all the registered content types known to the system. The list and its data should be freed using `g_list_free_full (list, g_free)`. list of the registered content types Escape @string so it can appear in a D-Bus address as the value part of a key-value pair. For instance, if @string is `/run/bus-for-:0`, this function would return `/run/bus-for-%3A0`, which could be used in a D-Bus address like `unix:nonce-tcp:host=127.0.0.1,port=42,noncefile=/run/bus-for-%3A0`. a copy of @string with all non-optionally-escaped bytes escaped an unescaped string to be included in a D-Bus address as the value in a key-value pair Synchronously looks up the D-Bus address for the well-known message bus instance specified by @bus_type. This may involve using various platform specific mechanisms. The returned address will be in the [D-Bus address format](https://dbus.freedesktop.org/doc/dbus-specification.html#addresses). a valid D-Bus address string for @bus_type or %NULL if @error is set a #GBusType a #GCancellable or %NULL Asynchronously connects to an endpoint specified by @address and sets up the connection so it is in a state to run the client-side of the D-Bus authentication conversation. @address must be in the [D-Bus address format](https://dbus.freedesktop.org/doc/dbus-specification.html#addresses). When the operation is finished, @callback will be invoked. You can then call g_dbus_address_get_stream_finish() to get the result of the operation. This is an asynchronous failable function. See g_dbus_address_get_stream_sync() for the synchronous version. A valid D-Bus address. A #GCancellable or %NULL. A #GAsyncReadyCallback to call when the request is satisfied. Data to pass to @callback. Finishes an operation started with g_dbus_address_get_stream(). A #GIOStream or %NULL if @error is set. A #GAsyncResult obtained from the GAsyncReadyCallback passed to g_dbus_address_get_stream(). %NULL or return location to store the GUID extracted from @address, if any. Synchronously connects to an endpoint specified by @address and sets up the connection so it is in a state to run the client-side of the D-Bus authentication conversation. @address must be in the [D-Bus address format](https://dbus.freedesktop.org/doc/dbus-specification.html#addresses). This is a synchronous failable function. See g_dbus_address_get_stream() for the asynchronous version. A #GIOStream or %NULL if @error is set. A valid D-Bus address. %NULL or return location to store the GUID extracted from @address, if any. A #GCancellable or %NULL. Looks up the value of an annotation. The cost of this function is O(n) in number of annotations. The value or %NULL if not found. Do not free, it is owned by @annotations. A %NULL-terminated array of annotations or %NULL. The name of the annotation to look up. Creates a D-Bus error name to use for @error. If @error matches a registered error (cf. g_dbus_error_register_error()), the corresponding D-Bus error name will be returned. Otherwise the a name of the form `org.gtk.GDBus.UnmappedGError.Quark._ESCAPED_QUARK_NAME.Code_ERROR_CODE` will be used. This allows other GDBus applications to map the error on the wire back to a #GError using g_dbus_error_new_for_dbus_error(). This function is typically only used in object mappings to put a #GError on the wire. Regular applications should not use it. A D-Bus error name (never %NULL). Free with g_free(). A #GError. Gets the D-Bus error name used for @error, if any. This function is guaranteed to return a D-Bus error name for all #GErrors returned from functions handling remote method calls (e.g. g_dbus_connection_call_finish()) unless g_dbus_error_strip_remote_error() has been used on @error. an allocated string or %NULL if the D-Bus error name could not be found. Free with g_free(). a #GError Checks if @error represents an error received via D-Bus from a remote peer. If so, use g_dbus_error_get_remote_error() to get the name of the error. %TRUE if @error represents an error from a remote peer, %FALSE otherwise. A #GError. Creates a #GError based on the contents of @dbus_error_name and @dbus_error_message. Errors registered with g_dbus_error_register_error() will be looked up using @dbus_error_name and if a match is found, the error domain and code is used. Applications can use g_dbus_error_get_remote_error() to recover @dbus_error_name. If a match against a registered error is not found and the D-Bus error name is in a form as returned by g_dbus_error_encode_gerror() the error domain and code encoded in the name is used to create the #GError. Also, @dbus_error_name is added to the error message such that it can be recovered with g_dbus_error_get_remote_error(). Otherwise, a #GError with the error code %G_IO_ERROR_DBUS_ERROR in the #G_IO_ERROR error domain is returned. Also, @dbus_error_name is added to the error message such that it can be recovered with g_dbus_error_get_remote_error(). In all three cases, @dbus_error_name can always be recovered from the returned #GError using the g_dbus_error_get_remote_error() function (unless g_dbus_error_strip_remote_error() hasn't been used on the returned error). This function is typically only used in object mappings to prepare #GError instances for applications. Regular applications should not use it. An allocated #GError. Free with g_error_free(). D-Bus error name. D-Bus error message. Creates an association to map between @dbus_error_name and #GErrors specified by @error_domain and @error_code. This is typically done in the routine that returns the #GQuark for an error domain. %TRUE if the association was created, %FALSE if it already exists. A #GQuark for an error domain. An error code. A D-Bus error name. Helper function for associating a #GError error domain with D-Bus error names. The error domain name. A pointer where to store the #GQuark. A pointer to @num_entries #GDBusErrorEntry struct items. Number of items to register. Looks for extra information in the error message used to recover the D-Bus error name and strips it if found. If stripped, the message field in @error will correspond exactly to what was received on the wire. This is typically used when presenting errors to the end user. %TRUE if information was stripped, %FALSE otherwise. A #GError. Destroys an association previously set up with g_dbus_error_register_error(). %TRUE if the association was destroyed, %FALSE if it wasn't found. A #GQuark for an error domain. An error code. A D-Bus error name. Generate a D-Bus GUID that can be used with e.g. g_dbus_connection_new(). See the D-Bus specification regarding what strings are valid D-Bus GUID (for example, D-Bus GUIDs are not RFC-4122 compliant). A valid D-Bus GUID. Free with g_free(). Converts a #GValue to a #GVariant of the type indicated by the @type parameter. The conversion is using the following rules: - #G_TYPE_STRING: 's', 'o', 'g' or 'ay' - #G_TYPE_STRV: 'as', 'ao' or 'aay' - #G_TYPE_BOOLEAN: 'b' - #G_TYPE_UCHAR: 'y' - #G_TYPE_INT: 'i', 'n' - #G_TYPE_UINT: 'u', 'q' - #G_TYPE_INT64 'x' - #G_TYPE_UINT64: 't' - #G_TYPE_DOUBLE: 'd' - #G_TYPE_VARIANT: Any #GVariantType This can fail if e.g. @gvalue is of type #G_TYPE_STRING and @type is ['i'][G-VARIANT-TYPE-INT32:CAPS]. It will also fail for any #GType (including e.g. #G_TYPE_OBJECT and #G_TYPE_BOXED derived-types) not in the table above. Note that if @gvalue is of type #G_TYPE_VARIANT and its value is %NULL, the empty #GVariant instance (never %NULL) for @type is returned (e.g. 0 for scalar types, the empty string for string types, '/' for object path types, the empty array for any array type and so on). See the g_dbus_gvariant_to_gvalue() function for how to convert a #GVariant to a #GValue. A #GVariant (never floating) of #GVariantType @type holding the data from @gvalue or %NULL in case of failure. Free with g_variant_unref(). A #GValue to convert to a #GVariant A #GVariantType Converts a #GVariant to a #GValue. If @value is floating, it is consumed. The rules specified in the g_dbus_gvalue_to_gvariant() function are used - this function is essentially its reverse form. So, a #GVariant containing any basic or string array type will be converted to a #GValue containing a basic value or string array. Any other #GVariant (handle, variant, tuple, dict entry) will be converted to a #GValue containing that #GVariant. The conversion never fails - a valid #GValue is always returned in @out_gvalue. A #GVariant. Return location pointing to a zero-filled (uninitialized) #GValue. Checks if @string is a [D-Bus address](https://dbus.freedesktop.org/doc/dbus-specification.html#addresses). This doesn't check if @string is actually supported by #GDBusServer or #GDBusConnection - use g_dbus_is_supported_address() to do more checks. %TRUE if @string is a valid D-Bus address, %FALSE otherwise. A string. Checks if @string is a D-Bus GUID. See the D-Bus specification regarding what strings are valid D-Bus GUID (for example, D-Bus GUIDs are not RFC-4122 compliant). %TRUE if @string is a guid, %FALSE otherwise. The string to check. Checks if @string is a valid D-Bus interface name. %TRUE if valid, %FALSE otherwise. The string to check. Checks if @string is a valid D-Bus member (e.g. signal or method) name. %TRUE if valid, %FALSE otherwise. The string to check. Checks if @string is a valid D-Bus bus name (either unique or well-known). %TRUE if valid, %FALSE otherwise. The string to check. Like g_dbus_is_address() but also checks if the library supports the transports in @string and that key/value pairs for each transport are valid. See the specification of the [D-Bus address format](https://dbus.freedesktop.org/doc/dbus-specification.html#addresses). %TRUE if @string is a valid D-Bus address that is supported by this library, %FALSE if @error is set. A string. Checks if @string is a valid D-Bus unique bus name. %TRUE if valid, %FALSE otherwise. The string to check. Creates a new #GDtlsClientConnection wrapping @base_socket which is assumed to communicate with the server identified by @server_identity. the new #GDtlsClientConnection, or %NULL on error the #GDatagramBased to wrap the expected identity of the server Creates a new #GDtlsServerConnection wrapping @base_socket. the new #GDtlsServerConnection, or %NULL on error the #GDatagramBased to wrap the default server certificate, or %NULL #GIOExtensionPoint provides a mechanism for modules to extend the functionality of the library or application that loaded it in an organized fashion. An extension point is identified by a name, and it may optionally require that any implementation must be of a certain type (or derived thereof). Use g_io_extension_point_register() to register an extension point, and g_io_extension_point_set_required_type() to set a required type. A module can implement an extension point by specifying the #GType that implements the functionality. Additionally, each implementation of an extension point has a name, and a priority. Use g_io_extension_point_implement() to implement an extension point. |[<!-- language="C" --> GIOExtensionPoint *ep; // Register an extension point ep = g_io_extension_point_register ("my-extension-point"); g_io_extension_point_set_required_type (ep, MY_TYPE_EXAMPLE); ]| |[<!-- language="C" --> // Implement an extension point G_DEFINE_TYPE (MyExampleImpl, my_example_impl, MY_TYPE_EXAMPLE) g_io_extension_point_implement ("my-extension-point", my_example_impl_get_type (), "my-example", 10); ]| It is up to the code that registered the extension point how it uses the implementations that have been associated with it. Depending on the use case, it may use all implementations, or only the one with the highest priority, or pick a specific one by name. To avoid opening all modules just to find out what extension points they implement, GIO makes use of a caching mechanism, see [gio-querymodules][gio-querymodules]. You are expected to run this command after installing a GIO module. The `GIO_EXTRA_MODULES` environment variable can be used to specify additional directories to automatically load modules from. This environment variable has the same syntax as the `PATH`. If two modules have the same base name in different directories, then the latter one will be ignored. If additional directories are specified GIO will load modules from the built-in directory last. Creates a #GFile with the given argument from the command line. The value of @arg can be either a URI, an absolute path or a relative path resolved relative to the current working directory. This operation never fails, but the returned object might not support any I/O operation if @arg points to a malformed path. Note that on Windows, this function expects its argument to be in UTF-8 -- not the system code page. This means that you should not use this function with string from argv as it is passed to main(). g_win32_get_command_line() will return a UTF-8 version of the commandline. #GApplication also uses UTF-8 but g_application_command_line_create_file_for_arg() may be more useful for you there. It is also always possible to use this function with #GOptionContext arguments of type %G_OPTION_ARG_FILENAME. a new #GFile. Free the returned object with g_object_unref(). a command line string Creates a #GFile with the given argument from the command line. This function is similar to g_file_new_for_commandline_arg() except that it allows for passing the current working directory as an argument instead of using the current working directory of the process. This is useful if the commandline argument was given in a context other than the invocation of the current process. See also g_application_command_line_create_file_for_arg(). a new #GFile a command line string the current working directory of the commandline Constructs a #GFile for a given path. This operation never fails, but the returned object might not support any I/O operation if @path is malformed. a new #GFile for the given @path. Free the returned object with g_object_unref(). a string containing a relative or absolute path. The string must be encoded in the glib filename encoding. Constructs a #GFile for a given URI. This operation never fails, but the returned object might not support any I/O operation if @uri is malformed or if the uri type is not supported. a new #GFile for the given @uri. Free the returned object with g_object_unref(). a UTF-8 string containing a URI Opens a file in the preferred directory for temporary files (as returned by g_get_tmp_dir()) and returns a #GFile and #GFileIOStream pointing to it. @tmpl should be a string in the GLib file name encoding containing a sequence of six 'X' characters, and containing no directory components. If it is %NULL, a default template is used. Unlike the other #GFile constructors, this will return %NULL if a temporary file could not be created. a new #GFile. Free the returned object with g_object_unref(). Template for the file name, as in g_file_open_tmp(), or %NULL for a default template on return, a #GFileIOStream for the created file Constructs a #GFile with the given @parse_name (i.e. something given by g_file_get_parse_name()). This operation never fails, but the returned object might not support any I/O operation if the @parse_name cannot be parsed. a new #GFile. a file name or path to be parsed These functions support exporting a #GActionGroup on D-Bus. The D-Bus interface that is used is a private implementation detail. To access an exported #GActionGroup remotely, use g_dbus_action_group_get() to obtain a #GDBusActionGroup. A content type is a platform specific string that defines the type of a file. On UNIX it is a [MIME type](http://www.wikipedia.org/wiki/Internet_media_type) like `text/plain` or `image/png`. On Win32 it is an extension string like `.doc`, `.txt` or a perceived string like `audio`. Such strings can be looked up in the registry at `HKEY_CLASSES_ROOT`. On macOS it is a [Uniform Type Identifier](https://en.wikipedia.org/wiki/Uniform_Type_Identifier) such as `com.apple.application`. Routines for working with D-Bus addresses. A D-Bus address is a string like `unix:tmpdir=/tmp/my-app-name`. The exact format of addresses is explained in detail in the [D-Bus specification](http://dbus.freedesktop.org/doc/dbus-specification.html#addresses). TCP D-Bus connections are supported, but accessing them via a proxy is currently not supported. All facilities that return errors from remote methods (such as g_dbus_connection_call_sync()) use #GError to represent both D-Bus errors (e.g. errors returned from the other peer) and locally in-process generated errors. To check if a returned #GError is an error from a remote peer, use g_dbus_error_is_remote_error(). To get the actual D-Bus error name, use g_dbus_error_get_remote_error(). Before presenting an error, always use g_dbus_error_strip_remote_error(). In addition, facilities used to return errors to a remote peer also use #GError. See g_dbus_method_invocation_return_error() for discussion about how the D-Bus error name is set. Applications can associate a #GError error domain with a set of D-Bus errors in order to automatically map from D-Bus errors to #GError and back. This is typically done in the function returning the #GQuark for the error domain: |[<!-- language="C" --> // foo-bar-error.h: #define FOO_BAR_ERROR (foo_bar_error_quark ()) GQuark foo_bar_error_quark (void); typedef enum { FOO_BAR_ERROR_FAILED, FOO_BAR_ERROR_ANOTHER_ERROR, FOO_BAR_ERROR_SOME_THIRD_ERROR, FOO_BAR_N_ERRORS / *< skip >* / } FooBarError; // foo-bar-error.c: static const GDBusErrorEntry foo_bar_error_entries[] = { {FOO_BAR_ERROR_FAILED, "org.project.Foo.Bar.Error.Failed"}, {FOO_BAR_ERROR_ANOTHER_ERROR, "org.project.Foo.Bar.Error.AnotherError"}, {FOO_BAR_ERROR_SOME_THIRD_ERROR, "org.project.Foo.Bar.Error.SomeThirdError"}, }; // Ensure that every error code has an associated D-Bus error name G_STATIC_ASSERT (G_N_ELEMENTS (foo_bar_error_entries) == FOO_BAR_N_ERRORS); GQuark foo_bar_error_quark (void) { static volatile gsize quark_volatile = 0; g_dbus_error_register_error_domain ("foo-bar-error-quark", &quark_volatile, foo_bar_error_entries, G_N_ELEMENTS (foo_bar_error_entries)); return (GQuark) quark_volatile; } ]| With this setup, a D-Bus peer can transparently pass e.g. %FOO_BAR_ERROR_ANOTHER_ERROR and other peers will see the D-Bus error name org.project.Foo.Bar.Error.AnotherError. If the other peer is using GDBus, and has registered the association with g_dbus_error_register_error_domain() in advance (e.g. by invoking the %FOO_BAR_ERROR quark generation itself in the previous example) the peer will see also %FOO_BAR_ERROR_ANOTHER_ERROR instead of %G_IO_ERROR_DBUS_ERROR. Note that GDBus clients can still recover org.project.Foo.Bar.Error.AnotherError using g_dbus_error_get_remote_error(). Note that the %G_DBUS_ERROR error domain is intended only for returning errors from a remote message bus process. Errors generated locally in-process by e.g. #GDBusConnection should use the %G_IO_ERROR domain. Various data structures and convenience routines to parse and generate D-Bus introspection XML. Introspection information is used when registering objects with g_dbus_connection_register_object(). The format of D-Bus introspection XML is specified in the [D-Bus specification](http://dbus.freedesktop.org/doc/dbus-specification.html#introspection-format) Convenience API for owning bus names. A simple example for owning a name can be found in [gdbus-example-own-name.c](https://git.gnome.org/browse/glib/tree/gio/tests/gdbus-example-own-name.c) Convenience API for watching bus names. A simple example for watching a name can be found in [gdbus-example-watch-name.c](https://git.gnome.org/browse/glib/tree/gio/tests/gdbus-example-watch-name.c) Various utility routines related to D-Bus. File attributes in GIO consist of a list of key-value pairs. Keys are strings that contain a key namespace and a key name, separated by a colon, e.g. "namespace::keyname". Namespaces are included to sort key-value pairs by namespaces for relevance. Keys can be retrieved using wildcards, e.g. "standard::*" will return all of the keys in the "standard" namespace. The list of possible attributes for a filesystem (pointed to by a #GFile) is available as a #GFileAttributeInfoList. This list is queryable by key names as indicated earlier. Information is stored within the list in #GFileAttributeInfo structures. The info structure can store different types, listed in the enum #GFileAttributeType. Upon creation of a #GFileAttributeInfo, the type will be set to %G_FILE_ATTRIBUTE_TYPE_INVALID. Classes that implement #GFileIface will create a #GFileAttributeInfoList and install default keys and values for their given file system, architecture, and other possible implementation details (e.g., on a UNIX system, a file attribute key will be registered for the user id for a given file). ## Default Namespaces - `"standard"`: The "Standard" namespace. General file information that any application may need should be put in this namespace. Examples include the file's name, type, and size. - `"etag`: The [Entity Tag][gfile-etag] namespace. Currently, the only key in this namespace is "value", which contains the value of the current entity tag. - `"id"`: The "Identification" namespace. This namespace is used by file managers and applications that list directories to check for loops and to uniquely identify files. - `"access"`: The "Access" namespace. Used to check if a user has the proper privileges to access files and perform file operations. Keys in this namespace are made to be generic and easily understood, e.g. the "can_read" key is %TRUE if the current user has permission to read the file. UNIX permissions and NTFS ACLs in Windows should be mapped to these values. - `"mountable"`: The "Mountable" namespace. Includes simple boolean keys for checking if a file or path supports mount operations, e.g. mount, unmount, eject. These are used for files of type %G_FILE_TYPE_MOUNTABLE. - `"time"`: The "Time" namespace. Includes file access, changed, created times. - `"unix"`: The "Unix" namespace. Includes UNIX-specific information and may not be available for all files. Examples include the UNIX "UID", "GID", etc. - `"dos"`: The "DOS" namespace. Includes DOS-specific information and may not be available for all files. Examples include "is_system" for checking if a file is marked as a system file, and "is_archive" for checking if a file is marked as an archive file. - `"owner"`: The "Owner" namespace. Includes information about who owns a file. May not be available for all file systems. Examples include "user" for getting the user name of the file owner. This information is often mapped from some backend specific data such as a UNIX UID. - `"thumbnail"`: The "Thumbnail" namespace. Includes information about file thumbnails and their location within the file system. Examples of keys in this namespace include "path" to get the location of a thumbnail, "failed" to check if thumbnailing of the file failed, and "is-valid" to check if the thumbnail is outdated. - `"filesystem"`: The "Filesystem" namespace. Gets information about the file system where a file is located, such as its type, how much space is left available, and the overall size of the file system. - `"gvfs"`: The "GVFS" namespace. Keys in this namespace contain information about the current GVFS backend in use. - `"xattr"`: The "xattr" namespace. Gets information about extended user attributes. See attr(5). The "user." prefix of the extended user attribute name is stripped away when constructing keys in this namespace, e.g. "xattr::mime_type" for the extended attribute with the name "user.mime_type". Note that this information is only available if GLib has been built with extended attribute support. - `"xattr-sys"`: The "xattr-sys" namespace. Gets information about extended attributes which are not user-specific. See attr(5). Note that this information is only available if GLib has been built with extended attribute support. - `"selinux"`: The "SELinux" namespace. Includes information about the SELinux context of files. Note that this information is only available if GLib has been built with SELinux support. Please note that these are not all of the possible namespaces. More namespaces can be added from GIO modules or by individual applications. For more information about writing GIO modules, see #GIOModule. <!-- TODO: Implementation note about using extended attributes on supported file systems --> ## Default Keys For a list of the built-in keys and their types, see the [GFileInfo][GFileInfo] documentation. Note that there are no predefined keys in the "xattr" and "xattr-sys" namespaces. Keys for the "xattr" namespace are constructed by stripping away the "user." prefix from the extended user attribute, and prepending "xattr::". Keys for the "xattr-sys" namespace are constructed by concatenating "xattr-sys::" with the extended attribute name. All extended attribute values are returned as hex-encoded strings in which bytes outside the ASCII range are encoded as escape sequences of the form \x`nn` where `nn` is a 2-digit hexadecimal number. Contains helper functions for reporting errors to the user. As of GLib 2.36, #GIOScheduler is deprecated in favor of #GThreadPool and #GTask. Schedules asynchronous I/O operations. #GIOScheduler integrates into the main event loop (#GMainLoop) and uses threads. These functions support exporting a #GMenuModel on D-Bus. The D-Bus interface that is used is a private implementation detail. To access an exported #GMenuModel remotely, use g_dbus_menu_model_get() to obtain a #GDBusMenuModel. The `<gio/gnetworking.h>` header can be included to get various low-level networking-related system headers, automatically taking care of certain portability issues for you. This can be used, for example, if you want to call setsockopt() on a #GSocket. Note that while WinSock has many of the same APIs as the traditional UNIX socket API, most of them behave at least slightly differently (particularly with respect to error handling). If you want your code to work under both UNIX and Windows, you will need to take these differences into account. Also, under GNU libc, certain non-portable functions are only visible in the headers if you define %_GNU_SOURCE before including them. Note that this symbol must be defined before including any headers, or it may not take effect. Utility functions for #GPollableInputStream and #GPollableOutputStream implementations. #GTlsConnection and related classes provide TLS (Transport Layer Security, previously known as SSL, Secure Sockets Layer) support for gio-based network streams. #GDtlsConnection and related classes provide DTLS (Datagram TLS) support for GIO-based network sockets, using the #GDatagramBased interface. The TLS and DTLS APIs are almost identical, except TLS is stream-based and DTLS is datagram-based. They share certificate and backend infrastructure. In the simplest case, for a client TLS connection, you can just set the #GSocketClient:tls flag on a #GSocketClient, and then any connections created by that client will have TLS negotiated automatically, using appropriate default settings, and rejecting any invalid or self-signed certificates (unless you change that default by setting the #GSocketClient:tls-validation-flags property). The returned object will be a #GTcpWrapperConnection, which wraps the underlying #GTlsClientConnection. For greater control, you can create your own #GTlsClientConnection, wrapping a #GSocketConnection (or an arbitrary #GIOStream with pollable input and output streams) and then connect to its signals, such as #GTlsConnection::accept-certificate, before starting the handshake. Server-side TLS is similar, using #GTlsServerConnection. At the moment, there is no support for automatically wrapping server-side connections in the way #GSocketClient does for client-side connections. Routines for managing mounted UNIX mount points and paths. Note that `<gio/gunixmounts.h>` belongs to the UNIX-specific GIO interfaces, thus you have to use the `gio-unix-2.0.pc` pkg-config file when using it. #GWin32InputStream implements #GInputStream for reading from a Windows file handle. Note that `<gio/gwin32inputstream.h>` belongs to the Windows-specific GIO interfaces, thus you have to use the `gio-windows-2.0.pc` pkg-config file when using it. #GWin32OutputStream implements #GOutputStream for writing to a Windows file handle. Note that `<gio/gwin32outputstream.h>` belongs to the Windows-specific GIO interfaces, thus you have to use the `gio-windows-2.0.pc` pkg-config file when using it. #GWin32RegistryKey represents a single Windows Registry key. #GWin32RegistryKey is used by a number of helper functions that read Windows Registry. All keys are opened with read-only access, and at the moment there is no API for writing into registry keys or creating new ones. #GWin32RegistryKey implements the #GInitable interface, so if it is manually constructed by e.g. g_object_new() you must call g_initable_init() and check the results before using the object. This is done automatically in g_win32_registry_key_new() and g_win32_registry_key_get_child(), so these functions can return %NULL. To increase efficiency, a UTF-16 variant is available for all functions that deal with key or value names in the registry. Use these to perform deep registry queries or other operations that require querying a name of a key or a value and then opening it (or querying its data). The use of UTF-16 functions avoids the overhead of converting names to UTF-8 and back. All functions operate in current user's context (it is not possible to access registry tree of a different user). Key paths must use '\\' as a separator, '/' is not supported. Key names must not include '\\', because it's used as a separator. Value names can include '\\'. Key and value names are not case sensitive. Full key name (excluding the pre-defined ancestor's name) can't exceed 255 UTF-16 characters, give or take. Value name can't exceed 16383 UTF-16 characters. Tree depth is limited to 512 levels. #GZlibCompressor is an implementation of #GConverter that compresses data using zlib. #GZlibDecompressor is an implementation of #GConverter that decompresses data compressed with zlib. Deserializes a #GIcon previously serialized using g_icon_serialize(). a #GIcon, or %NULL when deserialization fails. a #GVariant created with g_icon_serialize() Gets a hash for an icon. a #guint containing a hash for the @icon, suitable for use in a #GHashTable or similar data structure. #gconstpointer to an icon object. Generate a #GIcon instance from @str. This function can fail if @str is not valid - see g_icon_to_string() for discussion. If your application or library provides one or more #GIcon implementations you need to ensure that each #GType is registered with the type system prior to calling g_icon_new_for_string(). An object implementing the #GIcon interface or %NULL if @error is set. A string obtained via g_icon_to_string(). Helper function for constructing #GInitable object. This is similar to g_object_newv() but also initializes the object and returns %NULL, setting an error on failure. Use g_object_new_with_properties() and g_initable_init() instead. See #GParameter for more information. a newly allocated #GObject, or %NULL on error a #GType supporting #GInitable. the number of parameters in @parameters the parameters to use to construct the object optional #GCancellable object, %NULL to ignore. Converts errno.h error codes into GIO error codes. The fallback value %G_IO_ERROR_FAILED is returned for error codes not currently handled (but note that future GLib releases may return a more specific value instead). As %errno is global and may be modified by intermediate function calls, you should save its value as soon as the call which sets it #GIOErrorEnum value for the given errno.h error number. Error number as defined in errno.h. Gets the GIO Error Quark. a #GQuark. Registers @type as extension for the extension point with name @extension_point_name. If @type has already been registered as an extension for this extension point, the existing #GIOExtension object is returned. a #GIOExtension object for #GType the name of the extension point the #GType to register as extension the name for the extension the priority for the extension Looks up an existing extension point. the #GIOExtensionPoint, or %NULL if there is no registered extension point with the given name. the name of the extension point Registers an extension point. the new #GIOExtensionPoint. This object is owned by GIO and should not be freed. The name of the extension point Loads all the modules in the specified directory. If don't require all modules to be initialized (and thus registering all gtypes) then you can use g_io_modules_scan_all_in_directory() which allows delayed/lazy loading of modules. a list of #GIOModules loaded from the directory, All the modules are loaded into memory, if you want to unload them (enabling on-demand loading) you must call g_type_module_unuse() on all the modules. Free the list with g_list_free(). pathname for a directory containing modules to load. Loads all the modules in the specified directory. If don't require all modules to be initialized (and thus registering all gtypes) then you can use g_io_modules_scan_all_in_directory() which allows delayed/lazy loading of modules. a list of #GIOModules loaded from the directory, All the modules are loaded into memory, if you want to unload them (enabling on-demand loading) you must call g_type_module_unuse() on all the modules. Free the list with g_list_free(). pathname for a directory containing modules to load. a scope to use when scanning the modules. Scans all the modules in the specified directory, ensuring that any extension point implemented by a module is registered. This may not actually load and initialize all the types in each module, some modules may be lazily loaded and initialized when an extension point it implements is used with e.g. g_io_extension_point_get_extensions() or g_io_extension_point_get_extension_by_name(). If you need to guarantee that all types are loaded in all the modules, use g_io_modules_load_all_in_directory(). pathname for a directory containing modules to scan. Scans all the modules in the specified directory, ensuring that any extension point implemented by a module is registered. This may not actually load and initialize all the types in each module, some modules may be lazily loaded and initialized when an extension point it implements is used with e.g. g_io_extension_point_get_extensions() or g_io_extension_point_get_extension_by_name(). If you need to guarantee that all types are loaded in all the modules, use g_io_modules_load_all_in_directory(). pathname for a directory containing modules to scan. a scope to use when scanning the modules Cancels all cancellable I/O jobs. A job is cancellable if a #GCancellable was passed into g_io_scheduler_push_job(). You should never call this function, since you don't know how other libraries in your program might be making use of gioscheduler. Schedules the I/O job to run in another thread. @notify will be called on @user_data after @job_func has returned, regardless whether the job was cancelled or has run to completion. If @cancellable is not %NULL, it can be used to cancel the I/O job by calling g_cancellable_cancel() or by calling g_io_scheduler_cancel_all_jobs(). use #GThreadPool or g_task_run_in_thread() a #GIOSchedulerJobFunc. data to pass to @job_func a #GDestroyNotify for @user_data, or %NULL the [I/O priority][io-priority] of the request. optional #GCancellable object, %NULL to ignore. Creates a keyfile-backed #GSettingsBackend. The filename of the keyfile to use is given by @filename. All settings read to or written from the backend must fall under the path given in @root_path (which must start and end with a slash and not contain two consecutive slashes). @root_path may be "/". If @root_group is non-%NULL then it specifies the name of the keyfile group used for keys that are written directly below @root_path. For example, if @root_path is "/apps/example/" and @root_group is "toplevel", then settings the key "/apps/example/enabled" to a value of %TRUE will cause the following to appear in the keyfile: |[ [toplevel] enabled=true ]| If @root_group is %NULL then it is not permitted to store keys directly below the @root_path. For keys not stored directly below @root_path (ie: in a sub-path), the name of the subpath (with the final slash stripped) is used as the name of the keyfile group. To continue the example, if "/apps/example/profiles/default/font-size" were set to 12 then the following would appear in the keyfile: |[ [profiles/default] font-size=12 ]| The backend will refuse writes (and return writability as being %FALSE) for keys outside of @root_path and, in the event that @root_group is %NULL, also for keys directly under @root_path. Writes will also be refused if the backend detects that it has the inability to rewrite the keyfile (ie: the containing directory is not writable). There is no checking done for your key namespace clashing with the syntax of the key file format. For example, if you have '[' or ']' characters in your path names or '=' in your key names you may be in trouble. The backend reads default values from a keyfile called `defaults` in the directory specified by the #GKeyfileSettingsBackend:defaults-dir property, and a list of locked keys from a text file with the name `locks` in the same location. a keyfile-backed #GSettingsBackend the filename of the keyfile the path under which all settings keys appear the group name corresponding to @root_path, or %NULL Gets a reference to the default #GMemoryMonitor for the system. a new reference to the default #GMemoryMonitor Creates a memory-backed #GSettingsBackend. This backend allows changes to settings, but does not write them to any backing storage, so the next time you run your application, the memory backend will start out with the default values again. a newly created #GSettingsBackend Gets the default #GNetworkMonitor for the system. a #GNetworkMonitor Initializes the platform networking libraries (eg, on Windows, this calls WSAStartup()). GLib will call this itself if it is needed, so you only need to call it if you directly call system networking functions (without calling any GLib networking functions first). Creates a readonly #GSettingsBackend. This backend does not allow changes to settings, so all settings will always have their default values. a newly created #GSettingsBackend Utility method for #GPollableInputStream and #GPollableOutputStream implementations. Creates a new #GSource that expects a callback of type #GPollableSourceFunc. The new source does not actually do anything on its own; use g_source_add_child_source() to add other sources to it to cause it to trigger. the new #GSource. the stream associated with the new source Utility method for #GPollableInputStream and #GPollableOutputStream implementations. Creates a new #GSource, as with g_pollable_source_new(), but also attaching @child_source (with a dummy callback), and @cancellable, if they are non-%NULL. the new #GSource. the stream associated with the new source optional child source to attach optional #GCancellable to attach Tries to read from @stream, as with g_input_stream_read() (if @blocking is %TRUE) or g_pollable_input_stream_read_nonblocking() (if @blocking is %FALSE). This can be used to more easily share code between blocking and non-blocking implementations of a method. If @blocking is %FALSE, then @stream must be a #GPollableInputStream for which g_pollable_input_stream_can_poll() returns %TRUE, or else the behavior is undefined. If @blocking is %TRUE, then @stream does not need to be a #GPollableInputStream. the number of bytes read, or -1 on error. a #GInputStream a buffer to read data into the number of bytes to read whether to do blocking I/O optional #GCancellable object, %NULL to ignore. Tries to write to @stream, as with g_output_stream_write() (if @blocking is %TRUE) or g_pollable_output_stream_write_nonblocking() (if @blocking is %FALSE). This can be used to more easily share code between blocking and non-blocking implementations of a method. If @blocking is %FALSE, then @stream must be a #GPollableOutputStream for which g_pollable_output_stream_can_poll() returns %TRUE or else the behavior is undefined. If @blocking is %TRUE, then @stream does not need to be a #GPollableOutputStream. the number of bytes written, or -1 on error. a #GOutputStream. the buffer containing the data to write. the number of bytes to write whether to do blocking I/O optional #GCancellable object, %NULL to ignore. Tries to write @count bytes to @stream, as with g_output_stream_write_all(), but using g_pollable_stream_write() rather than g_output_stream_write(). On a successful write of @count bytes, %TRUE is returned, and @bytes_written is set to @count. If there is an error during the operation (including %G_IO_ERROR_WOULD_BLOCK in the non-blocking case), %FALSE is returned and @error is set to indicate the error status, @bytes_written is updated to contain the number of bytes written into the stream before the error occurred. As with g_pollable_stream_write(), if @blocking is %FALSE, then @stream must be a #GPollableOutputStream for which g_pollable_output_stream_can_poll() returns %TRUE or else the behavior is undefined. If @blocking is %TRUE, then @stream does not need to be a #GPollableOutputStream. %TRUE on success, %FALSE if there was an error a #GOutputStream. the buffer containing the data to write. the number of bytes to write whether to do blocking I/O location to store the number of bytes that was written to the stream optional #GCancellable object, %NULL to ignore. Find the `gio-proxy` extension point for a proxy implementation that supports the specified protocol. return a #GProxy or NULL if protocol is not supported. the proxy protocol name (e.g. http, socks, etc) Gets the default #GProxyResolver for the system. the default #GProxyResolver. Gets the #GResolver Error Quark. a #GQuark. Gets the #GResource Error Quark. a #GQuark Loads a binary resource bundle and creates a #GResource representation of it, allowing you to query it for data. If you want to use this resource in the global resource namespace you need to register it with g_resources_register(). If @filename is empty or the data in it is corrupt, %G_RESOURCE_ERROR_INTERNAL will be returned. If @filename doesn’t exist, or there is an error in reading it, an error from g_mapped_file_new() will be returned. a new #GResource, or %NULL on error the path of a filename to load, in the GLib filename encoding Returns all the names of children at the specified @path in the set of globally registered resources. The return result is a %NULL terminated list of strings which should be released with g_strfreev(). @lookup_flags controls the behaviour of the lookup. an array of constant strings A pathname inside the resource A #GResourceLookupFlags Looks for a file at the specified @path in the set of globally registered resources and if found returns information about it. @lookup_flags controls the behaviour of the lookup. %TRUE if the file was found. %FALSE if there were errors A pathname inside the resource A #GResourceLookupFlags a location to place the length of the contents of the file, or %NULL if the length is not needed a location to place the #GResourceFlags about the file, or %NULL if the flags are not needed Looks for a file at the specified @path in the set of globally registered resources and returns a #GBytes that lets you directly access the data in memory. The data is always followed by a zero byte, so you can safely use the data as a C string. However, that byte is not included in the size of the GBytes. For uncompressed resource files this is a pointer directly into the resource bundle, which is typically in some readonly data section in the program binary. For compressed files we allocate memory on the heap and automatically uncompress the data. @lookup_flags controls the behaviour of the lookup. #GBytes or %NULL on error. Free the returned object with g_bytes_unref() A pathname inside the resource A #GResourceLookupFlags Looks for a file at the specified @path in the set of globally registered resources and returns a #GInputStream that lets you read the data. @lookup_flags controls the behaviour of the lookup. #GInputStream or %NULL on error. Free the returned object with g_object_unref() A pathname inside the resource A #GResourceLookupFlags Registers the resource with the process-global set of resources. Once a resource is registered the files in it can be accessed with the global resource lookup functions like g_resources_lookup_data(). A #GResource Unregisters the resource from the process-global set of resources. A #GResource Gets the default system schema source. This function is not required for normal uses of #GSettings but it may be useful to authors of plugin management systems or to those who want to introspect the content of schemas. If no schemas are installed, %NULL will be returned. The returned source may actually consist of multiple schema sources from different directories, depending on which directories were given in `XDG_DATA_DIRS` and `GSETTINGS_SCHEMA_DIR`. For this reason, all lookups performed against the default source should probably be done recursively. the default schema source Reports an error in an asynchronous function in an idle function by directly setting the contents of the #GAsyncResult with the given error information. Use g_task_report_error(). a #GObject, or %NULL. a #GAsyncReadyCallback. user data passed to @callback. a #GQuark containing the error domain (usually #G_IO_ERROR). a specific error code. a formatted error reporting string. a list of variables to fill in @format. Reports an error in an idle function. Similar to g_simple_async_report_error_in_idle(), but takes a #GError rather than building a new one. Use g_task_report_error(). a #GObject, or %NULL a #GAsyncReadyCallback. user data passed to @callback. the #GError to report Reports an error in an idle function. Similar to g_simple_async_report_gerror_in_idle(), but takes over the caller's ownership of @error, so the caller does not have to free it any more. Use g_task_report_error(). a #GObject, or %NULL a #GAsyncReadyCallback. user data passed to @callback. the #GError to report Sorts @targets in place according to the algorithm in RFC 2782. the head of the sorted list. a #GList of #GSrvTarget Gets the default #GTlsBackend for the system. a #GTlsBackend Gets the TLS channel binding error quark. a #GQuark. Creates a new #GTlsClientConnection wrapping @base_io_stream (which must have pollable input and output streams) which is assumed to communicate with the server identified by @server_identity. See the documentation for #GTlsConnection:base-io-stream for restrictions on when application code can run operations on the @base_io_stream after this function has returned. the new #GTlsClientConnection, or %NULL on error the #GIOStream to wrap the expected identity of the server Gets the TLS error quark. a #GQuark. Creates a new #GTlsFileDatabase which uses anchor certificate authorities in @anchors to verify certificate chains. The certificates in @anchors must be PEM encoded. the new #GTlsFileDatabase, or %NULL on error filename of anchor certificate authorities. Creates a new #GTlsServerConnection wrapping @base_io_stream (which must have pollable input and output streams). See the documentation for #GTlsConnection:base-io-stream for restrictions on when application code can run operations on the @base_io_stream after this function has returned. the new #GTlsServerConnection, or %NULL on error the #GIOStream to wrap the default server certificate, or %NULL Determines if @mount_path is considered an implementation of the OS. This is primarily used for hiding mountable and mounted volumes that only are used in the OS and has little to no relevance to the casual user. %TRUE if @mount_path is considered an implementation detail of the OS. a mount path, e.g. `/media/disk` or `/usr` Determines if @device_path is considered a block device path which is only used in implementation of the OS. This is primarily used for hiding mounted volumes that are intended as APIs for programs to read, and system administrators at a shell; rather than something that should, for example, appear in a GUI. For example, the Linux `/proc` filesystem. The list of device paths considered ‘system’ ones may change over time. %TRUE if @device_path is considered an implementation detail of the OS. a device path, e.g. `/dev/loop0` or `nfsd` Determines if @fs_type is considered a type of file system which is only used in implementation of the OS. This is primarily used for hiding mounted volumes that are intended as APIs for programs to read, and system administrators at a shell; rather than something that should, for example, appear in a GUI. For example, the Linux `/proc` filesystem. The list of file system types considered ‘system’ ones may change over time. %TRUE if @fs_type is considered an implementation detail of the OS. a file system type, e.g. `procfs` or `tmpfs` Gets a #GUnixMountEntry for a given mount path. If @time_read is set, it will be filled with a unix timestamp for checking if the mounts have changed since with g_unix_mounts_changed_since(). If more mounts have the same mount path, the last matching mount is returned. a #GUnixMountEntry. path for a possible unix mount. guint64 to contain a timestamp. Compares two unix mounts. 1, 0 or -1 if @mount1 is greater than, equal to, or less than @mount2, respectively. first #GUnixMountEntry to compare. second #GUnixMountEntry to compare. Makes a copy of @mount_entry. a new #GUnixMountEntry a #GUnixMountEntry. Gets a #GUnixMountEntry for a given file path. If @time_read is set, it will be filled with a unix timestamp for checking if the mounts have changed since with g_unix_mounts_changed_since(). If more mounts have the same mount path, the last matching mount is returned. a #GUnixMountEntry. file path on some unix mount. guint64 to contain a timestamp. Frees a unix mount. a #GUnixMountEntry. Gets the device path for a unix mount. a string containing the device path. a #GUnixMount. Gets the filesystem type for the unix mount. a string containing the file system type. a #GUnixMount. Gets the mount path for a unix mount. the mount path for @mount_entry. input #GUnixMountEntry to get the mount path for. Gets a comma-separated list of mount options for the unix mount. For example, `rw,relatime,seclabel,data=ordered`. This is similar to g_unix_mount_point_get_options(), but it takes a #GUnixMountEntry as an argument. a string containing the options, or %NULL if not available. a #GUnixMountEntry. Gets the root of the mount within the filesystem. This is useful e.g. for mounts created by bind operation, or btrfs subvolumes. For example, the root path is equal to "/" for mount created by "mount /dev/sda1 /mnt/foo" and "/bar" for "mount --bind /mnt/foo/bar /mnt/bar". a string containing the root, or %NULL if not supported. a #GUnixMountEntry. Guesses whether a Unix mount can be ejected. %TRUE if @mount_entry is deemed to be ejectable. a #GUnixMountEntry Guesses the icon of a Unix mount. a #GIcon a #GUnixMountEntry Guesses the name of a Unix mount. The result is a translated string. A newly allocated string that must be freed with g_free() a #GUnixMountEntry Guesses whether a Unix mount should be displayed in the UI. %TRUE if @mount_entry is deemed to be displayable. a #GUnixMountEntry Guesses the symbolic icon of a Unix mount. a #GIcon a #GUnixMountEntry Checks if a unix mount is mounted read only. %TRUE if @mount_entry is read only. a #GUnixMount. Checks if a Unix mount is a system mount. This is the Boolean OR of g_unix_is_system_fs_type(), g_unix_is_system_device_path() and g_unix_is_mount_path_system_internal() on @mount_entry’s properties. The definition of what a ‘system’ mount entry is may change over time as new file system types and device paths are ignored. %TRUE if the unix mount is for a system path. a #GUnixMount. Gets a #GUnixMountPoint for a given mount path. If @time_read is set, it will be filled with a unix timestamp for checking if the mount points have changed since with g_unix_mount_points_changed_since(). If more mount points have the same mount path, the last matching mount point is returned. a #GUnixMountPoint, or %NULL if no match is found. path for a possible unix mount point. guint64 to contain a timestamp. Checks if the unix mount points have changed since a given unix time. %TRUE if the mount points have changed since @time. guint64 to contain a timestamp. Gets a #GList of #GUnixMountPoint containing the unix mount points. If @time_read is set, it will be filled with the mount timestamp, allowing for checking if the mounts have changed with g_unix_mount_points_changed_since(). a #GList of the UNIX mountpoints. guint64 to contain a timestamp. Checks if the unix mounts have changed since a given unix time. %TRUE if the mounts have changed since @time. guint64 to contain a timestamp. Gets a #GList of #GUnixMountEntry containing the unix mounts. If @time_read is set, it will be filled with the mount timestamp, allowing for checking if the mounts have changed with g_unix_mounts_changed_since(). a #GList of the UNIX mounts. guint64 to contain a timestamp, or %NULL gtkada-24.0.0/contrib/Gtk-3.0.gir000066400000000000000000445566641446021174000162530ustar00rootroot00000000000000 A #GtkAllocation-struct of a widget represents region which has been allocated to the widget by its parent. It is a subregion of its parents allocation. See [GtkWidget’s geometry management section][geometry-management] for more information. The GtkAboutDialog offers a simple way to display information about a program like its logo, name, copyright, website and license. It is also possible to give credits to the authors, documenters, translators and artists who have worked on the program. An about dialog is typically opened when the user selects the `About` option from the `Help` menu. All parts of the dialog are optional. About dialogs often contain links and email addresses. GtkAboutDialog displays these as clickable links. By default, it calls gtk_show_uri_on_window() when a user clicks one. The behaviour can be overridden with the #GtkAboutDialog::activate-link signal. To specify a person with an email address, use a string like "Edgar Allan Poe <edgar\@poe.com>". To specify a website with a title, use a string like "GTK+ team http://www.gtk.org". To make constructing a GtkAboutDialog as convenient as possible, you can use the function gtk_show_about_dialog() which constructs and shows a dialog and keeps it around so that it can be shown again. Note that GTK+ sets a default title of `_("About %s")` on the dialog window (where \%s is replaced by the name of the application, but in order to ensure proper translation of the title, applications should set the title property explicitly when constructing a GtkAboutDialog, as shown in the following example: |[<!-- language="C" --> GdkPixbuf *example_logo = gdk_pixbuf_new_from_file ("./logo.png", NULL); gtk_show_about_dialog (NULL, "program-name", "ExampleCode", "logo", example_logo, "title", _("About ExampleCode"), NULL); ]| It is also possible to show a #GtkAboutDialog like any other #GtkDialog, e.g. using gtk_dialog_run(). In this case, you might need to know that the “Close” button returns the #GTK_RESPONSE_CANCEL response id. Creates a new #GtkAboutDialog. a newly created #GtkAboutDialog Creates a new section in the Credits page. A #GtkAboutDialog The name of the section The people who belong to that section Returns the string which are displayed in the artists tab of the secondary credits dialog. A %NULL-terminated string array containing the artists. The array is owned by the about dialog and must not be modified. a #GtkAboutDialog Returns the string which are displayed in the authors tab of the secondary credits dialog. A %NULL-terminated string array containing the authors. The array is owned by the about dialog and must not be modified. a #GtkAboutDialog Returns the comments string. The comments. The string is owned by the about dialog and must not be modified. a #GtkAboutDialog Returns the copyright string. The copyright string. The string is owned by the about dialog and must not be modified. a #GtkAboutDialog Returns the string which are displayed in the documenters tab of the secondary credits dialog. A %NULL-terminated string array containing the documenters. The array is owned by the about dialog and must not be modified. a #GtkAboutDialog Returns the license information. The license information. The string is owned by the about dialog and must not be modified. a #GtkAboutDialog Retrieves the license set using gtk_about_dialog_set_license_type() a #GtkLicense value a #GtkAboutDialog Returns the pixbuf displayed as logo in the about dialog. the pixbuf displayed as logo. The pixbuf is owned by the about dialog. If you want to keep a reference to it, you have to call g_object_ref() on it. a #GtkAboutDialog Returns the icon name displayed as logo in the about dialog. the icon name displayed as logo. The string is owned by the dialog. If you want to keep a reference to it, you have to call g_strdup() on it. a #GtkAboutDialog Returns the program name displayed in the about dialog. The program name. The string is owned by the about dialog and must not be modified. a #GtkAboutDialog Returns the translator credits string which is displayed in the translators tab of the secondary credits dialog. The translator credits string. The string is owned by the about dialog and must not be modified. a #GtkAboutDialog Returns the version string. The version string. The string is owned by the about dialog and must not be modified. a #GtkAboutDialog Returns the website URL. The website URL. The string is owned by the about dialog and must not be modified. a #GtkAboutDialog Returns the label used for the website link. The label used for the website link. The string is owned by the about dialog and must not be modified. a #GtkAboutDialog Returns whether the license text in @about is automatically wrapped. %TRUE if the license text is wrapped a #GtkAboutDialog Sets the strings which are displayed in the artists tab of the secondary credits dialog. a #GtkAboutDialog a %NULL-terminated array of strings Sets the strings which are displayed in the authors tab of the secondary credits dialog. a #GtkAboutDialog a %NULL-terminated array of strings Sets the comments string to display in the about dialog. This should be a short string of one or two lines. a #GtkAboutDialog a comments string Sets the copyright string to display in the about dialog. This should be a short string of one or two lines. a #GtkAboutDialog the copyright string Sets the strings which are displayed in the documenters tab of the secondary credits dialog. a #GtkAboutDialog a %NULL-terminated array of strings Sets the license information to be displayed in the secondary license dialog. If @license is %NULL, the license button is hidden. a #GtkAboutDialog the license information or %NULL Sets the license of the application showing the @about dialog from a list of known licenses. This function overrides the license set using gtk_about_dialog_set_license(). a #GtkAboutDialog the type of license Sets the pixbuf to be displayed as logo in the about dialog. If it is %NULL, the default window icon set with gtk_window_set_default_icon() will be used. a #GtkAboutDialog a #GdkPixbuf, or %NULL Sets the pixbuf to be displayed as logo in the about dialog. If it is %NULL, the default window icon set with gtk_window_set_default_icon() will be used. a #GtkAboutDialog an icon name, or %NULL Sets the name to display in the about dialog. If this is not set, it defaults to g_get_application_name(). a #GtkAboutDialog the program name Sets the translator credits string which is displayed in the translators tab of the secondary credits dialog. The intended use for this string is to display the translator of the language which is currently used in the user interface. Using gettext(), a simple way to achieve that is to mark the string for translation: |[<!-- language="C" --> GtkWidget *about = gtk_about_dialog_new (); gtk_about_dialog_set_translator_credits (GTK_ABOUT_DIALOG (about), _("translator-credits")); ]| It is a good idea to use the customary msgid “translator-credits” for this purpose, since translators will already know the purpose of that msgid, and since #GtkAboutDialog will detect if “translator-credits” is untranslated and hide the tab. a #GtkAboutDialog the translator credits Sets the version string to display in the about dialog. a #GtkAboutDialog the version string Sets the URL to use for the website link. a #GtkAboutDialog a URL string starting with "http://" Sets the label to be used for the website link. a #GtkAboutDialog the label used for the website link Sets whether the license text in @about is automatically wrapped. a #GtkAboutDialog whether to wrap the license The people who contributed artwork to the program, as a %NULL-terminated array of strings. Each string may contain email addresses and URLs, which will be displayed as links, see the introduction for more details. The authors of the program, as a %NULL-terminated array of strings. Each string may contain email addresses and URLs, which will be displayed as links, see the introduction for more details. Comments about the program. This string is displayed in a label in the main dialog, thus it should be a short explanation of the main purpose of the program, not a detailed list of features. Copyright information for the program. The people documenting the program, as a %NULL-terminated array of strings. Each string may contain email addresses and URLs, which will be displayed as links, see the introduction for more details. The license of the program. This string is displayed in a text view in a secondary dialog, therefore it is fine to use a long multi-paragraph text. Note that the text is only wrapped in the text view if the "wrap-license" property is set to %TRUE; otherwise the text itself must contain the intended linebreaks. When setting this property to a non-%NULL value, the #GtkAboutDialog:license-type property is set to %GTK_LICENSE_CUSTOM as a side effect. The license of the program, as a value of the %GtkLicense enumeration. The #GtkAboutDialog will automatically fill out a standard disclaimer and link the user to the appropriate online resource for the license text. If %GTK_LICENSE_UNKNOWN is used, the link used will be the same specified in the #GtkAboutDialog:website property. If %GTK_LICENSE_CUSTOM is used, the current contents of the #GtkAboutDialog:license property are used. For any other #GtkLicense value, the contents of the #GtkAboutDialog:license property are also set by this property as a side effect. A logo for the about box. If it is %NULL, the default window icon set with gtk_window_set_default_icon() will be used. A named icon to use as the logo for the about box. This property overrides the #GtkAboutDialog:logo property. The name of the program. If this is not set, it defaults to g_get_application_name(). Credits to the translators. This string should be marked as translatable. The string may contain email addresses and URLs, which will be displayed as links, see the introduction for more details. The version of the program. The URL for the link to the website of the program. This should be a string starting with "http://. The label for the link to the website of the program. Whether to wrap the text in the license dialog. The signal which gets emitted to activate a URI. Applications may connect to it to override the default behaviour, which is to call gtk_show_uri_on_window(). %TRUE if the link has been activated the URI that is activated Accelerator flags used with gtk_accel_group_connect(). Accelerator is visible Accelerator not removable Mask A #GtkAccelGroup represents a group of keyboard accelerators, typically attached to a toplevel #GtkWindow (with gtk_window_add_accel_group()). Usually you won’t need to create a #GtkAccelGroup directly; instead, when using #GtkUIManager, GTK+ automatically sets up the accelerators for your menus in the ui manager’s #GtkAccelGroup. Note that “accelerators” are different from “mnemonics”. Accelerators are shortcuts for activating a menu item; they appear alongside the menu item they’re a shortcut for. For example “Ctrl+Q” might appear alongside the “Quit” menu item. Mnemonics are shortcuts for GUI elements such as text entries or buttons; they appear as underlined characters. See gtk_label_new_with_mnemonic(). Menu items can have both accelerators and mnemonics, of course. Creates a new #GtkAccelGroup. a new #GtkAccelGroup object Finds the #GtkAccelGroup to which @closure is connected; see gtk_accel_group_connect(). the #GtkAccelGroup to which @closure is connected, or %NULL a #GClosure Finds the first accelerator in @accel_group that matches @accel_key and @accel_mods, and activates it. %TRUE if an accelerator was activated and handled this keypress a #GtkAccelGroup the quark for the accelerator name the #GObject, usually a #GtkWindow, on which to activate the accelerator accelerator keyval from a key event keyboard state mask from a key event Installs an accelerator in this group. When @accel_group is being activated in response to a call to gtk_accel_groups_activate(), @closure will be invoked if the @accel_key and @accel_mods from gtk_accel_groups_activate() match those of this connection. The signature used for the @closure is that of #GtkAccelGroupActivate. Note that, due to implementation details, a single closure can only be connected to one accelerator group. the accelerator group to install an accelerator in key value of the accelerator modifier combination of the accelerator a flag mask to configure this accelerator closure to be executed upon accelerator activation Installs an accelerator in this group, using an accelerator path to look up the appropriate key and modifiers (see gtk_accel_map_add_entry()). When @accel_group is being activated in response to a call to gtk_accel_groups_activate(), @closure will be invoked if the @accel_key and @accel_mods from gtk_accel_groups_activate() match the key and modifiers for the path. The signature used for the @closure is that of #GtkAccelGroupActivate. Note that @accel_path string will be stored in a #GQuark. Therefore, if you pass a static string, you can save some memory by interning it first with g_intern_static_string(). the accelerator group to install an accelerator in path used for determining key and modifiers closure to be executed upon accelerator activation Removes an accelerator previously installed through gtk_accel_group_connect(). Since 2.20 @closure can be %NULL. %TRUE if the closure was found and got disconnected the accelerator group to remove an accelerator from the closure to remove from this accelerator group, or %NULL to remove all closures Removes an accelerator previously installed through gtk_accel_group_connect(). %TRUE if there was an accelerator which could be removed, %FALSE otherwise the accelerator group to install an accelerator in key value of the accelerator modifier combination of the accelerator Finds the first entry in an accelerator group for which @find_func returns %TRUE and returns its #GtkAccelKey. the key of the first entry passing @find_func. The key is owned by GTK+ and must not be freed. a #GtkAccelGroup a function to filter the entries of @accel_group with data to pass to @find_func Locks are added and removed using gtk_accel_group_lock() and gtk_accel_group_unlock(). %TRUE if there are 1 or more locks on the @accel_group, %FALSE otherwise. a #GtkAccelGroup Gets a #GdkModifierType representing the mask for this @accel_group. For example, #GDK_CONTROL_MASK, #GDK_SHIFT_MASK, etc. the modifier mask for this accel group. a #GtkAccelGroup Locks the given accelerator group. Locking an acelerator group prevents the accelerators contained within it to be changed during runtime. Refer to gtk_accel_map_change_entry() about runtime accelerator changes. If called more than once, @accel_group remains locked until gtk_accel_group_unlock() has been called an equivalent number of times. a #GtkAccelGroup Queries an accelerator group for all entries matching @accel_key and @accel_mods. an array of @n_entries #GtkAccelGroupEntry elements, or %NULL. The array is owned by GTK+ and must not be freed. the accelerator group to query key value of the accelerator modifier combination of the accelerator location to return the number of entries found, or %NULL Undoes the last call to gtk_accel_group_lock() on this @accel_group. a #GtkAccelGroup The accel-activate signal is an implementation detail of #GtkAccelGroup and not meant to be used by applications. %TRUE if the accelerator was activated the object on which the accelerator was activated the accelerator keyval the modifier combination of the accelerator The accel-changed signal is emitted when an entry is added to or removed from the accel group. Widgets like #GtkAccelLabel which display an associated accelerator should connect to this signal, and rebuild their visual representation if the @accel_closure is theirs. the accelerator keyval the modifier combination of the accelerator the #GClosure of the accelerator The parent class. The accelerator keyval The accelerator modifiers The accelerator flags The #GtkAccelLabel widget is a subclass of #GtkLabel that also displays an accelerator key on the right of the label text, e.g. “Ctrl+S”. It is commonly used in menus to show the keyboard short-cuts for commands. The accelerator key to display is typically not set explicitly (although it can be, with gtk_accel_label_set_accel()). Instead, the #GtkAccelLabel displays the accelerators which have been added to a particular widget. This widget is set by calling gtk_accel_label_set_accel_widget(). For example, a #GtkMenuItem widget may have an accelerator added to emit the “activate” signal when the “Ctrl+S” key combination is pressed. A #GtkAccelLabel is created and added to the #GtkMenuItem, and gtk_accel_label_set_accel_widget() is called with the #GtkMenuItem as the second argument. The #GtkAccelLabel will now display “Ctrl+S” after its label. Note that creating a #GtkMenuItem with gtk_menu_item_new_with_label() (or one of the similar functions for #GtkCheckMenuItem and #GtkRadioMenuItem) automatically adds a #GtkAccelLabel to the #GtkMenuItem and calls gtk_accel_label_set_accel_widget() to set it up for you. A #GtkAccelLabel will only display accelerators which have %GTK_ACCEL_VISIBLE set (see #GtkAccelFlags). A #GtkAccelLabel can display multiple accelerators and even signal names, though it is almost always used to display just one accelerator key. ## Creating a simple menu item with an accelerator key. |[<!-- language="C" --> GtkWidget *window = gtk_window_new (GTK_WINDOW_TOPLEVEL); GtkWidget *menu = gtk_menu_new (); GtkWidget *save_item; GtkAccelGroup *accel_group; // Create a GtkAccelGroup and add it to the window. accel_group = gtk_accel_group_new (); gtk_window_add_accel_group (GTK_WINDOW (window), accel_group); // Create the menu item using the convenience function. save_item = gtk_menu_item_new_with_label ("Save"); gtk_widget_show (save_item); gtk_container_add (GTK_CONTAINER (menu), save_item); // Now add the accelerator to the GtkMenuItem. Note that since we // called gtk_menu_item_new_with_label() to create the GtkMenuItem // the GtkAccelLabel is automatically set up to display the // GtkMenuItem accelerators. We just need to make sure we use // GTK_ACCEL_VISIBLE here. gtk_widget_add_accelerator (save_item, "activate", accel_group, GDK_KEY_s, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); ]| # CSS nodes |[<!-- language="plain" --> label ╰── accelerator ]| Like #GtkLabel, GtkAccelLabel has a main CSS node with the name label. It adds a subnode with name accelerator. Creates a new #GtkAccelLabel. a new #GtkAccelLabel. the label string. Must be non-%NULL. Gets the keyval and modifier mask set with gtk_accel_label_set_accel(). a #GtkAccelLabel return location for the keyval return location for the modifier mask Fetches the widget monitored by this accelerator label. See gtk_accel_label_set_accel_widget(). the object monitored by the accelerator label, or %NULL. a #GtkAccelLabel Returns the width needed to display the accelerator key(s). This is used by menus to align all of the #GtkMenuItem widgets, and shouldn't be needed by applications. the width needed to display the accelerator key(s). a #GtkAccelLabel. Recreates the string representing the accelerator keys. This should not be needed since the string is automatically updated whenever accelerators are added or removed from the associated widget. always returns %FALSE. a #GtkAccelLabel. Manually sets a keyval and modifier mask as the accelerator rendered by @accel_label. If a keyval and modifier are explicitly set then these values are used regardless of any associated accel closure or widget. Providing an @accelerator_key of 0 removes the manual setting. a #GtkAccelLabel a keyval, or 0 the modifier mask for the accel Sets the closure to be monitored by this accelerator label. The closure must be connected to an accelerator group; see gtk_accel_group_connect(). Passing %NULL for @accel_closure will dissociate @accel_label from its current closure, if any. a #GtkAccelLabel the closure to monitor for accelerator changes, or %NULL Sets the widget to be monitored by this accelerator label. Passing %NULL for @accel_widget will dissociate @accel_label from its current widget, if any. a #GtkAccelLabel the widget to be monitored, or %NULL Accelerator maps are used to define runtime configurable accelerators. Functions for manipulating them are are usually used by higher level convenience mechanisms like #GtkUIManager and are thus considered “low-level”. You’ll want to use them if you’re manually creating menus that should have user-configurable accelerators. An accelerator is uniquely defined by: - accelerator path - accelerator key - accelerator modifiers The accelerator path must consist of “<WINDOWTYPE>/Category1/Category2/.../Action”, where WINDOWTYPE should be a unique application-specific identifier that corresponds to the kind of window the accelerator is being used in, e.g. “Gimp-Image”, “Abiword-Document” or “Gnumeric-Settings”. The “Category1/.../Action” portion is most appropriately chosen by the action the accelerator triggers, i.e. for accelerators on menu items, choose the item’s menu path, e.g. “File/Save As”, “Image/View/Zoom” or “Edit/Select All”. So a full valid accelerator path may look like: “<Gimp-Toolbox>/File/Dialogs/Tool Options...”. All accelerators are stored inside one global #GtkAccelMap that can be obtained using gtk_accel_map_get(). See [Monitoring changes][monitoring-changes] for additional details. # Manipulating accelerators New accelerators can be added using gtk_accel_map_add_entry(). To search for specific accelerator, use gtk_accel_map_lookup_entry(). Modifications of existing accelerators should be done using gtk_accel_map_change_entry(). In order to avoid having some accelerators changed, they can be locked using gtk_accel_map_lock_path(). Unlocking is done using gtk_accel_map_unlock_path(). # Saving and loading accelerator maps Accelerator maps can be saved to and loaded from some external resource. For simple saving and loading from file, gtk_accel_map_save() and gtk_accel_map_load() are provided. Saving and loading can also be done by providing file descriptor to gtk_accel_map_save_fd() and gtk_accel_map_load_fd(). # Monitoring changes #GtkAccelMap object is only useful for monitoring changes of accelerators. By connecting to #GtkAccelMap::changed signal, one can monitor changes of all accelerators. It is also possible to monitor only single accelerator path by using it as a detail of the #GtkAccelMap::changed signal. Registers a new accelerator with the global accelerator map. This function should only be called once per @accel_path with the canonical @accel_key and @accel_mods for this path. To change the accelerator during runtime programatically, use gtk_accel_map_change_entry(). Set @accel_key and @accel_mods to 0 to request a removal of the accelerator. Note that @accel_path string will be stored in a #GQuark. Therefore, if you pass a static string, you can save some memory by interning it first with g_intern_static_string(). valid accelerator path the accelerator key the accelerator modifiers Adds a filter to the global list of accel path filters. Accel map entries whose accel path matches one of the filters are skipped by gtk_accel_map_foreach(). This function is intended for GTK+ modules that create their own menus, but don’t want them to be saved into the applications accelerator map dump. a pattern (see #GPatternSpec) Changes the @accel_key and @accel_mods currently associated with @accel_path. Due to conflicts with other accelerators, a change may not always be possible, @replace indicates whether other accelerators may be deleted to resolve such conflicts. A change will only occur if all conflicts could be resolved (which might not be the case if conflicting accelerators are locked). Successful changes are indicated by a %TRUE return value. Note that @accel_path string will be stored in a #GQuark. Therefore, if you pass a static string, you can save some memory by interning it first with g_intern_static_string(). %TRUE if the accelerator could be changed, %FALSE otherwise a valid accelerator path the new accelerator key the new accelerator modifiers %TRUE if other accelerators may be deleted upon conflicts Loops over the entries in the accelerator map whose accel path doesn’t match any of the filters added with gtk_accel_map_add_filter(), and execute @foreach_func on each. The signature of @foreach_func is that of #GtkAccelMapForeach, the @changed parameter indicates whether this accelerator was changed during runtime (thus, would need saving during an accelerator map dump). data to be passed into @foreach_func function to be executed for each accel map entry which is not filtered out Loops over all entries in the accelerator map, and execute @foreach_func on each. The signature of @foreach_func is that of #GtkAccelMapForeach, the @changed parameter indicates whether this accelerator was changed during runtime (thus, would need saving during an accelerator map dump). data to be passed into @foreach_func function to be executed for each accel map entry Gets the singleton global #GtkAccelMap object. This object is useful only for notification of changes to the accelerator map via the ::changed signal; it isn’t a parameter to the other accelerator map functions. the global #GtkAccelMap object Parses a file previously saved with gtk_accel_map_save() for accelerator specifications, and propagates them accordingly. a file containing accelerator specifications, in the GLib file name encoding Filedescriptor variant of gtk_accel_map_load(). Note that the file descriptor will not be closed by this function. a valid readable file descriptor #GScanner variant of gtk_accel_map_load(). a #GScanner which has already been provided with an input file Locks the given accelerator path. If the accelerator map doesn’t yet contain an entry for @accel_path, a new one is created. Locking an accelerator path prevents its accelerator from being changed during runtime. A locked accelerator path can be unlocked by gtk_accel_map_unlock_path(). Refer to gtk_accel_map_change_entry() for information about runtime accelerator changes. If called more than once, @accel_path remains locked until gtk_accel_map_unlock_path() has been called an equivalent number of times. Note that locking of individual accelerator paths is independent from locking the #GtkAccelGroup containing them. For runtime accelerator changes to be possible, both the accelerator path and its #GtkAccelGroup have to be unlocked. a valid accelerator path Looks up the accelerator entry for @accel_path and fills in @key. %TRUE if @accel_path is known, %FALSE otherwise a valid accelerator path the accelerator key to be filled in (optional) Saves current accelerator specifications (accelerator path, key and modifiers) to @file_name. The file is written in a format suitable to be read back in by gtk_accel_map_load(). the name of the file to contain accelerator specifications, in the GLib file name encoding Filedescriptor variant of gtk_accel_map_save(). Note that the file descriptor will not be closed by this function. a valid writable file descriptor Undoes the last call to gtk_accel_map_lock_path() on this @accel_path. Refer to gtk_accel_map_lock_path() for information about accelerator path locking. a valid accelerator path Notifies of a change in the global accelerator map. The path is also used as the detail for the signal, so it is possible to connect to changed::`accel_path`. the path of the accelerator that changed the key value for the new accelerator the modifier mask for the new accelerator User data passed to gtk_accel_map_foreach() or gtk_accel_map_foreach_unfiltered() Accel path of the current accelerator Key of the current accelerator Modifiers of the current accelerator Changed flag of the accelerator (if %TRUE, accelerator has changed during runtime and would need to be saved during an accelerator dump) The #GtkAccessible class is the base class for accessible implementations for #GtkWidget subclasses. It is a thin wrapper around #AtkObject, which adds facilities for associating a widget with its accessible object. An accessible implementation for a third-party widget should derive from #GtkAccessible and implement the suitable interfaces from ATK, such as #AtkText or #AtkSelection. To establish the connection between the widget class and its corresponding acccessible implementation, override the get_accessible vfunc in #GtkWidgetClass. This function specifies the callback function to be called when the widget corresponding to a GtkAccessible is destroyed. Use gtk_accessible_set_widget() and its vfuncs. a #GtkAccessible This function specifies the callback function to be called when the widget corresponding to a GtkAccessible is destroyed. Use gtk_accessible_set_widget() and its vfuncs. a #GtkAccessible Gets the #GtkWidget corresponding to the #GtkAccessible. The returned widget does not have a reference added, so you do not need to unref it. pointer to the #GtkWidget corresponding to the #GtkAccessible, or %NULL. a #GtkAccessible Sets the #GtkWidget corresponding to the #GtkAccessible. @accessible will not hold a reference to @widget. It is the caller’s responsibility to ensure that when @widget is destroyed, the widget is unset by calling this function again with @widget set to %NULL. a #GtkAccessible a #GtkWidget or %NULL to unset a #GtkAccessible > In GTK+ 3.10, GtkAction has been deprecated. Use #GAction > instead, and associate actions with #GtkActionable widgets. Use > #GMenuModel for creating menus with gtk_menu_new_from_model(). Actions represent operations that the user can be perform, along with some information how it should be presented in the interface. Each action provides methods to create icons, menu items and toolbar items representing itself. As well as the callback that is called when the action gets activated, the following also gets associated with the action: - a name (not translated, for path lookup) - a label (translated, for display) - an accelerator - whether label indicates a stock id - a tooltip (optional, translated) - a toolbar label (optional, shorter than label) The action will also have some state information: - visible (shown/hidden) - sensitive (enabled/disabled) Apart from regular actions, there are [toggle actions][GtkToggleAction], which can be toggled between two states and [radio actions][GtkRadioAction], of which only one in a group can be in the “active” state. Other actions can be implemented as #GtkAction subclasses. Each action can have one or more proxy widgets. To act as an action proxy, widget needs to implement #GtkActivatable interface. Proxies mirror the state of the action and should change when the action’s state changes. Properties that are always mirrored by proxies are #GtkAction:sensitive and #GtkAction:visible. #GtkAction:gicon, #GtkAction:icon-name, #GtkAction:label, #GtkAction:short-label and #GtkAction:stock-id properties are only mirorred if proxy widget has #GtkActivatable:use-action-appearance property set to %TRUE. When the proxy is activated, it should activate its action. Creates a new #GtkAction object. To add the action to a #GtkActionGroup and set the accelerator for the action, call gtk_action_group_add_action_with_accel(). See the [UI Definition section][XML-UI] for information on allowed action names. Use #GAction instead, associating it to a widget with #GtkActionable or creating a #GtkMenu with gtk_menu_new_from_model() a new #GtkAction A unique name for the action the label displayed in menu items and on buttons, or %NULL a tooltip for the action, or %NULL the stock icon to display in widgets representing the action, or %NULL Emits the “activate” signal on the specified action, if it isn't insensitive. This gets called by the proxy widgets when they get activated. It can also be used to manually activate an action. Use g_action_group_activate_action() on a #GAction instead the action object If @action provides a #GtkMenu widget as a submenu for the menu item or the toolbar item it creates, this function returns an instance of that menu. Use #GAction and #GMenuModel instead, and create a #GtkMenu with gtk_menu_new_from_model() the menu item provided by the action, or %NULL. a #GtkAction Creates a menu item widget that proxies for the given action. Use g_menu_item_new() and associate it with a #GAction instead. a menu item connected to the action. the action object Creates a toolbar item widget that proxies for the given action. Use a #GtkToolItem and associate it with a #GAction using gtk_actionable_set_action_name() instead a toolbar item connected to the action. the action object Emits the “activate” signal on the specified action, if it isn't insensitive. This gets called by the proxy widgets when they get activated. It can also be used to manually activate an action. Use g_action_group_activate_action() on a #GAction instead the action object Disable activation signals from the action This is needed when updating the state of your proxy #GtkActivatable widget could result in calling gtk_action_activate(), this is a convenience function to avoid recursing in those cases (updating toggle state for instance). Use g_simple_action_set_enabled() to disable the #GSimpleAction instead a #GtkAction Installs the accelerator for @action if @action has an accel path and group. See gtk_action_set_accel_path() and gtk_action_set_accel_group() Since multiple proxies may independently trigger the installation of the accelerator, the @action counts the number of times this function has been called and doesn’t remove the accelerator until gtk_action_disconnect_accelerator() has been called as many times. Use #GAction and the accelerator group on an associated #GtkMenu instead a #GtkAction This function is intended for use by action implementations to create icons displayed in the proxy widgets. Use g_menu_item_set_icon() to set an icon on a #GMenuItem, or gtk_container_add() to add a #GtkImage to a #GtkButton a widget that displays the icon for this action. the action object the size of the icon (#GtkIconSize) that should be created. If @action provides a #GtkMenu widget as a submenu for the menu item or the toolbar item it creates, this function returns an instance of that menu. Use #GAction and #GMenuModel instead, and create a #GtkMenu with gtk_menu_new_from_model() the menu item provided by the action, or %NULL. a #GtkAction Creates a menu item widget that proxies for the given action. Use g_menu_item_new() and associate it with a #GAction instead. a menu item connected to the action. the action object Creates a toolbar item widget that proxies for the given action. Use a #GtkToolItem and associate it with a #GAction using gtk_actionable_set_action_name() instead a toolbar item connected to the action. the action object Undoes the effect of one call to gtk_action_connect_accelerator(). Use #GAction and the accelerator group on an associated #GtkMenu instead a #GtkAction Returns the accel closure for this action. Use #GAction and #GtkMenu instead, which have no equivalent for getting the accel closure the accel closure for this action. The returned closure is owned by GTK+ and must not be unreffed or modified. the action object Returns the accel path for this action. Use #GAction and the accelerator path on an associated #GtkMenu instead the accel path for this action, or %NULL if none is set. The returned string is owned by GTK+ and must not be freed or modified. the action object Returns whether @action's menu item proxies will always show their image, if available. Use g_menu_item_get_attribute_value() on a #GMenuItem instead %TRUE if the menu item proxies will always show their image a #GtkAction Gets the gicon of @action. Use #GAction instead, and g_menu_item_get_attribute_value() to get an icon from a #GMenuItem associated with a #GAction The action’s #GIcon if one is set. a #GtkAction Gets the icon name of @action. Use #GAction instead, and g_menu_item_get_attribute_value() to get an icon from a #GMenuItem associated with a #GAction the icon name a #GtkAction Checks whether @action is important or not Use #GAction instead, and control and monitor whether labels are shown directly whether @action is important a #GtkAction Gets the label text of @action. Use #GAction instead, and get a label from a menu item with g_menu_item_get_attribute_value(). For #GtkActionable widgets, use the widget-specific API to get a label the label text a #GtkAction Returns the name of the action. Use g_action_get_name() on a #GAction instead the name of the action. The string belongs to GTK+ and should not be freed. the action object Returns the proxy widgets for an action. See also gtk_activatable_get_related_action(). a #GSList of proxy widgets. The list is owned by GTK+ and must not be modified. the action object Returns whether the action itself is sensitive. Note that this doesn’t necessarily mean effective sensitivity. See gtk_action_is_sensitive() for that. Use g_action_get_enabled() on a #GAction instead %TRUE if the action itself is sensitive. the action object Gets the short label text of @action. Use #GAction instead, which has no equivalent of short labels the short label text. a #GtkAction Gets the stock id of @action. Use #GAction instead, which has no equivalent of stock items the stock id a #GtkAction Gets the tooltip text of @action. Use #GAction instead, and get tooltips from associated #GtkActionable widgets with gtk_widget_get_tooltip_text() the tooltip text a #GtkAction Returns whether the action itself is visible. Note that this doesn’t necessarily mean effective visibility. See gtk_action_is_sensitive() for that. Use #GAction instead, and control and monitor the state of #GtkActionable widgets directly %TRUE if the action itself is visible. the action object Checks whether @action is visible when horizontal Use #GAction instead, and control and monitor the visibility of associated widgets and menu items directly whether @action is visible when horizontal a #GtkAction Checks whether @action is visible when horizontal Use #GAction instead, and control and monitor the visibility of associated widgets and menu items directly whether @action is visible when horizontal a #GtkAction Returns whether the action is effectively sensitive. Use g_action_get_enabled() on a #GAction instead %TRUE if the action and its associated action group are both sensitive. the action object Returns whether the action is effectively visible. Use #GAction instead, and control and monitor the state of #GtkActionable widgets directly %TRUE if the action and its associated action group are both visible. the action object Sets the #GtkAccelGroup in which the accelerator for this action will be installed. Use #GAction and the accelerator group on an associated #GtkMenu instead the action object a #GtkAccelGroup or %NULL Sets the accel path for this action. All proxy widgets associated with the action will have this accel path, so that their accelerators are consistent. Note that @accel_path string will be stored in a #GQuark. Therefore, if you pass a static string, you can save some memory by interning it first with g_intern_static_string(). Use #GAction and the accelerator path on an associated #GtkMenu instead the action object the accelerator path Sets whether @action's menu item proxies will ignore the #GtkSettings:gtk-menu-images setting and always show their image, if available. Use this if the menu item would be useless or hard to use without their image. Use g_menu_item_set_icon() on a #GMenuItem instead, if the item should have an image a #GtkAction %TRUE if menuitem proxies should always show their image Sets the icon of @action. Use #GAction instead, and g_menu_item_set_icon() to set an icon on a #GMenuItem associated with a #GAction, or gtk_container_add() to add a #GtkImage to a #GtkButton a #GtkAction the #GIcon to set Sets the icon name on @action Use #GAction instead, and g_menu_item_set_icon() to set an icon on a #GMenuItem associated with a #GAction, or gtk_container_add() to add a #GtkImage to a #GtkButton a #GtkAction the icon name to set Sets whether the action is important, this attribute is used primarily by toolbar items to decide whether to show a label or not. Use #GAction instead, and control and monitor whether labels are shown directly the action object %TRUE to make the action important Sets the label of @action. Use #GAction instead, and set a label on a menu item with g_menu_item_set_label(). For #GtkActionable widgets, use the widget-specific API to set a label a #GtkAction the label text to set Sets the :sensitive property of the action to @sensitive. Note that this doesn’t necessarily mean effective sensitivity. See gtk_action_is_sensitive() for that. Use g_simple_action_set_enabled() on a #GSimpleAction instead the action object %TRUE to make the action sensitive Sets a shorter label text on @action. Use #GAction instead, which has no equivalent of short labels a #GtkAction the label text to set Sets the stock id on @action Use #GAction instead, which has no equivalent of stock items a #GtkAction the stock id Sets the tooltip text on @action Use #GAction instead, and set tooltips on associated #GtkActionable widgets with gtk_widget_set_tooltip_text() a #GtkAction the tooltip text Sets the :visible property of the action to @visible. Note that this doesn’t necessarily mean effective visibility. See gtk_action_is_visible() for that. Use #GAction instead, and control and monitor the state of #GtkActionable widgets directly the action object %TRUE to make the action visible Sets whether @action is visible when horizontal Use #GAction instead, and control and monitor the visibility of associated widgets and menu items directly a #GtkAction whether the action is visible horizontally Sets whether @action is visible when vertical Use #GAction instead, and control and monitor the visibility of associated widgets and menu items directly a #GtkAction whether the action is visible vertically Reenable activation signals from the action Use g_simple_action_set_enabled() to enable the #GSimpleAction instead a #GtkAction The GtkActionGroup this GtkAction is associated with, or NULL (for internal use). Lookup the #GAction using g_action_map_lookup_action() instead If %TRUE, the action's menu item proxies will ignore the #GtkSettings:gtk-menu-images setting and always show their image, if available. Use this property if the menu item would be useless or hard to use without their image. There is no corresponding replacement when using #GAction The #GIcon displayed in the #GtkAction. Note that the stock icon is preferred, if the #GtkAction:stock-id property holds the id of an existing stock icon. This is an appearance property and thus only applies if #GtkActivatable:use-action-appearance is %TRUE. Use the "icon" attribute on a #GMenuItem instead When TRUE, empty menu proxies for this action are hidden. There is no corresponding replacement when using #GAction The name of the icon from the icon theme. Note that the stock icon is preferred, if the #GtkAction:stock-id property holds the id of an existing stock icon, and the #GIcon is preferred if the #GtkAction:gicon property is set. This is an appearance property and thus only applies if #GtkActivatable:use-action-appearance is %TRUE. Use the "icon" attribute on a #GMenuItem instead Whether the action is considered important. When TRUE, toolitem proxies for this action show text in GTK_TOOLBAR_BOTH_HORIZ mode. There is no corresponding replacement when using #GAction The label used for menu items and buttons that activate this action. If the label is %NULL, GTK+ uses the stock label specified via the stock-id property. This is an appearance property and thus only applies if #GtkActivatable:use-action-appearance is %TRUE. Use the "label" attribute on #GMenuItem instead A unique name for the action. Use #GAction:name instead Whether the action is enabled. Use #GAction:enabled and #GSimpleAction:enabled instead A shorter label that may be used on toolbar buttons. This is an appearance property and thus only applies if #GtkActivatable:use-action-appearance is %TRUE. There is no corresponding replacement when using #GAction The stock icon displayed in widgets representing this action. This is an appearance property and thus only applies if #GtkActivatable:use-action-appearance is %TRUE. There is no corresponding replacement when using #GAction A tooltip for this action. Use gtk_widget_set_tooltip_text() instead Whether the action is visible. There is no corresponding replacement when using #GAction Whether the toolbar item is visible when the toolbar is in a horizontal orientation. There is no corresponding replacement when using #GAction When %TRUE, toolitem proxies for this action are represented in the toolbar overflow menu. There is no corresponding replacement when using #GAction Whether the toolbar item is visible when the toolbar is in a vertical orientation. There is no corresponding replacement when using #GAction The "activate" signal is emitted when the action is activated. Use #GSimpleAction::activate instead GtkActionBar is designed to present contextual actions. It is expected to be displayed below the content and expand horizontally to fill the area. It allows placing children at the start or the end. In addition, it contains an internal centered box which is centered with respect to the full width of the box, even if the children at either side take up different amounts of space. # CSS nodes GtkActionBar has a single CSS node with name actionbar. Creates a new #GtkActionBar widget. a new #GtkActionBar Retrieves the center bar widget of the bar. the center #GtkWidget or %NULL. a #GtkActionBar Adds @child to @action_bar, packed with reference to the end of the @action_bar. A #GtkActionBar the #GtkWidget to be added to @action_bar Adds @child to @action_bar, packed with reference to the start of the @action_bar. A #GtkActionBar the #GtkWidget to be added to @action_bar Sets the center widget for the #GtkActionBar. a #GtkActionBar a widget to use for the center The parent class. the action object a menu item connected to the action. the action object a toolbar item connected to the action. the action object the menu item provided by the action, or %NULL. a #GtkAction #GtkActionEntry structs are used with gtk_action_group_add_actions() to construct actions. The name of the action. The stock id for the action, or the name of an icon from the icon theme. The label for the action. This field should typically be marked for translation, see gtk_action_group_set_translation_domain(). If @label is %NULL, the label of the stock item with id @stock_id is used. The accelerator for the action, in the format understood by gtk_accelerator_parse(). The tooltip for the action. This field should typically be marked for translation, see gtk_action_group_set_translation_domain(). The function to call when the action is activated. Actions are organised into groups. An action group is essentially a map from names to #GtkAction objects. All actions that would make sense to use in a particular context should be in a single group. Multiple action groups may be used for a particular user interface. In fact, it is expected that most nontrivial applications will make use of multiple groups. For example, in an application that can edit multiple documents, one group holding global actions (e.g. quit, about, new), and one group per document holding actions that act on that document (eg. save, cut/copy/paste, etc). Each window’s menus would be constructed from a combination of two action groups. ## Accelerators ## {#Action-Accel} Accelerators are handled by the GTK+ accelerator map. All actions are assigned an accelerator path (which normally has the form `<Actions>/group-name/action-name`) and a shortcut is associated with this accelerator path. All menuitems and toolitems take on this accelerator path. The GTK+ accelerator map code makes sure that the correct shortcut is displayed next to the menu item. # GtkActionGroup as GtkBuildable # {#GtkActionGroup-BUILDER-UI} The #GtkActionGroup implementation of the #GtkBuildable interface accepts #GtkAction objects as <child> elements in UI definitions. Note that it is probably more common to define actions and action groups in the code, since they are directly related to what the code can do. The GtkActionGroup implementation of the GtkBuildable interface supports a custom <accelerator> element, which has attributes named “key“ and “modifiers“ and allows to specify accelerators. This is similar to the <accelerator> element of #GtkWidget, the main difference is that it doesn’t allow you to specify a signal. ## A #GtkDialog UI definition fragment. ## |[ <object class="GtkActionGroup" id="actiongroup"> <child> <object class="GtkAction" id="About"> <property name="name">About</property> <property name="stock_id">gtk-about</property> <signal handler="about_activate" name="activate"/> </object> <accelerator key="F1" modifiers="GDK_CONTROL_MASK | GDK_SHIFT_MASK"/> </child> </object> ]| Creates a new #GtkActionGroup object. The name of the action group is used when associating [keybindings][Action-Accel] with the actions. the new #GtkActionGroup the name of the action group. Looks up an action in the action group by name. the action, or %NULL if no action by that name exists the action group the name of the action Adds an action object to the action group. Note that this function does not set up the accel path of the action, which can lead to problems if a user tries to modify the accelerator of a menuitem associated with the action. Therefore you must either set the accel path yourself with gtk_action_set_accel_path(), or use `gtk_action_group_add_action_with_accel (..., NULL)`. the action group an action Adds an action object to the action group and sets up the accelerator. If @accelerator is %NULL, attempts to use the accelerator associated with the stock_id of the action. Accel paths are set to `<Actions>/group-name/action-name`. the action group the action to add the accelerator for the action, in the format understood by gtk_accelerator_parse(), or "" for no accelerator, or %NULL to use the stock accelerator This is a convenience function to create a number of actions and add them to the action group. The “activate” signals of the actions are connected to the callbacks and their accel paths are set to `<Actions>/group-name/action-name`. the action group an array of action descriptions the number of entries data to pass to the action callbacks This variant of gtk_action_group_add_actions() adds a #GDestroyNotify callback for @user_data. the action group an array of action descriptions the number of entries data to pass to the action callbacks destroy notification callback for @user_data This is a convenience routine to create a group of radio actions and add them to the action group. The “changed” signal of the first radio action is connected to the @on_change callback and the accel paths of the actions are set to `<Actions>/group-name/action-name`. the action group an array of radio action descriptions the number of entries the value of the action to activate initially, or -1 if no action should be activated the callback to connect to the changed signal data to pass to the action callbacks This variant of gtk_action_group_add_radio_actions() adds a #GDestroyNotify callback for @user_data. the action group an array of radio action descriptions the number of entries the value of the action to activate initially, or -1 if no action should be activated the callback to connect to the changed signal data to pass to the action callbacks destroy notification callback for @user_data This is a convenience function to create a number of toggle actions and add them to the action group. The “activate” signals of the actions are connected to the callbacks and their accel paths are set to `<Actions>/group-name/action-name`. the action group an array of toggle action descriptions the number of entries data to pass to the action callbacks This variant of gtk_action_group_add_toggle_actions() adds a #GDestroyNotify callback for @user_data. the action group an array of toggle action descriptions the number of entries data to pass to the action callbacks destroy notification callback for @user_data Gets the accelerator group. the accelerator group associated with this action group or %NULL if there is none. a #GtkActionGroup Looks up an action in the action group by name. the action, or %NULL if no action by that name exists the action group the name of the action Gets the name of the action group. the name of the action group. the action group Returns %TRUE if the group is sensitive. The constituent actions can only be logically sensitive (see gtk_action_is_sensitive()) if they are sensitive (see gtk_action_get_sensitive()) and their group is sensitive. %TRUE if the group is sensitive. the action group Returns %TRUE if the group is visible. The constituent actions can only be logically visible (see gtk_action_is_visible()) if they are visible (see gtk_action_get_visible()) and their group is visible. %TRUE if the group is visible. the action group Lists the actions in the action group. an allocated list of the action objects in the action group the action group Removes an action object from the action group. the action group an action Sets the accelerator group to be used by every action in this group. a #GtkActionGroup a #GtkAccelGroup to set or %NULL Changes the sensitivity of @action_group the action group new sensitivity Sets a function to be used for translating the @label and @tooltip of #GtkActionEntrys added by gtk_action_group_add_actions(). If you’re using gettext(), it is enough to set the translation domain with gtk_action_group_set_translation_domain(). a #GtkActionGroup a #GtkTranslateFunc data to be passed to @func and @notify a #GDestroyNotify function to be called when @action_group is destroyed and when the translation function is changed again Sets the translation domain and uses g_dgettext() for translating the @label and @tooltip of #GtkActionEntrys added by gtk_action_group_add_actions(). If you’re not using gettext() for localization, see gtk_action_group_set_translate_func(). a #GtkActionGroup the translation domain to use for g_dgettext() calls, or %NULL to use the domain set with textdomain() Changes the visible of @action_group. the action group new visiblity Translates a string using the function set with gtk_action_group_set_translate_func(). This is mainly intended for language bindings. the translation of @string a #GtkActionGroup a string The accelerator group the actions of this group should use. A name for the action. Whether the action group is enabled. Whether the action group is visible. The ::connect-proxy signal is emitted after connecting a proxy to an action in the group. Note that the proxy may have been connected to a different action before. This is intended for simple customizations for which a custom action class would be too clumsy, e.g. showing tooltips for menuitems in the statusbar. #GtkUIManager proxies the signal and provides global notification just before any action is connected to a proxy, which is probably more convenient to use. the action the proxy The ::disconnect-proxy signal is emitted after disconnecting a proxy from an action in the group. #GtkUIManager proxies the signal and provides global notification just before any action is connected to a proxy, which is probably more convenient to use. the action the proxy The ::post-activate signal is emitted just after the @action in the @action_group is activated This is intended for #GtkUIManager to proxy the signal and provide global notification just after any action is activated. the action The ::pre-activate signal is emitted just before the @action in the @action_group is activated This is intended for #GtkUIManager to proxy the signal and provide global notification just before any action is activated. the action The parent class. the action, or %NULL if no action by that name exists the action group the name of the action This interface provides a convenient way of associating widgets with actions on a #GtkApplicationWindow or #GtkApplication. It primarily consists of two properties: #GtkActionable:action-name and #GtkActionable:action-target. There are also some convenience APIs for setting these properties. The action will be looked up in action groups that are found among the widgets ancestors. Most commonly, these will be the actions with the “win.” or “app.” prefix that are associated with the #GtkApplicationWindow or #GtkApplication, but other action groups that are added with gtk_widget_insert_action_group() will be consulted as well. Gets the action name for @actionable. See gtk_actionable_set_action_name() for more information. the action name, or %NULL if none is set a #GtkActionable widget Gets the current target value of @actionable. See gtk_actionable_set_action_target_value() for more information. the current target value a #GtkActionable widget Specifies the name of the action with which this widget should be associated. If @action_name is %NULL then the widget will be unassociated from any previous action. Usually this function is used when the widget is located (or will be located) within the hierarchy of a #GtkApplicationWindow. Names are of the form “win.save” or “app.quit” for actions on the containing #GtkApplicationWindow or its associated #GtkApplication, respectively. This is the same form used for actions in the #GMenu associated with the window. a #GtkActionable widget an action name, or %NULL Sets the target value of an actionable widget. If @target_value is %NULL then the target value is unset. The target value has two purposes. First, it is used as the parameter to activation of the action associated with the #GtkActionable widget. Second, it is used to determine if the widget should be rendered as “active” — the widget is active if the state is equal to the given target. Consider the example of associating a set of buttons with a #GAction with string state in a typical “radio button” situation. Each button will be associated with the same action, but with a different target value for that action. Clicking on a particular button will activate the action with the target of that button, which will typically cause the action’s state to change to that value. Since the action’s state is now equal to the target value of the button, the button will now be rendered as active (and the other buttons, with different targets, rendered inactive). a #GtkActionable widget a #GVariant to set as the target value, or %NULL Gets the action name for @actionable. See gtk_actionable_set_action_name() for more information. the action name, or %NULL if none is set a #GtkActionable widget Gets the current target value of @actionable. See gtk_actionable_set_action_target_value() for more information. the current target value a #GtkActionable widget Specifies the name of the action with which this widget should be associated. If @action_name is %NULL then the widget will be unassociated from any previous action. Usually this function is used when the widget is located (or will be located) within the hierarchy of a #GtkApplicationWindow. Names are of the form “win.save” or “app.quit” for actions on the containing #GtkApplicationWindow or its associated #GtkApplication, respectively. This is the same form used for actions in the #GMenu associated with the window. a #GtkActionable widget an action name, or %NULL Sets the target of an actionable widget. This is a convenience function that calls g_variant_new() for @format_string and uses the result to call gtk_actionable_set_action_target_value(). If you are setting a string-valued target and want to set the action name at the same time, you can use gtk_actionable_set_detailed_action_name (). a #GtkActionable widget a GVariant format string arguments appropriate for @format_string Sets the target value of an actionable widget. If @target_value is %NULL then the target value is unset. The target value has two purposes. First, it is used as the parameter to activation of the action associated with the #GtkActionable widget. Second, it is used to determine if the widget should be rendered as “active” — the widget is active if the state is equal to the given target. Consider the example of associating a set of buttons with a #GAction with string state in a typical “radio button” situation. Each button will be associated with the same action, but with a different target value for that action. Clicking on a particular button will activate the action with the target of that button, which will typically cause the action’s state to change to that value. Since the action’s state is now equal to the target value of the button, the button will now be rendered as active (and the other buttons, with different targets, rendered inactive). a #GtkActionable widget a #GVariant to set as the target value, or %NULL Sets the action-name and associated string target value of an actionable widget. @detailed_action_name is a string in the format accepted by g_action_parse_detailed_name(). (Note that prior to version 3.22.25, this function is only usable for actions with a simple "s" target, and @detailed_action_name must be of the form `"action::target"` where `action` is the action name and `target` is the string to use as the target.) a #GtkActionable widget the detailed action name The interface vtable for #GtkActionable. the action name, or %NULL if none is set a #GtkActionable widget a #GtkActionable widget an action name, or %NULL the current target value a #GtkActionable widget a #GtkActionable widget a #GVariant to set as the target value, or %NULL Activatable widgets can be connected to a #GtkAction and reflects the state of its action. A #GtkActivatable can also provide feedback through its action, as they are responsible for activating their related actions. # Implementing GtkActivatable When extending a class that is already #GtkActivatable; it is only necessary to implement the #GtkActivatable->sync_action_properties() and #GtkActivatable->update() methods and chain up to the parent implementation, however when introducing a new #GtkActivatable class; the #GtkActivatable:related-action and #GtkActivatable:use-action-appearance properties need to be handled by the implementor. Handling these properties is mostly a matter of installing the action pointer and boolean flag on your instance, and calling gtk_activatable_do_set_related_action() and gtk_activatable_sync_action_properties() at the appropriate times. ## A class fragment implementing #GtkActivatable |[<!-- language="C" --> enum { ... PROP_ACTIVATABLE_RELATED_ACTION, PROP_ACTIVATABLE_USE_ACTION_APPEARANCE } struct _FooBarPrivate { ... GtkAction *action; gboolean use_action_appearance; }; ... static void foo_bar_activatable_interface_init (GtkActivatableIface *iface); static void foo_bar_activatable_update (GtkActivatable *activatable, GtkAction *action, const gchar *property_name); static void foo_bar_activatable_sync_action_properties (GtkActivatable *activatable, GtkAction *action); ... static void foo_bar_class_init (FooBarClass *klass) { ... g_object_class_override_property (gobject_class, PROP_ACTIVATABLE_RELATED_ACTION, "related-action"); g_object_class_override_property (gobject_class, PROP_ACTIVATABLE_USE_ACTION_APPEARANCE, "use-action-appearance"); ... } static void foo_bar_activatable_interface_init (GtkActivatableIface *iface) { iface->update = foo_bar_activatable_update; iface->sync_action_properties = foo_bar_activatable_sync_action_properties; } ... Break the reference using gtk_activatable_do_set_related_action()... static void foo_bar_dispose (GObject *object) { FooBar *bar = FOO_BAR (object); FooBarPrivate *priv = FOO_BAR_GET_PRIVATE (bar); ... if (priv->action) { gtk_activatable_do_set_related_action (GTK_ACTIVATABLE (bar), NULL); priv->action = NULL; } G_OBJECT_CLASS (foo_bar_parent_class)->dispose (object); } ... Handle the “related-action” and “use-action-appearance” properties ... static void foo_bar_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec) { FooBar *bar = FOO_BAR (object); FooBarPrivate *priv = FOO_BAR_GET_PRIVATE (bar); switch (prop_id) { ... case PROP_ACTIVATABLE_RELATED_ACTION: foo_bar_set_related_action (bar, g_value_get_object (value)); break; case PROP_ACTIVATABLE_USE_ACTION_APPEARANCE: foo_bar_set_use_action_appearance (bar, g_value_get_boolean (value)); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } } static void foo_bar_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec) { FooBar *bar = FOO_BAR (object); FooBarPrivate *priv = FOO_BAR_GET_PRIVATE (bar); switch (prop_id) { ... case PROP_ACTIVATABLE_RELATED_ACTION: g_value_set_object (value, priv->action); break; case PROP_ACTIVATABLE_USE_ACTION_APPEARANCE: g_value_set_boolean (value, priv->use_action_appearance); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } } static void foo_bar_set_use_action_appearance (FooBar *bar, gboolean use_appearance) { FooBarPrivate *priv = FOO_BAR_GET_PRIVATE (bar); if (priv->use_action_appearance != use_appearance) { priv->use_action_appearance = use_appearance; gtk_activatable_sync_action_properties (GTK_ACTIVATABLE (bar), priv->action); } } ... call gtk_activatable_do_set_related_action() and then assign the action pointer, no need to reference the action here since gtk_activatable_do_set_related_action() already holds a reference here for you... static void foo_bar_set_related_action (FooBar *bar, GtkAction *action) { FooBarPrivate *priv = FOO_BAR_GET_PRIVATE (bar); if (priv->action == action) return; gtk_activatable_do_set_related_action (GTK_ACTIVATABLE (bar), action); priv->action = action; } ... Selectively reset and update activatable depending on the use-action-appearance property ... static void gtk_button_activatable_sync_action_properties (GtkActivatable *activatable, GtkAction *action) { GtkButtonPrivate *priv = GTK_BUTTON_GET_PRIVATE (activatable); if (!action) return; if (gtk_action_is_visible (action)) gtk_widget_show (GTK_WIDGET (activatable)); else gtk_widget_hide (GTK_WIDGET (activatable)); gtk_widget_set_sensitive (GTK_WIDGET (activatable), gtk_action_is_sensitive (action)); ... if (priv->use_action_appearance) { if (gtk_action_get_stock_id (action)) foo_bar_set_stock (button, gtk_action_get_stock_id (action)); else if (gtk_action_get_label (action)) foo_bar_set_label (button, gtk_action_get_label (action)); ... } } static void foo_bar_activatable_update (GtkActivatable *activatable, GtkAction *action, const gchar *property_name) { FooBarPrivate *priv = FOO_BAR_GET_PRIVATE (activatable); if (strcmp (property_name, "visible") == 0) { if (gtk_action_is_visible (action)) gtk_widget_show (GTK_WIDGET (activatable)); else gtk_widget_hide (GTK_WIDGET (activatable)); } else if (strcmp (property_name, "sensitive") == 0) gtk_widget_set_sensitive (GTK_WIDGET (activatable), gtk_action_is_sensitive (action)); ... if (!priv->use_action_appearance) return; if (strcmp (property_name, "stock-id") == 0) foo_bar_set_stock (button, gtk_action_get_stock_id (action)); else if (strcmp (property_name, "label") == 0) foo_bar_set_label (button, gtk_action_get_label (action)); ... } ]| This is called to update the activatable completely, this is called internally when the #GtkActivatable:related-action property is set or unset and by the implementing class when #GtkActivatable:use-action-appearance changes. a #GtkActivatable the related #GtkAction or %NULL This is a utility function for #GtkActivatable implementors. When implementing #GtkActivatable you must call this when handling changes of the #GtkActivatable:related-action, and you must also use this to break references in #GObject->dispose(). This function adds a reference to the currently set related action for you, it also makes sure the #GtkActivatable->update() method is called when the related #GtkAction properties change and registers to the action’s proxy list. > Be careful to call this before setting the local > copy of the #GtkAction property, since this function uses > gtk_activatable_get_related_action() to retrieve the > previous action. a #GtkActivatable the #GtkAction to set Gets the related #GtkAction for @activatable. the related #GtkAction if one is set. a #GtkActivatable Gets whether this activatable should reset its layout and appearance when setting the related action or when the action changes appearance. whether @activatable uses its actions appearance. a #GtkActivatable Sets the related action on the @activatable object. > #GtkActivatable implementors need to handle the #GtkActivatable:related-action > property and call gtk_activatable_do_set_related_action() when it changes. a #GtkActivatable the #GtkAction to set Sets whether this activatable should reset its layout and appearance when setting the related action or when the action changes appearance > #GtkActivatable implementors need to handle the > #GtkActivatable:use-action-appearance property and call > gtk_activatable_sync_action_properties() to update @activatable > if needed. a #GtkActivatable whether to use the actions appearance This is called to update the activatable completely, this is called internally when the #GtkActivatable:related-action property is set or unset and by the implementing class when #GtkActivatable:use-action-appearance changes. a #GtkActivatable the related #GtkAction or %NULL The action that this activatable will activate and receive updates from for various states and possibly appearance. > #GtkActivatable implementors need to handle the this property and > call gtk_activatable_do_set_related_action() when it changes. Whether this activatable should reset its layout and appearance when setting the related action or when the action changes appearance. See the #GtkAction documentation directly to find which properties should be ignored by the #GtkActivatable when this property is %FALSE. > #GtkActivatable implementors need to handle this property > and call gtk_activatable_sync_action_properties() on the activatable > widget when it changes. > This method can be called with a %NULL action at times. a #GtkActivatable the related #GtkAction or %NULL The #GtkAdjustment object represents a value which has an associated lower and upper bound, together with step and page increments, and a page size. It is used within several GTK+ widgets, including #GtkSpinButton, #GtkViewport, and #GtkRange (which is a base class for #GtkScrollbar and #GtkScale). The #GtkAdjustment object does not update the value itself. Instead it is left up to the owner of the #GtkAdjustment to control the value. Creates a new #GtkAdjustment. a new #GtkAdjustment the initial value the minimum value the maximum value the step increment the page increment the page size Emits a #GtkAdjustment::changed signal from the #GtkAdjustment. This is typically called by the owner of the #GtkAdjustment after it has changed any of the #GtkAdjustment properties other than the value. GTK+ emits #GtkAdjustment::changed itself whenever any of the properties (other than value) change a #GtkAdjustment Emits a #GtkAdjustment::value-changed signal from the #GtkAdjustment. This is typically called by the owner of the #GtkAdjustment after it has changed the #GtkAdjustment:value property. GTK+ emits #GtkAdjustment::value-changed itself whenever the value changes a #GtkAdjustment Emits a #GtkAdjustment::changed signal from the #GtkAdjustment. This is typically called by the owner of the #GtkAdjustment after it has changed any of the #GtkAdjustment properties other than the value. GTK+ emits #GtkAdjustment::changed itself whenever any of the properties (other than value) change a #GtkAdjustment Updates the #GtkAdjustment:value property to ensure that the range between @lower and @upper is in the current page (i.e. between #GtkAdjustment:value and #GtkAdjustment:value + #GtkAdjustment:page-size). If the range is larger than the page size, then only the start of it will be in the current page. A #GtkAdjustment::value-changed signal will be emitted if the value is changed. a #GtkAdjustment the lower value the upper value Sets all properties of the adjustment at once. Use this function to avoid multiple emissions of the #GtkAdjustment::changed signal. See gtk_adjustment_set_lower() for an alternative way of compressing multiple emissions of #GtkAdjustment::changed into one. a #GtkAdjustment the new value the new minimum value the new maximum value the new step increment the new page increment the new page size Retrieves the minimum value of the adjustment. The current minimum value of the adjustment a #GtkAdjustment Gets the smaller of step increment and page increment. the minimum increment of @adjustment a #GtkAdjustment Retrieves the page increment of the adjustment. The current page increment of the adjustment a #GtkAdjustment Retrieves the page size of the adjustment. The current page size of the adjustment a #GtkAdjustment Retrieves the step increment of the adjustment. The current step increment of the adjustment. a #GtkAdjustment Retrieves the maximum value of the adjustment. The current maximum value of the adjustment a #GtkAdjustment Gets the current value of the adjustment. See gtk_adjustment_set_value(). The current value of the adjustment a #GtkAdjustment Sets the minimum value of the adjustment. When setting multiple adjustment properties via their individual setters, multiple #GtkAdjustment::changed signals will be emitted. However, since the emission of the #GtkAdjustment::changed signal is tied to the emission of the #GObject::notify signals of the changed properties, it’s possible to compress the #GtkAdjustment::changed signals into one by calling g_object_freeze_notify() and g_object_thaw_notify() around the calls to the individual setters. Alternatively, using a single g_object_set() for all the properties to change, or using gtk_adjustment_configure() has the same effect of compressing #GtkAdjustment::changed emissions. a #GtkAdjustment the new minimum value Sets the page increment of the adjustment. See gtk_adjustment_set_lower() about how to compress multiple emissions of the #GtkAdjustment::changed signal when setting multiple adjustment properties. a #GtkAdjustment the new page increment Sets the page size of the adjustment. See gtk_adjustment_set_lower() about how to compress multiple emissions of the GtkAdjustment::changed signal when setting multiple adjustment properties. a #GtkAdjustment the new page size Sets the step increment of the adjustment. See gtk_adjustment_set_lower() about how to compress multiple emissions of the #GtkAdjustment::changed signal when setting multiple adjustment properties. a #GtkAdjustment the new step increment Sets the maximum value of the adjustment. Note that values will be restricted by `upper - page-size` if the page-size property is nonzero. See gtk_adjustment_set_lower() about how to compress multiple emissions of the #GtkAdjustment::changed signal when setting multiple adjustment properties. a #GtkAdjustment the new maximum value Sets the #GtkAdjustment value. The value is clamped to lie between #GtkAdjustment:lower and #GtkAdjustment:upper. Note that for adjustments which are used in a #GtkScrollbar, the effective range of allowed values goes from #GtkAdjustment:lower to #GtkAdjustment:upper - #GtkAdjustment:page-size. a #GtkAdjustment the new value Emits a #GtkAdjustment::value-changed signal from the #GtkAdjustment. This is typically called by the owner of the #GtkAdjustment after it has changed the #GtkAdjustment:value property. GTK+ emits #GtkAdjustment::value-changed itself whenever the value changes a #GtkAdjustment The minimum value of the adjustment. The page increment of the adjustment. The page size of the adjustment. Note that the page-size is irrelevant and should be set to zero if the adjustment is used for a simple scalar value, e.g. in a #GtkSpinButton. The step increment of the adjustment. The maximum value of the adjustment. Note that values will be restricted by `upper - page-size` if the page-size property is nonzero. The value of the adjustment. Emitted when one or more of the #GtkAdjustment properties have been changed, other than the #GtkAdjustment:value property. Emitted when the #GtkAdjustment:value property has been changed. a #GtkAdjustment a #GtkAdjustment Controls how a widget deals with extra space in a single (x or y) dimension. Alignment only matters if the widget receives a “too large” allocation, for example if you packed the widget with the #GtkWidget:expand flag inside a #GtkBox, then the widget might get extra space. If you have for example a 16x16 icon inside a 32x32 space, the icon could be scaled and stretched, it could be centered, or it could be positioned to one side of the space. Note that in horizontal context @GTK_ALIGN_START and @GTK_ALIGN_END are interpreted relative to text direction. GTK_ALIGN_BASELINE support for it is optional for containers and widgets, and it is only supported for vertical alignment. When its not supported by a child or a container it is treated as @GTK_ALIGN_FILL. stretch to fill all space if possible, center if no meaningful way to stretch snap to left or top side, leaving space on right or bottom snap to right or bottom side, leaving space on left or top center natural width of widget inside the allocation align the widget according to the baseline. Since 3.10. The #GtkAlignment widget controls the alignment and size of its child widget. It has four settings: xscale, yscale, xalign, and yalign. The scale settings are used to specify how much the child widget should expand to fill the space allocated to the #GtkAlignment. The values can range from 0 (meaning the child doesn’t expand at all) to 1 (meaning the child expands to fill all of the available space). The align settings are used to place the child widget within the available area. The values range from 0 (top or left) to 1 (bottom or right). Of course, if the scale settings are both set to 1, the alignment settings have no effect. GtkAlignment has been deprecated in 3.14 and should not be used in newly-written code. The desired effect can be achieved by using the #GtkWidget:halign, #GtkWidget:valign and #GtkWidget:margin properties on the child widget. Creates a new #GtkAlignment. Use #GtkWidget alignment and margin properties the new #GtkAlignment the horizontal alignment of the child widget, from 0 (left) to 1 (right). the vertical alignment of the child widget, from 0 (top) to 1 (bottom). the amount that the child widget expands horizontally to fill up unused space, from 0 to 1. A value of 0 indicates that the child widget should never expand. A value of 1 indicates that the child widget will expand to fill all of the space allocated for the #GtkAlignment. the amount that the child widget expands vertically to fill up unused space, from 0 to 1. The values are similar to @xscale. Gets the padding on the different sides of the widget. See gtk_alignment_set_padding (). Use #GtkWidget alignment and margin properties a #GtkAlignment location to store the padding for the top of the widget, or %NULL location to store the padding for the bottom of the widget, or %NULL location to store the padding for the left of the widget, or %NULL location to store the padding for the right of the widget, or %NULL Sets the #GtkAlignment values. Use #GtkWidget alignment and margin properties a #GtkAlignment. the horizontal alignment of the child widget, from 0 (left) to 1 (right). the vertical alignment of the child widget, from 0 (top) to 1 (bottom). the amount that the child widget expands horizontally to fill up unused space, from 0 to 1. A value of 0 indicates that the child widget should never expand. A value of 1 indicates that the child widget will expand to fill all of the space allocated for the #GtkAlignment. the amount that the child widget expands vertically to fill up unused space, from 0 to 1. The values are similar to @xscale. Sets the padding on the different sides of the widget. The padding adds blank space to the sides of the widget. For instance, this can be used to indent the child widget towards the right by adding padding on the left. Use #GtkWidget alignment and margin properties a #GtkAlignment the padding at the top of the widget the padding at the bottom of the widget the padding at the left of the widget the padding at the right of the widget. The padding to insert at the bottom of the widget. Use gtk_widget_set_margin_bottom() instead The padding to insert at the left of the widget. Use gtk_widget_set_margin_start() instead The padding to insert at the right of the widget. Use gtk_widget_set_margin_end() instead The padding to insert at the top of the widget. Use gtk_widget_set_margin_top() instead Horizontal position of child in available space. A value of 0.0 will flush the child left (or right, in RTL locales); a value of 1.0 will flush the child right (or left, in RTL locales). Use gtk_widget_set_halign() on the child instead If available horizontal space is bigger than needed, how much of it to use for the child. A value of 0.0 means none; a value of 1.0 means all. Use gtk_widget_set_hexpand() on the child instead Vertical position of child in available space. A value of 0.0 will flush the child to the top; a value of 1.0 will flush the child to the bottom. Use gtk_widget_set_valign() on the child instead If available vertical space is bigger than needed, how much of it to use for the child. A value of 0.0 means none; a value of 1.0 means all. Use gtk_widget_set_vexpand() on the child instead The parent class. #GtkAppChooser is an interface that can be implemented by widgets which allow the user to choose an application (typically for the purpose of opening a file). The main objects that implement this interface are #GtkAppChooserWidget, #GtkAppChooserDialog and #GtkAppChooserButton. Applications are represented by GIO #GAppInfo objects here. GIO has a concept of recommended and fallback applications for a given content type. Recommended applications are those that claim to handle the content type itself, while fallback also includes applications that handle a more generic content type. GIO also knows the default and last-used application for a given content type. The #GtkAppChooserWidget provides detailed control over whether the shown list of applications should include default, recommended or fallback applications. To obtain the application that has been selected in a #GtkAppChooser, use gtk_app_chooser_get_app_info(). Returns the currently selected application. a #GAppInfo for the currently selected application, or %NULL if none is selected. Free with g_object_unref() a #GtkAppChooser Returns the current value of the #GtkAppChooser:content-type property. the content type of @self. Free with g_free() a #GtkAppChooser Reloads the list of applications. a #GtkAppChooser The content type of the #GtkAppChooser object. See [GContentType][gio-GContentType] for more information about content types. The #GtkAppChooserButton is a widget that lets the user select an application. It implements the #GtkAppChooser interface. Initially, a #GtkAppChooserButton selects the first application in its list, which will either be the most-recently used application or, if #GtkAppChooserButton:show-default-item is %TRUE, the default application. The list of applications shown in a #GtkAppChooserButton includes the recommended applications for the given content type. When #GtkAppChooserButton:show-default-item is set, the default application is also included. To let the user chooser other applications, you can set the #GtkAppChooserButton:show-dialog-item property, which allows to open a full #GtkAppChooserDialog. It is possible to add custom items to the list, using gtk_app_chooser_button_append_custom_item(). These items cause the #GtkAppChooserButton::custom-item-activated signal to be emitted when they are selected. To track changes in the selected application, use the #GtkComboBox::changed signal. Creates a new #GtkAppChooserButton for applications that can handle content of the given type. a newly created #GtkAppChooserButton the content type to show applications for Appends a custom item to the list of applications that is shown in the popup; the item name must be unique per-widget. Clients can use the provided name as a detail for the #GtkAppChooserButton::custom-item-activated signal, to add a callback for the activation of a particular custom item in the list. See also gtk_app_chooser_button_append_separator(). a #GtkAppChooserButton the name of the custom item the label for the custom item the icon for the custom item Appends a separator to the list of applications that is shown in the popup. a #GtkAppChooserButton Returns the text to display at the top of the dialog. the text to display at the top of the dialog, or %NULL, in which case a default text is displayed a #GtkAppChooserButton Returns the current value of the #GtkAppChooserButton:show-default-item property. the value of #GtkAppChooserButton:show-default-item a #GtkAppChooserButton Returns the current value of the #GtkAppChooserButton:show-dialog-item property. the value of #GtkAppChooserButton:show-dialog-item a #GtkAppChooserButton Selects a custom item previously added with gtk_app_chooser_button_append_custom_item(). Use gtk_app_chooser_refresh() to bring the selection to its initial state. a #GtkAppChooserButton the name of the custom item Sets the text to display at the top of the dialog. If the heading is not set, the dialog displays a default text. a #GtkAppChooserButton a string containing Pango markup Sets whether the dropdown menu of this button should show the default application for the given content type at top. a #GtkAppChooserButton the new value for #GtkAppChooserButton:show-default-item Sets whether the dropdown menu of this button should show an entry to trigger a #GtkAppChooserDialog. a #GtkAppChooserButton the new value for #GtkAppChooserButton:show-dialog-item The text to show at the top of the dialog that can be opened from the button. The string may contain Pango markup. The #GtkAppChooserButton:show-default-item property determines whether the dropdown menu should show the default application on top for the provided content type. The #GtkAppChooserButton:show-dialog-item property determines whether the dropdown menu should show an item that triggers a #GtkAppChooserDialog when clicked. Emitted when a custom item, previously added with gtk_app_chooser_button_append_custom_item(), is activated from the dropdown menu. the name of the activated item The parent class. #GtkAppChooserDialog shows a #GtkAppChooserWidget inside a #GtkDialog. Note that #GtkAppChooserDialog does not have any interesting methods of its own. Instead, you should get the embedded #GtkAppChooserWidget using gtk_app_chooser_dialog_get_widget() and call its methods if the generic #GtkAppChooser interface is not sufficient for your needs. To set the heading that is shown above the #GtkAppChooserWidget, use gtk_app_chooser_dialog_set_heading(). Creates a new #GtkAppChooserDialog for the provided #GFile, to allow the user to select an application for it. a newly created #GtkAppChooserDialog a #GtkWindow, or %NULL flags for this dialog a #GFile Creates a new #GtkAppChooserDialog for the provided content type, to allow the user to select an application for it. a newly created #GtkAppChooserDialog a #GtkWindow, or %NULL flags for this dialog a content type string Returns the text to display at the top of the dialog. the text to display at the top of the dialog, or %NULL, in which case a default text is displayed a #GtkAppChooserDialog Returns the #GtkAppChooserWidget of this dialog. the #GtkAppChooserWidget of @self a #GtkAppChooserDialog Sets the text to display at the top of the dialog. If the heading is not set, the dialog displays a default text. a #GtkAppChooserDialog a string containing Pango markup The GFile used by the #GtkAppChooserDialog. The dialog's #GtkAppChooserWidget content type will be guessed from the file, if present. The text to show at the top of the dialog. The string may contain Pango markup. The parent class. #GtkAppChooserWidget is a widget for selecting applications. It is the main building block for #GtkAppChooserDialog. Most applications only need to use the latter; but you can use this widget as part of a larger widget if you have special needs. #GtkAppChooserWidget offers detailed control over what applications are shown, using the #GtkAppChooserWidget:show-default, #GtkAppChooserWidget:show-recommended, #GtkAppChooserWidget:show-fallback, #GtkAppChooserWidget:show-other and #GtkAppChooserWidget:show-all properties. See the #GtkAppChooser documentation for more information about these groups of applications. To keep track of the selected application, use the #GtkAppChooserWidget::application-selected and #GtkAppChooserWidget::application-activated signals. # CSS nodes GtkAppChooserWidget has a single CSS node with name appchooser. Creates a new #GtkAppChooserWidget for applications that can handle content of the given type. a newly created #GtkAppChooserWidget the content type to show applications for Returns the text that is shown if there are not applications that can handle the content type. the value of #GtkAppChooserWidget:default-text a #GtkAppChooserWidget Returns the current value of the #GtkAppChooserWidget:show-all property. the value of #GtkAppChooserWidget:show-all a #GtkAppChooserWidget Returns the current value of the #GtkAppChooserWidget:show-default property. the value of #GtkAppChooserWidget:show-default a #GtkAppChooserWidget Returns the current value of the #GtkAppChooserWidget:show-fallback property. the value of #GtkAppChooserWidget:show-fallback a #GtkAppChooserWidget Returns the current value of the #GtkAppChooserWidget:show-other property. the value of #GtkAppChooserWidget:show-other a #GtkAppChooserWidget Returns the current value of the #GtkAppChooserWidget:show-recommended property. the value of #GtkAppChooserWidget:show-recommended a #GtkAppChooserWidget Sets the text that is shown if there are not applications that can handle the content type. a #GtkAppChooserWidget the new value for #GtkAppChooserWidget:default-text Sets whether the app chooser should show all applications in a flat list. a #GtkAppChooserWidget the new value for #GtkAppChooserWidget:show-all Sets whether the app chooser should show the default handler for the content type in a separate section. a #GtkAppChooserWidget the new value for #GtkAppChooserWidget:show-default Sets whether the app chooser should show related applications for the content type in a separate section. a #GtkAppChooserWidget the new value for #GtkAppChooserWidget:show-fallback Sets whether the app chooser should show applications which are unrelated to the content type. a #GtkAppChooserWidget the new value for #GtkAppChooserWidget:show-other Sets whether the app chooser should show recommended applications for the content type in a separate section. a #GtkAppChooserWidget the new value for #GtkAppChooserWidget:show-recommended The #GtkAppChooserWidget:default-text property determines the text that appears in the widget when there are no applications for the given content type. See also gtk_app_chooser_widget_set_default_text(). If the #GtkAppChooserWidget:show-all property is %TRUE, the app chooser presents all applications in a single list, without subsections for default, recommended or related applications. The ::show-default property determines whether the app chooser should show the default handler for the content type in a separate section. If %FALSE, the default handler is listed among the recommended applications. The #GtkAppChooserWidget:show-fallback property determines whether the app chooser should show a section for fallback applications. If %FALSE, the fallback applications are listed among the other applications. The #GtkAppChooserWidget:show-other property determines whether the app chooser should show a section for other applications. The #GtkAppChooserWidget:show-recommended property determines whether the app chooser should show a section for recommended applications. If %FALSE, the recommended applications are listed among the other applications. Emitted when an application item is activated from the widget's list. This usually happens when the user double clicks an item, or an item is selected and the user presses one of the keys Space, Shift+Space, Return or Enter. the activated #GAppInfo Emitted when an application item is selected from the widget's list. the selected #GAppInfo Emitted when a context menu is about to popup over an application item. Clients can insert menu items into the provided #GtkMenu object in the callback of this signal; the context menu will be shown over the item if at least one item has been added to the menu. the #GtkMenu to populate the current #GAppInfo The parent class. #GtkApplication is a class that handles many important aspects of a GTK+ application in a convenient fashion, without enforcing a one-size-fits-all application model. Currently, GtkApplication handles GTK+ initialization, application uniqueness, session management, provides some basic scriptability and desktop shell integration by exporting actions and menus and manages a list of toplevel windows whose life-cycle is automatically tied to the life-cycle of your application. While GtkApplication works fine with plain #GtkWindows, it is recommended to use it together with #GtkApplicationWindow. When GDK threads are enabled, GtkApplication will acquire the GDK lock when invoking actions that arrive from other processes. The GDK lock is not touched for local action invocations. In order to have actions invoked in a predictable context it is therefore recommended that the GDK lock be held while invoking actions locally with g_action_group_activate_action(). The same applies to actions associated with #GtkApplicationWindow and to the “activate” and “open” #GApplication methods. ## Automatic resources ## {#automatic-resources} #GtkApplication will automatically load menus from the #GtkBuilder resource located at "gtk/menus.ui", relative to the application's resource base path (see g_application_set_resource_base_path()). The menu with the ID "app-menu" is taken as the application's app menu and the menu with the ID "menubar" is taken as the application's menubar. Additional menus (most interesting submenus) can be named and accessed via gtk_application_get_menu_by_id() which allows for dynamic population of a part of the menu structure. If the resources "gtk/menus-appmenu.ui" or "gtk/menus-traditional.ui" are present then these files will be used in preference, depending on the value of gtk_application_prefers_app_menu(). If the resource "gtk/menus-common.ui" is present it will be loaded as well. This is useful for storing items that are referenced from both "gtk/menus-appmenu.ui" and "gtk/menus-traditional.ui". It is also possible to provide the menus manually using gtk_application_set_app_menu() and gtk_application_set_menubar(). #GtkApplication will also automatically setup an icon search path for the default icon theme by appending "icons" to the resource base path. This allows your application to easily store its icons as resources. See gtk_icon_theme_add_resource_path() for more information. If there is a resource located at "gtk/help-overlay.ui" which defines a #GtkShortcutsWindow with ID "help_overlay" then GtkApplication associates an instance of this shortcuts window with each #GtkApplicationWindow and sets up keyboard accelerators (Control-F1 and Control-?) to open it. To create a menu item that displays the shortcuts window, associate the item with the action win.show-help-overlay. ## A simple application ## {#gtkapplication} [A simple example](https://git.gnome.org/browse/gtk+/tree/examples/bp/bloatpad.c) GtkApplication optionally registers with a session manager of the users session (if you set the #GtkApplication:register-session property) and offers various functionality related to the session life-cycle. An application can block various ways to end the session with the gtk_application_inhibit() function. Typical use cases for this kind of inhibiting are long-running, uninterruptible operations, such as burning a CD or performing a disk backup. The session manager may not honor the inhibitor, but it can be expected to inform the user about the negative consequences of ending the session while inhibitors are present. ## See Also ## {#seealso} [HowDoI: Using GtkApplication](https://wiki.gnome.org/HowDoI/GtkApplication), [Getting Started with GTK+: Basics](https://developer.gnome.org/gtk3/stable/gtk-getting-started.html#id-1.2.3.3) Creates a new #GtkApplication instance. When using #GtkApplication, it is not necessary to call gtk_init() manually. It is called as soon as the application gets registered as the primary instance. Concretely, gtk_init() is called in the default handler for the #GApplication::startup signal. Therefore, #GtkApplication subclasses should chain up in their #GApplication::startup handler before using any GTK+ API. Note that commandline arguments are not passed to gtk_init(). All GTK+ functionality that is available via commandline arguments can also be achieved by setting suitable environment variables such as `G_DEBUG`, so this should not be a big problem. If you absolutely must support GTK+ commandline arguments, you can explicitly call gtk_init() before creating the application instance. If non-%NULL, the application ID must be valid. See g_application_id_is_valid(). If no application ID is given then some features (most notably application uniqueness) will be disabled. A null application ID is only allowed with GTK+ 3.6 or later. a new #GtkApplication instance The application ID. the application flags Installs an accelerator that will cause the named action to be activated when the key combination specificed by @accelerator is pressed. @accelerator must be a string that can be parsed by gtk_accelerator_parse(), e.g. "<Primary>q" or “<Control><Alt>p”. @action_name must be the name of an action as it would be used in the app menu, i.e. actions that have been added to the application are referred to with an “app.” prefix, and window-specific actions with a “win.” prefix. GtkApplication also extracts accelerators out of “accel” attributes in the #GMenuModels passed to gtk_application_set_app_menu() and gtk_application_set_menubar(), which is usually more convenient than calling this function for each accelerator. Use gtk_application_set_accels_for_action() instead a #GtkApplication accelerator string the name of the action to activate parameter to pass when activating the action, or %NULL if the action does not accept an activation parameter Adds a window to @application. This call can only happen after the @application has started; typically, you should add new application windows in response to the emission of the #GApplication::activate signal. This call is equivalent to setting the #GtkWindow:application property of @window to @application. Normally, the connection between the application and the window will remain until the window is destroyed, but you can explicitly remove it with gtk_application_remove_window(). GTK+ will keep the @application running as long as it has any windows. a #GtkApplication a #GtkWindow Gets the accelerators that are currently associated with the given action. accelerators for @detailed_action_name, as a %NULL-terminated array. Free with g_strfreev() when no longer needed a #GtkApplication a detailed action name, specifying an action and target to obtain accelerators for Returns the list of actions (possibly empty) that @accel maps to. Each item in the list is a detailed action name in the usual form. This might be useful to discover if an accel already exists in order to prevent installation of a conflicting accelerator (from an accelerator editor or a plugin system, for example). Note that having more than one action per accelerator may not be a bad thing and might make sense in cases where the actions never appear in the same context. In case there are no actions for a given accelerator, an empty array is returned. %NULL is never returned. It is a programmer error to pass an invalid accelerator string. If you are unsure, check it with gtk_accelerator_parse() first. a %NULL-terminated array of actions for @accel a #GtkApplication an accelerator that can be parsed by gtk_accelerator_parse() Gets the “active” window for the application. The active window is the one that was most recently focused (within the application). This window may not have the focus at the moment if another application has it — this is just the most recently-focused window within this application. the active window, or %NULL if there isn't one. a #GtkApplication Returns the menu model that has been set with gtk_application_set_app_menu(). the application menu of @application or %NULL if no application menu has been set. a #GtkApplication Gets a menu from automatically loaded resources. See [Automatic resources][automatic-resources] for more information. Gets the menu with the given id from the automatically loaded resources a #GtkApplication the id of the menu to look up Returns the menu model that has been set with gtk_application_set_menubar(). the menubar for windows of @application a #GtkApplication Returns the #GtkApplicationWindow with the given ID. The ID of a #GtkApplicationWindow can be retrieved with gtk_application_window_get_id(). the window with ID @id, or %NULL if there is no window with this ID a #GtkApplication an identifier number Gets a list of the #GtkWindows associated with @application. The list is sorted by most recently focused window, such that the first element is the currently focused window. (Useful for choosing a parent for a transient window.) The list that is returned should not be modified in any way. It will only remain valid until the next focus change or window creation or deletion. a #GList of #GtkWindow a #GtkApplication Inform the session manager that certain types of actions should be inhibited. This is not guaranteed to work on all platforms and for all types of actions. Applications should invoke this method when they begin an operation that should not be interrupted, such as creating a CD or DVD. The types of actions that may be blocked are specified by the @flags parameter. When the application completes the operation it should call gtk_application_uninhibit() to remove the inhibitor. Note that an application can have multiple inhibitors, and all of them must be individually removed. Inhibitors are also cleared when the application exits. Applications should not expect that they will always be able to block the action. In most cases, users will be given the option to force the action to take place. Reasons should be short and to the point. If @window is given, the session manager may point the user to this window to find out more about why the action is inhibited. A non-zero cookie that is used to uniquely identify this request. It should be used as an argument to gtk_application_uninhibit() in order to remove the request. If the platform does not support inhibiting or the request failed for some reason, 0 is returned. the #GtkApplication a #GtkWindow, or %NULL what types of actions should be inhibited a short, human-readable string that explains why these operations are inhibited Determines if any of the actions specified in @flags are currently inhibited (possibly by another application). Note that this information may not be available (for example when the application is running in a sandbox). %TRUE if any of the actions specified in @flags are inhibited the #GtkApplication what types of actions should be queried Lists the detailed action names which have associated accelerators. See gtk_application_set_accels_for_action(). a %NULL-terminated array of strings, free with g_strfreev() when done a #GtkApplication Determines if the desktop environment in which the application is running would prefer an application menu be shown. If this function returns %TRUE then the application should call gtk_application_set_app_menu() with the contents of an application menu, which will be shown by the desktop environment. If it returns %FALSE then you should consider using an alternate approach, such as a menubar. The value returned by this function is purely advisory and you are free to ignore it. If you call gtk_application_set_app_menu() even if the desktop environment doesn't support app menus, then a fallback will be provided. Applications are similarly free not to set an app menu even if the desktop environment wants to show one. In that case, a fallback will also be created by the desktop environment (GNOME, for example, uses a menu with only a "Quit" item in it). The value returned by this function never changes. Once it returns a particular value, it is guaranteed to always return the same value. You may only call this function after the application has been registered and after the base startup handler has run. You're most likely to want to use this from your own startup handler. It may also make sense to consult this function while constructing UI (in activate, open or an action activation handler) in order to determine if you should show a gear menu or not. This function will return %FALSE on Mac OS and a default app menu will be created automatically with the "usual" contents of that menu typical to most Mac OS applications. If you call gtk_application_set_app_menu() anyway, then this menu will be replaced with your own. %TRUE if you should set an app menu a #GtkApplication Removes an accelerator that has been previously added with gtk_application_add_accelerator(). Use gtk_application_set_accels_for_action() instead a #GtkApplication the name of the action to activate parameter to pass when activating the action, or %NULL if the action does not accept an activation parameter Remove a window from @application. If @window belongs to @application then this call is equivalent to setting the #GtkWindow:application property of @window to %NULL. The application may stop running as a result of a call to this function. a #GtkApplication a #GtkWindow Sets zero or more keyboard accelerators that will trigger the given action. The first item in @accels will be the primary accelerator, which may be displayed in the UI. To remove all accelerators for an action, use an empty, zero-terminated array for @accels. For the @detailed_action_name, see g_action_parse_detailed_name() and g_action_print_detailed_name(). a #GtkApplication a detailed action name, specifying an action and target to associate accelerators with a list of accelerators in the format understood by gtk_accelerator_parse() Sets or unsets the application menu for @application. This can only be done in the primary instance of the application, after it has been registered. #GApplication::startup is a good place to call this. The application menu is a single menu containing items that typically impact the application as a whole, rather than acting on a specific window or document. For example, you would expect to see “Preferences” or “Quit” in an application menu, but not “Save” or “Print”. If supported, the application menu will be rendered by the desktop environment. Use the base #GActionMap interface to add actions, to respond to the user selecting these menu items. a #GtkApplication a #GMenuModel, or %NULL Sets or unsets the menubar for windows of @application. This is a menubar in the traditional sense. This can only be done in the primary instance of the application, after it has been registered. #GApplication::startup is a good place to call this. Depending on the desktop environment, this may appear at the top of each window, or at the top of the screen. In some environments, if both the application menu and the menubar are set, the application menu will be presented as if it were the first item of the menubar. Other environments treat the two as completely separate — for example, the application menu may be rendered by the desktop shell while the menubar (if set) remains in each individual window. Use the base #GActionMap interface to add actions, to respond to the user selecting these menu items. a #GtkApplication a #GMenuModel, or %NULL Removes an inhibitor that has been established with gtk_application_inhibit(). Inhibitors are also cleared when the application exits. the #GtkApplication a cookie that was returned by gtk_application_inhibit() Set this property to %TRUE to register with the session manager. This property is %TRUE if GTK+ believes that the screensaver is currently active. GTK+ only tracks session state (including this) when #GtkApplication::register-session is set to %TRUE. Tracking the screensaver state is supported on Linux. Emitted when the session manager is about to end the session, only if #GtkApplication::register-session is %TRUE. Applications can connect to this signal and call gtk_application_inhibit() with %GTK_APPLICATION_INHIBIT_LOGOUT to delay the end of the session until state has been saved. Emitted when a #GtkWindow is added to @application through gtk_application_add_window(). the newly-added #GtkWindow Emitted when a #GtkWindow is removed from @application, either as a side-effect of being destroyed or explicitly through gtk_application_remove_window(). the #GtkWindow that is being removed The parent class. Types of user actions that may be blocked by gtk_application_inhibit(). Inhibit ending the user session by logging out or by shutting down the computer Inhibit user switching Inhibit suspending the session or computer Inhibit the session being marked as idle (and possibly locked) #GtkApplicationWindow is a #GtkWindow subclass that offers some extra functionality for better integration with #GtkApplication features. Notably, it can handle both the application menu as well as the menubar. See gtk_application_set_app_menu() and gtk_application_set_menubar(). This class implements the #GActionGroup and #GActionMap interfaces, to let you add window-specific actions that will be exported by the associated #GtkApplication, together with its application-wide actions. Window-specific actions are prefixed with the “win.” prefix and application-wide actions are prefixed with the “app.” prefix. Actions must be addressed with the prefixed name when referring to them from a #GMenuModel. Note that widgets that are placed inside a #GtkApplicationWindow can also activate these actions, if they implement the #GtkActionable interface. As with #GtkApplication, the GDK lock will be acquired when processing actions arriving from other processes and should therefore be held when activating actions locally (if GDK threads are enabled). The settings #GtkSettings:gtk-shell-shows-app-menu and #GtkSettings:gtk-shell-shows-menubar tell GTK+ whether the desktop environment is showing the application menu and menubar models outside the application as part of the desktop shell. For instance, on OS X, both menus will be displayed remotely; on Windows neither will be. gnome-shell (starting with version 3.4) will display the application menu, but not the menubar. If the desktop environment does not display the menubar, then #GtkApplicationWindow will automatically show a #GtkMenuBar for it. This behaviour can be overridden with the #GtkApplicationWindow:show-menubar property. If the desktop environment does not display the application menu, then it will automatically be included in the menubar or in the windows client-side decorations. ## A GtkApplicationWindow with a menubar |[<!-- language="C" --> GtkApplication *app = gtk_application_new ("org.gtk.test", 0); GtkBuilder *builder = gtk_builder_new_from_string ( "<interface>" " <menu id='menubar'>" " <submenu label='_Edit'>" " <item label='_Copy' action='win.copy'/>" " <item label='_Paste' action='win.paste'/>" " </submenu>" " </menu>" "</interface>", -1); GMenuModel *menubar = G_MENU_MODEL (gtk_builder_get_object (builder, "menubar")); gtk_application_set_menubar (GTK_APPLICATION (app), menubar); g_object_unref (builder); // ... GtkWidget *window = gtk_application_window_new (app); ]| ## Handling fallback yourself [A simple example](https://git.gnome.org/browse/gtk+/tree/examples/sunny.c) The XML format understood by #GtkBuilder for #GMenuModel consists of a toplevel `<menu>` element, which contains one or more `<item>` elements. Each `<item>` element contains `<attribute>` and `<link>` elements with a mandatory name attribute. `<link>` elements have the same content model as `<menu>`. Instead of `<link name="submenu>` or `<link name="section">`, you can use `<submenu>` or `<section>` elements. Attribute values can be translated using gettext, like other #GtkBuilder content. `<attribute>` elements can be marked for translation with a `translatable="yes"` attribute. It is also possible to specify message context and translator comments, using the context and comments attributes. To make use of this, the #GtkBuilder must have been given the gettext domain to use. The following attributes are used when constructing menu items: - "label": a user-visible string to display - "action": the prefixed name of the action to trigger - "target": the parameter to use when activating the action - "icon" and "verb-icon": names of icons that may be displayed - "submenu-action": name of an action that may be used to determine if a submenu can be opened - "hidden-when": a string used to determine when the item will be hidden. Possible values include "action-disabled", "action-missing", "macos-menubar". The following attributes are used when constructing sections: - "label": a user-visible string to use as section heading - "display-hint": a string used to determine special formatting for the section. Possible values include "horizontal-buttons". - "text-direction": a string used to determine the #GtkTextDirection to use when "display-hint" is set to "horizontal-buttons". Possible values include "rtl", "ltr", and "none". The following attributes are used when constructing submenus: - "label": a user-visible string to display - "icon": icon name to display Creates a new #GtkApplicationWindow. a newly created #GtkApplicationWindow a #GtkApplication Gets the #GtkShortcutsWindow that has been set up with a prior call to gtk_application_window_set_help_overlay(). the help overlay associated with @window, or %NULL a #GtkApplicationWindow Returns the unique ID of the window. If the window has not yet been added to a #GtkApplication, returns `0`. the unique ID for @window, or `0` if the window has not yet been added to a #GtkApplication a #GtkApplicationWindow Returns whether the window will display a menubar for the app menu and menubar as needed. %TRUE if @window will display a menubar when needed a #GtkApplicationWindow Associates a shortcuts window with the application window, and sets up an action with the name win.show-help-overlay to present it. @window takes resposibility for destroying @help_overlay. a #GtkApplicationWindow a #GtkShortcutsWindow Sets whether the window will display a menubar for the app menu and menubar as needed. a #GtkApplicationWindow whether to show a menubar when needed If this property is %TRUE, the window will display a menubar that includes the app menu and menubar, unless these are shown by the desktop shell. See gtk_application_set_app_menu() and gtk_application_set_menubar(). If %FALSE, the window will not display a menubar, regardless of whether the desktop shell is showing the menus or not. The parent class. GtkArrow should be used to draw simple arrows that need to point in one of the four cardinal directions (up, down, left, or right). The style of the arrow can be one of shadow in, shadow out, etched in, or etched out. Note that these directions and style types may be amended in versions of GTK+ to come. GtkArrow will fill any space alloted to it, but since it is inherited from #GtkMisc, it can be padded and/or aligned, to fill exactly the space the programmer desires. Arrows are created with a call to gtk_arrow_new(). The direction or style of an arrow can be changed after creation by using gtk_arrow_set(). GtkArrow has been deprecated; you can simply use a #GtkImage with a suitable icon name, such as “pan-down-symbolic“. When replacing GtkArrow by an image, pay attention to the fact that GtkArrow is doing automatic flipping between #GTK_ARROW_LEFT and #GTK_ARROW_RIGHT, depending on the text direction. To get the same effect with an image, use the icon names “pan-start-symbolic“ and “pan-end-symbolic“, which react to the text direction. Creates a new #GtkArrow widget. Use a #GtkImage with a suitable icon. the new #GtkArrow widget. a valid #GtkArrowType. a valid #GtkShadowType. Sets the direction and style of the #GtkArrow, @arrow. Use a #GtkImage with a suitable icon. a widget of type #GtkArrow. a valid #GtkArrowType. a valid #GtkShadowType. Used to specify the placement of scroll arrows in scrolling menus. Place one arrow on each end of the menu. Place both arrows at the top of the menu. Place both arrows at the bottom of the menu. Used to indicate the direction in which an arrow should point. Represents an upward pointing arrow. Represents a downward pointing arrow. Represents a left pointing arrow. Represents a right pointing arrow. No arrow. Since 2.10. The #GtkAspectFrame is useful when you want pack a widget so that it can resize but always retains the same aspect ratio. For instance, one might be drawing a small preview of a larger image. #GtkAspectFrame derives from #GtkFrame, so it can draw a label and a frame around the child. The frame will be “shrink-wrapped” to the size of the child. # CSS nodes GtkAspectFrame uses a CSS node with name frame. Create a new #GtkAspectFrame. the new #GtkAspectFrame. Label text. Horizontal alignment of the child within the allocation of the #GtkAspectFrame. This ranges from 0.0 (left aligned) to 1.0 (right aligned) Vertical alignment of the child within the allocation of the #GtkAspectFrame. This ranges from 0.0 (top aligned) to 1.0 (bottom aligned) The desired aspect ratio. If %TRUE, @ratio is ignored, and the aspect ratio is taken from the requistion of the child. Set parameters for an existing #GtkAspectFrame. a #GtkAspectFrame Horizontal alignment of the child within the allocation of the #GtkAspectFrame. This ranges from 0.0 (left aligned) to 1.0 (right aligned) Vertical alignment of the child within the allocation of the #GtkAspectFrame. This ranges from 0.0 (top aligned) to 1.0 (bottom aligned) The desired aspect ratio. If %TRUE, @ratio is ignored, and the aspect ratio is taken from the requistion of the child. The parent class. A #GtkAssistant is a widget used to represent a generally complex operation splitted in several steps, guiding the user through its pages and controlling the page flow to collect the necessary data. The design of GtkAssistant is that it controls what buttons to show and to make sensitive, based on what it knows about the page sequence and the [type][GtkAssistantPageType] of each page, in addition to state information like the page [completion][gtk-assistant-set-page-complete] and [committed][gtk-assistant-commit] status. If you have a case that doesn’t quite fit in #GtkAssistants way of handling buttons, you can use the #GTK_ASSISTANT_PAGE_CUSTOM page type and handle buttons yourself. # GtkAssistant as GtkBuildable The GtkAssistant implementation of the #GtkBuildable interface exposes the @action_area as internal children with the name “action_area”. To add pages to an assistant in #GtkBuilder, simply add it as a child to the GtkAssistant object, and set its child properties as necessary. # CSS nodes GtkAssistant has a single CSS node with the name assistant. Creates a new #GtkAssistant. a newly created #GtkAssistant Adds a widget to the action area of a #GtkAssistant. a #GtkAssistant a #GtkWidget Appends a page to the @assistant. the index (starting at 0) of the inserted page a #GtkAssistant a #GtkWidget Erases the visited page history so the back button is not shown on the current page, and removes the cancel button from subsequent pages. Use this when the information provided up to the current page is hereafter deemed permanent and cannot be modified or undone. For example, showing a progress page to track a long-running, unreversible operation after the user has clicked apply on a confirmation page. a #GtkAssistant Returns the page number of the current page. The index (starting from 0) of the current page in the @assistant, or -1 if the @assistant has no pages, or no current page. a #GtkAssistant Returns the number of pages in the @assistant the number of pages in the @assistant a #GtkAssistant Returns the child widget contained in page number @page_num. the child widget, or %NULL if @page_num is out of bounds a #GtkAssistant the index of a page in the @assistant, or -1 to get the last page Gets whether @page is complete. %TRUE if @page is complete. a #GtkAssistant a page of @assistant Gets whether page has padding. %TRUE if @page has padding a #GtkAssistant a page of @assistant Gets the header image for @page. Since GTK+ 3.2, a header is no longer shown; add your header decoration to the page content instead. the header image for @page, or %NULL if there’s no header image for the page a #GtkAssistant a page of @assistant Gets the side image for @page. Since GTK+ 3.2, sidebar images are not shown anymore. the side image for @page, or %NULL if there’s no side image for the page a #GtkAssistant a page of @assistant Gets the title for @page. the title for @page a #GtkAssistant a page of @assistant Gets the page type of @page. the page type of @page a #GtkAssistant a page of @assistant Inserts a page in the @assistant at a given position. the index (starting from 0) of the inserted page a #GtkAssistant a #GtkWidget the index (starting at 0) at which to insert the page, or -1 to append the page to the @assistant Navigate to the next page. It is a programming error to call this function when there is no next page. This function is for use when creating pages of the #GTK_ASSISTANT_PAGE_CUSTOM type. a #GtkAssistant Prepends a page to the @assistant. the index (starting at 0) of the inserted page a #GtkAssistant a #GtkWidget Navigate to the previous visited page. It is a programming error to call this function when no previous page is available. This function is for use when creating pages of the #GTK_ASSISTANT_PAGE_CUSTOM type. a #GtkAssistant Removes a widget from the action area of a #GtkAssistant. a #GtkAssistant a #GtkWidget Removes the @page_num’s page from @assistant. a #GtkAssistant the index of a page in the @assistant, or -1 to remove the last page Switches the page to @page_num. Note that this will only be necessary in custom buttons, as the @assistant flow can be set with gtk_assistant_set_forward_page_func(). a #GtkAssistant index of the page to switch to, starting from 0. If negative, the last page will be used. If greater than the number of pages in the @assistant, nothing will be done. Sets the page forwarding function to be @page_func. This function will be used to determine what will be the next page when the user presses the forward button. Setting @page_func to %NULL will make the assistant to use the default forward function, which just goes to the next visible page. a #GtkAssistant the #GtkAssistantPageFunc, or %NULL to use the default one user data for @page_func destroy notifier for @data Sets whether @page contents are complete. This will make @assistant update the buttons state to be able to continue the task. a #GtkAssistant a page of @assistant the completeness status of the page Sets whether the assistant is adding padding around the page. a #GtkAssistant a page of @assistant whether this page has padding Sets a header image for @page. Since GTK+ 3.2, a header is no longer shown; add your header decoration to the page content instead. a #GtkAssistant a page of @assistant the new header image @page Sets a side image for @page. This image used to be displayed in the side area of the assistant when @page is the current page. Since GTK+ 3.2, sidebar images are not shown anymore. a #GtkAssistant a page of @assistant the new side image @page Sets a title for @page. The title is displayed in the header area of the assistant when @page is the current page. a #GtkAssistant a page of @assistant the new title for @page Sets the page type for @page. The page type determines the page behavior in the @assistant. a #GtkAssistant a page of @assistant the new type for @page Forces @assistant to recompute the buttons state. GTK+ automatically takes care of this in most situations, e.g. when the user goes to a different page, or when the visibility or completeness of a page changes. One situation where it can be necessary to call this function is when changing a value on the current page affects the future page flow of the assistant. a #GtkAssistant %TRUE if the assistant uses a #GtkHeaderBar for action buttons instead of the action-area. For technical reasons, this property is declared as an integer property, but you should only set it to %TRUE or %FALSE. The ::apply signal is emitted when the apply button is clicked. The default behavior of the #GtkAssistant is to switch to the page after the current page, unless the current page is the last one. A handler for the ::apply signal should carry out the actions for which the wizard has collected data. If the action takes a long time to complete, you might consider putting a page of type %GTK_ASSISTANT_PAGE_PROGRESS after the confirmation page and handle this operation within the #GtkAssistant::prepare signal of the progress page. The ::cancel signal is emitted when then the cancel button is clicked. The ::close signal is emitted either when the close button of a summary page is clicked, or when the apply button in the last page in the flow (of type %GTK_ASSISTANT_PAGE_CONFIRM) is clicked. The ::prepare signal is emitted when a new page is set as the assistant's current page, before making the new page visible. A handler for this signal can do any preparations which are necessary before showing @page. the current page The parent class. A function used by gtk_assistant_set_forward_page_func() to know which is the next page given a current one. It’s called both for computing the next page when the user presses the “forward” button and for handling the behavior of the “last” button. The next page number. The page number used to calculate the next page. user data. An enum for determining the page role inside the #GtkAssistant. It's used to handle buttons sensitivity and visibility. Note that an assistant needs to end its page flow with a page of type %GTK_ASSISTANT_PAGE_CONFIRM, %GTK_ASSISTANT_PAGE_SUMMARY or %GTK_ASSISTANT_PAGE_PROGRESS to be correct. The Cancel button will only be shown if the page isn’t “committed”. See gtk_assistant_commit() for details. The page has regular contents. Both the Back and forward buttons will be shown. The page contains an introduction to the assistant task. Only the Forward button will be shown if there is a next page. The page lets the user confirm or deny the changes. The Back and Apply buttons will be shown. The page informs the user of the changes done. Only the Close button will be shown. Used for tasks that take a long time to complete, blocks the assistant until the page is marked as complete. Only the back button will be shown. Used for when other page types are not appropriate. No buttons will be shown, and the application must add its own buttons through gtk_assistant_add_action_widget(). Denotes the expansion properties that a widget will have when it (or its parent) is resized. the widget should expand to take up any extra space in its container that has been allocated. the widget should shrink as and when possible. the widget should fill the space allocated to it. Like gtk_get_binary_age(), but from the headers used at application compile time, rather than from the library linked against at application run time. This macro should be used to emit a warning about and unexpected @type value in a #GtkBuildable add_child implementation. the #GtkBuildable on which the warning ocurred the unexpected type value Whenever a container has some form of natural row it may align children in that row along a common typographical baseline. If the amount of verical space in the row is taller than the total requested height of the baseline-aligned children then it can use a #GtkBaselinePosition to select where to put the baseline inside the extra availible space. Align the baseline at the top Center the baseline Align the baseline at the bottom The #GtkBin widget is a container with just one child. It is not very useful itself, but it is useful for deriving subclasses, since it provides common code needed for handling a single child widget. Many GTK+ widgets are subclasses of #GtkBin, including #GtkWindow, #GtkButton, #GtkFrame, #GtkHandleBox or #GtkScrolledWindow. Gets the child of the #GtkBin, or %NULL if the bin contains no child widget. The returned widget does not have a reference added, so you do not need to unref it. the child of @bin, or %NULL if it does not have a child. a #GtkBin The parent class. A #GtkBindingArg holds the data associated with an argument for a key binding signal emission as stored in #GtkBindingSignal. implementation detail Each key binding element of a binding sets binding list is represented by a GtkBindingEntry. key value to match key modifiers to match binding set this entry belongs to implementation detail implementation detail implementation detail linked list of entries maintained by binding set implementation detail action signals of this entry Override or install a new key binding for @keyval with @modifiers on @binding_set. When the binding is activated, @signal_name will be emitted on the target widget, with @n_args @Varargs used as arguments. Each argument to the signal must be passed as a pair of varargs: the #GType of the argument, followed by the argument value (which must be of the given type). There must be @n_args pairs in total. ## Adding a Key Binding |[<!-- language="C" --> GtkBindingSet *binding_set; GdkModifierType modmask = GDK_CONTROL_MASK; int count = 1; gtk_binding_entry_add_signal (binding_set, GDK_KEY_space, modmask, "move-cursor", 2, GTK_TYPE_MOVEMENT_STEP, GTK_MOVEMENT_PAGES, G_TYPE_INT, count, G_TYPE_BOOLEAN, FALSE); ]| a #GtkBindingSet to install an entry for key value of binding to install key modifier of binding to install signal to execute upon activation number of arguments to @signal_name arguments to @signal_name Parses a signal description from @signal_desc and incorporates it into @binding_set. Signal descriptions may either bind a key combination to one or more signals: |[ bind "key" { "signalname" (param, ...) ... } ]| Or they may also unbind a key combination: |[ unbind "key" ]| Key combinations must be in a format that can be parsed by gtk_accelerator_parse(). %G_TOKEN_NONE if the signal was successfully parsed and added, the expected token otherwise a #GtkBindingSet a signal description Override or install a new key binding for @keyval with @modifiers on @binding_set. a #GtkBindingSet to add a signal to key value key modifier signal name to be bound list of #GtkBindingArg signal arguments Remove a binding previously installed via gtk_binding_entry_add_signal() on @binding_set. a #GtkBindingSet to remove an entry of key value of binding to remove key modifier of binding to remove Install a binding on @binding_set which causes key lookups to be aborted, to prevent bindings from lower priority sets to be activated. a #GtkBindingSet to skip an entry of key value of binding to skip key modifier of binding to skip A binding set maintains a list of activatable key bindings. A single binding set can match multiple types of widgets. Similar to style contexts, can be matched by any information contained in a widgets #GtkWidgetPath. When a binding within a set is matched upon activation, an action signal is emitted on the target widget to carry out the actual activation. unique name of this binding set unused unused unused unused the key binding entries in this binding set implementation detail whether this binding set stems from a CSS file and is reset upon theme changes Find a key binding matching @keyval and @modifiers within @binding_set and activate the binding on @object. %TRUE if a binding was found and activated a #GtkBindingSet set to activate key value of the binding key modifier of the binding object to activate when binding found This function was used internally by the GtkRC parsing mechanism to assign match patterns to #GtkBindingSet structures. In GTK+ 3, these match patterns are unused. a #GtkBindingSet to add a path to path type the pattern applies to the actual match pattern binding priority This function returns the binding set named after the type name of the passed in class structure. New binding sets are created on demand by this function. the binding set corresponding to @object_class a valid #GObject class Find a binding set by its globally unique name. The @set_name can either be a name used for gtk_binding_set_new() or the type name of a class used in gtk_binding_set_by_class(). %NULL or the specified binding set unique binding set name GTK+ maintains a global list of binding sets. Each binding set has a unique name which needs to be specified upon creation. new binding set unique name of this binding set A GtkBindingSignal stores the necessary information to activate a widget in response to a key press via a signal emission. implementation detail the action signal to be emitted number of arguments specified for the signal the arguments specified for the signal A struct that specifies a border around a rectangular area that can be of different width on each side. The width of the left border The width of the right border The width of the top border The width of the bottom border Allocates a new #GtkBorder-struct and initializes its elements to zero. a newly allocated #GtkBorder-struct. Free with gtk_border_free() Copies a #GtkBorder-struct. a copy of @border_. a #GtkBorder-struct Frees a #GtkBorder-struct. a #GtkBorder-struct Describes how the border of a UI element should be rendered. No visible border A single line segment Looks as if the content is sunken into the canvas Looks as if the content is coming out of the canvas Same as @GTK_BORDER_STYLE_NONE A series of round dots A series of square-ended dashes Two parallel lines with some space between them Looks as if it were carved in the canvas Looks as if it were coming out of the canvas The GtkBox widget arranges child widgets into a single row or column, depending upon the value of its #GtkOrientable:orientation property. Within the other dimension, all children are allocated the same size. Of course, the #GtkWidget:halign and #GtkWidget:valign properties can be used on the children to influence their allocation. GtkBox uses a notion of packing. Packing refers to adding widgets with reference to a particular position in a #GtkContainer. For a GtkBox, there are two reference positions: the start and the end of the box. For a vertical #GtkBox, the start is defined as the top of the box and the end is defined as the bottom. For a horizontal #GtkBox the start is defined as the left side and the end is defined as the right side. Use repeated calls to gtk_box_pack_start() to pack widgets into a GtkBox from start to end. Use gtk_box_pack_end() to add widgets from end to start. You may intersperse these calls and add widgets from both ends of the same GtkBox. Because GtkBox is a #GtkContainer, you may also use gtk_container_add() to insert widgets into the box, and they will be packed with the default values for expand and fill child properties. Use gtk_container_remove() to remove widgets from the GtkBox. Use gtk_box_set_homogeneous() to specify whether or not all children of the GtkBox are forced to get the same amount of space. Use gtk_box_set_spacing() to determine how much space will be minimally placed between all children in the GtkBox. Note that spacing is added between the children, while padding added by gtk_box_pack_start() or gtk_box_pack_end() is added on either side of the widget it belongs to. Use gtk_box_reorder_child() to move a GtkBox child to a different place in the box. Use gtk_box_set_child_packing() to reset the expand, fill and padding child properties. Use gtk_box_query_child_packing() to query these fields. # CSS nodes GtkBox uses a single CSS node with name box. In horizontal orientation, the nodes of the children are always arranged from left to right. So :first-child will always select the leftmost child, regardless of text direction. Creates a new #GtkBox. a new #GtkBox. the box’s orientation. the number of pixels to place by default between children. Gets the value set by gtk_box_set_baseline_position(). the baseline position a #GtkBox Retrieves the center widget of the box. the center widget or %NULL in case no center widget is set. a #GtkBox Returns whether the box is homogeneous (all children are the same size). See gtk_box_set_homogeneous(). %TRUE if the box is homogeneous. a #GtkBox Gets the value set by gtk_box_set_spacing(). spacing between children a #GtkBox Adds @child to @box, packed with reference to the end of @box. The @child is packed after (away from end of) any other child packed with reference to the end of @box. a #GtkBox the #GtkWidget to be added to @box %TRUE if the new child is to be given extra space allocated to @box. The extra space will be divided evenly between all children of @box that use this option %TRUE if space given to @child by the @expand option is actually allocated to @child, rather than just padding it. This parameter has no effect if @expand is set to %FALSE. A child is always allocated the full height of a horizontal #GtkBox and the full width of a vertical #GtkBox. This option affects the other dimension extra space in pixels to put between this child and its neighbors, over and above the global amount specified by #GtkBox:spacing property. If @child is a widget at one of the reference ends of @box, then @padding pixels are also put between @child and the reference edge of @box Adds @child to @box, packed with reference to the start of @box. The @child is packed after any other child packed with reference to the start of @box. a #GtkBox the #GtkWidget to be added to @box %TRUE if the new child is to be given extra space allocated to @box. The extra space will be divided evenly between all children that use this option %TRUE if space given to @child by the @expand option is actually allocated to @child, rather than just padding it. This parameter has no effect if @expand is set to %FALSE. A child is always allocated the full height of a horizontal #GtkBox and the full width of a vertical #GtkBox. This option affects the other dimension extra space in pixels to put between this child and its neighbors, over and above the global amount specified by #GtkBox:spacing property. If @child is a widget at one of the reference ends of @box, then @padding pixels are also put between @child and the reference edge of @box Obtains information about how @child is packed into @box. a #GtkBox the #GtkWidget of the child to query pointer to return location for expand child property pointer to return location for fill child property pointer to return location for padding child property pointer to return location for pack-type child property Moves @child to a new @position in the list of @box children. The list contains widgets packed #GTK_PACK_START as well as widgets packed #GTK_PACK_END, in the order that these widgets were added to @box. A widget’s position in the @box children list determines where the widget is packed into @box. A child widget at some position in the list will be packed just after all other widgets of the same packing type that appear earlier in the list. a #GtkBox the #GtkWidget to move the new position for @child in the list of children of @box, starting from 0. If negative, indicates the end of the list Sets the baseline position of a box. This affects only horizontal boxes with at least one baseline aligned child. If there is more vertical space available than requested, and the baseline is not allocated by the parent then @position is used to allocate the baseline wrt the extra space available. a #GtkBox a #GtkBaselinePosition Sets a center widget; that is a child widget that will be centered with respect to the full width of the box, even if the children at either side take up different amounts of space. a #GtkBox the widget to center Sets the way @child is packed into @box. a #GtkBox the #GtkWidget of the child to set the new value of the expand child property the new value of the fill child property the new value of the padding child property the new value of the pack-type child property Sets the #GtkBox:homogeneous property of @box, controlling whether or not all children of @box are given equal space in the box. a #GtkBox a boolean value, %TRUE to create equal allotments, %FALSE for variable allotments Sets the #GtkBox:spacing property of @box, which is the number of pixels to place between children of @box. a #GtkBox the number of pixels to put between children The parent class. GtkBuildable allows objects to extend and customize their deserialization from [GtkBuilder UI descriptions][BUILDER-UI]. The interface includes methods for setting names and properties of objects, parsing custom tags and constructing child objects. The GtkBuildable interface is implemented by all widgets and many of the non-widget objects that are provided by GTK+. The main user of this interface is #GtkBuilder. There should be very little need for applications to call any of these functions directly. An object only needs to implement this interface if it needs to extend the #GtkBuilder format or run any extra routines at deserialization time. Adds a child to @buildable. @type is an optional string describing how the child should be added. a #GtkBuildable a #GtkBuilder child to add kind of child or %NULL Constructs a child of @buildable with the name @name. #GtkBuilder calls this function if a “constructor” has been specified in the UI definition. the constructed child A #GtkBuildable #GtkBuilder used to construct this object name of child to construct This is similar to gtk_buildable_parser_finished() but is called once for each custom tag handled by the @buildable. a #GtkBuildable a #GtkBuilder child object or %NULL for non-child tags the name of the tag user data created in custom_tag_start This is called at the end of each custom element handled by the buildable. A #GtkBuildable #GtkBuilder used to construct this object child object or %NULL for non-child tags name of tag user data that will be passed in to parser functions This is called for each unknown element under <child>. %TRUE if a object has a custom implementation, %FALSE if it doesn't. a #GtkBuildable a #GtkBuilder used to construct this object child object or %NULL for non-child tags name of tag a #GMarkupParser to fill in return location for user data that will be passed in to parser functions Get the internal child called @childname of the @buildable object. the internal child of the buildable object a #GtkBuildable a #GtkBuilder name of child Gets the name of the @buildable object. #GtkBuilder sets the name based on the [GtkBuilder UI definition][BUILDER-UI] used to construct the @buildable. the name set with gtk_buildable_set_name() a #GtkBuildable Called when the builder finishes the parsing of a [GtkBuilder UI definition][BUILDER-UI]. Note that this will be called once for each time gtk_builder_add_from_file() or gtk_builder_add_from_string() is called on a builder. a #GtkBuildable a #GtkBuilder Sets the property name @name to @value on the @buildable object. a #GtkBuildable a #GtkBuilder name of property value of property Sets the name of the @buildable object. a #GtkBuildable name to set Adds a child to @buildable. @type is an optional string describing how the child should be added. a #GtkBuildable a #GtkBuilder child to add kind of child or %NULL Constructs a child of @buildable with the name @name. #GtkBuilder calls this function if a “constructor” has been specified in the UI definition. the constructed child A #GtkBuildable #GtkBuilder used to construct this object name of child to construct This is similar to gtk_buildable_parser_finished() but is called once for each custom tag handled by the @buildable. a #GtkBuildable a #GtkBuilder child object or %NULL for non-child tags the name of the tag user data created in custom_tag_start This is called at the end of each custom element handled by the buildable. A #GtkBuildable #GtkBuilder used to construct this object child object or %NULL for non-child tags name of tag user data that will be passed in to parser functions This is called for each unknown element under <child>. %TRUE if a object has a custom implementation, %FALSE if it doesn't. a #GtkBuildable a #GtkBuilder used to construct this object child object or %NULL for non-child tags name of tag a #GMarkupParser to fill in return location for user data that will be passed in to parser functions Get the internal child called @childname of the @buildable object. the internal child of the buildable object a #GtkBuildable a #GtkBuilder name of child Gets the name of the @buildable object. #GtkBuilder sets the name based on the [GtkBuilder UI definition][BUILDER-UI] used to construct the @buildable. the name set with gtk_buildable_set_name() a #GtkBuildable Called when the builder finishes the parsing of a [GtkBuilder UI definition][BUILDER-UI]. Note that this will be called once for each time gtk_builder_add_from_file() or gtk_builder_add_from_string() is called on a builder. a #GtkBuildable a #GtkBuilder Sets the property name @name to @value on the @buildable object. a #GtkBuildable a #GtkBuilder name of property value of property Sets the name of the @buildable object. a #GtkBuildable name to set The #GtkBuildableIface interface contains method that are necessary to allow #GtkBuilder to construct an object from a #GtkBuilder UI definition. the parent class a #GtkBuildable name to set the name set with gtk_buildable_set_name() a #GtkBuildable a #GtkBuildable a #GtkBuilder child to add kind of child or %NULL a #GtkBuildable a #GtkBuilder name of property value of property the constructed child A #GtkBuildable #GtkBuilder used to construct this object name of child to construct %TRUE if a object has a custom implementation, %FALSE if it doesn't. a #GtkBuildable a #GtkBuilder used to construct this object child object or %NULL for non-child tags name of tag a #GMarkupParser to fill in return location for user data that will be passed in to parser functions A #GtkBuildable #GtkBuilder used to construct this object child object or %NULL for non-child tags name of tag user data that will be passed in to parser functions a #GtkBuildable a #GtkBuilder child object or %NULL for non-child tags the name of the tag user data created in custom_tag_start a #GtkBuildable a #GtkBuilder the internal child of the buildable object a #GtkBuildable a #GtkBuilder name of child A GtkBuilder is an auxiliary object that reads textual descriptions of a user interface and instantiates the described objects. To create a GtkBuilder from a user interface description, call gtk_builder_new_from_file(), gtk_builder_new_from_resource() or gtk_builder_new_from_string(). In the (unusual) case that you want to add user interface descriptions from multiple sources to the same GtkBuilder you can call gtk_builder_new() to get an empty builder and populate it by (multiple) calls to gtk_builder_add_from_file(), gtk_builder_add_from_resource() or gtk_builder_add_from_string(). A GtkBuilder holds a reference to all objects that it has constructed and drops these references when it is finalized. This finalization can cause the destruction of non-widget objects or widgets which are not contained in a toplevel window. For toplevel windows constructed by a builder, it is the responsibility of the user to call gtk_widget_destroy() to get rid of them and all the widgets they contain. The functions gtk_builder_get_object() and gtk_builder_get_objects() can be used to access the widgets in the interface by the names assigned to them inside the UI description. Toplevel windows returned by these functions will stay around until the user explicitly destroys them with gtk_widget_destroy(). Other widgets will either be part of a larger hierarchy constructed by the builder (in which case you should not have to worry about their lifecycle), or without a parent, in which case they have to be added to some container to make use of them. Non-widget objects need to be reffed with g_object_ref() to keep them beyond the lifespan of the builder. The function gtk_builder_connect_signals() and variants thereof can be used to connect handlers to the named signals in the description. # GtkBuilder UI Definitions # {#BUILDER-UI} GtkBuilder parses textual descriptions of user interfaces which are specified in an XML format which can be roughly described by the RELAX NG schema below. We refer to these descriptions as “GtkBuilder UI definitions” or just “UI definitions” if the context is clear. Do not confuse GtkBuilder UI Definitions with [GtkUIManager UI Definitions][XML-UI], which are more limited in scope. It is common to use `.ui` as the filename extension for files containing GtkBuilder UI definitions. [RELAX NG Compact Syntax](https://gitlab.gnome.org/GNOME/gtk/-/blob/gtk-3-24/gtk/gtkbuilder.rnc) The toplevel element is <interface>. It optionally takes a “domain” attribute, which will make the builder look for translated strings using dgettext() in the domain specified. This can also be done by calling gtk_builder_set_translation_domain() on the builder. Objects are described by <object> elements, which can contain <property> elements to set properties, <signal> elements which connect signals to handlers, and <child> elements, which describe child objects (most often widgets inside a container, but also e.g. actions in an action group, or columns in a tree model). A <child> element contains an <object> element which describes the child object. The target toolkit version(s) are described by <requires> elements, the “lib” attribute specifies the widget library in question (currently the only supported value is “gtk+”) and the “version” attribute specifies the target version in the form “<major>.<minor>”. The builder will error out if the version requirements are not met. Typically, the specific kind of object represented by an <object> element is specified by the “class” attribute. If the type has not been loaded yet, GTK+ tries to find the get_type() function from the class name by applying heuristics. This works in most cases, but if necessary, it is possible to specify the name of the get_type() function explictly with the "type-func" attribute. As a special case, GtkBuilder allows to use an object that has been constructed by a #GtkUIManager in another part of the UI definition by specifying the id of the #GtkUIManager in the “constructor” attribute and the name of the object in the “id” attribute. Objects may be given a name with the “id” attribute, which allows the application to retrieve them from the builder with gtk_builder_get_object(). An id is also necessary to use the object as property value in other parts of the UI definition. GTK+ reserves ids starting and ending with ___ (3 underscores) for its own purposes. Setting properties of objects is pretty straightforward with the <property> element: the “name” attribute specifies the name of the property, and the content of the element specifies the value. If the “translatable” attribute is set to a true value, GTK+ uses gettext() (or dgettext() if the builder has a translation domain set) to find a translation for the value. This happens before the value is parsed, so it can be used for properties of any type, but it is probably most useful for string properties. It is also possible to specify a context to disambiguate short strings, and comments which may help the translators. GtkBuilder can parse textual representations for the most common property types: characters, strings, integers, floating-point numbers, booleans (strings like “TRUE”, “t”, “yes”, “y”, “1” are interpreted as %TRUE, strings like “FALSE”, “f”, “no”, “n”, “0” are interpreted as %FALSE), enumerations (can be specified by their name, nick or integer value), flags (can be specified by their name, nick, integer value, optionally combined with “|”, e.g. “GTK_VISIBLE|GTK_REALIZED”) and colors (in a format understood by gdk_rgba_parse()). GVariants can be specified in the format understood by g_variant_parse(), and pixbufs can be specified as a filename of an image file to load. Objects can be referred to by their name and by default refer to objects declared in the local xml fragment and objects exposed via gtk_builder_expose_object(). In general, GtkBuilder allows forward references to objects — declared in the local xml; an object doesn’t have to be constructed before it can be referred to. The exception to this rule is that an object has to be constructed before it can be used as the value of a construct-only property. It is also possible to bind a property value to another object's property value using the attributes "bind-source" to specify the source object of the binding, "bind-property" to specify the source property and optionally "bind-flags" to specify the binding flags. Internally builder implements this using GBinding objects. For more information see g_object_bind_property() Signal handlers are set up with the <signal> element. The “name” attribute specifies the name of the signal, and the “handler” attribute specifies the function to connect to the signal. By default, GTK+ tries to find the handler using g_module_symbol(), but this can be changed by passing a custom #GtkBuilderConnectFunc to gtk_builder_connect_signals_full(). The remaining attributes, “after”, “swapped” and “object”, have the same meaning as the corresponding parameters of the g_signal_connect_object() or g_signal_connect_data() functions. A “last_modification_time” attribute is also allowed, but it does not have a meaning to the builder. Sometimes it is necessary to refer to widgets which have implicitly been constructed by GTK+ as part of a composite widget, to set properties on them or to add further children (e.g. the @vbox of a #GtkDialog). This can be achieved by setting the “internal-child” property of the <child> element to a true value. Note that GtkBuilder still requires an <object> element for the internal child, even if it has already been constructed. A number of widgets have different places where a child can be added (e.g. tabs vs. page content in notebooks). This can be reflected in a UI definition by specifying the “type” attribute on a <child> The possible values for the “type” attribute are described in the sections describing the widget-specific portions of UI definitions. # A GtkBuilder UI Definition |[ <interface> <object class="GtkDialog" id="dialog1"> <child internal-child="vbox"> <object class="GtkBox" id="vbox1"> <property name="border-width">10</property> <child internal-child="action_area"> <object class="GtkButtonBox" id="hbuttonbox1"> <property name="border-width">20</property> <child> <object class="GtkButton" id="ok_button"> <property name="label">gtk-ok</property> <property name="use-stock">TRUE</property> <signal name="clicked" handler="ok_button_clicked"/> </object> </child> </object> </child> </object> </child> </object> </interface> ]| Beyond this general structure, several object classes define their own XML DTD fragments for filling in the ANY placeholders in the DTD above. Note that a custom element in a <child> element gets parsed by the custom tag handler of the parent object, while a custom element in an <object> element gets parsed by the custom tag handler of the object. These XML fragments are explained in the documentation of the respective objects. Additionally, since 3.10 a special <template> tag has been added to the format allowing one to define a widget class’s components. See the [GtkWidget documentation][composite-templates] for details. Creates a new empty builder object. This function is only useful if you intend to make multiple calls to gtk_builder_add_from_file(), gtk_builder_add_from_resource() or gtk_builder_add_from_string() in order to merge multiple UI descriptions into a single builder. Most users will probably want to use gtk_builder_new_from_file(), gtk_builder_new_from_resource() or gtk_builder_new_from_string(). a new (empty) #GtkBuilder object Builds the [GtkBuilder UI definition][BUILDER-UI] in the file @filename. If there is an error opening the file or parsing the description then the program will be aborted. You should only ever attempt to parse user interface descriptions that are shipped as part of your program. a #GtkBuilder containing the described interface filename of user interface description file Builds the [GtkBuilder UI definition][BUILDER-UI] at @resource_path. If there is an error locating the resource or parsing the description, then the program will be aborted. a #GtkBuilder containing the described interface a #GResource resource path Builds the user interface described by @string (in the [GtkBuilder UI definition][BUILDER-UI] format). If @string is %NULL-terminated, then @length should be -1. If @length is not -1, then it is the length of @string. If there is an error parsing @string then the program will be aborted. You should not attempt to parse user interface description from untrusted sources. a #GtkBuilder containing the interface described by @string a user interface (XML) description the length of @string, or -1 Looks up a type by name, using the virtual function that #GtkBuilder has for that purpose. This is mainly used when implementing the #GtkBuildable interface on a type. the #GType found for @type_name or #G_TYPE_INVALID if no type was found a #GtkBuilder type name to lookup Adds the @callback_symbol to the scope of @builder under the given @callback_name. Using this function overrides the behavior of gtk_builder_connect_signals() for any callback symbols that are added. Using this method allows for better encapsulation as it does not require that callback symbols be declared in the global namespace. a #GtkBuilder The name of the callback, as expected in the XML The callback pointer A convenience function to add many callbacks instead of calling gtk_builder_add_callback_symbol() for each symbol. a #GtkBuilder The name of the callback, as expected in the XML The callback pointer A list of callback name and callback symbol pairs terminated with %NULL Parses a file containing a [GtkBuilder UI definition][BUILDER-UI] and merges it with the current contents of @builder. Most users will probably want to use gtk_builder_new_from_file(). If an error occurs, 0 will be returned and @error will be assigned a #GError from the #GTK_BUILDER_ERROR, #G_MARKUP_ERROR or #G_FILE_ERROR domain. It’s not really reasonable to attempt to handle failures of this call. You should not use this function with untrusted files (ie: files that are not part of your application). Broken #GtkBuilder files can easily crash your program, and it’s possible that memory was leaked leading up to the reported failure. The only reasonable thing to do when an error is detected is to call g_error(). A positive value on success, 0 if an error occurred a #GtkBuilder the name of the file to parse Parses a resource file containing a [GtkBuilder UI definition][BUILDER-UI] and merges it with the current contents of @builder. Most users will probably want to use gtk_builder_new_from_resource(). If an error occurs, 0 will be returned and @error will be assigned a #GError from the #GTK_BUILDER_ERROR, #G_MARKUP_ERROR or #G_RESOURCE_ERROR domain. It’s not really reasonable to attempt to handle failures of this call. The only reasonable thing to do when an error is detected is to call g_error(). A positive value on success, 0 if an error occurred a #GtkBuilder the path of the resource file to parse Parses a string containing a [GtkBuilder UI definition][BUILDER-UI] and merges it with the current contents of @builder. Most users will probably want to use gtk_builder_new_from_string(). Upon errors 0 will be returned and @error will be assigned a #GError from the #GTK_BUILDER_ERROR, #G_MARKUP_ERROR or #G_VARIANT_PARSE_ERROR domain. It’s not really reasonable to attempt to handle failures of this call. The only reasonable thing to do when an error is detected is to call g_error(). A positive value on success, 0 if an error occurred a #GtkBuilder the string to parse the length of @buffer (may be -1 if @buffer is nul-terminated) Parses a file containing a [GtkBuilder UI definition][BUILDER-UI] building only the requested objects and merges them with the current contents of @builder. Upon errors 0 will be returned and @error will be assigned a #GError from the #GTK_BUILDER_ERROR, #G_MARKUP_ERROR or #G_FILE_ERROR domain. If you are adding an object that depends on an object that is not its child (for instance a #GtkTreeView that depends on its #GtkTreeModel), you have to explicitly list all of them in @object_ids. A positive value on success, 0 if an error occurred a #GtkBuilder the name of the file to parse nul-terminated array of objects to build Parses a resource file containing a [GtkBuilder UI definition][BUILDER-UI] building only the requested objects and merges them with the current contents of @builder. Upon errors 0 will be returned and @error will be assigned a #GError from the #GTK_BUILDER_ERROR, #G_MARKUP_ERROR or #G_RESOURCE_ERROR domain. If you are adding an object that depends on an object that is not its child (for instance a #GtkTreeView that depends on its #GtkTreeModel), you have to explicitly list all of them in @object_ids. A positive value on success, 0 if an error occurred a #GtkBuilder the path of the resource file to parse nul-terminated array of objects to build Parses a string containing a [GtkBuilder UI definition][BUILDER-UI] building only the requested objects and merges them with the current contents of @builder. Upon errors 0 will be returned and @error will be assigned a #GError from the #GTK_BUILDER_ERROR or #G_MARKUP_ERROR domain. If you are adding an object that depends on an object that is not its child (for instance a #GtkTreeView that depends on its #GtkTreeModel), you have to explicitly list all of them in @object_ids. A positive value on success, 0 if an error occurred a #GtkBuilder the string to parse the length of @buffer (may be -1 if @buffer is nul-terminated) nul-terminated array of objects to build This method is a simpler variation of gtk_builder_connect_signals_full(). It uses symbols explicitly added to @builder with prior calls to gtk_builder_add_callback_symbol(). In the case that symbols are not explicitly added; it uses #GModule’s introspective features (by opening the module %NULL) to look at the application’s symbol table. From here it tries to match the signal handler names given in the interface description with symbols in the application and connects the signals. Note that this function can only be called once, subsequent calls will do nothing. Note that unless gtk_builder_add_callback_symbol() is called for all signal callbacks which are referenced by the loaded XML, this function will require that #GModule be supported on the platform. If you rely on #GModule support to lookup callbacks in the symbol table, the following details should be noted: When compiling applications for Windows, you must declare signal callbacks with #G_MODULE_EXPORT, or they will not be put in the symbol table. On Linux and Unices, this is not necessary; applications should instead be compiled with the -Wl,--export-dynamic CFLAGS, and linked against gmodule-export-2.0. a #GtkBuilder user data to pass back with all signals This function can be thought of the interpreted language binding version of gtk_builder_connect_signals(), except that it does not require GModule to function correctly. a #GtkBuilder the function used to connect the signals arbitrary data that will be passed to the connection function Add @object to the @builder object pool so it can be referenced just like any other object built by builder. a #GtkBuilder the name of the object exposed to the builder the object to expose Main private entry point for building composite container components from template XML. This is exported purely to let gtk-builder-tool validate templates, applications have no need to call this function. A positive value on success, 0 if an error occurred a #GtkBuilder the widget that is being extended the type that the template is for the string to parse the length of @buffer (may be -1 if @buffer is nul-terminated) Gets the #GtkApplication associated with the builder. The #GtkApplication is used for creating action proxies as requested from XML that the builder is loading. By default, the builder uses the default application: the one from g_application_get_default(). If you want to use another application for constructing proxies, use gtk_builder_set_application(). the application being used by the builder, or %NULL a #GtkBuilder Gets the object named @name. Note that this function does not increment the reference count of the returned object. the object named @name or %NULL if it could not be found in the object tree. a #GtkBuilder name of object to get Gets all objects that have been constructed by @builder. Note that this function does not increment the reference counts of the returned objects. a newly-allocated #GSList containing all the objects constructed by the #GtkBuilder instance. It should be freed by g_slist_free() a #GtkBuilder Gets the translation domain of @builder. the translation domain. This string is owned by the builder object and must not be modified or freed. a #GtkBuilder Looks up a type by name, using the virtual function that #GtkBuilder has for that purpose. This is mainly used when implementing the #GtkBuildable interface on a type. the #GType found for @type_name or #G_TYPE_INVALID if no type was found a #GtkBuilder type name to lookup Fetches a symbol previously added to @builder with gtk_builder_add_callback_symbols() This function is intended for possible use in language bindings or for any case that one might be cusomizing signal connections using gtk_builder_connect_signals_full() The callback symbol in @builder for @callback_name, or %NULL a #GtkBuilder The name of the callback Sets the application associated with @builder. You only need this function if there is more than one #GApplication in your process. @application cannot be %NULL. a #GtkBuilder a #GtkApplication Sets the translation domain of @builder. See #GtkBuilder:translation-domain. a #GtkBuilder the translation domain or %NULL This function demarshals a value from a string. This function calls g_value_init() on the @value argument, so it need not be initialised beforehand. This function can handle char, uchar, boolean, int, uint, long, ulong, enum, flags, float, double, string, #GdkColor, #GdkRGBA and #GtkAdjustment type values. Support for #GtkWidget type values is still to come. Upon errors %FALSE will be returned and @error will be assigned a #GError from the #GTK_BUILDER_ERROR domain. %TRUE on success a #GtkBuilder the #GParamSpec for the property the string representation of the value the #GValue to store the result in Like gtk_builder_value_from_string(), this function demarshals a value from a string, but takes a #GType instead of #GParamSpec. This function calls g_value_init() on the @value argument, so it need not be initialised beforehand. Upon errors %FALSE will be returned and @error will be assigned a #GError from the #GTK_BUILDER_ERROR domain. %TRUE on success a #GtkBuilder the #GType of the value the string representation of the value the #GValue to store the result in The translation domain used when translating property values that have been marked as translatable in interface descriptions. If the translation domain is %NULL, #GtkBuilder uses gettext(), otherwise g_dgettext(). the #GType found for @type_name or #G_TYPE_INVALID if no type was found a #GtkBuilder type name to lookup This is the signature of a function used to connect signals. It is used by the gtk_builder_connect_signals() and gtk_builder_connect_signals_full() methods. It is mainly intended for interpreted language bindings, but could be useful where the programmer wants more control over the signal connection process. Note that this function can only be called once, subsequent calls will do nothing. a #GtkBuilder object to connect a signal to name of the signal name of the handler a #GObject, if non-%NULL, use g_signal_connect_object() #GConnectFlags to use user data Error codes that identify various errors that can occur while using #GtkBuilder. A type-func attribute didn’t name a function that returns a #GType. The input contained a tag that #GtkBuilder can’t handle. An attribute that is required by #GtkBuilder was missing. #GtkBuilder found an attribute that it doesn’t understand. #GtkBuilder found a tag that it doesn’t understand. A required property value was missing. #GtkBuilder couldn’t parse some attribute value. The input file requires a newer version of GTK+. An object id occurred twice. A specified object type is of the same type or derived from the type of the composite class being extended with builder XML. The wrong type was specified in a composite class’s template XML The specified property is unknown for the object class. The specified signal is unknown for the object class. An object id is unknown The #GtkButton widget is generally used to trigger a callback function that is called when the button is pressed. The various signals and how to use them are outlined below. The #GtkButton widget can hold any valid child widget. That is, it can hold almost any other standard #GtkWidget. The most commonly used child is the #GtkLabel. # CSS nodes GtkButton has a single CSS node with name button. The node will get the style classes .image-button or .text-button, if the content is just an image or label, respectively. It may also receive the .flat style class. Other style classes that are commonly used with GtkButton include .suggested-action and .destructive-action. In special cases, buttons can be made round by adding the .circular style class. Button-like widgets like #GtkToggleButton, #GtkMenuButton, #GtkVolumeButton, #GtkLockButton, #GtkColorButton, #GtkFontButton or #GtkFileChooserButton use style classes such as .toggle, .popup, .scale, .lock, .color, .font, .file to differentiate themselves from a plain GtkButton. Creates a new #GtkButton widget. To add a child widget to the button, use gtk_container_add(). The newly created #GtkButton widget. Creates a new button containing an icon from the current icon theme. If the icon name isn’t known, a “broken image” icon will be displayed instead. If the current icon theme is changed, the icon will be updated appropriately. This function is a convenience wrapper around gtk_button_new() and gtk_button_set_image(). a new #GtkButton displaying the themed icon an icon name or %NULL an icon size (#GtkIconSize) Creates a new #GtkButton containing the image and text from a [stock item][gtkstock]. Some stock ids have preprocessor macros like #GTK_STOCK_OK and #GTK_STOCK_APPLY. If @stock_id is unknown, then it will be treated as a mnemonic label (as for gtk_button_new_with_mnemonic()). Stock items are deprecated. Use gtk_button_new_with_label() instead. a new #GtkButton the name of the stock item Creates a #GtkButton widget with a #GtkLabel child containing the given text. The newly created #GtkButton widget. The text you want the #GtkLabel to hold. Creates a new #GtkButton containing a label. If characters in @label are preceded by an underscore, they are underlined. If you need a literal underscore character in a label, use “__” (two underscores). The first underlined character represents a keyboard accelerator called a mnemonic. Pressing Alt and that key activates the button. a new #GtkButton The text of the button, with an underscore in front of the mnemonic character Emits a #GtkButton::clicked signal to the given #GtkButton. The #GtkButton you want to send the signal to. Emits a #GtkButton::enter signal to the given #GtkButton. Use the #GtkWidget::enter-notify-event signal. The #GtkButton you want to send the signal to. Emits a #GtkButton::leave signal to the given #GtkButton. Use the #GtkWidget::leave-notify-event signal. The #GtkButton you want to send the signal to. Emits a #GtkButton::pressed signal to the given #GtkButton. Use the #GtkWidget::button-press-event signal. The #GtkButton you want to send the signal to. Emits a #GtkButton::released signal to the given #GtkButton. Use the #GtkWidget::button-release-event signal. The #GtkButton you want to send the signal to. Emits a #GtkButton::clicked signal to the given #GtkButton. The #GtkButton you want to send the signal to. Emits a #GtkButton::enter signal to the given #GtkButton. Use the #GtkWidget::enter-notify-event signal. The #GtkButton you want to send the signal to. Gets the alignment of the child in the button. Access the child widget directly if you need to control its alignment. a #GtkButton return location for horizontal alignment return location for vertical alignment Returns whether the button will ignore the #GtkSettings:gtk-button-images setting and always show the image, if available. %TRUE if the button will always show the image a #GtkButton Returns the button’s event window if it is realized, %NULL otherwise. This function should be rarely needed. @button’s event window. a #GtkButton Returns whether the button grabs focus when it is clicked with the mouse. See gtk_button_set_focus_on_click(). Use gtk_widget_get_focus_on_click() instead %TRUE if the button grabs focus when it is clicked with the mouse. a #GtkButton Gets the widget that is currenty set as the image of @button. This may have been explicitly set by gtk_button_set_image() or constructed by gtk_button_new_from_stock(). a #GtkWidget or %NULL in case there is no image a #GtkButton Gets the position of the image relative to the text inside the button. the position a #GtkButton Fetches the text from the label of the button, as set by gtk_button_set_label(). If the label text has not been set the return value will be %NULL. This will be the case if you create an empty button with gtk_button_new() to use as a container. The text of the label widget. This string is owned by the widget and must not be modified or freed. a #GtkButton Returns the current relief style of the given #GtkButton. The current #GtkReliefStyle The #GtkButton you want the #GtkReliefStyle from. Returns whether the button label is a stock item. %TRUE if the button label is used to select a stock item instead of being used directly as the label text. a #GtkButton Returns whether an embedded underline in the button label indicates a mnemonic. See gtk_button_set_use_underline (). %TRUE if an embedded underline in the button label indicates the mnemonic accelerator keys. a #GtkButton Emits a #GtkButton::leave signal to the given #GtkButton. Use the #GtkWidget::leave-notify-event signal. The #GtkButton you want to send the signal to. Emits a #GtkButton::pressed signal to the given #GtkButton. Use the #GtkWidget::button-press-event signal. The #GtkButton you want to send the signal to. Emits a #GtkButton::released signal to the given #GtkButton. Use the #GtkWidget::button-release-event signal. The #GtkButton you want to send the signal to. Sets the alignment of the child. This property has no effect unless the child is a #GtkMisc or a #GtkAlignment. Access the child widget directly if you need to control its alignment. a #GtkButton the horizontal position of the child, 0.0 is left aligned, 1.0 is right aligned the vertical position of the child, 0.0 is top aligned, 1.0 is bottom aligned If %TRUE, the button will ignore the #GtkSettings:gtk-button-images setting and always show the image, if available. Use this property if the button would be useless or hard to use without the image. a #GtkButton %TRUE if the menuitem should always show the image Sets whether the button will grab focus when it is clicked with the mouse. Making mouse clicks not grab focus is useful in places like toolbars where you don’t want the keyboard focus removed from the main area of the application. Use gtk_widget_set_focus_on_click() instead a #GtkButton whether the button grabs focus when clicked with the mouse Set the image of @button to the given widget. The image will be displayed if the label text is %NULL or if #GtkButton:always-show-image is %TRUE. You don’t have to call gtk_widget_show() on @image yourself. a #GtkButton a widget to set as the image for the button, or %NULL to unset Sets the position of the image relative to the text inside the button. a #GtkButton the position Sets the text of the label of the button to @str. This text is also used to select the stock item if gtk_button_set_use_stock() is used. This will also clear any previously set labels. a #GtkButton a string Sets the relief style of the edges of the given #GtkButton widget. Two styles exist, %GTK_RELIEF_NORMAL and %GTK_RELIEF_NONE. The default style is, as one can guess, %GTK_RELIEF_NORMAL. The deprecated value %GTK_RELIEF_HALF behaves the same as %GTK_RELIEF_NORMAL. The #GtkButton you want to set relief styles of The GtkReliefStyle as described above If %TRUE, the label set on the button is used as a stock id to select the stock item for the button. a #GtkButton %TRUE if the button should use a stock item If true, an underline in the text of the button label indicates the next character should be used for the mnemonic accelerator key. a #GtkButton %TRUE if underlines in the text indicate mnemonics If %TRUE, the button will ignore the #GtkSettings:gtk-button-images setting and always show the image, if available. Use this property if the button would be useless or hard to use without the image. The child widget to appear next to the button text. The position of the image relative to the text inside the button. If the child of the button is a #GtkMisc or #GtkAlignment, this property can be used to control its horizontal alignment. 0.0 is left aligned, 1.0 is right aligned. Access the child widget directly if you need to control its alignment. If the child of the button is a #GtkMisc or #GtkAlignment, this property can be used to control its vertical alignment. 0.0 is top aligned, 1.0 is bottom aligned. Access the child widget directly if you need to control its alignment. The ::activate signal on GtkButton is an action signal and emitting it causes the button to animate press then release. Applications should never connect to this signal, but use the #GtkButton::clicked signal. Emitted when the button has been activated (pressed and released). Emitted when the pointer enters the button. Use the #GtkWidget::enter-notify-event signal. Emitted when the pointer leaves the button. Use the #GtkWidget::leave-notify-event signal. Emitted when the button is pressed. Use the #GtkWidget::button-press-event signal. Emitted when the button is released. Use the #GtkWidget::button-release-event signal. Creates a new #GtkButtonBox. a new #GtkButtonBox. the box's orientation. Returns whether the child is exempted from homogenous sizing. %TRUE if the child is not subject to homogenous sizing a #GtkButtonBox a child of @widget Returns whether @child should appear in a secondary group of children. whether @child should appear in a secondary group of children. a #GtkButtonBox a child of @widget Retrieves the method being used to arrange the buttons in a button box. the method used to lay out buttons in @widget. a #GtkButtonBox Sets whether the child is exempted from homogeous sizing. a #GtkButtonBox a child of @widget the new value Sets whether @child should appear in a secondary group of children. A typical use of a secondary child is the help button in a dialog. This group appears after the other children if the style is %GTK_BUTTONBOX_START, %GTK_BUTTONBOX_SPREAD or %GTK_BUTTONBOX_EDGE, and before the other children if the style is %GTK_BUTTONBOX_END. For horizontal button boxes, the definition of before/after depends on direction of the widget (see gtk_widget_set_direction()). If the style is %GTK_BUTTONBOX_START or %GTK_BUTTONBOX_END, then the secondary children are aligned at the other end of the button box from the main children. For the other styles, they appear immediately next to the main children. a #GtkButtonBox a child of @widget if %TRUE, the @child appears in a secondary group of the button box. Changes the way buttons are arranged in their container. a #GtkButtonBox the new layout style The parent class. Used to dictate the style that a #GtkButtonBox uses to layout the buttons it contains. Buttons are evenly spread across the box. Buttons are placed at the edges of the box. Buttons are grouped towards the start of the box, (on the left for a HBox, or the top for a VBox). Buttons are grouped towards the end of the box, (on the right for a HBox, or the bottom for a VBox). Buttons are centered in the box. Since 2.12. Buttons expand to fill the box. This entails giving buttons a "linked" appearance, making button sizes homogeneous, and setting spacing to 0 (same as calling gtk_box_set_homogeneous() and gtk_box_set_spacing() manually). Since 3.12. The parent class. The #GtkButton you want to send the signal to. The #GtkButton you want to send the signal to. The #GtkButton you want to send the signal to. The #GtkButton you want to send the signal to. The #GtkButton you want to send the signal to. The role specifies the desired appearance of a #GtkModelButton. A plain button A check button A radio button Prebuilt sets of buttons for the dialog. If none of these choices are appropriate, simply use %GTK_BUTTONS_NONE then call gtk_dialog_add_buttons(). > Please note that %GTK_BUTTONS_OK, %GTK_BUTTONS_YES_NO > and %GTK_BUTTONS_OK_CANCEL are discouraged by the > [GNOME Human Interface Guidelines](http://library.gnome.org/devel/hig-book/stable/). no buttons at all an OK button a Close button a Cancel button Yes and No buttons OK and Cancel buttons This macro should be used to emit a standard warning about unexpected properties in set_cell_property() and get_cell_property() implementations. the #GObject on which set_cell_property() or get_cell_property() was called the numeric id of the property the #GParamSpec of the property Returns %TRUE if the version of the GTK+ header files is the same as or newer than the passed-in version. major version (e.g. 1 for version 1.2.5) minor version (e.g. 2 for version 1.2.5) micro version (e.g. 5 for version 1.2.5) This macro should be used to emit a standard warning about unexpected properties in set_child_property() and get_child_property() implementations. the #GObject on which set_child_property() or get_child_property() was called the numeric id of the property the #GParamSpec of the property #GtkCalendar is a widget that displays a Gregorian calendar, one month at a time. It can be created with gtk_calendar_new(). The month and year currently displayed can be altered with gtk_calendar_select_month(). The exact day can be selected from the displayed month using gtk_calendar_select_day(). To place a visual marker on a particular day, use gtk_calendar_mark_day() and to remove the marker, gtk_calendar_unmark_day(). Alternative, all marks can be cleared with gtk_calendar_clear_marks(). The way in which the calendar itself is displayed can be altered using gtk_calendar_set_display_options(). The selected date can be retrieved from a #GtkCalendar using gtk_calendar_get_date(). Users should be aware that, although the Gregorian calendar is the legal calendar in most countries, it was adopted progressively between 1582 and 1929. Display before these dates is likely to be historically incorrect. Creates a new calendar, with the current date being selected. a newly #GtkCalendar widget Remove all visual markers. a #GtkCalendar Obtains the selected date from a #GtkCalendar. a #GtkCalendar location to store the year as a decimal number (e.g. 2011), or %NULL location to store the month number (between 0 and 11), or %NULL location to store the day number (between 1 and 31), or %NULL Returns if the @day of the @calendar is already marked. whether the day is marked. a #GtkCalendar the day number between 1 and 31. Queries the height of detail cells, in rows. See #GtkCalendar:detail-width-chars. The height of detail cells, in rows. a #GtkCalendar. Queries the width of detail cells, in characters. See #GtkCalendar:detail-width-chars. The width of detail cells, in characters. a #GtkCalendar. Returns the current display options of @calendar. the display options. a #GtkCalendar Places a visual marker on a particular day. a #GtkCalendar the day number to mark between 1 and 31. Selects a day from the current month. a #GtkCalendar. the day number between 1 and 31, or 0 to unselect the currently selected day. Shifts the calendar to a different month. a #GtkCalendar a month number between 0 and 11. the year the month is in. Installs a function which provides Pango markup with detail information for each day. Examples for such details are holidays or appointments. That information is shown below each day when #GtkCalendar:show-details is set. A tooltip containing with full detail information is provided, if the entire text should not fit into the details area, or if #GtkCalendar:show-details is not set. The size of the details area can be restricted by setting the #GtkCalendar:detail-width-chars and #GtkCalendar:detail-height-rows properties. a #GtkCalendar. a function providing details for each day. data to pass to @func invokations. a function for releasing @data. Updates the height of detail cells. See #GtkCalendar:detail-height-rows. a #GtkCalendar. detail height in rows. Updates the width of detail cells. See #GtkCalendar:detail-width-chars. a #GtkCalendar. detail width in characters. Sets display options (whether to display the heading and the month headings). a #GtkCalendar the display options to set Removes the visual marker from a particular day. a #GtkCalendar. the day number to unmark between 1 and 31. The selected day (as a number between 1 and 31, or 0 to unselect the currently selected day). This property gets initially set to the current day. Height of a detail cell, in rows. A value of 0 allows any width. See gtk_calendar_set_detail_func(). Width of a detail cell, in characters. A value of 0 allows any width. See gtk_calendar_set_detail_func(). The selected month (as a number between 0 and 11). This property gets initially set to the current month. Determines whether the selected month can be changed. Determines whether day names are displayed. Determines whether details are shown directly in the widget, or if they are available only as tooltip. When this property is set days with details are marked. Determines whether a heading is displayed. Determines whether week numbers are displayed. The selected year. This property gets initially set to the current year. Emitted when the user selects a day. Emitted when the user double-clicks a day. Emitted when the user clicks a button to change the selected month on a calendar. Emitted when the user switched to the next month. Emitted when user switched to the next year. Emitted when the user switched to the previous month. Emitted when user switched to the previous year. This kind of functions provide Pango markup with detail information for the specified day. Examples for such details are holidays or appointments. The function returns %NULL when no information is available. Newly allocated string with Pango markup with details for the specified day or %NULL. a #GtkCalendar. the year for which details are needed. the month for which details are needed. the day of @month for which details are needed. the data passed with gtk_calendar_set_detail_func(). These options can be used to influence the display and behaviour of a #GtkCalendar. Specifies that the month and year should be displayed. Specifies that three letter day descriptions should be present. Prevents the user from switching months with the calendar. Displays each week numbers of the current year, down the left side of the calendar. Just show an indicator, not the full details text when details are provided. See gtk_calendar_set_detail_func(). The type of the callback functions used for e.g. iterating over the children of a container, see gtk_container_foreach(). the widget to operate on user-supplied data The type of the callback functions used for iterating over the cell renderers and their allocated areas inside a #GtkCellArea, see gtk_cell_area_foreach_alloc(). %TRUE to stop iterating over cells. the cell renderer to operate on the area allocated to @renderer inside the rectangle provided to gtk_cell_area_foreach_alloc(). the background area for @renderer inside the background area provided to gtk_cell_area_foreach_alloc(). user-supplied data The #GtkCellArea is an abstract class for #GtkCellLayout widgets (also referred to as "layouting widgets") to interface with an arbitrary number of #GtkCellRenderers and interact with the user for a given #GtkTreeModel row. The cell area handles events, focus navigation, drawing and size requests and allocations for a given row of data. Usually users dont have to interact with the #GtkCellArea directly unless they are implementing a cell-layouting widget themselves. # Requesting area sizes As outlined in [GtkWidget’s geometry management section][geometry-management], GTK+ uses a height-for-width geometry management system to compute the sizes of widgets and user interfaces. #GtkCellArea uses the same semantics to calculate the size of an area for an arbitrary number of #GtkTreeModel rows. When requesting the size of a cell area one needs to calculate the size for a handful of rows, and this will be done differently by different layouting widgets. For instance a #GtkTreeViewColumn always lines up the areas from top to bottom while a #GtkIconView on the other hand might enforce that all areas received the same width and wrap the areas around, requesting height for more cell areas when allocated less width. It’s also important for areas to maintain some cell alignments with areas rendered for adjacent rows (cells can appear “columnized” inside an area even when the size of cells are different in each row). For this reason the #GtkCellArea uses a #GtkCellAreaContext object to store the alignments and sizes along the way (as well as the overall largest minimum and natural size for all the rows which have been calculated with the said context). The #GtkCellAreaContext is an opaque object specific to the #GtkCellArea which created it (see gtk_cell_area_create_context()). The owning cell-layouting widget can create as many contexts as it wishes to calculate sizes of rows which should receive the same size in at least one orientation (horizontally or vertically), However, it’s important that the same #GtkCellAreaContext which was used to request the sizes for a given #GtkTreeModel row be used when rendering or processing events for that row. In order to request the width of all the rows at the root level of a #GtkTreeModel one would do the following: |[<!-- language="C" --> GtkTreeIter iter; gint minimum_width; gint natural_width; valid = gtk_tree_model_get_iter_first (model, &iter); while (valid) { gtk_cell_area_apply_attributes (area, model, &iter, FALSE, FALSE); gtk_cell_area_get_preferred_width (area, context, widget, NULL, NULL); valid = gtk_tree_model_iter_next (model, &iter); } gtk_cell_area_context_get_preferred_width (context, &minimum_width, &natural_width); ]| Note that in this example it’s not important to observe the returned minimum and natural width of the area for each row unless the cell-layouting object is actually interested in the widths of individual rows. The overall width is however stored in the accompanying #GtkCellAreaContext object and can be consulted at any time. This can be useful since #GtkCellLayout widgets usually have to support requesting and rendering rows in treemodels with an exceedingly large amount of rows. The #GtkCellLayout widget in that case would calculate the required width of the rows in an idle or timeout source (see g_timeout_add()) and when the widget is requested its actual width in #GtkWidgetClass.get_preferred_width() it can simply consult the width accumulated so far in the #GtkCellAreaContext object. A simple example where rows are rendered from top to bottom and take up the full width of the layouting widget would look like: |[<!-- language="C" --> static void foo_get_preferred_width (GtkWidget *widget, gint *minimum_size, gint *natural_size) { Foo *foo = FOO (widget); FooPrivate *priv = foo->priv; foo_ensure_at_least_one_handfull_of_rows_have_been_requested (foo); gtk_cell_area_context_get_preferred_width (priv->context, minimum_size, natural_size); } ]| In the above example the Foo widget has to make sure that some row sizes have been calculated (the amount of rows that Foo judged was appropriate to request space for in a single timeout iteration) before simply returning the amount of space required by the area via the #GtkCellAreaContext. Requesting the height for width (or width for height) of an area is a similar task except in this case the #GtkCellAreaContext does not store the data (actually, it does not know how much space the layouting widget plans to allocate it for every row. It’s up to the layouting widget to render each row of data with the appropriate height and width which was requested by the #GtkCellArea). In order to request the height for width of all the rows at the root level of a #GtkTreeModel one would do the following: |[<!-- language="C" --> GtkTreeIter iter; gint minimum_height; gint natural_height; gint full_minimum_height = 0; gint full_natural_height = 0; valid = gtk_tree_model_get_iter_first (model, &iter); while (valid) { gtk_cell_area_apply_attributes (area, model, &iter, FALSE, FALSE); gtk_cell_area_get_preferred_height_for_width (area, context, widget, width, &minimum_height, &natural_height); if (width_is_for_allocation) cache_row_height (&iter, minimum_height, natural_height); full_minimum_height += minimum_height; full_natural_height += natural_height; valid = gtk_tree_model_iter_next (model, &iter); } ]| Note that in the above example we would need to cache the heights returned for each row so that we would know what sizes to render the areas for each row. However we would only want to really cache the heights if the request is intended for the layouting widgets real allocation. In some cases the layouting widget is requested the height for an arbitrary for_width, this is a special case for layouting widgets who need to request size for tens of thousands of rows. For this case it’s only important that the layouting widget calculate one reasonably sized chunk of rows and return that height synchronously. The reasoning here is that any layouting widget is at least capable of synchronously calculating enough height to fill the screen height (or scrolled window height) in response to a single call to #GtkWidgetClass.get_preferred_height_for_width(). Returning a perfect height for width that is larger than the screen area is inconsequential since after the layouting receives an allocation from a scrolled window it simply continues to drive the scrollbar values while more and more height is required for the row heights that are calculated in the background. # Rendering Areas Once area sizes have been aquired at least for the rows in the visible area of the layouting widget they can be rendered at #GtkWidgetClass.draw() time. A crude example of how to render all the rows at the root level runs as follows: |[<!-- language="C" --> GtkAllocation allocation; GdkRectangle cell_area = { 0, }; GtkTreeIter iter; gint minimum_width; gint natural_width; gtk_widget_get_allocation (widget, &allocation); cell_area.width = allocation.width; valid = gtk_tree_model_get_iter_first (model, &iter); while (valid) { cell_area.height = get_cached_height_for_row (&iter); gtk_cell_area_apply_attributes (area, model, &iter, FALSE, FALSE); gtk_cell_area_render (area, context, widget, cr, &cell_area, &cell_area, state_flags, FALSE); cell_area.y += cell_area.height; valid = gtk_tree_model_iter_next (model, &iter); } ]| Note that the cached height in this example really depends on how the layouting widget works. The layouting widget might decide to give every row its minimum or natural height or, if the model content is expected to fit inside the layouting widget without scrolling, it would make sense to calculate the allocation for each row at #GtkWidget::size-allocate time using gtk_distribute_natural_allocation(). # Handling Events and Driving Keyboard Focus Passing events to the area is as simple as handling events on any normal widget and then passing them to the gtk_cell_area_event() API as they come in. Usually #GtkCellArea is only interested in button events, however some customized derived areas can be implemented who are interested in handling other events. Handling an event can trigger the #GtkCellArea::focus-changed signal to fire; as well as #GtkCellArea::add-editable in the case that an editable cell was clicked and needs to start editing. You can call gtk_cell_area_stop_editing() at any time to cancel any cell editing that is currently in progress. The #GtkCellArea drives keyboard focus from cell to cell in a way similar to #GtkWidget. For layouting widgets that support giving focus to cells it’s important to remember to pass %GTK_CELL_RENDERER_FOCUSED to the area functions for the row that has focus and to tell the area to paint the focus at render time. Layouting widgets that accept focus on cells should implement the #GtkWidgetClass.focus() virtual method. The layouting widget is always responsible for knowing where #GtkTreeModel rows are rendered inside the widget, so at #GtkWidgetClass.focus() time the layouting widget should use the #GtkCellArea methods to navigate focus inside the area and then observe the GtkDirectionType to pass the focus to adjacent rows and areas. A basic example of how the #GtkWidgetClass.focus() virtual method should be implemented: |[<!-- language="C" --> static gboolean foo_focus (GtkWidget *widget, GtkDirectionType direction) { Foo *foo = FOO (widget); FooPrivate *priv = foo->priv; gint focus_row; gboolean have_focus = FALSE; focus_row = priv->focus_row; if (!gtk_widget_has_focus (widget)) gtk_widget_grab_focus (widget); valid = gtk_tree_model_iter_nth_child (priv->model, &iter, NULL, priv->focus_row); while (valid) { gtk_cell_area_apply_attributes (priv->area, priv->model, &iter, FALSE, FALSE); if (gtk_cell_area_focus (priv->area, direction)) { priv->focus_row = focus_row; have_focus = TRUE; break; } else { if (direction == GTK_DIR_RIGHT || direction == GTK_DIR_LEFT) break; else if (direction == GTK_DIR_UP || direction == GTK_DIR_TAB_BACKWARD) { if (focus_row == 0) break; else { focus_row--; valid = gtk_tree_model_iter_nth_child (priv->model, &iter, NULL, focus_row); } } else { if (focus_row == last_row) break; else { focus_row++; valid = gtk_tree_model_iter_next (priv->model, &iter); } } } } return have_focus; } ]| Note that the layouting widget is responsible for matching the GtkDirectionType values to the way it lays out its cells. # Cell Properties The #GtkCellArea introduces cell properties for #GtkCellRenderers in very much the same way that #GtkContainer introduces [child properties][child-properties] for #GtkWidgets. This provides some general interfaces for defining the relationship cell areas have with their cells. For instance in a #GtkCellAreaBox a cell might “expand” and receive extra space when the area is allocated more than its full natural request, or a cell might be configured to “align” with adjacent rows which were requested and rendered with the same #GtkCellAreaContext. Use gtk_cell_area_class_install_cell_property() to install cell properties for a cell area class and gtk_cell_area_class_find_cell_property() or gtk_cell_area_class_list_cell_properties() to get information about existing cell properties. To set the value of a cell property, use gtk_cell_area_cell_set_property(), gtk_cell_area_cell_set() or gtk_cell_area_cell_set_valist(). To obtain the value of a cell property, use gtk_cell_area_cell_get_property(), gtk_cell_area_cell_get() or gtk_cell_area_cell_get_valist(). Activates @area, usually by activating the currently focused cell, however some subclasses which embed widgets in the area can also activate a widget if it currently has the focus. Whether @area was successfully activated. a #GtkCellArea the #GtkCellAreaContext in context with the current row data the #GtkWidget that @area is rendering on the size and location of @area relative to @widget’s allocation the #GtkCellRendererState flags for @area for this row of data. if %TRUE then only cell renderers that are %GTK_CELL_RENDERER_MODE_EDITABLE will be activated. Adds @renderer to @area with the default child cell properties. a #GtkCellArea the #GtkCellRenderer to add to @area Applies any connected attributes to the renderers in @area by pulling the values from @tree_model. a #GtkCellArea the #GtkTreeModel to pull values from the #GtkTreeIter in @tree_model to apply values for whether @iter has children whether @iter is expanded in the view and children are visible This is sometimes needed for cases where rows need to share alignments in one orientation but may be separately grouped in the opposing orientation. For instance, #GtkIconView creates all icons (rows) to have the same width and the cells theirin to have the same horizontal alignments. However each row of icons may have a separate collective height. #GtkIconView uses this to request the heights of each row based on a context which was already used to request all the row widths that are to be displayed. a newly created #GtkCellAreaContext copy of @context. a #GtkCellArea the #GtkCellAreaContext to copy Creates a #GtkCellAreaContext to be used with @area for all purposes. #GtkCellAreaContext stores geometry information for rows for which it was operated on, it is important to use the same context for the same row of data at all times (i.e. one should render and handle events with the same #GtkCellAreaContext which was used to request the size of those rows of data). a newly created #GtkCellAreaContext which can be used with @area. a #GtkCellArea Delegates event handling to a #GtkCellArea. %TRUE if the event was handled by @area. a #GtkCellArea the #GtkCellAreaContext for this row of data. the #GtkWidget that @area is rendering to the #GdkEvent to handle the @widget relative coordinates for @area the #GtkCellRendererState for @area in this row. This should be called by the @area’s owning layout widget when focus is to be passed to @area, or moved within @area for a given @direction and row data. Implementing #GtkCellArea classes should implement this method to receive and navigate focus in its own way particular to how it lays out cells. %TRUE if focus remains inside @area as a result of this call. a #GtkCellArea the #GtkDirectionType Calls @callback for every #GtkCellRenderer in @area. a #GtkCellArea the #GtkCellCallback to call user provided data pointer Calls @callback for every #GtkCellRenderer in @area with the allocated rectangle inside @cell_area. a #GtkCellArea the #GtkCellAreaContext for this row of data. the #GtkWidget that @area is rendering to the @widget relative coordinates and size for @area the @widget relative coordinates of the background area the #GtkCellAllocCallback to call user provided data pointer Retrieves a cell area’s initial minimum and natural height. @area will store some geometrical information in @context along the way; when requesting sizes over an arbitrary number of rows, it’s not important to check the @minimum_height and @natural_height of this call but rather to consult gtk_cell_area_context_get_preferred_height() after a series of requests. a #GtkCellArea the #GtkCellAreaContext to perform this request with the #GtkWidget where @area will be rendering location to store the minimum height, or %NULL location to store the natural height, or %NULL Retrieves a cell area’s minimum and natural height if it would be given the specified @width. @area stores some geometrical information in @context along the way while calling gtk_cell_area_get_preferred_width(). It’s important to perform a series of gtk_cell_area_get_preferred_width() requests with @context first and then call gtk_cell_area_get_preferred_height_for_width() on each cell area individually to get the height for width of each fully requested row. If at some point, the width of a single row changes, it should be requested with gtk_cell_area_get_preferred_width() again and then the full width of the requested rows checked again with gtk_cell_area_context_get_preferred_width(). a #GtkCellArea the #GtkCellAreaContext which has already been requested for widths. the #GtkWidget where @area will be rendering the width for which to check the height of this area location to store the minimum height, or %NULL location to store the natural height, or %NULL Retrieves a cell area’s initial minimum and natural width. @area will store some geometrical information in @context along the way; when requesting sizes over an arbitrary number of rows, it’s not important to check the @minimum_width and @natural_width of this call but rather to consult gtk_cell_area_context_get_preferred_width() after a series of requests. a #GtkCellArea the #GtkCellAreaContext to perform this request with the #GtkWidget where @area will be rendering location to store the minimum width, or %NULL location to store the natural width, or %NULL Retrieves a cell area’s minimum and natural width if it would be given the specified @height. @area stores some geometrical information in @context along the way while calling gtk_cell_area_get_preferred_height(). It’s important to perform a series of gtk_cell_area_get_preferred_height() requests with @context first and then call gtk_cell_area_get_preferred_width_for_height() on each cell area individually to get the height for width of each fully requested row. If at some point, the height of a single row changes, it should be requested with gtk_cell_area_get_preferred_height() again and then the full height of the requested rows checked again with gtk_cell_area_context_get_preferred_height(). a #GtkCellArea the #GtkCellAreaContext which has already been requested for widths. the #GtkWidget where @area will be rendering the height for which to check the width of this area location to store the minimum width, or %NULL location to store the natural width, or %NULL Gets whether the area prefers a height-for-width layout or a width-for-height layout. The #GtkSizeRequestMode preferred by @area. a #GtkCellArea Returns whether the area can do anything when activated, after applying new attributes to @area. whether @area can do anything when activated. a #GtkCellArea Removes @renderer from @area. a #GtkCellArea the #GtkCellRenderer to remove from @area Renders @area’s cells according to @area’s layout onto @widget at the given coordinates. a #GtkCellArea the #GtkCellAreaContext for this row of data. the #GtkWidget that @area is rendering to the #cairo_t to render with the @widget relative coordinates for @area’s background the @widget relative coordinates for @area the #GtkCellRendererState for @area in this row. whether @area should paint focus on focused cells for focused rows or not. Activates @area, usually by activating the currently focused cell, however some subclasses which embed widgets in the area can also activate a widget if it currently has the focus. Whether @area was successfully activated. a #GtkCellArea the #GtkCellAreaContext in context with the current row data the #GtkWidget that @area is rendering on the size and location of @area relative to @widget’s allocation the #GtkCellRendererState flags for @area for this row of data. if %TRUE then only cell renderers that are %GTK_CELL_RENDERER_MODE_EDITABLE will be activated. This is used by #GtkCellArea subclasses when handling events to activate cells, the base #GtkCellArea class activates cells for keyboard events for free in its own GtkCellArea->activate() implementation. whether cell activation was successful a #GtkCellArea the #GtkWidget that @area is rendering onto the #GtkCellRenderer in @area to activate the #GdkEvent for which cell activation should occur the #GdkRectangle in @widget relative coordinates of @renderer for the current row. the #GtkCellRendererState for @renderer Adds @renderer to @area with the default child cell properties. a #GtkCellArea the #GtkCellRenderer to add to @area Adds @sibling to @renderer’s focusable area, focus will be drawn around @renderer and all of its siblings if @renderer can focus for a given row. Events handled by focus siblings can also activate the given focusable @renderer. a #GtkCellArea the #GtkCellRenderer expected to have focus the #GtkCellRenderer to add to @renderer’s focus area Adds @renderer to @area, setting cell properties at the same time. See gtk_cell_area_add() and gtk_cell_area_cell_set() for more details. a #GtkCellArea a #GtkCellRenderer to be placed inside @area the name of the first cell property to set a %NULL-terminated list of property names and values, starting with @first_prop_name Applies any connected attributes to the renderers in @area by pulling the values from @tree_model. a #GtkCellArea the #GtkTreeModel to pull values from the #GtkTreeIter in @tree_model to apply values for whether @iter has children whether @iter is expanded in the view and children are visible Connects an @attribute to apply values from @column for the #GtkTreeModel in use. a #GtkCellArea the #GtkCellRenderer to connect an attribute for the attribute name the #GtkTreeModel column to fetch attribute values from Disconnects @attribute for the @renderer in @area so that attribute will no longer be updated with values from the model. a #GtkCellArea the #GtkCellRenderer to disconnect an attribute for the attribute name Returns the model column that an attribute has been mapped to, or -1 if the attribute is not mapped. the model column, or -1 a #GtkCellArea a #GtkCellRenderer an attribute on the renderer Gets the values of one or more cell properties for @renderer in @area. a #GtkCellArea a #GtkCellRenderer which is inside @area the name of the first cell property to get return location for the first cell property, followed optionally by more name/return location pairs, followed by %NULL Gets the value of a cell property for @renderer in @area. a #GtkCellArea a #GtkCellRenderer inside @area the name of the property to get a location to return the value Gets the values of one or more cell properties for @renderer in @area. a #GtkCellArea a #GtkCellRenderer inside @area the name of the first property to get return location for the first property, followed optionally by more name/return location pairs, followed by %NULL Sets one or more cell properties for @cell in @area. a #GtkCellArea a #GtkCellRenderer which is a cell inside @area the name of the first cell property to set a %NULL-terminated list of property names and values, starting with @first_prop_name Sets a cell property for @renderer in @area. a #GtkCellArea a #GtkCellRenderer inside @area the name of the cell property to set the value to set the cell property to Sets one or more cell properties for @renderer in @area. a #GtkCellArea a #GtkCellRenderer which inside @area the name of the first cell property to set a %NULL-terminated list of property names and values, starting with @first_prop_name This is sometimes needed for cases where rows need to share alignments in one orientation but may be separately grouped in the opposing orientation. For instance, #GtkIconView creates all icons (rows) to have the same width and the cells theirin to have the same horizontal alignments. However each row of icons may have a separate collective height. #GtkIconView uses this to request the heights of each row based on a context which was already used to request all the row widths that are to be displayed. a newly created #GtkCellAreaContext copy of @context. a #GtkCellArea the #GtkCellAreaContext to copy Creates a #GtkCellAreaContext to be used with @area for all purposes. #GtkCellAreaContext stores geometry information for rows for which it was operated on, it is important to use the same context for the same row of data at all times (i.e. one should render and handle events with the same #GtkCellAreaContext which was used to request the size of those rows of data). a newly created #GtkCellAreaContext which can be used with @area. a #GtkCellArea Delegates event handling to a #GtkCellArea. %TRUE if the event was handled by @area. a #GtkCellArea the #GtkCellAreaContext for this row of data. the #GtkWidget that @area is rendering to the #GdkEvent to handle the @widget relative coordinates for @area the #GtkCellRendererState for @area in this row. This should be called by the @area’s owning layout widget when focus is to be passed to @area, or moved within @area for a given @direction and row data. Implementing #GtkCellArea classes should implement this method to receive and navigate focus in its own way particular to how it lays out cells. %TRUE if focus remains inside @area as a result of this call. a #GtkCellArea the #GtkDirectionType Calls @callback for every #GtkCellRenderer in @area. a #GtkCellArea the #GtkCellCallback to call user provided data pointer Calls @callback for every #GtkCellRenderer in @area with the allocated rectangle inside @cell_area. a #GtkCellArea the #GtkCellAreaContext for this row of data. the #GtkWidget that @area is rendering to the @widget relative coordinates and size for @area the @widget relative coordinates of the background area the #GtkCellAllocCallback to call user provided data pointer Derives the allocation of @renderer inside @area if @area were to be renderered in @cell_area. a #GtkCellArea the #GtkCellAreaContext used to hold sizes for @area. the #GtkWidget that @area is rendering on the #GtkCellRenderer to get the allocation for the whole allocated area for @area in @widget for this row where to store the allocation for @renderer Gets the #GtkCellRenderer at @x and @y coordinates inside @area and optionally returns the full cell allocation for it inside @cell_area. the #GtkCellRenderer at @x and @y. a #GtkCellArea the #GtkCellAreaContext used to hold sizes for @area. the #GtkWidget that @area is rendering on the whole allocated area for @area in @widget for this row the x position the y position where to store the inner allocated area of the returned cell renderer, or %NULL. Gets the current #GtkTreePath string for the currently applied #GtkTreeIter, this is implicitly updated when gtk_cell_area_apply_attributes() is called and can be used to interact with renderers from #GtkCellArea subclasses. The current #GtkTreePath string for the current attributes applied to @area. This string belongs to the area and should not be freed. a #GtkCellArea Gets the #GtkCellEditable widget currently used to edit the currently edited cell. The currently active #GtkCellEditable widget a #GtkCellArea Gets the #GtkCellRenderer in @area that is currently being edited. The currently edited #GtkCellRenderer a #GtkCellArea Retrieves the currently focused cell for @area the currently focused cell in @area. a #GtkCellArea Gets the #GtkCellRenderer which is expected to be focusable for which @renderer is, or may be a sibling. This is handy for #GtkCellArea subclasses when handling events, after determining the renderer at the event location it can then chose to activate the focus cell for which the event cell may have been a sibling. the #GtkCellRenderer for which @renderer is a sibling, or %NULL. a #GtkCellArea the #GtkCellRenderer Gets the focus sibling cell renderers for @renderer. A #GList of #GtkCellRenderers. The returned list is internal and should not be freed. a #GtkCellArea the #GtkCellRenderer expected to have focus Retrieves a cell area’s initial minimum and natural height. @area will store some geometrical information in @context along the way; when requesting sizes over an arbitrary number of rows, it’s not important to check the @minimum_height and @natural_height of this call but rather to consult gtk_cell_area_context_get_preferred_height() after a series of requests. a #GtkCellArea the #GtkCellAreaContext to perform this request with the #GtkWidget where @area will be rendering location to store the minimum height, or %NULL location to store the natural height, or %NULL Retrieves a cell area’s minimum and natural height if it would be given the specified @width. @area stores some geometrical information in @context along the way while calling gtk_cell_area_get_preferred_width(). It’s important to perform a series of gtk_cell_area_get_preferred_width() requests with @context first and then call gtk_cell_area_get_preferred_height_for_width() on each cell area individually to get the height for width of each fully requested row. If at some point, the width of a single row changes, it should be requested with gtk_cell_area_get_preferred_width() again and then the full width of the requested rows checked again with gtk_cell_area_context_get_preferred_width(). a #GtkCellArea the #GtkCellAreaContext which has already been requested for widths. the #GtkWidget where @area will be rendering the width for which to check the height of this area location to store the minimum height, or %NULL location to store the natural height, or %NULL Retrieves a cell area’s initial minimum and natural width. @area will store some geometrical information in @context along the way; when requesting sizes over an arbitrary number of rows, it’s not important to check the @minimum_width and @natural_width of this call but rather to consult gtk_cell_area_context_get_preferred_width() after a series of requests. a #GtkCellArea the #GtkCellAreaContext to perform this request with the #GtkWidget where @area will be rendering location to store the minimum width, or %NULL location to store the natural width, or %NULL Retrieves a cell area’s minimum and natural width if it would be given the specified @height. @area stores some geometrical information in @context along the way while calling gtk_cell_area_get_preferred_height(). It’s important to perform a series of gtk_cell_area_get_preferred_height() requests with @context first and then call gtk_cell_area_get_preferred_width_for_height() on each cell area individually to get the height for width of each fully requested row. If at some point, the height of a single row changes, it should be requested with gtk_cell_area_get_preferred_height() again and then the full height of the requested rows checked again with gtk_cell_area_context_get_preferred_height(). a #GtkCellArea the #GtkCellAreaContext which has already been requested for widths. the #GtkWidget where @area will be rendering the height for which to check the width of this area location to store the minimum width, or %NULL location to store the natural width, or %NULL Gets whether the area prefers a height-for-width layout or a width-for-height layout. The #GtkSizeRequestMode preferred by @area. a #GtkCellArea Checks if @area contains @renderer. %TRUE if @renderer is in the @area. a #GtkCellArea the #GtkCellRenderer to check This is a convenience function for #GtkCellArea implementations to get the inner area where a given #GtkCellRenderer will be rendered. It removes any padding previously added by gtk_cell_area_request_renderer(). a #GtkCellArea the #GtkWidget that @area is rendering onto the @widget relative coordinates where one of @area’s cells is to be placed the return location for the inner cell area Returns whether the area can do anything when activated, after applying new attributes to @area. whether @area can do anything when activated. a #GtkCellArea Returns whether @sibling is one of @renderer’s focus siblings (see gtk_cell_area_add_focus_sibling()). %TRUE if @sibling is a focus sibling of @renderer a #GtkCellArea the #GtkCellRenderer expected to have focus the #GtkCellRenderer to check against @renderer’s sibling list Removes @renderer from @area. a #GtkCellArea the #GtkCellRenderer to remove from @area Removes @sibling from @renderer’s focus sibling list (see gtk_cell_area_add_focus_sibling()). a #GtkCellArea the #GtkCellRenderer expected to have focus the #GtkCellRenderer to remove from @renderer’s focus area Renders @area’s cells according to @area’s layout onto @widget at the given coordinates. a #GtkCellArea the #GtkCellAreaContext for this row of data. the #GtkWidget that @area is rendering to the #cairo_t to render with the @widget relative coordinates for @area’s background the @widget relative coordinates for @area the #GtkCellRendererState for @area in this row. whether @area should paint focus on focused cells for focused rows or not. This is a convenience function for #GtkCellArea implementations to request size for cell renderers. It’s important to use this function to request size and then use gtk_cell_area_inner_cell_area() at render and event time since this function will add padding around the cell for focus painting. a #GtkCellArea the #GtkCellRenderer to request size for the #GtkOrientation in which to request size the #GtkWidget that @area is rendering onto the allocation contextual size to request for, or -1 if the base request for the orientation is to be returned. location to store the minimum size, or %NULL location to store the natural size, or %NULL Explicitly sets the currently focused cell to @renderer. This is generally called by implementations of #GtkCellAreaClass.focus() or #GtkCellAreaClass.event(), however it can also be used to implement functions such as gtk_tree_view_set_cursor_on_cell(). a #GtkCellArea the #GtkCellRenderer to give focus to Explicitly stops the editing of the currently edited cell. If @canceled is %TRUE, the currently edited cell renderer will emit the ::editing-canceled signal, otherwise the the ::editing-done signal will be emitted on the current edit widget. See gtk_cell_area_get_edited_cell() and gtk_cell_area_get_edit_widget(). a #GtkCellArea whether editing was canceled. The widget currently editing the edited cell This property is read-only and only changes as a result of a call gtk_cell_area_activate_cell(). The cell in the area that is currently edited This property is read-only and only changes as a result of a call gtk_cell_area_activate_cell(). The cell in the area that currently has focus Indicates that editing has started on @renderer and that @editable should be added to the owning cell-layouting widget at @cell_area. the #GtkCellRenderer that started the edited the #GtkCellEditable widget to add the #GtkWidget relative #GdkRectangle coordinates where @editable should be added the #GtkTreePath string this edit was initiated for This signal is emitted whenever applying attributes to @area from @model the #GtkTreeModel to apply the attributes from the #GtkTreeIter indicating which row to apply the attributes of whether the view shows children for this row whether the view is currently showing the children of this row Indicates that focus changed on this @area. This signal is emitted either as a result of focus handling or event handling. It's possible that the signal is emitted even if the currently focused renderer did not change, this is because focus may change to the same renderer in the same cell area for a different row of data. the #GtkCellRenderer that has focus the current #GtkTreePath string set for @area Indicates that editing finished on @renderer and that @editable should be removed from the owning cell-layouting widget. the #GtkCellRenderer that finished editeding the #GtkCellEditable widget to remove The #GtkCellAreaBox renders cell renderers into a row or a column depending on its #GtkOrientation. GtkCellAreaBox uses a notion of packing. Packing refers to adding cell renderers with reference to a particular position in a #GtkCellAreaBox. There are two reference positions: the start and the end of the box. When the #GtkCellAreaBox is oriented in the %GTK_ORIENTATION_VERTICAL orientation, the start is defined as the top of the box and the end is defined as the bottom. In the %GTK_ORIENTATION_HORIZONTAL orientation start is defined as the left side and the end is defined as the right side. Alignments of #GtkCellRenderers rendered in adjacent rows can be configured by configuring the #GtkCellAreaBox align child cell property with gtk_cell_area_cell_set_property() or by specifying the "align" argument to gtk_cell_area_box_pack_start() and gtk_cell_area_box_pack_end(). Creates a new #GtkCellAreaBox. a newly created #GtkCellAreaBox Gets the spacing added between cell renderers. the space added between cell renderers in @box. a #GtkCellAreaBox Adds @renderer to @box, packed with reference to the end of @box. The @renderer is packed after (away from end of) any other #GtkCellRenderer packed with reference to the end of @box. a #GtkCellAreaBox the #GtkCellRenderer to add whether @renderer should receive extra space when the area receives more than its natural size whether @renderer should be aligned in adjacent rows whether @renderer should have the same size in all rows Adds @renderer to @box, packed with reference to the start of @box. The @renderer is packed after any other #GtkCellRenderer packed with reference to the start of @box. a #GtkCellAreaBox the #GtkCellRenderer to add whether @renderer should receive extra space when the area receives more than its natural size whether @renderer should be aligned in adjacent rows whether @renderer should have the same size in all rows Sets the spacing to add between cell renderers in @box. a #GtkCellAreaBox the space to add between #GtkCellRenderers The amount of space to reserve between cells. a #GtkCellArea the #GtkCellRenderer to add to @area a #GtkCellArea the #GtkCellRenderer to remove from @area a #GtkCellArea the #GtkCellCallback to call user provided data pointer a #GtkCellArea the #GtkCellAreaContext for this row of data. the #GtkWidget that @area is rendering to the @widget relative coordinates and size for @area the @widget relative coordinates of the background area the #GtkCellAllocCallback to call user provided data pointer %TRUE if the event was handled by @area. a #GtkCellArea the #GtkCellAreaContext for this row of data. the #GtkWidget that @area is rendering to the #GdkEvent to handle the @widget relative coordinates for @area the #GtkCellRendererState for @area in this row. a #GtkCellArea the #GtkCellAreaContext for this row of data. the #GtkWidget that @area is rendering to the #cairo_t to render with the @widget relative coordinates for @area’s background the @widget relative coordinates for @area the #GtkCellRendererState for @area in this row. whether @area should paint focus on focused cells for focused rows or not. a #GtkCellArea the #GtkTreeModel to pull values from the #GtkTreeIter in @tree_model to apply values for whether @iter has children whether @iter is expanded in the view and children are visible a newly created #GtkCellAreaContext which can be used with @area. a #GtkCellArea a newly created #GtkCellAreaContext copy of @context. a #GtkCellArea the #GtkCellAreaContext to copy The #GtkSizeRequestMode preferred by @area. a #GtkCellArea a #GtkCellArea the #GtkCellAreaContext to perform this request with the #GtkWidget where @area will be rendering location to store the minimum width, or %NULL location to store the natural width, or %NULL a #GtkCellArea the #GtkCellAreaContext which has already been requested for widths. the #GtkWidget where @area will be rendering the width for which to check the height of this area location to store the minimum height, or %NULL location to store the natural height, or %NULL a #GtkCellArea the #GtkCellAreaContext to perform this request with the #GtkWidget where @area will be rendering location to store the minimum height, or %NULL location to store the natural height, or %NULL a #GtkCellArea the #GtkCellAreaContext which has already been requested for widths. the #GtkWidget where @area will be rendering the height for which to check the width of this area location to store the minimum width, or %NULL location to store the natural width, or %NULL %TRUE if focus remains inside @area as a result of this call. a #GtkCellArea the #GtkDirectionType whether @area can do anything when activated. a #GtkCellArea Whether @area was successfully activated. a #GtkCellArea the #GtkCellAreaContext in context with the current row data the #GtkWidget that @area is rendering on the size and location of @area relative to @widget’s allocation the #GtkCellRendererState flags for @area for this row of data. if %TRUE then only cell renderers that are %GTK_CELL_RENDERER_MODE_EDITABLE will be activated. Finds a cell property of a cell area class by name. the #GParamSpec of the child property or %NULL if @aclass has no child property with that name. a #GtkCellAreaClass the name of the child property to find Installs a cell property on a cell area class. a #GtkCellAreaClass the id for the property the #GParamSpec for the property Returns all cell properties of a cell area class. a newly allocated %NULL-terminated array of #GParamSpec*. The array must be freed with g_free(). a #GtkCellAreaClass location to return the number of cell properties found The #GtkCellAreaContext object is created by a given #GtkCellArea implementation via its #GtkCellAreaClass.create_context() virtual method and is used to store cell sizes and alignments for a series of #GtkTreeModel rows that are requested and rendered in the same context. #GtkCellLayout widgets can create any number of contexts in which to request and render groups of data rows. However, it’s important that the same context which was used to request sizes for a given #GtkTreeModel row also be used for the same row when calling other #GtkCellArea APIs such as gtk_cell_area_render() and gtk_cell_area_event(). Allocates a width and/or a height for all rows which are to be rendered with @context. Usually allocation is performed only horizontally or sometimes vertically since a group of rows are usually rendered side by side vertically or horizontally and share either the same width or the same height. Sometimes they are allocated in both horizontal and vertical orientations producing a homogeneous effect of the rows. This is generally the case for #GtkTreeView when #GtkTreeView:fixed-height-mode is enabled. Since 3.0 a #GtkCellAreaContext the allocated width for all #GtkTreeModel rows rendered with @context, or -1. the allocated height for all #GtkTreeModel rows rendered with @context, or -1. Gets the accumulative preferred height for @width for all rows which have been requested for the same said @width with this context. After gtk_cell_area_context_reset() is called and/or before ever requesting the size of a #GtkCellArea, the returned values are -1. a #GtkCellAreaContext a proposed width for allocation location to store the minimum height, or %NULL location to store the natural height, or %NULL Gets the accumulative preferred width for @height for all rows which have been requested for the same said @height with this context. After gtk_cell_area_context_reset() is called and/or before ever requesting the size of a #GtkCellArea, the returned values are -1. a #GtkCellAreaContext a proposed height for allocation location to store the minimum width, or %NULL location to store the natural width, or %NULL Resets any previously cached request and allocation data. When underlying #GtkTreeModel data changes its important to reset the context if the content size is allowed to shrink. If the content size is only allowed to grow (this is usually an option for views rendering large data stores as a measure of optimization), then only the row that changed or was inserted needs to be (re)requested with gtk_cell_area_get_preferred_width(). When the new overall size of the context requires that the allocated size changes (or whenever this allocation changes at all), the variable row sizes need to be re-requested for every row. For instance, if the rows are displayed all with the same width from top to bottom then a change in the allocated width necessitates a recalculation of all the displayed row heights using gtk_cell_area_get_preferred_height_for_width(). Since 3.0 a #GtkCellAreaContext Allocates a width and/or a height for all rows which are to be rendered with @context. Usually allocation is performed only horizontally or sometimes vertically since a group of rows are usually rendered side by side vertically or horizontally and share either the same width or the same height. Sometimes they are allocated in both horizontal and vertical orientations producing a homogeneous effect of the rows. This is generally the case for #GtkTreeView when #GtkTreeView:fixed-height-mode is enabled. Since 3.0 a #GtkCellAreaContext the allocated width for all #GtkTreeModel rows rendered with @context, or -1. the allocated height for all #GtkTreeModel rows rendered with @context, or -1. Fetches the current allocation size for @context. If the context was not allocated in width or height, or if the context was recently reset with gtk_cell_area_context_reset(), the returned value will be -1. a #GtkCellAreaContext location to store the allocated width, or %NULL location to store the allocated height, or %NULL Fetches the #GtkCellArea this @context was created by. This is generally unneeded by layouting widgets; however, it is important for the context implementation itself to fetch information about the area it is being used for. For instance at #GtkCellAreaContextClass.allocate() time it’s important to know details about any cell spacing that the #GtkCellArea is configured with in order to compute a proper allocation. the #GtkCellArea this context was created by. a #GtkCellAreaContext Gets the accumulative preferred height for all rows which have been requested with this context. After gtk_cell_area_context_reset() is called and/or before ever requesting the size of a #GtkCellArea, the returned values are 0. a #GtkCellAreaContext location to store the minimum height, or %NULL location to store the natural height, or %NULL Gets the accumulative preferred height for @width for all rows which have been requested for the same said @width with this context. After gtk_cell_area_context_reset() is called and/or before ever requesting the size of a #GtkCellArea, the returned values are -1. a #GtkCellAreaContext a proposed width for allocation location to store the minimum height, or %NULL location to store the natural height, or %NULL Gets the accumulative preferred width for all rows which have been requested with this context. After gtk_cell_area_context_reset() is called and/or before ever requesting the size of a #GtkCellArea, the returned values are 0. a #GtkCellAreaContext location to store the minimum width, or %NULL location to store the natural width, or %NULL Gets the accumulative preferred width for @height for all rows which have been requested for the same said @height with this context. After gtk_cell_area_context_reset() is called and/or before ever requesting the size of a #GtkCellArea, the returned values are -1. a #GtkCellAreaContext a proposed height for allocation location to store the minimum width, or %NULL location to store the natural width, or %NULL Causes the minimum and/or natural height to grow if the new proposed sizes exceed the current minimum and natural height. This is used by #GtkCellAreaContext implementations during the request process over a series of #GtkTreeModel rows to progressively push the requested height over a series of gtk_cell_area_get_preferred_height() requests. a #GtkCellAreaContext the proposed new minimum height for @context the proposed new natural height for @context Causes the minimum and/or natural width to grow if the new proposed sizes exceed the current minimum and natural width. This is used by #GtkCellAreaContext implementations during the request process over a series of #GtkTreeModel rows to progressively push the requested width over a series of gtk_cell_area_get_preferred_width() requests. a #GtkCellAreaContext the proposed new minimum width for @context the proposed new natural width for @context Resets any previously cached request and allocation data. When underlying #GtkTreeModel data changes its important to reset the context if the content size is allowed to shrink. If the content size is only allowed to grow (this is usually an option for views rendering large data stores as a measure of optimization), then only the row that changed or was inserted needs to be (re)requested with gtk_cell_area_get_preferred_width(). When the new overall size of the context requires that the allocated size changes (or whenever this allocation changes at all), the variable row sizes need to be re-requested for every row. For instance, if the rows are displayed all with the same width from top to bottom then a change in the allocated width necessitates a recalculation of all the displayed row heights using gtk_cell_area_get_preferred_height_for_width(). Since 3.0 a #GtkCellAreaContext The #GtkCellArea this context was created by The minimum height for the #GtkCellArea in this context for all #GtkTreeModel rows that this context was requested for using gtk_cell_area_get_preferred_height(). The minimum width for the #GtkCellArea in this context for all #GtkTreeModel rows that this context was requested for using gtk_cell_area_get_preferred_width(). The natural height for the #GtkCellArea in this context for all #GtkTreeModel rows that this context was requested for using gtk_cell_area_get_preferred_height(). The natural width for the #GtkCellArea in this context for all #GtkTreeModel rows that this context was requested for using gtk_cell_area_get_preferred_width(). a #GtkCellAreaContext the allocated width for all #GtkTreeModel rows rendered with @context, or -1. the allocated height for all #GtkTreeModel rows rendered with @context, or -1. a #GtkCellAreaContext a #GtkCellAreaContext a proposed width for allocation location to store the minimum height, or %NULL location to store the natural height, or %NULL a #GtkCellAreaContext a proposed height for allocation location to store the minimum width, or %NULL location to store the natural width, or %NULL The type of the callback functions used for iterating over the cell renderers of a #GtkCellArea, see gtk_cell_area_foreach(). %TRUE to stop iterating over cells. the cell renderer to operate on user-supplied data The #GtkCellEditable interface must be implemented for widgets to be usable to edit the contents of a #GtkTreeView cell. It provides a way to specify how temporary widgets should be configured for editing, get the new value, etc. Emits the #GtkCellEditable::editing-done signal. A #GtkCellEditable Emits the #GtkCellEditable::remove-widget signal. A #GtkCellEditable Begins editing on a @cell_editable. The #GtkCellRenderer for the cell creates and returns a #GtkCellEditable from gtk_cell_renderer_start_editing(), configured for the #GtkCellRenderer type. gtk_cell_editable_start_editing() can then set up @cell_editable suitably for editing a cell, e.g. making the Esc key emit #GtkCellEditable::editing-done. Note that the @cell_editable is created on-demand for the current edit; its lifetime is temporary and does not persist across other edits and/or cells. A #GtkCellEditable The #GdkEvent that began the editing process, or %NULL if editing was initiated programmatically Emits the #GtkCellEditable::editing-done signal. A #GtkCellEditable Emits the #GtkCellEditable::remove-widget signal. A #GtkCellEditable Begins editing on a @cell_editable. The #GtkCellRenderer for the cell creates and returns a #GtkCellEditable from gtk_cell_renderer_start_editing(), configured for the #GtkCellRenderer type. gtk_cell_editable_start_editing() can then set up @cell_editable suitably for editing a cell, e.g. making the Esc key emit #GtkCellEditable::editing-done. Note that the @cell_editable is created on-demand for the current edit; its lifetime is temporary and does not persist across other edits and/or cells. A #GtkCellEditable The #GdkEvent that began the editing process, or %NULL if editing was initiated programmatically Indicates whether editing on the cell has been canceled. This signal is a sign for the cell renderer to update its value from the @cell_editable. Implementations of #GtkCellEditable are responsible for emitting this signal when they are done editing, e.g. #GtkEntry emits this signal when the user presses Enter. Typical things to do in a handler for ::editing-done are to capture the edited value, disconnect the @cell_editable from signals on the #GtkCellRenderer, etc. gtk_cell_editable_editing_done() is a convenience method for emitting #GtkCellEditable::editing-done. This signal is meant to indicate that the cell is finished editing, and the @cell_editable widget is being removed and may subsequently be destroyed. Implementations of #GtkCellEditable are responsible for emitting this signal when they are done editing. It must be emitted after the #GtkCellEditable::editing-done signal, to give the cell renderer a chance to update the cell's value before the widget is removed. gtk_cell_editable_remove_widget() is a convenience method for emitting #GtkCellEditable::remove-widget. A #GtkCellEditable A #GtkCellEditable A #GtkCellEditable The #GdkEvent that began the editing process, or %NULL if editing was initiated programmatically #GtkCellLayout is an interface to be implemented by all objects which want to provide a #GtkTreeViewColumn like API for packing cells, setting attributes and data funcs. One of the notable features provided by implementations of GtkCellLayout are attributes. Attributes let you set the properties in flexible ways. They can just be set to constant values like regular properties. But they can also be mapped to a column of the underlying tree model with gtk_cell_layout_set_attributes(), which means that the value of the attribute can change from cell to cell as they are rendered by the cell renderer. Finally, it is possible to specify a function with gtk_cell_layout_set_cell_data_func() that is called to determine the value of the attribute for each cell that is rendered. # GtkCellLayouts as GtkBuildable Implementations of GtkCellLayout which also implement the GtkBuildable interface (#GtkCellView, #GtkIconView, #GtkComboBox, #GtkEntryCompletion, #GtkTreeViewColumn) accept GtkCellRenderer objects as <child> elements in UI definitions. They support a custom <attributes> element for their children, which can contain multiple <attribute> elements. Each <attribute> element has a name attribute which specifies a property of the cell renderer; the content of the element is the attribute value. This is an example of a UI definition fragment specifying attributes: |[ <object class="GtkCellView"> <child> <object class="GtkCellRendererText"/> <attributes> <attribute name="text">0</attribute> </attributes> </child>" </object> ]| Furthermore for implementations of GtkCellLayout that use a #GtkCellArea to lay out cells (all GtkCellLayouts in GTK+ use a GtkCellArea) [cell properties][cell-properties] can also be defined in the format by specifying the custom <cell-packing> attribute which can contain multiple <property> elements defined in the normal way. Here is a UI definition fragment specifying cell properties: |[ <object class="GtkTreeViewColumn"> <child> <object class="GtkCellRendererText"/> <cell-packing> <property name="align">True</property> <property name="expand">False</property> </cell-packing> </child>" </object> ]| # Subclassing GtkCellLayout implementations When subclassing a widget that implements #GtkCellLayout like #GtkIconView or #GtkComboBox, there are some considerations related to the fact that these widgets internally use a #GtkCellArea. The cell area is exposed as a construct-only property by these widgets. This means that it is possible to e.g. do |[<!-- language="C" --> combo = g_object_new (GTK_TYPE_COMBO_BOX, "cell-area", my_cell_area, NULL); ]| to use a custom cell area with a combo box. But construct properties are only initialized after instance init() functions have run, which means that using functions which rely on the existence of the cell area in your subclass’ init() function will cause the default cell area to be instantiated. In this case, a provided construct property value will be ignored (with a warning, to alert you to the problem). |[<!-- language="C" --> static void my_combo_box_init (MyComboBox *b) { GtkCellRenderer *cell; cell = gtk_cell_renderer_pixbuf_new (); // The following call causes the default cell area for combo boxes, // a GtkCellAreaBox, to be instantiated gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (b), cell, FALSE); ... } GtkWidget * my_combo_box_new (GtkCellArea *area) { // This call is going to cause a warning about area being ignored return g_object_new (MY_TYPE_COMBO_BOX, "cell-area", area, NULL); } ]| If supporting alternative cell areas with your derived widget is not important, then this does not have to concern you. If you want to support alternative cell areas, you can do so by moving the problematic calls out of init() and into a constructor() for your class. Adds an attribute mapping to the list in @cell_layout. The @column is the column of the model to get a value from, and the @attribute is the parameter on @cell to be set from the value. So for example if column 2 of the model contains strings, you could have the “text” attribute of a #GtkCellRendererText get its values from column 2. a #GtkCellLayout a #GtkCellRenderer an attribute on the renderer the column position on the model to get the attribute from Unsets all the mappings on all renderers on @cell_layout and removes all renderers from @cell_layout. a #GtkCellLayout Clears all existing attributes previously set with gtk_cell_layout_set_attributes(). a #GtkCellLayout a #GtkCellRenderer to clear the attribute mapping on Returns the underlying #GtkCellArea which might be @cell_layout if called on a #GtkCellArea or might be %NULL if no #GtkCellArea is used by @cell_layout. the cell area used by @cell_layout, or %NULL in case no cell area is used. a #GtkCellLayout Returns the cell renderers which have been added to @cell_layout. a list of cell renderers. The list, but not the renderers has been newly allocated and should be freed with g_list_free() when no longer needed. a #GtkCellLayout Adds the @cell to the end of @cell_layout. If @expand is %FALSE, then the @cell is allocated no more space than it needs. Any unused space is divided evenly between cells for which @expand is %TRUE. Note that reusing the same cell renderer is not supported. a #GtkCellLayout a #GtkCellRenderer %TRUE if @cell is to be given extra space allocated to @cell_layout Packs the @cell into the beginning of @cell_layout. If @expand is %FALSE, then the @cell is allocated no more space than it needs. Any unused space is divided evenly between cells for which @expand is %TRUE. Note that reusing the same cell renderer is not supported. a #GtkCellLayout a #GtkCellRenderer %TRUE if @cell is to be given extra space allocated to @cell_layout Re-inserts @cell at @position. Note that @cell has already to be packed into @cell_layout for this to function properly. a #GtkCellLayout a #GtkCellRenderer to reorder new position to insert @cell at Sets the #GtkCellLayoutDataFunc to use for @cell_layout. This function is used instead of the standard attributes mapping for setting the column value, and should set the value of @cell_layout’s cell renderer(s) as appropriate. @func may be %NULL to remove a previously set function. a #GtkCellLayout a #GtkCellRenderer the #GtkCellLayoutDataFunc to use, or %NULL user data for @func destroy notify for @func_data Adds an attribute mapping to the list in @cell_layout. The @column is the column of the model to get a value from, and the @attribute is the parameter on @cell to be set from the value. So for example if column 2 of the model contains strings, you could have the “text” attribute of a #GtkCellRendererText get its values from column 2. a #GtkCellLayout a #GtkCellRenderer an attribute on the renderer the column position on the model to get the attribute from Unsets all the mappings on all renderers on @cell_layout and removes all renderers from @cell_layout. a #GtkCellLayout Clears all existing attributes previously set with gtk_cell_layout_set_attributes(). a #GtkCellLayout a #GtkCellRenderer to clear the attribute mapping on Returns the underlying #GtkCellArea which might be @cell_layout if called on a #GtkCellArea or might be %NULL if no #GtkCellArea is used by @cell_layout. the cell area used by @cell_layout, or %NULL in case no cell area is used. a #GtkCellLayout Returns the cell renderers which have been added to @cell_layout. a list of cell renderers. The list, but not the renderers has been newly allocated and should be freed with g_list_free() when no longer needed. a #GtkCellLayout Adds the @cell to the end of @cell_layout. If @expand is %FALSE, then the @cell is allocated no more space than it needs. Any unused space is divided evenly between cells for which @expand is %TRUE. Note that reusing the same cell renderer is not supported. a #GtkCellLayout a #GtkCellRenderer %TRUE if @cell is to be given extra space allocated to @cell_layout Packs the @cell into the beginning of @cell_layout. If @expand is %FALSE, then the @cell is allocated no more space than it needs. Any unused space is divided evenly between cells for which @expand is %TRUE. Note that reusing the same cell renderer is not supported. a #GtkCellLayout a #GtkCellRenderer %TRUE if @cell is to be given extra space allocated to @cell_layout Re-inserts @cell at @position. Note that @cell has already to be packed into @cell_layout for this to function properly. a #GtkCellLayout a #GtkCellRenderer to reorder new position to insert @cell at Sets the attributes in list as the attributes of @cell_layout. The attributes should be in attribute/column order, as in gtk_cell_layout_add_attribute(). All existing attributes are removed, and replaced with the new attributes. a #GtkCellLayout a #GtkCellRenderer a %NULL-terminated list of attributes Sets the #GtkCellLayoutDataFunc to use for @cell_layout. This function is used instead of the standard attributes mapping for setting the column value, and should set the value of @cell_layout’s cell renderer(s) as appropriate. @func may be %NULL to remove a previously set function. a #GtkCellLayout a #GtkCellRenderer the #GtkCellLayoutDataFunc to use, or %NULL user data for @func destroy notify for @func_data A function which should set the value of @cell_layout’s cell renderer(s) as appropriate. a #GtkCellLayout the cell renderer whose value is to be set the model a #GtkTreeIter indicating the row to set the value for user data passed to gtk_cell_layout_set_cell_data_func() a #GtkCellLayout a #GtkCellRenderer %TRUE if @cell is to be given extra space allocated to @cell_layout a #GtkCellLayout a #GtkCellRenderer %TRUE if @cell is to be given extra space allocated to @cell_layout a #GtkCellLayout a #GtkCellLayout a #GtkCellRenderer an attribute on the renderer the column position on the model to get the attribute from a #GtkCellLayout a #GtkCellRenderer the #GtkCellLayoutDataFunc to use, or %NULL user data for @func destroy notify for @func_data a #GtkCellLayout a #GtkCellRenderer to clear the attribute mapping on a #GtkCellLayout a #GtkCellRenderer to reorder new position to insert @cell at a list of cell renderers. The list, but not the renderers has been newly allocated and should be freed with g_list_free() when no longer needed. a #GtkCellLayout the cell area used by @cell_layout, or %NULL in case no cell area is used. a #GtkCellLayout The #GtkCellRenderer is a base class of a set of objects used for rendering a cell to a #cairo_t. These objects are used primarily by the #GtkTreeView widget, though they aren’t tied to them in any specific way. It is worth noting that #GtkCellRenderer is not a #GtkWidget and cannot be treated as such. The primary use of a #GtkCellRenderer is for drawing a certain graphical elements on a #cairo_t. Typically, one cell renderer is used to draw many cells on the screen. To this extent, it isn’t expected that a CellRenderer keep any permanent state around. Instead, any state is set just prior to use using #GObjects property system. Then, the cell is measured using gtk_cell_renderer_get_size(). Finally, the cell is rendered in the correct location using gtk_cell_renderer_render(). There are a number of rules that must be followed when writing a new #GtkCellRenderer. First and foremost, it’s important that a certain set of properties will always yield a cell renderer of the same size, barring a #GtkStyle change. The #GtkCellRenderer also has a number of generic properties that are expected to be honored by all children. Beyond merely rendering a cell, cell renderers can optionally provide active user interface elements. A cell renderer can be “activatable” like #GtkCellRendererToggle, which toggles when it gets activated by a mouse click, or it can be “editable” like #GtkCellRendererText, which allows the user to edit the text using a widget implementing the #GtkCellEditable interface, e.g. #GtkEntry. To make a cell renderer activatable or editable, you have to implement the #GtkCellRendererClass.activate or #GtkCellRendererClass.start_editing virtual functions, respectively. Many properties of #GtkCellRenderer and its subclasses have a corresponding “set” property, e.g. “cell-background-set” corresponds to “cell-background”. These “set” properties reflect whether a property has been set or not. You should not set them independently. Passes an activate event to the cell renderer for possible processing. Some cell renderers may use events; for example, #GtkCellRendererToggle toggles when it gets a mouse click. %TRUE if the event was consumed/handled a #GtkCellRenderer a #GdkEvent widget that received the event widget-dependent string representation of the event location; e.g. for #GtkTreeView, a string representation of #GtkTreePath background area as passed to gtk_cell_renderer_render() cell area as passed to gtk_cell_renderer_render() render flags Gets the aligned area used by @cell inside @cell_area. Used for finding the appropriate edit and focus rectangle. a #GtkCellRenderer instance the #GtkWidget this cell will be rendering to render flags cell area which would be passed to gtk_cell_renderer_render() the return location for the space inside @cell_area that would acually be used to render. Retreives a renderer’s natural size when rendered to @widget. a #GtkCellRenderer instance the #GtkWidget this cell will be rendering to location to store the minimum size, or %NULL location to store the natural size, or %NULL Retreives a cell renderers’s minimum and natural height if it were rendered to @widget with the specified @width. a #GtkCellRenderer instance the #GtkWidget this cell will be rendering to the size which is available for allocation location for storing the minimum size, or %NULL location for storing the preferred size, or %NULL Retreives a renderer’s natural size when rendered to @widget. a #GtkCellRenderer instance the #GtkWidget this cell will be rendering to location to store the minimum size, or %NULL location to store the natural size, or %NULL Retreives a cell renderers’s minimum and natural width if it were rendered to @widget with the specified @height. a #GtkCellRenderer instance the #GtkWidget this cell will be rendering to the size which is available for allocation location for storing the minimum size, or %NULL location for storing the preferred size, or %NULL Gets whether the cell renderer prefers a height-for-width layout or a width-for-height layout. The #GtkSizeRequestMode preferred by this renderer. a #GtkCellRenderer instance Obtains the width and height needed to render the cell. Used by view widgets to determine the appropriate size for the cell_area passed to gtk_cell_renderer_render(). If @cell_area is not %NULL, fills in the x and y offsets (if set) of the cell relative to this location. Please note that the values set in @width and @height, as well as those in @x_offset and @y_offset are inclusive of the xpad and ypad properties. Use gtk_cell_renderer_get_preferred_size() instead. a #GtkCellRenderer the widget the renderer is rendering to The area a cell will be allocated, or %NULL location to return x offset of cell relative to @cell_area, or %NULL location to return y offset of cell relative to @cell_area, or %NULL location to return width needed to render a cell, or %NULL location to return height needed to render a cell, or %NULL Invokes the virtual render function of the #GtkCellRenderer. The three passed-in rectangles are areas in @cr. Most renderers will draw within @cell_area; the xalign, yalign, xpad, and ypad fields of the #GtkCellRenderer should be honored with respect to @cell_area. @background_area includes the blank space around the cell, and also the area containing the tree expander; so the @background_area rectangles for all cells tile to cover the entire @window. a #GtkCellRenderer a cairo context to draw to the widget owning @window entire cell area (including tree expanders and maybe padding on the sides) area normally rendered by a cell renderer flags that affect rendering Starts editing the contents of this @cell, through a new #GtkCellEditable widget created by the #GtkCellRendererClass.start_editing virtual function. A new #GtkCellEditable for editing this @cell, or %NULL if editing is not possible a #GtkCellRenderer a #GdkEvent widget that received the event widget-dependent string representation of the event location; e.g. for #GtkTreeView, a string representation of #GtkTreePath background area as passed to gtk_cell_renderer_render() cell area as passed to gtk_cell_renderer_render() render flags Passes an activate event to the cell renderer for possible processing. Some cell renderers may use events; for example, #GtkCellRendererToggle toggles when it gets a mouse click. %TRUE if the event was consumed/handled a #GtkCellRenderer a #GdkEvent widget that received the event widget-dependent string representation of the event location; e.g. for #GtkTreeView, a string representation of #GtkTreePath background area as passed to gtk_cell_renderer_render() cell area as passed to gtk_cell_renderer_render() render flags Gets the aligned area used by @cell inside @cell_area. Used for finding the appropriate edit and focus rectangle. a #GtkCellRenderer instance the #GtkWidget this cell will be rendering to render flags cell area which would be passed to gtk_cell_renderer_render() the return location for the space inside @cell_area that would acually be used to render. Fills in @xalign and @yalign with the appropriate values of @cell. A #GtkCellRenderer location to fill in with the x alignment of the cell, or %NULL location to fill in with the y alignment of the cell, or %NULL Fills in @width and @height with the appropriate size of @cell. A #GtkCellRenderer location to fill in with the fixed width of the cell, or %NULL location to fill in with the fixed height of the cell, or %NULL Fills in @xpad and @ypad with the appropriate values of @cell. A #GtkCellRenderer location to fill in with the x padding of the cell, or %NULL location to fill in with the y padding of the cell, or %NULL Retreives a renderer’s natural size when rendered to @widget. a #GtkCellRenderer instance the #GtkWidget this cell will be rendering to location to store the minimum size, or %NULL location to store the natural size, or %NULL Retreives a cell renderers’s minimum and natural height if it were rendered to @widget with the specified @width. a #GtkCellRenderer instance the #GtkWidget this cell will be rendering to the size which is available for allocation location for storing the minimum size, or %NULL location for storing the preferred size, or %NULL Retrieves the minimum and natural size of a cell taking into account the widget’s preference for height-for-width management. a #GtkCellRenderer instance the #GtkWidget this cell will be rendering to location for storing the minimum size, or %NULL location for storing the natural size, or %NULL Retreives a renderer’s natural size when rendered to @widget. a #GtkCellRenderer instance the #GtkWidget this cell will be rendering to location to store the minimum size, or %NULL location to store the natural size, or %NULL Retreives a cell renderers’s minimum and natural width if it were rendered to @widget with the specified @height. a #GtkCellRenderer instance the #GtkWidget this cell will be rendering to the size which is available for allocation location for storing the minimum size, or %NULL location for storing the preferred size, or %NULL Gets whether the cell renderer prefers a height-for-width layout or a width-for-height layout. The #GtkSizeRequestMode preferred by this renderer. a #GtkCellRenderer instance Returns the cell renderer’s sensitivity. %TRUE if the cell renderer is sensitive A #GtkCellRenderer Obtains the width and height needed to render the cell. Used by view widgets to determine the appropriate size for the cell_area passed to gtk_cell_renderer_render(). If @cell_area is not %NULL, fills in the x and y offsets (if set) of the cell relative to this location. Please note that the values set in @width and @height, as well as those in @x_offset and @y_offset are inclusive of the xpad and ypad properties. Use gtk_cell_renderer_get_preferred_size() instead. a #GtkCellRenderer the widget the renderer is rendering to The area a cell will be allocated, or %NULL location to return x offset of cell relative to @cell_area, or %NULL location to return y offset of cell relative to @cell_area, or %NULL location to return width needed to render a cell, or %NULL location to return height needed to render a cell, or %NULL Translates the cell renderer state to #GtkStateFlags, based on the cell renderer and widget sensitivity, and the given #GtkCellRendererState. the widget state flags applying to @cell a #GtkCellRenderer, or %NULL a #GtkWidget, or %NULL cell renderer state Returns the cell renderer’s visibility. %TRUE if the cell renderer is visible A #GtkCellRenderer Checks whether the cell renderer can do something when activated. %TRUE if the cell renderer can do anything when activated A #GtkCellRenderer Invokes the virtual render function of the #GtkCellRenderer. The three passed-in rectangles are areas in @cr. Most renderers will draw within @cell_area; the xalign, yalign, xpad, and ypad fields of the #GtkCellRenderer should be honored with respect to @cell_area. @background_area includes the blank space around the cell, and also the area containing the tree expander; so the @background_area rectangles for all cells tile to cover the entire @window. a #GtkCellRenderer a cairo context to draw to the widget owning @window entire cell area (including tree expanders and maybe padding on the sides) area normally rendered by a cell renderer flags that affect rendering Sets the renderer’s alignment within its available space. A #GtkCellRenderer the x alignment of the cell renderer the y alignment of the cell renderer Sets the renderer size to be explicit, independent of the properties set. A #GtkCellRenderer the width of the cell renderer, or -1 the height of the cell renderer, or -1 Sets the renderer’s padding. A #GtkCellRenderer the x padding of the cell renderer the y padding of the cell renderer Sets the cell renderer’s sensitivity. A #GtkCellRenderer the sensitivity of the cell Sets the cell renderer’s visibility. A #GtkCellRenderer the visibility of the cell Starts editing the contents of this @cell, through a new #GtkCellEditable widget created by the #GtkCellRendererClass.start_editing virtual function. A new #GtkCellEditable for editing this @cell, or %NULL if editing is not possible a #GtkCellRenderer a #GdkEvent widget that received the event widget-dependent string representation of the event location; e.g. for #GtkTreeView, a string representation of #GtkTreePath background area as passed to gtk_cell_renderer_render() cell area as passed to gtk_cell_renderer_render() render flags Informs the cell renderer that the editing is stopped. If @canceled is %TRUE, the cell renderer will emit the #GtkCellRenderer::editing-canceled signal. This function should be called by cell renderer implementations in response to the #GtkCellEditable::editing-done signal of #GtkCellEditable. A #GtkCellRenderer %TRUE if the editing has been canceled Cell background as a #GdkColor Use #GtkCellRenderer:cell-background-rgba instead. Cell background as a #GdkRGBA This signal gets emitted when the user cancels the process of editing a cell. For example, an editable cell renderer could be written to cancel editing when the user presses Escape. See also: gtk_cell_renderer_stop_editing(). This signal gets emitted when a cell starts to be edited. The intended use of this signal is to do special setup on @editable, e.g. adding a #GtkEntryCompletion or setting up additional columns in a #GtkComboBox. See gtk_cell_editable_start_editing() for information on the lifecycle of the @editable and a way to do setup that doesn’t depend on the @renderer. Note that GTK+ doesn't guarantee that cell renderers will continue to use the same kind of widget for editing in future releases, therefore you should check the type of @editable before doing any specific setup, as in the following example: |[<!-- language="C" --> static void text_editing_started (GtkCellRenderer *cell, GtkCellEditable *editable, const gchar *path, gpointer data) { if (GTK_IS_ENTRY (editable)) { GtkEntry *entry = GTK_ENTRY (editable); // ... create a GtkEntryCompletion gtk_entry_set_completion (entry, completion); } } ]| the #GtkCellEditable the path identifying the edited cell #GtkCellRendererAccel displays a keyboard accelerator (i.e. a key combination like `Control + a`). If the cell renderer is editable, the accelerator can be changed by simply typing the new combination. The #GtkCellRendererAccel cell renderer was added in GTK+ 2.10. Creates a new #GtkCellRendererAccel. the new cell renderer The keyval of the accelerator. Determines if the edited accelerators are GTK+ accelerators. If they are, consumed modifiers are suppressed, only accelerators accepted by GTK+ are allowed, and the accelerators are rendered in the same way as they are in menus. The modifier mask of the accelerator. The hardware keycode of the accelerator. Note that the hardware keycode is only relevant if the key does not have a keyval. Normally, the keyboard configuration should assign keyvals to all keys. Gets emitted when the user has removed the accelerator. the path identifying the row of the edited cell Gets emitted when the user has selected a new accelerator. the path identifying the row of the edited cell the new accelerator keyval the new acclerator modifier mask the keycode of the new accelerator Determines if the edited accelerators are GTK+ accelerators. If they are, consumed modifiers are suppressed, only accelerators accepted by GTK+ are allowed, and the accelerators are rendered in the same way as they are in menus. GTK+ accelerators mode Other accelerator mode The #GtkSizeRequestMode preferred by this renderer. a #GtkCellRenderer instance a #GtkCellRenderer instance the #GtkWidget this cell will be rendering to location to store the minimum size, or %NULL location to store the natural size, or %NULL a #GtkCellRenderer instance the #GtkWidget this cell will be rendering to the size which is available for allocation location for storing the minimum size, or %NULL location for storing the preferred size, or %NULL a #GtkCellRenderer instance the #GtkWidget this cell will be rendering to location to store the minimum size, or %NULL location to store the natural size, or %NULL a #GtkCellRenderer instance the #GtkWidget this cell will be rendering to the size which is available for allocation location for storing the minimum size, or %NULL location for storing the preferred size, or %NULL a #GtkCellRenderer instance the #GtkWidget this cell will be rendering to render flags cell area which would be passed to gtk_cell_renderer_render() the return location for the space inside @cell_area that would acually be used to render. a #GtkCellRenderer the widget the renderer is rendering to The area a cell will be allocated, or %NULL location to return x offset of cell relative to @cell_area, or %NULL location to return y offset of cell relative to @cell_area, or %NULL location to return width needed to render a cell, or %NULL location to return height needed to render a cell, or %NULL a #GtkCellRenderer a cairo context to draw to the widget owning @window entire cell area (including tree expanders and maybe padding on the sides) area normally rendered by a cell renderer flags that affect rendering %TRUE if the event was consumed/handled a #GtkCellRenderer a #GdkEvent widget that received the event widget-dependent string representation of the event location; e.g. for #GtkTreeView, a string representation of #GtkTreePath background area as passed to gtk_cell_renderer_render() cell area as passed to gtk_cell_renderer_render() render flags A new #GtkCellEditable for editing this @cell, or %NULL if editing is not possible a #GtkCellRenderer a #GdkEvent widget that received the event widget-dependent string representation of the event location; e.g. for #GtkTreeView, a string representation of #GtkTreePath background area as passed to gtk_cell_renderer_render() cell area as passed to gtk_cell_renderer_render() render flags Sets the type to be used for creating accessibles for cells rendered by cell renderers of @renderer_class. Note that multiple accessibles will be created. This function should only be called from class init functions of cell renderers. class to set the accessible type for The object type that implements the accessible for @widget_class. The type must be a subtype of #GtkRendererCellAccessible #GtkCellRendererCombo renders text in a cell like #GtkCellRendererText from which it is derived. But while #GtkCellRendererText offers a simple entry to edit the text, #GtkCellRendererCombo offers a #GtkComboBox widget to edit the text. The values to display in the combo box are taken from the tree model specified in the #GtkCellRendererCombo:model property. The combo cell renderer takes care of adding a text cell renderer to the combo box and sets it to display the column specified by its #GtkCellRendererCombo:text-column property. Further properties of the combo box can be set in a handler for the #GtkCellRenderer::editing-started signal. The #GtkCellRendererCombo cell renderer was added in GTK+ 2.6. Creates a new #GtkCellRendererCombo. Adjust how text is drawn using object properties. Object properties can be set globally (with g_object_set()). Also, with #GtkTreeViewColumn, you can bind a property to a value in a #GtkTreeModel. For example, you can bind the “text” property on the cell renderer to a string value in the model, thus rendering a different string in each row of the #GtkTreeView. the new cell renderer If %TRUE, the cell renderer will include an entry and allow to enter values other than the ones in the popup list. Holds a tree model containing the possible values for the combo box. Use the text_column property to specify the column holding the values. Specifies the model column which holds the possible values for the combo box. Note that this refers to the model specified in the model property, not the model backing the tree view to which this cell renderer is attached. #GtkCellRendererCombo automatically adds a text cell renderer for this column to its combo box. This signal is emitted each time after the user selected an item in the combo box, either by using the mouse or the arrow keys. Contrary to GtkComboBox, GtkCellRendererCombo::changed is not emitted for changes made to a selected item in the entry. The argument @new_iter corresponds to the newly selected item in the combo box and it is relative to the GtkTreeModel set via the model property on GtkCellRendererCombo. Note that as soon as you change the model displayed in the tree view, the tree view will immediately cease the editing operating. This means that you most probably want to refrain from changing the model until the combo cell renderer emits the edited or editing_canceled signal. a string of the path identifying the edited cell (relative to the tree view model) the new iter selected in the combo box (relative to the combo box model) Identifies how the user can interact with a particular cell. The cell is just for display and cannot be interacted with. Note that this doesn’t mean that eg. the row being drawn can’t be selected -- just that a particular element of it cannot be individually modified. The cell can be clicked. The cell can be edited or otherwise modified. A #GtkCellRendererPixbuf can be used to render an image in a cell. It allows to render either a given #GdkPixbuf (set via the #GtkCellRendererPixbuf:pixbuf property) or a named icon (set via the #GtkCellRendererPixbuf:icon-name property). To support the tree view, #GtkCellRendererPixbuf also supports rendering two alternative pixbufs, when the #GtkCellRenderer:is-expander property is %TRUE. If the #GtkCellRenderer:is-expanded property is %TRUE and the #GtkCellRendererPixbuf:pixbuf-expander-open property is set to a pixbuf, it renders that pixbuf, if the #GtkCellRenderer:is-expanded property is %FALSE and the #GtkCellRendererPixbuf:pixbuf-expander-closed property is set to a pixbuf, it renders that one. Creates a new #GtkCellRendererPixbuf. Adjust rendering parameters using object properties. Object properties can be set globally (with g_object_set()). Also, with #GtkTreeViewColumn, you can bind a property to a value in a #GtkTreeModel. For example, you can bind the “pixbuf” property on the cell renderer to a pixbuf value in the model, thus rendering a different image in each row of the #GtkTreeView. the new cell renderer Specifies whether the rendered pixbuf should be colorized according to the #GtkCellRendererState. Cell renderers always follow state. The GIcon representing the icon to display. If the icon theme is changed, the image will be updated automatically. The name of the themed icon to display. This property only has an effect if not overridden by "stock_id" or "pixbuf" properties. Use #GtkCellRendererPixbuf:icon-name instead. The #GtkIconSize value that specifies the size of the rendered icon. #GtkCellRendererProgress renders a numeric value as a progress par in a cell. Additionally, it can display a text on top of the progress bar. The #GtkCellRendererProgress cell renderer was added in GTK+ 2.6. Creates a new #GtkCellRendererProgress. the new cell renderer Setting this to a non-negative value causes the cell renderer to enter "activity mode", where a block bounces back and forth to indicate that some progress is made, without specifying exactly how much. Each increment of the property causes the block to move by a little bit. To indicate that the activity has not started yet, set the property to zero. To indicate completion, set the property to %G_MAXINT. The "text" property determines the label which will be drawn over the progress bar. Setting this property to %NULL causes the default label to be displayed. Setting this property to an empty string causes no label to be displayed. The "text-xalign" property controls the horizontal alignment of the text in the progress bar. Valid values range from 0 (left) to 1 (right). Reserved for RTL layouts. The "text-yalign" property controls the vertical alignment of the text in the progress bar. Valid values range from 0 (top) to 1 (bottom). The "value" property determines the percentage to which the progress bar will be "filled in". #GtkCellRendererSpin renders text in a cell like #GtkCellRendererText from which it is derived. But while #GtkCellRendererText offers a simple entry to edit the text, #GtkCellRendererSpin offers a #GtkSpinButton widget. Of course, that means that the text has to be parseable as a floating point number. The range of the spinbutton is taken from the adjustment property of the cell renderer, which can be set explicitly or mapped to a column in the tree model, like all properties of cell renders. #GtkCellRendererSpin also has properties for the #GtkCellRendererSpin:climb-rate and the number of #GtkCellRendererSpin:digits to display. Other #GtkSpinButton properties can be set in a handler for the #GtkCellRenderer::editing-started signal. The #GtkCellRendererSpin cell renderer was added in GTK+ 2.10. Creates a new #GtkCellRendererSpin. a new #GtkCellRendererSpin The adjustment that holds the value of the spinbutton. This must be non-%NULL for the cell renderer to be editable. The acceleration rate when you hold down a button. The number of decimal places to display. GtkCellRendererSpinner renders a spinning animation in a cell, very similar to #GtkSpinner. It can often be used as an alternative to a #GtkCellRendererProgress for displaying indefinite activity, instead of actual progress. To start the animation in a cell, set the #GtkCellRendererSpinner:active property to %TRUE and increment the #GtkCellRendererSpinner:pulse property at regular intervals. The usual way to set the cell renderer properties for each cell is to bind them to columns in your tree model using e.g. gtk_tree_view_column_add_attribute(). Returns a new cell renderer which will show a spinner to indicate activity. a new #GtkCellRenderer Pulse of the spinner. Increment this value to draw the next frame of the spinner animation. Usually, you would update this value in a timeout. By default, the #GtkSpinner widget draws one full cycle of the animation, consisting of 12 frames, in 750 milliseconds. The #GtkIconSize value that specifies the size of the rendered spinner. Tells how a cell is to be rendered. The cell is currently selected, and probably has a selection colored background to render to. The mouse is hovering over the cell. The cell is drawn in an insensitive manner The cell is in a sorted row The cell is in the focus row. The cell is in a row that can be expanded. Since 3.4 The cell is in a row that is expanded. Since 3.4 A #GtkCellRendererText renders a given text in its cell, using the font, color and style information provided by its properties. The text will be ellipsized if it is too long and the #GtkCellRendererText:ellipsize property allows it. If the #GtkCellRenderer:mode is %GTK_CELL_RENDERER_MODE_EDITABLE, the #GtkCellRendererText allows to edit its text using an entry. Creates a new #GtkCellRendererText. Adjust how text is drawn using object properties. Object properties can be set globally (with g_object_set()). Also, with #GtkTreeViewColumn, you can bind a property to a value in a #GtkTreeModel. For example, you can bind the “text” property on the cell renderer to a string value in the model, thus rendering a different string in each row of the #GtkTreeView the new cell renderer Sets the height of a renderer to explicitly be determined by the “font” and “y_pad” property set on it. Further changes in these properties do not affect the height, so they must be accompanied by a subsequent call to this function. Using this function is unflexible, and should really only be used if calculating the size of a cell is too slow (ie, a massive number of cells displayed). If @number_of_rows is -1, then the fixed height is unset, and the height is determined by the properties again. A #GtkCellRendererText Number of rows of text each cell renderer is allocated, or -1 Specifies how to align the lines of text with respect to each other. Note that this property describes how to align the lines of text in case there are several of them. The "xalign" property of #GtkCellRenderer, on the other hand, sets the horizontal alignment of the whole text. Background color as a #GdkColor Use #GtkCellRendererText:background-rgba instead. Background color as a #GdkRGBA Specifies whether or not to discard the edition when the #GtkCellRenderer loses focus. If this is set to TRUE (the default), then edition will be canceled if the focus leaves the tree. Since 3.22 Specifies the preferred place to ellipsize the string, if the cell renderer does not have enough room to display the entire string. Setting it to %PANGO_ELLIPSIZE_NONE turns off ellipsizing. See the wrap-width property for another way of making the text fit into a given width. Foreground color as a #GdkColor Use #GtkCellRendererText:foreground-rgba instead. Foreground color as a #GdkRGBA The desired maximum width of the cell, in characters. If this property is set to -1, the width will be calculated automatically. For cell renderers that ellipsize or wrap text; this property controls the maximum reported width of the cell. The cell should not receive any greater allocation unless it is set to expand in its #GtkCellLayout and all of the cell's siblings have received their natural width. The text that will be displayed in the #GtkCellRenderer if #GtkCellRendererText:editable is %TRUE and the cell is empty. Since 3.6 The desired width of the cell, in characters. If this property is set to -1, the width will be calculated automatically, otherwise the cell will request either 3 characters or the property value, whichever is greater. Specifies how to break the string into multiple lines, if the cell renderer does not have enough room to display the entire string. This property has no effect unless the wrap-width property is set. Specifies the minimum width at which the text is wrapped. The wrap-mode property can be used to influence at what character positions the line breaks can be placed. Setting wrap-width to -1 turns wrapping off. This signal is emitted after @renderer has been edited. It is the responsibility of the application to update the model and store @new_text at the position indicated by @path. the path identifying the edited cell the new text #GtkCellRendererToggle renders a toggle button in a cell. The button is drawn as a radio or a checkbutton, depending on the #GtkCellRendererToggle:radio property. When activated, it emits the #GtkCellRendererToggle::toggled signal. Creates a new #GtkCellRendererToggle. Adjust rendering parameters using object properties. Object properties can be set globally (with g_object_set()). Also, with #GtkTreeViewColumn, you can bind a property to a value in a #GtkTreeModel. For example, you can bind the “active” property on the cell renderer to a boolean value in the model, thus causing the check button to reflect the state of the model. the new cell renderer Returns whether the cell renderer is activatable. See gtk_cell_renderer_toggle_set_activatable(). %TRUE if the cell renderer is activatable. a #GtkCellRendererToggle Returns whether the cell renderer is active. See gtk_cell_renderer_toggle_set_active(). %TRUE if the cell renderer is active. a #GtkCellRendererToggle Returns whether we’re rendering radio toggles rather than checkboxes. %TRUE if we’re rendering radio toggles rather than checkboxes a #GtkCellRendererToggle Makes the cell renderer activatable. a #GtkCellRendererToggle. the value to set. Activates or deactivates a cell renderer. a #GtkCellRendererToggle. the value to set. If @radio is %TRUE, the cell renderer renders a radio toggle (i.e. a toggle in a group of mutually-exclusive toggles). If %FALSE, it renders a check toggle (a standalone boolean option). This can be set globally for the cell renderer, or changed just before rendering each cell in the model (for #GtkTreeView, you set up a per-row setting using #GtkTreeViewColumn to associate model columns with cell renderer properties). a #GtkCellRendererToggle %TRUE to make the toggle look like a radio button The ::toggled signal is emitted when the cell is toggled. It is the responsibility of the application to update the model with the correct value to store at @path. Often this is simply the opposite of the value currently stored at @path. string representation of #GtkTreePath describing the event location A #GtkCellView displays a single row of a #GtkTreeModel using a #GtkCellArea and #GtkCellAreaContext. A #GtkCellAreaContext can be provided to the #GtkCellView at construction time in order to keep the cellview in context of a group of cell views, this ensures that the renderers displayed will be properly aligned with eachother (like the aligned cells in the menus of #GtkComboBox). #GtkCellView is #GtkOrientable in order to decide in which orientation the underlying #GtkCellAreaContext should be allocated. Taking the #GtkComboBox menu as an example, cellviews should be oriented horizontally if the menus are listed top-to-bottom and thus all share the same width but may have separate individual heights (left-to-right menus should be allocated vertically since they all share the same height but may have variable widths). # CSS nodes GtkCellView has a single CSS node with name cellview. Creates a new #GtkCellView widget. A newly created #GtkCellView widget. Creates a new #GtkCellView widget with a specific #GtkCellArea to layout cells and a specific #GtkCellAreaContext. Specifying the same context for a handfull of cells lets the underlying area synchronize the geometry for those cells, in this way alignments with cellviews for other rows are possible. A newly created #GtkCellView widget. the #GtkCellArea to layout cells the #GtkCellAreaContext in which to calculate cell geometry Creates a new #GtkCellView widget, adds a #GtkCellRendererText to it, and makes it show @markup. The text can be marked up with the [Pango text markup language][PangoMarkupFormat]. A newly created #GtkCellView widget. the text to display in the cell view Creates a new #GtkCellView widget, adds a #GtkCellRendererPixbuf to it, and makes it show @pixbuf. A newly created #GtkCellView widget. the image to display in the cell view Creates a new #GtkCellView widget, adds a #GtkCellRendererText to it, and makes it show @text. A newly created #GtkCellView widget. the text to display in the cell view Returns a #GtkTreePath referring to the currently displayed row. If no row is currently displayed, %NULL is returned. the currently displayed row or %NULL a #GtkCellView Gets whether @cell_view is configured to draw all of its cells in a sensitive state. whether @cell_view draws all of its cells in a sensitive state a #GtkCellView Gets whether @cell_view is configured to request space to fit the entire #GtkTreeModel. whether @cell_view requests space to fit the entire #GtkTreeModel. a #GtkCellView Returns the model for @cell_view. If no model is used %NULL is returned. a #GtkTreeModel used or %NULL a #GtkCellView Sets @requisition to the size needed by @cell_view to display the model row pointed to by @path. Combo box formerly used this to calculate the sizes for cellviews, now you can achieve this by either using the #GtkCellView:fit-model property or by setting the currently displayed row of the #GtkCellView and using gtk_widget_get_preferred_size(). %TRUE a #GtkCellView a #GtkTreePath return location for the size Sets the background color of @view. Use gtk_cell_view_set_background_rgba() instead. a #GtkCellView the new background color Sets the background color of @cell_view. a #GtkCellView the new background color Sets the row of the model that is currently displayed by the #GtkCellView. If the path is unset, then the contents of the cellview “stick” at their last value; this is not normally a desired result, but may be a needed intermediate state if say, the model for the #GtkCellView becomes temporarily empty. a #GtkCellView a #GtkTreePath or %NULL to unset. Sets whether @cell_view should draw all of its cells in a sensitive state, this is used by #GtkComboBox menus to ensure that rows with insensitive cells that contain children appear sensitive in the parent menu item. a #GtkCellView whether to draw all cells in a sensitive state. Sets whether @cell_view should request space to fit the entire #GtkTreeModel. This is used by #GtkComboBox to ensure that the cell view displayed on the combo box’s button always gets enough space and does not resize when selection changes. a #GtkCellView whether @cell_view should request space for the whole model. Sets the model for @cell_view. If @cell_view already has a model set, it will remove it before setting the new model. If @model is %NULL, then it will unset the old model. a #GtkCellView a #GtkTreeModel The background color as a #GdkColor Use #GtkCellView:background-rgba instead. The background color as a #GdkRGBA The #GtkCellArea rendering cells If no area is specified when creating the cell view with gtk_cell_view_new_with_context() a horizontally oriented #GtkCellAreaBox will be used. since 3.0 The #GtkCellAreaContext used to compute the geometry of the cell view. A group of cell views can be assigned the same context in order to ensure the sizes and cell alignments match across all the views with the same context. #GtkComboBox menus uses this to assign the same context to all cell views in the menu items for a single menu (each submenu creates its own context since the size of each submenu does not depend on parent or sibling menus). since 3.0 Whether all cells should be draw as sensitive for this view regardless of the actual cell properties (used to make menus with submenus appear sensitive when the items in submenus might be insensitive). since 3.0 Whether the view should request enough space to always fit the size of every row in the model (used by the combo box to ensure the combo box size doesnt change when different items are selected). since 3.0 The model for cell view since 2.10 The parent class. A #GtkCheckButton places a discrete #GtkToggleButton next to a widget, (usually a #GtkLabel). See the section on #GtkToggleButton widgets for more information about toggle/check buttons. The important signal ( #GtkToggleButton::toggled ) is also inherited from #GtkToggleButton. # CSS nodes |[<!-- language="plain" --> checkbutton ├── check ╰── <child> ]| A GtkCheckButton with indicator (see gtk_toggle_button_set_mode()) has a main CSS node with name checkbutton and a subnode with name check. |[<!-- language="plain" --> button.check ├── check ╰── <child> ]| A GtkCheckButton without indicator changes the name of its main node to button and adds a .check style class to it. The subnode is invisible in this case. Creates a new #GtkCheckButton. a #GtkWidget. Creates a new #GtkCheckButton with a #GtkLabel to the right of it. a #GtkWidget. the text for the check button. Creates a new #GtkCheckButton containing a label. The label will be created using gtk_label_new_with_mnemonic(), so underscores in @label indicate the mnemonic for the check button. a new #GtkCheckButton The text of the button, with an underscore in front of the mnemonic character A #GtkCheckMenuItem is a menu item that maintains the state of a boolean value in addition to a #GtkMenuItem usual role in activating application code. A check box indicating the state of the boolean value is displayed at the left side of the #GtkMenuItem. Activating the #GtkMenuItem toggles the value. # CSS nodes |[<!-- language="plain" --> menuitem ├── check.left ╰── <child> ]| GtkCheckMenuItem has a main CSS node with name menuitem, and a subnode with name check, which gets the .left or .right style class. Creates a new #GtkCheckMenuItem. a new #GtkCheckMenuItem. Creates a new #GtkCheckMenuItem with a label. a new #GtkCheckMenuItem. the string to use for the label. Creates a new #GtkCheckMenuItem containing a label. The label will be created using gtk_label_new_with_mnemonic(), so underscores in @label indicate the mnemonic for the menu item. a new #GtkCheckMenuItem The text of the button, with an underscore in front of the character Emits the #GtkCheckMenuItem::toggled signal. a #GtkCheckMenuItem. Returns whether the check menu item is active. See gtk_check_menu_item_set_active (). %TRUE if the menu item is checked. a #GtkCheckMenuItem Returns whether @check_menu_item looks like a #GtkRadioMenuItem Whether @check_menu_item looks like a #GtkRadioMenuItem a #GtkCheckMenuItem Retrieves the value set by gtk_check_menu_item_set_inconsistent(). %TRUE if inconsistent a #GtkCheckMenuItem Sets the active state of the menu item’s check box. a #GtkCheckMenuItem. boolean value indicating whether the check box is active. Sets whether @check_menu_item is drawn like a #GtkRadioMenuItem a #GtkCheckMenuItem whether @check_menu_item is drawn like a #GtkRadioMenuItem If the user has selected a range of elements (such as some text or spreadsheet cells) that are affected by a boolean setting, and the current values in that range are inconsistent, you may want to display the check in an “in between” state. This function turns on “in between” display. Normally you would turn off the inconsistent state again if the user explicitly selects a setting. This has to be done manually, gtk_check_menu_item_set_inconsistent() only affects visual appearance, it doesn’t affect the semantics of the widget. a #GtkCheckMenuItem %TRUE to display an “inconsistent” third state check Emits the #GtkCheckMenuItem::toggled signal. a #GtkCheckMenuItem. This signal is emitted when the state of the check box is changed. A signal handler can use gtk_check_menu_item_get_active() to discover the new state. The parent class. a #GtkCheckMenuItem. The #GtkClipboard object represents a clipboard of data shared between different processes or between different widgets in the same process. Each clipboard is identified by a name encoded as a #GdkAtom. (Conversion to and from strings can be done with gdk_atom_intern() and gdk_atom_name().) The default clipboard corresponds to the “CLIPBOARD” atom; another commonly used clipboard is the “PRIMARY” clipboard, which, in X, traditionally contains the currently selected text. To support having a number of different formats on the clipboard at the same time, the clipboard mechanism allows providing callbacks instead of the actual data. When you set the contents of the clipboard, you can either supply the data directly (via functions like gtk_clipboard_set_text()), or you can supply a callback to be called at a later time when the data is needed (via gtk_clipboard_set_with_data() or gtk_clipboard_set_with_owner().) Providing a callback also avoids having to make copies of the data when it is not needed. gtk_clipboard_set_with_data() and gtk_clipboard_set_with_owner() are quite similar; the choice between the two depends mostly on which is more convenient in a particular situation. The former is most useful when you want to have a blob of data with callbacks to convert it into the various data types that you advertise. When the @clear_func you provided is called, you simply free the data blob. The latter is more useful when the contents of clipboard reflect the internal state of a #GObject (As an example, for the PRIMARY clipboard, when an entry widget provides the clipboard’s contents the contents are simply the text within the selected region.) If the contents change, the entry widget can call gtk_clipboard_set_with_owner() to update the timestamp for clipboard ownership, without having to worry about @clear_func being called. Requesting the data from the clipboard is essentially asynchronous. If the contents of the clipboard are provided within the same process, then a direct function call will be made to retrieve the data, but if they are provided by another process, then the data needs to be retrieved from the other process, which may take some time. To avoid blocking the user interface, the call to request the selection, gtk_clipboard_request_contents() takes a callback that will be called when the contents are received (or when the request fails.) If you don’t want to deal with providing a separate callback, you can also use gtk_clipboard_wait_for_contents(). What this does is run the GLib main loop recursively waiting for the contents. This can simplify the code flow, but you still have to be aware that other callbacks in your program can be called while this recursive mainloop is running. Along with the functions to get the clipboard contents as an arbitrary data chunk, there are also functions to retrieve it as text, gtk_clipboard_request_text() and gtk_clipboard_wait_for_text(). These functions take care of determining which formats are advertised by the clipboard provider, asking for the clipboard in the best available format and converting the results into the UTF-8 encoding. (The standard form for representing strings in GTK+.) Returns the clipboard object for the given selection. See gtk_clipboard_get_for_display() for complete details. the appropriate clipboard object. If no clipboard already exists, a new one will be created. Once a clipboard object has been created, it is persistent and, since it is owned by GTK+, must not be freed or unreffed. a #GdkAtom which identifies the clipboard to use Returns the default clipboard object for use with cut/copy/paste menu items and keyboard shortcuts. the default clipboard object. the #GdkDisplay for which the clipboard is to be retrieved. Returns the clipboard object for the given selection. Cut/copy/paste menu items and keyboard shortcuts should use the default clipboard, returned by passing %GDK_SELECTION_CLIPBOARD for @selection. (%GDK_NONE is supported as a synonym for GDK_SELECTION_CLIPBOARD for backwards compatibility reasons.) The currently-selected object or text should be provided on the clipboard identified by #GDK_SELECTION_PRIMARY. Cut/copy/paste menu items conceptually copy the contents of the #GDK_SELECTION_PRIMARY clipboard to the default clipboard, i.e. they copy the selection to what the user sees as the clipboard. (Passing #GDK_NONE is the same as using `gdk_atom_intern ("CLIPBOARD", FALSE)`. See the [FreeDesktop Clipboard Specification](http://www.freedesktop.org/Standards/clipboards-spec) for a detailed discussion of the “CLIPBOARD” vs. “PRIMARY” selections under the X window system. On Win32 the #GDK_SELECTION_PRIMARY clipboard is essentially ignored.) It’s possible to have arbitrary named clipboards; if you do invent new clipboards, you should prefix the selection name with an underscore (because the ICCCM requires that nonstandard atoms are underscore-prefixed), and namespace it as well. For example, if your application called “Foo” has a special-purpose clipboard, you might call it “_FOO_SPECIAL_CLIPBOARD”. the appropriate clipboard object. If no clipboard already exists, a new one will be created. Once a clipboard object has been created, it is persistent and, since it is owned by GTK+, must not be freed or unrefd. the #GdkDisplay for which the clipboard is to be retrieved or created. a #GdkAtom which identifies the clipboard to use. Clears the contents of the clipboard. Generally this should only be called between the time you call gtk_clipboard_set_with_owner() or gtk_clipboard_set_with_data(), and when the @clear_func you supplied is called. Otherwise, the clipboard may be owned by someone else. a #GtkClipboard Gets the #GdkDisplay associated with @clipboard the #GdkDisplay associated with @clipboard a #GtkClipboard If the clipboard contents callbacks were set with gtk_clipboard_set_with_owner(), and the gtk_clipboard_set_with_data() or gtk_clipboard_clear() has not subsequently called, returns the owner set by gtk_clipboard_set_with_owner(). the owner of the clipboard, if any; otherwise %NULL. a #GtkClipboard Gets the selection that this clipboard is for. the selection a #GtkClipboard Requests the contents of clipboard as the given target. When the results of the result are later received the supplied callback will be called. a #GtkClipboard an atom representing the form into which the clipboard owner should convert the selection. A function to call when the results are received (or the retrieval fails). If the retrieval fails the length field of @selection_data will be negative. user data to pass to @callback Requests the contents of the clipboard as image. When the image is later received, it will be converted to a #GdkPixbuf, and @callback will be called. The @pixbuf parameter to @callback will contain the resulting #GdkPixbuf if the request succeeded, or %NULL if it failed. This could happen for various reasons, in particular if the clipboard was empty or if the contents of the clipboard could not be converted into an image. a #GtkClipboard a function to call when the image is received, or the retrieval fails. (It will always be called one way or the other.) user data to pass to @callback. Requests the contents of the clipboard as rich text. When the rich text is later received, @callback will be called. The @text parameter to @callback will contain the resulting rich text if the request succeeded, or %NULL if it failed. The @length parameter will contain @text’s length. This function can fail for various reasons, in particular if the clipboard was empty or if the contents of the clipboard could not be converted into rich text form. a #GtkClipboard a #GtkTextBuffer a function to call when the text is received, or the retrieval fails. (It will always be called one way or the other.) user data to pass to @callback. Requests the contents of the clipboard as list of supported targets. When the list is later received, @callback will be called. The @targets parameter to @callback will contain the resulting targets if the request succeeded, or %NULL if it failed. a #GtkClipboard a function to call when the targets are received, or the retrieval fails. (It will always be called one way or the other.) user data to pass to @callback. Requests the contents of the clipboard as text. When the text is later received, it will be converted to UTF-8 if necessary, and @callback will be called. The @text parameter to @callback will contain the resulting text if the request succeeded, or %NULL if it failed. This could happen for various reasons, in particular if the clipboard was empty or if the contents of the clipboard could not be converted into text form. a #GtkClipboard a function to call when the text is received, or the retrieval fails. (It will always be called one way or the other.) user data to pass to @callback. Requests the contents of the clipboard as URIs. When the URIs are later received @callback will be called. The @uris parameter to @callback will contain the resulting array of URIs if the request succeeded, or %NULL if it failed. This could happen for various reasons, in particular if the clipboard was empty or if the contents of the clipboard could not be converted into URI form. a #GtkClipboard a function to call when the URIs are received, or the retrieval fails. (It will always be called one way or the other.) user data to pass to @callback. Hints that the clipboard data should be stored somewhere when the application exits or when gtk_clipboard_store () is called. This value is reset when the clipboard owner changes. Where the clipboard data is stored is platform dependent, see gdk_display_store_clipboard () for more information. a #GtkClipboard array containing information about which forms should be stored or %NULL to indicate that all forms should be stored. number of elements in @targets Sets the contents of the clipboard to the given #GdkPixbuf. GTK+ will take responsibility for responding for requests for the image, and for converting the image into the requested format. a #GtkClipboard object a #GdkPixbuf Sets the contents of the clipboard to the given UTF-8 string. GTK+ will make a copy of the text and take responsibility for responding for requests for the text, and for converting the text into the requested format. a #GtkClipboard object a UTF-8 string. length of @text, in bytes, or -1, in which case the length will be determined with strlen(). Virtually sets the contents of the specified clipboard by providing a list of supported formats for the clipboard data and a function to call to get the actual data when it is requested. %TRUE if setting the clipboard data succeeded. If setting the clipboard data failed the provided callback functions will be ignored. a #GtkClipboard array containing information about the available forms for the clipboard data number of elements in @targets function to call to get the actual clipboard data when the clipboard contents are set again, this function will be called, and @get_func will not be subsequently called. user data to pass to @get_func and @clear_func. Virtually sets the contents of the specified clipboard by providing a list of supported formats for the clipboard data and a function to call to get the actual data when it is requested. The difference between this function and gtk_clipboard_set_with_data() is that instead of an generic @user_data pointer, a #GObject is passed in. %TRUE if setting the clipboard data succeeded. If setting the clipboard data failed the provided callback functions will be ignored. a #GtkClipboard array containing information about the available forms for the clipboard data number of elements in @targets function to call to get the actual clipboard data when the clipboard contents are set again, this function will be called, and @get_func will not be subsequently called an object that “owns” the data. This object will be passed to the callbacks when called Stores the current clipboard data somewhere so that it will stay around after the application has quit. a #GtkClipboard Requests the contents of the clipboard using the given target. This function waits for the data to be received using the main loop, so events, timeouts, etc, may be dispatched during the wait. a newly-allocated #GtkSelectionData object or %NULL if retrieving the given target failed. If non-%NULL, this value must be freed with gtk_selection_data_free() when you are finished with it. a #GtkClipboard an atom representing the form into which the clipboard owner should convert the selection. Requests the contents of the clipboard as image and converts the result to a #GdkPixbuf. This function waits for the data to be received using the main loop, so events, timeouts, etc, may be dispatched during the wait. a newly-allocated #GdkPixbuf object which must be disposed with g_object_unref(), or %NULL if retrieving the selection data failed. (This could happen for various reasons, in particular if the clipboard was empty or if the contents of the clipboard could not be converted into an image.) a #GtkClipboard Requests the contents of the clipboard as rich text. This function waits for the data to be received using the main loop, so events, timeouts, etc, may be dispatched during the wait. a newly-allocated binary block of data which must be freed with g_free(), or %NULL if retrieving the selection data failed. (This could happen for various reasons, in particular if the clipboard was empty or if the contents of the clipboard could not be converted into text form.) a #GtkClipboard a #GtkTextBuffer return location for the format of the returned data return location for the length of the returned data Returns a list of targets that are present on the clipboard, or %NULL if there aren’t any targets available. The returned list must be freed with g_free(). This function waits for the data to be received using the main loop, so events, timeouts, etc, may be dispatched during the wait. %TRUE if any targets are present on the clipboard, otherwise %FALSE. a #GtkClipboard location to store an array of targets. The result stored here must be freed with g_free(). location to store number of items in @targets. Requests the contents of the clipboard as text and converts the result to UTF-8 if necessary. This function waits for the data to be received using the main loop, so events, timeouts, etc, may be dispatched during the wait. a newly-allocated UTF-8 string which must be freed with g_free(), or %NULL if retrieving the selection data failed. (This could happen for various reasons, in particular if the clipboard was empty or if the contents of the clipboard could not be converted into text form.) a #GtkClipboard Requests the contents of the clipboard as URIs. This function waits for the data to be received using the main loop, so events, timeouts, etc, may be dispatched during the wait. a newly-allocated %NULL-terminated array of strings which must be freed with g_strfreev(), or %NULL if retrieving the selection data failed. (This could happen for various reasons, in particular if the clipboard was empty or if the contents of the clipboard could not be converted into URI form.) a #GtkClipboard Test to see if there is an image available to be pasted This is done by requesting the TARGETS atom and checking if it contains any of the supported image targets. This function waits for the data to be received using the main loop, so events, timeouts, etc, may be dispatched during the wait. This function is a little faster than calling gtk_clipboard_wait_for_image() since it doesn’t need to retrieve the actual image data. %TRUE is there is an image available, %FALSE otherwise. a #GtkClipboard Test to see if there is rich text available to be pasted This is done by requesting the TARGETS atom and checking if it contains any of the supported rich text targets. This function waits for the data to be received using the main loop, so events, timeouts, etc, may be dispatched during the wait. This function is a little faster than calling gtk_clipboard_wait_for_rich_text() since it doesn’t need to retrieve the actual text. %TRUE is there is rich text available, %FALSE otherwise. a #GtkClipboard a #GtkTextBuffer Checks if a clipboard supports pasting data of a given type. This function can be used to determine if a “Paste” menu item should be insensitive or not. If you want to see if there’s text available on the clipboard, use gtk_clipboard_wait_is_text_available () instead. %TRUE if the target is available, %FALSE otherwise. a #GtkClipboard A #GdkAtom indicating which target to look for. Test to see if there is text available to be pasted This is done by requesting the TARGETS atom and checking if it contains any of the supported text targets. This function waits for the data to be received using the main loop, so events, timeouts, etc, may be dispatched during the wait. This function is a little faster than calling gtk_clipboard_wait_for_text() since it doesn’t need to retrieve the actual text. %TRUE is there is text available, %FALSE otherwise. a #GtkClipboard Test to see if there is a list of URIs available to be pasted This is done by requesting the TARGETS atom and checking if it contains the URI targets. This function waits for the data to be received using the main loop, so events, timeouts, etc, may be dispatched during the wait. This function is a little faster than calling gtk_clipboard_wait_for_uris() since it doesn’t need to retrieve the actual URI data. %TRUE is there is an URI list available, %FALSE otherwise. a #GtkClipboard The ::owner-change signal is emitted when GTK+ receives an event that indicates that the ownership of the selection associated with @clipboard has changed. the @GdkEventOwnerChange event A function that will be called when the contents of the clipboard are changed or cleared. Once this has called, the @user_data_or_owner argument will not be used again. the #GtkClipboard the @user_data argument passed to gtk_clipboard_set_with_data(), or the @owner argument passed to gtk_clipboard_set_with_owner() A function that will be called to provide the contents of the selection. If multiple types of data were advertised, the requested type can be determined from the @info parameter or by checking the target field of @selection_data. If the data could successfully be converted into then it should be stored into the @selection_data object by calling gtk_selection_data_set() (or related functions such as gtk_selection_data_set_text()). If no data is set, the requestor will be informed that the attempt to get the data failed. the #GtkClipboard a #GtkSelectionData argument in which the requested data should be stored. the info field corresponding to the requested target from the #GtkTargetEntry array passed to gtk_clipboard_set_with_data() or gtk_clipboard_set_with_owner(). the @user_data argument passed to gtk_clipboard_set_with_data(), or the @owner argument passed to gtk_clipboard_set_with_owner() A function to be called when the results of gtk_clipboard_request_image() are received, or when the request fails. the #GtkClipboard the received image the @user_data supplied to gtk_clipboard_request_image(). A function to be called when the results of gtk_clipboard_request_contents() are received, or when the request fails. the #GtkClipboard a #GtkSelectionData containing the data was received. If retrieving the data failed, then then length field of @selection_data will be negative. the @user_data supplied to gtk_clipboard_request_contents(). A function to be called when the results of gtk_clipboard_request_rich_text() are received, or when the request fails. the #GtkClipboard The format of the rich text the rich text received, as a UTF-8 encoded string, or %NULL if retrieving the data failed. Length of the text. the @user_data supplied to gtk_clipboard_request_rich_text(). A function to be called when the results of gtk_clipboard_request_targets() are received, or when the request fails. the #GtkClipboard the supported targets, as array of #GdkAtom, or %NULL if retrieving the data failed. the length of the @atoms array. the @user_data supplied to gtk_clipboard_request_targets(). A function to be called when the results of gtk_clipboard_request_text() are received, or when the request fails. the #GtkClipboard the text received, as a UTF-8 encoded string, or %NULL if retrieving the data failed. the @user_data supplied to gtk_clipboard_request_text(). A function to be called when the results of gtk_clipboard_request_uris() are received, or when the request fails. the #GtkClipboard the received URIs the @user_data supplied to gtk_clipboard_request_uris(). The #GtkColorButton is a button which displays the currently selected color and allows to open a color selection dialog to change the color. It is suitable widget for selecting a color in a preference dialog. # CSS nodes GtkColorButton has a single CSS node with name button. To differentiate it from a plain #GtkButton, it gets the .color style class. Creates a new color button. This returns a widget in the form of a small button containing a swatch representing the current selected color. When the button is clicked, a color-selection dialog will open, allowing the user to select a color. The swatch will be updated to reflect the new color when the user finishes. a new color button Creates a new color button. Use gtk_color_button_new_with_rgba() instead. a new color button A #GdkColor to set the current color with Creates a new color button. a new color button A #GdkRGBA to set the current color with Returns the current alpha value. Use gtk_color_chooser_get_rgba() instead. an integer between 0 and 65535 a #GtkColorButton Sets @color to be the current color in the #GtkColorButton widget. Use gtk_color_chooser_get_rgba() instead. a #GtkColorButton a #GdkColor to fill in with the current color Sets @rgba to be the current color in the #GtkColorButton widget. Use gtk_color_chooser_get_rgba() instead. a #GtkColorButton a #GdkRGBA to fill in with the current color Gets the title of the color selection dialog. An internal string, do not free the return value a #GtkColorButton Does the color selection dialog use the alpha channel ? Use gtk_color_chooser_get_use_alpha() instead. %TRUE if the color sample uses alpha channel, %FALSE if not a #GtkColorButton Sets the current opacity to be @alpha. Use gtk_color_chooser_set_rgba() instead. a #GtkColorButton an integer between 0 and 65535 Sets the current color to be @color. Use gtk_color_chooser_set_rgba() instead. a #GtkColorButton A #GdkColor to set the current color with Sets the current color to be @rgba. Use gtk_color_chooser_set_rgba() instead. a #GtkColorButton a #GdkRGBA to set the current color with Sets the title for the color selection dialog. a #GtkColorButton String containing new window title Sets whether or not the color button should use the alpha channel. Use gtk_color_chooser_set_use_alpha() instead. a #GtkColorButton %TRUE if color button should use alpha channel, %FALSE if not The selected opacity value (0 fully transparent, 65535 fully opaque). The selected color. Use #GtkColorButton:rgba instead. The RGBA color. Set this property to %TRUE to skip the palette in the dialog and go directly to the color editor. This property should be used in cases where the palette in the editor would be redundant, such as when the color button is already part of a palette. The title of the color selection dialog If this property is set to %TRUE, the color swatch on the button is rendered against a checkerboard background to show its opacity and the opacity slider is displayed in the color selection dialog. The ::color-set signal is emitted when the user selects a color. When handling this signal, use gtk_color_button_get_rgba() to find out which color was just selected. Note that this signal is only emitted when the user changes the color. If you need to react to programmatic color changes as well, use the notify::color signal. #GtkColorChooser is an interface that is implemented by widgets for choosing colors. Depending on the situation, colors may be allowed to have alpha (translucency). In GTK+, the main widgets that implement this interface are #GtkColorChooserWidget, #GtkColorChooserDialog and #GtkColorButton. Adds a palette to the color chooser. If @orientation is horizontal, the colors are grouped in rows, with @colors_per_line colors in each row. If @horizontal is %FALSE, the colors are grouped in columns instead. The default color palette of #GtkColorChooserWidget has 27 colors, organized in columns of 3 colors. The default gray palette has 9 grays in a single row. The layout of the color chooser widget works best when the palettes have 9-10 columns. Calling this function for the first time has the side effect of removing the default color and gray palettes from the color chooser. If @colors is %NULL, removes all previously added palettes. a #GtkColorChooser %GTK_ORIENTATION_HORIZONTAL if the palette should be displayed in rows, %GTK_ORIENTATION_VERTICAL for columns the number of colors to show in each row/column the total number of elements in @colors the colors of the palette, or %NULL Gets the currently-selected color. a #GtkColorChooser a #GdkRGBA to fill in with the current color Sets the color. a #GtkColorChooser the new color Adds a palette to the color chooser. If @orientation is horizontal, the colors are grouped in rows, with @colors_per_line colors in each row. If @horizontal is %FALSE, the colors are grouped in columns instead. The default color palette of #GtkColorChooserWidget has 27 colors, organized in columns of 3 colors. The default gray palette has 9 grays in a single row. The layout of the color chooser widget works best when the palettes have 9-10 columns. Calling this function for the first time has the side effect of removing the default color and gray palettes from the color chooser. If @colors is %NULL, removes all previously added palettes. a #GtkColorChooser %GTK_ORIENTATION_HORIZONTAL if the palette should be displayed in rows, %GTK_ORIENTATION_VERTICAL for columns the number of colors to show in each row/column the total number of elements in @colors the colors of the palette, or %NULL Gets the currently-selected color. a #GtkColorChooser a #GdkRGBA to fill in with the current color Returns whether the color chooser shows the alpha channel. %TRUE if the color chooser uses the alpha channel, %FALSE if not a #GtkColorChooser Sets the color. a #GtkColorChooser the new color Sets whether or not the color chooser should use the alpha channel. a #GtkColorChooser %TRUE if color chooser should use alpha channel, %FALSE if not The ::rgba property contains the currently selected color, as a #GdkRGBA struct. The property can be set to change the current selection programmatically. When ::use-alpha is %TRUE, colors may have alpha (translucency) information. When it is %FALSE, the #GdkRGBA struct obtained via the #GtkColorChooser:rgba property will be forced to have alpha == 1. Implementations are expected to show alpha by rendering the color over a non-uniform background (like a checkerboard pattern). Emitted when a color is activated from the color chooser. This usually happens when the user clicks a color swatch, or a color is selected and the user presses one of the keys Space, Shift+Space, Return or Enter. the color The #GtkColorChooserDialog widget is a dialog for choosing a color. It implements the #GtkColorChooser interface. Creates a new #GtkColorChooserDialog. a new #GtkColorChooserDialog Title of the dialog, or %NULL Transient parent of the dialog, or %NULL a #GtkColorChooser a #GdkRGBA to fill in with the current color a #GtkColorChooser the new color a #GtkColorChooser %GTK_ORIENTATION_HORIZONTAL if the palette should be displayed in rows, %GTK_ORIENTATION_VERTICAL for columns the number of colors to show in each row/column the total number of elements in @colors the colors of the palette, or %NULL The #GtkColorChooserWidget widget lets the user select a color. By default, the chooser presents a predefined palette of colors, plus a small number of settable custom colors. It is also possible to select a different color with the single-color editor. To enter the single-color editing mode, use the context menu of any color of the palette, or use the '+' button to add a new custom color. The chooser automatically remembers the last selection, as well as custom colors. To change the initially selected color, use gtk_color_chooser_set_rgba(). To get the selected color use gtk_color_chooser_get_rgba(). The #GtkColorChooserWidget is used in the #GtkColorChooserDialog to provide a dialog for selecting colors. # CSS names GtkColorChooserWidget has a single CSS node with name colorchooser. Creates a new #GtkColorChooserWidget. a new #GtkColorChooserWidget The ::show-editor property is %TRUE when the color chooser is showing the single-color editor. It can be set to switch the color chooser into single-color editing mode. The parent class. Creates a new GtkColorSelection. a new #GtkColorSelection Parses a color palette string; the string is a colon-separated list of color names readable by gdk_color_parse(). %TRUE if a palette was successfully parsed a string encoding a color palette return location for allocated array of #GdkColor return location for length of array Encodes a palette as a string, useful for persistent storage. allocated string encoding the palette an array of colors length of the array Installs a global function to be called whenever the user tries to modify the palette in a color selection. This function should save the new palette contents, and update the #GtkSettings:gtk-color-palette GtkSettings property so all GtkColorSelection widgets will be modified. the previous change palette hook (that was replaced) a function to call when the custom palette needs saving Returns the current alpha value. an integer between 0 and 65535 a #GtkColorSelection Sets @color to be the current color in the GtkColorSelection widget. Use gtk_color_selection_get_current_rgba() instead. a #GtkColorSelection a #GdkColor to fill in with the current color Sets @rgba to be the current color in the GtkColorSelection widget. a #GtkColorSelection a #GdkRGBA to fill in with the current color Determines whether the colorsel has an opacity control. %TRUE if the @colorsel has an opacity control, %FALSE if it does't a #GtkColorSelection Determines whether the color selector has a color palette. %TRUE if the selector has a palette, %FALSE if it hasn't a #GtkColorSelection Returns the previous alpha value. an integer between 0 and 65535 a #GtkColorSelection Fills @color in with the original color value. Use gtk_color_selection_get_previous_rgba() instead. a #GtkColorSelection a #GdkColor to fill in with the original color value Fills @rgba in with the original color value. a #GtkColorSelection a #GdkRGBA to fill in with the original color value Gets the current state of the @colorsel. %TRUE if the user is currently dragging a color around, and %FALSE if the selection has stopped a #GtkColorSelection Sets the current opacity to be @alpha. The first time this is called, it will also set the original opacity to be @alpha too. a #GtkColorSelection an integer between 0 and 65535 Sets the current color to be @color. The first time this is called, it will also set the original color to be @color too. Use gtk_color_selection_set_current_rgba() instead. a #GtkColorSelection a #GdkColor to set the current color with Sets the current color to be @rgba. The first time this is called, it will also set the original color to be @rgba too. a #GtkColorSelection A #GdkRGBA to set the current color with Sets the @colorsel to use or not use opacity. a #GtkColorSelection %TRUE if @colorsel can set the opacity, %FALSE otherwise Shows and hides the palette based upon the value of @has_palette. a #GtkColorSelection %TRUE if palette is to be visible, %FALSE otherwise Sets the “previous” alpha to be @alpha. This function should be called with some hesitations, as it might seem confusing to have that alpha change. a #GtkColorSelection an integer between 0 and 65535 Sets the “previous” color to be @color. This function should be called with some hesitations, as it might seem confusing to have that color change. Calling gtk_color_selection_set_current_color() will also set this color the first time it is called. Use gtk_color_selection_set_previous_rgba() instead. a #GtkColorSelection a #GdkColor to set the previous color with Sets the “previous” color to be @rgba. This function should be called with some hesitations, as it might seem confusing to have that color change. Calling gtk_color_selection_set_current_rgba() will also set this color the first time it is called. a #GtkColorSelection a #GdkRGBA to set the previous color with The current GdkColor color. Use #GtkColorSelection:current-rgba instead. The current RGBA color. This signal is emitted when the color changes in the #GtkColorSelection according to its update policy. Array of colors Number of colors in the array Array of colors Number of colors in the array The parent class. Creates a new #GtkColorSelectionDialog. a #GtkColorSelectionDialog. a string containing the title text for the dialog. Retrieves the #GtkColorSelection widget embedded in the dialog. the embedded #GtkColorSelection a #GtkColorSelectionDialog A GtkComboBox is a widget that allows the user to choose from a list of valid choices. The GtkComboBox displays the selected choice. When activated, the GtkComboBox displays a popup which allows the user to make a new choice. The style in which the selected value is displayed, and the style of the popup is determined by the current theme. It may be similar to a Windows-style combo box. The GtkComboBox uses the model-view pattern; the list of valid choices is specified in the form of a tree model, and the display of the choices can be adapted to the data in the model by using cell renderers, as you would in a tree view. This is possible since GtkComboBox implements the #GtkCellLayout interface. The tree model holding the valid choices is not restricted to a flat list, it can be a real tree, and the popup will reflect the tree structure. To allow the user to enter values not in the model, the “has-entry” property allows the GtkComboBox to contain a #GtkEntry. This entry can be accessed by calling gtk_bin_get_child() on the combo box. For a simple list of textual choices, the model-view API of GtkComboBox can be a bit overwhelming. In this case, #GtkComboBoxText offers a simple alternative. Both GtkComboBox and #GtkComboBoxText can contain an entry. # CSS nodes |[<!-- language="plain" --> combobox ├── box.linked │ ╰── button.combo │ ╰── box │ ├── cellview │ ╰── arrow ╰── window.popup ]| A normal combobox contains a box with the .linked class, a button with the .combo class and inside those buttons, there are a cellview and an arrow. |[<!-- language="plain" --> combobox ├── box.linked │ ├── entry.combo │ ╰── button.combo │ ╰── box │ ╰── arrow ╰── window.popup ]| A GtkComboBox with an entry has a single CSS node with name combobox. It contains a box with the .linked class. That box contains an entry and a button, both with the .combo class added. The button also contains another node with name arrow. Creates a new empty #GtkComboBox. A new #GtkComboBox. Creates a new empty #GtkComboBox using @area to layout cells. A new #GtkComboBox. the #GtkCellArea to use to layout cell renderers Creates a new empty #GtkComboBox with an entry. The new combo box will use @area to layout cells. A new #GtkComboBox. the #GtkCellArea to use to layout cell renderers Creates a new empty #GtkComboBox with an entry. A new #GtkComboBox. Creates a new #GtkComboBox with the model initialized to @model. A new #GtkComboBox. A #GtkTreeModel. Creates a new empty #GtkComboBox with an entry and with the model initialized to @model. A new #GtkComboBox A #GtkTreeModel Returns the index of the currently active item, or -1 if there’s no active item. If the model is a non-flat treemodel, and the active item is not an immediate child of the root of the tree, this function returns `gtk_tree_path_get_indices (path)[0]`, where `path` is the #GtkTreePath of the active item. An integer which is the index of the currently active item, or -1 if there’s no active item. A #GtkComboBox Returns the ID of the active row of @combo_box. This value is taken from the active row and the column specified by the #GtkComboBox:id-column property of @combo_box (see gtk_combo_box_set_id_column()). The returned value is an interned string which means that you can compare the pointer by value to other interned strings and that you must not free it. If the #GtkComboBox:id-column property of @combo_box is not set, or if no row is active, or if the active row has a %NULL ID value, then %NULL is returned. the ID of the active row, or %NULL a #GtkComboBox Sets @iter to point to the currently active item, if any item is active. Otherwise, @iter is left unchanged. %TRUE if @iter was set, %FALSE otherwise A #GtkComboBox A #GtkTreeIter Gets the current value of the :add-tearoffs property. the current value of the :add-tearoffs property. a #GtkComboBox Returns whether the combo box sets the dropdown button sensitive or not when there are no items in the model. %GTK_SENSITIVITY_ON if the dropdown button is sensitive when the model is empty, %GTK_SENSITIVITY_OFF if the button is always insensitive or %GTK_SENSITIVITY_AUTO if it is only sensitive as long as the model has one item to be selected. a #GtkComboBox Returns the column with column span information for @combo_box. the column span column. A #GtkComboBox Returns the column which @combo_box is using to get the strings from to display in the internal entry. A column in the data source model of @combo_box. A #GtkComboBox. Returns whether the combo box grabs focus when it is clicked with the mouse. See gtk_combo_box_set_focus_on_click(). Use gtk_widget_get_focus_on_click() instead %TRUE if the combo box grabs focus when it is clicked with the mouse. a #GtkComboBox Returns whether the combo box has an entry. whether there is an entry in @combo_box. a #GtkComboBox Returns the column which @combo_box is using to get string IDs for values from. A column in the data source model of @combo_box. A #GtkComboBox Returns the #GtkTreeModel which is acting as data source for @combo_box. A #GtkTreeModel which was passed during construction. A #GtkComboBox Gets the accessible object corresponding to the combo box’s popup. This function is mostly intended for use by accessibility technologies; applications should have little use for it. the accessible object corresponding to the combo box’s popup. a #GtkComboBox Gets whether the popup uses a fixed width matching the allocated width of the combo box. %TRUE if the popup uses a fixed width a #GtkComboBox Returns the current row separator function. the current row separator function. a #GtkComboBox Returns the column with row span information for @combo_box. the row span column. A #GtkComboBox Gets the current title of the menu in tearoff mode. See gtk_combo_box_set_add_tearoffs(). the menu’s title in tearoff mode. This is an internal copy of the string which must not be freed. a #GtkComboBox Returns the wrap width which is used to determine the number of columns for the popup menu. If the wrap width is larger than 1, the combo box is in table mode. the wrap width. A #GtkComboBox Hides the menu or dropdown list of @combo_box. This function is mostly intended for use by accessibility technologies; applications should have little use for it. a #GtkComboBox Pops up the menu or dropdown list of @combo_box. This function is mostly intended for use by accessibility technologies; applications should have little use for it. Before calling this, @combo_box must be mapped, or nothing will happen. a #GtkComboBox Pops up the menu or dropdown list of @combo_box, the popup window will be grabbed so only @device and its associated pointer/keyboard are the only #GdkDevices able to send events to it. a #GtkComboBox a #GdkDevice Sets the active item of @combo_box to be the item at @index. A #GtkComboBox An index in the model passed during construction, or -1 to have no active item Changes the active row of @combo_box to the one that has an ID equal to @active_id, or unsets the active row if @active_id is %NULL. Rows having a %NULL ID string cannot be made active by this function. If the #GtkComboBox:id-column property of @combo_box is unset or if no row has the given ID then the function does nothing and returns %FALSE. %TRUE if a row with a matching ID was found. If a %NULL @active_id was given to unset the active row, the function always returns %TRUE. a #GtkComboBox the ID of the row to select, or %NULL Sets the current active item to be the one referenced by @iter, or unsets the active item if @iter is %NULL. A #GtkComboBox The #GtkTreeIter, or %NULL Sets whether the popup menu should have a tearoff menu item. a #GtkComboBox %TRUE to add tearoff menu items Sets whether the dropdown button of the combo box should be always sensitive (%GTK_SENSITIVITY_ON), never sensitive (%GTK_SENSITIVITY_OFF) or only if there is at least one item to display (%GTK_SENSITIVITY_AUTO). a #GtkComboBox specify the sensitivity of the dropdown button Sets the column with column span information for @combo_box to be @column_span. The column span column contains integers which indicate how many columns an item should span. A #GtkComboBox A column in the model passed during construction Sets the model column which @combo_box should use to get strings from to be @text_column. The column @text_column in the model of @combo_box must be of type %G_TYPE_STRING. This is only relevant if @combo_box has been created with #GtkComboBox:has-entry as %TRUE. A #GtkComboBox A column in @model to get the strings from for the internal entry Sets whether the combo box will grab focus when it is clicked with the mouse. Making mouse clicks not grab focus is useful in places like toolbars where you don’t want the keyboard focus removed from the main area of the application. Use gtk_widget_set_focus_on_click() instead a #GtkComboBox whether the combo box grabs focus when clicked with the mouse Sets the model column which @combo_box should use to get string IDs for values from. The column @id_column in the model of @combo_box must be of type %G_TYPE_STRING. A #GtkComboBox A column in @model to get string IDs for values from Sets the model used by @combo_box to be @model. Will unset a previously set model (if applicable). If model is %NULL, then it will unset the model. Note that this function does not clear the cell renderers, you have to call gtk_cell_layout_clear() yourself if you need to set up different cell renderers for the new model. A #GtkComboBox A #GtkTreeModel Specifies whether the popup’s width should be a fixed width matching the allocated width of the combo box. a #GtkComboBox whether to use a fixed popup width Sets the row separator function, which is used to determine whether a row should be drawn as a separator. If the row separator function is %NULL, no separators are drawn. This is the default value. a #GtkComboBox a #GtkTreeViewRowSeparatorFunc user data to pass to @func, or %NULL destroy notifier for @data, or %NULL Sets the column with row span information for @combo_box to be @row_span. The row span column contains integers which indicate how many rows an item should span. A #GtkComboBox. A column in the model passed during construction. Sets the menu’s title in tearoff mode. a #GtkComboBox a title for the menu in tearoff mode Sets the wrap width of @combo_box to be @width. The wrap width is basically the preferred number of columns when you want the popup to be layed out in a table. A #GtkComboBox Preferred number of columns The item which is currently active. If the model is a non-flat treemodel, and the active item is not an immediate child of the root of the tree, this property has the value `gtk_tree_path_get_indices (path)[0]`, where `path` is the #GtkTreePath of the active item. The value of the ID column of the active row. The add-tearoffs property controls whether generated menus have tearoff menu items. Note that this only affects menu style combo boxes. Whether the dropdown button is sensitive when the model is empty. The #GtkCellArea used to layout cell renderers for this combo box. If no area is specified when creating the combo box with gtk_combo_box_new_with_area() a horizontally oriented #GtkCellAreaBox will be used. If this is set to a non-negative value, it must be the index of a column of type %G_TYPE_INT in the model. The value in that column for each item will determine how many columns that item will span in the popup. Therefore, values in this column must be greater than zero, and the sum of an item’s column position + span should not exceed #GtkComboBox:wrap-width. The column in the combo box's model to associate with strings from the entry if the combo was created with #GtkComboBox:has-entry = %TRUE. Whether the combo box has an entry. The has-frame property controls whether a frame is drawn around the entry. The column in the combo box's model that provides string IDs for the values in the model, if != -1. The model from which the combo box takes the values shown in the list. Whether the popup's width should be a fixed width matching the allocated width of the combo box. Whether the combo boxes dropdown is popped up. Note that this property is mainly useful, because it allows you to connect to notify::popup-shown. If this is set to a non-negative value, it must be the index of a column of type %G_TYPE_INT in the model. The value in that column for each item will determine how many rows that item will span in the popup. Therefore, values in this column must be greater than zero. A title that may be displayed by the window manager when the popup is torn-off. If wrap-width is set to a positive value, items in the popup will be laid out along multiple columns, starting a new row on reaching the wrap width. The changed signal is emitted when the active item is changed. The can be due to the user selecting a different item from the list, or due to a call to gtk_combo_box_set_active_iter(). It will also be emitted while typing into the entry of a combo box with an entry. For combo boxes that are created with an entry (See GtkComboBox:has-entry). A signal which allows you to change how the text displayed in a combo box's entry is displayed. Connect a signal handler which returns an allocated string representing @path. That string will then be used to set the text in the combo box's entry. The default signal handler uses the text from the GtkComboBox::entry-text-column model column. Here's an example signal handler which fetches data from the model and displays it in the entry. |[<!-- language="C" --> static gchar* format_entry_text_callback (GtkComboBox *combo, const gchar *path, gpointer user_data) { GtkTreeIter iter; GtkTreeModel model; gdouble value; model = gtk_combo_box_get_model (combo); gtk_tree_model_get_iter_from_string (model, &iter, path); gtk_tree_model_get (model, &iter, THE_DOUBLE_VALUE_COLUMN, &value, -1); return g_strdup_printf ("%g", value); } ]| a newly allocated string representing @path for the current GtkComboBox model. the GtkTreePath string from the combo box's current model to format text for The ::move-active signal is a [keybinding signal][GtkBindingSignal] which gets emitted to move the active selection. a #GtkScrollType The ::popdown signal is a [keybinding signal][GtkBindingSignal] which gets emitted to popdown the combo box list. The default bindings for this signal are Alt+Up and Escape. The ::popup signal is a [keybinding signal][GtkBindingSignal] which gets emitted to popup the combo box list. The default binding for this signal is Alt+Down. The parent class. A GtkComboBoxText is a simple variant of #GtkComboBox that hides the model-view complexity for simple text-only use cases. To create a GtkComboBoxText, use gtk_combo_box_text_new() or gtk_combo_box_text_new_with_entry(). You can add items to a GtkComboBoxText with gtk_combo_box_text_append_text(), gtk_combo_box_text_insert_text() or gtk_combo_box_text_prepend_text() and remove options with gtk_combo_box_text_remove(). If the GtkComboBoxText contains an entry (via the “has-entry” property), its contents can be retrieved using gtk_combo_box_text_get_active_text(). The entry itself can be accessed by calling gtk_bin_get_child() on the combo box. You should not call gtk_combo_box_set_model() or attempt to pack more cells into this combo box via its GtkCellLayout interface. # GtkComboBoxText as GtkBuildable The GtkComboBoxText implementation of the GtkBuildable interface supports adding items directly using the <items> element and specifying <item> elements for each item. Each <item> element can specify the “id” corresponding to the appended text and also supports the regular translation attributes “translatable”, “context” and “comments”. Here is a UI definition fragment specifying GtkComboBoxText items: |[ <object class="GtkComboBoxText"> <items> <item translatable="yes" id="factory">Factory</item> <item translatable="yes" id="home">Home</item> <item translatable="yes" id="subway">Subway</item> </items> </object> ]| # CSS nodes |[<!-- language="plain" --> combobox ╰── box.linked ├── entry.combo ├── button.combo ╰── window.popup ]| GtkComboBoxText has a single CSS node with name combobox. It adds the style class .combo to the main CSS nodes of its entry and button children, and the .linked class to the node of its internal box. Creates a new #GtkComboBoxText, which is a #GtkComboBox just displaying strings. A new #GtkComboBoxText Creates a new #GtkComboBoxText, which is a #GtkComboBox just displaying strings. The combo box created by this function has an entry. a new #GtkComboBoxText Appends @text to the list of strings stored in @combo_box. If @id is non-%NULL then it is used as the ID of the row. This is the same as calling gtk_combo_box_text_insert() with a position of -1. A #GtkComboBoxText a string ID for this value, or %NULL A string Appends @text to the list of strings stored in @combo_box. This is the same as calling gtk_combo_box_text_insert_text() with a position of -1. A #GtkComboBoxText A string Returns the currently active string in @combo_box, or %NULL if none is selected. If @combo_box contains an entry, this function will return its contents (which will not necessarily be an item from the list). a newly allocated string containing the currently active text. Must be freed with g_free(). A #GtkComboBoxText Inserts @text at @position in the list of strings stored in @combo_box. If @id is non-%NULL then it is used as the ID of the row. See #GtkComboBox:id-column. If @position is negative then @text is appended. A #GtkComboBoxText An index to insert @text a string ID for this value, or %NULL A string to display Inserts @text at @position in the list of strings stored in @combo_box. If @position is negative then @text is appended. This is the same as calling gtk_combo_box_text_insert() with a %NULL ID string. A #GtkComboBoxText An index to insert @text A string Prepends @text to the list of strings stored in @combo_box. If @id is non-%NULL then it is used as the ID of the row. This is the same as calling gtk_combo_box_text_insert() with a position of 0. A #GtkComboBox a string ID for this value, or %NULL a string Prepends @text to the list of strings stored in @combo_box. This is the same as calling gtk_combo_box_text_insert_text() with a position of 0. A #GtkComboBox A string Removes the string at @position from @combo_box. A #GtkComboBox Index of the item to remove Removes all the text entries from the combo box. A #GtkComboBoxText A GTK+ user interface is constructed by nesting widgets inside widgets. Container widgets are the inner nodes in the resulting tree of widgets: they contain other widgets. So, for example, you might have a #GtkWindow containing a #GtkFrame containing a #GtkLabel. If you wanted an image instead of a textual label inside the frame, you might replace the #GtkLabel widget with a #GtkImage widget. There are two major kinds of container widgets in GTK+. Both are subclasses of the abstract GtkContainer base class. The first type of container widget has a single child widget and derives from #GtkBin. These containers are decorators, which add some kind of functionality to the child. For example, a #GtkButton makes its child into a clickable button; a #GtkFrame draws a frame around its child and a #GtkWindow places its child widget inside a top-level window. The second type of container can have more than one child; its purpose is to manage layout. This means that these containers assign sizes and positions to their children. For example, a #GtkHBox arranges its children in a horizontal row, and a #GtkGrid arranges the widgets it contains in a two-dimensional grid. For implementations of #GtkContainer the virtual method #GtkContainerClass.forall() is always required, since it's used for drawing and other internal operations on the children. If the #GtkContainer implementation expect to have non internal children it's needed to implement both #GtkContainerClass.add() and #GtkContainerClass.remove(). If the GtkContainer implementation has internal children, they should be added with gtk_widget_set_parent() on init() and removed with gtk_widget_unparent() in the #GtkWidgetClass.destroy() implementation. See more about implementing custom widgets at https://wiki.gnome.org/HowDoI/CustomWidgets # Height for width geometry management GTK+ uses a height-for-width (and width-for-height) geometry management system. Height-for-width means that a widget can change how much vertical space it needs, depending on the amount of horizontal space that it is given (and similar for width-for-height). There are some things to keep in mind when implementing container widgets that make use of GTK+’s height for width geometry management system. First, it’s important to note that a container must prioritize one of its dimensions, that is to say that a widget or container can only have a #GtkSizeRequestMode that is %GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH or %GTK_SIZE_REQUEST_WIDTH_FOR_HEIGHT. However, every widget and container must be able to respond to the APIs for both dimensions, i.e. even if a widget has a request mode that is height-for-width, it is possible that its parent will request its sizes using the width-for-height APIs. To ensure that everything works properly, here are some guidelines to follow when implementing height-for-width (or width-for-height) containers. Each request mode involves 2 virtual methods. Height-for-width apis run through gtk_widget_get_preferred_width() and then through gtk_widget_get_preferred_height_for_width(). When handling requests in the opposite #GtkSizeRequestMode it is important that every widget request at least enough space to display all of its content at all times. When gtk_widget_get_preferred_height() is called on a container that is height-for-width, the container must return the height for its minimum width. This is easily achieved by simply calling the reverse apis implemented for itself as follows: |[<!-- language="C" --> static void foo_container_get_preferred_height (GtkWidget *widget, gint *min_height, gint *nat_height) { if (i_am_in_height_for_width_mode) { gint min_width; GTK_WIDGET_GET_CLASS (widget)->get_preferred_width (widget, &min_width, NULL); GTK_WIDGET_GET_CLASS (widget)->get_preferred_height_for_width (widget, min_width, min_height, nat_height); } else { ... many containers support both request modes, execute the real width-for-height request here by returning the collective heights of all widgets that are stacked vertically (or whatever is appropriate for this container) ... } } ]| Similarly, when gtk_widget_get_preferred_width_for_height() is called for a container or widget that is height-for-width, it then only needs to return the base minimum width like so: |[<!-- language="C" --> static void foo_container_get_preferred_width_for_height (GtkWidget *widget, gint for_height, gint *min_width, gint *nat_width) { if (i_am_in_height_for_width_mode) { GTK_WIDGET_GET_CLASS (widget)->get_preferred_width (widget, min_width, nat_width); } else { ... execute the real width-for-height request here based on the required width of the children collectively if the container were to be allocated the said height ... } } ]| Height for width requests are generally implemented in terms of a virtual allocation of widgets in the input orientation. Assuming an height-for-width request mode, a container would implement the get_preferred_height_for_width() virtual function by first calling gtk_widget_get_preferred_width() for each of its children. For each potential group of children that are lined up horizontally, the values returned by gtk_widget_get_preferred_width() should be collected in an array of #GtkRequestedSize structures. Any child spacing should be removed from the input @for_width and then the collective size should be allocated using the gtk_distribute_natural_allocation() convenience function. The container will then move on to request the preferred height for each child by using gtk_widget_get_preferred_height_for_width() and using the sizes stored in the #GtkRequestedSize array. To allocate a height-for-width container, it’s again important to consider that a container must prioritize one dimension over the other. So if a container is a height-for-width container it must first allocate all widgets horizontally using a #GtkRequestedSize array and gtk_distribute_natural_allocation() and then add any extra space (if and where appropriate) for the widget to expand. After adding all the expand space, the container assumes it was allocated sufficient height to fit all of its content. At this time, the container must use the total horizontal sizes of each widget to request the height-for-width of each of its children and store the requests in a #GtkRequestedSize array for any widgets that stack vertically (for tabular containers this can be generalized into the heights and widths of rows and columns). The vertical space must then again be distributed using gtk_distribute_natural_allocation() while this time considering the allocated height of the widget minus any vertical spacing that the container adds. Then vertical expand space should be added where appropriate and available and the container should go on to actually allocating the child widgets. See [GtkWidget’s geometry management section][geometry-management] to learn more about implementing height-for-width geometry management for widgets. # Child properties GtkContainer introduces child properties. These are object properties that are not specific to either the container or the contained widget, but rather to their relation. Typical examples of child properties are the position or pack-type of a widget which is contained in a #GtkBox. Use gtk_container_class_install_child_property() to install child properties for a container class and gtk_container_class_find_child_property() or gtk_container_class_list_child_properties() to get information about existing child properties. To set the value of a child property, use gtk_container_child_set_property(), gtk_container_child_set() or gtk_container_child_set_valist(). To obtain the value of a child property, use gtk_container_child_get_property(), gtk_container_child_get() or gtk_container_child_get_valist(). To emit notification about child property changes, use gtk_widget_child_notify(). # GtkContainer as GtkBuildable The GtkContainer implementation of the GtkBuildable interface supports a <packing> element for children, which can contain multiple <property> elements that specify child properties for the child. Since 2.16, child properties can also be marked as translatable using the same “translatable”, “comments” and “context” attributes that are used for regular properties. Since 3.16, containers can have a <focus-chain> element containing multiple <widget> elements, one for each child that should be added to the focus chain. The ”name” attribute gives the id of the widget. An example of these properties in UI definitions: |[ <object class="GtkBox"> <child> <object class="GtkEntry" id="entry1"/> <packing> <property name="pack-type">start</property> </packing> </child> <child> <object class="GtkEntry" id="entry2"/> </child> <focus-chain> <widget name="entry1"/> <widget name="entry2"/> </focus-chain> </object> ]| Adds @widget to @container. Typically used for simple containers such as #GtkWindow, #GtkFrame, or #GtkButton; for more complicated layout containers such as #GtkBox or #GtkGrid, this function will pick default packing parameters that may not be correct. So consider functions such as gtk_box_pack_start() and gtk_grid_attach() as an alternative to gtk_container_add() in those cases. A widget may be added to only one container at a time; you can’t place the same widget inside two different containers. Note that some containers, such as #GtkScrolledWindow or #GtkListBox, may add intermediate children between the added widget and the container. a #GtkContainer a widget to be placed inside @container Returns the type of the children supported by the container. Note that this may return %G_TYPE_NONE to indicate that no more children can be added, e.g. for a #GtkPaned which already has two children. a #GType. a #GtkContainer Invokes @callback on each direct child of @container, including children that are considered “internal” (implementation details of the container). “Internal” children generally weren’t added by the user of the container, but were added by the container implementation itself. Most applications should use gtk_container_foreach(), rather than gtk_container_forall(). a #GtkContainer a callback callback user data Returns a newly created widget path representing all the widget hierarchy from the toplevel down to and including @child. A newly created #GtkWidgetPath a #GtkContainer a child of @container Removes @widget from @container. @widget must be inside @container. Note that @container will own a reference to @widget, and that this may be the last reference held; so removing a widget from its container can destroy that widget. If you want to use @widget again, you need to add a reference to it before removing it from a container, using g_object_ref(). If you don’t want to use @widget again it’s usually more efficient to simply destroy it directly using gtk_widget_destroy() since this will remove it from the container and help break any circular reference count cycles. a #GtkContainer a current child of @container Sets, or unsets if @child is %NULL, the focused child of @container. This function emits the GtkContainer::set_focus_child signal of @container. Implementations of #GtkContainer can override the default behaviour by overriding the class closure of this signal. This is function is mostly meant to be used by widgets. Applications can use gtk_widget_grab_focus() to manually set the focus to a specific widget. a #GtkContainer a #GtkWidget, or %NULL Adds @widget to @container. Typically used for simple containers such as #GtkWindow, #GtkFrame, or #GtkButton; for more complicated layout containers such as #GtkBox or #GtkGrid, this function will pick default packing parameters that may not be correct. So consider functions such as gtk_box_pack_start() and gtk_grid_attach() as an alternative to gtk_container_add() in those cases. A widget may be added to only one container at a time; you can’t place the same widget inside two different containers. Note that some containers, such as #GtkScrolledWindow or #GtkListBox, may add intermediate children between the added widget and the container. a #GtkContainer a widget to be placed inside @container Adds @widget to @container, setting child properties at the same time. See gtk_container_add() and gtk_container_child_set() for more details. a #GtkContainer a widget to be placed inside @container the name of the first child property to set a %NULL-terminated list of property names and values, starting with @first_prop_name Gets the values of one or more child properties for @child and @container. a #GtkContainer a widget which is a child of @container the name of the first property to get return location for the first property, followed optionally by more name/return location pairs, followed by %NULL Gets the value of a child property for @child and @container. a #GtkContainer a widget which is a child of @container the name of the property to get a location to return the value Gets the values of one or more child properties for @child and @container. a #GtkContainer a widget which is a child of @container the name of the first property to get return location for the first property, followed optionally by more name/return location pairs, followed by %NULL Emits a #GtkWidget::child-notify signal for the [child property][child-properties] @child_property on the child. This is an analogue of g_object_notify() for child properties. Also see gtk_widget_child_notify(). the #GtkContainer the child widget the name of a child property installed on the class of @container Emits a #GtkWidget::child-notify signal for the [child property][child-properties] specified by @pspec on the child. This is an analogue of g_object_notify_by_pspec() for child properties. the #GtkContainer the child widget the #GParamSpec of a child property instealled on the class of @container Sets one or more child properties for @child and @container. a #GtkContainer a widget which is a child of @container the name of the first property to set a %NULL-terminated list of property names and values, starting with @first_prop_name Sets a child property for @child and @container. a #GtkContainer a widget which is a child of @container the name of the property to set the value to set the property to Sets one or more child properties for @child and @container. a #GtkContainer a widget which is a child of @container the name of the first property to set a %NULL-terminated list of property names and values, starting with @first_prop_name Returns the type of the children supported by the container. Note that this may return %G_TYPE_NONE to indicate that no more children can be added, e.g. for a #GtkPaned which already has two children. a #GType. a #GtkContainer Invokes @callback on each direct child of @container, including children that are considered “internal” (implementation details of the container). “Internal” children generally weren’t added by the user of the container, but were added by the container implementation itself. Most applications should use gtk_container_foreach(), rather than gtk_container_forall(). a #GtkContainer a callback callback user data Invokes @callback on each non-internal child of @container. See gtk_container_forall() for details on what constitutes an “internal” child. For all practical purposes, this function should iterate over precisely those child widgets that were added to the container by the application with explicit add() calls. It is permissible to remove the child from the @callback handler. Most applications should use gtk_container_foreach(), rather than gtk_container_forall(). a #GtkContainer a callback callback user data Retrieves the border width of the container. See gtk_container_set_border_width(). the current border width a #GtkContainer Returns the container’s non-internal children. See gtk_container_forall() for details on what constitutes an "internal" child. a newly-allocated list of the container’s non-internal children. a #GtkContainer Retrieves the focus chain of the container, if one has been set explicitly. If no focus chain has been explicitly set, GTK+ computes the focus chain based on the positions of the children. In that case, GTK+ stores %NULL in @focusable_widgets and returns %FALSE. For overriding focus behavior, use the GtkWidgetClass::focus signal. %TRUE if the focus chain of the container has been set explicitly. a #GtkContainer location to store the focus chain of the container, or %NULL. You should free this list using g_list_free() when you are done with it, however no additional reference count is added to the individual widgets in the focus chain. Returns the current focus child widget inside @container. This is not the currently focused widget. That can be obtained by calling gtk_window_get_focus(). The child widget which will receive the focus inside @container when the @container is focused, or %NULL if none is set. a #GtkContainer Retrieves the horizontal focus adjustment for the container. See gtk_container_set_focus_hadjustment (). the horizontal focus adjustment, or %NULL if none has been set. a #GtkContainer Retrieves the vertical focus adjustment for the container. See gtk_container_set_focus_vadjustment(). the vertical focus adjustment, or %NULL if none has been set. a #GtkContainer Returns a newly created widget path representing all the widget hierarchy from the toplevel down to and including @child. A newly created #GtkWidgetPath a #GtkContainer a child of @container Returns the resize mode for the container. See gtk_container_set_resize_mode (). Resize modes are deprecated. They aren’t necessary anymore since frame clocks and might introduce obscure bugs if used. the current resize mode a #GtkContainer When a container receives a call to the draw function, it must send synthetic #GtkWidget::draw calls to all children that don’t have their own #GdkWindows. This function provides a convenient way of doing this. A container, when it receives a call to its #GtkWidget::draw function, calls gtk_container_propagate_draw() once for each child, passing in the @cr the container received. gtk_container_propagate_draw() takes care of translating the origin of @cr, and deciding whether the draw needs to be sent to the child. It is a convenient and optimized way of getting the same effect as calling gtk_widget_draw() on the child directly. In most cases, a container can simply either inherit the #GtkWidget::draw implementation from #GtkContainer, or do some drawing and then chain to the ::draw implementation from #GtkContainer. a #GtkContainer a child of @container Cairo context as passed to the container. If you want to use @cr in container’s draw function, consider using cairo_save() and cairo_restore() before calling this function. Removes @widget from @container. @widget must be inside @container. Note that @container will own a reference to @widget, and that this may be the last reference held; so removing a widget from its container can destroy that widget. If you want to use @widget again, you need to add a reference to it before removing it from a container, using g_object_ref(). If you don’t want to use @widget again it’s usually more efficient to simply destroy it directly using gtk_widget_destroy() since this will remove it from the container and help break any circular reference count cycles. a #GtkContainer a current child of @container a #GtkContainer Sets the border width of the container. The border width of a container is the amount of space to leave around the outside of the container. The only exception to this is #GtkWindow; because toplevel windows can’t leave space outside, they leave the space inside. The border is added on all sides of the container. To add space to only one side, use a specific #GtkWidget:margin property on the child widget, for example #GtkWidget:margin-top. a #GtkContainer amount of blank space to leave outside the container. Valid values are in the range 0-65535 pixels. Sets a focus chain, overriding the one computed automatically by GTK+. In principle each widget in the chain should be a descendant of the container, but this is not enforced by this method, since it’s allowed to set the focus chain before you pack the widgets, or have a widget in the chain that isn’t always packed. The necessary checks are done when the focus chain is actually traversed. For overriding focus behavior, use the GtkWidgetClass::focus signal. a #GtkContainer the new focus chain Sets, or unsets if @child is %NULL, the focused child of @container. This function emits the GtkContainer::set_focus_child signal of @container. Implementations of #GtkContainer can override the default behaviour by overriding the class closure of this signal. This is function is mostly meant to be used by widgets. Applications can use gtk_widget_grab_focus() to manually set the focus to a specific widget. a #GtkContainer a #GtkWidget, or %NULL Hooks up an adjustment to focus handling in a container, so when a child of the container is focused, the adjustment is scrolled to show that widget. This function sets the horizontal alignment. See gtk_scrolled_window_get_hadjustment() for a typical way of obtaining the adjustment and gtk_container_set_focus_vadjustment() for setting the vertical adjustment. The adjustments have to be in pixel units and in the same coordinate system as the allocation for immediate children of the container. a #GtkContainer an adjustment which should be adjusted when the focus is moved among the descendents of @container Hooks up an adjustment to focus handling in a container, so when a child of the container is focused, the adjustment is scrolled to show that widget. This function sets the vertical alignment. See gtk_scrolled_window_get_vadjustment() for a typical way of obtaining the adjustment and gtk_container_set_focus_hadjustment() for setting the horizontal adjustment. The adjustments have to be in pixel units and in the same coordinate system as the allocation for immediate children of the container. a #GtkContainer an adjustment which should be adjusted when the focus is moved among the descendents of @container Sets the @reallocate_redraws flag of the container to the given value. Containers requesting reallocation redraws get automatically redrawn if any of their children changed allocation. Call gtk_widget_queue_draw() in your size_allocate handler. a #GtkContainer the new value for the container’s @reallocate_redraws flag Sets the resize mode for the container. The resize mode of a container determines whether a resize request will be passed to the container’s parent, queued for later execution or executed immediately. Resize modes are deprecated. They aren’t necessary anymore since frame clocks and might introduce obscure bugs if used. a #GtkContainer the new resize mode Removes a focus chain explicitly set with gtk_container_set_focus_chain(). For overriding focus behavior, use the GtkWidgetClass::focus signal. a #GtkContainer Get a list of children. the container Base class for containers. The parent class. a #GtkContainer a widget to be placed inside @container a #GtkContainer a current child of @container a #GtkContainer a callback callback user data a #GtkContainer a #GtkWidget, or %NULL a #GType. a #GtkContainer A newly created #GtkWidgetPath a #GtkContainer a child of @container Finds a child property of a container class by name. the #GParamSpec of the child property or %NULL if @class has no child property with that name. a #GtkContainerClass the name of the child property to find Modifies a subclass of #GtkContainerClass to automatically add and remove the border-width setting on GtkContainer. This allows the subclass to ignore the border width in its size request and allocate methods. The intent is for a subclass to invoke this in its class_init function. gtk_container_class_handle_border_width() is necessary because it would break API too badly to make this behavior the default. So subclasses must “opt in” to the parent class handling border_width for them. the class struct of a #GtkContainer subclass Installs child properties on a container class. a #GtkContainerClass the length of the #GParamSpec array the #GParamSpec array defining the new child properties Installs a child property on a container class. a #GtkContainerClass the id for the property the #GParamSpec for the property Returns all child properties of a container class. a newly allocated %NULL-terminated array of #GParamSpec*. The array must be freed with g_free(). a #GtkContainerClass location to return the number of child properties found Specifies which corner a child widget should be placed in when packed into a #GtkScrolledWindow. This is effectively the opposite of where the scroll bars are placed. Place the scrollbars on the right and bottom of the widget (default behaviour). Place the scrollbars on the top and right of the widget. Place the scrollbars on the left and bottom of the widget. Place the scrollbars on the top and left of the widget. GtkCssProvider is an object implementing the #GtkStyleProvider interface. It is able to parse [CSS-like][css-overview] input in order to style widgets. An application can make GTK+ parse a specific CSS style sheet by calling gtk_css_provider_load_from_file() or gtk_css_provider_load_from_resource() and adding the provider with gtk_style_context_add_provider() or gtk_style_context_add_provider_for_screen(). In addition, certain files will be read when GTK+ is initialized. First, the file `$XDG_CONFIG_HOME/gtk-3.0/gtk.css` is loaded if it exists. Then, GTK+ loads the first existing file among `XDG_DATA_HOME/themes/THEME/gtk-VERSION/gtk.css`, `$HOME/.themes/THEME/gtk-VERSION/gtk.css`, `$XDG_DATA_DIRS/themes/THEME/gtk-VERSION/gtk.css` and `DATADIR/share/themes/THEME/gtk-VERSION/gtk.css`, where `THEME` is the name of the current theme (see the #GtkSettings:gtk-theme-name setting), `DATADIR` is the prefix configured when GTK+ was compiled (unless overridden by the `GTK_DATA_PREFIX` environment variable), and `VERSION` is the GTK+ version number. If no file is found for the current version, GTK+ tries older versions all the way back to 3.0. In the same way, GTK+ tries to load a gtk-keys.css file for the current key theme, as defined by #GtkSettings:gtk-key-theme-name. Returns a newly created #GtkCssProvider. A new #GtkCssProvider Returns the provider containing the style settings used as a fallback for all widgets. Use gtk_css_provider_new() instead. The provider used for fallback styling. This memory is owned by GTK+, and you must not free it. Loads a theme from the usual theme paths a #GtkCssProvider with the theme loaded. This memory is owned by GTK+, and you must not free it. A theme name variant to load, for example, "dark", or %NULL for the default Loads @data into @css_provider, and by doing so clears any previously loaded information. %TRUE. The return value is deprecated and %FALSE will only be returned for backwards compatibility reasons if an @error is not %NULL and a loading error occurred. To track errors while loading CSS, connect to the #GtkCssProvider::parsing-error signal. a #GtkCssProvider CSS data loaded in memory the length of @data in bytes, or -1 for NUL terminated strings. If @length is not -1, the code will assume it is not NUL terminated and will potentially do a copy. Loads the data contained in @file into @css_provider, making it clear any previously loaded information. %TRUE. The return value is deprecated and %FALSE will only be returned for backwards compatibility reasons if an @error is not %NULL and a loading error occurred. To track errors while loading CSS, connect to the #GtkCssProvider::parsing-error signal. a #GtkCssProvider #GFile pointing to a file to load Loads the data contained in @path into @css_provider, making it clear any previously loaded information. %TRUE. The return value is deprecated and %FALSE will only be returned for backwards compatibility reasons if an @error is not %NULL and a loading error occurred. To track errors while loading CSS, connect to the #GtkCssProvider::parsing-error signal. a #GtkCssProvider the path of a filename to load, in the GLib filename encoding Loads the data contained in the resource at @resource_path into the #GtkCssProvider, clearing any previously loaded information. To track errors while loading CSS, connect to the #GtkCssProvider::parsing-error signal. a #GtkCssProvider a #GResource resource path Converts the @provider into a string representation in CSS format. Using gtk_css_provider_load_from_data() with the return value from this function on a new provider created with gtk_css_provider_new() will basically create a duplicate of this @provider. a new string representing the @provider. the provider to write to a string Signals that a parsing error occurred. the @path, @line and @position describe the actual location of the error as accurately as possible. Parsing errors are never fatal, so the parsing will resume after the error. Errors may however cause parts of the given data or even all of it to not be parsed at all. So it is a useful idea to check that the parsing succeeds by connecting to this signal. Note that this signal may be emitted at any time as the css provider may opt to defer parsing parts or all of the input to a later time than when a loading function was called. section the error happened in The parsing error Error codes for %GTK_CSS_PROVIDER_ERROR. Failed. Syntax error. Import error. Name error. Deprecation error. Unknown value. Defines a part of a CSS document. Because sections are nested into one another, you can use gtk_css_section_get_parent() to get the containing region. Returns the line in the CSS document where this section end. The line number is 0-indexed, so the first line of the document will return 0. This value may change in future invocations of this function if @section is not yet parsed completely. This will for example happen in the GtkCssProvider::parsing-error signal. The end position and line may be identical to the start position and line for sections which failed to parse anything successfully. the line number the section Returns the offset in bytes from the start of the current line returned via gtk_css_section_get_end_line(). This value may change in future invocations of this function if @section is not yet parsed completely. This will for example happen in the GtkCssProvider::parsing-error signal. The end position and line may be identical to the start position and line for sections which failed to parse anything successfully. the offset in bytes from the start of the line. the section Gets the file that @section was parsed from. If no such file exists, for example because the CSS was loaded via @gtk_css_provider_load_from_data(), then %NULL is returned. the #GFile that @section was parsed from or %NULL if @section was parsed from other data the section Gets the parent section for the given @section. The parent section is the section that contains this @section. A special case are sections of type #GTK_CSS_SECTION_DOCUMENT. Their parent will either be %NULL if they are the original CSS document that was loaded by gtk_css_provider_load_from_file() or a section of type #GTK_CSS_SECTION_IMPORT if it was loaded with an import rule from a different file. the parent section or %NULL if none the section Gets the type of information that @section describes. the type of @section the section Returns the line in the CSS document where this section starts. The line number is 0-indexed, so the first line of the document will return 0. the line number the section Returns the offset in bytes from the start of the current line returned via gtk_css_section_get_start_line(). the offset in bytes from the start of the line. the section Increments the reference count on @section. @section itself. a #GtkCssSection Decrements the reference count on @section, freeing the structure if the reference count reaches 0. a #GtkCssSection The different types of sections indicate parts of a CSS document as parsed by GTK’s CSS parser. They are oriented towards the [CSS Grammar](http://www.w3.org/TR/CSS21/grammar.html), but may contain extensions. More types might be added in the future as the parser incorporates more features. The section describes a complete document. This section time is the only one where gtk_css_section_get_parent() might return %NULL. The section defines an import rule. The section defines a color. This is a GTK extension to CSS. The section defines a binding set. This is a GTK extension to CSS. The section defines a CSS ruleset. The section defines a CSS selector. The section defines the declaration of a CSS variable. The section defines the value of a CSS declaration. The section defines keyframes. See [CSS Animations](http://dev.w3.org/csswg/css3-animations/#keyframes) for details. Since 3.6 See also: #GtkEntry::delete-from-cursor. Delete characters. Delete only the portion of the word to the left/right of cursor if we’re in the middle of a word. Delete words. Delete display-lines. Display-lines refers to the visible lines, with respect to to the current line breaks. As opposed to paragraphs, which are defined by line breaks in the input. Delete only the portion of the display-line to the left/right of cursor. Delete to the end of the paragraph. Like C-k in Emacs (or its reverse). Delete entire line. Like C-k in pico. Delete only whitespace. Like M-\ in Emacs. The #GtkDestDefaults enumeration specifies the various types of action that will be taken on behalf of the user for a drag destination site. If set for a widget, GTK+, during a drag over this widget will check if the drag matches this widget’s list of possible targets and actions. GTK+ will then call gdk_drag_status() as appropriate. If set for a widget, GTK+ will draw a highlight on this widget as long as a drag is over this widget and the widget drag format and action are acceptable. If set for a widget, when a drop occurs, GTK+ will will check if the drag matches this widget’s list of possible targets and actions. If so, GTK+ will call gtk_drag_get_data() on behalf of the widget. Whether or not the drop is successful, GTK+ will call gtk_drag_finish(). If the action was a move, then if the drag was successful, then %TRUE will be passed for the @delete parameter to gtk_drag_finish(). If set, specifies that all default actions should be taken. Dialog boxes are a convenient way to prompt the user for a small amount of input, e.g. to display a message, ask a question, or anything else that does not require extensive effort on the user’s part. GTK+ treats a dialog as a window split vertically. The top section is a #GtkVBox, and is where widgets such as a #GtkLabel or a #GtkEntry should be packed. The bottom area is known as the “action area”. This is generally used for packing buttons into the dialog which may perform functions such as cancel, ok, or apply. #GtkDialog boxes are created with a call to gtk_dialog_new() or gtk_dialog_new_with_buttons(). gtk_dialog_new_with_buttons() is recommended; it allows you to set the dialog title, some convenient flags, and add simple buttons. If “dialog” is a newly created dialog, the two primary areas of the window can be accessed through gtk_dialog_get_content_area() and gtk_dialog_get_action_area(), as can be seen from the example below. A “modal” dialog (that is, one which freezes the rest of the application from user input), can be created by calling gtk_window_set_modal() on the dialog. Use the GTK_WINDOW() macro to cast the widget returned from gtk_dialog_new() into a #GtkWindow. When using gtk_dialog_new_with_buttons() you can also pass the #GTK_DIALOG_MODAL flag to make a dialog modal. If you add buttons to #GtkDialog using gtk_dialog_new_with_buttons(), gtk_dialog_add_button(), gtk_dialog_add_buttons(), or gtk_dialog_add_action_widget(), clicking the button will emit a signal called #GtkDialog::response with a response ID that you specified. GTK+ will never assign a meaning to positive response IDs; these are entirely user-defined. But for convenience, you can use the response IDs in the #GtkResponseType enumeration (these all have values less than zero). If a dialog receives a delete event, the #GtkDialog::response signal will be emitted with a response ID of #GTK_RESPONSE_DELETE_EVENT. If you want to block waiting for a dialog to return before returning control flow to your code, you can call gtk_dialog_run(). This function enters a recursive main loop and waits for the user to respond to the dialog, returning the response ID corresponding to the button the user clicked. For the simple dialog in the following example, in reality you’d probably use #GtkMessageDialog to save yourself some effort. But you’d need to create the dialog contents manually if you had more than a simple message in the dialog. An example for simple GtkDialog usage: |[<!-- language="C" --> // Function to open a dialog box with a message void quick_message (GtkWindow *parent, gchar *message) { GtkWidget *dialog, *label, *content_area; GtkDialogFlags flags; // Create the widgets flags = GTK_DIALOG_DESTROY_WITH_PARENT; dialog = gtk_dialog_new_with_buttons ("Message", parent, flags, _("_OK"), GTK_RESPONSE_NONE, NULL); content_area = gtk_dialog_get_content_area (GTK_DIALOG (dialog)); label = gtk_label_new (message); // Ensure that the dialog box is destroyed when the user responds g_signal_connect_swapped (dialog, "response", G_CALLBACK (gtk_widget_destroy), dialog); // Add the label, and show everything we’ve added gtk_container_add (GTK_CONTAINER (content_area), label); gtk_widget_show_all (dialog); } ]| # GtkDialog as GtkBuildable The GtkDialog implementation of the #GtkBuildable interface exposes the @vbox and @action_area as internal children with the names “vbox” and “action_area”. GtkDialog supports a custom <action-widgets> element, which can contain multiple <action-widget> elements. The “response” attribute specifies a numeric response, and the content of the element is the id of widget (which should be a child of the dialogs @action_area). To mark a response as default, set the “default“ attribute of the <action-widget> element to true. GtkDialog supports adding action widgets by specifying “action“ as the “type“ attribute of a <child> element. The widget will be added either to the action area or the headerbar of the dialog, depending on the “use-header-bar“ property. The response id has to be associated with the action widget using the <action-widgets> element. An example of a #GtkDialog UI definition fragment: |[ <object class="GtkDialog" id="dialog1"> <child type="action"> <object class="GtkButton" id="button_cancel"/> </child> <child type="action"> <object class="GtkButton" id="button_ok"> <property name="can-default">True</property> </object> </child> <action-widgets> <action-widget response="cancel">button_cancel</action-widget> <action-widget response="ok" default="true">button_ok</action-widget> </action-widgets> </object> ]| Creates a new dialog box. Widgets should not be packed into this #GtkWindow directly, but into the @vbox and @action_area, as described above. the new dialog as a #GtkWidget Creates a new #GtkDialog with title @title (or %NULL for the default title; see gtk_window_set_title()) and transient parent @parent (or %NULL for none; see gtk_window_set_transient_for()). The @flags argument can be used to make the dialog modal (#GTK_DIALOG_MODAL) and/or to have it destroyed along with its transient parent (#GTK_DIALOG_DESTROY_WITH_PARENT). After @flags, button text/response ID pairs should be listed, with a %NULL pointer ending the list. Button text can be arbitrary text. A response ID can be any positive number, or one of the values in the #GtkResponseType enumeration. If the user clicks one of these dialog buttons, #GtkDialog will emit the #GtkDialog::response signal with the corresponding response ID. If a #GtkDialog receives the #GtkWidget::delete-event signal, it will emit ::response with a response ID of #GTK_RESPONSE_DELETE_EVENT. However, destroying a dialog does not emit the ::response signal; so be careful relying on ::response when using the #GTK_DIALOG_DESTROY_WITH_PARENT flag. Buttons are from left to right, so the first button in the list will be the leftmost button in the dialog. Here’s a simple example: |[<!-- language="C" --> GtkWidget *main_app_window; // Window the dialog should show up on GtkWidget *dialog; GtkDialogFlags flags = GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT; dialog = gtk_dialog_new_with_buttons ("My dialog", main_app_window, flags, _("_OK"), GTK_RESPONSE_ACCEPT, _("_Cancel"), GTK_RESPONSE_REJECT, NULL); ]| a new #GtkDialog Title of the dialog, or %NULL Transient parent of the dialog, or %NULL from #GtkDialogFlags text to go in first button, or %NULL response ID for first button, then additional buttons, ending with %NULL Emits the #GtkDialog::response signal with the given response ID. Used to indicate that the user has responded to the dialog in some way; typically either you or gtk_dialog_run() will be monitoring the ::response signal and take appropriate action. a #GtkDialog response ID Adds an activatable widget to the action area of a #GtkDialog, connecting a signal handler that will emit the #GtkDialog::response signal on the dialog when the widget is activated. The widget is appended to the end of the dialog’s action area. If you want to add a non-activatable widget, simply pack it into the @action_area field of the #GtkDialog struct. a #GtkDialog an activatable widget response ID for @child Adds a button with the given text and sets things up so that clicking the button will emit the #GtkDialog::response signal with the given @response_id. The button is appended to the end of the dialog’s action area. The button widget is returned, but usually you don’t need it. the #GtkButton widget that was added a #GtkDialog text of button response ID for the button Adds more buttons, same as calling gtk_dialog_add_button() repeatedly. The variable argument list should be %NULL-terminated as with gtk_dialog_new_with_buttons(). Each button must have both text and response ID. a #GtkDialog button text response ID for first button, then more text-response_id pairs Returns the action area of @dialog. Direct access to the action area is discouraged; use gtk_dialog_add_button(), etc. the action area a #GtkDialog Returns the content area of @dialog. the content area #GtkBox. a #GtkDialog Returns the header bar of @dialog. Note that the headerbar is only used by the dialog if the #GtkDialog:use-header-bar property is %TRUE. the header bar a #GtkDialog Gets the response id of a widget in the action area of a dialog. the response id of @widget, or %GTK_RESPONSE_NONE if @widget doesn’t have a response id set. a #GtkDialog a widget in the action area of @dialog Gets the widget button that uses the given response ID in the action area of a dialog. the @widget button that uses the given @response_id, or %NULL. a #GtkDialog the response ID used by the @dialog widget Emits the #GtkDialog::response signal with the given response ID. Used to indicate that the user has responded to the dialog in some way; typically either you or gtk_dialog_run() will be monitoring the ::response signal and take appropriate action. a #GtkDialog response ID Blocks in a recursive main loop until the @dialog either emits the #GtkDialog::response signal, or is destroyed. If the dialog is destroyed during the call to gtk_dialog_run(), gtk_dialog_run() returns #GTK_RESPONSE_NONE. Otherwise, it returns the response ID from the ::response signal emission. Before entering the recursive main loop, gtk_dialog_run() calls gtk_widget_show() on the dialog for you. Note that you still need to show any children of the dialog yourself. During gtk_dialog_run(), the default behavior of #GtkWidget::delete-event is disabled; if the dialog receives ::delete_event, it will not be destroyed as windows usually are, and gtk_dialog_run() will return #GTK_RESPONSE_DELETE_EVENT. Also, during gtk_dialog_run() the dialog will be modal. You can force gtk_dialog_run() to return at any time by calling gtk_dialog_response() to emit the ::response signal. Destroying the dialog during gtk_dialog_run() is a very bad idea, because your post-run code won’t know whether the dialog was destroyed or not. After gtk_dialog_run() returns, you are responsible for hiding or destroying the dialog if you wish to do so. Typical usage of this function might be: |[<!-- language="C" --> GtkWidget *dialog = gtk_dialog_new (); // Set up dialog... int result = gtk_dialog_run (GTK_DIALOG (dialog)); switch (result) { case GTK_RESPONSE_ACCEPT: // do_application_specific_something (); break; default: // do_nothing_since_dialog_was_cancelled (); break; } gtk_widget_destroy (dialog); ]| Note that even though the recursive main loop gives the effect of a modal dialog (it prevents the user from interacting with other windows in the same window group while the dialog is run), callbacks such as timeouts, IO channel watches, DND drops, etc, will be triggered during a gtk_dialog_run() call. response ID a #GtkDialog Sets an alternative button order. If the #GtkSettings:gtk-alternative-button-order setting is set to %TRUE, the dialog buttons are reordered according to the order of the response ids passed to this function. By default, GTK+ dialogs use the button order advocated by the [GNOME Human Interface Guidelines](http://library.gnome.org/devel/hig-book/stable/) with the affirmative button at the far right, and the cancel button left of it. But the builtin GTK+ dialogs and #GtkMessageDialogs do provide an alternative button order, which is more suitable on some platforms, e.g. Windows. Use this function after adding all the buttons to your dialog, as the following example shows: |[<!-- language="C" --> cancel_button = gtk_dialog_add_button (GTK_DIALOG (dialog), _("_Cancel"), GTK_RESPONSE_CANCEL); ok_button = gtk_dialog_add_button (GTK_DIALOG (dialog), _("_OK"), GTK_RESPONSE_OK); gtk_widget_grab_default (ok_button); help_button = gtk_dialog_add_button (GTK_DIALOG (dialog), _("_Help"), GTK_RESPONSE_HELP); gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, GTK_RESPONSE_HELP, -1); ]| Deprecated a #GtkDialog a response id used by one @dialog’s buttons a list of more response ids of @dialog’s buttons, terminated by -1 Sets an alternative button order. If the #GtkSettings:gtk-alternative-button-order setting is set to %TRUE, the dialog buttons are reordered according to the order of the response ids in @new_order. See gtk_dialog_set_alternative_button_order() for more information. This function is for use by language bindings. Deprecated a #GtkDialog the number of response ids in @new_order an array of response ids of @dialog’s buttons Sets the last widget in the dialog’s action area with the given @response_id as the default widget for the dialog. Pressing “Enter” normally activates the default widget. a #GtkDialog a response ID Calls `gtk_widget_set_sensitive (widget, @setting)` for each widget in the dialog’s action area with the given @response_id. A convenient way to sensitize/desensitize dialog buttons. a #GtkDialog a response ID %TRUE for sensitive %TRUE if the dialog uses a #GtkHeaderBar for action buttons instead of the action-area. For technical reasons, this property is declared as an integer property, but you should only set it to %TRUE or %FALSE. The ::close signal is a [keybinding signal][GtkBindingSignal] which gets emitted when the user uses a keybinding to close the dialog. The default binding for this signal is the Escape key. Emitted when an action widget is clicked, the dialog receives a delete event, or the application programmer calls gtk_dialog_response(). On a delete event, the response ID is #GTK_RESPONSE_DELETE_EVENT. Otherwise, it depends on which action widget was clicked. the response ID The parent class. a #GtkDialog response ID Flags used to influence dialog construction. Make the constructed dialog modal, see gtk_window_set_modal() Destroy the dialog when its parent is destroyed, see gtk_window_set_destroy_with_parent() Create dialog with actions in header bar instead of action area. Since 3.12. Focus movement types. Move forward. Move backward. Move up. Move down. Move left. Move right. Gives an indication why a drag operation failed. The value can by obtained by connecting to the #GtkWidget::drag-failed signal. The drag operation was successful. No suitable drag target. The user cancelled the drag operation. The drag operation timed out. The pointer or keyboard grab used for the drag operation was broken. The drag operation failed due to some unspecified error. The #GtkDrawingArea widget is used for creating custom user interface elements. It’s essentially a blank widget; you can draw on it. After creating a drawing area, the application may want to connect to: - Mouse and button press signals to respond to input from the user. (Use gtk_widget_add_events() to enable events you wish to receive.) - The #GtkWidget::realize signal to take any necessary actions when the widget is instantiated on a particular display. (Create GDK resources in response to this signal.) - The #GtkWidget::size-allocate signal to take any necessary actions when the widget changes size. - The #GtkWidget::draw signal to handle redrawing the contents of the widget. The following code portion demonstrates using a drawing area to display a circle in the normal widget foreground color. Note that GDK automatically clears the exposed area before sending the expose event, and that drawing is implicitly clipped to the exposed area. If you want to have a theme-provided background, you need to call gtk_render_background() in your ::draw method. ## Simple GtkDrawingArea usage |[<!-- language="C" --> gboolean draw_callback (GtkWidget *widget, cairo_t *cr, gpointer data) { guint width, height; GdkRGBA color; GtkStyleContext *context; context = gtk_widget_get_style_context (widget); width = gtk_widget_get_allocated_width (widget); height = gtk_widget_get_allocated_height (widget); gtk_render_background (context, cr, 0, 0, width, height); cairo_arc (cr, width / 2.0, height / 2.0, MIN (width, height) / 2.0, 0, 2 * G_PI); gtk_style_context_get_color (context, gtk_style_context_get_state (context), &color); gdk_cairo_set_source_rgba (cr, &color); cairo_fill (cr); return FALSE; } [...] GtkWidget *drawing_area = gtk_drawing_area_new (); gtk_widget_set_size_request (drawing_area, 100, 100); g_signal_connect (G_OBJECT (drawing_area), "draw", G_CALLBACK (draw_callback), NULL); ]| Draw signals are normally delivered when a drawing area first comes onscreen, or when it’s covered by another window and then uncovered. You can also force an expose event by adding to the “damage region” of the drawing area’s window; gtk_widget_queue_draw_area() and gdk_window_invalidate_rect() are equally good ways to do this. You’ll then get a draw signal for the invalid region. The available routines for drawing are documented on the [GDK Drawing Primitives][gdk3-Cairo-Interaction] page and the cairo documentation. To receive mouse events on a drawing area, you will need to enable them with gtk_widget_add_events(). To receive keyboard events, you will need to set the “can-focus” property on the drawing area, and you should probably draw some user-visible indication that the drawing area is focused. Use gtk_widget_has_focus() in your expose event handler to decide whether to draw the focus indicator. See gtk_render_focus() for one way to draw focus. Creates a new drawing area. a new #GtkDrawingArea The #GtkEditable interface is an interface which should be implemented by text editing widgets, such as #GtkEntry and #GtkSpinButton. It contains functions for generically manipulating an editable widget, a large number of action signals used for key bindings, and several signals that an application can connect to to modify the behavior of a widget. As an example of the latter usage, by connecting the following handler to #GtkEditable::insert-text, an application can convert all entry into a widget into uppercase. ## Forcing entry to uppercase. |[<!-- language="C" --> #include <ctype.h>; void insert_text_handler (GtkEditable *editable, const gchar *text, gint length, gint *position, gpointer data) { gchar *result = g_utf8_strup (text, length); g_signal_handlers_block_by_func (editable, (gpointer) insert_text_handler, data); gtk_editable_insert_text (editable, result, length, position); g_signal_handlers_unblock_by_func (editable, (gpointer) insert_text_handler, data); g_signal_stop_emission_by_name (editable, "insert_text"); g_free (result); } ]| Deletes a sequence of characters. The characters that are deleted are those characters at positions from @start_pos up to, but not including @end_pos. If @end_pos is negative, then the characters deleted are those from @start_pos to the end of the text. Note that the positions are specified in characters, not bytes. a #GtkEditable start position end position Deletes a sequence of characters. The characters that are deleted are those characters at positions from @start_pos up to, but not including @end_pos. If @end_pos is negative, then the characters deleted are those from @start_pos to the end of the text. Note that the positions are specified in characters, not bytes. a #GtkEditable start position end position Inserts @new_text_length bytes of @new_text into the contents of the widget, at position @position. Note that the position is in characters, not in bytes. The function updates @position to point after the newly inserted text. a #GtkEditable the text to append the length of the text in bytes, or -1 location of the position text will be inserted at Retrieves a sequence of characters. The characters that are retrieved are those characters at positions from @start_pos up to, but not including @end_pos. If @end_pos is negative, then the characters retrieved are those characters from @start_pos to the end of the text. Note that positions are specified in characters, not bytes. a pointer to the contents of the widget as a string. This string is allocated by the #GtkEditable implementation and should be freed by the caller. a #GtkEditable start of text end of text Retrieves the current position of the cursor relative to the start of the content of the editable. Note that this position is in characters, not in bytes. the cursor position a #GtkEditable Retrieves the selection bound of the editable. start_pos will be filled with the start of the selection and @end_pos with end. If no text was selected both will be identical and %FALSE will be returned. Note that positions are specified in characters, not bytes. %TRUE if an area is selected, %FALSE otherwise a #GtkEditable location to store the starting position, or %NULL location to store the end position, or %NULL Inserts @new_text_length bytes of @new_text into the contents of the widget, at position @position. Note that the position is in characters, not in bytes. The function updates @position to point after the newly inserted text. a #GtkEditable the text to append the length of the text in bytes, or -1 location of the position text will be inserted at Sets the cursor position in the editable to the given value. The cursor is displayed before the character with the given (base 0) index in the contents of the editable. The value must be less than or equal to the number of characters in the editable. A value of -1 indicates that the position should be set after the last character of the editable. Note that @position is in characters, not in bytes. a #GtkEditable the position of the cursor Selects a region of text. The characters that are selected are those characters at positions from @start_pos up to, but not including @end_pos. If @end_pos is negative, then the characters selected are those characters from @start_pos to the end of the text. Note that positions are specified in characters, not bytes. a #GtkEditable start of region end of region Copies the contents of the currently selected content in the editable and puts it on the clipboard. a #GtkEditable Removes the contents of the currently selected content in the editable and puts it on the clipboard. a #GtkEditable Deletes the currently selected text of the editable. This call doesn’t do anything if there is no selected text. a #GtkEditable Deletes a sequence of characters. The characters that are deleted are those characters at positions from @start_pos up to, but not including @end_pos. If @end_pos is negative, then the characters deleted are those from @start_pos to the end of the text. Note that the positions are specified in characters, not bytes. a #GtkEditable start position end position Retrieves a sequence of characters. The characters that are retrieved are those characters at positions from @start_pos up to, but not including @end_pos. If @end_pos is negative, then the characters retrieved are those characters from @start_pos to the end of the text. Note that positions are specified in characters, not bytes. a pointer to the contents of the widget as a string. This string is allocated by the #GtkEditable implementation and should be freed by the caller. a #GtkEditable start of text end of text Retrieves whether @editable is editable. See gtk_editable_set_editable(). %TRUE if @editable is editable. a #GtkEditable Retrieves the current position of the cursor relative to the start of the content of the editable. Note that this position is in characters, not in bytes. the cursor position a #GtkEditable Retrieves the selection bound of the editable. start_pos will be filled with the start of the selection and @end_pos with end. If no text was selected both will be identical and %FALSE will be returned. Note that positions are specified in characters, not bytes. %TRUE if an area is selected, %FALSE otherwise a #GtkEditable location to store the starting position, or %NULL location to store the end position, or %NULL Inserts @new_text_length bytes of @new_text into the contents of the widget, at position @position. Note that the position is in characters, not in bytes. The function updates @position to point after the newly inserted text. a #GtkEditable the text to append the length of the text in bytes, or -1 location of the position text will be inserted at Pastes the content of the clipboard to the current position of the cursor in the editable. a #GtkEditable Selects a region of text. The characters that are selected are those characters at positions from @start_pos up to, but not including @end_pos. If @end_pos is negative, then the characters selected are those characters from @start_pos to the end of the text. Note that positions are specified in characters, not bytes. a #GtkEditable start of region end of region Determines if the user can edit the text in the editable widget or not. a #GtkEditable %TRUE if the user is allowed to edit the text in the widget Sets the cursor position in the editable to the given value. The cursor is displayed before the character with the given (base 0) index in the contents of the editable. The value must be less than or equal to the number of characters in the editable. A value of -1 indicates that the position should be set after the last character of the editable. Note that @position is in characters, not in bytes. a #GtkEditable the position of the cursor The ::changed signal is emitted at the end of a single user-visible operation on the contents of the #GtkEditable. E.g., a paste operation that replaces the contents of the selection will cause only one signal emission (even though it is implemented by first deleting the selection, then inserting the new content, and may cause multiple ::notify::text signals to be emitted). This signal is emitted when text is deleted from the widget by the user. The default handler for this signal will normally be responsible for deleting the text, so by connecting to this signal and then stopping the signal with g_signal_stop_emission(), it is possible to modify the range of deleted text, or prevent it from being deleted entirely. The @start_pos and @end_pos parameters are interpreted as for gtk_editable_delete_text(). the starting position the end position This signal is emitted when text is inserted into the widget by the user. The default handler for this signal will normally be responsible for inserting the text, so by connecting to this signal and then stopping the signal with g_signal_stop_emission(), it is possible to modify the inserted text, or prevent it from being inserted entirely. the new text to insert the length of the new text, in bytes, or -1 if new_text is nul-terminated the position, in characters, at which to insert the new text. this is an in-out parameter. After the signal emission is finished, it should point after the newly inserted text. a #GtkEditable the text to append the length of the text in bytes, or -1 location of the position text will be inserted at a #GtkEditable start position end position a #GtkEditable the text to append the length of the text in bytes, or -1 location of the position text will be inserted at a #GtkEditable start position end position a pointer to the contents of the widget as a string. This string is allocated by the #GtkEditable implementation and should be freed by the caller. a #GtkEditable start of text end of text a #GtkEditable start of region end of region %TRUE if an area is selected, %FALSE otherwise a #GtkEditable location to store the starting position, or %NULL location to store the end position, or %NULL a #GtkEditable the position of the cursor the cursor position a #GtkEditable The #GtkEntry widget is a single line text entry widget. A fairly large set of key bindings are supported by default. If the entered text is longer than the allocation of the widget, the widget will scroll so that the cursor position is visible. When using an entry for passwords and other sensitive information, it can be put into “password mode” using gtk_entry_set_visibility(). In this mode, entered text is displayed using a “invisible” character. By default, GTK+ picks the best invisible character that is available in the current font, but it can be changed with gtk_entry_set_invisible_char(). Since 2.16, GTK+ displays a warning when Caps Lock or input methods might interfere with entering text in a password entry. The warning can be turned off with the #GtkEntry:caps-lock-warning property. Since 2.16, GtkEntry has the ability to display progress or activity information behind the text. To make an entry display such information, use gtk_entry_set_progress_fraction() or gtk_entry_set_progress_pulse_step(). Additionally, GtkEntry can show icons at either side of the entry. These icons can be activatable by clicking, can be set up as drag source and can have tooltips. To add an icon, use gtk_entry_set_icon_from_gicon() or one of the various other functions that set an icon from a stock id, an icon name or a pixbuf. To trigger an action when the user clicks an icon, connect to the #GtkEntry::icon-press signal. To allow DND operations from an icon, use gtk_entry_set_icon_drag_source(). To set a tooltip on an icon, use gtk_entry_set_icon_tooltip_text() or the corresponding function for markup. Note that functionality or information that is only available by clicking on an icon in an entry may not be accessible at all to users which are not able to use a mouse or other pointing device. It is therefore recommended that any such functionality should also be available by other means, e.g. via the context menu of the entry. # CSS nodes |[<!-- language="plain" --> entry[.read-only][.flat][.warning][.error] ├── image.left ├── image.right ├── undershoot.left ├── undershoot.right ├── [selection] ├── [progress[.pulse]] ╰── [window.popup] ]| GtkEntry has a main node with the name entry. Depending on the properties of the entry, the style classes .read-only and .flat may appear. The style classes .warning and .error may also be used with entries. When the entry shows icons, it adds subnodes with the name image and the style class .left or .right, depending on where the icon appears. When the entry has a selection, it adds a subnode with the name selection. When the entry shows progress, it adds a subnode with the name progress. The node has the style class .pulse when the shown progress is pulsing. The CSS node for a context menu is added as a subnode below entry as well. The undershoot nodes are used to draw the underflow indication when content is scrolled out of view. These nodes get the .left and .right style classes added depending on where the indication is drawn. When touch is used and touch selection handles are shown, they are using CSS nodes with name cursor-handle. They get the .top or .bottom style class depending on where they are shown in relation to the selection. If there is just a single handle for the text cursor, it gets the style class .insertion-cursor. Creates a new entry. a new #GtkEntry. Creates a new entry with the specified text buffer. a new #GtkEntry The buffer to use for the new #GtkEntry. Retrieves the value set by gtk_entry_set_activates_default(). %TRUE if the entry will activate the default widget a #GtkEntry Gets the value set by gtk_entry_set_alignment(). the alignment a #GtkEntry Gets the attribute list that was set on the entry using gtk_entry_set_attributes(), if any. the attribute list, or %NULL if none was set. a #GtkEntry Get the #GtkEntryBuffer object which holds the text for this widget. A #GtkEntryBuffer object. a #GtkEntry Returns the auxiliary completion object currently in use by @entry. The auxiliary completion object currently in use by @entry. A #GtkEntry Returns the index of the icon which is the source of the current DND operation, or -1. This function is meant to be used in a #GtkWidget::drag-data-get callback. index of the icon which is the source of the current DND operation, or -1. a #GtkEntry Retrieves the horizontal cursor adjustment for the entry. See gtk_entry_set_cursor_hadjustment(). the horizontal cursor adjustment, or %NULL if none has been set. a #GtkEntry Gets the value set by gtk_entry_set_has_frame(). whether the entry has a beveled frame a #GtkEntry Returns whether the icon is activatable. %TRUE if the icon is activatable. a #GtkEntry Icon position Gets the area where entry’s icon at @icon_pos is drawn. This function is useful when drawing something to the entry in a draw callback. If the entry is not realized or has no icon at the given position, @icon_area is filled with zeros. Otherwise, @icon_area will be filled with the icon’s allocation, relative to @entry’s allocation. See also gtk_entry_get_text_area() A #GtkEntry Icon position Return location for the icon’s area Finds the icon at the given position and return its index. The position’s coordinates are relative to the @entry’s top left corner. If @x, @y doesn’t lie inside an icon, -1 is returned. This function is intended for use in a #GtkWidget::query-tooltip signal handler. the index of the icon at the given position, or -1 a #GtkEntry the x coordinate of the position to find the y coordinate of the position to find Retrieves the #GIcon used for the icon, or %NULL if there is no icon or if the icon was set by some other method (e.g., by stock, pixbuf, or icon name). A #GIcon, or %NULL if no icon is set or if the icon is not a #GIcon A #GtkEntry Icon position Retrieves the icon name used for the icon, or %NULL if there is no icon or if the icon was set by some other method (e.g., by pixbuf, stock or gicon). An icon name, or %NULL if no icon is set or if the icon wasn’t set from an icon name A #GtkEntry Icon position Retrieves the image used for the icon. Unlike the other methods of setting and getting icon data, this method will work regardless of whether the icon was set using a #GdkPixbuf, a #GIcon, a stock item, or an icon name. A #GdkPixbuf, or %NULL if no icon is set for this position. A #GtkEntry Icon position Returns whether the icon appears sensitive or insensitive. %TRUE if the icon is sensitive. a #GtkEntry Icon position Retrieves the stock id used for the icon, or %NULL if there is no icon or if the icon was set by some other method (e.g., by pixbuf, icon name or gicon). Use gtk_entry_get_icon_name() instead. A stock id, or %NULL if no icon is set or if the icon wasn’t set from a stock id A #GtkEntry Icon position Gets the type of representation being used by the icon to store image data. If the icon has no image data, the return value will be %GTK_IMAGE_EMPTY. image representation being used a #GtkEntry Icon position Gets the contents of the tooltip on the icon at the specified position in @entry. the tooltip text, or %NULL. Free the returned string with g_free() when done. a #GtkEntry the icon position Gets the contents of the tooltip on the icon at the specified position in @entry. the tooltip text, or %NULL. Free the returned string with g_free() when done. a #GtkEntry the icon position This function returns the entry’s #GtkEntry:inner-border property. See gtk_entry_set_inner_border() for more information. Use the standard border and padding CSS properties (through objects like #GtkStyleContext and #GtkCssProvider); the value returned by this function is ignored by #GtkEntry. the entry’s #GtkBorder, or %NULL if none was set. a #GtkEntry Gets the value of the #GtkEntry:input-hints property. a #GtkEntry Gets the value of the #GtkEntry:input-purpose property. a #GtkEntry Retrieves the character displayed in place of the real characters for entries with visibility set to false. See gtk_entry_set_invisible_char(). the current invisible char, or 0, if the entry does not show invisible text at all. a #GtkEntry Gets the #PangoLayout used to display the entry. The layout is useful to e.g. convert text positions to pixel positions, in combination with gtk_entry_get_layout_offsets(). The returned layout is owned by the entry and must not be modified or freed by the caller. Keep in mind that the layout text may contain a preedit string, so gtk_entry_layout_index_to_text_index() and gtk_entry_text_index_to_layout_index() are needed to convert byte indices in the layout to byte indices in the entry contents. the #PangoLayout for this entry a #GtkEntry Obtains the position of the #PangoLayout used to render text in the entry, in widget coordinates. Useful if you want to line up the text in an entry with some other text, e.g. when using the entry to implement editable cells in a sheet widget. Also useful to convert mouse events into coordinates inside the #PangoLayout, e.g. to take some action if some part of the entry text is clicked. Note that as the user scrolls around in the entry the offsets will change; you’ll need to connect to the “notify::scroll-offset” signal to track this. Remember when using the #PangoLayout functions you need to convert to and from pixels using PANGO_PIXELS() or #PANGO_SCALE. Keep in mind that the layout text may contain a preedit string, so gtk_entry_layout_index_to_text_index() and gtk_entry_text_index_to_layout_index() are needed to convert byte indices in the layout to byte indices in the entry contents. a #GtkEntry location to store X offset of layout, or %NULL location to store Y offset of layout, or %NULL Retrieves the maximum allowed length of the text in @entry. See gtk_entry_set_max_length(). This is equivalent to getting @entry's #GtkEntryBuffer and calling gtk_entry_buffer_get_max_length() on it. the maximum allowed number of characters in #GtkEntry, or 0 if there is no maximum. a #GtkEntry Retrieves the desired maximum width of @entry, in characters. See gtk_entry_set_max_width_chars(). the maximum width of the entry, in characters a #GtkEntry Gets the value set by gtk_entry_set_overwrite_mode(). whether the text is overwritten when typing. a #GtkEntry Retrieves the text that will be displayed when @entry is empty and unfocused a pointer to the placeholder text as a string. This string points to internally allocated storage in the widget and must not be freed, modified or stored. a #GtkEntry Returns the current fraction of the task that’s been completed. See gtk_entry_set_progress_fraction(). a fraction from 0.0 to 1.0 a #GtkEntry Retrieves the pulse step set with gtk_entry_set_progress_pulse_step(). a fraction from 0.0 to 1.0 a #GtkEntry Gets the tabstops that were set on the entry using gtk_entry_set_tabs(), if any. the tabstops, or %NULL if none was set. a #GtkEntry Retrieves the contents of the entry widget. See also gtk_editable_get_chars(). This is equivalent to getting @entry's #GtkEntryBuffer and calling gtk_entry_buffer_get_text() on it. a pointer to the contents of the widget as a string. This string points to internally allocated storage in the widget and must not be freed, modified or stored. a #GtkEntry Gets the area where the entry’s text is drawn. This function is useful when drawing something to the entry in a draw callback. If the entry is not realized, @text_area is filled with zeros. See also gtk_entry_get_icon_area(). a #GtkEntry Return location for the text area. Retrieves the current length of the text in @entry. This is equivalent to getting @entry's #GtkEntryBuffer and calling gtk_entry_buffer_get_length() on it. the current number of characters in #GtkEntry, or 0 if there are none. a #GtkEntry Retrieves whether the text in @entry is visible. See gtk_entry_set_visibility(). %TRUE if the text is currently visible a #GtkEntry Gets the value set by gtk_entry_set_width_chars(). number of chars to request space for, or negative if unset a #GtkEntry Causes @entry to have keyboard focus. It behaves like gtk_widget_grab_focus(), except that it doesn't select the contents of the entry. You only want to call this on some special entries which the user usually doesn't want to replace all text in, such as search-as-you-type entries. a #GtkEntry Allow the #GtkEntry input method to internally handle key press and release events. If this function returns %TRUE, then no further processing should be done for this key event. See gtk_im_context_filter_keypress(). Note that you are expected to call this function from your handler when overriding key event handling. This is needed in the case when you need to insert your own key handling between the input method and the default key event handling of the #GtkEntry. See gtk_text_view_reset_im_context() for an example of use. %TRUE if the input method handled the key event. a #GtkEntry the key event Converts from a position in the entry’s #PangoLayout (returned by gtk_entry_get_layout()) to a position in the entry contents (returned by gtk_entry_get_text()). byte index into the entry contents a #GtkEntry byte index into the entry layout text Indicates that some progress is made, but you don’t know how much. Causes the entry’s progress indicator to enter “activity mode,” where a block bounces back and forth. Each call to gtk_entry_progress_pulse() causes the block to move by a little bit (the amount of movement per pulse is determined by gtk_entry_set_progress_pulse_step()). a #GtkEntry Reset the input method context of the entry if needed. This can be necessary in the case where modifying the buffer would confuse on-going input method behavior. a #GtkEntry If @setting is %TRUE, pressing Enter in the @entry will activate the default widget for the window containing the entry. This usually means that the dialog box containing the entry will be closed, since the default widget is usually one of the dialog buttons. (For experts: if @setting is %TRUE, the entry calls gtk_window_activate_default() on the window containing the entry, in the default handler for the #GtkEntry::activate signal.) a #GtkEntry %TRUE to activate window’s default widget on Enter keypress Sets the alignment for the contents of the entry. This controls the horizontal positioning of the contents when the displayed text is shorter than the width of the entry. a #GtkEntry The horizontal alignment, from 0 (left) to 1 (right). Reversed for RTL layouts Sets a #PangoAttrList; the attributes in the list are applied to the entry text. a #GtkEntry a #PangoAttrList Set the #GtkEntryBuffer object which holds the text for this widget. a #GtkEntry a #GtkEntryBuffer Sets @completion to be the auxiliary completion object to use with @entry. All further configuration of the completion mechanism is done on @completion using the #GtkEntryCompletion API. Completion is disabled if @completion is set to %NULL. A #GtkEntry The #GtkEntryCompletion or %NULL Hooks up an adjustment to the cursor position in an entry, so that when the cursor is moved, the adjustment is scrolled to show that position. See gtk_scrolled_window_get_hadjustment() for a typical way of obtaining the adjustment. The adjustment has to be in pixel units and in the same coordinate system as the entry. a #GtkEntry an adjustment which should be adjusted when the cursor is moved, or %NULL Sets whether the entry has a beveled frame around it. a #GtkEntry new value Sets whether the icon is activatable. A #GtkEntry Icon position %TRUE if the icon should be activatable Sets up the icon at the given position so that GTK+ will start a drag operation when the user clicks and drags the icon. To handle the drag operation, you need to connect to the usual #GtkWidget::drag-data-get (or possibly #GtkWidget::drag-data-delete) signal, and use gtk_entry_get_current_icon_drag_source() in your signal handler to find out if the drag was started from an icon. By default, GTK+ uses the icon as the drag icon. You can use the #GtkWidget::drag-begin signal to set a different icon. Note that you have to use g_signal_connect_after() to ensure that your signal handler gets executed after the default handler. a #GtkEntry icon position the targets (data formats) in which the data can be provided a bitmask of the allowed drag actions Sets the icon shown in the entry at the specified position from the current icon theme. If the icon isn’t known, a “broken image” icon will be displayed instead. If @icon is %NULL, no icon will be shown in the specified position. A #GtkEntry The position at which to set the icon The icon to set, or %NULL Sets the icon shown in the entry at the specified position from the current icon theme. If the icon name isn’t known, a “broken image” icon will be displayed instead. If @icon_name is %NULL, no icon will be shown in the specified position. A #GtkEntry The position at which to set the icon An icon name, or %NULL Sets the icon shown in the specified position using a pixbuf. If @pixbuf is %NULL, no icon will be shown in the specified position. a #GtkEntry Icon position A #GdkPixbuf, or %NULL Sets the icon shown in the entry at the specified position from a stock image. If @stock_id is %NULL, no icon will be shown in the specified position. Use gtk_entry_set_icon_from_icon_name() instead. A #GtkEntry Icon position The name of the stock item, or %NULL Sets the sensitivity for the specified icon. A #GtkEntry Icon position Specifies whether the icon should appear sensitive or insensitive Sets @tooltip as the contents of the tooltip for the icon at the specified position. @tooltip is assumed to be marked up with the [Pango text markup language][PangoMarkupFormat]. Use %NULL for @tooltip to remove an existing tooltip. See also gtk_widget_set_tooltip_markup() and gtk_entry_set_icon_tooltip_text(). a #GtkEntry the icon position the contents of the tooltip for the icon, or %NULL Sets @tooltip as the contents of the tooltip for the icon at the specified position. Use %NULL for @tooltip to remove an existing tooltip. See also gtk_widget_set_tooltip_text() and gtk_entry_set_icon_tooltip_markup(). If you unset the widget tooltip via gtk_widget_set_tooltip_text() or gtk_widget_set_tooltip_markup(), this sets GtkWidget:has-tooltip to %FALSE, which suppresses icon tooltips too. You can resolve this by then calling gtk_widget_set_has_tooltip() to set GtkWidget:has-tooltip back to %TRUE, or setting at least one non-empty tooltip on any icon achieves the same result. a #GtkEntry the icon position the contents of the tooltip for the icon, or %NULL Sets %entry’s inner-border property to @border, or clears it if %NULL is passed. The inner-border is the area around the entry’s text, but inside its frame. If set, this property overrides the inner-border style property. Overriding the style-provided border is useful when you want to do in-place editing of some text in a canvas or list widget, where pixel-exact positioning of the entry is important. Use the standard border and padding CSS properties (through objects like #GtkStyleContext and #GtkCssProvider); the value set with this function is ignored by #GtkEntry. a #GtkEntry a #GtkBorder, or %NULL Sets the #GtkEntry:input-hints property, which allows input methods to fine-tune their behaviour. a #GtkEntry the hints Sets the #GtkEntry:input-purpose property which can be used by on-screen keyboards and other input methods to adjust their behaviour. a #GtkEntry the purpose Sets the character to use in place of the actual text when gtk_entry_set_visibility() has been called to set text visibility to %FALSE. i.e. this is the character used in “password mode” to show the user how many characters have been typed. By default, GTK+ picks the best invisible char available in the current font. If you set the invisible char to 0, then the user will get no feedback at all; there will be no text on the screen as they type. a #GtkEntry a Unicode character Sets the maximum allowed length of the contents of the widget. If the current contents are longer than the given length, then they will be truncated to fit. This is equivalent to getting @entry's #GtkEntryBuffer and calling gtk_entry_buffer_set_max_length() on it. ]| a #GtkEntry the maximum length of the entry, or 0 for no maximum. (other than the maximum length of entries.) The value passed in will be clamped to the range 0-65536. Sets the desired maximum width in characters of @entry. a #GtkEntry the new desired maximum width, in characters Sets whether the text is overwritten when typing in the #GtkEntry. a #GtkEntry new value Sets text to be displayed in @entry when it is empty and unfocused. This can be used to give a visual hint of the expected contents of the #GtkEntry. Note that since the placeholder text gets removed when the entry received focus, using this feature is a bit problematic if the entry is given the initial focus in a window. Sometimes this can be worked around by delaying the initial focus setting until the first key event arrives. a #GtkEntry a string to be displayed when @entry is empty and unfocused, or %NULL Causes the entry’s progress indicator to “fill in” the given fraction of the bar. The fraction should be between 0.0 and 1.0, inclusive. a #GtkEntry fraction of the task that’s been completed Sets the fraction of total entry width to move the progress bouncing block for each call to gtk_entry_progress_pulse(). a #GtkEntry fraction between 0.0 and 1.0 Sets a #PangoTabArray; the tabstops in the array are applied to the entry text. a #GtkEntry a #PangoTabArray Sets the text in the widget to the given value, replacing the current contents. See gtk_entry_buffer_set_text(). a #GtkEntry the new text Sets whether the contents of the entry are visible or not. When visibility is set to %FALSE, characters are displayed as the invisible char, and will also appear that way when the text in the entry widget is copied elsewhere. By default, GTK+ picks the best invisible character available in the current font, but it can be changed with gtk_entry_set_invisible_char(). Note that you probably want to set #GtkEntry:input-purpose to %GTK_INPUT_PURPOSE_PASSWORD or %GTK_INPUT_PURPOSE_PIN to inform input methods about the purpose of this entry, in addition to setting visibility to %FALSE. a #GtkEntry %TRUE if the contents of the entry are displayed as plaintext Changes the size request of the entry to be about the right size for @n_chars characters. Note that it changes the size request, the size can still be affected by how you pack the widget into containers. If @n_chars is -1, the size reverts to the default entry size. a #GtkEntry width in chars Converts from a position in the entry contents (returned by gtk_entry_get_text()) to a position in the entry’s #PangoLayout (returned by gtk_entry_get_layout(), with text retrieved via pango_layout_get_text()). byte index into the entry layout text a #GtkEntry byte index into the entry contents Unsets the invisible char previously set with gtk_entry_set_invisible_char(). So that the default invisible char is used again. a #GtkEntry A list of Pango attributes to apply to the text of the entry. This is mainly useful to change the size or weight of the text. The #PangoAttribute's @start_index and @end_index must refer to the #GtkEntryBuffer text, i.e. without the preedit string. Whether password entries will show a warning when Caps Lock is on. Note that the warning is shown using a secondary icon, and thus does not work if you are using the secondary icon position for some other purpose. The auxiliary completion object to use with the entry. Which IM (input method) module should be used for this entry. See #GtkIMContext. Setting this to a non-%NULL value overrides the system-wide IM module setting. See the GtkSettings #GtkSettings:gtk-im-module property. Sets the text area's border between the text and the frame. Use the standard border and padding CSS properties (through objects like #GtkStyleContext and #GtkCssProvider); the value of this style property is ignored. Additional hints (beyond #GtkEntry:input-purpose) that allow input methods to fine-tune their behaviour. The purpose of this text field. This property can be used by on-screen keyboards and other input methods to adjust their behaviour. Note that setting the purpose to %GTK_INPUT_PURPOSE_PASSWORD or %GTK_INPUT_PURPOSE_PIN is independent from setting #GtkEntry:visibility. The invisible character is used when masking entry contents (in \"password mode\")"). When it is not explicitly set with the #GtkEntry:invisible-char property, GTK+ determines the character to use from a list of possible candidates, depending on availability in the current font. This style property allows the theme to prepend a character to the list of candidates. Whether the invisible char has been set for the #GtkEntry. The desired maximum width of the entry, in characters. If this property is set to -1, the width will be calculated automatically. If text is overwritten when typing in the #GtkEntry. The text that will be displayed in the #GtkEntry when it is empty and unfocused. If :populate-all is %TRUE, the #GtkEntry::populate-popup signal is also emitted for touch popups. Whether the primary icon is activatable. GTK+ emits the #GtkEntry::icon-press and #GtkEntry::icon-release signals only on sensitive, activatable icons. Sensitive, but non-activatable icons can be used for purely informational purposes. The #GIcon to use for the primary icon for the entry. The icon name to use for the primary icon for the entry. A pixbuf to use as the primary icon for the entry. Whether the primary icon is sensitive. An insensitive icon appears grayed out. GTK+ does not emit the #GtkEntry::icon-press and #GtkEntry::icon-release signals and does not allow DND from insensitive icons. An icon should be set insensitive if the action that would trigger when clicked is currently not available. The stock id to use for the primary icon for the entry. Use #GtkEntry:primary-icon-name instead. The representation which is used for the primary icon of the entry. The contents of the tooltip on the primary icon, which is marked up with the [Pango text markup language][PangoMarkupFormat]. Also see gtk_entry_set_icon_tooltip_markup(). The contents of the tooltip on the primary icon. Also see gtk_entry_set_icon_tooltip_text(). The current fraction of the task that's been completed. The fraction of total entry width to move the progress bouncing block for each call to gtk_entry_progress_pulse(). Whether the secondary icon is activatable. GTK+ emits the #GtkEntry::icon-press and #GtkEntry::icon-release signals only on sensitive, activatable icons. Sensitive, but non-activatable icons can be used for purely informational purposes. The #GIcon to use for the secondary icon for the entry. The icon name to use for the secondary icon for the entry. An pixbuf to use as the secondary icon for the entry. Whether the secondary icon is sensitive. An insensitive icon appears grayed out. GTK+ does not emit the #GtkEntry::icon-press and #GtkEntry::icon-release signals and does not allow DND from insensitive icons. An icon should be set insensitive if the action that would trigger when clicked is currently not available. The stock id to use for the secondary icon for the entry. Use #GtkEntry:secondary-icon-name instead. The representation which is used for the secondary icon of the entry. The contents of the tooltip on the secondary icon, which is marked up with the [Pango text markup language][PangoMarkupFormat]. Also see gtk_entry_set_icon_tooltip_markup(). The contents of the tooltip on the secondary icon. Also see gtk_entry_set_icon_tooltip_text(). Which kind of shadow to draw around the entry when #GtkEntry:has-frame is set to %TRUE. Use CSS to determine the style of the border; the value of this style property is ignored. The length of the text in the #GtkEntry. When %TRUE, pasted multi-line text is truncated to the first line. The horizontal alignment, from 0 (left) to 1 (right). Reversed for RTL layouts. The ::activate signal is emitted when the user hits the Enter key. While this signal is used as a [keybinding signal][GtkBindingSignal], it is also commonly used by applications to intercept activation of entries. The default bindings for this signal are all forms of the Enter key. The ::backspace signal is a [keybinding signal][GtkBindingSignal] which gets emitted when the user asks for it. The default bindings for this signal are Backspace and Shift-Backspace. The ::copy-clipboard signal is a [keybinding signal][GtkBindingSignal] which gets emitted to copy the selection to the clipboard. The default bindings for this signal are Ctrl-c and Ctrl-Insert. The ::cut-clipboard signal is a [keybinding signal][GtkBindingSignal] which gets emitted to cut the selection to the clipboard. The default bindings for this signal are Ctrl-x and Shift-Delete. The ::delete-from-cursor signal is a [keybinding signal][GtkBindingSignal] which gets emitted when the user initiates a text deletion. If the @type is %GTK_DELETE_CHARS, GTK+ deletes the selection if there is one, otherwise it deletes the requested number of characters. The default bindings for this signal are Delete for deleting a character and Ctrl-Delete for deleting a word. the granularity of the deletion, as a #GtkDeleteType the number of @type units to delete The ::icon-press signal is emitted when an activatable icon is clicked. The position of the clicked icon The ::icon-release signal is emitted on the button release from a mouse click over an activatable icon. The position of the clicked icon The ::insert-at-cursor signal is a [keybinding signal][GtkBindingSignal] which gets emitted when the user initiates the insertion of a fixed string at the cursor. This signal has no default bindings. the string to insert The ::insert-emoji signal is a [keybinding signal][GtkBindingSignal] which gets emitted to present the Emoji chooser for the @entry. The default bindings for this signal are Ctrl-. and Ctrl-; The ::move-cursor signal is a [keybinding signal][GtkBindingSignal] which gets emitted when the user initiates a cursor movement. If the cursor is not visible in @entry, this signal causes the viewport to be moved instead. Applications should not connect to it, but may emit it with g_signal_emit_by_name() if they need to control the cursor programmatically. The default bindings for this signal come in two variants, the variant with the Shift modifier extends the selection, the variant without the Shift modifer does not. There are too many key combinations to list them all here. - Arrow keys move by individual characters/lines - Ctrl-arrow key combinations move by words/paragraphs - Home/End keys move to the ends of the buffer the granularity of the move, as a #GtkMovementStep the number of @step units to move %TRUE if the move should extend the selection The ::paste-clipboard signal is a [keybinding signal][GtkBindingSignal] which gets emitted to paste the contents of the clipboard into the text view. The default bindings for this signal are Ctrl-v and Shift-Insert. The ::populate-popup signal gets emitted before showing the context menu of the entry. If you need to add items to the context menu, connect to this signal and append your items to the @widget, which will be a #GtkMenu in this case. If #GtkEntry:populate-all is %TRUE, this signal will also be emitted to populate touch popups. In this case, @widget will be a different container, e.g. a #GtkToolbar. The signal handler should not make assumptions about the type of @widget. the container that is being populated If an input method is used, the typed text will not immediately be committed to the buffer. So if you are interested in the text, connect to this signal. the current preedit string The ::toggle-overwrite signal is a [keybinding signal][GtkBindingSignal] which gets emitted to toggle the overwrite mode of the entry. The default bindings for this signal is Insert. The #GtkEntryBuffer class contains the actual text displayed in a #GtkEntry widget. A single #GtkEntryBuffer object can be shared by multiple #GtkEntry widgets which will then share the same text content, but not the cursor position, visibility attributes, icon etc. #GtkEntryBuffer may be derived from. Such a derived class might allow text to be stored in an alternate location, such as non-pageable memory, useful in the case of important passwords. Or a derived class could integrate with an application’s concept of undo/redo. Create a new GtkEntryBuffer object. Optionally, specify initial text to set in the buffer. A new GtkEntryBuffer object. initial buffer text, or %NULL number of characters in @initial_chars, or -1 Deletes a sequence of characters from the buffer. @n_chars characters are deleted starting at @position. If @n_chars is negative, then all characters until the end of the text are deleted. If @position or @n_chars are out of bounds, then they are coerced to sane values. Note that the positions are specified in characters, not bytes. The number of characters deleted. a #GtkEntryBuffer position at which to delete text number of characters to delete Retrieves the length in characters of the buffer. The number of characters in the buffer. a #GtkEntryBuffer Inserts @n_chars characters of @chars into the contents of the buffer, at position @position. If @n_chars is negative, then characters from chars will be inserted until a null-terminator is found. If @position or @n_chars are out of bounds, or the maximum buffer text length is exceeded, then they are coerced to sane values. Note that the position and length are in characters, not in bytes. The number of characters actually inserted. a #GtkEntryBuffer the position at which to insert text. the text to insert into the buffer. the length of the text in characters, or -1 Deletes a sequence of characters from the buffer. @n_chars characters are deleted starting at @position. If @n_chars is negative, then all characters until the end of the text are deleted. If @position or @n_chars are out of bounds, then they are coerced to sane values. Note that the positions are specified in characters, not bytes. The number of characters deleted. a #GtkEntryBuffer position at which to delete text number of characters to delete Used when subclassing #GtkEntryBuffer a #GtkEntryBuffer position at which text was deleted number of characters deleted Used when subclassing #GtkEntryBuffer a #GtkEntryBuffer position at which text was inserted text that was inserted number of characters inserted Retrieves the length in bytes of the buffer. See gtk_entry_buffer_get_length(). The byte length of the buffer. a #GtkEntryBuffer Retrieves the length in characters of the buffer. The number of characters in the buffer. a #GtkEntryBuffer Retrieves the maximum allowed length of the text in @buffer. See gtk_entry_buffer_set_max_length(). the maximum allowed number of characters in #GtkEntryBuffer, or 0 if there is no maximum. a #GtkEntryBuffer Retrieves the contents of the buffer. The memory pointer returned by this call will not change unless this object emits a signal, or is finalized. a pointer to the contents of the widget as a string. This string points to internally allocated storage in the buffer and must not be freed, modified or stored. a #GtkEntryBuffer Inserts @n_chars characters of @chars into the contents of the buffer, at position @position. If @n_chars is negative, then characters from chars will be inserted until a null-terminator is found. If @position or @n_chars are out of bounds, or the maximum buffer text length is exceeded, then they are coerced to sane values. Note that the position and length are in characters, not in bytes. The number of characters actually inserted. a #GtkEntryBuffer the position at which to insert text. the text to insert into the buffer. the length of the text in characters, or -1 Sets the maximum allowed length of the contents of the buffer. If the current contents are longer than the given length, then they will be truncated to fit. a #GtkEntryBuffer the maximum length of the entry buffer, or 0 for no maximum. (other than the maximum length of entries.) The value passed in will be clamped to the range 0-65536. Sets the text in the buffer. This is roughly equivalent to calling gtk_entry_buffer_delete_text() and gtk_entry_buffer_insert_text(). Note that @n_chars is in characters, not in bytes. a #GtkEntryBuffer the new text the number of characters in @text, or -1 The length (in characters) of the text in buffer. The maximum length (in characters) of the text in the buffer. The contents of the buffer. This signal is emitted after text is deleted from the buffer. the position the text was deleted at. The number of characters that were deleted. This signal is emitted after text is inserted into the buffer. the position the text was inserted at. The text that was inserted. The number of characters that were inserted. The number of characters in the buffer. a #GtkEntryBuffer The number of characters actually inserted. a #GtkEntryBuffer the position at which to insert text. the text to insert into the buffer. the length of the text in characters, or -1 The number of characters deleted. a #GtkEntryBuffer position at which to delete text number of characters to delete Class structure for #GtkEntry. All virtual functions have a default implementation. Derived classes may set the virtual function pointers for the signal handlers to %NULL, but must keep @get_text_area_size and @get_frame_size non-%NULL; either use the default implementation, or provide a custom one. The parent class. #GtkEntryCompletion is an auxiliary object to be used in conjunction with #GtkEntry to provide the completion functionality. It implements the #GtkCellLayout interface, to allow the user to add extra cells to the #GtkTreeView with completion matches. “Completion functionality” means that when the user modifies the text in the entry, #GtkEntryCompletion checks which rows in the model match the current content of the entry, and displays a list of matches. By default, the matching is done by comparing the entry text case-insensitively against the text column of the model (see gtk_entry_completion_set_text_column()), but this can be overridden with a custom match function (see gtk_entry_completion_set_match_func()). When the user selects a completion, the content of the entry is updated. By default, the content of the entry is replaced by the text column of the model, but this can be overridden by connecting to the #GtkEntryCompletion::match-selected signal and updating the entry in the signal handler. Note that you should return %TRUE from the signal handler to suppress the default behaviour. To add completion functionality to an entry, use gtk_entry_set_completion(). In addition to regular completion matches, which will be inserted into the entry when they are selected, #GtkEntryCompletion also allows to display “actions” in the popup window. Their appearance is similar to menuitems, to differentiate them clearly from completion strings. When an action is selected, the #GtkEntryCompletion::action-activated signal is emitted. GtkEntryCompletion uses a #GtkTreeModelFilter model to represent the subset of the entire model that is currently matching. While the GtkEntryCompletion signals #GtkEntryCompletion::match-selected and #GtkEntryCompletion::cursor-on-match take the original model and an iter pointing to that model as arguments, other callbacks and signals (such as #GtkCellLayoutDataFuncs or #GtkCellArea::apply-attributes) will generally take the filter model as argument. As long as you are only calling gtk_tree_model_get(), this will make no difference to you. If for some reason, you need the original model, use gtk_tree_model_filter_get_model(). Don’t forget to use gtk_tree_model_filter_convert_iter_to_child_iter() to obtain a matching iter. Creates a new #GtkEntryCompletion object. A newly created #GtkEntryCompletion object Creates a new #GtkEntryCompletion object using the specified @area to layout cells in the underlying #GtkTreeViewColumn for the drop-down menu. A newly created #GtkEntryCompletion object the #GtkCellArea used to layout cells Requests a completion operation, or in other words a refiltering of the current list with completions, using the current key. The completion list view will be updated accordingly. a #GtkEntryCompletion Computes the common prefix that is shared by all rows in @completion that start with @key. If no row matches @key, %NULL will be returned. Note that a text column must have been set for this function to work, see gtk_entry_completion_set_text_column() for details. The common prefix all rows starting with @key or %NULL if no row matches @key. the entry completion The text to complete for Deletes the action at @index_ from @completion’s action list. Note that @index_ is a relative position and the position of an action may have changed since it was inserted. a #GtkEntryCompletion the index of the item to delete Get the original text entered by the user that triggered the completion or %NULL if there’s no completion ongoing. the prefix for the current completion a #GtkEntryCompletion Gets the entry @completion has been attached to. The entry @completion has been attached to a #GtkEntryCompletion Returns whether the common prefix of the possible completions should be automatically inserted in the entry. %TRUE if inline completion is turned on a #GtkEntryCompletion Returns %TRUE if inline-selection mode is turned on. %TRUE if inline-selection mode is on a #GtkEntryCompletion Returns the minimum key length as set for @completion. The currently used minimum key length a #GtkEntryCompletion Returns the model the #GtkEntryCompletion is using as data source. Returns %NULL if the model is unset. A #GtkTreeModel, or %NULL if none is currently being used a #GtkEntryCompletion Returns whether the completions should be presented in a popup window. %TRUE if popup completion is turned on a #GtkEntryCompletion Returns whether the completion popup window will be resized to the width of the entry. %TRUE if the popup window will be resized to the width of the entry a #GtkEntryCompletion Returns whether the completion popup window will appear even if there is only a single match. %TRUE if the popup window will appear regardless of the number of matches a #GtkEntryCompletion Returns the column in the model of @completion to get strings from. the column containing the strings a #GtkEntryCompletion Inserts an action in @completion’s action item list at position @index_ with markup @markup. a #GtkEntryCompletion the index of the item to insert markup of the item to insert Inserts an action in @completion’s action item list at position @index_ with text @text. If you want the action item to have markup, use gtk_entry_completion_insert_action_markup(). Note that @index_ is a relative position in the list of actions and the position of an action can change when deleting a different action. a #GtkEntryCompletion the index of the item to insert text of the item to insert Requests a prefix insertion. a #GtkEntryCompletion Sets whether the common prefix of the possible completions should be automatically inserted in the entry. a #GtkEntryCompletion %TRUE to do inline completion Sets whether it is possible to cycle through the possible completions inside the entry. a #GtkEntryCompletion %TRUE to do inline selection Sets the match function for @completion to be @func. The match function is used to determine if a row should or should not be in the completion list. a #GtkEntryCompletion the #GtkEntryCompletionMatchFunc to use user data for @func destroy notify for @func_data. Requires the length of the search key for @completion to be at least @length. This is useful for long lists, where completing using a small key takes a lot of time and will come up with meaningless results anyway (ie, a too large dataset). a #GtkEntryCompletion the minimum length of the key in order to start completing Sets the model for a #GtkEntryCompletion. If @completion already has a model set, it will remove it before setting the new model. If model is %NULL, then it will unset the model. a #GtkEntryCompletion the #GtkTreeModel Sets whether the completions should be presented in a popup window. a #GtkEntryCompletion %TRUE to do popup completion Sets whether the completion popup window will be resized to be the same width as the entry. a #GtkEntryCompletion %TRUE to make the width of the popup the same as the entry Sets whether the completion popup window will appear even if there is only a single match. You may want to set this to %FALSE if you are using [inline completion][GtkEntryCompletion--inline-completion]. a #GtkEntryCompletion %TRUE if the popup should appear even for a single match Convenience function for setting up the most used case of this code: a completion list with just strings. This function will set up @completion to have a list displaying all (and just) strings in the completion list, and to get those strings from @column in the model of @completion. This functions creates and adds a #GtkCellRendererText for the selected column. If you need to set the text column, but don't want the cell renderer, use g_object_set() to set the #GtkEntryCompletion:text-column property directly. a #GtkEntryCompletion the column in the model of @completion to get strings from The #GtkCellArea used to layout cell renderers in the treeview column. If no area is specified when creating the entry completion with gtk_entry_completion_new_with_area() a horizontally oriented #GtkCellAreaBox will be used. Determines whether the common prefix of the possible completions should be inserted automatically in the entry. Note that this requires text-column to be set, even if you are using a custom match function. Determines whether the possible completions on the popup will appear in the entry as you navigate through them. Determines whether the possible completions should be shown in a popup window. Determines whether the completions popup window will be resized to the width of the entry. Determines whether the completions popup window will shown for a single possible completion. You probably want to set this to %FALSE if you are using [inline completion][GtkEntryCompletion--inline-completion]. The column of the model containing the strings. Note that the strings must be UTF-8. Gets emitted when an action is activated. the index of the activated action Gets emitted when a match from the cursor is on a match of the list. The default behaviour is to replace the contents of the entry with the contents of the text column in the row pointed to by @iter. Note that @model is the model that was passed to gtk_entry_completion_set_model(). %TRUE if the signal has been handled the #GtkTreeModel containing the matches a #GtkTreeIter positioned at the selected match Gets emitted when the inline autocompletion is triggered. The default behaviour is to make the entry display the whole prefix and select the newly inserted part. Applications may connect to this signal in order to insert only a smaller part of the @prefix into the entry - e.g. the entry used in the #GtkFileChooser inserts only the part of the prefix up to the next '/'. %TRUE if the signal has been handled the common prefix of all possible completions Gets emitted when a match from the list is selected. The default behaviour is to replace the contents of the entry with the contents of the text column in the row pointed to by @iter. Note that @model is the model that was passed to gtk_entry_completion_set_model(). %TRUE if the signal has been handled the #GtkTreeModel containing the matches a #GtkTreeIter positioned at the selected match Gets emitted when the filter model has zero number of rows in completion_complete method. (In other words when GtkEntryCompletion is out of suggestions) A function which decides whether the row indicated by @iter matches a given @key, and should be displayed as a possible completion for @key. Note that @key is normalized and case-folded (see g_utf8_normalize() and g_utf8_casefold()). If this is not appropriate, match functions have access to the unmodified key via `gtk_entry_get_text (GTK_ENTRY (gtk_entry_completion_get_entry ()))`. %TRUE if @iter should be displayed as a possible completion for @key the #GtkEntryCompletion the string to match, normalized and case-folded a #GtkTreeIter indicating the row to match user data given to gtk_entry_completion_set_match_func() Specifies the side of the entry at which an icon is placed. At the beginning of the entry (depending on the text direction). At the end of the entry (depending on the text direction). The #GtkEventBox widget is a subclass of #GtkBin which also has its own window. It is useful since it allows you to catch events for widgets which do not have their own window. Creates a new #GtkEventBox. a new #GtkEventBox Returns whether the event box window is above or below the windows of its child. See gtk_event_box_set_above_child() for details. %TRUE if the event box window is above the window of its child a #GtkEventBox Returns whether the event box has a visible window. See gtk_event_box_set_visible_window() for details. %TRUE if the event box window is visible a #GtkEventBox Set whether the event box window is positioned above the windows of its child, as opposed to below it. If the window is above, all events inside the event box will go to the event box. If the window is below, events in windows of child widgets will first got to that widget, and then to its parents. The default is to keep the window below the child. a #GtkEventBox %TRUE if the event box window is above its child Set whether the event box uses a visible or invisible child window. The default is to use visible windows. In an invisible window event box, the window that the event box creates is a %GDK_INPUT_ONLY window, which means that it is invisible and only serves to receive events. A visible window event box creates a visible (%GDK_INPUT_OUTPUT) window that acts as the parent window for all the widgets contained in the event box. You should generally make your event box invisible if you just want to trap events. Creating a visible window may cause artifacts that are visible to the user, especially if the user is using a theme with gradients or pixmaps. The main reason to create a non input-only event box is if you want to set the background to a different color or draw on it. There is one unexpected issue for an invisible event box that has its window below the child. (See gtk_event_box_set_above_child().) Since the input-only window is not an ancestor window of any windows that descendent widgets of the event box create, events on these windows aren’t propagated up by the windowing system, but only by GTK+. The practical effect of this is if an event isn’t in the event mask for the descendant window (see gtk_widget_add_events()), it won’t be received by the event box. This problem doesn’t occur for visible event boxes, because in that case, the event box window is actually the ancestor of the descendant windows, not just at the same place on the screen. a #GtkEventBox %TRUE to make the event box have a visible window The parent class. #GtkEventController is a base, low-level implementation for event controllers. Those react to a series of #GdkEvents, and possibly trigger actions as a consequence of those. Gets the propagation phase at which @controller handles events. the propagation phase a #GtkEventController Returns the #GtkWidget this controller relates to. a #GtkWidget a #GtkEventController Feeds an events into @controller, so it can be interpreted and the controller actions triggered. %TRUE if the event was potentially useful to trigger the controller action a #GtkEventController a #GdkEvent Resets the @controller to a clean state. Every interaction the controller did through #GtkEventController::handle-event will be dropped at this point. a #GtkEventController Sets the propagation phase at which a controller handles events. If @phase is %GTK_PHASE_NONE, no automatic event handling will be performed, but other additional gesture maintenance will. In that phase, the events can be managed by calling gtk_event_controller_handle_event(). a #GtkEventController a propagation phase The propagation phase at which this controller will handle events. The widget receiving the #GdkEvents that the controller will handle. #GtkEventControllerKey is an event controller meant for situations where you need access to key events. This object was added in 3.24. Gets the IM context of a key controller. the IM context a #GtkEventControllerKey This signal is emitted whenever a key is pressed. %TRUE if the key press was handled, %FALSE otherwise. the pressed key. the raw code of the pressed key. the bitmask, representing the state of modifier keys and pointer buttons. See #GdkModifierType. This signal is emitted whenever a key is released. the released key. the raw code of the released key. the bitmask, representing the state of modifier keys and pointer buttons. See #GdkModifierType. #GtkEventControllerMotion is an event controller meant for situations where you need to track the position of the pointer. This object was added in 3.24. Creates a new event controller that will handle motion events for the given @widget. a new #GtkEventControllerMotion a #GtkWidget Signals that the pointer has entered the widget. the x coordinate the y coordinate Signals that pointer has left the widget. Emitted when the pointer moves inside the widget. the x coordinate the y coordinate #GtkEventControllerScroll is an event controller meant to handle scroll events from mice and touchpads. It is capable of handling both discrete and continuous scroll events, abstracting them both on the #GtkEventControllerScroll::scroll signal (deltas in the discrete case are multiples of 1). In the case of continuous scroll events, #GtkEventControllerScroll encloses all #GtkEventControllerScroll::scroll events between two #GtkEventControllerScroll::scroll-begin and #GtkEventControllerScroll::scroll-end signals. The behavior of the event controller can be modified by the flags given at creation time, or modified at a later point through gtk_event_controller_scroll_set_flags() (e.g. because the scrolling conditions of the widget changed). The controller can be set up to emit motion for either/both vertical and horizontal scroll events through #GTK_EVENT_CONTROLLER_SCROLL_VERTICAL, #GTK_EVENT_CONTROLLER_SCROLL_HORIZONTAL and #GTK_EVENT_CONTROLLER_SCROLL_BOTH. If any axis is disabled, the respective #GtkEventControllerScroll::scroll delta will be 0. Vertical scroll events will be translated to horizontal motion for the devices incapable of horizontal scrolling. The event controller can also be forced to emit discrete events on all devices through #GTK_EVENT_CONTROLLER_SCROLL_DISCRETE. This can be used to implement discrete actions triggered through scroll events (e.g. switching across combobox options). The #GTK_EVENT_CONTROLLER_SCROLL_KINETIC flag toggles the emission of the #GtkEventControllerScroll::decelerate signal, emitted at the end of scrolling with two X/Y velocity arguments that are consistent with the motion that was received. This object was added in 3.24. Creates a new event controller that will handle scroll events for the given @widget. a new #GtkEventControllerScroll a #GtkWidget behavior flags Gets the flags conditioning the scroll controller behavior. the controller flags. Sets the flags conditioning scroll controller behavior. behavior flags The flags affecting event controller behavior Emitted after scroll is finished if the #GTK_EVENT_CONTROLLER_SCROLL_KINETIC flag is set. @vel_x and @vel_y express the initial velocity that was imprinted by the scroll events. @vel_x and @vel_y are expressed in pixels/ms. X velocity Y velocity Signals that the widget should scroll by the amount specified by @dx and @dy. X delta Y delta Signals that a new scrolling operation has begun. It will only be emitted on devices capable of it. Signals that a new scrolling operation has finished. It will only be emitted on devices capable of it. Describes the behavior of a #GtkEventControllerScroll. Don't emit scroll. Emit scroll with vertical deltas. Emit scroll with horizontal deltas. Only emit deltas that are multiples of 1. Emit #GtkEventControllerScroll::decelerate after continuous scroll finishes. Emit scroll on both axes. Describes the state of a #GdkEventSequence in a #GtkGesture. The sequence is handled, but not grabbed. The sequence is handled and grabbed. The sequence is denied. A #GtkExpander allows the user to hide or show its child by clicking on an expander triangle similar to the triangles used in a #GtkTreeView. Normally you use an expander as you would use any other descendant of #GtkBin; you create the child widget and use gtk_container_add() to add it to the expander. When the expander is toggled, it will take care of showing and hiding the child automatically. # Special Usage There are situations in which you may prefer to show and hide the expanded widget yourself, such as when you want to actually create the widget at expansion time. In this case, create a #GtkExpander but do not add a child to it. The expander widget has an #GtkExpander:expanded property which can be used to monitor its expansion state. You should watch this property with a signal connection as follows: |[<!-- language="C" --> static void expander_callback (GObject *object, GParamSpec *param_spec, gpointer user_data) { GtkExpander *expander; expander = GTK_EXPANDER (object); if (gtk_expander_get_expanded (expander)) { // Show or create widgets } else { // Hide or destroy widgets } } static void create_expander (void) { GtkWidget *expander = gtk_expander_new_with_mnemonic ("_More Options"); g_signal_connect (expander, "notify::expanded", G_CALLBACK (expander_callback), NULL); // ... } ]| # GtkExpander as GtkBuildable The GtkExpander implementation of the GtkBuildable interface supports placing a child in the label position by specifying “label” as the “type” attribute of a <child> element. A normal content child can be specified without specifying a <child> type attribute. An example of a UI definition fragment with GtkExpander: |[ <object class="GtkExpander"> <child type="label"> <object class="GtkLabel" id="expander-label"/> </child> <child> <object class="GtkEntry" id="expander-content"/> </child> </object> ]| # CSS nodes |[<!-- language="plain" --> expander ├── title │ ├── arrow │ ╰── <label widget> ╰── <child> ]| GtkExpander has three CSS nodes, the main node with the name expander, a subnode with name title and node below it with name arrow. The arrow of an expander that is showing its child gets the :checked pseudoclass added to it. Creates a new expander using @label as the text of the label. a new #GtkExpander widget. the text of the label Creates a new expander using @label as the text of the label. If characters in @label are preceded by an underscore, they are underlined. If you need a literal underscore character in a label, use “__” (two underscores). The first underlined character represents a keyboard accelerator called a mnemonic. Pressing Alt and that key activates the button. a new #GtkExpander widget. the text of the label with an underscore in front of the mnemonic character Queries a #GtkExpander and returns its current state. Returns %TRUE if the child widget is revealed. See gtk_expander_set_expanded(). the current state of the expander a #GtkExpander Fetches the text from a label widget including any embedded underlines indicating mnemonics and Pango markup, as set by gtk_expander_set_label(). If the label text has not been set the return value will be %NULL. This will be the case if you create an empty button with gtk_button_new() to use as a container. Note that this function behaved differently in versions prior to 2.14 and used to return the label text stripped of embedded underlines indicating mnemonics and Pango markup. This problem can be avoided by fetching the label text directly from the label widget. The text of the label widget. This string is owned by the widget and must not be modified or freed. a #GtkExpander Returns whether the label widget will fill all available horizontal space allocated to @expander. %TRUE if the label widget will fill all available horizontal space a #GtkExpander Retrieves the label widget for the frame. See gtk_expander_set_label_widget(). the label widget, or %NULL if there is none a #GtkExpander Returns whether the expander will resize the toplevel widget containing the expander upon resizing and collpasing. the “resize toplevel” setting. a #GtkExpander Gets the value set by gtk_expander_set_spacing(). Use margins on the child instead. spacing between the expander and child a #GtkExpander Returns whether the label’s text is interpreted as marked up with the [Pango text markup language][PangoMarkupFormat]. See gtk_expander_set_use_markup(). %TRUE if the label’s text will be parsed for markup a #GtkExpander Returns whether an embedded underline in the expander label indicates a mnemonic. See gtk_expander_set_use_underline(). %TRUE if an embedded underline in the expander label indicates the mnemonic accelerator keys a #GtkExpander Sets the state of the expander. Set to %TRUE, if you want the child widget to be revealed, and %FALSE if you want the child widget to be hidden. a #GtkExpander whether the child widget is revealed Sets the text of the label of the expander to @label. This will also clear any previously set labels. a #GtkExpander a string Sets whether the label widget should fill all available horizontal space allocated to @expander. Note that this function has no effect since 3.20. a #GtkExpander %TRUE if the label should should fill all available horizontal space Set the label widget for the expander. This is the widget that will appear embedded alongside the expander arrow. a #GtkExpander the new label widget Sets whether the expander will resize the toplevel widget containing the expander upon resizing and collpasing. a #GtkExpander whether to resize the toplevel Sets the spacing field of @expander, which is the number of pixels to place between expander and the child. Use margins on the child instead. a #GtkExpander distance between the expander and child in pixels Sets whether the text of the label contains markup in [Pango’s text markup language][PangoMarkupFormat]. See gtk_label_set_markup(). a #GtkExpander %TRUE if the label’s text should be parsed for markup If true, an underline in the text of the expander label indicates the next character should be used for the mnemonic accelerator key. a #GtkExpander %TRUE if underlines in the text indicate mnemonics Whether the label widget should fill all available horizontal space. Note that this property is ignored since 3.20. When this property is %TRUE, the expander will resize the toplevel widget containing the expander upon expanding and collapsing. Space to put between the label and the child when the expander is expanded. This property is deprecated and ignored. Use margins on the child instead. The parent class. Used to specify the style of the expanders drawn by a #GtkTreeView. The style used for a collapsed subtree. Intermediate style used during animation. Intermediate style used during animation. The style used for an expanded subtree. #GtkFileChooser is an interface that can be implemented by file selection widgets. In GTK+, the main objects that implement this interface are #GtkFileChooserWidget, #GtkFileChooserDialog, and #GtkFileChooserButton. You do not need to write an object that implements the #GtkFileChooser interface unless you are trying to adapt an existing file selector to expose a standard programming interface. #GtkFileChooser allows for shortcuts to various places in the filesystem. In the default implementation these are displayed in the left pane. It may be a bit confusing at first that these shortcuts come from various sources and in various flavours, so lets explain the terminology here: - Bookmarks: are created by the user, by dragging folders from the right pane to the left pane, or by using the “Add”. Bookmarks can be renamed and deleted by the user. - Shortcuts: can be provided by the application. For example, a Paint program may want to add a shortcut for a Clipart folder. Shortcuts cannot be modified by the user. - Volumes: are provided by the underlying filesystem abstraction. They are the “roots” of the filesystem. # File Names and Encodings When the user is finished selecting files in a #GtkFileChooser, your program can get the selected names either as filenames or as URIs. For URIs, the normal escaping rules are applied if the URI contains non-ASCII characters. However, filenames are always returned in the character set specified by the `G_FILENAME_ENCODING` environment variable. Please see the GLib documentation for more details about this variable. This means that while you can pass the result of gtk_file_chooser_get_filename() to g_open() or g_fopen(), you may not be able to directly set it as the text of a #GtkLabel widget unless you convert it first to UTF-8, which all GTK+ widgets expect. You should use g_filename_to_utf8() to convert filenames into strings that can be passed to GTK+ widgets. # Adding a Preview Widget You can add a custom preview widget to a file chooser and then get notification about when the preview needs to be updated. To install a preview widget, use gtk_file_chooser_set_preview_widget(). Then, connect to the #GtkFileChooser::update-preview signal to get notified when you need to update the contents of the preview. Your callback should use gtk_file_chooser_get_preview_filename() to see what needs previewing. Once you have generated the preview for the corresponding file, you must call gtk_file_chooser_set_preview_widget_active() with a boolean flag that indicates whether your callback could successfully generate a preview. ## Example: Using a Preview Widget ## {#gtkfilechooser-preview} |[<!-- language="C" --> { GtkImage *preview; ... preview = gtk_image_new (); gtk_file_chooser_set_preview_widget (my_file_chooser, preview); g_signal_connect (my_file_chooser, "update-preview", G_CALLBACK (update_preview_cb), preview); } static void update_preview_cb (GtkFileChooser *file_chooser, gpointer data) { GtkWidget *preview; char *filename; GdkPixbuf *pixbuf; gboolean have_preview; preview = GTK_WIDGET (data); filename = gtk_file_chooser_get_preview_filename (file_chooser); pixbuf = gdk_pixbuf_new_from_file_at_size (filename, 128, 128, NULL); have_preview = (pixbuf != NULL); g_free (filename); gtk_image_set_from_pixbuf (GTK_IMAGE (preview), pixbuf); if (pixbuf) g_object_unref (pixbuf); gtk_file_chooser_set_preview_widget_active (file_chooser, have_preview); } ]| # Adding Extra Widgets You can add extra widgets to a file chooser to provide options that are not present in the default design. For example, you can add a toggle button to give the user the option to open a file in read-only mode. You can use gtk_file_chooser_set_extra_widget() to insert additional widgets in a file chooser. An example for adding extra widgets: |[<!-- language="C" --> GtkWidget *toggle; ... toggle = gtk_check_button_new_with_label ("Open file read-only"); gtk_widget_show (toggle); gtk_file_chooser_set_extra_widget (my_file_chooser, toggle); } ]| If you want to set more than one extra widget in the file chooser, you can a container such as a #GtkBox or a #GtkGrid and include your widgets in it. Then, set the container as the whole extra widget. Adds a 'choice' to the file chooser. This is typically implemented as a combobox or, for boolean choices, as a checkbutton. You can select a value using gtk_file_chooser_set_choice() before the dialog is shown, and you can obtain the user-selected value in the ::response signal handler using gtk_file_chooser_get_choice(). Compare gtk_file_chooser_set_extra_widget(). a #GtkFileChooser id for the added choice user-visible label for the added choice ids for the options of the choice, or %NULL for a boolean choice user-visible labels for the options, must be the same length as @options Adds @filter to the list of filters that the user can select between. When a filter is selected, only files that are passed by that filter are displayed. Note that the @chooser takes ownership of the filter, so you have to ref and sink it if you want to keep a reference. a #GtkFileChooser a #GtkFileFilter Adds a folder to be displayed with the shortcut folders in a file chooser. Note that shortcut folders do not get saved, as they are provided by the application. For example, you can use this to add a “/usr/share/mydrawprogram/Clipart” folder to the volume list. %TRUE if the folder could be added successfully, %FALSE otherwise. In the latter case, the @error will be set as appropriate. a #GtkFileChooser filename of the folder to add Adds a folder URI to be displayed with the shortcut folders in a file chooser. Note that shortcut folders do not get saved, as they are provided by the application. For example, you can use this to add a “file:///usr/share/mydrawprogram/Clipart” folder to the volume list. %TRUE if the folder could be added successfully, %FALSE otherwise. In the latter case, the @error will be set as appropriate. a #GtkFileChooser URI of the folder to add Gets the type of operation that the file chooser is performing; see gtk_file_chooser_set_action(). the action that the file selector is performing a #GtkFileChooser Gets the currently selected option in the 'choice' with the given ID. the ID of the currenly selected option a #GtkFileChooser the ID of the choice to get Gets whether file choser will offer to create new folders. See gtk_file_chooser_set_create_folders(). %TRUE if the Create Folder button should be displayed. a #GtkFileChooser Gets the current folder of @chooser as a local filename. See gtk_file_chooser_set_current_folder(). Note that this is the folder that the file chooser is currently displaying (e.g. "/home/username/Documents"), which is not the same as the currently-selected folder if the chooser is in %GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER mode (e.g. "/home/username/Documents/selected-folder/". To get the currently-selected folder in that mode, use gtk_file_chooser_get_uri() as the usual way to get the selection. the full path of the current folder, or %NULL if the current path cannot be represented as a local filename. Free with g_free(). This function will also return %NULL if the file chooser was unable to load the last folder that was requested from it; for example, as would be for calling gtk_file_chooser_set_current_folder() on a nonexistent folder. a #GtkFileChooser Gets the current folder of @chooser as #GFile. See gtk_file_chooser_get_current_folder_uri(). the #GFile for the current folder. a #GtkFileChooser Gets the current folder of @chooser as an URI. See gtk_file_chooser_set_current_folder_uri(). Note that this is the folder that the file chooser is currently displaying (e.g. "file:///home/username/Documents"), which is not the same as the currently-selected folder if the chooser is in %GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER mode (e.g. "file:///home/username/Documents/selected-folder/". To get the currently-selected folder in that mode, use gtk_file_chooser_get_uri() as the usual way to get the selection. the URI for the current folder. Free with g_free(). This function will also return %NULL if the file chooser was unable to load the last folder that was requested from it; for example, as would be for calling gtk_file_chooser_set_current_folder_uri() on a nonexistent folder. a #GtkFileChooser Gets the current name in the file selector, as entered by the user in the text entry for “Name”. This is meant to be used in save dialogs, to get the currently typed filename when the file itself does not exist yet. For example, an application that adds a custom extra widget to the file chooser for “file format” may want to change the extension of the typed filename based on the chosen format, say, from “.jpg” to “.png”. The raw text from the file chooser’s “Name” entry. Free this with g_free(). Note that this string is not a full pathname or URI; it is whatever the contents of the entry are. Note also that this string is in UTF-8 encoding, which is not necessarily the system’s encoding for filenames. a #GtkFileChooser Queries whether a file chooser is set to confirm for overwriting when the user types a file name that already exists. %TRUE if the file chooser will present a confirmation dialog; %FALSE otherwise. a #GtkFileChooser Gets the current extra widget; see gtk_file_chooser_set_extra_widget(). the current extra widget, or %NULL a #GtkFileChooser Gets the #GFile for the currently selected file in the file selector. If multiple files are selected, one of the files will be returned at random. If the file chooser is in folder mode, this function returns the selected folder. a selected #GFile. You own the returned file; use g_object_unref() to release it. a #GtkFileChooser Gets the filename for the currently selected file in the file selector. The filename is returned as an absolute path. If multiple files are selected, one of the filenames will be returned at random. If the file chooser is in folder mode, this function returns the selected folder. The currently selected filename, or %NULL if no file is selected, or the selected file can't be represented with a local filename. Free with g_free(). a #GtkFileChooser Lists all the selected files and subfolders in the current folder of @chooser. The returned names are full absolute paths. If files in the current folder cannot be represented as local filenames they will be ignored. (See gtk_file_chooser_get_uris()) a #GSList containing the filenames of all selected files and subfolders in the current folder. Free the returned list with g_slist_free(), and the filenames with g_free(). a #GtkFileChooser Lists all the selected files and subfolders in the current folder of @chooser as #GFile. An internal function, see gtk_file_chooser_get_uris(). a #GSList containing a #GFile for each selected file and subfolder in the current folder. Free the returned list with g_slist_free(), and the files with g_object_unref(). a #GtkFileChooser Gets the current filter; see gtk_file_chooser_set_filter(). the current filter, or %NULL a #GtkFileChooser Gets whether only local files can be selected in the file selector. See gtk_file_chooser_set_local_only() %TRUE if only local files can be selected. a #GtkFileChooser Gets the #GFile that should be previewed in a custom preview Internal function, see gtk_file_chooser_get_preview_uri(). the #GFile for the file to preview, or %NULL if no file is selected. Free with g_object_unref(). a #GtkFileChooser Gets the filename that should be previewed in a custom preview widget. See gtk_file_chooser_set_preview_widget(). the filename to preview, or %NULL if no file is selected, or if the selected file cannot be represented as a local filename. Free with g_free() a #GtkFileChooser Gets the URI that should be previewed in a custom preview widget. See gtk_file_chooser_set_preview_widget(). the URI for the file to preview, or %NULL if no file is selected. Free with g_free(). a #GtkFileChooser Gets the current preview widget; see gtk_file_chooser_set_preview_widget(). the current preview widget, or %NULL a #GtkFileChooser Gets whether the preview widget set by gtk_file_chooser_set_preview_widget() should be shown for the current filename. See gtk_file_chooser_set_preview_widget_active(). %TRUE if the preview widget is active for the current filename. a #GtkFileChooser Gets whether multiple files can be selected in the file selector. See gtk_file_chooser_set_select_multiple(). %TRUE if multiple files can be selected. a #GtkFileChooser Gets whether hidden files and folders are displayed in the file selector. See gtk_file_chooser_set_show_hidden(). %TRUE if hidden files and folders are displayed. a #GtkFileChooser Gets the URI for the currently selected file in the file selector. If multiple files are selected, one of the filenames will be returned at random. If the file chooser is in folder mode, this function returns the selected folder. The currently selected URI, or %NULL if no file is selected. If gtk_file_chooser_set_local_only() is set to %TRUE (the default) a local URI will be returned for any FUSE locations. Free with g_free() a #GtkFileChooser Lists all the selected files and subfolders in the current folder of @chooser. The returned names are full absolute URIs. a #GSList containing the URIs of all selected files and subfolders in the current folder. Free the returned list with g_slist_free(), and the filenames with g_free(). a #GtkFileChooser Gets whether a stock label should be drawn with the name of the previewed file. See gtk_file_chooser_set_use_preview_label(). %TRUE if the file chooser is set to display a label with the name of the previewed file, %FALSE otherwise. a #GtkFileChooser Lists the current set of user-selectable filters; see gtk_file_chooser_add_filter(), gtk_file_chooser_remove_filter(). a #GSList containing the current set of user selectable filters. The contents of the list are owned by GTK+, but you must free the list itself with g_slist_free() when you are done with it. a #GtkFileChooser Queries the list of shortcut folders in the file chooser, as set by gtk_file_chooser_add_shortcut_folder_uri(). A list of folder URIs, or %NULL if there are no shortcut folders. Free the returned list with g_slist_free(), and the URIs with g_free(). a #GtkFileChooser Queries the list of shortcut folders in the file chooser, as set by gtk_file_chooser_add_shortcut_folder(). A list of folder filenames, or %NULL if there are no shortcut folders. Free the returned list with g_slist_free(), and the filenames with g_free(). a #GtkFileChooser Removes a 'choice' that has been added with gtk_file_chooser_add_choice(). a #GtkFileChooser the ID of the choice to remove Removes @filter from the list of filters that the user can select between. a #GtkFileChooser a #GtkFileFilter Removes a folder from a file chooser’s list of shortcut folders. %TRUE if the operation succeeds, %FALSE otherwise. In the latter case, the @error will be set as appropriate. See also: gtk_file_chooser_add_shortcut_folder() a #GtkFileChooser filename of the folder to remove Removes a folder URI from a file chooser’s list of shortcut folders. %TRUE if the operation succeeds, %FALSE otherwise. In the latter case, the @error will be set as appropriate. See also: gtk_file_chooser_add_shortcut_folder_uri() a #GtkFileChooser URI of the folder to remove Selects all the files in the current folder of a file chooser. a #GtkFileChooser Selects the file referred to by @file. An internal function. See _gtk_file_chooser_select_uri(). Not useful. a #GtkFileChooser the file to select Selects a filename. If the file name isn’t in the current folder of @chooser, then the current folder of @chooser will be changed to the folder containing @filename. Not useful. See also: gtk_file_chooser_set_filename() a #GtkFileChooser the filename to select Selects the file to by @uri. If the URI doesn’t refer to a file in the current folder of @chooser, then the current folder of @chooser will be changed to the folder containing @filename. Not useful. a #GtkFileChooser the URI to select Sets the type of operation that the chooser is performing; the user interface is adapted to suit the selected action. For example, an option to create a new folder might be shown if the action is %GTK_FILE_CHOOSER_ACTION_SAVE but not if the action is %GTK_FILE_CHOOSER_ACTION_OPEN. a #GtkFileChooser the action that the file selector is performing Selects an option in a 'choice' that has been added with gtk_file_chooser_add_choice(). For a boolean choice, the possible options are "true" and "false". a #GtkFileChooser the ID of the choice to set the ID of the option to select Sets whether file choser will offer to create new folders. This is only relevant if the action is not set to be %GTK_FILE_CHOOSER_ACTION_OPEN. a #GtkFileChooser %TRUE if the Create Folder button should be displayed Sets the current folder for @chooser from a local filename. The user will be shown the full contents of the current folder, plus user interface elements for navigating to other folders. In general, you should not use this function. See the [section on setting up a file chooser dialog][gtkfilechooserdialog-setting-up] for the rationale behind this. Not useful. a #GtkFileChooser the full path of the new current folder Sets the current folder for @chooser from a #GFile. Internal function, see gtk_file_chooser_set_current_folder_uri(). %TRUE if the folder could be changed successfully, %FALSE otherwise. a #GtkFileChooser the #GFile for the new folder Sets the current folder for @chooser from an URI. The user will be shown the full contents of the current folder, plus user interface elements for navigating to other folders. In general, you should not use this function. See the [section on setting up a file chooser dialog][gtkfilechooserdialog-setting-up] for the rationale behind this. %TRUE if the folder could be changed successfully, %FALSE otherwise. a #GtkFileChooser the URI for the new current folder Sets the current name in the file selector, as if entered by the user. Note that the name passed in here is a UTF-8 string rather than a filename. This function is meant for such uses as a suggested name in a “Save As...” dialog. You can pass “Untitled.doc” or a similarly suitable suggestion for the @name. If you want to preselect a particular existing file, you should use gtk_file_chooser_set_filename() or gtk_file_chooser_set_uri() instead. Please see the documentation for those functions for an example of using gtk_file_chooser_set_current_name() as well. a #GtkFileChooser the filename to use, as a UTF-8 string Sets whether a file chooser in %GTK_FILE_CHOOSER_ACTION_SAVE mode will present a confirmation dialog if the user types a file name that already exists. This is %FALSE by default. If set to %TRUE, the @chooser will emit the #GtkFileChooser::confirm-overwrite signal when appropriate. If all you need is the stock confirmation dialog, set this property to %TRUE. You can override the way confirmation is done by actually handling the #GtkFileChooser::confirm-overwrite signal; please refer to its documentation for the details. a #GtkFileChooser whether to confirm overwriting in save mode Sets an application-supplied widget to provide extra options to the user. a #GtkFileChooser widget for extra options Sets @file as the current filename for the file chooser, by changing to the file’s parent folder and actually selecting the file in list. If the @chooser is in %GTK_FILE_CHOOSER_ACTION_SAVE mode, the file’s base name will also appear in the dialog’s file name entry. If the file name isn’t in the current folder of @chooser, then the current folder of @chooser will be changed to the folder containing @filename. This is equivalent to a sequence of gtk_file_chooser_unselect_all() followed by gtk_file_chooser_select_filename(). Note that the file must exist, or nothing will be done except for the directory change. If you are implementing a save dialog, you should use this function if you already have a file name to which the user may save; for example, when the user opens an existing file and then does Save As... If you don’t have a file name already — for example, if the user just created a new file and is saving it for the first time, do not call this function. Instead, use something similar to this: |[<!-- language="C" --> if (document_is_new) { // the user just created a new document gtk_file_chooser_set_current_folder_file (chooser, default_file_for_saving); gtk_file_chooser_set_current_name (chooser, "Untitled document"); } else { // the user edited an existing document gtk_file_chooser_set_file (chooser, existing_file); } ]| Not useful. a #GtkFileChooser the #GFile to set as current Sets @filename as the current filename for the file chooser, by changing to the file’s parent folder and actually selecting the file in list; all other files will be unselected. If the @chooser is in %GTK_FILE_CHOOSER_ACTION_SAVE mode, the file’s base name will also appear in the dialog’s file name entry. Note that the file must exist, or nothing will be done except for the directory change. You should use this function only when implementing a save dialog for which you already have a file name to which the user may save. For example, when the user opens an existing file and then does Save As... to save a copy or a modified version. If you don’t have a file name already — for example, if the user just created a new file and is saving it for the first time, do not call this function. Instead, use something similar to this: |[<!-- language="C" --> if (document_is_new) { // the user just created a new document gtk_file_chooser_set_current_name (chooser, "Untitled document"); } else { // the user edited an existing document gtk_file_chooser_set_filename (chooser, existing_filename); } ]| In the first case, the file chooser will present the user with useful suggestions as to where to save his new file. In the second case, the file’s existing location is already known, so the file chooser will use it. Not useful. a #GtkFileChooser the filename to set as current Sets the current filter; only the files that pass the filter will be displayed. If the user-selectable list of filters is non-empty, then the filter should be one of the filters in that list. Setting the current filter when the list of filters is empty is useful if you want to restrict the displayed set of files without letting the user change it. a #GtkFileChooser a #GtkFileFilter Sets whether only local files can be selected in the file selector. If @local_only is %TRUE (the default), then the selected file or files are guaranteed to be accessible through the operating systems native file system and therefore the application only needs to worry about the filename functions in #GtkFileChooser, like gtk_file_chooser_get_filename(), rather than the URI functions like gtk_file_chooser_get_uri(), On some systems non-native files may still be available using the native filesystem via a userspace filesystem (FUSE). a #GtkFileChooser %TRUE if only local files can be selected Sets an application-supplied widget to use to display a custom preview of the currently selected file. To implement a preview, after setting the preview widget, you connect to the #GtkFileChooser::update-preview signal, and call gtk_file_chooser_get_preview_filename() or gtk_file_chooser_get_preview_uri() on each change. If you can display a preview of the new file, update your widget and set the preview active using gtk_file_chooser_set_preview_widget_active(). Otherwise, set the preview inactive. When there is no application-supplied preview widget, or the application-supplied preview widget is not active, the file chooser will display no preview at all. a #GtkFileChooser widget for displaying preview. Sets whether the preview widget set by gtk_file_chooser_set_preview_widget() should be shown for the current filename. When @active is set to false, the file chooser may display an internally generated preview of the current file or it may display no preview at all. See gtk_file_chooser_set_preview_widget() for more details. a #GtkFileChooser whether to display the user-specified preview widget Sets whether multiple files can be selected in the file selector. This is only relevant if the action is set to be %GTK_FILE_CHOOSER_ACTION_OPEN or %GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER. a #GtkFileChooser %TRUE if multiple files can be selected. Sets whether hidden files and folders are displayed in the file selector. a #GtkFileChooser %TRUE if hidden files and folders should be displayed. Sets the file referred to by @uri as the current file for the file chooser, by changing to the URI’s parent folder and actually selecting the URI in the list. If the @chooser is %GTK_FILE_CHOOSER_ACTION_SAVE mode, the URI’s base name will also appear in the dialog’s file name entry. Note that the URI must exist, or nothing will be done except for the directory change. You should use this function only when implementing a save dialog for which you already have a file name to which the user may save. For example, when the user opens an existing file and then does Save As... to save a copy or a modified version. If you don’t have a file name already — for example, if the user just created a new file and is saving it for the first time, do not call this function. Instead, use something similar to this: |[<!-- language="C" --> if (document_is_new) { // the user just created a new document gtk_file_chooser_set_current_name (chooser, "Untitled document"); } else { // the user edited an existing document gtk_file_chooser_set_uri (chooser, existing_uri); } ]| In the first case, the file chooser will present the user with useful suggestions as to where to save his new file. In the second case, the file’s existing location is already known, so the file chooser will use it. Not useful. a #GtkFileChooser the URI to set as current Sets whether the file chooser should display a stock label with the name of the file that is being previewed; the default is %TRUE. Applications that want to draw the whole preview area themselves should set this to %FALSE and display the name themselves in their preview widget. See also: gtk_file_chooser_set_preview_widget() a #GtkFileChooser whether to display a stock label with the name of the previewed file Unselects all the files in the current folder of a file chooser. a #GtkFileChooser Unselects the file referred to by @file. If the file is not in the current directory, does not exist, or is otherwise not currently selected, does nothing. a #GtkFileChooser a #GFile Unselects a currently selected filename. If the filename is not in the current directory, does not exist, or is otherwise not currently selected, does nothing. a #GtkFileChooser the filename to unselect Unselects the file referred to by @uri. If the file is not in the current directory, does not exist, or is otherwise not currently selected, does nothing. a #GtkFileChooser the URI to unselect Whether a file chooser not in %GTK_FILE_CHOOSER_ACTION_OPEN mode will offer the user to create new folders. Whether a file chooser in %GTK_FILE_CHOOSER_ACTION_SAVE mode will present an overwrite confirmation dialog if the user selects a file name that already exists. This signal gets emitted whenever it is appropriate to present a confirmation dialog when the user has selected a file name that already exists. The signal only gets emitted when the file chooser is in %GTK_FILE_CHOOSER_ACTION_SAVE mode. Most applications just need to turn on the #GtkFileChooser:do-overwrite-confirmation property (or call the gtk_file_chooser_set_do_overwrite_confirmation() function), and they will automatically get a stock confirmation dialog. Applications which need to customize this behavior should do that, and also connect to the #GtkFileChooser::confirm-overwrite signal. A signal handler for this signal must return a #GtkFileChooserConfirmation value, which indicates the action to take. If the handler determines that the user wants to select a different filename, it should return %GTK_FILE_CHOOSER_CONFIRMATION_SELECT_AGAIN. If it determines that the user is satisfied with his choice of file name, it should return %GTK_FILE_CHOOSER_CONFIRMATION_ACCEPT_FILENAME. On the other hand, if it determines that the stock confirmation dialog should be used, it should return %GTK_FILE_CHOOSER_CONFIRMATION_CONFIRM. The following example illustrates this. ## Custom confirmation ## {#gtkfilechooser-confirmation} |[<!-- language="C" --> static GtkFileChooserConfirmation confirm_overwrite_callback (GtkFileChooser *chooser, gpointer data) { char *uri; uri = gtk_file_chooser_get_uri (chooser); if (is_uri_read_only (uri)) { if (user_wants_to_replace_read_only_file (uri)) return GTK_FILE_CHOOSER_CONFIRMATION_ACCEPT_FILENAME; else return GTK_FILE_CHOOSER_CONFIRMATION_SELECT_AGAIN; } else return GTK_FILE_CHOOSER_CONFIRMATION_CONFIRM; // fall back to the default dialog } ... chooser = gtk_file_chooser_dialog_new (...); gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (dialog), TRUE); g_signal_connect (chooser, "confirm-overwrite", G_CALLBACK (confirm_overwrite_callback), NULL); if (gtk_dialog_run (chooser) == GTK_RESPONSE_ACCEPT) save_to_file (gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (chooser)); gtk_widget_destroy (chooser); ]| a #GtkFileChooserConfirmation value that indicates which action to take after emitting the signal. This signal is emitted when the current folder in a #GtkFileChooser changes. This can happen due to the user performing some action that changes folders, such as selecting a bookmark or visiting a folder on the file list. It can also happen as a result of calling a function to explicitly change the current folder in a file chooser. Normally you do not need to connect to this signal, unless you need to keep track of which folder a file chooser is showing. See also: gtk_file_chooser_set_current_folder(), gtk_file_chooser_get_current_folder(), gtk_file_chooser_set_current_folder_uri(), gtk_file_chooser_get_current_folder_uri(). This signal is emitted when the user "activates" a file in the file chooser. This can happen by double-clicking on a file in the file list, or by pressing `Enter`. Normally you do not need to connect to this signal. It is used internally by #GtkFileChooserDialog to know when to activate the default button in the dialog. See also: gtk_file_chooser_get_filename(), gtk_file_chooser_get_filenames(), gtk_file_chooser_get_uri(), gtk_file_chooser_get_uris(). This signal is emitted when there is a change in the set of selected files in a #GtkFileChooser. This can happen when the user modifies the selection with the mouse or the keyboard, or when explicitly calling functions to change the selection. Normally you do not need to connect to this signal, as it is easier to wait for the file chooser to finish running, and then to get the list of selected files using the functions mentioned below. See also: gtk_file_chooser_select_filename(), gtk_file_chooser_unselect_filename(), gtk_file_chooser_get_filename(), gtk_file_chooser_get_filenames(), gtk_file_chooser_select_uri(), gtk_file_chooser_unselect_uri(), gtk_file_chooser_get_uri(), gtk_file_chooser_get_uris(). This signal is emitted when the preview in a file chooser should be regenerated. For example, this can happen when the currently selected file changes. You should use this signal if you want your file chooser to have a preview widget. Once you have installed a preview widget with gtk_file_chooser_set_preview_widget(), you should update it when this signal is emitted. You can use the functions gtk_file_chooser_get_preview_filename() or gtk_file_chooser_get_preview_uri() to get the name of the file to preview. Your widget may not be able to preview all kinds of files; your callback must call gtk_file_chooser_set_preview_widget_active() to inform the file chooser about whether the preview was generated successfully or not. Please see the example code in [Using a Preview Widget][gtkfilechooser-preview]. See also: gtk_file_chooser_set_preview_widget(), gtk_file_chooser_set_preview_widget_active(), gtk_file_chooser_set_use_preview_label(), gtk_file_chooser_get_preview_filename(), gtk_file_chooser_get_preview_uri(). Describes whether a #GtkFileChooser is being used to open existing files or to save to a possibly new file. Indicates open mode. The file chooser will only let the user pick an existing file. Indicates save mode. The file chooser will let the user pick an existing file, or type in a new filename. Indicates an Open mode for selecting folders. The file chooser will let the user pick an existing folder. Indicates a mode for creating a new folder. The file chooser will let the user name an existing or new folder. The #GtkFileChooserButton is a widget that lets the user select a file. It implements the #GtkFileChooser interface. Visually, it is a file name with a button to bring up a #GtkFileChooserDialog. The user can then use that dialog to change the file associated with that button. This widget does not support setting the #GtkFileChooser:select-multiple property to %TRUE. ## Create a button to let the user select a file in /etc |[<!-- language="C" --> { GtkWidget *button; button = gtk_file_chooser_button_new (_("Select a file"), GTK_FILE_CHOOSER_ACTION_OPEN); gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (button), "/etc"); } ]| The #GtkFileChooserButton supports the #GtkFileChooserActions %GTK_FILE_CHOOSER_ACTION_OPEN and %GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER. > The #GtkFileChooserButton will ellipsize the label, and will thus > request little horizontal space. To give the button more space, > you should call gtk_widget_get_preferred_size(), > gtk_file_chooser_button_set_width_chars(), or pack the button in > such a way that other interface elements give space to the > widget. # CSS nodes GtkFileChooserButton has a CSS node with name “filechooserbutton”, containing a subnode for the internal button with name “button” and style class “.file”. Creates a new file-selecting button widget. a new button widget. the title of the browse dialog. the open mode for the widget. Creates a #GtkFileChooserButton widget which uses @dialog as its file-picking window. Note that @dialog must be a #GtkDialog (or subclass) which implements the #GtkFileChooser interface and must not have %GTK_DIALOG_DESTROY_WITH_PARENT set. Also note that the dialog needs to have its confirmative button added with response %GTK_RESPONSE_ACCEPT or %GTK_RESPONSE_OK in order for the button to take over the file selected in the dialog. a new button widget. the widget to use as dialog Returns whether the button grabs focus when it is clicked with the mouse. See gtk_file_chooser_button_set_focus_on_click(). Use gtk_widget_get_focus_on_click() instead %TRUE if the button grabs focus when it is clicked with the mouse. a #GtkFileChooserButton Retrieves the title of the browse dialog used by @button. The returned value should not be modified or freed. a pointer to the browse dialog’s title. the button widget to examine. Retrieves the width in characters of the @button widget’s entry and/or label. an integer width (in characters) that the button will use to size itself. the button widget to examine. Sets whether the button will grab focus when it is clicked with the mouse. Making mouse clicks not grab focus is useful in places like toolbars where you don’t want the keyboard focus removed from the main area of the application. Use gtk_widget_set_focus_on_click() instead a #GtkFileChooserButton whether the button grabs focus when clicked with the mouse Modifies the @title of the browse dialog used by @button. the button widget to modify. the new browse dialog title. Sets the width (in characters) that @button will use to @n_chars. the button widget to examine. the new width, in characters. Instance of the #GtkFileChooserDialog associated with the button. Title to put on the #GtkFileChooserDialog associated with the button. The width of the entry and label inside the button, in characters. The ::file-set signal is emitted when the user selects a file. Note that this signal is only emitted when the user changes the file. The parent class. Used as a return value of handlers for the #GtkFileChooser::confirm-overwrite signal of a #GtkFileChooser. This value determines whether the file chooser will present the stock confirmation dialog, accept the user’s choice of a filename, or let the user choose another filename. The file chooser will present its stock dialog to confirm about overwriting an existing file. The file chooser will terminate and accept the user’s choice of a file name. The file chooser will continue running, so as to let the user select another file name. #GtkFileChooserDialog is a dialog box suitable for use with “File/Open” or “File/Save as” commands. This widget works by putting a #GtkFileChooserWidget inside a #GtkDialog. It exposes the #GtkFileChooser interface, so you can use all of the #GtkFileChooser functions on the file chooser dialog as well as those for #GtkDialog. Note that #GtkFileChooserDialog does not have any methods of its own. Instead, you should use the functions that work on a #GtkFileChooser. If you want to integrate well with the platform you should use the #GtkFileChooserNative API, which will use a platform-specific dialog if available and fall back to GtkFileChooserDialog otherwise. ## Typical usage ## {#gtkfilechooser-typical-usage} In the simplest of cases, you can the following code to use #GtkFileChooserDialog to select a file for opening: |[ GtkWidget *dialog; GtkFileChooserAction action = GTK_FILE_CHOOSER_ACTION_OPEN; gint res; dialog = gtk_file_chooser_dialog_new ("Open File", parent_window, action, _("_Cancel"), GTK_RESPONSE_CANCEL, _("_Open"), GTK_RESPONSE_ACCEPT, NULL); res = gtk_dialog_run (GTK_DIALOG (dialog)); if (res == GTK_RESPONSE_ACCEPT) { char *filename; GtkFileChooser *chooser = GTK_FILE_CHOOSER (dialog); filename = gtk_file_chooser_get_filename (chooser); open_file (filename); g_free (filename); } gtk_widget_destroy (dialog); ]| To use a dialog for saving, you can use this: |[ GtkWidget *dialog; GtkFileChooser *chooser; GtkFileChooserAction action = GTK_FILE_CHOOSER_ACTION_SAVE; gint res; dialog = gtk_file_chooser_dialog_new ("Save File", parent_window, action, _("_Cancel"), GTK_RESPONSE_CANCEL, _("_Save"), GTK_RESPONSE_ACCEPT, NULL); chooser = GTK_FILE_CHOOSER (dialog); gtk_file_chooser_set_do_overwrite_confirmation (chooser, TRUE); if (user_edited_a_new_document) gtk_file_chooser_set_current_name (chooser, _("Untitled document")); else gtk_file_chooser_set_filename (chooser, existing_filename); res = gtk_dialog_run (GTK_DIALOG (dialog)); if (res == GTK_RESPONSE_ACCEPT) { char *filename; filename = gtk_file_chooser_get_filename (chooser); save_to_file (filename); g_free (filename); } gtk_widget_destroy (dialog); ]| ## Setting up a file chooser dialog ## {#gtkfilechooserdialog-setting-up} There are various cases in which you may need to use a #GtkFileChooserDialog: - To select a file for opening. Use #GTK_FILE_CHOOSER_ACTION_OPEN. - To save a file for the first time. Use #GTK_FILE_CHOOSER_ACTION_SAVE, and suggest a name such as “Untitled” with gtk_file_chooser_set_current_name(). - To save a file under a different name. Use #GTK_FILE_CHOOSER_ACTION_SAVE, and set the existing filename with gtk_file_chooser_set_filename(). - To choose a folder instead of a file. Use #GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER. Note that old versions of the file chooser’s documentation suggested using gtk_file_chooser_set_current_folder() in various situations, with the intention of letting the application suggest a reasonable default folder. This is no longer considered to be a good policy, as now the file chooser is able to make good suggestions on its own. In general, you should only cause the file chooser to show a specific folder when it is appropriate to use gtk_file_chooser_set_filename(), i.e. when you are doing a Save As command and you already have a file saved somewhere. ## Response Codes ## {#gtkfilechooserdialog-responses} #GtkFileChooserDialog inherits from #GtkDialog, so buttons that go in its action area have response codes such as #GTK_RESPONSE_ACCEPT and #GTK_RESPONSE_CANCEL. For example, you could call gtk_file_chooser_dialog_new() as follows: |[ GtkWidget *dialog; GtkFileChooserAction action = GTK_FILE_CHOOSER_ACTION_OPEN; dialog = gtk_file_chooser_dialog_new ("Open File", parent_window, action, _("_Cancel"), GTK_RESPONSE_CANCEL, _("_Open"), GTK_RESPONSE_ACCEPT, NULL); ]| This will create buttons for “Cancel” and “Open” that use stock response identifiers from #GtkResponseType. For most dialog boxes you can use your own custom response codes rather than the ones in #GtkResponseType, but #GtkFileChooserDialog assumes that its “accept”-type action, e.g. an “Open” or “Save” button, will have one of the following response codes: - #GTK_RESPONSE_ACCEPT - #GTK_RESPONSE_OK - #GTK_RESPONSE_YES - #GTK_RESPONSE_APPLY This is because #GtkFileChooserDialog must intercept responses and switch to folders if appropriate, rather than letting the dialog terminate — the implementation uses these known response codes to know which responses can be blocked if appropriate. To summarize, make sure you use a [stock response code][gtkfilechooserdialog-responses] when you use #GtkFileChooserDialog to ensure proper operation. Creates a new #GtkFileChooserDialog. This function is analogous to gtk_dialog_new_with_buttons(). a new #GtkFileChooserDialog Title of the dialog, or %NULL Transient parent of the dialog, or %NULL Open or save mode for the dialog stock ID or text to go in the first button, or %NULL response ID for the first button, then additional (button, id) pairs, ending with %NULL These identify the various errors that can occur while calling #GtkFileChooser functions. Indicates that a file does not exist. Indicates a malformed filename. Indicates a duplicate path (e.g. when adding a bookmark). Indicates an incomplete hostname (e.g. "http://foo" without a slash after that). Registers an error quark for #GtkFileChooser if necessary. The error quark used for #GtkFileChooser errors. #GtkFileChooserNative is an abstraction of a dialog box suitable for use with “File/Open” or “File/Save as” commands. By default, this just uses a #GtkFileChooserDialog to implement the actual dialog. However, on certain platforms, such as Windows and macOS, the native platform file chooser is used instead. When the application is running in a sandboxed environment without direct filesystem access (such as Flatpak), #GtkFileChooserNative may call the proper APIs (portals) to let the user choose a file and make it available to the application. While the API of #GtkFileChooserNative closely mirrors #GtkFileChooserDialog, the main difference is that there is no access to any #GtkWindow or #GtkWidget for the dialog. This is required, as there may not be one in the case of a platform native dialog. Showing, hiding and running the dialog is handled by the #GtkNativeDialog functions. ## Typical usage ## {#gtkfilechoosernative-typical-usage} In the simplest of cases, you can the following code to use #GtkFileChooserDialog to select a file for opening: |[ GtkFileChooserNative *native; GtkFileChooserAction action = GTK_FILE_CHOOSER_ACTION_OPEN; gint res; native = gtk_file_chooser_native_new ("Open File", parent_window, action, "_Open", "_Cancel"); res = gtk_native_dialog_run (GTK_NATIVE_DIALOG (native)); if (res == GTK_RESPONSE_ACCEPT) { char *filename; GtkFileChooser *chooser = GTK_FILE_CHOOSER (native); filename = gtk_file_chooser_get_filename (chooser); open_file (filename); g_free (filename); } g_object_unref (native); ]| To use a dialog for saving, you can use this: |[ GtkFileChooserNative *native; GtkFileChooser *chooser; GtkFileChooserAction action = GTK_FILE_CHOOSER_ACTION_SAVE; gint res; native = gtk_file_chooser_native_new ("Save File", parent_window, action, "_Save", "_Cancel"); chooser = GTK_FILE_CHOOSER (native); gtk_file_chooser_set_do_overwrite_confirmation (chooser, TRUE); if (user_edited_a_new_document) gtk_file_chooser_set_current_name (chooser, _("Untitled document")); else gtk_file_chooser_set_filename (chooser, existing_filename); res = gtk_native_dialog_run (GTK_NATIVE_DIALOG (native)); if (res == GTK_RESPONSE_ACCEPT) { char *filename; filename = gtk_file_chooser_get_filename (chooser); save_to_file (filename); g_free (filename); } g_object_unref (native); ]| For more information on how to best set up a file dialog, see #GtkFileChooserDialog. ## Response Codes ## {#gtkfilechooserdialognative-responses} #GtkFileChooserNative inherits from #GtkNativeDialog, which means it will return #GTK_RESPONSE_ACCEPT if the user accepted, and #GTK_RESPONSE_CANCEL if he pressed cancel. It can also return #GTK_RESPONSE_DELETE_EVENT if the window was unexpectedly closed. ## Differences from #GtkFileChooserDialog ## {#gtkfilechooserdialognative-differences} There are a few things in the GtkFileChooser API that are not possible to use with #GtkFileChooserNative, as such use would prohibit the use of a native dialog. There is no support for the signals that are emitted when the user navigates in the dialog, including: * #GtkFileChooser::current-folder-changed * #GtkFileChooser::selection-changed * #GtkFileChooser::file-activated * #GtkFileChooser::confirm-overwrite You can also not use the methods that directly control user navigation: * gtk_file_chooser_unselect_filename() * gtk_file_chooser_select_all() * gtk_file_chooser_unselect_all() If you need any of the above you will have to use #GtkFileChooserDialog directly. No operations that change the the dialog work while the dialog is visible. Set all the properties that are required before showing the dialog. ## Win32 details ## {#gtkfilechooserdialognative-win32} On windows the IFileDialog implementation (added in Windows Vista) is used. It supports many of the features that #GtkFileChooserDialog does, but there are some things it does not handle: * Extra widgets added with gtk_file_chooser_set_extra_widget(). * Use of custom previews by connecting to #GtkFileChooser::update-preview. * Any #GtkFileFilter added using a mimetype or custom filter. If any of these features are used the regular #GtkFileChooserDialog will be used in place of the native one. ## Portal details ## {#gtkfilechooserdialognative-portal} When the org.freedesktop.portal.FileChooser portal is available on the session bus, it is used to bring up an out-of-process file chooser. Depending on the kind of session the application is running in, this may or may not be a GTK+ file chooser. In this situation, the following things are not supported and will be silently ignored: * Extra widgets added with gtk_file_chooser_set_extra_widget(). * Use of custom previews by connecting to #GtkFileChooser::update-preview. * Any #GtkFileFilter added with a custom filter. ## macOS details ## {#gtkfilechooserdialognative-macos} On macOS the NSSavePanel and NSOpenPanel classes are used to provide native file chooser dialogs. Some features provided by #GtkFileChooserDialog are not supported: * Extra widgets added with gtk_file_chooser_set_extra_widget(), unless the widget is an instance of GtkLabel, in which case the label text will be used to set the NSSavePanel message instance property. * Use of custom previews by connecting to #GtkFileChooser::update-preview. * Any #GtkFileFilter added with a custom filter. * Shortcut folders. Creates a new #GtkFileChooserNative. a new #GtkFileChooserNative Title of the native, or %NULL Transient parent of the native, or %NULL Open or save mode for the dialog text to go in the accept button, or %NULL for the default text to go in the cancel button, or %NULL for the default Retrieves the custom label text for the accept button. The custom label, or %NULL for the default. This string is owned by GTK+ and should not be modified or freed a #GtFileChooserNative Retrieves the custom label text for the cancel button. The custom label, or %NULL for the default. This string is owned by GTK+ and should not be modified or freed a #GtFileChooserNative Sets the custom label text for the accept button. If characters in @label are preceded by an underscore, they are underlined. If you need a literal underscore character in a label, use “__” (two underscores). The first underlined character represents a keyboard accelerator called a mnemonic. Pressing Alt and that key activates the button. a #GtFileChooserNative custom label or %NULL for the default Sets the custom label text for the cancel button. If characters in @label are preceded by an underscore, they are underlined. If you need a literal underscore character in a label, use “__” (two underscores). The first underlined character represents a keyboard accelerator called a mnemonic. Pressing Alt and that key activates the button. a #GtFileChooserNative custom label or %NULL for the default The text used for the label on the accept button in the dialog, or %NULL to use the default text. The text used for the label on the cancel button in the dialog, or %NULL to use the default text. #GtkFileChooserWidget is a widget for choosing files. It exposes the #GtkFileChooser interface, and you should use the methods of this interface to interact with the widget. # CSS nodes GtkFileChooserWidget has a single CSS node with name filechooser. Creates a new #GtkFileChooserWidget. This is a file chooser widget that can be embedded in custom windows, and it is the same widget that is used by #GtkFileChooserDialog. a new #GtkFileChooserWidget Open or save mode for the widget The ::desktop-folder signal is a [keybinding signal][GtkBindingSignal] which gets emitted when the user asks for it. This is used to make the file chooser show the user's Desktop folder in the file list. The default binding for this signal is `Alt + D`. The ::down-folder signal is a [keybinding signal][GtkBindingSignal] which gets emitted when the user asks for it. This is used to make the file chooser go to a child of the current folder in the file hierarchy. The subfolder that will be used is displayed in the path bar widget of the file chooser. For example, if the path bar is showing "/foo/bar/baz", with bar currently displayed, then this will cause the file chooser to switch to the "baz" subfolder. The default binding for this signal is `Alt + Down`. The ::home-folder signal is a [keybinding signal][GtkBindingSignal] which gets emitted when the user asks for it. This is used to make the file chooser show the user's home folder in the file list. The default binding for this signal is `Alt + Home`. The ::location-popup signal is a [keybinding signal][GtkBindingSignal] which gets emitted when the user asks for it. This is used to make the file chooser show a "Location" prompt which the user can use to manually type the name of the file he wishes to select. The default bindings for this signal are `Control + L` with a @path string of "" (the empty string). It is also bound to `/` with a @path string of "`/`" (a slash): this lets you type `/` and immediately type a path name. On Unix systems, this is bound to `~` (tilde) with a @path string of "~" itself for access to home directories. a string that gets put in the text entry for the file name The ::location-popup-on-paste signal is a [keybinding signal][GtkBindingSignal] which gets emitted when the user asks for it. This is used to make the file chooser show a "Location" prompt when the user pastes into a #GtkFileChooserWidget. The default binding for this signal is `Control + V`. The ::location-toggle-popup signal is a [keybinding signal][GtkBindingSignal] which gets emitted when the user asks for it. This is used to toggle the visibility of a "Location" prompt which the user can use to manually type the name of the file he wishes to select. The default binding for this signal is `Control + L`. The ::places-shortcut signal is a [keybinding signal][GtkBindingSignal] which gets emitted when the user asks for it. This is used to move the focus to the places sidebar. The default binding for this signal is `Alt + P`. The ::quick-bookmark signal is a [keybinding signal][GtkBindingSignal] which gets emitted when the user asks for it. This is used to make the file chooser switch to the bookmark specified in the @bookmark_index parameter. For example, if you have three bookmarks, you can pass 0, 1, 2 to this signal to switch to each of them, respectively. The default binding for this signal is `Alt + 1`, `Alt + 2`, etc. until `Alt + 0`. Note that in the default binding, that `Alt + 1` is actually defined to switch to the bookmark at index 0, and so on successively; `Alt + 0` is defined to switch to the bookmark at index 10. the number of the bookmark to switch to The ::recent-shortcut signal is a [keybinding signal][GtkBindingSignal] which gets emitted when the user asks for it. This is used to make the file chooser show the Recent location. The default binding for this signal is `Alt + R`. The ::search-shortcut signal is a [keybinding signal][GtkBindingSignal] which gets emitted when the user asks for it. This is used to make the file chooser show the search entry. The default binding for this signal is `Alt + S`. The ::show-hidden signal is a [keybinding signal][GtkBindingSignal] which gets emitted when the user asks for it. This is used to make the file chooser display hidden files. The default binding for this signal is `Control + H`. The ::up-folder signal is a [keybinding signal][GtkBindingSignal] which gets emitted when the user asks for it. This is used to make the file chooser go to the parent of the current folder in the file hierarchy. The default binding for this signal is `Alt + Up`. The parent class. A GtkFileFilter can be used to restrict the files being shown in a #GtkFileChooser. Files can be filtered based on their name (with gtk_file_filter_add_pattern()), on their mime type (with gtk_file_filter_add_mime_type()), or by a custom filter function (with gtk_file_filter_add_custom()). Filtering by mime types handles aliasing and subclassing of mime types; e.g. a filter for text/plain also matches a file with mime type application/rtf, since application/rtf is a subclass of text/plain. Note that #GtkFileFilter allows wildcards for the subtype of a mime type, so you can e.g. filter for image/\*. Normally, filters are used by adding them to a #GtkFileChooser, see gtk_file_chooser_add_filter(), but it is also possible to manually use a filter on a file with gtk_file_filter_filter(). # GtkFileFilter as GtkBuildable The GtkFileFilter implementation of the GtkBuildable interface supports adding rules using the <mime-types>, <patterns> and <applications> elements and listing the rules within. Specifying a <mime-type> or <pattern> has the same effect as as calling gtk_file_filter_add_mime_type() or gtk_file_filter_add_pattern(). An example of a UI definition fragment specifying GtkFileFilter rules: |[ <object class="GtkFileFilter"> <mime-types> <mime-type>text/plain</mime-type> <mime-type>image/ *</mime-type> </mime-types> <patterns> <pattern>*.txt</pattern> <pattern>*.png</pattern> </patterns> </object> ]| Creates a new #GtkFileFilter with no rules added to it. Such a filter doesn’t accept any files, so is not particularly useful until you add rules with gtk_file_filter_add_mime_type(), gtk_file_filter_add_pattern(), or gtk_file_filter_add_custom(). To create a filter that accepts any file, use: |[<!-- language="C" --> GtkFileFilter *filter = gtk_file_filter_new (); gtk_file_filter_add_pattern (filter, "*"); ]| a new #GtkFileFilter Deserialize a file filter from an a{sv} variant in the format produced by gtk_file_filter_to_gvariant(). a new #GtkFileFilter object an a{sv} #GVariant Adds rule to a filter that allows files based on a custom callback function. The bitfield @needed which is passed in provides information about what sorts of information that the filter function needs; this allows GTK+ to avoid retrieving expensive information when it isn’t needed by the filter. a #GtkFileFilter bitfield of flags indicating the information that the custom filter function needs. callback function; if the function returns %TRUE, then the file will be displayed. data to pass to @func function to call to free @data when it is no longer needed. Adds a rule allowing a given mime type to @filter. A #GtkFileFilter name of a MIME type Adds a rule allowing a shell style glob to a filter. a #GtkFileFilter a shell style glob Adds a rule allowing image files in the formats supported by GdkPixbuf. a #GtkFileFilter Tests whether a file should be displayed according to @filter. The #GtkFileFilterInfo @filter_info should include the fields returned from gtk_file_filter_get_needed(). This function will not typically be used by applications; it is intended principally for use in the implementation of #GtkFileChooser. %TRUE if the file should be displayed a #GtkFileFilter a #GtkFileFilterInfo containing information about a file. Gets the human-readable name for the filter. See gtk_file_filter_set_name(). The human-readable name of the filter, or %NULL. This value is owned by GTK+ and must not be modified or freed. a #GtkFileFilter Gets the fields that need to be filled in for the #GtkFileFilterInfo passed to gtk_file_filter_filter() This function will not typically be used by applications; it is intended principally for use in the implementation of #GtkFileChooser. bitfield of flags indicating needed fields when calling gtk_file_filter_filter() a #GtkFileFilter Sets the human-readable name of the filter; this is the string that will be displayed in the file selector user interface if there is a selectable list of filters. a #GtkFileFilter the human-readable-name for the filter, or %NULL to remove any existing name. Serialize a file filter to an a{sv} variant. a new, floating, #GVariant a #GtkFileFilter These flags indicate what parts of a #GtkFileFilterInfo struct are filled or need to be filled. the filename of the file being tested the URI for the file being tested the string that will be used to display the file in the file chooser the mime type of the file The type of function that is used with custom filters, see gtk_file_filter_add_custom(). %TRUE if the file should be displayed a #GtkFileFilterInfo that is filled according to the @needed flags passed to gtk_file_filter_add_custom() user data passed to gtk_file_filter_add_custom() A #GtkFileFilterInfo-struct is used to pass information about the tested file to gtk_file_filter_filter(). Flags indicating which of the following fields need are filled the filename of the file being tested the URI for the file being tested the string that will be used to display the file in the file chooser the mime type of the file The #GtkFixed widget is a container which can place child widgets at fixed positions and with fixed sizes, given in pixels. #GtkFixed performs no automatic layout management. For most applications, you should not use this container! It keeps you from having to learn about the other GTK+ containers, but it results in broken applications. With #GtkFixed, the following things will result in truncated text, overlapping widgets, and other display bugs: - Themes, which may change widget sizes. - Fonts other than the one you used to write the app will of course change the size of widgets containing text; keep in mind that users may use a larger font because of difficulty reading the default, or they may be using a different OS that provides different fonts. - Translation of text into other languages changes its size. Also, display of non-English text will use a different font in many cases. In addition, #GtkFixed does not pay attention to text direction and thus may produce unwanted results if your app is run under right-to-left languages such as Hebrew or Arabic. That is: normally GTK+ will order containers appropriately for the text direction, e.g. to put labels to the right of the thing they label when using an RTL language, but it can’t do that with #GtkFixed. So if you need to reorder widgets depending on the text direction, you would need to manually detect it and adjust child positions accordingly. Finally, fixed positioning makes it kind of annoying to add/remove GUI elements, since you have to reposition all the other elements. This is a long-term maintenance problem for your application. If you know none of these things are an issue for your application, and prefer the simplicity of #GtkFixed, by all means use the widget. But you should be aware of the tradeoffs. See also #GtkLayout, which shares the ability to perform fixed positioning of child widgets and additionally adds custom drawing and scrollability. Creates a new #GtkFixed. a new #GtkFixed. Moves a child of a #GtkFixed container to the given position. a #GtkFixed. the child widget. the horizontal position to move the widget to. the vertical position to move the widget to. Adds a widget to a #GtkFixed container at the given position. a #GtkFixed. the widget to add. the horizontal position to place the widget at. the vertical position to place the widget at. A GtkFlowBox positions child widgets in sequence according to its orientation. For instance, with the horizontal orientation, the widgets will be arranged from left to right, starting a new row under the previous row when necessary. Reducing the width in this case will require more rows, so a larger height will be requested. Likewise, with the vertical orientation, the widgets will be arranged from top to bottom, starting a new column to the right when necessary. Reducing the height will require more columns, so a larger width will be requested. The size request of a GtkFlowBox alone may not be what you expect; if you need to be able to shrink it along both axes and dynamically reflow its children, you may have to wrap it in a #GtkScrolledWindow to enable that. The children of a GtkFlowBox can be dynamically sorted and filtered. Although a GtkFlowBox must have only #GtkFlowBoxChild children, you can add any kind of widget to it via gtk_container_add(), and a GtkFlowBoxChild widget will automatically be inserted between the box and the widget. Also see #GtkListBox. GtkFlowBox was added in GTK+ 3.12. # CSS nodes |[<!-- language="plain" --> flowbox ├── flowboxchild │ ╰── <child> ├── flowboxchild │ ╰── <child> ┊ ╰── [rubberband] ]| GtkFlowBox uses a single CSS node with name flowbox. GtkFlowBoxChild uses a single CSS node with name flowboxchild. For rubberband selection, a subnode with name rubberband is used. Creates a GtkFlowBox. a new #GtkFlowBox container Select all children of @box, if the selection mode allows it. a #GtkFlowBox Unselect all children of @box, if the selection mode allows it. a #GtkFlowBox Binds @model to @box. If @box was already bound to a model, that previous binding is destroyed. The contents of @box are cleared and then filled with widgets that represent items from @model. @box is updated whenever @model changes. If @model is %NULL, @box is left empty. It is undefined to add or remove widgets directly (for example, with gtk_flow_box_insert() or gtk_container_add()) while @box is bound to a model. Note that using a model is incompatible with the filtering and sorting functionality in GtkFlowBox. When using a model, filtering and sorting should be implemented by the model. a #GtkFlowBox the #GListModel to be bound to @box a function that creates widgets for items user data passed to @create_widget_func function for freeing @user_data Returns whether children activate on single clicks. %TRUE if children are activated on single click, %FALSE otherwise a #GtkFlowBox Gets the nth child in the @box. the child widget, which will always be a #GtkFlowBoxChild or %NULL in case no child widget with the given index exists. a #GtkFlowBox the position of the child Gets the child in the (@x, @y) position. the child widget, which will always be a #GtkFlowBoxChild or %NULL in case no child widget exists for the given x and y coordinates. a #GtkFlowBox the x coordinate of the child the y coordinate of the child Gets the horizontal spacing. the horizontal spacing a #GtkFlowBox Returns whether the box is homogeneous (all children are the same size). See gtk_box_set_homogeneous(). %TRUE if the box is homogeneous. a #GtkFlowBox Gets the maximum number of children per line. the maximum number of children per line a #GtkFlowBox Gets the minimum number of children per line. the minimum number of children per line a #GtkFlowBox Gets the vertical spacing. the vertical spacing a #GtkFlowBox Creates a list of all selected children. A #GList containing the #GtkWidget for each selected child. Free with g_list_free() when done. a #GtkFlowBox Gets the selection mode of @box. the #GtkSelectionMode a #GtkFlowBox Inserts the @widget into @box at @position. If a sort function is set, the widget will actually be inserted at the calculated position and this function has the same effect as gtk_container_add(). If @position is -1, or larger than the total number of children in the @box, then the @widget will be appended to the end. a #GtkFlowBox the #GtkWidget to add the position to insert @child in Updates the filtering for all children. Call this function when the result of the filter function on the @box is changed due ot an external factor. For instance, this would be used if the filter function just looked for a specific search term, and the entry with the string has changed. a #GtkFlowBox Updates the sorting for all children. Call this when the result of the sort function on @box is changed due to an external factor. a #GtkFlowBox Select all children of @box, if the selection mode allows it. a #GtkFlowBox Selects a single child of @box, if the selection mode allows it. a #GtkFlowBox a child of @box Calls a function for each selected child. Note that the selection cannot be modified from within this function. a #GtkFlowBox the function to call for each selected child user data to pass to the function If @single is %TRUE, children will be activated when you click on them, otherwise you need to double-click. a #GtkFlowBox %TRUE to emit child-activated on a single click Sets the horizontal space to add between children. See the #GtkFlowBox:column-spacing property. a #GtkFlowBox the spacing to use By setting a filter function on the @box one can decide dynamically which of the children to show. For instance, to implement a search function that only shows the children matching the search terms. The @filter_func will be called for each child after the call, and it will continue to be called each time a child changes (via gtk_flow_box_child_changed()) or when gtk_flow_box_invalidate_filter() is called. Note that using a filter function is incompatible with using a model (see gtk_flow_box_bind_model()). a #GtkFlowBox callback that lets you filter which children to show user data passed to @filter_func destroy notifier for @user_data Hooks up an adjustment to focus handling in @box. The adjustment is also used for autoscrolling during rubberband selection. See gtk_scrolled_window_get_hadjustment() for a typical way of obtaining the adjustment, and gtk_flow_box_set_vadjustment()for setting the vertical adjustment. The adjustments have to be in pixel units and in the same coordinate system as the allocation for immediate children of the box. a #GtkFlowBox an adjustment which should be adjusted when the focus is moved among the descendents of @container Sets the #GtkFlowBox:homogeneous property of @box, controlling whether or not all children of @box are given equal space in the box. a #GtkFlowBox %TRUE to create equal allotments, %FALSE for variable allotments Sets the maximum number of children to request and allocate space for in @box’s orientation. Setting the maximum number of children per line limits the overall natural size request to be no more than @n_children children long in the given orientation. a #GtkFlowBox the maximum number of children per line Sets the minimum number of children to line up in @box’s orientation before flowing. a #GtkFlowBox the minimum number of children per line Sets the vertical space to add between children. See the #GtkFlowBox:row-spacing property. a #GtkFlowBox the spacing to use Sets how selection works in @box. See #GtkSelectionMode for details. a #GtkFlowBox the new selection mode By setting a sort function on the @box, one can dynamically reorder the children of the box, based on the contents of the children. The @sort_func will be called for each child after the call, and will continue to be called each time a child changes (via gtk_flow_box_child_changed()) and when gtk_flow_box_invalidate_sort() is called. Note that using a sort function is incompatible with using a model (see gtk_flow_box_bind_model()). a #GtkFlowBox the sort function user data passed to @sort_func destroy notifier for @user_data Hooks up an adjustment to focus handling in @box. The adjustment is also used for autoscrolling during rubberband selection. See gtk_scrolled_window_get_vadjustment() for a typical way of obtaining the adjustment, and gtk_flow_box_set_hadjustment()for setting the horizontal adjustment. The adjustments have to be in pixel units and in the same coordinate system as the allocation for immediate children of the box. a #GtkFlowBox an adjustment which should be adjusted when the focus is moved among the descendents of @container Unselect all children of @box, if the selection mode allows it. a #GtkFlowBox Unselects a single child of @box, if the selection mode allows it. a #GtkFlowBox a child of @box Determines whether children can be activated with a single click, or require a double-click. The amount of horizontal space between two children. Determines whether all children should be allocated the same size. The maximum amount of children to request space for consecutively in the given orientation. The minimum number of children to allocate consecutively in the given orientation. Setting the minimum children per line ensures that a reasonably small height will be requested for the overall minimum width of the box. The amount of vertical space between two children. The selection mode used by the flow box. The ::activate-cursor-child signal is a [keybinding signal][GtkBindingSignal] which gets emitted when the user activates the @box. The ::child-activated signal is emitted when a child has been activated by the user. the child that is activated The ::move-cursor signal is a [keybinding signal][GtkBindingSignal] which gets emitted when the user initiates a cursor movement. Applications should not connect to it, but may emit it with g_signal_emit_by_name() if they need to control the cursor programmatically. The default bindings for this signal come in two variants, the variant with the Shift modifier extends the selection, the variant without the Shift modifer does not. There are too many key combinations to list them all here. - Arrow keys move by individual children - Home/End keys move to the ends of the box - PageUp/PageDown keys move vertically by pages %TRUE to stop other handlers from being invoked for the event. %FALSE to propagate the event further. the granularity fo the move, as a #GtkMovementStep the number of @step units to move The ::select-all signal is a [keybinding signal][GtkBindingSignal] which gets emitted to select all children of the box, if the selection mode permits it. The default bindings for this signal is Ctrl-a. The ::selected-children-changed signal is emitted when the set of selected children changes. Use gtk_flow_box_selected_foreach() or gtk_flow_box_get_selected_children() to obtain the selected children. The ::toggle-cursor-child signal is a [keybinding signal][GtkBindingSignal] which toggles the selection of the child that has the focus. The default binding for this signal is Ctrl-Space. The ::unselect-all signal is a [keybinding signal][GtkBindingSignal] which gets emitted to unselect all children of the box, if the selection mode permits it. The default bindings for this signal is Ctrl-Shift-a. Creates a new #GtkFlowBoxChild, to be used as a child of a #GtkFlowBox. a new #GtkFlowBoxChild Marks @child as changed, causing any state that depends on this to be updated. This affects sorting and filtering. Note that calls to this method must be in sync with the data used for the sorting and filtering functions. For instance, if the list is mirroring some external data set, and *two* children changed in the external data set when you call gtk_flow_box_child_changed() on the first child, the sort function must only read the new data for the first of the two changed children, otherwise the resorting of the children will be wrong. This generally means that if you don’t fully control the data model, you have to duplicate the data that affects the sorting and filtering functions into the widgets themselves. Another alternative is to call gtk_flow_box_invalidate_sort() on any model change, but that is more expensive. a #GtkFlowBoxChild Gets the current index of the @child in its #GtkFlowBox container. the index of the @child, or -1 if the @child is not in a flow box. a #GtkFlowBoxChild Returns whether the @child is currently selected in its #GtkFlowBox container. %TRUE if @child is selected a #GtkFlowBoxChild The ::activate signal is emitted when the user activates a child widget in a #GtkFlowBox, either by clicking or double-clicking, or by using the Space or Enter key. While this signal is used as a [keybinding signal][GtkBindingSignal], it can be used by applications for their own purposes. a #GtkFlowBox a #GtkFlowBox Called for flow boxes that are bound to a #GListModel with gtk_flow_box_bind_model() for each item that gets added to the model. a #GtkWidget that represents @item the item from the model for which to create a widget for user data from gtk_flow_box_bind_model() A function that will be called whenrever a child changes or is added. It lets you control if the child should be visible or not. %TRUE if the row should be visible, %FALSE otherwise a #GtkFlowBoxChild that may be filtered user data A function used by gtk_flow_box_selected_foreach(). It will be called on every selected child of the @box. a #GtkFlowBox a #GtkFlowBoxChild user data A function to compare two children to determine which should come first. < 0 if @child1 should be before @child2, 0 if the are equal, and > 0 otherwise the first child the second child user data The #GtkFontButton is a button which displays the currently selected font an allows to open a font chooser dialog to change the font. It is suitable widget for selecting a font in a preference dialog. # CSS nodes GtkFontButton has a single CSS node with name button and style class .font. Creates a new font picker widget. a new font picker widget. Creates a new font picker widget. a new font picker widget. Name of font to display in font chooser dialog Retrieves the name of the currently selected font. This name includes style and size information as well. If you want to render something with the font, use this string with pango_font_description_from_string() . If you’re interested in peeking certain values (family name, style, size, weight) just query these properties from the #PangoFontDescription object. Use gtk_font_chooser_get_font() instead an internal copy of the font name which must not be freed. a #GtkFontButton Returns whether the font size will be shown in the label. whether the font size will be shown in the label. a #GtkFontButton Returns whether the name of the font style will be shown in the label. whether the font style will be shown in the label. a #GtkFontButton Retrieves the title of the font chooser dialog. an internal copy of the title string which must not be freed. a #GtkFontButton Returns whether the selected font is used in the label. whether the selected font is used in the label. a #GtkFontButton Returns whether the selected size is used in the label. whether the selected size is used in the label. a #GtkFontButton Sets or updates the currently-displayed font in font picker dialog. Use gtk_font_chooser_set_font() instead %TRUE a #GtkFontButton Name of font to display in font chooser dialog If @show_size is %TRUE, the font size will be displayed along with the name of the selected font. a #GtkFontButton %TRUE if font size should be displayed in dialog. If @show_style is %TRUE, the font style will be displayed along with name of the selected font. a #GtkFontButton %TRUE if font style should be displayed in label. Sets the title for the font chooser dialog. a #GtkFontButton a string containing the font chooser dialog title If @use_font is %TRUE, the font name will be written using the selected font. a #GtkFontButton If %TRUE, font name will be written using font chosen. If @use_size is %TRUE, the font name will be written using the selected size. a #GtkFontButton If %TRUE, font name will be written using the selected size. The name of the currently selected font. Use the #GtkFontChooser::font property instead If this property is set to %TRUE, the selected font size will be shown in the label. For a more WYSIWYG way to show the selected size, see the ::use-size property. If this property is set to %TRUE, the name of the selected font style will be shown in the label. For a more WYSIWYG way to show the selected style, see the ::use-font property. The title of the font chooser dialog. If this property is set to %TRUE, the label will be drawn in the selected font. If this property is set to %TRUE, the label will be drawn with the selected font size. The ::font-set signal is emitted when the user selects a font. When handling this signal, use gtk_font_chooser_get_font() to find out which font was just selected. Note that this signal is only emitted when the user changes the font. If you need to react to programmatic font changes as well, use the notify::font signal. #GtkFontChooser is an interface that can be implemented by widgets displaying the list of fonts. In GTK+, the main objects that implement this interface are #GtkFontChooserWidget, #GtkFontChooserDialog and #GtkFontButton. The GtkFontChooser interface has been introducted in GTK+ 3.2. Gets the #PangoFontFace representing the selected font group details (i.e. family, slant, weight, width, etc). If the selected font is not installed, returns %NULL. A #PangoFontFace representing the selected font group details, or %NULL. The returned object is owned by @fontchooser and must not be modified or freed. a #GtkFontChooser Gets the #PangoFontFamily representing the selected font family. Font families are a collection of font faces. If the selected font is not installed, returns %NULL. A #PangoFontFamily representing the selected font family, or %NULL. The returned object is owned by @fontchooser and must not be modified or freed. a #GtkFontChooser Gets the custom font map of this font chooser widget, or %NULL if it does not have one. a #PangoFontMap, or %NULL a #GtkFontChooser The selected font size. A n integer representing the selected font size, or -1 if no font size is selected. a #GtkFontChooser Adds a filter function that decides which fonts to display in the font chooser. a #GtkFontChooser a #GtkFontFilterFunc, or %NULL data to pass to @filter function to call to free @data when it is no longer needed Sets a custom font map to use for this font chooser widget. A custom font map can be used to present application-specific fonts instead of or in addition to the normal system fonts. |[<!-- language="C" --> FcConfig *config; PangoFontMap *fontmap; config = FcInitLoadConfigAndFonts (); FcConfigAppFontAddFile (config, my_app_font_file); fontmap = pango_cairo_font_map_new_for_font_type (CAIRO_FONT_TYPE_FT); pango_fc_font_map_set_config (PANGO_FC_FONT_MAP (fontmap), config); gtk_font_chooser_set_font_map (font_chooser, fontmap); ]| Note that other GTK+ widgets will only be able to use the application-specific font if it is present in the font map they use: |[ context = gtk_widget_get_pango_context (label); pango_context_set_font_map (context, fontmap); ]| a #GtkFontChooser a #PangoFontMap Gets the currently-selected font name. Note that this can be a different string than what you set with gtk_font_chooser_set_font(), as the font chooser widget may normalize font names and thus return a string with a different structure. For example, “Helvetica Italic Bold 12” could be normalized to “Helvetica Bold Italic 12”. Use pango_font_description_equal() if you want to compare two font descriptions. A string with the name of the current font, or %NULL if no font is selected. You must free this string with g_free(). a #GtkFontChooser Gets the currently-selected font. Note that this can be a different string than what you set with gtk_font_chooser_set_font(), as the font chooser widget may normalize font names and thus return a string with a different structure. For example, “Helvetica Italic Bold 12” could be normalized to “Helvetica Bold Italic 12”. Use pango_font_description_equal() if you want to compare two font descriptions. A #PangoFontDescription for the current font, or %NULL if no font is selected. a #GtkFontChooser Gets the #PangoFontFace representing the selected font group details (i.e. family, slant, weight, width, etc). If the selected font is not installed, returns %NULL. A #PangoFontFace representing the selected font group details, or %NULL. The returned object is owned by @fontchooser and must not be modified or freed. a #GtkFontChooser Gets the #PangoFontFamily representing the selected font family. Font families are a collection of font faces. If the selected font is not installed, returns %NULL. A #PangoFontFamily representing the selected font family, or %NULL. The returned object is owned by @fontchooser and must not be modified or freed. a #GtkFontChooser Gets the currently-selected font features. the currently selected font features a #GtkFontChooser Gets the custom font map of this font chooser widget, or %NULL if it does not have one. a #PangoFontMap, or %NULL a #GtkFontChooser The selected font size. A n integer representing the selected font size, or -1 if no font size is selected. a #GtkFontChooser Gets the language that is used for font features. the currently selected language a #GtkFontChooser Returns the current level of granularity for selecting fonts. the current granularity level a #GtkFontChooser Gets the text displayed in the preview area. the text displayed in the preview area a #GtkFontChooser Returns whether the preview entry is shown or not. %TRUE if the preview entry is shown or %FALSE if it is hidden. a #GtkFontChooser Adds a filter function that decides which fonts to display in the font chooser. a #GtkFontChooser a #GtkFontFilterFunc, or %NULL data to pass to @filter function to call to free @data when it is no longer needed Sets the currently-selected font. a #GtkFontChooser a font name like “Helvetica 12” or “Times Bold 18” Sets the currently-selected font from @font_desc. a #GtkFontChooser a #PangoFontDescription Sets a custom font map to use for this font chooser widget. A custom font map can be used to present application-specific fonts instead of or in addition to the normal system fonts. |[<!-- language="C" --> FcConfig *config; PangoFontMap *fontmap; config = FcInitLoadConfigAndFonts (); FcConfigAppFontAddFile (config, my_app_font_file); fontmap = pango_cairo_font_map_new_for_font_type (CAIRO_FONT_TYPE_FT); pango_fc_font_map_set_config (PANGO_FC_FONT_MAP (fontmap), config); gtk_font_chooser_set_font_map (font_chooser, fontmap); ]| Note that other GTK+ widgets will only be able to use the application-specific font if it is present in the font map they use: |[ context = gtk_widget_get_pango_context (label); pango_context_set_font_map (context, fontmap); ]| a #GtkFontChooser a #PangoFontMap Sets the language to use for font features. a #GtkFontChooser a language Sets the desired level of granularity for selecting fonts. a #GtkFontChooser the desired level of granularity Sets the text displayed in the preview area. The @text is used to show how the selected font looks. a #GtkFontChooser the text to display in the preview area Shows or hides the editable preview entry. a #GtkFontChooser whether to show the editable preview entry or not The font description as a string, e.g. "Sans Italic 12". The font description as a #PangoFontDescription. The selected font features, in a format that is compatible with CSS and with Pango attributes. The language for which the #GtkFontChooser:font-features were selected, in a format that is compatible with CSS and with Pango attributes. The level of granularity to offer for selecting fonts. The string with which to preview the font. Whether to show an entry to change the preview text. Emitted when a font is activated. This usually happens when the user double clicks an item, or an item is selected and the user presses one of the keys Space, Shift+Space, Return or Enter. the font name The #GtkFontChooserDialog widget is a dialog for selecting a font. It implements the #GtkFontChooser interface. # GtkFontChooserDialog as GtkBuildable The GtkFontChooserDialog implementation of the #GtkBuildable interface exposes the buttons with the names “select_button” and “cancel_button”. Creates a new #GtkFontChooserDialog. a new #GtkFontChooserDialog Title of the dialog, or %NULL Transient parent of the dialog, or %NULL The parent class. A #PangoFontFamily representing the selected font family, or %NULL. The returned object is owned by @fontchooser and must not be modified or freed. a #GtkFontChooser A #PangoFontFace representing the selected font group details, or %NULL. The returned object is owned by @fontchooser and must not be modified or freed. a #GtkFontChooser A n integer representing the selected font size, or -1 if no font size is selected. a #GtkFontChooser a #GtkFontChooser a #GtkFontFilterFunc, or %NULL data to pass to @filter function to call to free @data when it is no longer needed a #GtkFontChooser a #PangoFontMap a #PangoFontMap, or %NULL a #GtkFontChooser This enumeration specifies the granularity of font selection that is desired in a font chooser. This enumeration may be extended in the future; applications should ignore unknown values. Allow selecting a font family Allow selecting a specific font face Allow selecting a specific font size Allow selecting specific OpenType font features The #GtkFontChooserWidget widget lists the available fonts, styles and sizes, allowing the user to select a font. It is used in the #GtkFontChooserDialog widget to provide a dialog box for selecting fonts. To set the font which is initially selected, use gtk_font_chooser_set_font() or gtk_font_chooser_set_font_desc(). To get the selected font use gtk_font_chooser_get_font() or gtk_font_chooser_get_font_desc(). To change the text which is shown in the preview area, use gtk_font_chooser_set_preview_text(). # CSS nodes GtkFontChooserWidget has a single CSS node with name fontchooser. Creates a new #GtkFontChooserWidget. a new #GtkFontChooserWidget A toggle action that can be used to switch to the tweak page of the font chooser widget, which lets the user tweak the OpenType features and variation axes of the selected font. The action will be enabled or disabled depending on whether the selected font has any features or axes. The parent class. The type of function that is used for deciding what fonts get shown in a #GtkFontChooser. See gtk_font_chooser_set_filter_func(). %TRUE if the font should be displayed a #PangoFontFamily a #PangoFontFace belonging to @family user data passed to gtk_font_chooser_set_filter_func() Creates a new #GtkFontSelection. Use #GtkFontChooserWidget instead a new #GtkFontSelection Gets the #PangoFontFace representing the selected font group details (i.e. family, slant, weight, width, etc). Use #GtkFontChooser A #PangoFontFace representing the selected font group details. The returned object is owned by @fontsel and must not be modified or freed. a #GtkFontSelection This returns the #GtkTreeView which lists all styles available for the selected font. For example, “Regular”, “Bold”, etc. Use #GtkFontChooser A #GtkWidget that is part of @fontsel a #GtkFontSelection Gets the #PangoFontFamily representing the selected font family. Use #GtkFontChooser A #PangoFontFamily representing the selected font family. Font families are a collection of font faces. The returned object is owned by @fontsel and must not be modified or freed. a #GtkFontSelection This returns the #GtkTreeView that lists font families, for example, “Sans”, “Serif”, etc. Use #GtkFontChooser A #GtkWidget that is part of @fontsel a #GtkFontSelection Gets the currently-selected font name. Note that this can be a different string than what you set with gtk_font_selection_set_font_name(), as the font selection widget may normalize font names and thus return a string with a different structure. For example, “Helvetica Italic Bold 12” could be normalized to “Helvetica Bold Italic 12”. Use pango_font_description_equal() if you want to compare two font descriptions. Use #GtkFontChooser A string with the name of the current font, or %NULL if no font is selected. You must free this string with g_free(). a #GtkFontSelection This returns the #GtkEntry used to display the font as a preview. Use #GtkFontChooser A #GtkWidget that is part of @fontsel a #GtkFontSelection Gets the text displayed in the preview area. Use #GtkFontChooser the text displayed in the preview area. This string is owned by the widget and should not be modified or freed a #GtkFontSelection The selected font size. Use #GtkFontChooser A n integer representing the selected font size, or -1 if no font size is selected. a #GtkFontSelection This returns the #GtkEntry used to allow the user to edit the font number manually instead of selecting it from the list of font sizes. Use #GtkFontChooser A #GtkWidget that is part of @fontsel a #GtkFontSelection This returns the #GtkTreeView used to list font sizes. Use #GtkFontChooser A #GtkWidget that is part of @fontsel a #GtkFontSelection Sets the currently-selected font. Note that the @fontsel needs to know the screen in which it will appear for this to work; this can be guaranteed by simply making sure that the @fontsel is inserted in a toplevel window before you call this function. Use #GtkFontChooser %TRUE if the font could be set successfully; %FALSE if no such font exists or if the @fontsel doesn’t belong to a particular screen yet. a #GtkFontSelection a font name like “Helvetica 12” or “Times Bold 18” Sets the text displayed in the preview area. The @text is used to show how the selected font looks. Use #GtkFontChooser a #GtkFontSelection the text to display in the preview area Creates a new #GtkFontSelectionDialog. Use #GtkFontChooserDialog a new #GtkFontSelectionDialog the title of the dialog window Gets the “Cancel” button. Use #GtkFontChooserDialog the #GtkWidget used in the dialog for the “Cancel” button. a #GtkFontSelectionDialog Gets the currently-selected font name. Note that this can be a different string than what you set with gtk_font_selection_dialog_set_font_name(), as the font selection widget may normalize font names and thus return a string with a different structure. For example, “Helvetica Italic Bold 12” could be normalized to “Helvetica Bold Italic 12”. Use pango_font_description_equal() if you want to compare two font descriptions. Use #GtkFontChooserDialog A string with the name of the current font, or %NULL if no font is selected. You must free this string with g_free(). a #GtkFontSelectionDialog Retrieves the #GtkFontSelection widget embedded in the dialog. Use #GtkFontChooserDialog the embedded #GtkFontSelection a #GtkFontSelectionDialog Gets the “OK” button. Use #GtkFontChooserDialog the #GtkWidget used in the dialog for the “OK” button. a #GtkFontSelectionDialog Gets the text displayed in the preview area. Use #GtkFontChooserDialog the text displayed in the preview area. This string is owned by the widget and should not be modified or freed a #GtkFontSelectionDialog Sets the currently selected font. Use #GtkFontChooserDialog %TRUE if the font selected in @fsd is now the @fontname specified, %FALSE otherwise. a #GtkFontSelectionDialog a font name like “Helvetica 12” or “Times Bold 18” Sets the text displayed in the preview area. Use #GtkFontChooserDialog a #GtkFontSelectionDialog the text to display in the preview area The frame widget is a bin that surrounds its child with a decorative frame and an optional label. If present, the label is drawn in a gap in the top side of the frame. The position of the label can be controlled with gtk_frame_set_label_align(). # GtkFrame as GtkBuildable The GtkFrame implementation of the GtkBuildable interface supports placing a child in the label position by specifying “label” as the “type” attribute of a <child> element. A normal content child can be specified without specifying a <child> type attribute. An example of a UI definition fragment with GtkFrame: |[ <object class="GtkFrame"> <child type="label"> <object class="GtkLabel" id="frame-label"/> </child> <child> <object class="GtkEntry" id="frame-content"/> </child> </object> ]| # CSS nodes |[<!-- language="plain" --> frame ├── border[.flat] ├── <label widget> ╰── <child> ]| GtkFrame has a main CSS node named “frame” and a subnode named “border”. The “border” node is used to draw the visible border. You can set the appearance of the border using CSS properties like “border-style” on the “border” node. The border node can be given the style class “.flat”, which is used by themes to disable drawing of the border. To do this from code, call gtk_frame_set_shadow_type() with %GTK_SHADOW_NONE to add the “.flat” class or any other shadow type to remove it. Creates a new #GtkFrame, with optional label @label. If @label is %NULL, the label is omitted. a new #GtkFrame widget the text to use as the label of the frame If the frame’s label widget is a #GtkLabel, returns the text in the label widget. (The frame will have a #GtkLabel for the label widget if a non-%NULL argument was passed to gtk_frame_new().) the text in the label, or %NULL if there was no label widget or the lable widget was not a #GtkLabel. This string is owned by GTK+ and must not be modified or freed. a #GtkFrame Retrieves the X and Y alignment of the frame’s label. See gtk_frame_set_label_align(). a #GtkFrame location to store X alignment of frame’s label, or %NULL location to store X alignment of frame’s label, or %NULL Retrieves the label widget for the frame. See gtk_frame_set_label_widget(). the label widget, or %NULL if there is none. a #GtkFrame Retrieves the shadow type of the frame. See gtk_frame_set_shadow_type(). the current shadow type of the frame. a #GtkFrame Removes the current #GtkFrame:label-widget. If @label is not %NULL, creates a new #GtkLabel with that text and adds it as the #GtkFrame:label-widget. a #GtkFrame the text to use as the label of the frame Sets the alignment of the frame widget’s label. The default values for a newly created frame are 0.0 and 0.5. a #GtkFrame The position of the label along the top edge of the widget. A value of 0.0 represents left alignment; 1.0 represents right alignment. The y alignment of the label. A value of 0.0 aligns under the frame; 1.0 aligns above the frame. If the values are exactly 0.0 or 1.0 the gap in the frame won’t be painted because the label will be completely above or below the frame. Sets the #GtkFrame:label-widget for the frame. This is the widget that will appear embedded in the top edge of the frame as a title. a #GtkFrame the new label widget Sets the #GtkFrame:shadow-type for @frame, i.e. whether it is drawn without (%GTK_SHADOW_NONE) or with (other values) a visible border. Values other than %GTK_SHADOW_NONE are treated identically by GtkFrame. The chosen type is applied by removing or adding the .flat class to the CSS node named border. a #GtkFrame the new #GtkShadowType The parent class. #GtkGLArea is a widget that allows drawing with OpenGL. #GtkGLArea sets up its own #GdkGLContext for the window it creates, and creates a custom GL framebuffer that the widget will do GL rendering onto. It also ensures that this framebuffer is the default GL rendering target when rendering. In order to draw, you have to connect to the #GtkGLArea::render signal, or subclass #GtkGLArea and override the @GtkGLAreaClass.render() virtual function. The #GtkGLArea widget ensures that the #GdkGLContext is associated with the widget's drawing area, and it is kept updated when the size and position of the drawing area changes. ## Drawing with GtkGLArea ## The simplest way to draw using OpenGL commands in a #GtkGLArea is to create a widget instance and connect to the #GtkGLArea::render signal: |[<!-- language="C" --> // create a GtkGLArea instance GtkWidget *gl_area = gtk_gl_area_new (); // connect to the "render" signal g_signal_connect (gl_area, "render", G_CALLBACK (render), NULL); ]| The `render()` function will be called when the #GtkGLArea is ready for you to draw its content: |[<!-- language="C" --> static gboolean render (GtkGLArea *area, GdkGLContext *context) { // inside this function it's safe to use GL; the given // #GdkGLContext has been made current to the drawable // surface used by the #GtkGLArea and the viewport has // already been set to be the size of the allocation // we can start by clearing the buffer glClearColor (0, 0, 0, 0); glClear (GL_COLOR_BUFFER_BIT); // draw your object draw_an_object (); // we completed our drawing; the draw commands will be // flushed at the end of the signal emission chain, and // the buffers will be drawn on the window return TRUE; } ]| If you need to initialize OpenGL state, e.g. buffer objects or shaders, you should use the #GtkWidget::realize signal; you can use the #GtkWidget::unrealize signal to clean up. Since the #GdkGLContext creation and initialization may fail, you will need to check for errors, using gtk_gl_area_get_error(). An example of how to safely initialize the GL state is: |[<!-- language="C" --> static void on_realize (GtkGLarea *area) { // We need to make the context current if we want to // call GL API gtk_gl_area_make_current (area); // If there were errors during the initialization or // when trying to make the context current, this // function will return a #GError for you to catch if (gtk_gl_area_get_error (area) != NULL) return; // You can also use gtk_gl_area_set_error() in order // to show eventual initialization errors on the // GtkGLArea widget itself GError *internal_error = NULL; init_buffer_objects (&error); if (error != NULL) { gtk_gl_area_set_error (area, error); g_error_free (error); return; } init_shaders (&error); if (error != NULL) { gtk_gl_area_set_error (area, error); g_error_free (error); return; } } ]| If you need to change the options for creating the #GdkGLContext you should use the #GtkGLArea::create-context signal. Creates a new #GtkGLArea widget. a new #GtkGLArea Ensures that the @area framebuffer object is made the current draw and read target, and that all the required buffers for the @area are created and bound to the frambuffer. This function is automatically called before emitting the #GtkGLArea::render signal, and doesn't normally need to be called by application code. a #GtkGLArea Returns whether the area is in auto render mode or not. %TRUE if the @area is auto rendering, %FALSE otherwise a #GtkGLArea Retrieves the #GdkGLContext used by @area. the #GdkGLContext a #GtkGLArea Gets the current error set on the @area. the #GError or %NULL a #GtkGLArea Returns whether the area has an alpha component. %TRUE if the @area has an alpha component, %FALSE otherwise a #GtkGLArea Returns whether the area has a depth buffer. %TRUE if the @area has a depth buffer, %FALSE otherwise a #GtkGLArea Returns whether the area has a stencil buffer. %TRUE if the @area has a stencil buffer, %FALSE otherwise a #GtkGLArea Retrieves the required version of OpenGL set using gtk_gl_area_set_required_version(). a #GtkGLArea return location for the required major version return location for the required minor version Retrieves the value set by gtk_gl_area_set_use_es(). %TRUE if the #GtkGLArea should create an OpenGL ES context and %FALSE otherwise a #GtkGLArea Ensures that the #GdkGLContext used by @area is associated with the #GtkGLArea. This function is automatically called before emitting the #GtkGLArea::render signal, and doesn't normally need to be called by application code. a #GtkGLArea Marks the currently rendered data (if any) as invalid, and queues a redraw of the widget, ensuring that the #GtkGLArea::render signal is emitted during the draw. This is only needed when the gtk_gl_area_set_auto_render() has been called with a %FALSE value. The default behaviour is to emit #GtkGLArea::render on each draw. a #GtkGLArea If @auto_render is %TRUE the #GtkGLArea::render signal will be emitted every time the widget draws. This is the default and is useful if drawing the widget is faster. If @auto_render is %FALSE the data from previous rendering is kept around and will be used for drawing the widget the next time, unless the window is resized. In order to force a rendering gtk_gl_area_queue_render() must be called. This mode is useful when the scene changes seldomly, but takes a long time to redraw. a #GtkGLArea a boolean Sets an error on the area which will be shown instead of the GL rendering. This is useful in the #GtkGLArea::create-context signal if GL context creation fails. a #GtkGLArea a new #GError, or %NULL to unset the error If @has_alpha is %TRUE the buffer allocated by the widget will have an alpha channel component, and when rendering to the window the result will be composited over whatever is below the widget. If @has_alpha is %FALSE there will be no alpha channel, and the buffer will fully replace anything below the widget. a #GtkGLArea %TRUE to add an alpha component If @has_depth_buffer is %TRUE the widget will allocate and enable a depth buffer for the target framebuffer. Otherwise there will be none. a #GtkGLArea %TRUE to add a depth buffer If @has_stencil_buffer is %TRUE the widget will allocate and enable a stencil buffer for the target framebuffer. Otherwise there will be none. a #GtkGLArea %TRUE to add a stencil buffer Sets the required version of OpenGL to be used when creating the context for the widget. This function must be called before the area has been realized. a #GtkGLArea the major version the minor version Sets whether the @area should create an OpenGL or an OpenGL ES context. You should check the capabilities of the #GdkGLContext before drawing with either API. a #GtkGLArea whether to use OpenGL or OpenGL ES If set to %TRUE the #GtkGLArea::render signal will be emitted every time the widget draws. This is the default and is useful if drawing the widget is faster. If set to %FALSE the data from previous rendering is kept around and will be used for drawing the widget the next time, unless the window is resized. In order to force a rendering gtk_gl_area_queue_render() must be called. This mode is useful when the scene changes seldomly, but takes a long time to redraw. The #GdkGLContext used by the #GtkGLArea widget. The #GtkGLArea widget is responsible for creating the #GdkGLContext instance. If you need to render with other kinds of buffers (stencil, depth, etc), use render buffers. If set to %TRUE the buffer allocated by the widget will have an alpha channel component, and when rendering to the window the result will be composited over whatever is below the widget. If set to %FALSE there will be no alpha channel, and the buffer will fully replace anything below the widget. If set to %TRUE the widget will allocate and enable a depth buffer for the target framebuffer. If set to %TRUE the widget will allocate and enable a stencil buffer for the target framebuffer. If set to %TRUE the widget will try to create a #GdkGLContext using OpenGL ES instead of OpenGL. See also: gdk_gl_context_set_use_es() The ::create-context signal is emitted when the widget is being realized, and allows you to override how the GL context is created. This is useful when you want to reuse an existing GL context, or if you want to try creating different kinds of GL options. If context creation fails then the signal handler can use gtk_gl_area_set_error() to register a more detailed error of how the construction failed. a newly created #GdkGLContext; the #GtkGLArea widget will take ownership of the returned value. The ::render signal is emitted every time the contents of the #GtkGLArea should be redrawn. The @context is bound to the @area prior to emitting this function, and the buffers are painted to the window once the emission terminates. %TRUE to stop other handlers from being invoked for the event. %FALSE to propagate the event further. the #GdkGLContext used by @area The ::resize signal is emitted once when the widget is realized, and then each time the widget is changed while realized. This is useful in order to keep GL state up to date with the widget size, like for instance camera properties which may depend on the width/height ratio. The GL context for the area is guaranteed to be current when this signal is emitted. The default handler sets up the GL viewport. the width of the viewport the height of the viewport The `GtkGLAreaClass` structure contains only private data. #GtkGesture is the base object for gesture recognition, although this object is quite generalized to serve as a base for multi-touch gestures, it is suitable to implement single-touch and pointer-based gestures (using the special %NULL #GdkEventSequence value for these). The number of touches that a #GtkGesture need to be recognized is controlled by the #GtkGesture:n-points property, if a gesture is keeping track of less or more than that number of sequences, it won't check wether the gesture is recognized. As soon as the gesture has the expected number of touches, the gesture will run the #GtkGesture::check signal regularly on input events until the gesture is recognized, the criteria to consider a gesture as "recognized" is left to #GtkGesture subclasses. A recognized gesture will then emit the following signals: - #GtkGesture::begin when the gesture is recognized. - A number of #GtkGesture::update, whenever an input event is processed. - #GtkGesture::end when the gesture is no longer recognized. ## Event propagation In order to receive events, a gesture needs to either set a propagation phase through gtk_event_controller_set_propagation_phase(), or feed those manually through gtk_event_controller_handle_event(). In the capture phase, events are propagated from the toplevel down to the target widget, and gestures that are attached to containers above the widget get a chance to interact with the event before it reaches the target. After the capture phase, GTK+ emits the traditional #GtkWidget::button-press-event, #GtkWidget::button-release-event, #GtkWidget::touch-event, etc signals. Gestures with the %GTK_PHASE_TARGET phase are fed events from the default #GtkWidget::event handlers. In the bubble phase, events are propagated up from the target widget to the toplevel, and gestures that are attached to containers above the widget get a chance to interact with events that have not been handled yet. ## States of a sequence # {#touch-sequence-states} Whenever input interaction happens, a single event may trigger a cascade of #GtkGestures, both across the parents of the widget receiving the event and in parallel within an individual widget. It is a responsibility of the widgets using those gestures to set the state of touch sequences accordingly in order to enable cooperation of gestures around the #GdkEventSequences triggering those. Within a widget, gestures can be grouped through gtk_gesture_group(), grouped gestures synchronize the state of sequences, so calling gtk_gesture_set_sequence_state() on one will effectively propagate the state throughout the group. By default, all sequences start out in the #GTK_EVENT_SEQUENCE_NONE state, sequences in this state trigger the gesture event handler, but event propagation will continue unstopped by gestures. If a sequence enters into the #GTK_EVENT_SEQUENCE_DENIED state, the gesture group will effectively ignore the sequence, letting events go unstopped through the gesture, but the "slot" will still remain occupied while the touch is active. If a sequence enters in the #GTK_EVENT_SEQUENCE_CLAIMED state, the gesture group will grab all interaction on the sequence, by: - Setting the same sequence to #GTK_EVENT_SEQUENCE_DENIED on every other gesture group within the widget, and every gesture on parent widgets in the propagation chain. - calling #GtkGesture::cancel on every gesture in widgets underneath in the propagation chain. - Stopping event propagation after the gesture group handles the event. Note: if a sequence is set early to #GTK_EVENT_SEQUENCE_CLAIMED on #GDK_TOUCH_BEGIN/#GDK_BUTTON_PRESS (so those events are captured before reaching the event widget, this implies #GTK_PHASE_CAPTURE), one similar event will emulated if the sequence changes to #GTK_EVENT_SEQUENCE_DENIED. This way event coherence is preserved before event propagation is unstopped again. Sequence states can't be changed freely, see gtk_gesture_set_sequence_state() to know about the possible lifetimes of a #GdkEventSequence. ## Touchpad gestures On the platforms that support it, #GtkGesture will handle transparently touchpad gesture events. The only precautions users of #GtkGesture should do to enable this support are: - Enabling %GDK_TOUCHPAD_GESTURE_MASK on their #GdkWindows - If the gesture has %GTK_PHASE_NONE, ensuring events of type %GDK_TOUCHPAD_SWIPE and %GDK_TOUCHPAD_PINCH are handled by the #GtkGesture If there are touch sequences being currently handled by @gesture, this function returns %TRUE and fills in @rect with the bounding box containing all active touches. Otherwise, %FALSE will be returned. Note: This function will yield unexpected results on touchpad gestures. Since there is no correlation between physical and pixel distances, these will look as if constrained in an infinitely small area, @rect width and height will thus be 0 regardless of the number of touchpoints. %TRUE if there are active touches, %FALSE otherwise a #GtkGesture bounding box containing all active touches. If there are touch sequences being currently handled by @gesture, this function returns %TRUE and fills in @x and @y with the center of the bounding box containing all active touches. Otherwise, %FALSE will be returned. %FALSE if no active touches are present, %TRUE otherwise a #GtkGesture X coordinate for the bounding box center Y coordinate for the bounding box center Returns the master #GdkDevice that is currently operating on @gesture, or %NULL if the gesture is not being interacted. a #GdkDevice, or %NULL a #GtkGesture Returns all gestures in the group of @gesture The list of #GtkGestures, free with g_list_free() a #GtkGesture Returns the last event that was processed for @sequence. Note that the returned pointer is only valid as long as the @sequence is still interpreted by the @gesture. If in doubt, you should make a copy of the event. The last event from @sequence a #GtkGesture a #GdkEventSequence Returns the #GdkEventSequence that was last updated on @gesture. The last updated sequence a #GtkGesture If @sequence is currently being interpreted by @gesture, this function returns %TRUE and fills in @x and @y with the last coordinates stored for that event sequence. The coordinates are always relative to the widget allocation. %TRUE if @sequence is currently interpreted a #GtkGesture a #GdkEventSequence, or %NULL for pointer events return location for X axis of the sequence coordinates return location for Y axis of the sequence coordinates Returns the @sequence state, as seen by @gesture. The sequence state in @gesture a #GtkGesture a #GdkEventSequence Returns the list of #GdkEventSequences currently being interpreted by @gesture. A list of #GdkEventSequences, the list elements are owned by GTK+ and must not be freed or modified, the list itself must be deleted through g_list_free() a #GtkGesture Returns the user-defined window that receives the events handled by @gesture. See gtk_gesture_set_window() for more information. the user defined window, or %NULL if none a #GtkGesture Adds @gesture to the same group than @group_gesture. Gestures are by default isolated in their own groups. When gestures are grouped, the state of #GdkEventSequences is kept in sync for all of those, so calling gtk_gesture_set_sequence_state(), on one will transfer the same value to the others. Groups also perform an "implicit grabbing" of sequences, if a #GdkEventSequence state is set to #GTK_EVENT_SEQUENCE_CLAIMED on one group, every other gesture group attached to the same #GtkWidget will switch the state for that sequence to #GTK_EVENT_SEQUENCE_DENIED. #GtkGesture to group @gesture with a #GtkGesture Returns %TRUE if @gesture is currently handling events corresponding to @sequence. %TRUE if @gesture is handling @sequence, %FALSE otherwise a #GtkGesture a #GdkEventSequence or %NULL Returns %TRUE if the gesture is currently active. A gesture is active meanwhile there are touch sequences interacting with it. %TRUE if gesture is active a #GtkGesture Returns %TRUE if both gestures pertain to the same group. whether the gestures are grouped a #GtkGesture another #GtkGesture Returns %TRUE if the gesture is currently recognized. A gesture is recognized if there are as many interacting touch sequences as required by @gesture, and #GtkGesture::check returned %TRUE for the sequences being currently interpreted. %TRUE if gesture is recognized a #GtkGesture Sets the state of @sequence in @gesture. Sequences start in state #GTK_EVENT_SEQUENCE_NONE, and whenever they change state, they can never go back to that state. Likewise, sequences in state #GTK_EVENT_SEQUENCE_DENIED cannot turn back to a not denied state. With these rules, the lifetime of an event sequence is constrained to the next four: * None * None → Denied * None → Claimed * None → Claimed → Denied Note: Due to event handling ordering, it may be unsafe to set the state on another gesture within a #GtkGesture::begin signal handler, as the callback might be executed before the other gesture knows about the sequence. A safe way to perform this could be: |[ static void first_gesture_begin_cb (GtkGesture *first_gesture, GdkEventSequence *sequence, gpointer user_data) { gtk_gesture_set_sequence_state (first_gesture, sequence, GTK_EVENT_SEQUENCE_CLAIMED); gtk_gesture_set_sequence_state (second_gesture, sequence, GTK_EVENT_SEQUENCE_DENIED); } static void second_gesture_begin_cb (GtkGesture *second_gesture, GdkEventSequence *sequence, gpointer user_data) { if (gtk_gesture_get_sequence_state (first_gesture, sequence) == GTK_EVENT_SEQUENCE_CLAIMED) gtk_gesture_set_sequence_state (second_gesture, sequence, GTK_EVENT_SEQUENCE_DENIED); } ]| If both gestures are in the same group, just set the state on the gesture emitting the event, the sequence will be already be initialized to the group's global state when the second gesture processes the event. %TRUE if @sequence is handled by @gesture, and the state is changed successfully a #GtkGesture a #GdkEventSequence the sequence state Sets the state of all sequences that @gesture is currently interacting with. See gtk_gesture_set_sequence_state() for more details on sequence states. %TRUE if the state of at least one sequence was changed successfully a #GtkGesture the sequence state Sets a specific window to receive events about, so @gesture will effectively handle only events targeting @window, or a child of it. @window must pertain to gtk_event_controller_get_widget(). a #GtkGesture a #GdkWindow, or %NULL Separates @gesture into an isolated group. a #GtkGesture The number of touch points that trigger recognition on this gesture, If non-%NULL, the gesture will only listen for events that happen on this #GdkWindow, or a child of it. This signal is emitted when the gesture is recognized. This means the number of touch sequences matches #GtkGesture:n-points, and the #GtkGesture::check handler(s) returned #TRUE. Note: These conditions may also happen when an extra touch (eg. a third touch on a 2-touches gesture) is lifted, in that situation @sequence won't pertain to the current set of active touches, so don't rely on this being true. the #GdkEventSequence that made the gesture to be recognized This signal is emitted whenever a sequence is cancelled. This usually happens on active touches when gtk_event_controller_reset() is called on @gesture (manually, due to grabs...), or the individual @sequence was claimed by parent widgets' controllers (see gtk_gesture_set_sequence_state()). @gesture must forget everything about @sequence as a reaction to this signal. the #GdkEventSequence that was cancelled This signal is emitted when @gesture either stopped recognizing the event sequences as something to be handled (the #GtkGesture::check handler returned %FALSE), or the number of touch sequences became higher or lower than #GtkGesture:n-points. Note: @sequence might not pertain to the group of sequences that were previously triggering recognition on @gesture (ie. a just pressed touch sequence that exceeds #GtkGesture:n-points). This situation may be detected by checking through gtk_gesture_handles_sequence(). the #GdkEventSequence that made gesture recognition to finish This signal is emitted whenever a sequence state changes. See gtk_gesture_set_sequence_state() to know more about the expectable sequence lifetimes. the #GdkEventSequence that was cancelled the new sequence state This signal is emitted whenever an event is handled while the gesture is recognized. @sequence is guaranteed to pertain to the set of active touches. the #GdkEventSequence that was updated #GtkGestureDrag is a #GtkGesture implementation that recognizes drag operations. The drag operation itself can be tracked throught the #GtkGestureDrag::drag-begin, #GtkGestureDrag::drag-update and #GtkGestureDrag::drag-end signals, or the relevant coordinates be extracted through gtk_gesture_drag_get_offset() and gtk_gesture_drag_get_start_point(). Returns a newly created #GtkGesture that recognizes drags. a newly created #GtkGestureDrag a #GtkWidget If the @gesture is active, this function returns %TRUE and fills in @x and @y with the coordinates of the current point, as an offset to the starting drag point. %TRUE if the gesture is active a #GtkGesture X offset for the current point Y offset for the current point If the @gesture is active, this function returns %TRUE and fills in @x and @y with the drag start coordinates, in window-relative coordinates. %TRUE if the gesture is active a #GtkGesture X coordinate for the drag start point Y coordinate for the drag start point This signal is emitted whenever dragging starts. X coordinate, relative to the widget allocation Y coordinate, relative to the widget allocation This signal is emitted whenever the dragging is finished. X offset, relative to the start point Y offset, relative to the start point This signal is emitted whenever the dragging point moves. X offset, relative to the start point Y offset, relative to the start point #GtkGestureLongPress is a #GtkGesture implementation able to recognize long presses, triggering the #GtkGestureLongPress::pressed after the timeout is exceeded. If the touchpoint is lifted before the timeout passes, or if it drifts too far of the initial press point, the #GtkGestureLongPress::cancelled signal will be emitted. Returns a newly created #GtkGesture that recognizes long presses. a newly created #GtkGestureLongPress a #GtkWidget This signal is emitted whenever a press moved too far, or was released before #GtkGestureLongPress::pressed happened. This signal is emitted whenever a press goes unmoved/unreleased longer than what the GTK+ defaults tell. the X coordinate where the press happened, relative to the widget allocation the Y coordinate where the press happened, relative to the widget allocation #GtkGestureMultiPress is a #GtkGesture implementation able to recognize multiple clicks on a nearby zone, which can be listened for through the #GtkGestureMultiPress::pressed signal. Whenever time or distance between clicks exceed the GTK+ defaults, #GtkGestureMultiPress::stopped is emitted, and the click counter is reset. Callers may also restrict the area that is considered valid for a >1 touch/button press through gtk_gesture_multi_press_set_area(), so any click happening outside that area is considered to be a first click of its own. Returns a newly created #GtkGesture that recognizes single and multiple presses. a newly created #GtkGestureMultiPress a #GtkWidget If an area was set through gtk_gesture_multi_press_set_area(), this function will return %TRUE and fill in @rect with the press area. See gtk_gesture_multi_press_set_area() for more details on what the press area represents. %TRUE if @rect was filled with the press area a #GtkGestureMultiPress return location for the press area If @rect is non-%NULL, the press area will be checked to be confined within the rectangle, otherwise the button count will be reset so the press is seen as being the first one. If @rect is %NULL, the area will be reset to an unrestricted state. Note: The rectangle is only used to determine whether any non-first click falls within the expected area. This is not akin to an input shape. a #GtkGestureMultiPress rectangle to receive coordinates on This signal is emitted whenever a button or touch press happens. how many touch/button presses happened with this one The X coordinate, in widget allocation coordinates The Y coordinate, in widget allocation coordinates This signal is emitted when a button or touch is released. @n_press will report the number of press that is paired to this event, note that #GtkGestureMultiPress::stopped may have been emitted between the press and its release, @n_press will only start over at the next press. number of press that is paired with this release The X coordinate, in widget allocation coordinates The Y coordinate, in widget allocation coordinates This signal is emitted whenever any time/distance threshold has been exceeded. #GtkGesturePan is a #GtkGesture implementation able to recognize pan gestures, those are drags that are locked to happen along one axis. The axis that a #GtkGesturePan handles is defined at construct time, and can be changed through gtk_gesture_pan_set_orientation(). When the gesture starts to be recognized, #GtkGesturePan will attempt to determine as early as possible whether the sequence is moving in the expected direction, and denying the sequence if this does not happen. Once a panning gesture along the expected axis is recognized, the #GtkGesturePan::pan signal will be emitted as input events are received, containing the offset in the given axis. Returns a newly created #GtkGesture that recognizes pan gestures. a newly created #GtkGesturePan a #GtkWidget expected orientation Returns the orientation of the pan gestures that this @gesture expects. the expected orientation for pan gestures A #GtkGesturePan Sets the orientation to be expected on pan gestures. A #GtkGesturePan expected orientation The expected orientation of pan gestures. This signal is emitted once a panning gesture along the expected axis is detected. current direction of the pan gesture Offset along the gesture orientation #GtkGestureRotate is a #GtkGesture implementation able to recognize 2-finger rotations, whenever the angle between both handled sequences changes, the #GtkGestureRotate::angle-changed signal is emitted. Returns a newly created #GtkGesture that recognizes 2-touch rotation gestures. a newly created #GtkGestureRotate a #GtkWidget If @gesture is active, this function returns the angle difference in radians since the gesture was first recognized. If @gesture is not active, 0 is returned. the angle delta in radians a #GtkGestureRotate This signal is emitted when the angle between both tracked points changes. Current angle in radians Difference with the starting angle, in radians #GtkGestureSingle is a subclass of #GtkGesture, optimized (although not restricted) for dealing with mouse and single-touch gestures. Under interaction, these gestures stick to the first interacting sequence, which is accessible through gtk_gesture_single_get_current_sequence() while the gesture is being interacted with. By default gestures react to both %GDK_BUTTON_PRIMARY and touch events, gtk_gesture_single_set_touch_only() can be used to change the touch behavior. Callers may also specify a different mouse button number to interact with through gtk_gesture_single_set_button(), or react to any mouse button by setting 0. While the gesture is active, the button being currently pressed can be known through gtk_gesture_single_get_current_button(). Returns the button number @gesture listens for, or 0 if @gesture reacts to any button press. The button number, or 0 for any button a #GtkGestureSingle Returns the button number currently interacting with @gesture, or 0 if there is none. The current button number a #GtkGestureSingle Returns the event sequence currently interacting with @gesture. This is only meaningful if gtk_gesture_is_active() returns %TRUE. the current sequence a #GtkGestureSingle Gets whether a gesture is exclusive. For more information, see gtk_gesture_single_set_exclusive(). Whether the gesture is exclusive a #GtkGestureSingle Returns %TRUE if the gesture is only triggered by touch events. %TRUE if the gesture only handles touch events a #GtkGestureSingle Sets the button number @gesture listens to. If non-0, every button press from a different button number will be ignored. Touch events implicitly match with button 1. a #GtkGestureSingle button number to listen to, or 0 for any button Sets whether @gesture is exclusive. An exclusive gesture will only handle pointer and "pointer emulated" touch events, so at any given time, there is only one sequence able to interact with those. a #GtkGestureSingle %TRUE to make @gesture exclusive If @touch_only is %TRUE, @gesture will only handle events of type #GDK_TOUCH_BEGIN, #GDK_TOUCH_UPDATE or #GDK_TOUCH_END. If %FALSE, mouse events will be handled too. a #GtkGestureSingle whether @gesture handles only touch events Mouse button number to listen to, or 0 to listen for any button. Whether the gesture is exclusive. Exclusive gestures only listen to pointer and pointer emulated events. Whether the gesture handles only touch events. #GtkGestureStylus is a #GtkGesture implementation specific to stylus input. The provided signals just provide the basic information Creates a new #GtkGestureStylus. a newly created stylus gesture a #GtkWidget Returns the current values for the requested @axes. This function must be called from either the #GtkGestureStylus:down, #GtkGestureStylus:motion, #GtkGestureStylus:up or #GtkGestureStylus:proximity signals. #TRUE if there is a current value for the axes a GtkGestureStylus array of requested axes, terminated with #GDK_AXIS_IGNORE return location for the axis values Returns the current value for the requested @axis. This function must be called from either the #GtkGestureStylus:down, #GtkGestureStylus:motion, #GtkGestureStylus:up or #GtkGestureStylus:proximity signals. #TRUE if there is a current value for the axis a #GtkGestureStylus requested device axis return location for the axis value Returns the #GdkDeviceTool currently driving input through this gesture. This function must be called from either the #GtkGestureStylus::down, #GtkGestureStylus::motion, #GtkGestureStylus::up or #GtkGestureStylus::proximity signal handlers. The current stylus tool a #GtkGestureStylus #GtkGestureSwipe is a #GtkGesture implementation able to recognize swipes, after a press/move/.../move/release sequence happens, the #GtkGestureSwipe::swipe signal will be emitted, providing the velocity and directionality of the sequence at the time it was lifted. If the velocity is desired in intermediate points, gtk_gesture_swipe_get_velocity() can be called on eg. a #GtkGesture::update handler. All velocities are reported in pixels/sec units. Returns a newly created #GtkGesture that recognizes swipes. a newly created #GtkGestureSwipe a #GtkWidget If the gesture is recognized, this function returns %TRUE and fill in @velocity_x and @velocity_y with the recorded velocity, as per the last event(s) processed. whether velocity could be calculated a #GtkGestureSwipe return value for the velocity in the X axis, in pixels/sec return value for the velocity in the Y axis, in pixels/sec This signal is emitted when the recognized gesture is finished, velocity and direction are a product of previously recorded events. velocity in the X axis, in pixels/sec velocity in the Y axis, in pixels/sec #GtkGestureZoom is a #GtkGesture implementation able to recognize pinch/zoom gestures, whenever the distance between both tracked sequences changes, the #GtkGestureZoom::scale-changed signal is emitted to report the scale factor. Returns a newly created #GtkGesture that recognizes zoom in/out gestures (usually known as pinch/zoom). a newly created #GtkGestureZoom a #GtkWidget If @gesture is active, this function returns the zooming difference since the gesture was recognized (hence the starting point is considered 1:1). If @gesture is not active, 1 is returned. the scale delta a #GtkGestureZoom This signal is emitted whenever the distance between both tracked sequences changes. Scale delta, taking the initial state as 1:1 GtkGradient is a boxed type that represents a gradient. It is the result of parsing a [gradient expression][gtkcssprovider-gradients]. To obtain the gradient represented by a GtkGradient, it has to be resolved with gtk_gradient_resolve(), which replaces all symbolic color references by the colors they refer to (in a given context) and constructs a #cairo_pattern_t value. It is not normally necessary to deal directly with #GtkGradients, since they are mostly used behind the scenes by #GtkStyleContext and #GtkCssProvider. #GtkGradient is deprecated. It was used internally by GTK’s CSS engine to represent gradients. As its handling is not conforming to modern web standards, it is not used anymore. If you want to use gradients in your own code, please use Cairo directly. Creates a new linear gradient along the line defined by (x0, y0) and (x1, y1). Before using the gradient a number of stop colors must be added through gtk_gradient_add_color_stop(). #GtkGradient is deprecated. A newly created #GtkGradient X coordinate of the starting point Y coordinate of the starting point X coordinate of the end point Y coordinate of the end point Creates a new radial gradient along the two circles defined by (x0, y0, radius0) and (x1, y1, radius1). Before using the gradient a number of stop colors must be added through gtk_gradient_add_color_stop(). #GtkGradient is deprecated. A newly created #GtkGradient X coordinate of the start circle Y coordinate of the start circle radius of the start circle X coordinate of the end circle Y coordinate of the end circle radius of the end circle Adds a stop color to @gradient. #GtkGradient is deprecated. a #GtkGradient offset for the color stop color to use Increases the reference count of @gradient. #GtkGradient is deprecated. The same @gradient a #GtkGradient If @gradient is resolvable, @resolved_gradient will be filled in with the resolved gradient as a cairo_pattern_t, and %TRUE will be returned. Generally, if @gradient can’t be resolved, it is due to it being defined on top of a named color that doesn't exist in @props. #GtkGradient is deprecated. %TRUE if the gradient has been resolved a #GtkGradient #GtkStyleProperties to use when resolving named colors return location for the resolved pattern Creates a string representation for @gradient that is suitable for using in GTK CSS files. #GtkGradient is deprecated. A string representation for @gradient the gradient to print Decreases the reference count of @gradient, freeing its memory if the reference count reaches 0. #GtkGradient is deprecated. a #GtkGradient GtkGrid is a container which arranges its child widgets in rows and columns, with arbitrary positions and horizontal/vertical spans. Children are added using gtk_grid_attach(). They can span multiple rows or columns. It is also possible to add a child next to an existing child, using gtk_grid_attach_next_to(). The behaviour of GtkGrid when several children occupy the same grid cell is undefined. GtkGrid can be used like a #GtkBox by just using gtk_container_add(), which will place children next to each other in the direction determined by the #GtkOrientable:orientation property. However, if all you want is a single row or column, then #GtkBox is the preferred widget. # CSS nodes GtkGrid uses a single CSS node with name grid. Creates a new grid widget. the new #GtkGrid Adds a widget to the grid. The position of @child is determined by @left and @top. The number of “cells” that @child will occupy is determined by @width and @height. a #GtkGrid the widget to add the column number to attach the left side of @child to the row number to attach the top side of @child to the number of columns that @child will span the number of rows that @child will span Adds a widget to the grid. The widget is placed next to @sibling, on the side determined by @side. When @sibling is %NULL, the widget is placed in row (for left or right placement) or column 0 (for top or bottom placement), at the end indicated by @side. Attaching widgets labeled [1], [2], [3] with @sibling == %NULL and @side == %GTK_POS_LEFT yields a layout of [3][2][1]. a #GtkGrid the widget to add the child of @grid that @child will be placed next to, or %NULL to place @child at the beginning or end the side of @sibling that @child is positioned next to the number of columns that @child will span the number of rows that @child will span Returns which row defines the global baseline of @grid. the row index defining the global baseline a #GtkGrid Gets the child of @grid whose area covers the grid cell whose upper left corner is at @left, @top. the child at the given position, or %NULL a #GtkGrid the left edge of the cell the top edge of the cell Returns whether all columns of @grid have the same width. whether all columns of @grid have the same width. a #GtkGrid Returns the amount of space between the columns of @grid. the column spacing of @grid a #GtkGrid Returns the baseline position of @row as set by gtk_grid_set_row_baseline_position() or the default value %GTK_BASELINE_POSITION_CENTER. the baseline position of @row a #GtkGrid a row index Returns whether all rows of @grid have the same height. whether all rows of @grid have the same height. a #GtkGrid Returns the amount of space between the rows of @grid. the row spacing of @grid a #GtkGrid Inserts a column at the specified position. Children which are attached at or to the right of this position are moved one column to the right. Children which span across this position are grown to span the new column. a #GtkGrid the position to insert the column at Inserts a row or column at the specified position. The new row or column is placed next to @sibling, on the side determined by @side. If @side is %GTK_POS_TOP or %GTK_POS_BOTTOM, a row is inserted. If @side is %GTK_POS_LEFT of %GTK_POS_RIGHT, a column is inserted. a #GtkGrid the child of @grid that the new row or column will be placed next to the side of @sibling that @child is positioned next to Inserts a row at the specified position. Children which are attached at or below this position are moved one row down. Children which span across this position are grown to span the new row. a #GtkGrid the position to insert the row at Removes a column from the grid. Children that are placed in this column are removed, spanning children that overlap this column have their width reduced by one, and children after the column are moved to the left. a #GtkGrid the position of the column to remove Removes a row from the grid. Children that are placed in this row are removed, spanning children that overlap this row have their height reduced by one, and children below the row are moved up. a #GtkGrid the position of the row to remove Sets which row defines the global baseline for the entire grid. Each row in the grid can have its own local baseline, but only one of those is global, meaning it will be the baseline in the parent of the @grid. a #GtkGrid the row index Sets whether all columns of @grid will have the same width. a #GtkGrid %TRUE to make columns homogeneous Sets the amount of space between columns of @grid. a #GtkGrid the amount of space to insert between columns Sets how the baseline should be positioned on @row of the grid, in case that row is assigned more space than is requested. a #GtkGrid a row index a #GtkBaselinePosition Sets whether all rows of @grid will have the same height. a #GtkGrid %TRUE to make rows homogeneous Sets the amount of space between rows of @grid. a #GtkGrid the amount of space to insert between rows The parent class. #GtkHBox is a container that organizes child widgets into a single row. Use the #GtkBox packing interface to determine the arrangement, spacing, width, and alignment of #GtkHBox children. All children are allocated the same height. GtkHBox has been deprecated. You can use #GtkBox instead, which is a very quick and easy change. If you have derived your own classes from GtkHBox, you can simply change the inheritance to derive directly from #GtkBox. No further changes are needed, since the default value of the #GtkOrientable:orientation property is %GTK_ORIENTATION_HORIZONTAL. If you have a grid-like layout composed of nested boxes, and you don’t need first-child or last-child styling, the recommendation is to switch to #GtkGrid. For more information about migrating to #GtkGrid, see [Migrating from other containers to GtkGrid][gtk-migrating-GtkGrid]. Creates a new #GtkHBox. You can use gtk_box_new() with %GTK_ORIENTATION_HORIZONTAL instead, which is a quick and easy change. But the recommendation is to switch to #GtkGrid, since #GtkBox is going to go away eventually. See [Migrating from other containers to GtkGrid][gtk-migrating-GtkGrid]. a new #GtkHBox. %TRUE if all children are to be given equal space allotments. the number of pixels to place by default between children. Creates a new horizontal button box. Use gtk_button_box_new() with %GTK_ORIENTATION_HORIZONTAL instead a new button box #GtkWidget. The HPaned widget is a container widget with two children arranged horizontally. The division between the two panes is adjustable by the user by dragging a handle. See #GtkPaned for details. GtkHPaned has been deprecated, use #GtkPaned instead. Create a new #GtkHPaned Use gtk_paned_new() with %GTK_ORIENTATION_HORIZONTAL instead the new #GtkHPaned #GtkHSV is the “color wheel” part of a complete color selector widget. It allows to select a color by determining its HSV components in an intuitive way. Moving the selection around the outer ring changes the hue, and moving the selection point inside the inner triangle changes value and saturation. #GtkHSV has been deprecated together with #GtkColorSelection, where it was used. Creates a new HSV color selector. A newly-created HSV color selector. Converts a color from HSV space to RGB. Input values must be in the [0.0, 1.0] range; output values will be in the same range. Hue Saturation Value Return value for the red component Return value for the green component Return value for the blue component Queries the current color in an HSV color selector. Returned values will be in the [0.0, 1.0] range. An HSV color selector Return value for the hue Return value for the saturation Return value for the value Queries the size and ring width of an HSV color selector. An HSV color selector Return value for the diameter of the hue ring Return value for the width of the hue ring An HSV color selector can be said to be adjusting if multiple rapid changes are being made to its value, for example, when the user is adjusting the value with the mouse. This function queries whether the HSV color selector is being adjusted or not. %TRUE if clients can ignore changes to the color value, since they may be transitory, or %FALSE if they should consider the color value status to be final. A #GtkHSV Sets the current color in an HSV color selector. Color component values must be in the [0.0, 1.0] range. An HSV color selector Hue Saturation Value Sets the size and ring width of an HSV color selector. An HSV color selector Diameter for the hue ring Width of the hue ring The #GtkHScale widget is used to allow the user to select a value using a horizontal slider. To create one, use gtk_hscale_new_with_range(). The position to show the current value, and the number of decimal places shown can be set using the parent #GtkScale class’s functions. GtkHScale has been deprecated, use #GtkScale instead. Creates a new #GtkHScale. Use gtk_scale_new() with %GTK_ORIENTATION_HORIZONTAL instead a new #GtkHScale. the #GtkAdjustment which sets the range of the scale. Creates a new horizontal scale widget that lets the user input a number between @min and @max (including @min and @max) with the increment @step. @step must be nonzero; it’s the distance the slider moves when using the arrow keys to adjust the scale value. Note that the way in which the precision is derived works best if @step is a power of ten. If the resulting precision is not suitable for your needs, use gtk_scale_set_digits() to correct it. Use gtk_scale_new_with_range() with %GTK_ORIENTATION_HORIZONTAL instead a new #GtkHScale minimum value maximum value step increment (tick size) used with keyboard shortcuts The #GtkHScrollbar widget is a widget arranged horizontally creating a scrollbar. See #GtkScrollbar for details on scrollbars. #GtkAdjustment pointers may be added to handle the adjustment of the scrollbar or it may be left %NULL in which case one will be created for you. See #GtkScrollbar for a description of what the fields in an adjustment represent for a scrollbar. GtkHScrollbar has been deprecated, use #GtkScrollbar instead. Creates a new horizontal scrollbar. Use gtk_scrollbar_new() with %GTK_ORIENTATION_HORIZONTAL instead the new #GtkHScrollbar the #GtkAdjustment to use, or %NULL to create a new adjustment The #GtkHSeparator widget is a horizontal separator, used to group the widgets within a window. It displays a horizontal line with a shadow to make it appear sunken into the interface. > The #GtkHSeparator widget is not used as a separator within menus. > To create a separator in a menu create an empty #GtkSeparatorMenuItem > widget using gtk_separator_menu_item_new() and add it to the menu with > gtk_menu_shell_append(). GtkHSeparator has been deprecated, use #GtkSeparator instead. Creates a new #GtkHSeparator. Use gtk_separator_new() with %GTK_ORIENTATION_HORIZONTAL instead a new #GtkHSeparator. The #GtkHandleBox widget allows a portion of a window to be "torn off". It is a bin widget which displays its child and a handle that the user can drag to tear off a separate window (the “float window”) containing the child widget. A thin “ghost” is drawn in the original location of the handlebox. By dragging the separate window back to its original location, it can be reattached. When reattaching, the ghost and float window, must be aligned along one of the edges, the “snap edge”. This either can be specified by the application programmer explicitly, or GTK+ will pick a reasonable default based on the handle position. To make detaching and reattaching the handlebox as minimally confusing as possible to the user, it is important to set the snap edge so that the snap edge does not move when the handlebox is deattached. For instance, if the handlebox is packed at the bottom of a VBox, then when the handlebox is detached, the bottom edge of the handlebox's allocation will remain fixed as the height of the handlebox shrinks, so the snap edge should be set to %GTK_POS_BOTTOM. > #GtkHandleBox has been deprecated. It is very specialized, lacks features > to make it useful and most importantly does not fit well into modern > application design. Do not use it. There is no replacement. Create a new handle box. #GtkHandleBox has been deprecated. a new #GtkHandleBox. Whether the handlebox’s child is currently detached. #GtkHandleBox has been deprecated. %TRUE if the child is currently detached, otherwise %FALSE a #GtkHandleBox Gets the handle position of the handle box. See gtk_handle_box_set_handle_position(). #GtkHandleBox has been deprecated. the current handle position. a #GtkHandleBox Gets the type of shadow drawn around the handle box. See gtk_handle_box_set_shadow_type(). #GtkHandleBox has been deprecated. the type of shadow currently drawn around the handle box. a #GtkHandleBox Gets the edge used for determining reattachment of the handle box. See gtk_handle_box_set_snap_edge(). #GtkHandleBox has been deprecated. the edge used for determining reattachment, or (GtkPositionType)-1 if this is determined (as per default) from the handle position. a #GtkHandleBox Sets the side of the handlebox where the handle is drawn. #GtkHandleBox has been deprecated. a #GtkHandleBox the side of the handlebox where the handle should be drawn. Sets the type of shadow to be drawn around the border of the handle box. #GtkHandleBox has been deprecated. a #GtkHandleBox the shadow type. Sets the snap edge of a handlebox. The snap edge is the edge of the detached child that must be aligned with the corresponding edge of the “ghost” left behind when the child was detached to reattach the torn-off window. Usually, the snap edge should be chosen so that it stays in the same place on the screen when the handlebox is torn off. If the snap edge is not set, then an appropriate value will be guessed from the handle position. If the handle position is %GTK_POS_RIGHT or %GTK_POS_LEFT, then the snap edge will be %GTK_POS_TOP, otherwise it will be %GTK_POS_LEFT. #GtkHandleBox has been deprecated. a #GtkHandleBox the snap edge, or -1 to unset the value; in which case GTK+ will try to guess an appropriate value in the future. This signal is emitted when the contents of the handlebox are reattached to the main window. #GtkHandleBox has been deprecated. the child widget of the handlebox. (this argument provides no extra information and is here only for backwards-compatibility) This signal is emitted when the contents of the handlebox are detached from the main window. #GtkHandleBox has been deprecated. the child widget of the handlebox. (this argument provides no extra information and is here only for backwards-compatibility) The parent class. GtkHeaderBar is similar to a horizontal #GtkBox. It allows children to be placed at the start or the end. In addition, it allows a title and subtitle to be displayed. The title will be centered with respect to the width of the box, even if the children at either side take up different amounts of space. The height of the titlebar will be set to provide sufficient space for the subtitle, even if none is currently set. If a subtitle is not needed, the space reservation can be turned off with gtk_header_bar_set_has_subtitle(). GtkHeaderBar can add typical window frame controls, such as minimize, maximize and close buttons, or the window icon. For these reasons, GtkHeaderBar is the natural choice for use as the custom titlebar widget of a #GtkWindow (see gtk_window_set_titlebar()), as it gives features typical of titlebars while allowing the addition of child widgets. Creates a new #GtkHeaderBar widget. a new #GtkHeaderBar Retrieves the custom title widget of the header. See gtk_header_bar_set_custom_title(). the custom title widget of the header, or %NULL if none has been set explicitly. a #GtkHeaderBar Gets the decoration layout set with gtk_header_bar_set_decoration_layout(). the decoration layout a #GtkHeaderBar Retrieves whether the header bar reserves space for a subtitle, regardless if one is currently set or not. %TRUE if the header bar reserves space for a subtitle a #GtkHeaderBar Returns whether this header bar shows the standard window decorations. %TRUE if the decorations are shown a #GtkHeaderBar Retrieves the subtitle of the header. See gtk_header_bar_set_subtitle(). the subtitle of the header, or %NULL if none has been set explicitly. The returned string is owned by the widget and must not be modified or freed. a #GtkHeaderBar Retrieves the title of the header. See gtk_header_bar_set_title(). the title of the header, or %NULL if none has been set explicitly. The returned string is owned by the widget and must not be modified or freed. a #GtkHeaderBar Adds @child to @bar, packed with reference to the end of the @bar. A #GtkHeaderBar the #GtkWidget to be added to @bar Adds @child to @bar, packed with reference to the start of the @bar. A #GtkHeaderBar the #GtkWidget to be added to @bar Sets a custom title for the #GtkHeaderBar. The title should help a user identify the current view. This supersedes any title set by gtk_header_bar_set_title() or gtk_header_bar_set_subtitle(). To achieve the same style as the builtin title and subtitle, use the “title” and “subtitle” style classes. You should set the custom title to %NULL, for the header title label to be visible again. a #GtkHeaderBar a custom widget to use for a title Sets the decoration layout for this header bar, overriding the #GtkSettings:gtk-decoration-layout setting. There can be valid reasons for overriding the setting, such as a header bar design that does not allow for buttons to take room on the right, or only offers room for a single close button. Split header bars are another example for overriding the setting. The format of the string is button names, separated by commas. A colon separates the buttons that should appear on the left from those on the right. Recognized button names are minimize, maximize, close, icon (the window icon) and menu (a menu button for the fallback app menu). For example, “menu:minimize,maximize,close” specifies a menu on the left, and minimize, maximize and close buttons on the right. a #GtkHeaderBar a decoration layout, or %NULL to unset the layout Sets whether the header bar should reserve space for a subtitle, even if none is currently set. a #GtkHeaderBar %TRUE to reserve space for a subtitle Sets whether this header bar shows the standard window decorations, including close, maximize, and minimize. a #GtkHeaderBar %TRUE to show standard window decorations Sets the subtitle of the #GtkHeaderBar. The title should give a user an additional detail to help him identify the current view. Note that GtkHeaderBar by default reserves room for the subtitle, even if none is currently set. If this is not desired, set the #GtkHeaderBar:has-subtitle property to %FALSE. a #GtkHeaderBar a subtitle, or %NULL Sets the title of the #GtkHeaderBar. The title should help a user identify the current view. A good title should not include the application name. a #GtkHeaderBar a title, or %NULL The decoration layout for buttons. If this property is not set, the #GtkSettings:gtk-decoration-layout setting is used. See gtk_header_bar_set_decoration_layout() for information about the format of this string. Set to %TRUE if #GtkHeaderBar:decoration-layout is set. If %TRUE, reserve space for a subtitle, even if none is currently set. Whether to show window decorations. Which buttons are actually shown and where is determined by the #GtkHeaderBar:decoration-layout property, and by the state of the window (e.g. a close button will not be shown if the window can't be closed). #GtkIMContext defines the interface for GTK+ input methods. An input method is used by GTK+ text input widgets like #GtkEntry to map from key events to Unicode character strings. The default input method can be set programmatically via the #GtkSettings:gtk-im-module GtkSettings property. Alternatively, you may set the GTK_IM_MODULE environment variable as documented in [Running GTK+ Applications][gtk-running]. The #GtkEntry #GtkEntry:im-module and #GtkTextView #GtkTextView:im-module properties may also be used to set input methods for specific widget instances. For instance, a certain entry widget might be expected to contain certain characters which would be easier to input with a certain input method. An input method may consume multiple key events in sequence and finally output the composed result. This is called preediting, and an input method may provide feedback about this process by displaying the intermediate composition states as preedit text. For instance, the default GTK+ input method implements the input of arbitrary Unicode code points by holding down the Control and Shift keys and then typing “U” followed by the hexadecimal digits of the code point. When releasing the Control and Shift keys, preediting ends and the character is inserted as text. Ctrl+Shift+u20AC for example results in the euro sign. Additional input methods can be made available for use by GTK+ widgets as loadable modules. An input method module is a small shared library which implements a subclass of #GtkIMContext or #GtkIMContextSimple and exports these four functions: |[<!-- language="C" --> void im_module_init(GTypeModule *module); ]| This function should register the #GType of the #GtkIMContext subclass which implements the input method by means of g_type_module_register_type(). Note that g_type_register_static() cannot be used as the type needs to be registered dynamically. |[<!-- language="C" --> void im_module_exit(void); ]| Here goes any cleanup code your input method might require on module unload. |[<!-- language="C" --> void im_module_list(const GtkIMContextInfo ***contexts, int *n_contexts) { *contexts = info_list; *n_contexts = G_N_ELEMENTS (info_list); } ]| This function returns the list of input methods provided by the module. The example implementation above shows a common solution and simply returns a pointer to statically defined array of #GtkIMContextInfo items for each provided input method. |[<!-- language="C" --> GtkIMContext * im_module_create(const gchar *context_id); ]| This function should return a pointer to a newly created instance of the #GtkIMContext subclass identified by @context_id. The context ID is the same as specified in the #GtkIMContextInfo array returned by im_module_list(). After a new loadable input method module has been installed on the system, the configuration file `gtk.immodules` needs to be regenerated by [gtk-query-immodules-3.0][gtk-query-immodules-3.0], in order for the new input method to become available to GTK+ applications. Asks the widget that the input context is attached to to delete characters around the cursor position by emitting the GtkIMContext::delete_surrounding signal. Note that @offset and @n_chars are in characters not in bytes which differs from the usage other places in #GtkIMContext. In order to use this function, you should first call gtk_im_context_get_surrounding() to get the current context, and call this function immediately afterwards to make sure that you know what you are deleting. You should also account for the fact that even if the signal was handled, the input context might not have deleted all the characters that were requested to be deleted. This function is used by an input method that wants to make subsitutions in the existing text in response to new input. It is not useful for applications. %TRUE if the signal was handled. a #GtkIMContext offset from cursor position in chars; a negative value means start before the cursor. number of characters to delete. Allow an input method to internally handle key press and release events. If this function returns %TRUE, then no further processing should be done for this key event. %TRUE if the input method handled the key event. a #GtkIMContext the key event Notify the input method that the widget to which this input context corresponds has gained focus. The input method may, for example, change the displayed feedback to reflect this change. a #GtkIMContext Notify the input method that the widget to which this input context corresponds has lost focus. The input method may, for example, change the displayed feedback or reset the contexts state to reflect this change. a #GtkIMContext Retrieve the current preedit string for the input context, and a list of attributes to apply to the string. This string should be displayed inserted at the insertion point. a #GtkIMContext location to store the retrieved string. The string retrieved must be freed with g_free(). location to store the retrieved attribute list. When you are done with this list, you must unreference it with pango_attr_list_unref(). location to store position of cursor (in characters) within the preedit string. Retrieves context around the insertion point. Input methods typically want context in order to constrain input text based on existing text; this is important for languages such as Thai where only some sequences of characters are allowed. This function is implemented by emitting the GtkIMContext::retrieve_surrounding signal on the input method; in response to this signal, a widget should provide as much context as is available, up to an entire paragraph, by calling gtk_im_context_set_surrounding(). Note that there is no obligation for a widget to respond to the ::retrieve_surrounding signal, so input methods must be prepared to function without context. %TRUE if surrounding text was provided; in this case you must free the result stored in *text. a #GtkIMContext location to store a UTF-8 encoded string of text holding context around the insertion point. If the function returns %TRUE, then you must free the result stored in this location with g_free(). location to store byte index of the insertion cursor within @text. Notify the input method that a change such as a change in cursor position has been made. This will typically cause the input method to clear the preedit state. a #GtkIMContext Set the client window for the input context; this is the #GdkWindow in which the input appears. This window is used in order to correctly position status windows, and may also be used for purposes internal to the input method. a #GtkIMContext the client window. This may be %NULL to indicate that the previous client window no longer exists. Notify the input method that a change in cursor position has been made. The location is relative to the client window. a #GtkIMContext new location Sets surrounding context around the insertion point and preedit string. This function is expected to be called in response to the GtkIMContext::retrieve_surrounding signal, and will likely have no effect if called at other times. a #GtkIMContext text surrounding the insertion point, as UTF-8. the preedit string should not be included within @text. the length of @text, or -1 if @text is nul-terminated the byte index of the insertion cursor within @text. Sets whether the IM context should use the preedit string to display feedback. If @use_preedit is FALSE (default is TRUE), then the IM context may use some other method to display feedback, such as displaying it in a child of the root window. a #GtkIMContext whether the IM context should use the preedit string. Asks the widget that the input context is attached to to delete characters around the cursor position by emitting the GtkIMContext::delete_surrounding signal. Note that @offset and @n_chars are in characters not in bytes which differs from the usage other places in #GtkIMContext. In order to use this function, you should first call gtk_im_context_get_surrounding() to get the current context, and call this function immediately afterwards to make sure that you know what you are deleting. You should also account for the fact that even if the signal was handled, the input context might not have deleted all the characters that were requested to be deleted. This function is used by an input method that wants to make subsitutions in the existing text in response to new input. It is not useful for applications. %TRUE if the signal was handled. a #GtkIMContext offset from cursor position in chars; a negative value means start before the cursor. number of characters to delete. Allow an input method to internally handle key press and release events. If this function returns %TRUE, then no further processing should be done for this key event. %TRUE if the input method handled the key event. a #GtkIMContext the key event Notify the input method that the widget to which this input context corresponds has gained focus. The input method may, for example, change the displayed feedback to reflect this change. a #GtkIMContext Notify the input method that the widget to which this input context corresponds has lost focus. The input method may, for example, change the displayed feedback or reset the contexts state to reflect this change. a #GtkIMContext Retrieve the current preedit string for the input context, and a list of attributes to apply to the string. This string should be displayed inserted at the insertion point. a #GtkIMContext location to store the retrieved string. The string retrieved must be freed with g_free(). location to store the retrieved attribute list. When you are done with this list, you must unreference it with pango_attr_list_unref(). location to store position of cursor (in characters) within the preedit string. Retrieves context around the insertion point. Input methods typically want context in order to constrain input text based on existing text; this is important for languages such as Thai where only some sequences of characters are allowed. This function is implemented by emitting the GtkIMContext::retrieve_surrounding signal on the input method; in response to this signal, a widget should provide as much context as is available, up to an entire paragraph, by calling gtk_im_context_set_surrounding(). Note that there is no obligation for a widget to respond to the ::retrieve_surrounding signal, so input methods must be prepared to function without context. %TRUE if surrounding text was provided; in this case you must free the result stored in *text. a #GtkIMContext location to store a UTF-8 encoded string of text holding context around the insertion point. If the function returns %TRUE, then you must free the result stored in this location with g_free(). location to store byte index of the insertion cursor within @text. Notify the input method that a change such as a change in cursor position has been made. This will typically cause the input method to clear the preedit state. a #GtkIMContext Set the client window for the input context; this is the #GdkWindow in which the input appears. This window is used in order to correctly position status windows, and may also be used for purposes internal to the input method. a #GtkIMContext the client window. This may be %NULL to indicate that the previous client window no longer exists. Notify the input method that a change in cursor position has been made. The location is relative to the client window. a #GtkIMContext new location Sets surrounding context around the insertion point and preedit string. This function is expected to be called in response to the GtkIMContext::retrieve_surrounding signal, and will likely have no effect if called at other times. a #GtkIMContext text surrounding the insertion point, as UTF-8. the preedit string should not be included within @text. the length of @text, or -1 if @text is nul-terminated the byte index of the insertion cursor within @text. Sets whether the IM context should use the preedit string to display feedback. If @use_preedit is FALSE (default is TRUE), then the IM context may use some other method to display feedback, such as displaying it in a child of the root window. a #GtkIMContext whether the IM context should use the preedit string. The ::commit signal is emitted when a complete input sequence has been entered by the user. This can be a single character immediately after a key press or the final result of preediting. the completed character(s) entered by the user The ::delete-surrounding signal is emitted when the input method needs to delete all or part of the context surrounding the cursor. %TRUE if the signal was handled. the character offset from the cursor position of the text to be deleted. A negative value indicates a position before the cursor. the number of characters to be deleted The ::preedit-changed signal is emitted whenever the preedit sequence currently being entered has changed. It is also emitted at the end of a preedit sequence, in which case gtk_im_context_get_preedit_string() returns the empty string. The ::preedit-end signal is emitted when a preediting sequence has been completed or canceled. The ::preedit-start signal is emitted when a new preediting sequence starts. The ::retrieve-surrounding signal is emitted when the input method requires the context surrounding the cursor. The callback should set the input method surrounding context by calling the gtk_im_context_set_surrounding() method. %TRUE if the signal was handled. %TRUE if the signal was handled. a #GtkIMContext offset from cursor position in chars; a negative value means start before the cursor. number of characters to delete. a #GtkIMContext the client window. This may be %NULL to indicate that the previous client window no longer exists. a #GtkIMContext location to store the retrieved string. The string retrieved must be freed with g_free(). location to store the retrieved attribute list. When you are done with this list, you must unreference it with pango_attr_list_unref(). location to store position of cursor (in characters) within the preedit string. %TRUE if the input method handled the key event. a #GtkIMContext the key event a #GtkIMContext a #GtkIMContext a #GtkIMContext a #GtkIMContext new location a #GtkIMContext whether the IM context should use the preedit string. a #GtkIMContext text surrounding the insertion point, as UTF-8. the preedit string should not be included within @text. the length of @text, or -1 if @text is nul-terminated the byte index of the insertion cursor within @text. %TRUE if surrounding text was provided; in this case you must free the result stored in *text. a #GtkIMContext location to store a UTF-8 encoded string of text holding context around the insertion point. If the function returns %TRUE, then you must free the result stored in this location with g_free(). location to store byte index of the insertion cursor within @text. Bookkeeping information about a loadable input method. The unique identification string of the input method. The human-readable name of the input method. Translation domain to be used with dgettext() Name of locale directory for use with bindtextdomain() A colon-separated list of locales where this input method should be the default. The asterisk “*” sets the default for all locales. GtkIMContextSimple is a simple input method context supporting table-based input methods. It has a built-in table of compose sequences that is derived from the X11 Compose files. GtkIMContextSimple reads additional compose sequences from the first of the following files that is found: ~/.config/gtk-3.0/Compose, ~/.XCompose, /usr/share/X11/locale/$locale/Compose (for locales that have a nontrivial Compose file). The syntax of these files is described in the Compose(5) manual page. GtkIMContextSimple also supports numeric entry of Unicode characters by typing Ctrl-Shift-u, followed by a hexadecimal Unicode codepoint. For example, Ctrl-Shift-u 1 2 3 Enter yields U+0123 LATIN SMALL LETTER G WITH CEDILLA, i.e. ģ. Creates a new #GtkIMContextSimple. a new #GtkIMContextSimple. Adds an additional table to search to the input context. Each row of the table consists of @max_seq_len key symbols followed by two #guint16 interpreted as the high and low words of a #gunicode value. Tables are searched starting from the last added. The table must be sorted in dictionary order on the numeric value of the key symbol fields. (Values beyond the length of the sequence should be zero.) A #GtkIMContextSimple the table Maximum length of a sequence in the table (cannot be greater than #GTK_MAX_COMPOSE_LEN) number of sequences in the table Creates a new #GtkIMMulticontext. a new #GtkIMMulticontext. Add menuitems for various available input methods to a menu; the menuitems, when selected, will switch the input method for the context and the global default input method. It is better to use the system-wide input method framework for changing input methods. Modern desktop shells offer on-screen displays for this that can triggered with a keyboard shortcut, e.g. Super-Space. a #GtkIMMulticontext a #GtkMenuShell Gets the id of the currently active slave of the @context. the id of the currently active slave a #GtkIMMulticontext Sets the context id for @context. This causes the currently active slave of @context to be replaced by the slave corresponding to the new context id. a #GtkIMMulticontext the id to use Style for input method preedit. See also #GtkSettings:gtk-im-preedit-style Deprecated Deprecated Deprecated Style for input method status. See also #GtkSettings:gtk-im-status-style Deprecated Deprecated Deprecated Constant to return from a signal handler for the #GtkSpinButton::input signal in case of conversion failure. Like gtk_get_interface_age(), but from the headers used at application compile time, rather than from the library linked against at application run time. An icon factory manages a collection of #GtkIconSet; a #GtkIconSet manages a set of variants of a particular icon (i.e. a #GtkIconSet contains variants for different sizes and widget states). Icons in an icon factory are named by a stock ID, which is a simple string identifying the icon. Each #GtkStyle has a list of #GtkIconFactory derived from the current theme; those icon factories are consulted first when searching for an icon. If the theme doesn’t set a particular icon, GTK+ looks for the icon in a list of default icon factories, maintained by gtk_icon_factory_add_default() and gtk_icon_factory_remove_default(). Applications with icons should add a default icon factory with their icons, which will allow themes to override the icons for the application. To display an icon, always use gtk_style_lookup_icon_set() on the widget that will display the icon, or the convenience function gtk_widget_render_icon(). These functions take the theme into account when looking up the icon to use for a given stock ID. # GtkIconFactory as GtkBuildable # {#GtkIconFactory-BUILDER-UI} GtkIconFactory supports a custom <sources> element, which can contain multiple <source> elements. The following attributes are allowed: - stock-id The stock id of the source, a string. This attribute is mandatory - filename The filename of the source, a string. This attribute is optional - icon-name The icon name for the source, a string. This attribute is optional. - size Size of the icon, a #GtkIconSize enum value. This attribute is optional. - direction Direction of the source, a #GtkTextDirection enum value. This attribute is optional. - state State of the source, a #GtkStateType enum value. This attribute is optional. ## A #GtkIconFactory UI definition fragment. ## |[ <object class="GtkIconFactory" id="iconfactory1"> <sources> <source stock-id="apple-red" filename="apple-red.png"/> </sources> </object> <object class="GtkWindow" id="window1"> <child> <object class="GtkButton" id="apple_button"> <property name="label">apple-red</property> <property name="use-stock">True</property> </object> </child> </object> ]| Creates a new #GtkIconFactory. An icon factory manages a collection of #GtkIconSets; a #GtkIconSet manages a set of variants of a particular icon (i.e. a #GtkIconSet contains variants for different sizes and widget states). Icons in an icon factory are named by a stock ID, which is a simple string identifying the icon. Each #GtkStyle has a list of #GtkIconFactorys derived from the current theme; those icon factories are consulted first when searching for an icon. If the theme doesn’t set a particular icon, GTK+ looks for the icon in a list of default icon factories, maintained by gtk_icon_factory_add_default() and gtk_icon_factory_remove_default(). Applications with icons should add a default icon factory with their icons, which will allow themes to override the icons for the application. Use #GtkIconTheme instead. a new #GtkIconFactory Looks for an icon in the list of default icon factories. For display to the user, you should use gtk_style_lookup_icon_set() on the #GtkStyle for the widget that will display the icon, instead of using this function directly, so that themes are taken into account. Use #GtkIconTheme instead. a #GtkIconSet, or %NULL an icon name Adds the given @icon_set to the icon factory, under the name @stock_id. @stock_id should be namespaced for your application, e.g. “myapp-whatever-icon”. Normally applications create a #GtkIconFactory, then add it to the list of default factories with gtk_icon_factory_add_default(). Then they pass the @stock_id to widgets such as #GtkImage to display the icon. Themes can provide an icon with the same name (such as "myapp-whatever-icon") to override your application’s default icons. If an icon already existed in @factory for @stock_id, it is unreferenced and replaced with the new @icon_set. Use #GtkIconTheme instead. a #GtkIconFactory icon name icon set Adds an icon factory to the list of icon factories searched by gtk_style_lookup_icon_set(). This means that, for example, gtk_image_new_from_stock() will be able to find icons in @factory. There will normally be an icon factory added for each library or application that comes with icons. The default icon factories can be overridden by themes. Use #GtkIconTheme instead. a #GtkIconFactory Looks up @stock_id in the icon factory, returning an icon set if found, otherwise %NULL. For display to the user, you should use gtk_style_lookup_icon_set() on the #GtkStyle for the widget that will display the icon, instead of using this function directly, so that themes are taken into account. Use #GtkIconTheme instead. icon set of @stock_id. a #GtkIconFactory an icon name Removes an icon factory from the list of default icon factories. Not normally used; you might use it for a library that can be unloaded or shut down. Use #GtkIconTheme instead. a #GtkIconFactory previously added with gtk_icon_factory_add_default() The parent class. Contains information found when looking up an icon in an icon theme. Creates a #GtkIconInfo for a #GdkPixbuf. a #GtkIconInfo a #GtkIconTheme the pixbuf to wrap in a #GtkIconInfo Make a copy of a #GtkIconInfo. Use g_object_ref() the new GtkIconInfo a #GtkIconInfo Free a #GtkIconInfo and associated information Use g_object_unref() a #GtkIconInfo This function is deprecated and always returns %FALSE. Attachment points are deprecated %FALSE a #GtkIconInfo location to store pointer to an array of points, or %NULL free the array of points with g_free(). location to store the number of points in @points, or %NULL Gets the base scale for the icon. The base scale is a scale for the icon that was specified by the icon theme creator. For instance an icon drawn for a high-dpi screen with window scale 2 for a base size of 32 will be 64 pixels tall and have a base scale of 2. the base scale a #GtkIconInfo Gets the base size for the icon. The base size is a size for the icon that was specified by the icon theme creator. This may be different than the actual size of image; an example of this is small emblem icons that can be attached to a larger icon. These icons will be given the same base size as the larger icons to which they are attached. Note that for scaled icons the base size does not include the base scale. the base size, or 0, if no base size is known for the icon. a #GtkIconInfo Gets the built-in image for this icon, if any. To allow GTK+ to use built in icon images, you must pass the %GTK_ICON_LOOKUP_USE_BUILTIN to gtk_icon_theme_lookup_icon(). This function is deprecated, use gtk_icon_theme_add_resource_path() instead of builtin icons. the built-in image pixbuf, or %NULL. No extra reference is added to the returned pixbuf, so if you want to keep it around, you must use g_object_ref(). The returned image must not be modified. a #GtkIconInfo This function is deprecated and always returns %NULL. Display names are deprecated %NULL a #GtkIconInfo This function is deprecated and always returns %FALSE. Embedded rectangles are deprecated %FALSE a #GtkIconInfo #GdkRectangle in which to store embedded rectangle coordinates; coordinates are only stored when this function returns %TRUE. Gets the filename for the icon. If the %GTK_ICON_LOOKUP_USE_BUILTIN flag was passed to gtk_icon_theme_lookup_icon(), there may be no filename if a builtin icon is returned; in this case, you should use gtk_icon_info_get_builtin_pixbuf(). the filename for the icon, or %NULL if gtk_icon_info_get_builtin_pixbuf() should be used instead. The return value is owned by GTK+ and should not be modified or freed. a #GtkIconInfo Checks if the icon is symbolic or not. This currently uses only the file name and not the file contents for determining this. This behaviour may change in the future. %TRUE if the icon is symbolic, %FALSE otherwise a #GtkIconInfo Renders an icon previously looked up in an icon theme using gtk_icon_theme_lookup_icon(); the size will be based on the size passed to gtk_icon_theme_lookup_icon(). Note that the resulting pixbuf may not be exactly this size; an icon theme may have icons that differ slightly from their nominal sizes, and in addition GTK+ will avoid scaling icons that it considers sufficiently close to the requested size or for which the source image would have to be scaled up too far. (This maintains sharpness.). This behaviour can be changed by passing the %GTK_ICON_LOOKUP_FORCE_SIZE flag when obtaining the #GtkIconInfo. If this flag has been specified, the pixbuf returned by this function will be scaled to the exact size. the rendered icon; this may be a newly created icon or a new reference to an internal icon, so you must not modify the icon. Use g_object_unref() to release your reference to the icon. a #GtkIconInfo from gtk_icon_theme_lookup_icon() Asynchronously load, render and scale an icon previously looked up from the icon theme using gtk_icon_theme_lookup_icon(). For more details, see gtk_icon_info_load_icon() which is the synchronous version of this call. a #GtkIconInfo from gtk_icon_theme_lookup_icon() optional #GCancellable object, %NULL to ignore a #GAsyncReadyCallback to call when the request is satisfied the data to pass to callback function Finishes an async icon load, see gtk_icon_info_load_icon_async(). the rendered icon; this may be a newly created icon or a new reference to an internal icon, so you must not modify the icon. Use g_object_unref() to release your reference to the icon. a #GtkIconInfo from gtk_icon_theme_lookup_icon() a #GAsyncResult Renders an icon previously looked up in an icon theme using gtk_icon_theme_lookup_icon(); the size will be based on the size passed to gtk_icon_theme_lookup_icon(). Note that the resulting surface may not be exactly this size; an icon theme may have icons that differ slightly from their nominal sizes, and in addition GTK+ will avoid scaling icons that it considers sufficiently close to the requested size or for which the source image would have to be scaled up too far. (This maintains sharpness.). This behaviour can be changed by passing the %GTK_ICON_LOOKUP_FORCE_SIZE flag when obtaining the #GtkIconInfo. If this flag has been specified, the pixbuf returned by this function will be scaled to the exact size. the rendered icon; this may be a newly created icon or a new reference to an internal icon, so you must not modify the icon. Use cairo_surface_destroy() to release your reference to the icon. a #GtkIconInfo from gtk_icon_theme_lookup_icon() #GdkWindow to optimize drawing for, or %NULL Loads an icon, modifying it to match the system colours for the foreground, success, warning and error colors provided. If the icon is not a symbolic one, the function will return the result from gtk_icon_info_load_icon(). This allows loading symbolic icons that will match the system theme. Unless you are implementing a widget, you will want to use g_themed_icon_new_with_default_fallbacks() to load the icon. As implementation details, the icon loaded needs to be of SVG type, contain the “symbolic” term as the last component of the icon name, and use the “fg”, “success”, “warning” and “error” CSS styles in the SVG file itself. See the [Symbolic Icons Specification](http://www.freedesktop.org/wiki/SymbolicIcons) for more information about symbolic icons. a #GdkPixbuf representing the loaded icon a #GtkIconInfo a #GdkRGBA representing the foreground color of the icon a #GdkRGBA representing the warning color of the icon or %NULL to use the default color a #GdkRGBA representing the warning color of the icon or %NULL to use the default color a #GdkRGBA representing the error color of the icon or %NULL to use the default color (allow-none) a #gboolean, returns whether the loaded icon was a symbolic one and whether the @fg color was applied to it. Asynchronously load, render and scale a symbolic icon previously looked up from the icon theme using gtk_icon_theme_lookup_icon(). For more details, see gtk_icon_info_load_symbolic() which is the synchronous version of this call. a #GtkIconInfo from gtk_icon_theme_lookup_icon() a #GdkRGBA representing the foreground color of the icon a #GdkRGBA representing the warning color of the icon or %NULL to use the default color a #GdkRGBA representing the warning color of the icon or %NULL to use the default color a #GdkRGBA representing the error color of the icon or %NULL to use the default color (allow-none) optional #GCancellable object, %NULL to ignore a #GAsyncReadyCallback to call when the request is satisfied the data to pass to callback function Finishes an async icon load, see gtk_icon_info_load_symbolic_async(). the rendered icon; this may be a newly created icon or a new reference to an internal icon, so you must not modify the icon. Use g_object_unref() to release your reference to the icon. a #GtkIconInfo from gtk_icon_theme_lookup_icon() a #GAsyncResult a #gboolean, returns whether the loaded icon was a symbolic one and whether the @fg color was applied to it. Loads an icon, modifying it to match the system colors for the foreground, success, warning and error colors provided. If the icon is not a symbolic one, the function will return the result from gtk_icon_info_load_icon(). This function uses the regular foreground color and the symbolic colors with the names “success_color”, “warning_color” and “error_color” from the context. This allows loading symbolic icons that will match the system theme. See gtk_icon_info_load_symbolic() for more details. a #GdkPixbuf representing the loaded icon a #GtkIconInfo a #GtkStyleContext a #gboolean, returns whether the loaded icon was a symbolic one and whether the @fg color was applied to it. Asynchronously load, render and scale a symbolic icon previously looked up from the icon theme using gtk_icon_theme_lookup_icon(). For more details, see gtk_icon_info_load_symbolic_for_context() which is the synchronous version of this call. a #GtkIconInfo from gtk_icon_theme_lookup_icon() a #GtkStyleContext optional #GCancellable object, %NULL to ignore a #GAsyncReadyCallback to call when the request is satisfied the data to pass to callback function Finishes an async icon load, see gtk_icon_info_load_symbolic_for_context_async(). the rendered icon; this may be a newly created icon or a new reference to an internal icon, so you must not modify the icon. Use g_object_unref() to release your reference to the icon. a #GtkIconInfo from gtk_icon_theme_lookup_icon() a #GAsyncResult a #gboolean, returns whether the loaded icon was a symbolic one and whether the @fg color was applied to it. Loads an icon, modifying it to match the system colours for the foreground, success, warning and error colors provided. If the icon is not a symbolic one, the function will return the result from gtk_icon_info_load_icon(). This allows loading symbolic icons that will match the system theme. See gtk_icon_info_load_symbolic() for more details. Use gtk_icon_info_load_symbolic_for_context() instead a #GdkPixbuf representing the loaded icon a #GtkIconInfo a #GtkStyle to take the colors from the widget state to use for colors a #gboolean, returns whether the loaded icon was a symbolic one and whether the @fg color was applied to it. Sets whether the coordinates returned by gtk_icon_info_get_embedded_rect() and gtk_icon_info_get_attach_points() should be returned in their original form as specified in the icon theme, instead of scaled appropriately for the pixbuf returned by gtk_icon_info_load_icon(). Raw coordinates are somewhat strange; they are specified to be with respect to the unscaled pixmap for PNG and XPM icons, but for SVG icons, they are in a 1000x1000 coordinate space that is scaled to the final size of the icon. You can determine if the icon is an SVG icon by using gtk_icon_info_get_filename(), and seeing if it is non-%NULL and ends in “.svg”. This function is provided primarily to allow compatibility wrappers for older API's, and is not expected to be useful for applications. Embedded rectangles and attachment points are deprecated a #GtkIconInfo whether the coordinates of embedded rectangles and attached points should be returned in their original (unscaled) form. Used to specify options for gtk_icon_theme_lookup_icon() Never get SVG icons, even if gdk-pixbuf supports them. Cannot be used together with %GTK_ICON_LOOKUP_FORCE_SVG. Get SVG icons, even if gdk-pixbuf doesn’t support them. Cannot be used together with %GTK_ICON_LOOKUP_NO_SVG. When passed to gtk_icon_theme_lookup_icon() includes builtin icons as well as files. For a builtin icon, gtk_icon_info_get_filename() is %NULL and you need to call gtk_icon_info_get_builtin_pixbuf(). Try to shorten icon name at '-' characters before looking at inherited themes. This flag is only supported in functions that take a single icon name. For more general fallback, see gtk_icon_theme_choose_icon(). Since 2.12. Always get the icon scaled to the requested size. Since 2.14. Try to always load regular icons, even when symbolic icon names are given. Since 3.14. Try to always load symbolic icons, even when regular icon names are given. Since 3.14. Try to load a variant of the icon for left-to-right text direction. Since 3.14. Try to load a variant of the icon for right-to-left text direction. Since 3.14. Creates a new #GtkIconSet. A #GtkIconSet represents a single icon in various sizes and widget states. It can provide a #GdkPixbuf for a given size and state on request, and automatically caches some of the rendered #GdkPixbuf objects. Normally you would use gtk_widget_render_icon_pixbuf() instead of using #GtkIconSet directly. The one case where you’d use #GtkIconSet is to create application-specific icon sets to place in a #GtkIconFactory. Use #GtkIconTheme instead. a new #GtkIconSet Creates a new #GtkIconSet with @pixbuf as the default/fallback source image. If you don’t add any additional #GtkIconSource to the icon set, all variants of the icon will be created from @pixbuf, using scaling, pixelation, etc. as required to adjust the icon size or make the icon look insensitive/prelighted. Use #GtkIconTheme instead. a new #GtkIconSet a #GdkPixbuf Icon sets have a list of #GtkIconSource, which they use as base icons for rendering icons in different states and sizes. Icons are scaled, made to look insensitive, etc. in gtk_icon_set_render_icon(), but #GtkIconSet needs base images to work with. The base images and when to use them are described by a #GtkIconSource. This function copies @source, so you can reuse the same source immediately without affecting the icon set. An example of when you’d use this function: a web browser’s "Back to Previous Page" icon might point in a different direction in Hebrew and in English; it might look different when insensitive; and it might change size depending on toolbar mode (small/large icons). So a single icon set would contain all those variants of the icon, and you might add a separate source for each one. You should nearly always add a “default” icon source with all fields wildcarded, which will be used as a fallback if no more specific source matches. #GtkIconSet always prefers more specific icon sources to more generic icon sources. The order in which you add the sources to the icon set does not matter. gtk_icon_set_new_from_pixbuf() creates a new icon set with a default icon source based on the given pixbuf. Use #GtkIconTheme instead. a #GtkIconSet a #GtkIconSource Copies @icon_set by value. Use #GtkIconTheme instead. a new #GtkIconSet identical to the first. a #GtkIconSet Obtains a list of icon sizes this icon set can render. The returned array must be freed with g_free(). Use #GtkIconTheme instead. a #GtkIconSet return location for array of sizes (#GtkIconSize) location to store number of elements in returned array Increments the reference count on @icon_set. Use #GtkIconTheme instead. @icon_set. a #GtkIconSet. Renders an icon using gtk_style_render_icon(). In most cases, gtk_widget_render_icon() is better, since it automatically provides most of the arguments from the current widget settings. This function never returns %NULL; if the icon can’t be rendered (perhaps because an image file fails to load), a default "missing image" icon will be returned instead. Use gtk_icon_set_render_icon_pixbuf() instead a #GdkPixbuf to be displayed a #GtkIconSet a #GtkStyle associated with @widget, or %NULL text direction widget state icon size (#GtkIconSize). A size of `(GtkIconSize)-1` means render at the size of the source and don’t scale. widget that will display the icon, or %NULL. The only use that is typically made of this is to determine the appropriate #GdkScreen. detail to pass to the theme engine, or %NULL. Note that passing a detail of anything but %NULL will disable caching. Renders an icon using gtk_render_icon_pixbuf(). In most cases, gtk_widget_render_icon_pixbuf() is better, since it automatically provides most of the arguments from the current widget settings. This function never returns %NULL; if the icon can’t be rendered (perhaps because an image file fails to load), a default "missing image" icon will be returned instead. Use #GtkIconTheme instead. a #GdkPixbuf to be displayed a #GtkIconSet a #GtkStyleContext icon size (#GtkIconSize). A size of `(GtkIconSize)-1` means render at the size of the source and don’t scale. Renders an icon using gtk_render_icon_pixbuf() and converts it to a cairo surface. This function never returns %NULL; if the icon can’t be rendered (perhaps because an image file fails to load), a default "missing image" icon will be returned instead. Use #GtkIconTheme instead. a #cairo_surface_t to be displayed a #GtkIconSet a #GtkStyleContext icon size (#GtkIconSize). A size of `(GtkIconSize)-1` means render at the size of the source and don’t scale. the window scale to render for #GdkWindow to optimize drawing for, or %NULL Decrements the reference count on @icon_set, and frees memory if the reference count reaches 0. Use #GtkIconTheme instead. a #GtkIconSet Built-in stock icon sizes. Invalid size. Size appropriate for menus (16px). Size appropriate for small toolbars (16px). Size appropriate for large toolbars (24px) Size appropriate for buttons (16px) Size appropriate for drag and drop (32px) Size appropriate for dialogs (48px) Looks up the icon size associated with @name. Use #GtkIconTheme instead. the icon size (#GtkIconSize) the name to look up. Gets the canonical name of the given icon size. The returned string is statically allocated and should not be freed. Use #GtkIconTheme instead. the name of the given icon size. a #GtkIconSize. Obtains the pixel size of a semantic icon size @size: #GTK_ICON_SIZE_MENU, #GTK_ICON_SIZE_BUTTON, etc. This function isn’t normally needed, gtk_icon_theme_load_icon() is the usual way to get an icon for rendering, then just look at the size of the rendered pixbuf. The rendered pixbuf may not even correspond to the width/height returned by gtk_icon_size_lookup(), because themes are free to render the pixbuf however they like, including changing the usual size. %TRUE if @size was a valid size an icon size (#GtkIconSize) location to store icon width location to store icon height Obtains the pixel size of a semantic icon size, possibly modified by user preferences for a particular #GtkSettings. Normally @size would be #GTK_ICON_SIZE_MENU, #GTK_ICON_SIZE_BUTTON, etc. This function isn’t normally needed, gtk_widget_render_icon_pixbuf() is the usual way to get an icon for rendering, then just look at the size of the rendered pixbuf. The rendered pixbuf may not even correspond to the width/height returned by gtk_icon_size_lookup(), because themes are free to render the pixbuf however they like, including changing the usual size. Use gtk_icon_size_lookup() instead. %TRUE if @size was a valid size a #GtkSettings object, used to determine which set of user preferences to used. an icon size (#GtkIconSize) location to store icon width location to store icon height Registers a new icon size, along the same lines as #GTK_ICON_SIZE_MENU, etc. Returns the integer value for the size. Use #GtkIconTheme instead. integer value representing the size (#GtkIconSize) name of the icon size the icon width the icon height Registers @alias as another name for @target. So calling gtk_icon_size_from_name() with @alias as argument will return @target. Use #GtkIconTheme instead. an alias for @target an existing icon size (#GtkIconSize) Creates a new #GtkIconSource. A #GtkIconSource contains a #GdkPixbuf (or image filename) that serves as the base image for one or more of the icons in a #GtkIconSet, along with a specification for which icons in the icon set will be based on that pixbuf or image file. An icon set contains a set of icons that represent “the same” logical concept in different states, different global text directions, and different sizes. So for example a web browser’s “Back to Previous Page” icon might point in a different direction in Hebrew and in English; it might look different when insensitive; and it might change size depending on toolbar mode (small/large icons). So a single icon set would contain all those variants of the icon. #GtkIconSet contains a list of #GtkIconSource from which it can derive specific icon variants in the set. In the simplest case, #GtkIconSet contains one source pixbuf from which it derives all variants. The convenience function gtk_icon_set_new_from_pixbuf() handles this case; if you only have one source pixbuf, just use that function. If you want to use a different base pixbuf for different icon variants, you create multiple icon sources, mark which variants they’ll be used to create, and add them to the icon set with gtk_icon_set_add_source(). By default, the icon source has all parameters wildcarded. That is, the icon source will be used as the base icon for any desired text direction, widget state, or icon size. Use #GtkIconTheme instead. a new #GtkIconSource Creates a copy of @source; mostly useful for language bindings. Use #GtkIconTheme instead. a new #GtkIconSource a #GtkIconSource Frees a dynamically-allocated icon source, along with its filename, size, and pixbuf fields if those are not %NULL. Use #GtkIconTheme instead. a #GtkIconSource Obtains the text direction this icon source applies to. The return value is only useful/meaningful if the text direction is not wildcarded. Use #GtkIconTheme instead. text direction this source matches a #GtkIconSource Gets the value set by gtk_icon_source_set_direction_wildcarded(). Use #GtkIconTheme instead. %TRUE if this icon source is a base for any text direction variant a #GtkIconSource Retrieves the source filename, or %NULL if none is set. The filename is not a copy, and should not be modified or expected to persist beyond the lifetime of the icon source. Use #GtkIconTheme instead. image filename. This string must not be modified or freed. a #GtkIconSource Retrieves the source icon name, or %NULL if none is set. The icon_name is not a copy, and should not be modified or expected to persist beyond the lifetime of the icon source. Use #GtkIconTheme instead. icon name. This string must not be modified or freed. a #GtkIconSource Retrieves the source pixbuf, or %NULL if none is set. In addition, if a filename source is in use, this function in some cases will return the pixbuf from loaded from the filename. This is, for example, true for the GtkIconSource passed to the #GtkStyle render_icon() virtual function. The reference count on the pixbuf is not incremented. Use #GtkIconTheme instead. source pixbuf a #GtkIconSource Obtains the icon size this source applies to. The return value is only useful/meaningful if the icon size is not wildcarded. Use #GtkIconTheme instead. icon size (#GtkIconSize) this source matches. a #GtkIconSource Gets the value set by gtk_icon_source_set_size_wildcarded(). Use #GtkIconTheme instead. %TRUE if this icon source is a base for any icon size variant a #GtkIconSource Obtains the widget state this icon source applies to. The return value is only useful/meaningful if the widget state is not wildcarded. Use #GtkIconTheme instead. widget state this source matches a #GtkIconSource Gets the value set by gtk_icon_source_set_state_wildcarded(). Use #GtkIconTheme instead. %TRUE if this icon source is a base for any widget state variant a #GtkIconSource Sets the text direction this icon source is intended to be used with. Setting the text direction on an icon source makes no difference if the text direction is wildcarded. Therefore, you should usually call gtk_icon_source_set_direction_wildcarded() to un-wildcard it in addition to calling this function. Use #GtkIconTheme instead. a #GtkIconSource text direction this source applies to If the text direction is wildcarded, this source can be used as the base image for an icon in any #GtkTextDirection. If the text direction is not wildcarded, then the text direction the icon source applies to should be set with gtk_icon_source_set_direction(), and the icon source will only be used with that text direction. #GtkIconSet prefers non-wildcarded sources (exact matches) over wildcarded sources, and will use an exact match when possible. Use #GtkIconTheme instead. a #GtkIconSource %TRUE to wildcard the text direction Sets the name of an image file to use as a base image when creating icon variants for #GtkIconSet. The filename must be absolute. Use #GtkIconTheme instead. a #GtkIconSource image file to use Sets the name of an icon to look up in the current icon theme to use as a base image when creating icon variants for #GtkIconSet. Use #GtkIconTheme instead. a #GtkIconSource name of icon to use Sets a pixbuf to use as a base image when creating icon variants for #GtkIconSet. Use #GtkIconTheme instead. a #GtkIconSource pixbuf to use as a source Sets the icon size this icon source is intended to be used with. Setting the icon size on an icon source makes no difference if the size is wildcarded. Therefore, you should usually call gtk_icon_source_set_size_wildcarded() to un-wildcard it in addition to calling this function. Use #GtkIconTheme instead. a #GtkIconSource icon size (#GtkIconSize) this source applies to If the icon size is wildcarded, this source can be used as the base image for an icon of any size. If the size is not wildcarded, then the size the source applies to should be set with gtk_icon_source_set_size() and the icon source will only be used with that specific size. #GtkIconSet prefers non-wildcarded sources (exact matches) over wildcarded sources, and will use an exact match when possible. #GtkIconSet will normally scale wildcarded source images to produce an appropriate icon at a given size, but will not change the size of source images that match exactly. Use #GtkIconTheme instead. a #GtkIconSource %TRUE to wildcard the widget state Sets the widget state this icon source is intended to be used with. Setting the widget state on an icon source makes no difference if the state is wildcarded. Therefore, you should usually call gtk_icon_source_set_state_wildcarded() to un-wildcard it in addition to calling this function. Use #GtkIconTheme instead. a #GtkIconSource widget state this source applies to If the widget state is wildcarded, this source can be used as the base image for an icon in any #GtkStateType. If the widget state is not wildcarded, then the state the source applies to should be set with gtk_icon_source_set_state() and the icon source will only be used with that specific state. #GtkIconSet prefers non-wildcarded sources (exact matches) over wildcarded sources, and will use an exact match when possible. #GtkIconSet will normally transform wildcarded source images to produce an appropriate icon for a given state, for example lightening an image on prelight, but will not modify source images that match exactly. Use #GtkIconTheme instead. a #GtkIconSource %TRUE to wildcard the widget state #GtkIconTheme provides a facility for looking up icons by name and size. The main reason for using a name rather than simply providing a filename is to allow different icons to be used depending on what “icon theme” is selected by the user. The operation of icon themes on Linux and Unix follows the [Icon Theme Specification](http://www.freedesktop.org/Standards/icon-theme-spec) There is a fallback icon theme, named `hicolor`, where applications should install their icons, but additional icon themes can be installed as operating system vendors and users choose. Named icons are similar to the deprecated [Stock Items][gtkstock], and the distinction between the two may be a bit confusing. A few things to keep in mind: - Stock images usually are used in conjunction with [Stock Items][gtkstock], such as %GTK_STOCK_OK or %GTK_STOCK_OPEN. Named icons are easier to set up and therefore are more useful for new icons that an application wants to add, such as application icons or window icons. - Stock images can only be loaded at the symbolic sizes defined by the #GtkIconSize enumeration, or by custom sizes defined by gtk_icon_size_register(), while named icons are more flexible and any pixel size can be specified. - Because stock images are closely tied to stock items, and thus to actions in the user interface, stock images may come in multiple variants for different widget states or writing directions. A good rule of thumb is that if there is a stock image for what you want to use, use it, otherwise use a named icon. It turns out that internally stock images are generally defined in terms of one or more named icons. (An example of the more than one case is icons that depend on writing direction; %GTK_STOCK_GO_FORWARD uses the two themed icons “gtk-stock-go-forward-ltr” and “gtk-stock-go-forward-rtl”.) In many cases, named themes are used indirectly, via #GtkImage or stock items, rather than directly, but looking up icons directly is also simple. The #GtkIconTheme object acts as a database of all the icons in the current theme. You can create new #GtkIconTheme objects, but it’s much more efficient to use the standard icon theme for the #GdkScreen so that the icon information is shared with other people looking up icons. |[<!-- language="C" --> GError *error = NULL; GtkIconTheme *icon_theme; GdkPixbuf *pixbuf; icon_theme = gtk_icon_theme_get_default (); pixbuf = gtk_icon_theme_load_icon (icon_theme, "my-icon-name", // icon name 48, // icon size 0, // flags &error); if (!pixbuf) { g_warning ("Couldn’t load icon: %s", error->message); g_error_free (error); } else { // Use the pixbuf g_object_unref (pixbuf); } ]| Creates a new icon theme object. Icon theme objects are used to lookup up an icon by name in a particular icon theme. Usually, you’ll want to use gtk_icon_theme_get_default() or gtk_icon_theme_get_for_screen() rather than creating a new icon theme object for scratch. the newly created #GtkIconTheme object. Registers a built-in icon for icon theme lookups. The idea of built-in icons is to allow an application or library that uses themed icons to function requiring files to be present in the file system. For instance, the default images for all of GTK+’s stock icons are registered as built-icons. In general, if you use gtk_icon_theme_add_builtin_icon() you should also install the icon in the icon theme, so that the icon is generally available. This function will generally be used with pixbufs loaded via gdk_pixbuf_new_from_inline(). Use gtk_icon_theme_add_resource_path() to add application-specific icons to the icon theme. the name of the icon to register the size in pixels at which to register the icon (different images can be registered for the same icon name at different sizes.) #GdkPixbuf that contains the image to use for @icon_name Gets the icon theme for the default screen. See gtk_icon_theme_get_for_screen(). A unique #GtkIconTheme associated with the default screen. This icon theme is associated with the screen and can be used as long as the screen is open. Do not ref or unref it. Gets the icon theme object associated with @screen; if this function has not previously been called for the given screen, a new icon theme object will be created and associated with the screen. Icon theme objects are fairly expensive to create, so using this function is usually a better choice than calling than gtk_icon_theme_new() and setting the screen yourself; by using this function a single icon theme object will be shared between users. A unique #GtkIconTheme associated with the given screen. This icon theme is associated with the screen and can be used as long as the screen is open. Do not ref or unref it. a #GdkScreen Adds a resource path that will be looked at when looking for icons, similar to search paths. This function should be used to make application-specific icons available as part of the icon theme. The resources are considered as part of the hicolor icon theme and must be located in subdirectories that are defined in the hicolor icon theme, such as `@path/16x16/actions/run.png`. Icons that are directly placed in the resource path instead of a subdirectory are also considered as ultimate fallback. a #GtkIconTheme a resource path Appends a directory to the search path. See gtk_icon_theme_set_search_path(). a #GtkIconTheme directory name to append to the icon path Looks up a named icon and returns a #GtkIconInfo containing information such as the filename of the icon. The icon can then be rendered into a pixbuf using gtk_icon_info_load_icon(). (gtk_icon_theme_load_icon() combines these two steps if all you need is the pixbuf.) If @icon_names contains more than one name, this function tries them all in the given order before falling back to inherited icon themes. a #GtkIconInfo object containing information about the icon, or %NULL if the icon wasn’t found. a #GtkIconTheme %NULL-terminated array of icon names to lookup desired icon size flags modifying the behavior of the icon lookup Looks up a named icon for a particular window scale and returns a #GtkIconInfo containing information such as the filename of the icon. The icon can then be rendered into a pixbuf using gtk_icon_info_load_icon(). (gtk_icon_theme_load_icon() combines these two steps if all you need is the pixbuf.) If @icon_names contains more than one name, this function tries them all in the given order before falling back to inherited icon themes. a #GtkIconInfo object containing information about the icon, or %NULL if the icon wasn’t found. a #GtkIconTheme %NULL-terminated array of icon names to lookup desired icon size desired scale flags modifying the behavior of the icon lookup Gets the name of an icon that is representative of the current theme (for instance, to use when presenting a list of themes to the user.) the name of an example icon or %NULL. Free with g_free(). a #GtkIconTheme Returns an array of integers describing the sizes at which the icon is available without scaling. A size of -1 means that the icon is available in a scalable format. The array is zero-terminated. An newly allocated array describing the sizes at which the icon is available. The array should be freed with g_free() when it is no longer needed. a #GtkIconTheme the name of an icon Gets the current search path. See gtk_icon_theme_set_search_path(). a #GtkIconTheme location to store a list of icon theme path directories or %NULL. The stored value should be freed with g_strfreev(). location to store number of elements in @path, or %NULL Checks whether an icon theme includes an icon for a particular name. %TRUE if @icon_theme includes an icon for @icon_name. a #GtkIconTheme the name of an icon Gets the list of contexts available within the current hierarchy of icon themes. See gtk_icon_theme_list_icons() for details about contexts. a #GList list holding the names of all the contexts in the theme. You must first free each element in the list with g_free(), then free the list itself with g_list_free(). a #GtkIconTheme Lists the icons in the current icon theme. Only a subset of the icons can be listed by providing a context string. The set of values for the context string is system dependent, but will typically include such values as “Applications” and “MimeTypes”. Contexts are explained in the [Icon Theme Specification](http://www.freedesktop.org/wiki/Specifications/icon-theme-spec). The standard contexts are listed in the [Icon Naming Specification](http://www.freedesktop.org/wiki/Specifications/icon-naming-spec). Also see gtk_icon_theme_list_contexts(). a #GList list holding the names of all the icons in the theme. You must first free each element in the list with g_free(), then free the list itself with g_list_free(). a #GtkIconTheme a string identifying a particular type of icon, or %NULL to list all icons. Looks up an icon in an icon theme, scales it to the given size and renders it into a pixbuf. This is a convenience function; if more details about the icon are needed, use gtk_icon_theme_lookup_icon() followed by gtk_icon_info_load_icon(). Note that you probably want to listen for icon theme changes and update the icon. This is usually done by connecting to the GtkWidget::style-set signal. If for some reason you do not want to update the icon when the icon theme changes, you should consider using gdk_pixbuf_copy() to make a private copy of the pixbuf returned by this function. Otherwise GTK+ may need to keep the old icon theme loaded, which would be a waste of memory. the rendered icon; this may be a newly created icon or a new reference to an internal icon, so you must not modify the icon. Use g_object_unref() to release your reference to the icon. %NULL if the icon isn’t found. a #GtkIconTheme the name of the icon to lookup the desired icon size. The resulting icon may not be exactly this size; see gtk_icon_info_load_icon(). flags modifying the behavior of the icon lookup Looks up an icon in an icon theme for a particular window scale, scales it to the given size and renders it into a pixbuf. This is a convenience function; if more details about the icon are needed, use gtk_icon_theme_lookup_icon() followed by gtk_icon_info_load_icon(). Note that you probably want to listen for icon theme changes and update the icon. This is usually done by connecting to the GtkWidget::style-set signal. If for some reason you do not want to update the icon when the icon theme changes, you should consider using gdk_pixbuf_copy() to make a private copy of the pixbuf returned by this function. Otherwise GTK+ may need to keep the old icon theme loaded, which would be a waste of memory. the rendered icon; this may be a newly created icon or a new reference to an internal icon, so you must not modify the icon. Use g_object_unref() to release your reference to the icon. %NULL if the icon isn’t found. a #GtkIconTheme the name of the icon to lookup the desired icon size. The resulting icon may not be exactly this size; see gtk_icon_info_load_icon(). desired scale flags modifying the behavior of the icon lookup Looks up an icon in an icon theme for a particular window scale, scales it to the given size and renders it into a cairo surface. This is a convenience function; if more details about the icon are needed, use gtk_icon_theme_lookup_icon() followed by gtk_icon_info_load_surface(). Note that you probably want to listen for icon theme changes and update the icon. This is usually done by connecting to the GtkWidget::style-set signal. the rendered icon; this may be a newly created icon or a new reference to an internal icon, so you must not modify the icon. Use cairo_surface_destroy() to release your reference to the icon. %NULL if the icon isn’t found. a #GtkIconTheme the name of the icon to lookup the desired icon size. The resulting icon may not be exactly this size; see gtk_icon_info_load_icon(). desired scale #GdkWindow to optimize drawing for, or %NULL flags modifying the behavior of the icon lookup Looks up an icon and returns a #GtkIconInfo containing information such as the filename of the icon. The icon can then be rendered into a pixbuf using gtk_icon_info_load_icon(). When rendering on displays with high pixel densities you should not use a @size multiplied by the scaling factor returned by functions like gdk_window_get_scale_factor(). Instead, you should use gtk_icon_theme_lookup_by_gicon_for_scale(), as the assets loaded for a given scaling factor may be different. a #GtkIconInfo containing information about the icon, or %NULL if the icon wasn’t found. Unref with g_object_unref() a #GtkIconTheme the #GIcon to look up desired icon size flags modifying the behavior of the icon lookup Looks up an icon and returns a #GtkIconInfo containing information such as the filename of the icon. The icon can then be rendered into a pixbuf using gtk_icon_info_load_icon(). a #GtkIconInfo containing information about the icon, or %NULL if the icon wasn’t found. Unref with g_object_unref() a #GtkIconTheme the #GIcon to look up desired icon size the desired scale flags modifying the behavior of the icon lookup Looks up a named icon and returns a #GtkIconInfo containing information such as the filename of the icon. The icon can then be rendered into a pixbuf using gtk_icon_info_load_icon(). (gtk_icon_theme_load_icon() combines these two steps if all you need is the pixbuf.) When rendering on displays with high pixel densities you should not use a @size multiplied by the scaling factor returned by functions like gdk_window_get_scale_factor(). Instead, you should use gtk_icon_theme_lookup_icon_for_scale(), as the assets loaded for a given scaling factor may be different. a #GtkIconInfo object containing information about the icon, or %NULL if the icon wasn’t found. a #GtkIconTheme the name of the icon to lookup desired icon size flags modifying the behavior of the icon lookup Looks up a named icon for a particular window scale and returns a #GtkIconInfo containing information such as the filename of the icon. The icon can then be rendered into a pixbuf using gtk_icon_info_load_icon(). (gtk_icon_theme_load_icon() combines these two steps if all you need is the pixbuf.) a #GtkIconInfo object containing information about the icon, or %NULL if the icon wasn’t found. a #GtkIconTheme the name of the icon to lookup desired icon size the desired scale flags modifying the behavior of the icon lookup Prepends a directory to the search path. See gtk_icon_theme_set_search_path(). a #GtkIconTheme directory name to prepend to the icon path Checks to see if the icon theme has changed; if it has, any currently cached information is discarded and will be reloaded next time @icon_theme is accessed. %TRUE if the icon theme has changed and needed to be reloaded. a #GtkIconTheme Sets the name of the icon theme that the #GtkIconTheme object uses overriding system configuration. This function cannot be called on the icon theme objects returned from gtk_icon_theme_get_default() and gtk_icon_theme_get_for_screen(). a #GtkIconTheme name of icon theme to use instead of configured theme, or %NULL to unset a previously set custom theme Sets the screen for an icon theme; the screen is used to track the user’s currently configured icon theme, which might be different for different screens. a #GtkIconTheme a #GdkScreen Sets the search path for the icon theme object. When looking for an icon theme, GTK+ will search for a subdirectory of one or more of the directories in @path with the same name as the icon theme containing an index.theme file. (Themes from multiple of the path elements are combined to allow themes to be extended by adding icons in the user’s home directory.) In addition if an icon found isn’t found either in the current icon theme or the default icon theme, and an image file with the right name is found directly in one of the elements of @path, then that image will be used for the icon name. (This is legacy feature, and new icons should be put into the fallback icon theme, which is called hicolor, rather than directly on the icon path.) a #GtkIconTheme array of directories that are searched for icon themes number of elements in @path. Emitted when the current icon theme is switched or GTK+ detects that a change has occurred in the contents of the current icon theme. The parent class. Error codes for GtkIconTheme operations. The icon specified does not exist in the theme An unspecified error occurred. #GtkIconView provides an alternative view on a #GtkTreeModel. It displays the model as a grid of icons with labels. Like #GtkTreeView, it allows to select one or multiple items (depending on the selection mode, see gtk_icon_view_set_selection_mode()). In addition to selection with the arrow keys, #GtkIconView supports rubberband selection, which is controlled by dragging the pointer. Note that if the tree model is backed by an actual tree store (as opposed to a flat list where the mapping to icons is obvious), #GtkIconView will only display the first level of the tree and ignore the tree’s branches. # CSS nodes |[<!-- language="plain" --> iconview.view ╰── [rubberband] ]| GtkIconView has a single CSS node with name iconview and style class .view. For rubberband selection, a subnode with name rubberband is used. Creates a new #GtkIconView widget A newly created #GtkIconView widget Creates a new #GtkIconView widget using the specified @area to layout cells inside the icons. A newly created #GtkIconView widget the #GtkCellArea to use to layout cells Creates a new #GtkIconView widget with the model @model. A newly created #GtkIconView widget. The model. Activates the item determined by @path. A #GtkIconView The #GtkTreePath to be activated Selects all the icons. @icon_view must has its selection mode set to #GTK_SELECTION_MULTIPLE. A #GtkIconView. Unselects all the icons. A #GtkIconView. Converts widget coordinates to coordinates for the bin_window, as expected by e.g. gtk_icon_view_get_path_at_pos(). a #GtkIconView X coordinate relative to the widget Y coordinate relative to the widget return location for bin_window X coordinate return location for bin_window Y coordinate Creates a #cairo_surface_t representation of the item at @path. This image is used for a drag icon. a newly-allocated surface of the drag icon. a #GtkIconView a #GtkTreePath in @icon_view Turns @icon_view into a drop destination for automatic DND. Calling this method sets #GtkIconView:reorderable to %FALSE. a #GtkIconView the table of targets that the drag will support the number of items in @targets the bitmask of possible actions for a drag to this widget Turns @icon_view into a drag source for automatic DND. Calling this method sets #GtkIconView:reorderable to %FALSE. a #GtkIconView Mask of allowed buttons to start drag the table of targets that the drag will support the number of items in @targets the bitmask of possible actions for a drag from this widget Gets the setting set by gtk_icon_view_set_activate_on_single_click(). %TRUE if item-activated will be emitted on a single click a #GtkIconView Fills the bounding rectangle in widget coordinates for the cell specified by @path and @cell. If @cell is %NULL the main cell area is used. This function is only valid if @icon_view is realized. %FALSE if there is no such item, %TRUE otherwise a #GtkIconView a #GtkTreePath a #GtkCellRenderer or %NULL rectangle to fill with cell rect Returns the value of the ::column-spacing property. the space between columns a #GtkIconView Returns the value of the ::columns property. the number of columns, or -1 a #GtkIconView Fills in @path and @cell with the current cursor path and cell. If the cursor isn’t currently set, then *@path will be %NULL. If no cell currently has focus, then *@cell will be %NULL. The returned #GtkTreePath must be freed with gtk_tree_path_free(). %TRUE if the cursor is set. A #GtkIconView Return location for the current cursor path, or %NULL Return location the current focus cell, or %NULL Determines the destination item for a given position. whether there is an item at the given position. a #GtkIconView the position to determine the destination item for the position to determine the destination item for Return location for the path of the item, or %NULL. Return location for the drop position, or %NULL Gets information about the item that is highlighted for feedback. a #GtkIconView Return location for the path of the highlighted item, or %NULL. Return location for the drop position, or %NULL Finds the path at the point (@x, @y), relative to bin_window coordinates. In contrast to gtk_icon_view_get_path_at_pos(), this function also obtains the cell at the specified position. The returned path should be freed with gtk_tree_path_free(). See gtk_icon_view_convert_widget_to_bin_window_coords() for converting widget coordinates to bin_window coordinates. %TRUE if an item exists at the specified position A #GtkIconView. The x position to be identified The y position to be identified Return location for the path, or %NULL Return location for the renderer responsible for the cell at (@x, @y), or %NULL Gets the column in which the item @path is currently displayed. Column numbers start at 0. The column in which the item is displayed a #GtkIconView the #GtkTreePath of the item Returns the value of the ::item-orientation property which determines whether the labels are drawn beside the icons instead of below. the relative position of texts and icons a #GtkIconView Returns the value of the ::item-padding property. the padding around items a #GtkIconView Gets the row in which the item @path is currently displayed. Row numbers start at 0. The row in which the item is displayed a #GtkIconView the #GtkTreePath of the item Returns the value of the ::item-width property. the width of a single item, or -1 a #GtkIconView Returns the value of the ::margin property. the space at the borders a #GtkIconView Returns the column with markup text for @icon_view. the markup column, or -1 if it’s unset. A #GtkIconView. Returns the model the #GtkIconView is based on. Returns %NULL if the model is unset. A #GtkTreeModel, or %NULL if none is currently being used. a #GtkIconView Finds the path at the point (@x, @y), relative to bin_window coordinates. See gtk_icon_view_get_item_at_pos(), if you are also interested in the cell at the specified position. See gtk_icon_view_convert_widget_to_bin_window_coords() for converting widget coordinates to bin_window coordinates. The #GtkTreePath corresponding to the icon or %NULL if no icon exists at that position. A #GtkIconView. The x position to be identified The y position to be identified Returns the column with pixbufs for @icon_view. the pixbuf column, or -1 if it’s unset. A #GtkIconView. Retrieves whether the user can reorder the list via drag-and-drop. See gtk_icon_view_set_reorderable(). %TRUE if the list can be reordered. a #GtkIconView Returns the value of the ::row-spacing property. the space between rows a #GtkIconView Creates a list of paths of all selected items. Additionally, if you are planning on modifying the model after calling this function, you may want to convert the returned list into a list of #GtkTreeRowReferences. To do this, you can use gtk_tree_row_reference_new(). To free the return value, use: |[<!-- language="C" --> g_list_free_full (list, (GDestroyNotify) gtk_tree_path_free); ]| A #GList containing a #GtkTreePath for each selected row. A #GtkIconView. Gets the selection mode of the @icon_view. the current selection mode A #GtkIconView. Returns the value of the ::spacing property. the space between cells a #GtkIconView Returns the column with text for @icon_view. the text column, or -1 if it’s unset. A #GtkIconView. Returns the column of @icon_view’s model which is being used for displaying tooltips on @icon_view’s rows. the index of the tooltip column that is currently being used, or -1 if this is disabled. a #GtkIconView This function is supposed to be used in a #GtkWidget::query-tooltip signal handler for #GtkIconView. The @x, @y and @keyboard_tip values which are received in the signal handler, should be passed to this function without modification. The return value indicates whether there is an icon view item at the given coordinates (%TRUE) or not (%FALSE) for mouse tooltips. For keyboard tooltips the item returned will be the cursor item. When %TRUE, then any of @model, @path and @iter which have been provided will be set to point to that row and the corresponding model. @x and @y will always be converted to be relative to @icon_view’s bin_window if @keyboard_tooltip is %FALSE. whether or not the given tooltip context points to a item an #GtkIconView the x coordinate (relative to widget coordinates) the y coordinate (relative to widget coordinates) whether this is a keyboard tooltip or not a pointer to receive a #GtkTreeModel or %NULL a pointer to receive a #GtkTreePath or %NULL a pointer to receive a #GtkTreeIter or %NULL Sets @start_path and @end_path to be the first and last visible path. Note that there may be invisible paths in between. Both paths should be freed with gtk_tree_path_free() after use. %TRUE, if valid paths were placed in @start_path and @end_path A #GtkIconView Return location for start of region, or %NULL Return location for end of region, or %NULL Activates the item determined by @path. A #GtkIconView The #GtkTreePath to be activated Returns %TRUE if the icon pointed to by @path is currently selected. If @path does not point to a valid location, %FALSE is returned. %TRUE if @path is selected. A #GtkIconView. A #GtkTreePath to check selection on. Moves the alignments of @icon_view to the position specified by @path. @row_align determines where the row is placed, and @col_align determines where @column is placed. Both are expected to be between 0.0 and 1.0. 0.0 means left/top alignment, 1.0 means right/bottom alignment, 0.5 means center. If @use_align is %FALSE, then the alignment arguments are ignored, and the tree does the minimum amount of work to scroll the item onto the screen. This means that the item will be scrolled to the edge closest to its current position. If the item is currently visible on the screen, nothing is done. This function only works if the model is set, and @path is a valid row on the model. If the model changes before the @icon_view is realized, the centered path will be modified to reflect this change. A #GtkIconView. The path of the item to move to. whether to use alignment arguments, or %FALSE. The vertical alignment of the item specified by @path. The horizontal alignment of the item specified by @path. Selects all the icons. @icon_view must has its selection mode set to #GTK_SELECTION_MULTIPLE. A #GtkIconView. Selects the row at @path. A #GtkIconView. The #GtkTreePath to be selected. Calls a function for each selected icon. Note that the model or selection cannot be modified from within this function. A #GtkIconView. The function to call for each selected icon. User data to pass to the function. Causes the #GtkIconView::item-activated signal to be emitted on a single click instead of a double click. a #GtkIconView %TRUE to emit item-activated on a single click Sets the ::column-spacing property which specifies the space which is inserted between the columns of the icon view. a #GtkIconView the column spacing Sets the ::columns property which determines in how many columns the icons are arranged. If @columns is -1, the number of columns will be chosen automatically to fill the available area. a #GtkIconView the number of columns Sets the current keyboard focus to be at @path, and selects it. This is useful when you want to focus the user’s attention on a particular item. If @cell is not %NULL, then focus is given to the cell specified by it. Additionally, if @start_editing is %TRUE, then editing should be started in the specified cell. This function is often followed by `gtk_widget_grab_focus (icon_view)` in order to give keyboard focus to the widget. Please note that editing can only happen when the widget is realized. A #GtkIconView A #GtkTreePath One of the cell renderers of @icon_view, or %NULL %TRUE if the specified cell should start being edited. Sets the item that is highlighted for feedback. a #GtkIconView The path of the item to highlight, or %NULL. Specifies where to drop, relative to the item Sets the ::item-orientation property which determines whether the labels are drawn beside the icons instead of below. a #GtkIconView the relative position of texts and icons Sets the #GtkIconView:item-padding property which specifies the padding around each of the icon view’s items. a #GtkIconView the item padding Sets the ::item-width property which specifies the width to use for each item. If it is set to -1, the icon view will automatically determine a suitable item size. a #GtkIconView the width for each item Sets the ::margin property which specifies the space which is inserted at the top, bottom, left and right of the icon view. a #GtkIconView the margin Sets the column with markup information for @icon_view to be @column. The markup column must be of type #G_TYPE_STRING. If the markup column is set to something, it overrides the text column set by gtk_icon_view_set_text_column(). A #GtkIconView. A column in the currently used model, or -1 to display no text Sets the model for a #GtkIconView. If the @icon_view already has a model set, it will remove it before setting the new model. If @model is %NULL, then it will unset the old model. A #GtkIconView. The model. Sets the column with pixbufs for @icon_view to be @column. The pixbuf column must be of type #GDK_TYPE_PIXBUF A #GtkIconView. A column in the currently used model, or -1 to disable This function is a convenience function to allow you to reorder models that support the #GtkTreeDragSourceIface and the #GtkTreeDragDestIface. Both #GtkTreeStore and #GtkListStore support these. If @reorderable is %TRUE, then the user can reorder the model by dragging and dropping rows. The developer can listen to these changes by connecting to the model's row_inserted and row_deleted signals. The reordering is implemented by setting up the icon view as a drag source and destination. Therefore, drag and drop can not be used in a reorderable view for any other purpose. This function does not give you any degree of control over the order -- any reordering is allowed. If more control is needed, you should probably handle drag and drop manually. A #GtkIconView. %TRUE, if the list of items can be reordered. Sets the ::row-spacing property which specifies the space which is inserted between the rows of the icon view. a #GtkIconView the row spacing Sets the selection mode of the @icon_view. A #GtkIconView. The selection mode Sets the ::spacing property which specifies the space which is inserted between the cells (i.e. the icon and the text) of an item. a #GtkIconView the spacing Sets the column with text for @icon_view to be @column. The text column must be of type #G_TYPE_STRING. A #GtkIconView. A column in the currently used model, or -1 to display no text Sets the tip area of @tooltip to the area which @cell occupies in the item pointed to by @path. See also gtk_tooltip_set_tip_area(). See also gtk_icon_view_set_tooltip_column() for a simpler alternative. a #GtkIconView a #GtkTooltip a #GtkTreePath a #GtkCellRenderer or %NULL If you only plan to have simple (text-only) tooltips on full items, you can use this function to have #GtkIconView handle these automatically for you. @column should be set to the column in @icon_view’s model containing the tooltip texts, or -1 to disable this feature. When enabled, #GtkWidget:has-tooltip will be set to %TRUE and @icon_view will connect a #GtkWidget::query-tooltip signal handler. Note that the signal handler sets the text with gtk_tooltip_set_markup(), so &, <, etc have to be escaped in the text. a #GtkIconView an integer, which is a valid column number for @icon_view’s model Sets the tip area of @tooltip to be the area covered by the item at @path. See also gtk_icon_view_set_tooltip_column() for a simpler alternative. See also gtk_tooltip_set_tip_area(). a #GtkIconView a #GtkTooltip a #GtkTreePath Unselects all the icons. A #GtkIconView. Unselects the row at @path. A #GtkIconView. The #GtkTreePath to be unselected. Undoes the effect of gtk_icon_view_enable_model_drag_dest(). Calling this method sets #GtkIconView:reorderable to %FALSE. a #GtkIconView Undoes the effect of gtk_icon_view_enable_model_drag_source(). Calling this method sets #GtkIconView:reorderable to %FALSE. a #GtkIconView The activate-on-single-click property specifies whether the "item-activated" signal will be emitted after a single click. The #GtkCellArea used to layout cell renderers for this view. If no area is specified when creating the icon view with gtk_icon_view_new_with_area() a #GtkCellAreaBox will be used. The column-spacing property specifies the space which is inserted between the columns of the icon view. The columns property contains the number of the columns in which the items should be displayed. If it is -1, the number of columns will be chosen automatically to fill the available area. The item-orientation property specifies how the cells (i.e. the icon and the text) of the item are positioned relative to each other. The item-padding property specifies the padding around each of the icon view's item. The item-width property specifies the width to use for each item. If it is set to -1, the icon view will automatically determine a suitable item size. The margin property specifies the space which is inserted at the edges of the icon view. The ::markup-column property contains the number of the model column containing markup information to be displayed. The markup column must be of type #G_TYPE_STRING. If this property and the :text-column property are both set to column numbers, it overrides the text column. If both are set to -1, no texts are displayed. The ::pixbuf-column property contains the number of the model column containing the pixbufs which are displayed. The pixbuf column must be of type #GDK_TYPE_PIXBUF. Setting this property to -1 turns off the display of pixbufs. The reorderable property specifies if the items can be reordered by DND. The row-spacing property specifies the space which is inserted between the rows of the icon view. The ::selection-mode property specifies the selection mode of icon view. If the mode is #GTK_SELECTION_MULTIPLE, rubberband selection is enabled, for the other modes, only keyboard selection is possible. The spacing property specifies the space which is inserted between the cells (i.e. the icon and the text) of an item. The ::text-column property contains the number of the model column containing the texts which are displayed. The text column must be of type #G_TYPE_STRING. If this property and the :markup-column property are both set to -1, no texts are displayed. A [keybinding signal][GtkBindingSignal] which gets emitted when the user activates the currently focused item. Applications should not connect to it, but may emit it with g_signal_emit_by_name() if they need to control activation programmatically. The default bindings for this signal are Space, Return and Enter. The ::item-activated signal is emitted when the method gtk_icon_view_item_activated() is called, when the user double clicks an item with the "activate-on-single-click" property set to %FALSE, or when the user single clicks an item when the "activate-on-single-click" property set to %TRUE. It is also emitted when a non-editable item is selected and one of the keys: Space, Return or Enter is pressed. the #GtkTreePath for the activated item The ::move-cursor signal is a [keybinding signal][GtkBindingSignal] which gets emitted when the user initiates a cursor movement. Applications should not connect to it, but may emit it with g_signal_emit_by_name() if they need to control the cursor programmatically. The default bindings for this signal include - Arrow keys which move by individual steps - Home/End keys which move to the first/last item - PageUp/PageDown which move by "pages" All of these will extend the selection when combined with the Shift modifier. the granularity of the move, as a #GtkMovementStep the number of @step units to move A [keybinding signal][GtkBindingSignal] which gets emitted when the user selects all items. Applications should not connect to it, but may emit it with g_signal_emit_by_name() if they need to control selection programmatically. The default binding for this signal is Ctrl-a. A [keybinding signal][GtkBindingSignal] which gets emitted when the user selects the item that is currently focused. Applications should not connect to it, but may emit it with g_signal_emit_by_name() if they need to control selection programmatically. There is no default binding for this signal. The ::selection-changed signal is emitted when the selection (i.e. the set of selected items) changes. A [keybinding signal][GtkBindingSignal] which gets emitted when the user toggles whether the currently focused item is selected or not. The exact effect of this depend on the selection mode. Applications should not connect to it, but may emit it with g_signal_emit_by_name() if they need to control selection programmatically. There is no default binding for this signal is Ctrl-Space. A [keybinding signal][GtkBindingSignal] which gets emitted when the user unselects all items. Applications should not connect to it, but may emit it with g_signal_emit_by_name() if they need to control selection programmatically. The default binding for this signal is Ctrl-Shift-a. A #GtkIconView The #GtkTreePath to be activated A #GtkIconView. A #GtkIconView. An enum for determining where a dropped item goes. no drop possible dropped item replaces the item droppped item is inserted to the left dropped item is inserted to the right dropped item is inserted above dropped item is inserted below A function used by gtk_icon_view_selected_foreach() to map all selected rows. It will be called on every selected row in the view. a #GtkIconView The #GtkTreePath of a selected row user data The #GtkImage widget displays an image. Various kinds of object can be displayed as an image; most typically, you would load a #GdkPixbuf ("pixel buffer") from a file, and then display that. There’s a convenience function to do this, gtk_image_new_from_file(), used as follows: |[<!-- language="C" --> GtkWidget *image; image = gtk_image_new_from_file ("myfile.png"); ]| If the file isn’t loaded successfully, the image will contain a “broken image” icon similar to that used in many web browsers. If you want to handle errors in loading the file yourself, for example by displaying an error message, then load the image with gdk_pixbuf_new_from_file(), then create the #GtkImage with gtk_image_new_from_pixbuf(). The image file may contain an animation, if so the #GtkImage will display an animation (#GdkPixbufAnimation) instead of a static image. #GtkImage is a subclass of #GtkMisc, which implies that you can align it (center, left, right) and add padding to it, using #GtkMisc methods. #GtkImage is a “no window” widget (has no #GdkWindow of its own), so by default does not receive events. If you want to receive events on the image, such as button clicks, place the image inside a #GtkEventBox, then connect to the event signals on the event box. ## Handling button press events on a #GtkImage. |[<!-- language="C" --> static gboolean button_press_callback (GtkWidget *event_box, GdkEventButton *event, gpointer data) { g_print ("Event box clicked at coordinates %f,%f\n", event->x, event->y); // Returning TRUE means we handled the event, so the signal // emission should be stopped (don’t call any further callbacks // that may be connected). Return FALSE to continue invoking callbacks. return TRUE; } static GtkWidget* create_image (void) { GtkWidget *image; GtkWidget *event_box; image = gtk_image_new_from_file ("myfile.png"); event_box = gtk_event_box_new (); gtk_container_add (GTK_CONTAINER (event_box), image); g_signal_connect (G_OBJECT (event_box), "button_press_event", G_CALLBACK (button_press_callback), image); return image; } ]| When handling events on the event box, keep in mind that coordinates in the image may be different from event box coordinates due to the alignment and padding settings on the image (see #GtkMisc). The simplest way to solve this is to set the alignment to 0.0 (left/top), and set the padding to zero. Then the origin of the image will be the same as the origin of the event box. Sometimes an application will want to avoid depending on external data files, such as image files. GTK+ comes with a program to avoid this, called “gdk-pixbuf-csource”. This library allows you to convert an image into a C variable declaration, which can then be loaded into a #GdkPixbuf using gdk_pixbuf_new_from_inline(). # CSS nodes GtkImage has a single CSS node with the name image. The style classes may appear on image CSS nodes: .icon-dropshadow, .lowres-icon. Creates a new empty #GtkImage widget. a newly created #GtkImage widget. Creates a #GtkImage displaying the given animation. The #GtkImage does not assume a reference to the animation; you still need to unref it if you own references. #GtkImage will add its own reference rather than adopting yours. Note that the animation frames are shown using a timeout with #G_PRIORITY_DEFAULT. When using animations to indicate busyness, keep in mind that the animation will only be shown if the main loop is not busy with something that has a higher priority. a new #GtkImage widget an animation Creates a new #GtkImage displaying the file @filename. If the file isn’t found or can’t be loaded, the resulting #GtkImage will display a “broken image” icon. This function never returns %NULL, it always returns a valid #GtkImage widget. If the file contains an animation, the image will contain an animation. If you need to detect failures to load the file, use gdk_pixbuf_new_from_file() to load the file yourself, then create the #GtkImage from the pixbuf. (Or for animations, use gdk_pixbuf_animation_new_from_file()). The storage type (gtk_image_get_storage_type()) of the returned image is not defined, it will be whatever is appropriate for displaying the file. a new #GtkImage a filename Creates a #GtkImage displaying an icon from the current icon theme. If the icon name isn’t known, a “broken image” icon will be displayed instead. If the current icon theme is changed, the icon will be updated appropriately. a new #GtkImage displaying the themed icon an icon a stock icon size (#GtkIconSize) Creates a #GtkImage displaying an icon from the current icon theme. If the icon name isn’t known, a “broken image” icon will be displayed instead. If the current icon theme is changed, the icon will be updated appropriately. a new #GtkImage displaying the themed icon an icon name or %NULL a stock icon size (#GtkIconSize) Creates a #GtkImage displaying an icon set. Sample stock sizes are #GTK_ICON_SIZE_MENU, #GTK_ICON_SIZE_SMALL_TOOLBAR. Instead of using this function, usually it’s better to create a #GtkIconFactory, put your icon sets in the icon factory, add the icon factory to the list of default factories with gtk_icon_factory_add_default(), and then use gtk_image_new_from_stock(). This will allow themes to override the icon you ship with your application. The #GtkImage does not assume a reference to the icon set; you still need to unref it if you own references. #GtkImage will add its own reference rather than adopting yours. Use gtk_image_new_from_icon_name() instead. a new #GtkImage a #GtkIconSet a stock icon size (#GtkIconSize) Creates a new #GtkImage displaying @pixbuf. The #GtkImage does not assume a reference to the pixbuf; you still need to unref it if you own references. #GtkImage will add its own reference rather than adopting yours. Note that this function just creates an #GtkImage from the pixbuf. The #GtkImage created will not react to state changes. Should you want that, you should use gtk_image_new_from_icon_name(). a new #GtkImage a #GdkPixbuf, or %NULL Creates a new #GtkImage displaying the resource file @resource_path. If the file isn’t found or can’t be loaded, the resulting #GtkImage will display a “broken image” icon. This function never returns %NULL, it always returns a valid #GtkImage widget. If the file contains an animation, the image will contain an animation. If you need to detect failures to load the file, use gdk_pixbuf_new_from_file() to load the file yourself, then create the #GtkImage from the pixbuf. (Or for animations, use gdk_pixbuf_animation_new_from_file()). The storage type (gtk_image_get_storage_type()) of the returned image is not defined, it will be whatever is appropriate for displaying the file. a new #GtkImage a resource path Creates a #GtkImage displaying a stock icon. Sample stock icon names are #GTK_STOCK_OPEN, #GTK_STOCK_QUIT. Sample stock sizes are #GTK_ICON_SIZE_MENU, #GTK_ICON_SIZE_SMALL_TOOLBAR. If the stock icon name isn’t known, the image will be empty. You can register your own stock icon names, see gtk_icon_factory_add_default() and gtk_icon_factory_add(). Use gtk_image_new_from_icon_name() instead. a new #GtkImage displaying the stock icon a stock icon name a stock icon size (#GtkIconSize) Creates a new #GtkImage displaying @surface. The #GtkImage does not assume a reference to the surface; you still need to unref it if you own references. #GtkImage will add its own reference rather than adopting yours. a new #GtkImage a #cairo_surface_t, or %NULL Resets the image to be empty. a #GtkImage Gets the #GdkPixbufAnimation being displayed by the #GtkImage. The storage type of the image must be %GTK_IMAGE_EMPTY or %GTK_IMAGE_ANIMATION (see gtk_image_get_storage_type()). The caller of this function does not own a reference to the returned animation. the displayed animation, or %NULL if the image is empty a #GtkImage Gets the #GIcon and size being displayed by the #GtkImage. The storage type of the image must be %GTK_IMAGE_EMPTY or %GTK_IMAGE_GICON (see gtk_image_get_storage_type()). The caller of this function does not own a reference to the returned #GIcon. a #GtkImage place to store a #GIcon, or %NULL place to store an icon size (#GtkIconSize), or %NULL Gets the icon name and size being displayed by the #GtkImage. The storage type of the image must be %GTK_IMAGE_EMPTY or %GTK_IMAGE_ICON_NAME (see gtk_image_get_storage_type()). The returned string is owned by the #GtkImage and should not be freed. a #GtkImage place to store an icon name, or %NULL place to store an icon size (#GtkIconSize), or %NULL Gets the icon set and size being displayed by the #GtkImage. The storage type of the image must be %GTK_IMAGE_EMPTY or %GTK_IMAGE_ICON_SET (see gtk_image_get_storage_type()). Use gtk_image_get_icon_name() instead. a #GtkImage location to store a #GtkIconSet, or %NULL location to store a stock icon size (#GtkIconSize), or %NULL Gets the #GdkPixbuf being displayed by the #GtkImage. The storage type of the image must be %GTK_IMAGE_EMPTY or %GTK_IMAGE_PIXBUF (see gtk_image_get_storage_type()). The caller of this function does not own a reference to the returned pixbuf. the displayed pixbuf, or %NULL if the image is empty a #GtkImage Gets the pixel size used for named icons. the pixel size used for named icons. a #GtkImage Gets the stock icon name and size being displayed by the #GtkImage. The storage type of the image must be %GTK_IMAGE_EMPTY or %GTK_IMAGE_STOCK (see gtk_image_get_storage_type()). The returned string is owned by the #GtkImage and should not be freed. Use gtk_image_get_icon_name() instead. a #GtkImage place to store a stock icon name, or %NULL place to store a stock icon size (#GtkIconSize), or %NULL Gets the type of representation being used by the #GtkImage to store image data. If the #GtkImage has no image data, the return value will be %GTK_IMAGE_EMPTY. image representation being used a #GtkImage Causes the #GtkImage to display the given animation (or display nothing, if you set the animation to %NULL). a #GtkImage the #GdkPixbufAnimation See gtk_image_new_from_file() for details. a #GtkImage a filename or %NULL See gtk_image_new_from_gicon() for details. a #GtkImage an icon an icon size (#GtkIconSize) See gtk_image_new_from_icon_name() for details. a #GtkImage an icon name or %NULL an icon size (#GtkIconSize) See gtk_image_new_from_icon_set() for details. Use gtk_image_set_from_icon_name() instead. a #GtkImage a #GtkIconSet a stock icon size (#GtkIconSize) See gtk_image_new_from_pixbuf() for details. a #GtkImage a #GdkPixbuf or %NULL See gtk_image_new_from_resource() for details. a #GtkImage a resource path or %NULL See gtk_image_new_from_stock() for details. Use gtk_image_set_from_icon_name() instead. a #GtkImage a stock icon name a stock icon size (#GtkIconSize) See gtk_image_new_from_surface() for details. a #GtkImage a cairo_surface_t or %NULL Sets the pixel size to use for named icons. If the pixel size is set to a value != -1, it is used instead of the icon size set by gtk_image_set_from_icon_name(). a #GtkImage the new pixel size The GIcon displayed in the GtkImage. For themed icons, If the icon theme is changed, the image will be updated automatically. The name of the icon in the icon theme. If the icon theme is changed, the image will be updated automatically. Use #GtkImage:icon-name instead. The "pixel-size" property can be used to specify a fixed size overriding the #GtkImage:icon-size property for images of type %GTK_IMAGE_ICON_NAME. A path to a resource file to display. Use #GtkImage:icon-name instead. Whether the icon displayed in the GtkImage will use standard icon names fallback. The value of this property is only relevant for images of type %GTK_IMAGE_ICON_NAME and %GTK_IMAGE_GICON. A GtkImageMenuItem is a menu item which has an icon next to the text label. This is functionally equivalent to: |[<!-- language="C" --> GtkWidget *box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); GtkWidget *icon = gtk_image_new_from_icon_name ("folder-music-symbolic", GTK_ICON_SIZE_MENU); GtkWidget *label = gtk_label_new ("Music"); GtkWidget *menu_item = gtk_menu_item_new (); gtk_container_add (GTK_CONTAINER (box), icon); gtk_container_add (GTK_CONTAINER (box), label); gtk_container_add (GTK_CONTAINER (menu_item), box); gtk_widget_show_all (menu_item); ]| Note that the user may disable display of menu icons using the #GtkSettings:gtk-menu-images setting, so make sure to still fill in the text label. If you want to ensure that your menu items show an icon you are strongly encouraged to use a #GtkMenuItem with a #GtkImage instead. #GtkImageMenuItem has been deprecated since GTK+ 3.10. If you want to display an icon in a menu item, you should use #GtkMenuItem and pack a #GtkBox with a #GtkImage and a #GtkLabel instead. You should also consider using #GtkBuilder and the XML #GMenu description for creating menus, by following the [GMenu guide][https://developer.gnome.org/GMenu/]. You should consider using icons in menu items only sparingly, and for "objects" (or "nouns") elements only, like bookmarks, files, and links; "actions" (or "verbs") should not have icons. Furthermore, if you would like to display keyboard accelerator, you must pack the accel label into the box using gtk_box_pack_end() and align the label, otherwise the accelerator will not display correctly. The following code snippet adds a keyboard accelerator to the menu item, with a key binding of Ctrl+M: |[<!-- language="C" --> GtkWidget *box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); GtkWidget *icon = gtk_image_new_from_icon_name ("folder-music-symbolic", GTK_ICON_SIZE_MENU); GtkWidget *label = gtk_accel_label_new ("Music"); GtkWidget *menu_item = gtk_menu_item_new (); GtkAccelGroup *accel_group = gtk_accel_group_new (); gtk_container_add (GTK_CONTAINER (box), icon); gtk_label_set_use_underline (GTK_LABEL (label), TRUE); gtk_label_set_xalign (GTK_LABEL (label), 0.0); gtk_widget_add_accelerator (menu_item, "activate", accel_group, GDK_KEY_m, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); gtk_accel_label_set_accel_widget (GTK_ACCEL_LABEL (label), menu_item); gtk_box_pack_end (GTK_BOX (box), label, TRUE, TRUE, 0); gtk_container_add (GTK_CONTAINER (menu_item), box); gtk_widget_show_all (menu_item); ]| Creates a new #GtkImageMenuItem with an empty label. Use gtk_menu_item_new() instead. a new #GtkImageMenuItem Creates a new #GtkImageMenuItem containing the image and text from a stock item. Some stock ids have preprocessor macros like #GTK_STOCK_OK and #GTK_STOCK_APPLY. If you want this menu item to have changeable accelerators, then pass in %NULL for accel_group. Next call gtk_menu_item_set_accel_path() with an appropriate path for the menu item, use gtk_stock_lookup() to look up the standard accelerator for the stock item, and if one is found, call gtk_accel_map_add_entry() to register it. Use gtk_menu_item_new_with_mnemonic() instead. a new #GtkImageMenuItem. the name of the stock item. the #GtkAccelGroup to add the menu items accelerator to, or %NULL. Creates a new #GtkImageMenuItem containing a label. Use gtk_menu_item_new_with_label() instead. a new #GtkImageMenuItem. the text of the menu item. Creates a new #GtkImageMenuItem containing a label. The label will be created using gtk_label_new_with_mnemonic(), so underscores in @label indicate the mnemonic for the menu item. Use gtk_menu_item_new_with_mnemonic() instead. a new #GtkImageMenuItem the text of the menu item, with an underscore in front of the mnemonic character Returns whether the menu item will ignore the #GtkSettings:gtk-menu-images setting and always show the image, if available. %TRUE if the menu item will always show the image a #GtkImageMenuItem Gets the widget that is currently set as the image of @image_menu_item. See gtk_image_menu_item_set_image(). the widget set as image of @image_menu_item a #GtkImageMenuItem Checks whether the label set in the menuitem is used as a stock id to select the stock item for the item. %TRUE if the label set in the menuitem is used as a stock id to select the stock item for the item a #GtkImageMenuItem Specifies an @accel_group to add the menu items accelerator to (this only applies to stock items so a stock item must already be set, make sure to call gtk_image_menu_item_set_use_stock() and gtk_menu_item_set_label() with a valid stock item first). If you want this menu item to have changeable accelerators then you shouldnt need this (see gtk_image_menu_item_new_from_stock()). a #GtkImageMenuItem the #GtkAccelGroup If %TRUE, the menu item will ignore the #GtkSettings:gtk-menu-images setting and always show the image, if available. Use this property if the menuitem would be useless or hard to use without the image. a #GtkImageMenuItem %TRUE if the menuitem should always show the image Sets the image of @image_menu_item to the given widget. Note that it depends on the show-menu-images setting whether the image will be displayed or not. a #GtkImageMenuItem. a widget to set as the image for the menu item. If %TRUE, the label set in the menuitem is used as a stock id to select the stock item for the item. a #GtkImageMenuItem %TRUE if the menuitem should use a stock item The Accel Group to use for stock accelerator keys Use gtk_widget_add_accelerator() instead If %TRUE, the menu item will always show the image, if available. Use this property only if the menuitem would be useless or hard to use without the image. Use a #GtkMenuItem containing a #GtkBox with a #GtkAccelLabel and a #GtkImage instead Child widget to appear next to the menu text. Use a #GtkMenuItem containing a #GtkBox with a #GtkAccelLabel and a #GtkImage instead If %TRUE, the label set in the menuitem is used as a stock id to select the stock item for the item. Use a named icon from the #GtkIconTheme instead The parent class. Describes the image data representation used by a #GtkImage. If you want to get the image from the widget, you can only get the currently-stored representation. e.g. if the gtk_image_get_storage_type() returns #GTK_IMAGE_PIXBUF, then you can call gtk_image_get_pixbuf() but not gtk_image_get_stock(). For empty images, you can request any storage type (call any of the "get" functions), but they will all return %NULL values. there is no image displayed by the widget the widget contains a #GdkPixbuf the widget contains a [stock item name][gtkstock] the widget contains a #GtkIconSet the widget contains a #GdkPixbufAnimation the widget contains a named icon. This image type was added in GTK+ 2.6 the widget contains a #GIcon. This image type was added in GTK+ 2.14 the widget contains a #cairo_surface_t. This image type was added in GTK+ 3.10 #GtkInfoBar is a widget that can be used to show messages to the user without showing a dialog. It is often temporarily shown at the top or bottom of a document. In contrast to #GtkDialog, which has a action area at the bottom, #GtkInfoBar has an action area at the side. The API of #GtkInfoBar is very similar to #GtkDialog, allowing you to add buttons to the action area with gtk_info_bar_add_button() or gtk_info_bar_new_with_buttons(). The sensitivity of action widgets can be controlled with gtk_info_bar_set_response_sensitive(). To add widgets to the main content area of a #GtkInfoBar, use gtk_info_bar_get_content_area() and add your widgets to the container. Similar to #GtkMessageDialog, the contents of a #GtkInfoBar can by classified as error message, warning, informational message, etc, by using gtk_info_bar_set_message_type(). GTK+ may use the message type to determine how the message is displayed. A simple example for using a #GtkInfoBar: |[<!-- language="C" --> GtkWidget *widget, *message_label, *content_area; GtkWidget *grid; GtkInfoBar *bar; // set up info bar widget = gtk_info_bar_new (); bar = GTK_INFO_BAR (widget); grid = gtk_grid_new (); gtk_widget_set_no_show_all (widget, TRUE); message_label = gtk_label_new (""); content_area = gtk_info_bar_get_content_area (bar); gtk_container_add (GTK_CONTAINER (content_area), message_label); gtk_info_bar_add_button (bar, _("_OK"), GTK_RESPONSE_OK); g_signal_connect (bar, "response", G_CALLBACK (gtk_widget_hide), NULL); gtk_grid_attach (GTK_GRID (grid), widget, 0, 2, 1, 1); // ... // show an error message gtk_label_set_text (GTK_LABEL (message_label), "An error occurred!"); gtk_info_bar_set_message_type (bar, GTK_MESSAGE_ERROR); gtk_widget_show (bar); ]| # GtkInfoBar as GtkBuildable The GtkInfoBar implementation of the GtkBuildable interface exposes the content area and action area as internal children with the names “content_area” and “action_area”. GtkInfoBar supports a custom <action-widgets> element, which can contain multiple <action-widget> elements. The “response” attribute specifies a numeric response, and the content of the element is the id of widget (which should be a child of the dialogs @action_area). # CSS nodes GtkInfoBar has a single CSS node with name infobar. The node may get one of the style classes .info, .warning, .error or .question, depending on the message type. Creates a new #GtkInfoBar object. a new #GtkInfoBar object Creates a new #GtkInfoBar with buttons. Button text/response ID pairs should be listed, with a %NULL pointer ending the list. Button text can be either a stock ID such as %GTK_STOCK_OK, or some arbitrary text. A response ID can be any positive number, or one of the values in the #GtkResponseType enumeration. If the user clicks one of these dialog buttons, GtkInfoBar will emit the “response” signal with the corresponding response ID. a new #GtkInfoBar stock ID or text to go in first button, or %NULL response ID for first button, then additional buttons, ending with %NULL Emits the “response” signal with the given @response_id. a #GtkInfoBar a response ID Add an activatable widget to the action area of a #GtkInfoBar, connecting a signal handler that will emit the #GtkInfoBar::response signal on the message area when the widget is activated. The widget is appended to the end of the message areas action area. a #GtkInfoBar an activatable widget response ID for @child Adds a button with the given text and sets things up so that clicking the button will emit the “response” signal with the given response_id. The button is appended to the end of the info bars's action area. The button widget is returned, but usually you don't need it. the #GtkButton widget that was added a #GtkInfoBar text of button response ID for the button Adds more buttons, same as calling gtk_info_bar_add_button() repeatedly. The variable argument list should be %NULL-terminated as with gtk_info_bar_new_with_buttons(). Each button must have both text and response ID. a #GtkInfoBar button text or stock ID response ID for first button, then more text-response_id pairs, ending with %NULL Returns the action area of @info_bar. the action area a #GtkInfoBar Returns the content area of @info_bar. the content area a #GtkInfoBar Returns the message type of the message area. the message type of the message area. a #GtkInfoBar the current value of the GtkInfoBar:revealed property. a #GtkInfoBar Returns whether the widget will display a standard close button. %TRUE if the widget displays standard close button a #GtkInfoBar Emits the “response” signal with the given @response_id. a #GtkInfoBar a response ID Sets the last widget in the info bar’s action area with the given response_id as the default widget for the dialog. Pressing “Enter” normally activates the default widget. Note that this function currently requires @info_bar to be added to a widget hierarchy. a #GtkInfoBar a response ID Sets the message type of the message area. GTK+ uses this type to determine how the message is displayed. a #GtkInfoBar a #GtkMessageType Calls gtk_widget_set_sensitive (widget, setting) for each widget in the info bars’s action area with the given response_id. A convenient way to sensitize/desensitize dialog buttons. a #GtkInfoBar a response ID TRUE for sensitive Sets the GtkInfoBar:revealed property to @revealed. This will cause @info_bar to show up with a slide-in transition. Note that this property does not automatically show @info_bar and thus won’t have any effect if it is invisible. a #GtkInfoBar The new value of the property If true, a standard close button is shown. When clicked it emits the response %GTK_RESPONSE_CLOSE. a #GtkInfoBar %TRUE to include a close button The type of the message. The type may be used to determine the appearance of the info bar. Whether to include a standard close button. The ::close signal is a [keybinding signal][GtkBindingSignal] which gets emitted when the user uses a keybinding to dismiss the info bar. The default binding for this signal is the Escape key. Emitted when an action widget is clicked or the application programmer calls gtk_dialog_response(). The @response_id depends on which action widget was clicked. the response ID a #GtkInfoBar a response ID Describes hints that might be taken into account by input methods or applications. Note that input methods may already tailor their behaviour according to the #GtkInputPurpose of the entry. Some common sense is expected when using these flags - mixing @GTK_INPUT_HINT_LOWERCASE with any of the uppercase hints makes no sense. This enumeration may be extended in the future; input methods should ignore unknown values. No special behaviour suggested Suggest checking for typos Suggest not checking for typos Suggest word completion Suggest to convert all text to lowercase Suggest to capitalize all text Suggest to capitalize the first character of each word Suggest to capitalize the first word of each sentence Suggest to not show an onscreen keyboard (e.g for a calculator that already has all the keys). The text is vertical. Since 3.18 Suggest offering Emoji support. Since 3.22.20 Suggest not offering Emoji support. Since 3.22.20 Describes primary purpose of the input widget. This information is useful for on-screen keyboards and similar input methods to decide which keys should be presented to the user. Note that the purpose is not meant to impose a totally strict rule about allowed characters, and does not replace input validation. It is fine for an on-screen keyboard to let the user override the character set restriction that is expressed by the purpose. The application is expected to validate the entry contents, even if it specified a purpose. The difference between @GTK_INPUT_PURPOSE_DIGITS and @GTK_INPUT_PURPOSE_NUMBER is that the former accepts only digits while the latter also some punctuation (like commas or points, plus, minus) and “e” or “E” as in 3.14E+000. This enumeration may be extended in the future; input methods should interpret unknown values as “free form”. Allow any character Allow only alphabetic characters Allow only digits Edited field expects numbers Edited field expects phone number Edited field expects URL Edited field expects email address Edited field expects the name of a person Like @GTK_INPUT_PURPOSE_FREE_FORM, but characters are hidden Like @GTK_INPUT_PURPOSE_DIGITS, but characters are hidden Allow any character, in addition to control codes The #GtkInvisible widget is used internally in GTK+, and is probably not very useful for application developers. It is used for reliable pointer grabs and selection handling in the code for drag-and-drop. Creates a new #GtkInvisible. a new #GtkInvisible. Creates a new #GtkInvisible object for a specified screen a newly created #GtkInvisible object a #GdkScreen which identifies on which the new #GtkInvisible will be created. Returns the #GdkScreen object associated with @invisible the associated #GdkScreen. a #GtkInvisible. Sets the #GdkScreen where the #GtkInvisible object will be displayed. a #GtkInvisible. a #GdkScreen. Describes how a rendered element connects to adjacent elements. No junctions. Element connects on the top-left corner. Element connects on the top-right corner. Element connects on the bottom-left corner. Element connects on the bottom-right corner. Element connects on the top side. Element connects on the bottom side. Element connects on the left side. Element connects on the right side. Used for justifying the text inside a #GtkLabel widget. (See also #GtkAlignment). The text is placed at the left edge of the label. The text is placed at the right edge of the label. The text is placed in the center of the label. The text is placed is distributed across the label. Key snooper functions are called before normal event delivery. They can be used to implement custom key event handling. %TRUE to stop further processing of @event, %FALSE to continue. the widget to which the event will be delivered the key event data supplied to gtk_key_snooper_install() The name used for the stock full offset included by #GtkLevelBar. The name used for the stock high offset included by #GtkLevelBar. The name used for the stock low offset included by #GtkLevelBar. The #GtkLabel widget displays a small amount of text. As the name implies, most labels are used to label another widget such as a #GtkButton, a #GtkMenuItem, or a #GtkComboBox. # CSS nodes |[<!-- language="plain" --> label ├── [selection] ├── [link] ┊ ╰── [link] ]| GtkLabel has a single CSS node with the name label. A wide variety of style classes may be applied to labels, such as .title, .subtitle, .dim-label, etc. In the #GtkShortcutsWindow, labels are used wth the .keycap style class. If the label has a selection, it gets a subnode with name selection. If the label has links, there is one subnode per link. These subnodes carry the link or visited state depending on whether they have been visited. # GtkLabel as GtkBuildable The GtkLabel implementation of the GtkBuildable interface supports a custom <attributes> element, which supports any number of <attribute> elements. The <attribute> element has attributes named “name“, “value“, “start“ and “end“ and allows you to specify #PangoAttribute values for this label. An example of a UI definition fragment specifying Pango attributes: |[ <object class="GtkLabel"> <attributes> <attribute name="weight" value="PANGO_WEIGHT_BOLD"/> <attribute name="background" value="red" start="5" end="10"/> </attributes> </object> ]| The start and end attributes specify the range of characters to which the Pango attribute applies. If start and end are not specified, the attribute is applied to the whole text. Note that specifying ranges does not make much sense with translatable attributes. Use markup embedded in the translatable content instead. # Mnemonics Labels may contain “mnemonics”. Mnemonics are underlined characters in the label, used for keyboard navigation. Mnemonics are created by providing a string with an underscore before the mnemonic character, such as `"_File"`, to the functions gtk_label_new_with_mnemonic() or gtk_label_set_text_with_mnemonic(). Mnemonics automatically activate any activatable widget the label is inside, such as a #GtkButton; if the label is not inside the mnemonic’s target widget, you have to tell the label about the target using gtk_label_set_mnemonic_widget(). Here’s a simple example where the label is inside a button: |[<!-- language="C" --> // Pressing Alt+H will activate this button GtkWidget *button = gtk_button_new (); GtkWidget *label = gtk_label_new_with_mnemonic ("_Hello"); gtk_container_add (GTK_CONTAINER (button), label); ]| There’s a convenience function to create buttons with a mnemonic label already inside: |[<!-- language="C" --> // Pressing Alt+H will activate this button GtkWidget *button = gtk_button_new_with_mnemonic ("_Hello"); ]| To create a mnemonic for a widget alongside the label, such as a #GtkEntry, you have to point the label at the entry with gtk_label_set_mnemonic_widget(): |[<!-- language="C" --> // Pressing Alt+H will focus the entry GtkWidget *entry = gtk_entry_new (); GtkWidget *label = gtk_label_new_with_mnemonic ("_Hello"); gtk_label_set_mnemonic_widget (GTK_LABEL (label), entry); ]| # Markup (styled text) To make it easy to format text in a label (changing colors, fonts, etc.), label text can be provided in a simple [markup format][PangoMarkupFormat]. Here’s how to create a label with a small font: |[<!-- language="C" --> GtkWidget *label = gtk_label_new (NULL); gtk_label_set_markup (GTK_LABEL (label), "<small>Small text</small>"); ]| (See [complete documentation][PangoMarkupFormat] of available tags in the Pango manual.) The markup passed to gtk_label_set_markup() must be valid; for example, literal <, > and & characters must be escaped as &lt;, &gt;, and &amp;. If you pass text obtained from the user, file, or a network to gtk_label_set_markup(), you’ll want to escape it with g_markup_escape_text() or g_markup_printf_escaped(). Markup strings are just a convenient way to set the #PangoAttrList on a label; gtk_label_set_attributes() may be a simpler way to set attributes in some cases. Be careful though; #PangoAttrList tends to cause internationalization problems, unless you’re applying attributes to the entire string (i.e. unless you set the range of each attribute to [0, %G_MAXINT)). The reason is that specifying the start_index and end_index for a #PangoAttribute requires knowledge of the exact string being displayed, so translations will cause problems. # Selectable labels Labels can be made selectable with gtk_label_set_selectable(). Selectable labels allow the user to copy the label contents to the clipboard. Only labels that contain useful-to-copy information — such as error messages — should be made selectable. # Text layout # {#label-text-layout} A label can contain any number of paragraphs, but will have performance problems if it contains more than a small number. Paragraphs are separated by newlines or other paragraph separators understood by Pango. Labels can automatically wrap text if you call gtk_label_set_line_wrap(). gtk_label_set_justify() sets how the lines in a label align with one another. If you want to set how the label as a whole aligns in its available space, see the #GtkWidget:halign and #GtkWidget:valign properties. The #GtkLabel:width-chars and #GtkLabel:max-width-chars properties can be used to control the size allocation of ellipsized or wrapped labels. For ellipsizing labels, if either is specified (and less than the actual text size), it is used as the minimum width, and the actual text size is used as the natural width of the label. For wrapping labels, width-chars is used as the minimum width, if specified, and max-width-chars is used as the natural width. Even if max-width-chars specified, wrapping labels will be rewrapped to use all of the available width. Note that the interpretation of #GtkLabel:width-chars and #GtkLabel:max-width-chars has changed a bit with the introduction of [width-for-height geometry management.][geometry-management] # Links Since 2.18, GTK+ supports markup for clickable hyperlinks in addition to regular Pango markup. The markup for links is borrowed from HTML, using the `<a>` with “href“ and “title“ attributes. GTK+ renders links similar to the way they appear in web browsers, with colored, underlined text. The “title“ attribute is displayed as a tooltip on the link. An example looks like this: |[<!-- language="C" --> const gchar *text = "Go to the" "<a href=\"http://www.gtk.org title=\"&lt;i&gt;Our&lt;/i&gt; website\">" "GTK+ website</a> for more..."; GtkWidget *label = gtk_label_new (NULL); gtk_label_set_markup (GTK_LABEL (label), text); ]| It is possible to implement custom handling for links and their tooltips with the #GtkLabel::activate-link signal and the gtk_label_get_current_uri() function. Creates a new label with the given text inside it. You can pass %NULL to get an empty label widget. the new #GtkLabel The text of the label Creates a new #GtkLabel, containing the text in @str. If characters in @str are preceded by an underscore, they are underlined. If you need a literal underscore character in a label, use '__' (two underscores). The first underlined character represents a keyboard accelerator called a mnemonic. The mnemonic key can be used to activate another widget, chosen automatically, or explicitly using gtk_label_set_mnemonic_widget(). If gtk_label_set_mnemonic_widget() is not called, then the first activatable ancestor of the #GtkLabel will be chosen as the mnemonic widget. For instance, if the label is inside a button or menu item, the button or menu item will automatically become the mnemonic widget and be activated by the mnemonic. the new #GtkLabel The text of the label, with an underscore in front of the mnemonic character Gets the angle of rotation for the label. See gtk_label_set_angle(). the angle of rotation for the label a #GtkLabel Gets the attribute list that was set on the label using gtk_label_set_attributes(), if any. This function does not reflect attributes that come from the labels markup (see gtk_label_set_markup()). If you want to get the effective attributes for the label, use pango_layout_get_attribute (gtk_label_get_layout (label)). the attribute list, or %NULL if none was set. a #GtkLabel Returns the URI for the currently active link in the label. The active link is the one under the mouse pointer or, in a selectable label, the link in which the text cursor is currently positioned. This function is intended for use in a #GtkLabel::activate-link handler or for use in a #GtkWidget::query-tooltip handler. the currently active URI. The string is owned by GTK+ and must not be freed or modified. a #GtkLabel Returns the ellipsizing position of the label. See gtk_label_set_ellipsize(). #PangoEllipsizeMode a #GtkLabel Returns the justification of the label. See gtk_label_set_justify(). #GtkJustification a #GtkLabel Fetches the text from a label widget including any embedded underlines indicating mnemonics and Pango markup. (See gtk_label_get_text()). the text of the label widget. This string is owned by the widget and must not be modified or freed. a #GtkLabel Gets the #PangoLayout used to display the label. The layout is useful to e.g. convert text positions to pixel positions, in combination with gtk_label_get_layout_offsets(). The returned layout is owned by the @label so need not be freed by the caller. The @label is free to recreate its layout at any time, so it should be considered read-only. the #PangoLayout for this label a #GtkLabel Obtains the coordinates where the label will draw the #PangoLayout representing the text in the label; useful to convert mouse events into coordinates inside the #PangoLayout, e.g. to take some action if some part of the label is clicked. Of course you will need to create a #GtkEventBox to receive the events, and pack the label inside it, since labels are windowless (they return %FALSE from gtk_widget_get_has_window()). Remember when using the #PangoLayout functions you need to convert to and from pixels using PANGO_PIXELS() or #PANGO_SCALE. a #GtkLabel location to store X offset of layout, or %NULL location to store Y offset of layout, or %NULL Returns whether lines in the label are automatically wrapped. See gtk_label_set_line_wrap(). %TRUE if the lines of the label are automatically wrapped. a #GtkLabel Returns line wrap mode used by the label. See gtk_label_set_line_wrap_mode(). %TRUE if the lines of the label are automatically wrapped. a #GtkLabel Gets the number of lines to which an ellipsized, wrapping label should be limited. See gtk_label_set_lines(). The number of lines a #GtkLabel Retrieves the desired maximum width of @label, in characters. See gtk_label_set_width_chars(). the maximum width of the label in characters. a #GtkLabel If the label has been set so that it has an mnemonic key this function returns the keyval used for the mnemonic accelerator. If there is no mnemonic set up it returns #GDK_KEY_VoidSymbol. GDK keyval usable for accelerators, or #GDK_KEY_VoidSymbol a #GtkLabel Retrieves the target of the mnemonic (keyboard shortcut) of this label. See gtk_label_set_mnemonic_widget(). the target of the label’s mnemonic, or %NULL if none has been set and the default algorithm will be used. a #GtkLabel Gets the value set by gtk_label_set_selectable(). %TRUE if the user can copy text from the label a #GtkLabel Gets the selected range of characters in the label, returning %TRUE if there’s a selection. %TRUE if selection is non-empty a #GtkLabel return location for start of selection, as a character offset return location for end of selection, as a character offset Returns whether the label is in single line mode. %TRUE when the label is in single line mode. a #GtkLabel Fetches the text from a label widget, as displayed on the screen. This does not include any embedded underlines indicating mnemonics or Pango markup. (See gtk_label_get_label()) the text in the label widget. This is the internal string used by the label, and must not be modified. a #GtkLabel Returns whether the label is currently keeping track of clicked links. %TRUE if clicked links are remembered a #GtkLabel Returns whether the label’s text is interpreted as marked up with the [Pango text markup language][PangoMarkupFormat]. See gtk_label_set_use_markup (). %TRUE if the label’s text will be parsed for markup. a #GtkLabel Returns whether an embedded underline in the label indicates a mnemonic. See gtk_label_set_use_underline(). %TRUE whether an embedded underline in the label indicates the mnemonic accelerator keys. a #GtkLabel Retrieves the desired width of @label, in characters. See gtk_label_set_width_chars(). the width of the label in characters. a #GtkLabel Gets the #GtkLabel:xalign property for @label. the xalign property a #GtkLabel Gets the #GtkLabel:yalign property for @label. the yalign property a #GtkLabel Selects a range of characters in the label, if the label is selectable. See gtk_label_set_selectable(). If the label is not selectable, this function has no effect. If @start_offset or @end_offset are -1, then the end of the label will be substituted. a #GtkLabel start offset (in characters not bytes) end offset (in characters not bytes) Sets the angle of rotation for the label. An angle of 90 reads from from bottom to top, an angle of 270, from top to bottom. The angle setting for the label is ignored if the label is selectable, wrapped, or ellipsized. a #GtkLabel the angle that the baseline of the label makes with the horizontal, in degrees, measured counterclockwise Sets a #PangoAttrList; the attributes in the list are applied to the label text. The attributes set with this function will be applied and merged with any other attributes previously effected by way of the #GtkLabel:use-underline or #GtkLabel:use-markup properties. While it is not recommended to mix markup strings with manually set attributes, if you must; know that the attributes will be applied to the label after the markup string is parsed. a #GtkLabel a #PangoAttrList, or %NULL Sets the mode used to ellipsize (add an ellipsis: "...") to the text if there is not enough space to render the entire string. a #GtkLabel a #PangoEllipsizeMode Sets the alignment of the lines in the text of the label relative to each other. %GTK_JUSTIFY_LEFT is the default value when the widget is first created with gtk_label_new(). If you instead want to set the alignment of the label as a whole, use gtk_widget_set_halign() instead. gtk_label_set_justify() has no effect on labels containing only a single line. a #GtkLabel a #GtkJustification Sets the text of the label. The label is interpreted as including embedded underlines and/or Pango markup depending on the values of the #GtkLabel:use-underline and #GtkLabel:use-markup properties. a #GtkLabel the new text to set for the label Toggles line wrapping within the #GtkLabel widget. %TRUE makes it break lines if text exceeds the widget’s size. %FALSE lets the text get cut off by the edge of the widget if it exceeds the widget size. Note that setting line wrapping to %TRUE does not make the label wrap at its parent container’s width, because GTK+ widgets conceptually can’t make their requisition depend on the parent container’s size. For a label that wraps at a specific position, set the label’s width using gtk_widget_set_size_request(). a #GtkLabel the setting If line wrapping is on (see gtk_label_set_line_wrap()) this controls how the line wrapping is done. The default is %PANGO_WRAP_WORD which means wrap on word boundaries. a #GtkLabel the line wrapping mode Sets the number of lines to which an ellipsized, wrapping label should be limited. This has no effect if the label is not wrapping or ellipsized. Set this to -1 if you don’t want to limit the number of lines. a #GtkLabel the desired number of lines, or -1 Parses @str which is marked up with the [Pango text markup language][PangoMarkupFormat], setting the label’s text and attribute list based on the parse results. If the @str is external data, you may need to escape it with g_markup_escape_text() or g_markup_printf_escaped(): |[<!-- language="C" --> GtkWidget *label = gtk_label_new (NULL); const char *str = "some text"; const char *format = "<span style=\"italic\">\%s</span>"; char *markup; markup = g_markup_printf_escaped (format, str); gtk_label_set_markup (GTK_LABEL (label), markup); g_free (markup); ]| This function will set the #GtkLabel:use-markup property to %TRUE as a side effect. If you set the label contents using the #GtkLabel:label property you should also ensure that you set the #GtkLabel:use-markup property accordingly. See also: gtk_label_set_text() a #GtkLabel a markup string (see [Pango markup format][PangoMarkupFormat]) Parses @str which is marked up with the [Pango text markup language][PangoMarkupFormat], setting the label’s text and attribute list based on the parse results. If characters in @str are preceded by an underscore, they are underlined indicating that they represent a keyboard accelerator called a mnemonic. The mnemonic key can be used to activate another widget, chosen automatically, or explicitly using gtk_label_set_mnemonic_widget(). a #GtkLabel a markup string (see [Pango markup format][PangoMarkupFormat]) Sets the desired maximum width in characters of @label to @n_chars. a #GtkLabel the new desired maximum width, in characters. If the label has been set so that it has an mnemonic key (using i.e. gtk_label_set_markup_with_mnemonic(), gtk_label_set_text_with_mnemonic(), gtk_label_new_with_mnemonic() or the “use_underline” property) the label can be associated with a widget that is the target of the mnemonic. When the label is inside a widget (like a #GtkButton or a #GtkNotebook tab) it is automatically associated with the correct widget, but sometimes (i.e. when the target is a #GtkEntry next to the label) you need to set it explicitly using this function. The target widget will be accelerated by emitting the GtkWidget::mnemonic-activate signal on it. The default handler for this signal will activate the widget if there are no mnemonic collisions and toggle focus between the colliding widgets otherwise. a #GtkLabel the target #GtkWidget, or %NULL to unset The pattern of underlines you want under the existing text within the #GtkLabel widget. For example if the current text of the label says “FooBarBaz” passing a pattern of “___ ___” will underline “Foo” and “Baz” but not “Bar”. The #GtkLabel you want to set the pattern to. The pattern as described above. Selectable labels allow the user to select text from the label, for copy-and-paste. a #GtkLabel %TRUE to allow selecting text in the label Sets whether the label is in single line mode. a #GtkLabel %TRUE if the label should be in single line mode Sets the text within the #GtkLabel widget. It overwrites any text that was there before. This function will clear any previously set mnemonic accelerators, and set the #GtkLabel:use-underline property to %FALSE as a side effect. This function will set the #GtkLabel:use-markup property to %FALSE as a side effect. See also: gtk_label_set_markup() a #GtkLabel The text you want to set Sets the label’s text from the string @str. If characters in @str are preceded by an underscore, they are underlined indicating that they represent a keyboard accelerator called a mnemonic. The mnemonic key can be used to activate another widget, chosen automatically, or explicitly using gtk_label_set_mnemonic_widget(). a #GtkLabel a string Sets whether the label should keep track of clicked links (and use a different color for them). a #GtkLabel %TRUE to track visited links Sets whether the text of the label contains markup in [Pango’s text markup language][PangoMarkupFormat]. See gtk_label_set_markup(). a #GtkLabel %TRUE if the label’s text should be parsed for markup. If true, an underline in the text indicates the next character should be used for the mnemonic accelerator key. a #GtkLabel %TRUE if underlines in the text indicate mnemonics Sets the desired width in characters of @label to @n_chars. a #GtkLabel the new desired width, in characters. Sets the #GtkLabel:xalign property for @label. a #GtkLabel the new xalign value, between 0 and 1 Sets the #GtkLabel:yalign property for @label. a #GtkLabel the new yalign value, between 0 and 1 The angle that the baseline of the label makes with the horizontal, in degrees, measured counterclockwise. An angle of 90 reads from from bottom to top, an angle of 270, from top to bottom. Ignored if the label is selectable. The preferred place to ellipsize the string, if the label does not have enough room to display the entire string, specified as a #PangoEllipsizeMode. Note that setting this property to a value other than %PANGO_ELLIPSIZE_NONE has the side-effect that the label requests only enough space to display the ellipsis "...". In particular, this means that ellipsizing labels do not work well in notebook tabs, unless the #GtkNotebook tab-expand child property is set to %TRUE. Other ways to set a label's width are gtk_widget_set_size_request() and gtk_label_set_width_chars(). The contents of the label. If the string contains [Pango XML markup][PangoMarkupFormat], you will have to set the #GtkLabel:use-markup property to %TRUE in order for the label to display the markup attributes. See also gtk_label_set_markup() for a convenience function that sets both this property and the #GtkLabel:use-markup property at the same time. If the string contains underlines acting as mnemonics, you will have to set the #GtkLabel:use-underline property to %TRUE in order for the label to display them. The number of lines to which an ellipsized, wrapping label should be limited. This property has no effect if the label is not wrapping or ellipsized. Set this property to -1 if you don't want to limit the number of lines. The desired maximum width of the label, in characters. If this property is set to -1, the width will be calculated automatically. See the section on [text layout][label-text-layout] for details of how #GtkLabel:width-chars and #GtkLabel:max-width-chars determine the width of ellipsized and wrapped labels. Whether the label is in single line mode. In single line mode, the height of the label does not depend on the actual text, it is always set to ascent + descent of the font. This can be an advantage in situations where resizing the label because of text changes would be distracting, e.g. in a statusbar. Set this property to %TRUE to make the label track which links have been visited. It will then apply the #GTK_STATE_FLAG_VISITED when rendering this link, in addition to #GTK_STATE_FLAG_LINK. The desired width of the label, in characters. If this property is set to -1, the width will be calculated automatically. See the section on [text layout][label-text-layout] for details of how #GtkLabel:width-chars and #GtkLabel:max-width-chars determine the width of ellipsized and wrapped labels. If line wrapping is on (see the #GtkLabel:wrap property) this controls how the line wrapping is done. The default is %PANGO_WRAP_WORD, which means wrap on word boundaries. The xalign property determines the horizontal aligment of the label text inside the labels size allocation. Compare this to #GtkWidget:halign, which determines how the labels size allocation is positioned in the space available for the label. The yalign property determines the vertical aligment of the label text inside the labels size allocation. Compare this to #GtkWidget:valign, which determines how the labels size allocation is positioned in the space available for the label. A [keybinding signal][GtkBindingSignal] which gets emitted when the user activates a link in the label. Applications may also emit the signal with g_signal_emit_by_name() if they need to control activation of URIs programmatically. The default bindings for this signal are all forms of the Enter key. The signal which gets emitted to activate a URI. Applications may connect to it to override the default behaviour, which is to call gtk_show_uri_on_window(). %TRUE if the link has been activated the URI that is activated The ::copy-clipboard signal is a [keybinding signal][GtkBindingSignal] which gets emitted to copy the selection to the clipboard. The default binding for this signal is Ctrl-c. The ::move-cursor signal is a [keybinding signal][GtkBindingSignal] which gets emitted when the user initiates a cursor movement. If the cursor is not visible in @entry, this signal causes the viewport to be moved instead. Applications should not connect to it, but may emit it with g_signal_emit_by_name() if they need to control the cursor programmatically. The default bindings for this signal come in two variants, the variant with the Shift modifier extends the selection, the variant without the Shift modifer does not. There are too many key combinations to list them all here. - Arrow keys move by individual characters/lines - Ctrl-arrow key combinations move by words/paragraphs - Home/End keys move to the ends of the buffer the granularity of the move, as a #GtkMovementStep the number of @step units to move %TRUE if the move should extend the selection The ::populate-popup signal gets emitted before showing the context menu of the label. Note that only selectable labels have context menus. If you need to add items to the context menu, connect to this signal and append your menuitems to the @menu. the menu that is being populated #GtkLayout is similar to #GtkDrawingArea in that it’s a “blank slate” and doesn’t do anything except paint a blank background by default. It’s different in that it supports scrolling natively due to implementing #GtkScrollable, and can contain child widgets since it’s a #GtkContainer. If you just want to draw, a #GtkDrawingArea is a better choice since it has lower overhead. If you just need to position child widgets at specific points, then #GtkFixed provides that functionality on its own. When handling expose events on a #GtkLayout, you must draw to the #GdkWindow returned by gtk_layout_get_bin_window(), rather than to the one returned by gtk_widget_get_window() as you would for a #GtkDrawingArea. Creates a new #GtkLayout. Unless you have a specific adjustment you’d like the layout to use for scrolling, pass %NULL for @hadjustment and @vadjustment. a new #GtkLayout horizontal scroll adjustment, or %NULL vertical scroll adjustment, or %NULL Retrieve the bin window of the layout used for drawing operations. a #GdkWindow a #GtkLayout This function should only be called after the layout has been placed in a #GtkScrolledWindow or otherwise configured for scrolling. It returns the #GtkAdjustment used for communication between the horizontal scrollbar and @layout. See #GtkScrolledWindow, #GtkScrollbar, #GtkAdjustment for details. Use gtk_scrollable_get_hadjustment() horizontal scroll adjustment a #GtkLayout Gets the size that has been set on the layout, and that determines the total extents of the layout’s scrollbar area. See gtk_layout_set_size (). a #GtkLayout location to store the width set on @layout, or %NULL location to store the height set on @layout, or %NULL This function should only be called after the layout has been placed in a #GtkScrolledWindow or otherwise configured for scrolling. It returns the #GtkAdjustment used for communication between the vertical scrollbar and @layout. See #GtkScrolledWindow, #GtkScrollbar, #GtkAdjustment for details. Use gtk_scrollable_get_vadjustment() vertical scroll adjustment a #GtkLayout Moves a current child of @layout to a new position. a #GtkLayout a current child of @layout X position to move to Y position to move to Adds @child_widget to @layout, at position (@x,@y). @layout becomes the new parent container of @child_widget. a #GtkLayout child widget X position of child widget Y position of child widget Sets the horizontal scroll adjustment for the layout. See #GtkScrolledWindow, #GtkScrollbar, #GtkAdjustment for details. Use gtk_scrollable_set_hadjustment() a #GtkLayout new scroll adjustment Sets the size of the scrollable area of the layout. a #GtkLayout width of entire scrollable area height of entire scrollable area Sets the vertical scroll adjustment for the layout. See #GtkScrolledWindow, #GtkScrollbar, #GtkAdjustment for details. Use gtk_scrollable_set_vadjustment() a #GtkLayout new scroll adjustment The #GtkLevelBar is a bar widget that can be used as a level indicator. Typical use cases are displaying the strength of a password, or showing the charge level of a battery. Use gtk_level_bar_set_value() to set the current value, and gtk_level_bar_add_offset_value() to set the value offsets at which the bar will be considered in a different state. GTK will add a few offsets by default on the level bar: #GTK_LEVEL_BAR_OFFSET_LOW, #GTK_LEVEL_BAR_OFFSET_HIGH and #GTK_LEVEL_BAR_OFFSET_FULL, with values 0.25, 0.75 and 1.0 respectively. Note that it is your responsibility to update preexisting offsets when changing the minimum or maximum value. GTK+ will simply clamp them to the new range. ## Adding a custom offset on the bar |[<!-- language="C" --> static GtkWidget * create_level_bar (void) { GtkWidget *widget; GtkLevelBar *bar; widget = gtk_level_bar_new (); bar = GTK_LEVEL_BAR (widget); // This changes the value of the default low offset gtk_level_bar_add_offset_value (bar, GTK_LEVEL_BAR_OFFSET_LOW, 0.10); // This adds a new offset to the bar; the application will // be able to change its color CSS like this: // // levelbar block.my-offset { // background-color: magenta; // border-style: solid; // border-color: black; // border-style: 1px; // } gtk_level_bar_add_offset_value (bar, "my-offset", 0.60); return widget; } ]| The default interval of values is between zero and one, but it’s possible to modify the interval using gtk_level_bar_set_min_value() and gtk_level_bar_set_max_value(). The value will be always drawn in proportion to the admissible interval, i.e. a value of 15 with a specified interval between 10 and 20 is equivalent to a value of 0.5 with an interval between 0 and 1. When #GTK_LEVEL_BAR_MODE_DISCRETE is used, the bar level is rendered as a finite number of separated blocks instead of a single one. The number of blocks that will be rendered is equal to the number of units specified by the admissible interval. For instance, to build a bar rendered with five blocks, it’s sufficient to set the minimum value to 0 and the maximum value to 5 after changing the indicator mode to discrete. GtkLevelBar was introduced in GTK+ 3.6. # GtkLevelBar as GtkBuildable The GtkLevelBar implementation of the GtkBuildable interface supports a custom <offsets> element, which can contain any number of <offset> elements, each of which must have name and value attributes. # CSS nodes |[<!-- language="plain" --> levelbar[.discrete] ╰── trough ├── block.filled.level-name ┊ ├── block.empty ┊ ]| GtkLevelBar has a main CSS node with name levelbar and one of the style classes .discrete or .continuous and a subnode with name trough. Below the trough node are a number of nodes with name block and style class .filled or .empty. In continuous mode, there is exactly one node of each, in discrete mode, the number of filled and unfilled nodes corresponds to blocks that are drawn. The block.filled nodes also get a style class .level-name corresponding to the level for the current value. In horizontal orientation, the nodes are always arranged from left to right, regardless of text direction. Creates a new #GtkLevelBar. a #GtkLevelBar. Utility constructor that creates a new #GtkLevelBar for the specified interval. a #GtkLevelBar a positive value a positive value Adds a new offset marker on @self at the position specified by @value. When the bar value is in the interval topped by @value (or between @value and #GtkLevelBar:max-value in case the offset is the last one on the bar) a style class named `level-`@name will be applied when rendering the level bar fill. If another offset marker named @name exists, its value will be replaced by @value. a #GtkLevelBar the name of the new offset the value for the new offset Return the value of the #GtkLevelBar:inverted property. %TRUE if the level bar is inverted a #GtkLevelBar Returns the value of the #GtkLevelBar:max-value property. a positive value a #GtkLevelBar Returns the value of the #GtkLevelBar:min-value property. a positive value a #GtkLevelBar Returns the value of the #GtkLevelBar:mode property. a #GtkLevelBarMode a #GtkLevelBar Fetches the value specified for the offset marker @name in @self, returning %TRUE in case an offset named @name was found. %TRUE if the specified offset is found a #GtkLevelBar the name of an offset in the bar location where to store the value Returns the value of the #GtkLevelBar:value property. a value in the interval between #GtkLevelBar:min-value and #GtkLevelBar:max-value a #GtkLevelBar Removes an offset marker previously added with gtk_level_bar_add_offset_value(). a #GtkLevelBar the name of an offset in the bar Sets the value of the #GtkLevelBar:inverted property. a #GtkLevelBar %TRUE to invert the level bar Sets the value of the #GtkLevelBar:max-value property. You probably want to update preexisting level offsets after calling this function. a #GtkLevelBar a positive value Sets the value of the #GtkLevelBar:min-value property. You probably want to update preexisting level offsets after calling this function. a #GtkLevelBar a positive value Sets the value of the #GtkLevelBar:mode property. a #GtkLevelBar a #GtkLevelBarMode Sets the value of the #GtkLevelBar:value property. a #GtkLevelBar a value in the interval between #GtkLevelBar:min-value and #GtkLevelBar:max-value Level bars normally grow from top to bottom or left to right. Inverted level bars grow in the opposite direction. The #GtkLevelBar:max-value property determaxes the maximum value of the interval that can be displayed by the bar. The #GtkLevelBar:min-value property determines the minimum value of the interval that can be displayed by the bar. The #GtkLevelBar:mode property determines the way #GtkLevelBar interprets the value properties to draw the level fill area. Specifically, when the value is #GTK_LEVEL_BAR_MODE_CONTINUOUS, #GtkLevelBar will draw a single block representing the current value in that area; when the value is #GTK_LEVEL_BAR_MODE_DISCRETE, the widget will draw a succession of separate blocks filling the draw area, with the number of blocks being equal to the units separating the integral roundings of #GtkLevelBar:min-value and #GtkLevelBar:max-value. The #GtkLevelBar:value property determines the currently filled value of the level bar. Emitted when an offset specified on the bar changes value as an effect to gtk_level_bar_add_offset_value() being called. The signal supports detailed connections; you can connect to the detailed signal "changed::x" in order to only receive callbacks when the value of offset "x" changes. the name of the offset that changed value Describes how #GtkLevelBar contents should be rendered. Note that this enumeration could be extended with additional modes in the future. the bar has a continuous mode the bar has a discrete mode The type of license for an application. This enumeration can be expanded at later date. No license specified A license text is going to be specified by the developer The GNU General Public License, version 2.0 or later The GNU General Public License, version 3.0 or later The GNU Lesser General Public License, version 2.1 or later The GNU Lesser General Public License, version 3.0 or later The BSD standard license The MIT/X11 standard license The Artistic License, version 2.0 The GNU General Public License, version 2.0 only. Since 3.12. The GNU General Public License, version 3.0 only. Since 3.12. The GNU Lesser General Public License, version 2.1 only. Since 3.12. The GNU Lesser General Public License, version 3.0 only. Since 3.12. The GNU Affero General Public License, version 3.0 or later. Since: 3.22. The GNU Affero General Public License, version 3.0 only. Since: 3.22.27. The 3-clause BSD licence. Since: 3.24.20. The Apache License, version 2.0. Since: 3.24.20. The Mozilla Public License, version 2.0. Since: 3.24.20. A GtkLinkButton is a #GtkButton with a hyperlink, similar to the one used by web browsers, which triggers an action when clicked. It is useful to show quick links to resources. A link button is created by calling either gtk_link_button_new() or gtk_link_button_new_with_label(). If using the former, the URI you pass to the constructor is used as a label for the widget. The URI bound to a GtkLinkButton can be set specifically using gtk_link_button_set_uri(), and retrieved using gtk_link_button_get_uri(). By default, GtkLinkButton calls gtk_show_uri_on_window() when the button is clicked. This behaviour can be overridden by connecting to the #GtkLinkButton::activate-link signal and returning %TRUE from the signal handler. # CSS nodes GtkLinkButton has a single CSS node with name button. To differentiate it from a plain #GtkButton, it gets the .link style class. Creates a new #GtkLinkButton with the URI as its text. a new link button widget. a valid URI Creates a new #GtkLinkButton containing a label. a new link button widget. a valid URI the text of the button Retrieves the URI set using gtk_link_button_set_uri(). a valid URI. The returned string is owned by the link button and should not be modified or freed. a #GtkLinkButton Retrieves the “visited” state of the URI where the #GtkLinkButton points. The button becomes visited when it is clicked. If the URI is changed on the button, the “visited” state is unset again. The state may also be changed using gtk_link_button_set_visited(). %TRUE if the link has been visited, %FALSE otherwise a #GtkLinkButton Sets @uri as the URI where the #GtkLinkButton points. As a side-effect this unsets the “visited” state of the button. a #GtkLinkButton a valid URI Sets the “visited” state of the URI where the #GtkLinkButton points. See gtk_link_button_get_visited() for more details. a #GtkLinkButton the new “visited” state The URI bound to this button. The 'visited' state of this button. A visited link is drawn in a different color. The ::activate-link signal is emitted each time the #GtkLinkButton has been clicked. The default handler will call gtk_show_uri_on_window() with the URI stored inside the #GtkLinkButton:uri property. To override the default behavior, you can connect to the ::activate-link signal and stop the propagation of the signal by returning %TRUE from your handler. The #GtkLinkButtonClass contains only private data. A GtkListBox is a vertical container that contains GtkListBoxRow children. These rows can by dynamically sorted and filtered, and headers can be added dynamically depending on the row content. It also allows keyboard and mouse navigation and selection like a typical list. Using GtkListBox is often an alternative to #GtkTreeView, especially when the list contents has a more complicated layout than what is allowed by a #GtkCellRenderer, or when the contents is interactive (i.e. has a button in it). Although a #GtkListBox must have only #GtkListBoxRow children you can add any kind of widget to it via gtk_container_add(), and a #GtkListBoxRow widget will automatically be inserted between the list and the widget. #GtkListBoxRows can be marked as activatable or selectable. If a row is activatable, #GtkListBox::row-activated will be emitted for it when the user tries to activate it. If it is selectable, the row will be marked as selected when the user tries to select it. The GtkListBox widget was added in GTK+ 3.10. # GtkListBox as GtkBuildable The GtkListBox implementation of the #GtkBuildable interface supports setting a child as the placeholder by specifying “placeholder” as the “type” attribute of a <child> element. See gtk_list_box_set_placeholder() for info. # CSS nodes |[<!-- language="plain" --> list ╰── row[.activatable] ]| GtkListBox uses a single CSS node named list. Each GtkListBoxRow uses a single CSS node named row. The row nodes get the .activatable style class added when appropriate. Creates a new #GtkListBox container. a new #GtkListBox Select all children of @box, if the selection mode allows it. a #GtkListBox Unselect all children of @box, if the selection mode allows it. a #GtkListBox Binds @model to @box. If @box was already bound to a model, that previous binding is destroyed. The contents of @box are cleared and then filled with widgets that represent items from @model. @box is updated whenever @model changes. If @model is %NULL, @box is left empty. It is undefined to add or remove widgets directly (for example, with gtk_list_box_insert() or gtk_container_add()) while @box is bound to a model. Note that using a model is incompatible with the filtering and sorting functionality in GtkListBox. When using a model, filtering and sorting should be implemented by the model. a #GtkListBox the #GListModel to be bound to @box a function that creates widgets for items or %NULL in case you also passed %NULL as @model user data passed to @create_widget_func function for freeing @user_data This is a helper function for implementing DnD onto a #GtkListBox. The passed in @row will be highlighted via gtk_drag_highlight(), and any previously highlighted row will be unhighlighted. The row will also be unhighlighted when the widget gets a drag leave event. a #GtkListBox a #GtkListBoxRow If a row has previously been highlighted via gtk_list_box_drag_highlight_row() it will have the highlight removed. a #GtkListBox Returns whether rows activate on single clicks. %TRUE if rows are activated on single click, %FALSE otherwise a #GtkListBox Gets the adjustment (if any) that the widget uses to for vertical scrolling. the adjustment a #GtkListBox Gets the n-th child in the list (not counting headers). If @_index is negative or larger than the number of items in the list, %NULL is returned. the child #GtkWidget or %NULL a #GtkListBox the index of the row Gets the row at the @y position. the row or %NULL in case no row exists for the given y coordinate. a #GtkListBox position Gets the selected row. Note that the box may allow multiple selection, in which case you should use gtk_list_box_selected_foreach() to find all selected rows. the selected row a #GtkListBox Creates a list of all selected children. A #GList containing the #GtkWidget for each selected child. Free with g_list_free() when done. a #GtkListBox Gets the selection mode of the listbox. a #GtkSelectionMode a #GtkListBox Insert the @child into the @box at @position. If a sort function is set, the widget will actually be inserted at the calculated position and this function has the same effect of gtk_container_add(). If @position is -1, or larger than the total number of items in the @box, then the @child will be appended to the end. a #GtkListBox the #GtkWidget to add the position to insert @child in Update the filtering for all rows. Call this when result of the filter function on the @box is changed due to an external factor. For instance, this would be used if the filter function just looked for a specific search string and the entry with the search string has changed. a #GtkListBox Update the separators for all rows. Call this when result of the header function on the @box is changed due to an external factor. a #GtkListBox Update the sorting for all rows. Call this when result of the sort function on the @box is changed due to an external factor. a #GtkListBox Prepend a widget to the list. If a sort function is set, the widget will actually be inserted at the calculated position and this function has the same effect of gtk_container_add(). a #GtkListBox the #GtkWidget to add Select all children of @box, if the selection mode allows it. a #GtkListBox Make @row the currently selected row. a #GtkListBox The row to select or %NULL Calls a function for each selected child. Note that the selection cannot be modified from within this function. a #GtkListBox the function to call for each selected child user data to pass to the function If @single is %TRUE, rows will be activated when you click on them, otherwise you need to double-click. a #GtkListBox a boolean Sets the adjustment (if any) that the widget uses to for vertical scrolling. For instance, this is used to get the page size for PageUp/Down key handling. In the normal case when the @box is packed inside a #GtkScrolledWindow the adjustment from that will be picked up automatically, so there is no need to manually do that. a #GtkListBox the adjustment, or %NULL By setting a filter function on the @box one can decide dynamically which of the rows to show. For instance, to implement a search function on a list that filters the original list to only show the matching rows. The @filter_func will be called for each row after the call, and it will continue to be called each time a row changes (via gtk_list_box_row_changed()) or when gtk_list_box_invalidate_filter() is called. Note that using a filter function is incompatible with using a model (see gtk_list_box_bind_model()). a #GtkListBox callback that lets you filter which rows to show user data passed to @filter_func destroy notifier for @user_data By setting a header function on the @box one can dynamically add headers in front of rows, depending on the contents of the row and its position in the list. For instance, one could use it to add headers in front of the first item of a new kind, in a list sorted by the kind. The @update_header can look at the current header widget using gtk_list_box_row_get_header() and either update the state of the widget as needed, or set a new one using gtk_list_box_row_set_header(). If no header is needed, set the header to %NULL. Note that you may get many calls @update_header to this for a particular row when e.g. changing things that don’t affect the header. In this case it is important for performance to not blindly replace an existing header with an identical one. The @update_header function will be called for each row after the call, and it will continue to be called each time a row changes (via gtk_list_box_row_changed()) and when the row before changes (either by gtk_list_box_row_changed() on the previous row, or when the previous row becomes a different row). It is also called for all rows when gtk_list_box_invalidate_headers() is called. a #GtkListBox callback that lets you add row headers user data passed to @update_header destroy notifier for @user_data Sets the placeholder widget that is shown in the list when it doesn't display any visible children. a #GtkListBox a #GtkWidget or %NULL Sets how selection works in the listbox. See #GtkSelectionMode for details. a #GtkListBox The #GtkSelectionMode By setting a sort function on the @box one can dynamically reorder the rows of the list, based on the contents of the rows. The @sort_func will be called for each row after the call, and will continue to be called each time a row changes (via gtk_list_box_row_changed()) and when gtk_list_box_invalidate_sort() is called. Note that using a sort function is incompatible with using a model (see gtk_list_box_bind_model()). a #GtkListBox the sort function user data passed to @sort_func destroy notifier for @user_data Unselect all children of @box, if the selection mode allows it. a #GtkListBox Unselects a single row of @box, if the selection mode allows it. a #GtkListBox the row to unselected The ::row-activated signal is emitted when a row has been activated by the user. the activated row The ::row-selected signal is emitted when a new row is selected, or (with a %NULL @row) when the selection is cleared. When the @box is using #GTK_SELECTION_MULTIPLE, this signal will not give you the full picture of selection changes, and you should use the #GtkListBox::selected-rows-changed signal instead. the selected row The ::select-all signal is a [keybinding signal][GtkBindingSignal] which gets emitted to select all children of the box, if the selection mode permits it. The default bindings for this signal is Ctrl-a. The ::selected-rows-changed signal is emitted when the set of selected rows changes. The ::unselect-all signal is a [keybinding signal][GtkBindingSignal] which gets emitted to unselect all children of the box, if the selection mode permits it. The default bindings for this signal is Ctrl-Shift-a. The parent class. a #GtkListBox a #GtkListBox Called for list boxes that are bound to a #GListModel with gtk_list_box_bind_model() for each item that gets added to the model. Versions of GTK+ prior to 3.18 called gtk_widget_show_all() on the rows created by the GtkListBoxCreateWidgetFunc, but this forced all widgets inside the row to be shown, and is no longer the case. Applications should be updated to show the desired row widgets. a #GtkWidget that represents @item the item from the model for which to create a widget for user data Will be called whenever the row changes or is added and lets you control if the row should be visible or not. %TRUE if the row should be visible, %FALSE otherwise the row that may be filtered user data A function used by gtk_list_box_selected_foreach(). It will be called on every selected child of the @box. a #GtkListBox a #GtkListBoxRow user data Creates a new #GtkListBoxRow, to be used as a child of a #GtkListBox. a new #GtkListBoxRow Marks @row as changed, causing any state that depends on this to be updated. This affects sorting, filtering and headers. Note that calls to this method must be in sync with the data used for the row functions. For instance, if the list is mirroring some external data set, and *two* rows changed in the external data set then when you call gtk_list_box_row_changed() on the first row the sort function must only read the new data for the first of the two changed rows, otherwise the resorting of the rows will be wrong. This generally means that if you don’t fully control the data model you have to duplicate the data that affects the listbox row functions into the row widgets themselves. Another alternative is to call gtk_list_box_invalidate_sort() on any model change, but that is more expensive. a #GtkListBoxRow Gets the value of the #GtkListBoxRow:activatable property for this row. %TRUE if the row is activatable a #GtkListBoxRow Returns the current header of the @row. This can be used in a #GtkListBoxUpdateHeaderFunc to see if there is a header set already, and if so to update the state of it. the current header, or %NULL if none a #GtkListBoxRow Gets the current index of the @row in its #GtkListBox container. the index of the @row, or -1 if the @row is not in a listbox a #GtkListBoxRow Gets the value of the #GtkListBoxRow:selectable property for this row. %TRUE if the row is selectable a #GtkListBoxRow Returns whether the child is currently selected in its #GtkListBox container. %TRUE if @row is selected a #GtkListBoxRow Set the #GtkListBoxRow:activatable property for this row. a #GtkListBoxRow %TRUE to mark the row as activatable Sets the current header of the @row. This is only allowed to be called from a #GtkListBoxUpdateHeaderFunc. It will replace any existing header in the row, and be shown in front of the row in the listbox. a #GtkListBoxRow the header, or %NULL Set the #GtkListBoxRow:selectable property for this row. a #GtkListBoxRow %TRUE to mark the row as selectable The property determines whether the #GtkListBox::row-activated signal will be emitted for this row. The property determines whether this row can be selected. This is a keybinding signal, which will cause this row to be activated. If you want to be notified when the user activates a row (by key or not), use the #GtkListBox::row-activated signal on the row’s parent #GtkListBox. The parent class. Compare two rows to determine which should be first. < 0 if @row1 should be before @row2, 0 if they are equal and > 0 otherwise the first row the second row user data Whenever @row changes or which row is before @row changes this is called, which lets you update the header on @row. You may remove or set a new one via gtk_list_box_row_set_header() or just change the state of the current header widget. the row to update the row before @row, or %NULL if it is first user data The #GtkListStore object is a list model for use with a #GtkTreeView widget. It implements the #GtkTreeModel interface, and consequentialy, can use all of the methods available there. It also implements the #GtkTreeSortable interface so it can be sorted by the view. Finally, it also implements the tree [drag and drop][gtk3-GtkTreeView-drag-and-drop] interfaces. The #GtkListStore can accept most GObject types as a column type, though it can’t accept all custom types. Internally, it will keep a copy of data passed in (such as a string or a boxed pointer). Columns that accept #GObjects are handled a little differently. The #GtkListStore will keep a reference to the object instead of copying the value. As a result, if the object is modified, it is up to the application writer to call gtk_tree_model_row_changed() to emit the #GtkTreeModel::row_changed signal. This most commonly affects lists with #GdkPixbufs stored. An example for creating a simple list store: |[<!-- language="C" --> enum { COLUMN_STRING, COLUMN_INT, COLUMN_BOOLEAN, N_COLUMNS }; { GtkListStore *list_store; GtkTreePath *path; GtkTreeIter iter; gint i; list_store = gtk_list_store_new (N_COLUMNS, G_TYPE_STRING, G_TYPE_INT, G_TYPE_BOOLEAN); for (i = 0; i < 10; i++) { gchar *some_data; some_data = get_some_data (i); // Add a new row to the model gtk_list_store_append (list_store, &iter); gtk_list_store_set (list_store, &iter, COLUMN_STRING, some_data, COLUMN_INT, i, COLUMN_BOOLEAN, FALSE, -1); // As the store will keep a copy of the string internally, // we free some_data. g_free (some_data); } // Modify a particular row path = gtk_tree_path_new_from_string ("4"); gtk_tree_model_get_iter (GTK_TREE_MODEL (list_store), &iter, path); gtk_tree_path_free (path); gtk_list_store_set (list_store, &iter, COLUMN_BOOLEAN, TRUE, -1); } ]| # Performance Considerations Internally, the #GtkListStore was implemented with a linked list with a tail pointer prior to GTK+ 2.6. As a result, it was fast at data insertion and deletion, and not fast at random data access. The #GtkListStore sets the #GTK_TREE_MODEL_ITERS_PERSIST flag, which means that #GtkTreeIters can be cached while the row exists. Thus, if access to a particular row is needed often and your code is expected to run on older versions of GTK+, it is worth keeping the iter around. # Atomic Operations It is important to note that only the methods gtk_list_store_insert_with_values() and gtk_list_store_insert_with_valuesv() are atomic, in the sense that the row is being appended to the store and the values filled in in a single operation with regard to #GtkTreeModel signaling. In contrast, using e.g. gtk_list_store_append() and then gtk_list_store_set() will first create a row, which triggers the #GtkTreeModel::row-inserted signal on #GtkListStore. The row, however, is still empty, and any signal handler connecting to #GtkTreeModel::row-inserted on this particular store should be prepared for the situation that the row might be empty. This is especially important if you are wrapping the #GtkListStore inside a #GtkTreeModelFilter and are using a #GtkTreeModelFilterVisibleFunc. Using any of the non-atomic operations to append rows to the #GtkListStore will cause the #GtkTreeModelFilterVisibleFunc to be visited with an empty row first; the function must be prepared for that. # GtkListStore as GtkBuildable The GtkListStore implementation of the GtkBuildable interface allows to specify the model columns with a <columns> element that may contain multiple <column> elements, each specifying one model column. The “type” attribute specifies the data type for the column. Additionally, it is possible to specify content for the list store in the UI definition, with the <data> element. It can contain multiple <row> elements, each specifying to content for one row of the list model. Inside a <row>, the <col> elements specify the content for individual cells. Note that it is probably more common to define your models in the code, and one might consider it a layering violation to specify the content of a list store in a UI definition, data, not presentation, and common wisdom is to separate the two, as far as possible. An example of a UI Definition fragment for a list store: |[<!-- language="C" --> <object class="GtkListStore"> <columns> <column type="gchararray"/> <column type="gchararray"/> <column type="gint"/> </columns> <data> <row> <col id="0">John</col> <col id="1">Doe</col> <col id="2">25</col> </row> <row> <col id="0">Johan</col> <col id="1">Dahlin</col> <col id="2">50</col> </row> </data> </object> ]| Creates a new list store as with @n_columns columns each of the types passed in. Note that only types derived from standard GObject fundamental types are supported. As an example, `gtk_list_store_new (3, G_TYPE_INT, G_TYPE_STRING, GDK_TYPE_PIXBUF);` will create a new #GtkListStore with three columns, of type int, string and #GdkPixbuf respectively. a new #GtkListStore number of columns in the list store all #GType types for the columns, from first to last Non-vararg creation function. Used primarily by language bindings. a new #GtkListStore number of columns in the list store an array of #GType types for the columns, from first to last Appends a new row to @list_store. @iter will be changed to point to this new row. The row will be empty after this function is called. To fill in values, you need to call gtk_list_store_set() or gtk_list_store_set_value(). A #GtkListStore An unset #GtkTreeIter to set to the appended row Removes all rows from the list store. a #GtkListStore. Creates a new row at @position. @iter will be changed to point to this new row. If @position is -1 or is larger than the number of rows on the list, then the new row will be appended to the list. The row will be empty after this function is called. To fill in values, you need to call gtk_list_store_set() or gtk_list_store_set_value(). A #GtkListStore An unset #GtkTreeIter to set to the new row position to insert the new row, or -1 for last Inserts a new row after @sibling. If @sibling is %NULL, then the row will be prepended to the beginning of the list. @iter will be changed to point to this new row. The row will be empty after this function is called. To fill in values, you need to call gtk_list_store_set() or gtk_list_store_set_value(). A #GtkListStore An unset #GtkTreeIter to set to the new row A valid #GtkTreeIter, or %NULL Inserts a new row before @sibling. If @sibling is %NULL, then the row will be appended to the end of the list. @iter will be changed to point to this new row. The row will be empty after this function is called. To fill in values, you need to call gtk_list_store_set() or gtk_list_store_set_value(). A #GtkListStore An unset #GtkTreeIter to set to the new row A valid #GtkTreeIter, or %NULL Creates a new row at @position. @iter will be changed to point to this new row. If @position is -1, or larger than the number of rows in the list, then the new row will be appended to the list. The row will be filled with the values given to this function. Calling `gtk_list_store_insert_with_values (list_store, iter, position...)` has the same effect as calling |[<!-- language="C" --> static void insert_value (GtkListStore *list_store, GtkTreeIter *iter, int position) { gtk_list_store_insert (list_store, iter, position); gtk_list_store_set (list_store, iter // ... ); } ]| with the difference that the former will only emit a row_inserted signal, while the latter will emit row_inserted, row_changed and, if the list store is sorted, rows_reordered. Since emitting the rows_reordered signal repeatedly can affect the performance of the program, gtk_list_store_insert_with_values() should generally be preferred when inserting rows in a sorted list store. A #GtkListStore An unset #GtkTreeIter to set to the new row, or %NULL position to insert the new row, or -1 to append after existing rows pairs of column number and value, terminated with -1 A variant of gtk_list_store_insert_with_values() which takes the columns and values as two arrays, instead of varargs. This function is mainly intended for language-bindings. A #GtkListStore An unset #GtkTreeIter to set to the new row, or %NULL. position to insert the new row, or -1 for last an array of column numbers an array of GValues the length of the @columns and @values arrays > This function is slow. Only use it for debugging and/or testing > purposes. Checks if the given iter is a valid iter for this #GtkListStore. %TRUE if the iter is valid, %FALSE if the iter is invalid. A #GtkListStore. A #GtkTreeIter. Moves @iter in @store to the position after @position. Note that this function only works with unsorted stores. If @position is %NULL, @iter will be moved to the start of the list. A #GtkListStore. A #GtkTreeIter. A #GtkTreeIter or %NULL. Moves @iter in @store to the position before @position. Note that this function only works with unsorted stores. If @position is %NULL, @iter will be moved to the end of the list. A #GtkListStore. A #GtkTreeIter. A #GtkTreeIter, or %NULL. Prepends a new row to @list_store. @iter will be changed to point to this new row. The row will be empty after this function is called. To fill in values, you need to call gtk_list_store_set() or gtk_list_store_set_value(). A #GtkListStore An unset #GtkTreeIter to set to the prepend row Removes the given row from the list store. After being removed, @iter is set to be the next valid row, or invalidated if it pointed to the last row in @list_store. %TRUE if @iter is valid, %FALSE if not. A #GtkListStore A valid #GtkTreeIter Reorders @store to follow the order indicated by @new_order. Note that this function only works with unsorted stores. A #GtkListStore. an array of integers mapping the new position of each child to its old position before the re-ordering, i.e. @new_order`[newpos] = oldpos`. It must have exactly as many items as the list store’s length. Sets the value of one or more cells in the row referenced by @iter. The variable argument list should contain integer column numbers, each column number followed by the value to be set. The list is terminated by a -1. For example, to set column 0 with type %G_TYPE_STRING to “Foo”, you would write `gtk_list_store_set (store, iter, 0, "Foo", -1)`. The value will be referenced by the store if it is a %G_TYPE_OBJECT, and it will be copied if it is a %G_TYPE_STRING or %G_TYPE_BOXED. a #GtkListStore row iterator pairs of column number and value, terminated with -1 This function is meant primarily for #GObjects that inherit from #GtkListStore, and should only be used when constructing a new #GtkListStore. It will not function after a row has been added, or a method on the #GtkTreeModel interface is called. A #GtkListStore Number of columns for the list store An array length n of #GTypes See gtk_list_store_set(); this version takes a va_list for use by language bindings. A #GtkListStore A valid #GtkTreeIter for the row being modified va_list of column/value pairs Sets the data in the cell specified by @iter and @column. The type of @value must be convertible to the type of the column. A #GtkListStore A valid #GtkTreeIter for the row being modified column number to modify new value for the cell A variant of gtk_list_store_set_valist() which takes the columns and values as two arrays, instead of varargs. This function is mainly intended for language-bindings and in case the number of columns to change is not known until run-time. A #GtkListStore A valid #GtkTreeIter for the row being modified an array of column numbers an array of GValues the length of the @columns and @values arrays Swaps @a and @b in @store. Note that this function only works with unsorted stores. A #GtkListStore. A #GtkTreeIter. Another #GtkTreeIter. GtkLockButton is a widget that can be used in control panels or preference dialogs to allow users to obtain and revoke authorizations needed to operate the controls. The required authorization is represented by a #GPermission object. Concrete implementations of #GPermission may use PolicyKit or some other authorization framework. To obtain a PolicyKit-based #GPermission, use polkit_permission_new(). If the user is not currently allowed to perform the action, but can obtain the permission, the widget looks like this: ![](lockbutton-locked.png) and the user can click the button to request the permission. Depending on the platform, this may pop up an authentication dialog or ask the user to authenticate in some other way. Once the user has obtained the permission, the widget changes to this: ![](lockbutton-unlocked.png) and the permission can be dropped again by clicking the button. If the user is not able to obtain the permission at all, the widget looks like this: ![](lockbutton-sorry.png) If the user has the permission and cannot drop it, the button is hidden. The text (and tooltips) that are shown in the various cases can be adjusted with the #GtkLockButton:text-lock, #GtkLockButton:text-unlock, #GtkLockButton:tooltip-lock, #GtkLockButton:tooltip-unlock and #GtkLockButton:tooltip-not-authorized properties. Creates a new lock button which reflects the @permission. a new #GtkLockButton a #GPermission Obtains the #GPermission object that controls @button. the #GPermission of @button a #GtkLockButton Sets the #GPermission object that controls @button. a #GtkLockButton a #GPermission object, or %NULL The parent class. Like gtk_get_major_version(), but from the headers used at application compile time, rather than from the library linked against at application run time. The maximum length of sequences in compose tables. Like gtk_get_micro_version(), but from the headers used at application compile time, rather than from the library linked against at application run time. Like gtk_get_minor_version(), but from the headers used at application compile time, rather than from the library linked against at application run time. A #GtkMenu is a #GtkMenuShell that implements a drop down menu consisting of a list of #GtkMenuItem objects which can be navigated and activated by the user to perform application functions. A #GtkMenu is most commonly dropped down by activating a #GtkMenuItem in a #GtkMenuBar or popped up by activating a #GtkMenuItem in another #GtkMenu. A #GtkMenu can also be popped up by activating a #GtkComboBox. Other composite widgets such as the #GtkNotebook can pop up a #GtkMenu as well. Applications can display a #GtkMenu as a popup menu by calling the gtk_menu_popup() function. The example below shows how an application can pop up a menu when the 3rd mouse button is pressed. ## Connecting the popup signal handler. |[<!-- language="C" --> // connect our handler which will popup the menu g_signal_connect_swapped (window, "button_press_event", G_CALLBACK (my_popup_handler), menu); ]| ## Signal handler which displays a popup menu. |[<!-- language="C" --> static gint my_popup_handler (GtkWidget *widget, GdkEvent *event) { GtkMenu *menu; GdkEventButton *event_button; g_return_val_if_fail (widget != NULL, FALSE); g_return_val_if_fail (GTK_IS_MENU (widget), FALSE); g_return_val_if_fail (event != NULL, FALSE); // The "widget" is the menu that was supplied when // g_signal_connect_swapped() was called. menu = GTK_MENU (widget); if (event->type == GDK_BUTTON_PRESS) { event_button = (GdkEventButton *) event; if (event_button->button == GDK_BUTTON_SECONDARY) { gtk_menu_popup (menu, NULL, NULL, NULL, NULL, event_button->button, event_button->time); return TRUE; } } return FALSE; } ]| # CSS nodes |[<!-- language="plain" --> menu ├── arrow.top ├── <child> ┊ ├── <child> ╰── arrow.bottom ]| The main CSS node of GtkMenu has name menu, and there are two subnodes with name arrow, for scrolling menu arrows. These subnodes get the .top and .bottom style classes. Creates a new #GtkMenu a new #GtkMenu Creates a #GtkMenu and populates it with menu items and submenus according to @model. The created menu items are connected to actions found in the #GtkApplicationWindow to which the menu belongs - typically by means of being attached to a widget (see gtk_menu_attach_to_widget()) that is contained within the #GtkApplicationWindows widget hierarchy. Actions can also be added using gtk_widget_insert_action_group() on the menu's attach widget or on any of its parent widgets. a new #GtkMenu a #GMenuModel Returns a list of the menus which are attached to this widget. This list is owned by GTK+ and must not be modified. the list of menus attached to his widget. a #GtkWidget Adds a new #GtkMenuItem to a (table) menu. The number of “cells” that an item will occupy is specified by @left_attach, @right_attach, @top_attach and @bottom_attach. These each represent the leftmost, rightmost, uppermost and lower column and row numbers of the table. (Columns and rows are indexed from zero). Note that this function is not related to gtk_menu_detach(). a #GtkMenu a #GtkMenuItem The column number to attach the left side of the item to The column number to attach the right side of the item to The row number to attach the top of the item to The row number to attach the bottom of the item to Attaches the menu to the widget and provides a callback function that will be invoked when the menu calls gtk_menu_detach() during its destruction. If the menu is attached to the widget then it will be destroyed when the widget is destroyed, as if it was a child widget. An attached menu will also move between screens correctly if the widgets moves between screens. a #GtkMenu the #GtkWidget that the menu will be attached to the user supplied callback function that will be called when the menu calls gtk_menu_detach() Detaches the menu from the widget to which it had been attached. This function will call the callback function, @detacher, provided when the gtk_menu_attach_to_widget() function was called. a #GtkMenu Gets the #GtkAccelGroup which holds global accelerators for the menu. See gtk_menu_set_accel_group(). the #GtkAccelGroup associated with the menu a #GtkMenu Retrieves the accelerator path set on the menu. the accelerator path set on the menu. a valid #GtkMenu Returns the selected menu item from the menu. This is used by the #GtkComboBox. the #GtkMenuItem that was last selected in the menu. If a selection has not yet been made, the first menu item is selected. a #GtkMenu Returns the #GtkWidget that the menu is attached to. the #GtkWidget that the menu is attached to a #GtkMenu Retrieves the number of the monitor on which to show the menu. the number of the monitor on which the menu should be popped up or -1, if no monitor has been set a #GtkMenu Returns whether the menu reserves space for toggles and icons, regardless of their actual presence. Whether the menu reserves toggle space a #GtkMenu Returns whether the menu is torn off. See gtk_menu_set_tearoff_state(). %TRUE if the menu is currently torn off. a #GtkMenu Returns the title of the menu. See gtk_menu_set_title(). the title of the menu, or %NULL if the menu has no title set on it. This string is owned by GTK+ and should not be modified or freed. a #GtkMenu Places @menu on the given monitor. a #GtkMenu the monitor to place the menu on Removes the menu from the screen. a #GtkMenu Displays a menu and makes it available for selection. Applications can use this function to display context-sensitive menus, and will typically supply %NULL for the @parent_menu_shell, @parent_menu_item, @func and @data parameters. The default menu positioning function will position the menu at the current mouse cursor position. The @button parameter should be the mouse button pressed to initiate the menu popup. If the menu popup was initiated by something other than a mouse button press, such as a mouse button release or a keypress, @button should be 0. The @activate_time parameter is used to conflict-resolve initiation of concurrent requests for mouse/keyboard grab requests. To function properly, this needs to be the timestamp of the user event (such as a mouse click or key press) that caused the initiation of the popup. Only if no such event is available, gtk_get_current_event_time() can be used instead. Note that this function does not work very well on GDK backends that do not have global coordinates, such as Wayland or Mir. You should probably use one of the gtk_menu_popup_at_ variants, which do not have this problem. Please use gtk_menu_popup_at_widget(), gtk_menu_popup_at_pointer(). or gtk_menu_popup_at_rect() instead a #GtkMenu the menu shell containing the triggering menu item, or %NULL the menu item whose activation triggered the popup, or %NULL a user supplied function used to position the menu, or %NULL user supplied data to be passed to @func. the mouse button which was pressed to initiate the event. the time at which the activation event occurred. Displays @menu and makes it available for selection. See gtk_menu_popup_at_widget () to pop up a menu at a widget. gtk_menu_popup_at_rect () also allows you to position a menu at an arbitrary rectangle. @menu will be positioned at the pointer associated with @trigger_event. Properties that influence the behaviour of this function are #GtkMenu:anchor-hints, #GtkMenu:rect-anchor-dx, #GtkMenu:rect-anchor-dy, and #GtkMenu:menu-type-hint. Connect to the #GtkMenu::popped-up signal to find out how it was actually positioned. the #GtkMenu to pop up the #GdkEvent that initiated this request or %NULL if it's the current event Displays @menu and makes it available for selection. See gtk_menu_popup_at_widget () and gtk_menu_popup_at_pointer (), which handle more common cases for popping up menus. @menu will be positioned at @rect, aligning their anchor points. @rect is relative to the top-left corner of @rect_window. @rect_anchor and @menu_anchor determine anchor points on @rect and @menu to pin together. @menu can optionally be offset by #GtkMenu:rect-anchor-dx and #GtkMenu:rect-anchor-dy. Anchors should be specified under the assumption that the text direction is left-to-right; they will be flipped horizontally automatically if the text direction is right-to-left. Other properties that influence the behaviour of this function are #GtkMenu:anchor-hints and #GtkMenu:menu-type-hint. Connect to the #GtkMenu::popped-up signal to find out how it was actually positioned. the #GtkMenu to pop up the #GdkWindow @rect is relative to the #GdkRectangle to align @menu with the point on @rect to align with @menu's anchor point the point on @menu to align with @rect's anchor point the #GdkEvent that initiated this request or %NULL if it's the current event Displays @menu and makes it available for selection. See gtk_menu_popup_at_pointer () to pop up a menu at the master pointer. gtk_menu_popup_at_rect () also allows you to position a menu at an arbitrary rectangle. ![](popup-anchors.png) @menu will be positioned at @widget, aligning their anchor points. @widget_anchor and @menu_anchor determine anchor points on @widget and @menu to pin together. @menu can optionally be offset by #GtkMenu:rect-anchor-dx and #GtkMenu:rect-anchor-dy. Anchors should be specified under the assumption that the text direction is left-to-right; they will be flipped horizontally automatically if the text direction is right-to-left. Other properties that influence the behaviour of this function are #GtkMenu:anchor-hints and #GtkMenu:menu-type-hint. Connect to the #GtkMenu::popped-up signal to find out how it was actually positioned. the #GtkMenu to pop up the #GtkWidget to align @menu with the point on @widget to align with @menu's anchor point the point on @menu to align with @widget's anchor point the #GdkEvent that initiated this request or %NULL if it's the current event Displays a menu and makes it available for selection. Applications can use this function to display context-sensitive menus, and will typically supply %NULL for the @parent_menu_shell, @parent_menu_item, @func, @data and @destroy parameters. The default menu positioning function will position the menu at the current position of @device (or its corresponding pointer). The @button parameter should be the mouse button pressed to initiate the menu popup. If the menu popup was initiated by something other than a mouse button press, such as a mouse button release or a keypress, @button should be 0. The @activate_time parameter is used to conflict-resolve initiation of concurrent requests for mouse/keyboard grab requests. To function properly, this needs to be the time stamp of the user event (such as a mouse click or key press) that caused the initiation of the popup. Only if no such event is available, gtk_get_current_event_time() can be used instead. Note that this function does not work very well on GDK backends that do not have global coordinates, such as Wayland or Mir. You should probably use one of the gtk_menu_popup_at_ variants, which do not have this problem. Please use gtk_menu_popup_at_widget(), gtk_menu_popup_at_pointer(). or gtk_menu_popup_at_rect() instead a #GtkMenu a #GdkDevice the menu shell containing the triggering menu item, or %NULL the menu item whose activation triggered the popup, or %NULL a user supplied function used to position the menu, or %NULL user supplied data to be passed to @func destroy notify for @data the mouse button which was pressed to initiate the event the time at which the activation event occurred Moves @child to a new @position in the list of @menu children. a #GtkMenu the #GtkMenuItem to move the new position to place @child. Positions are numbered from 0 to n - 1 Repositions the menu according to its position function. a #GtkMenu Set the #GtkAccelGroup which holds global accelerators for the menu. This accelerator group needs to also be added to all windows that this menu is being used in with gtk_window_add_accel_group(), in order for those windows to support all the accelerators contained in this group. a #GtkMenu the #GtkAccelGroup to be associated with the menu. Sets an accelerator path for this menu from which accelerator paths for its immediate children, its menu items, can be constructed. The main purpose of this function is to spare the programmer the inconvenience of having to call gtk_menu_item_set_accel_path() on each menu item that should support runtime user changable accelerators. Instead, by just calling gtk_menu_set_accel_path() on their parent, each menu item of this menu, that contains a label describing its purpose, automatically gets an accel path assigned. For example, a menu containing menu items “New” and “Exit”, will, after `gtk_menu_set_accel_path (menu, "<Gnumeric-Sheet>/File");` has been called, assign its items the accel paths: `"<Gnumeric-Sheet>/File/New"` and `"<Gnumeric-Sheet>/File/Exit"`. Assigning accel paths to menu items then enables the user to change their accelerators at runtime. More details about accelerator paths and their default setups can be found at gtk_accel_map_add_entry(). Note that @accel_path string will be stored in a #GQuark. Therefore, if you pass a static string, you can save some memory by interning it first with g_intern_static_string(). a valid #GtkMenu a valid accelerator path, or %NULL to unset the path Selects the specified menu item within the menu. This is used by the #GtkComboBox and should not be used by anyone else. a #GtkMenu the index of the menu item to select. Index values are from 0 to n-1 Informs GTK+ on which monitor a menu should be popped up. See gdk_monitor_get_geometry(). This function should be called from a #GtkMenuPositionFunc if the menu should not appear on the same monitor as the pointer. This information can’t be reliably inferred from the coordinates returned by a #GtkMenuPositionFunc, since, for very long menus, these coordinates may extend beyond the monitor boundaries or even the screen boundaries. a #GtkMenu the number of the monitor on which the menu should be popped up Sets whether the menu should reserve space for drawing toggles or icons, regardless of their actual presence. a #GtkMenu whether to reserve size for toggles Sets the #GdkScreen on which the menu will be displayed. a #GtkMenu a #GdkScreen, or %NULL if the screen should be determined by the widget the menu is attached to Changes the tearoff state of the menu. A menu is normally displayed as drop down menu which persists as long as the menu is active. It can also be displayed as a tearoff menu which persists until it is closed or reattached. a #GtkMenu If %TRUE, menu is displayed as a tearoff menu. Sets the title string for the menu. The title is displayed when the menu is shown as a tearoff menu. If @title is %NULL, the menu will see if it is attached to a parent menu item, and if so it will try to use the same text as that menu item’s label. a #GtkMenu a string containing the title for the menu, or %NULL to inherit the title of the parent menu item, if any The accel group holding accelerators for the menu. An accel path used to conveniently construct accel paths of child items. The index of the currently selected menu item, or -1 if no menu item is selected. Positioning hints for aligning the menu relative to a rectangle. These hints determine how the menu should be positioned in the case that the menu would fall off-screen if placed in its ideal position. ![](popup-flip.png) For example, %GDK_ANCHOR_FLIP_Y will replace %GDK_GRAVITY_NORTH_WEST with %GDK_GRAVITY_SOUTH_WEST and vice versa if the menu extends beyond the bottom edge of the monitor. See gtk_menu_popup_at_rect (), gtk_menu_popup_at_widget (), gtk_menu_popup_at_pointer (), #GtkMenu:rect-anchor-dx, #GtkMenu:rect-anchor-dy, #GtkMenu:menu-type-hint, and #GtkMenu::popped-up. The widget the menu is attached to. Setting this property attaches the menu without a #GtkMenuDetachFunc. If you need to use a detacher, use gtk_menu_attach_to_widget() directly. The #GdkWindowTypeHint to use for the menu's #GdkWindow. See gtk_menu_popup_at_rect (), gtk_menu_popup_at_widget (), gtk_menu_popup_at_pointer (), #GtkMenu:anchor-hints, #GtkMenu:rect-anchor-dx, #GtkMenu:rect-anchor-dy, and #GtkMenu::popped-up. The monitor the menu will be popped up on. Horizontal offset to apply to the menu, i.e. the rectangle or widget anchor. See gtk_menu_popup_at_rect (), gtk_menu_popup_at_widget (), gtk_menu_popup_at_pointer (), #GtkMenu:anchor-hints, #GtkMenu:rect-anchor-dy, #GtkMenu:menu-type-hint, and #GtkMenu::popped-up. Vertical offset to apply to the menu, i.e. the rectangle or widget anchor. See gtk_menu_popup_at_rect (), gtk_menu_popup_at_widget (), gtk_menu_popup_at_pointer (), #GtkMenu:anchor-hints, #GtkMenu:rect-anchor-dx, #GtkMenu:menu-type-hint, and #GtkMenu::popped-up. A boolean that indicates whether the menu reserves space for toggles and icons, regardless of their actual presence. This property should only be changed from its default value for special-purposes such as tabular menus. Regular menus that are connected to a menu bar or context menus should reserve toggle space for consistency. A boolean that indicates whether the menu is torn-off. A title that may be displayed by the window manager when this menu is torn-off. a #GtkScrollType Emitted when the position of @menu is finalized after being popped up using gtk_menu_popup_at_rect (), gtk_menu_popup_at_widget (), or gtk_menu_popup_at_pointer (). @menu might be flipped over the anchor rectangle in order to keep it on-screen, in which case @flipped_x and @flipped_y will be set to %TRUE accordingly. @flipped_rect is the ideal position of @menu after any possible flipping, but before any possible sliding. @final_rect is @flipped_rect, but possibly translated in the case that flipping is still ineffective in keeping @menu on-screen. ![](popup-slide.png) The blue menu is @menu's ideal position, the green menu is @flipped_rect, and the red menu is @final_rect. See gtk_menu_popup_at_rect (), gtk_menu_popup_at_widget (), gtk_menu_popup_at_pointer (), #GtkMenu:anchor-hints, #GtkMenu:rect-anchor-dx, #GtkMenu:rect-anchor-dy, and #GtkMenu:menu-type-hint. the position of @menu after any possible flipping or %NULL if the backend can't obtain it the final position of @menu or %NULL if the backend can't obtain it %TRUE if the anchors were flipped horizontally %TRUE if the anchors were flipped vertically The #GtkMenuBar is a subclass of #GtkMenuShell which contains one or more #GtkMenuItems. The result is a standard menu bar which can hold many menu items. # CSS nodes GtkMenuBar has a single CSS node with name menubar. Creates a new #GtkMenuBar the new menu bar, as a #GtkWidget Creates a new #GtkMenuBar and populates it with menu items and submenus according to @model. The created menu items are connected to actions found in the #GtkApplicationWindow to which the menu bar belongs - typically by means of being contained within the #GtkApplicationWindows widget hierarchy. a new #GtkMenuBar a #GMenuModel Retrieves the current child pack direction of the menubar. See gtk_menu_bar_set_child_pack_direction(). the child pack direction a #GtkMenuBar Retrieves the current pack direction of the menubar. See gtk_menu_bar_set_pack_direction(). the pack direction a #GtkMenuBar Sets how widgets should be packed inside the children of a menubar. a #GtkMenuBar a new #GtkPackDirection Sets how items should be packed inside a menubar. a #GtkMenuBar a new #GtkPackDirection The child pack direction of the menubar. It determines how the widgets contained in child menuitems are arranged. The pack direction of the menubar. It determines how menuitems are arranged in the menubar. The #GtkMenuButton widget is used to display a popup when clicked on. This popup can be provided either as a #GtkMenu, a #GtkPopover or an abstract #GMenuModel. The #GtkMenuButton widget can hold any valid child widget. That is, it can hold almost any other standard #GtkWidget. The most commonly used child is #GtkImage. If no widget is explicitely added to the #GtkMenuButton, a #GtkImage is automatically created, using an arrow image oriented according to #GtkMenuButton:direction or the generic “open-menu-symbolic” icon if the direction is not set. The positioning of the popup is determined by the #GtkMenuButton:direction property of the menu button. For menus, the #GtkWidget:halign and #GtkWidget:valign properties of the menu are also taken into account. For example, when the direction is %GTK_ARROW_DOWN and the horizontal alignment is %GTK_ALIGN_START, the menu will be positioned below the button, with the starting edge (depending on the text direction) of the menu aligned with the starting edge of the button. If there is not enough space below the button, the menu is popped up above the button instead. If the alignment would move part of the menu offscreen, it is “pushed in”. ## Direction = Down - halign = start ![](down-start.png) - halign = center ![](down-center.png) - halign = end ![](down-end.png) ## Direction = Up - halign = start ![](up-start.png) - halign = center ![](up-center.png) - halign = end ![](up-end.png) ## Direction = Left - valign = start ![](left-start.png) - valign = center ![](left-center.png) - valign = end ![](left-end.png) ## Direction = Right - valign = start ![](right-start.png) - valign = center ![](right-center.png) - valign = end ![](right-end.png) # CSS nodes GtkMenuButton has a single CSS node with name button. To differentiate it from a plain #GtkButton, it gets the .popup style class. Creates a new #GtkMenuButton widget with downwards-pointing arrow as the only child. You can replace the child widget with another #GtkWidget should you wish to. The newly created #GtkMenuButton widget Returns the parent #GtkWidget to use to line up with menu. a #GtkWidget value or %NULL a #GtkMenuButton Returns the direction the popup will be pointing at when popped up. a #GtkArrowType value a #GtkMenuButton Returns the #GMenuModel used to generate the popup. a #GMenuModel or %NULL a #GtkMenuButton Returns the #GtkPopover that pops out of the button. If the button is not using a #GtkPopover, this function returns %NULL. a #GtkPopover or %NULL a #GtkMenuButton Returns the #GtkMenu that pops out of the button. If the button does not use a #GtkMenu, this function returns %NULL. a #GtkMenu or %NULL a #GtkMenuButton Returns whether a #GtkPopover or a #GtkMenu will be constructed from the menu model. %TRUE if using a #GtkPopover a #GtkMenuButton Sets the #GtkWidget to use to line the menu with when popped up. Note that the @align_widget must contain the #GtkMenuButton itself. Setting it to %NULL means that the menu will be aligned with the button itself. Note that this property is only used with menus currently, and not for popovers. a #GtkMenuButton a #GtkWidget Sets the direction in which the popup will be popped up, as well as changing the arrow’s direction. The child will not be changed to an arrow if it was customized. If the does not fit in the available space in the given direction, GTK+ will its best to keep it inside the screen and fully visible. If you pass %GTK_ARROW_NONE for a @direction, the popup will behave as if you passed %GTK_ARROW_DOWN (although you won’t see any arrows). a #GtkMenuButton a #GtkArrowType Sets the #GMenuModel from which the popup will be constructed, or %NULL to dissociate any existing menu model and disable the button. Depending on the value of #GtkMenuButton:use-popover, either a #GtkMenu will be created with gtk_menu_new_from_model(), or a #GtkPopover with gtk_popover_new_from_model(). In either case, actions will be connected as documented for these functions. If #GtkMenuButton:popup or #GtkMenuButton:popover are already set, those widgets are dissociated from the @menu_button, and those properties are set to %NULL. a #GtkMenuButton a #GMenuModel, or %NULL to unset and disable the button Sets the #GtkPopover that will be popped up when the @menu_button is clicked, or %NULL to dissociate any existing popover and disable the button. If #GtkMenuButton:menu-model or #GtkMenuButton:popup are set, those objects are dissociated from the @menu_button, and those properties are set to %NULL. a #GtkMenuButton a #GtkPopover, or %NULL to unset and disable the button Sets the #GtkMenu that will be popped up when the @menu_button is clicked, or %NULL to dissociate any existing menu and disable the button. If #GtkMenuButton:menu-model or #GtkMenuButton:popover are set, those objects are dissociated from the @menu_button, and those properties are set to %NULL. a #GtkMenuButton a #GtkMenu, or %NULL to unset and disable the button Sets whether to construct a #GtkPopover instead of #GtkMenu when gtk_menu_button_set_menu_model() is called. Note that this property is only consulted when a new menu model is set. a #GtkMenuButton %TRUE to construct a popover from the menu model The #GtkWidget to use to align the menu with. The #GtkArrowType representing the direction in which the menu or popover will be popped out. The #GMenuModel from which the popup will be created. Depending on the #GtkMenuButton:use-popover property, that may be a menu or a popover. See gtk_menu_button_set_menu_model() for the interaction with the #GtkMenuButton:popup property. The #GtkPopover that will be popped up when the button is clicked. The #GtkMenu that will be popped up when the button is clicked. Whether to construct a #GtkPopover from the menu model, or a #GtkMenu. A user function supplied when calling gtk_menu_attach_to_widget() which will be called when the menu is later detached from the widget. the #GtkWidget that the menu is being detached from. the #GtkMenu being detached. An enumeration representing directional movements within a menu. To the parent menu shell To the submenu, if any, associated with the item To the next menu item To the previous menu item The #GtkMenuItem widget and the derived widgets are the only valid children for menus. Their function is to correctly handle highlighting, alignment, events and submenus. As a GtkMenuItem derives from #GtkBin it can hold any valid child widget, although only a few are really useful. By default, a GtkMenuItem sets a #GtkAccelLabel as its child. GtkMenuItem has direct functions to set the label and its mnemonic. For more advanced label settings, you can fetch the child widget from the GtkBin. An example for setting markup and accelerator on a MenuItem: |[<!-- language="C" --> GtkWidget *menu_item = gtk_menu_item_new_with_label ("Example Menu Item"); GtkWidget *child = gtk_bin_get_child (GTK_BIN (menu_item)); gtk_label_set_markup (GTK_LABEL (child), "<i>new label</i> with <b>markup</b>"); gtk_accel_label_set_accel (GTK_ACCEL_LABEL (child), GDK_KEY_1, 0); ]| # GtkMenuItem as GtkBuildable The GtkMenuItem implementation of the #GtkBuildable interface supports adding a submenu by specifying “submenu” as the “type” attribute of a <child> element. An example of UI definition fragment with submenus: |[ <object class="GtkMenuItem"> <child type="submenu"> <object class="GtkMenu"/> </child> </object> ]| # CSS nodes |[<!-- language="plain" --> menuitem ├── <child> ╰── [arrow.right] ]| GtkMenuItem has a single CSS node with name menuitem. If the menuitem has a submenu, it gets another CSS node with name arrow, which has the .left or .right style class. Creates a new #GtkMenuItem. the newly created #GtkMenuItem Creates a new #GtkMenuItem whose child is a #GtkLabel. the newly created #GtkMenuItem the text for the label Creates a new #GtkMenuItem containing a label. The label will be created using gtk_label_new_with_mnemonic(), so underscores in @label indicate the mnemonic for the menu item. a new #GtkMenuItem The text of the button, with an underscore in front of the mnemonic character Emits the #GtkMenuItem::activate signal on the given item the menu item Emits the #GtkMenuItem::deselect signal on the given item. the menu item Sets @text on the @menu_item label The text in the @menu_item label. This is the internal string used by the label, and must not be modified. a #GtkMenuItem Emits the #GtkMenuItem::select signal on the given item. the menu item Sets @text on the @menu_item label a #GtkMenuItem the text you want to set Emits the #GtkMenuItem::toggle-size-allocate signal on the given item. the menu item. the allocation to use as signal data. Emits the #GtkMenuItem::toggle-size-request signal on the given item. the menu item the requisition to use as signal data. Emits the #GtkMenuItem::activate signal on the given item the menu item Emits the #GtkMenuItem::deselect signal on the given item. the menu item Retrieve the accelerator path that was previously set on @menu_item. See gtk_menu_item_set_accel_path() for details. the accelerator path corresponding to this menu item’s functionality, or %NULL if not set a valid #GtkMenuItem Sets @text on the @menu_item label The text in the @menu_item label. This is the internal string used by the label, and must not be modified. a #GtkMenuItem Returns whether the @menu_item reserves space for the submenu indicator, regardless if it has a submenu or not. %TRUE if @menu_item always reserves space for the submenu indicator a #GtkMenuItem Gets whether the menu item appears justified at the right side of the menu bar. See gtk_menu_item_set_right_justified() %TRUE if the menu item will appear at the far right if added to a menu bar. a #GtkMenuItem Gets the submenu underneath this menu item, if any. See gtk_menu_item_set_submenu(). submenu for this menu item, or %NULL if none a #GtkMenuItem Checks if an underline in the text indicates the next character should be used for the mnemonic accelerator key. %TRUE if an embedded underline in the label indicates the mnemonic accelerator key. a #GtkMenuItem Emits the #GtkMenuItem::select signal on the given item. the menu item Set the accelerator path on @menu_item, through which runtime changes of the menu item’s accelerator caused by the user can be identified and saved to persistent storage (see gtk_accel_map_save() on this). To set up a default accelerator for this menu item, call gtk_accel_map_add_entry() with the same @accel_path. See also gtk_accel_map_add_entry() on the specifics of accelerator paths, and gtk_menu_set_accel_path() for a more convenient variant of this function. This function is basically a convenience wrapper that handles calling gtk_widget_set_accel_path() with the appropriate accelerator group for the menu item. Note that you do need to set an accelerator on the parent menu with gtk_menu_set_accel_group() for this to work. Note that @accel_path string will be stored in a #GQuark. Therefore, if you pass a static string, you can save some memory by interning it first with g_intern_static_string(). a valid #GtkMenuItem accelerator path, corresponding to this menu item’s functionality, or %NULL to unset the current path. Sets @text on the @menu_item label a #GtkMenuItem the text you want to set Sets whether the @menu_item should reserve space for the submenu indicator, regardless if it actually has a submenu or not. There should be little need for applications to call this functions. a #GtkMenuItem the new value Sets whether the menu item appears justified at the right side of a menu bar. This was traditionally done for “Help” menu items, but is now considered a bad idea. (If the widget layout is reversed for a right-to-left language like Hebrew or Arabic, right-justified-menu-items appear at the left.) If you insist on using it, use gtk_widget_set_hexpand() and gtk_widget_set_halign(). a #GtkMenuItem. if %TRUE the menu item will appear at the far right if added to a menu bar Sets or replaces the menu item’s submenu, or removes it when a %NULL submenu is passed. a #GtkMenuItem the submenu, or %NULL If true, an underline in the text indicates the next character should be used for the mnemonic accelerator key. a #GtkMenuItem %TRUE if underlines in the text indicate mnemonics Emits the #GtkMenuItem::toggle-size-allocate signal on the given item. the menu item. the allocation to use as signal data. Emits the #GtkMenuItem::toggle-size-request signal on the given item. the menu item the requisition to use as signal data. Sets the accelerator path of the menu item, through which runtime changes of the menu item's accelerator caused by the user can be identified and saved to persistant storage. The text for the child label. Sets whether the menu item appears justified at the right side of a menu bar. The submenu attached to the menu item, or %NULL if it has none. %TRUE if underlines in the text indicate mnemonics. Emitted when the item is activated. Emitted when the item is activated, but also if the menu item has a submenu. For normal applications, the relevant signal is #GtkMenuItem::activate. The parent class. If %TRUE, then we should always hide the menu when the %GtkMenuItem is activated. Otherwise, it is up to the caller. the menu item the menu item the requisition to use as signal data. the menu item. the allocation to use as signal data. a #GtkMenuItem the text you want to set The text in the @menu_item label. This is the internal string used by the label, and must not be modified. a #GtkMenuItem the menu item the menu item A user function supplied when calling gtk_menu_popup() which controls the positioning of the menu when it is displayed. The function sets the @x and @y parameters to the coordinates where the menu is to be drawn. To make the menu appear on a different monitor than the mouse pointer, gtk_menu_set_monitor() must be called. a #GtkMenu. address of the #gint representing the horizontal position where the menu shall be drawn. address of the #gint representing the vertical position where the menu shall be drawn. This is an output parameter. This parameter controls how menus placed outside the monitor are handled. If this is set to %TRUE and part of the menu is outside the monitor then GTK+ pushes the window into the visible area, effectively modifying the popup position. Note that moving and possibly resizing the menu around will alter the scroll position to keep the menu items “in place”, i.e. at the same monitor position they would have been without resizing. In practice, this behavior is only useful for combobox popups or option menus and cannot be used to simply confine a menu to monitor boundaries. In that case, changing the scroll offset is not desirable. the data supplied by the user in the gtk_menu_popup() @data parameter. A #GtkMenuShell is the abstract base class used to derive the #GtkMenu and #GtkMenuBar subclasses. A #GtkMenuShell is a container of #GtkMenuItem objects arranged in a list which can be navigated, selected, and activated by the user to perform application functions. A #GtkMenuItem can have a submenu associated with it, allowing for nested hierarchical menus. # Terminology A menu item can be “selected”, this means that it is displayed in the prelight state, and if it has a submenu, that submenu will be popped up. A menu is “active” when it is visible onscreen and the user is selecting from it. A menubar is not active until the user clicks on one of its menuitems. When a menu is active, passing the mouse over a submenu will pop it up. There is also is a concept of the current menu and a current menu item. The current menu item is the selected menu item that is furthest down in the hierarchy. (Every active menu shell does not necessarily contain a selected menu item, but if it does, then the parent menu shell must also contain a selected menu item.) The current menu is the menu that contains the current menu item. It will always have a GTK grab and receive all key presses. Cancels the selection within the menu shell. a #GtkMenuShell Deactivates the menu shell. Typically this results in the menu shell being erased from the screen. a #GtkMenuShell Adds a new #GtkMenuItem to the menu shell’s item list at the position indicated by @position. a #GtkMenuShell The #GtkMenuItem to add The position in the item list where @child is added. Positions are numbered from 0 to n-1 Selects the menu item from the menu shell. a #GtkMenuShell The #GtkMenuItem to select Activates the menu item within the menu shell. a #GtkMenuShell the #GtkMenuItem to activate if %TRUE, force the deactivation of the menu shell after the menu item is activated Adds a new #GtkMenuItem to the end of the menu shell's item list. a #GtkMenuShell The #GtkMenuItem to add Establishes a binding between a #GtkMenuShell and a #GMenuModel. The contents of @shell are removed and then refilled with menu items according to @model. When @model changes, @shell is updated. Calling this function twice on @shell with different @model will cause the first binding to be replaced with a binding to the new model. If @model is %NULL then any previous binding is undone and all children are removed. @with_separators determines if toplevel items (eg: sections) have separators inserted between them. This is typically desired for menus but doesn’t make sense for menubars. If @action_namespace is non-%NULL then the effect is as if all actions mentioned in the @model have their names prefixed with the namespace, plus a dot. For example, if the action “quit” is mentioned and @action_namespace is “app” then the effective action name is “app.quit”. This function uses #GtkActionable to define the action name and target values on the created menu items. If you want to use an action group other than “app” and “win”, or if you want to use a #GtkMenuShell outside of a #GtkApplicationWindow, then you will need to attach your own action group to the widget hierarchy using gtk_widget_insert_action_group(). As an example, if you created a group with a “quit” action and inserted it with the name “mygroup” then you would use the action name “mygroup.quit” in your #GMenuModel. For most cases you are probably better off using gtk_menu_new_from_model() or gtk_menu_bar_new_from_model() or just directly passing the #GMenuModel to gtk_application_set_app_menu() or gtk_application_set_menubar(). a #GtkMenuShell the #GMenuModel to bind to or %NULL to remove binding the namespace for actions in @model %TRUE if toplevel items in @shell should have separators between them Cancels the selection within the menu shell. a #GtkMenuShell Deactivates the menu shell. Typically this results in the menu shell being erased from the screen. a #GtkMenuShell Deselects the currently selected item from the menu shell, if any. a #GtkMenuShell Gets the parent menu shell. The parent menu shell of a submenu is the #GtkMenu or #GtkMenuBar from which it was opened up. the parent #GtkMenuShell a #GtkMenuShell Gets the currently selected item. the currently selected item a #GtkMenuShell Returns %TRUE if the menu shell will take the keyboard focus on popup. %TRUE if the menu shell will take the keyboard focus on popup. a #GtkMenuShell Adds a new #GtkMenuItem to the menu shell’s item list at the position indicated by @position. a #GtkMenuShell The #GtkMenuItem to add The position in the item list where @child is added. Positions are numbered from 0 to n-1 Adds a new #GtkMenuItem to the beginning of the menu shell's item list. a #GtkMenuShell The #GtkMenuItem to add Select the first visible or selectable child of the menu shell; don’t select tearoff items unless the only item is a tearoff item. a #GtkMenuShell if %TRUE, search for the first selectable menu item, otherwise select nothing if the first item isn’t sensitive. This should be %FALSE if the menu is being popped up initially. Selects the menu item from the menu shell. a #GtkMenuShell The #GtkMenuItem to select If @take_focus is %TRUE (the default) the menu shell will take the keyboard focus so that it will receive all keyboard events which is needed to enable keyboard navigation in menus. Setting @take_focus to %FALSE is useful only for special applications like virtual keyboard implementations which should not take keyboard focus. The @take_focus state of a menu or menu bar is automatically propagated to submenus whenever a submenu is popped up, so you don’t have to worry about recursively setting it for your entire menu hierarchy. Only when programmatically picking a submenu and popping it up manually, the @take_focus property of the submenu needs to be set explicitly. Note that setting it to %FALSE has side-effects: If the focus is in some other app, it keeps the focus and keynav in the menu doesn’t work. Consequently, keynav on the menu will only work if the focus is on some toplevel owned by the onscreen keyboard. To avoid confusing the user, menus with @take_focus set to %FALSE should not display mnemonics or accelerators, since it cannot be guaranteed that they will work. See also gdk_keyboard_grab() a #GtkMenuShell %TRUE if the menu shell should take the keyboard focus on popup A boolean that determines whether the menu and its submenus grab the keyboard focus. See gtk_menu_shell_set_take_focus() and gtk_menu_shell_get_take_focus(). An action signal that activates the current menu item within the menu shell. if %TRUE, hide the menu after activating the menu item An action signal which cancels the selection within the menu shell. Causes the #GtkMenuShell::selection-done signal to be emitted. A keybinding signal which moves the focus in the given @direction. the direction to cycle in This signal is emitted when a menu shell is deactivated. The ::insert signal is emitted when a new #GtkMenuItem is added to a #GtkMenuShell. A separate signal is used instead of GtkContainer::add because of the need for an additional position parameter. The inverse of this signal is the GtkContainer::removed signal. the #GtkMenuItem that is being inserted the position at which the insert occurs An keybinding signal which moves the current menu item in the direction specified by @direction. the direction to move The ::move-selected signal is emitted to move the selection to another item. %TRUE to stop the signal emission, %FALSE to continue +1 to move to the next item, -1 to move to the previous This signal is emitted when a selection has been completed within a menu shell. a #GtkMenuShell a #GtkMenuShell a #GtkMenuShell The #GtkMenuItem to select a #GtkMenuShell The #GtkMenuItem to add The position in the item list where @child is added. Positions are numbered from 0 to n-1 A #GtkMenuToolButton is a #GtkToolItem that contains a button and a small additional button with an arrow. When clicked, the arrow button pops up a dropdown menu. Use gtk_menu_tool_button_new() to create a new #GtkMenuToolButton. # GtkMenuToolButton as GtkBuildable The GtkMenuToolButton implementation of the GtkBuildable interface supports adding a menu by specifying “menu” as the “type” attribute of a <child> element. An example for a UI definition fragment with menus: |[ <object class="GtkMenuToolButton"> <child type="menu"> <object class="GtkMenu"/> </child> </object> ]| Creates a new #GtkMenuToolButton using @icon_widget as icon and @label as label. the new #GtkMenuToolButton a widget that will be used as icon widget, or %NULL a string that will be used as label, or %NULL Creates a new #GtkMenuToolButton. The new #GtkMenuToolButton will contain an icon and label from the stock item indicated by @stock_id. Use gtk_menu_tool_button_new() instead. the new #GtkMenuToolButton the name of a stock item Gets the #GtkMenu associated with #GtkMenuToolButton. the #GtkMenu associated with #GtkMenuToolButton a #GtkMenuToolButton Sets the tooltip markup text to be used as tooltip for the arrow button which pops up the menu. See gtk_tool_item_set_tooltip_text() for setting a tooltip on the whole #GtkMenuToolButton. a #GtkMenuToolButton markup text to be used as tooltip text for button’s arrow button Sets the tooltip text to be used as tooltip for the arrow button which pops up the menu. See gtk_tool_item_set_tooltip_text() for setting a tooltip on the whole #GtkMenuToolButton. a #GtkMenuToolButton text to be used as tooltip text for button’s arrow button Sets the #GtkMenu that is popped up when the user clicks on the arrow. If @menu is NULL, the arrow button becomes insensitive. a #GtkMenuToolButton the #GtkMenu associated with #GtkMenuToolButton The ::show-menu signal is emitted before the menu is shown. It can be used to populate the menu on demand, using gtk_menu_tool_button_set_menu(). Note that even if you populate the menu dynamically in this way, you must set an empty menu on the #GtkMenuToolButton beforehand, since the arrow is made insensitive if the menu is not set. The parent class. #GtkMessageDialog presents a dialog with some message text. It’s simply a convenience widget; you could construct the equivalent of #GtkMessageDialog from #GtkDialog without too much effort, but #GtkMessageDialog saves typing. One difference from #GtkDialog is that #GtkMessageDialog sets the #GtkWindow:skip-taskbar-hint property to %TRUE, so that the dialog is hidden from the taskbar by default. The easiest way to do a modal message dialog is to use gtk_dialog_run(), though you can also pass in the %GTK_DIALOG_MODAL flag, gtk_dialog_run() automatically makes the dialog modal and waits for the user to respond to it. gtk_dialog_run() returns when any dialog button is clicked. An example for using a modal dialog: |[<!-- language="C" --> GtkDialogFlags flags = GTK_DIALOG_DESTROY_WITH_PARENT; dialog = gtk_message_dialog_new (parent_window, flags, GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE, "Error reading “%s”: %s", filename, g_strerror (errno)); gtk_dialog_run (GTK_DIALOG (dialog)); gtk_widget_destroy (dialog); ]| You might do a non-modal #GtkMessageDialog as follows: An example for a non-modal dialog: |[<!-- language="C" --> GtkDialogFlags flags = GTK_DIALOG_DESTROY_WITH_PARENT; dialog = gtk_message_dialog_new (parent_window, flags, GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE, "Error reading “%s”: %s", filename, g_strerror (errno)); // Destroy the dialog when the user responds to it // (e.g. clicks a button) g_signal_connect_swapped (dialog, "response", G_CALLBACK (gtk_widget_destroy), dialog); ]| # GtkMessageDialog as GtkBuildable The GtkMessageDialog implementation of the GtkBuildable interface exposes the message area as an internal child with the name “message_area”. Creates a new message dialog, which is a simple dialog with some text the user may want to see. When the user clicks a button a “response” signal is emitted with response IDs from #GtkResponseType. See #GtkDialog for more details. a new #GtkMessageDialog transient parent, or %NULL for none flags type of message set of buttons to use printf()-style format string, or %NULL arguments for @message_format Creates a new message dialog, which is a simple dialog with some text that is marked up with the [Pango text markup language][PangoMarkupFormat]. When the user clicks a button a “response” signal is emitted with response IDs from #GtkResponseType. See #GtkDialog for more details. Special XML characters in the printf() arguments passed to this function will automatically be escaped as necessary. (See g_markup_printf_escaped() for how this is implemented.) Usually this is what you want, but if you have an existing Pango markup string that you want to use literally as the label, then you need to use gtk_message_dialog_set_markup() instead, since you can’t pass the markup string either as the format (it might contain “%” characters) or as a string argument. |[<!-- language="C" --> GtkWidget *dialog; GtkDialogFlags flags = GTK_DIALOG_DESTROY_WITH_PARENT; dialog = gtk_message_dialog_new (parent_window, flags, GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE, NULL); gtk_message_dialog_set_markup (GTK_MESSAGE_DIALOG (dialog), markup); ]| a new #GtkMessageDialog transient parent, or %NULL for none flags type of message set of buttons to use printf()-style format string, or %NULL arguments for @message_format Sets the secondary text of the message dialog to be @message_format (with printf()-style), which is marked up with the [Pango text markup language][PangoMarkupFormat]. Due to an oversight, this function does not escape special XML characters like gtk_message_dialog_new_with_markup() does. Thus, if the arguments may contain special XML characters, you should use g_markup_printf_escaped() to escape it. |[<!-- language="C" --> gchar *msg; msg = g_markup_printf_escaped (message_format, ...); gtk_message_dialog_format_secondary_markup (message_dialog, "%s", msg); g_free (msg); ]| a #GtkMessageDialog printf()-style markup string (see [Pango markup format][PangoMarkupFormat]), or %NULL arguments for @message_format Sets the secondary text of the message dialog to be @message_format (with printf()-style). a #GtkMessageDialog printf()-style format string, or %NULL arguments for @message_format Gets the dialog’s image. Use #GtkDialog for dialogs with images the dialog’s image a #GtkMessageDialog Returns the message area of the dialog. This is the box where the dialog’s primary and secondary labels are packed. You can add your own extra content to that box and it will appear below those labels. See gtk_dialog_get_content_area() for the corresponding function in the parent #GtkDialog. A #GtkBox corresponding to the “message area” in the @message_dialog. a #GtkMessageDialog Sets the dialog’s image to @image. Use #GtkDialog to create dialogs with images a #GtkMessageDialog the image Sets the text of the message dialog to be @str, which is marked up with the [Pango text markup language][PangoMarkupFormat]. a #GtkMessageDialog markup string (see [Pango markup format][PangoMarkupFormat]) The image for this dialog. Use #GtkDialog to create dialogs with images The #GtkBox that corresponds to the message area of this dialog. See gtk_message_dialog_get_message_area() for a detailed description of this area. The type of the message. The secondary text of the message dialog. %TRUE if the secondary text of the dialog includes Pango markup. See pango_parse_markup(). The primary text of the message dialog. If the dialog has a secondary text, this will appear as the title. %TRUE if the primary text of the dialog includes Pango markup. See pango_parse_markup(). The type of message being displayed in the dialog. Informational message Non-fatal warning message Question requiring a choice Fatal error message None of the above The #GtkMisc widget is an abstract widget which is not useful itself, but is used to derive subclasses which have alignment and padding attributes. The horizontal and vertical padding attributes allows extra space to be added around the widget. The horizontal and vertical alignment attributes enable the widget to be positioned within its allocated area. Note that if the widget is added to a container in such a way that it expands automatically to fill its allocated area, the alignment settings will not alter the widget's position. Note that the desired effect can in most cases be achieved by using the #GtkWidget:halign, #GtkWidget:valign and #GtkWidget:margin properties on the child widget, so GtkMisc should not be used in new code. To reflect this fact, all #GtkMisc API has been deprecated. Gets the X and Y alignment of the widget within its allocation. See gtk_misc_set_alignment(). Use #GtkWidget alignment and margin properties. a #GtkMisc location to store X alignment of @misc, or %NULL location to store Y alignment of @misc, or %NULL Gets the padding in the X and Y directions of the widget. See gtk_misc_set_padding(). Use #GtkWidget alignment and margin properties. a #GtkMisc location to store padding in the X direction, or %NULL location to store padding in the Y direction, or %NULL Sets the alignment of the widget. Use #GtkWidget's alignment (#GtkWidget:halign and #GtkWidget:valign) and margin properties or #GtkLabel's #GtkLabel:xalign and #GtkLabel:yalign properties. a #GtkMisc. the horizontal alignment, from 0 (left) to 1 (right). the vertical alignment, from 0 (top) to 1 (bottom). Sets the amount of space to add around the widget. Use #GtkWidget alignment and margin properties. a #GtkMisc. the amount of space to add on the left and right of the widget, in pixels. the amount of space to add on the top and bottom of the widget, in pixels. The horizontal alignment. A value of 0.0 means left alignment (or right on RTL locales); a value of 1.0 means right alignment (or left on RTL locales). Use gtk_widget_set_halign() instead. If you are using #GtkLabel, use #GtkLabel:xalign instead. The amount of space to add on the left and right of the widget, in pixels. Use gtk_widget_set_margin_start() and gtk_widget_set_margin_end() instead The vertical alignment. A value of 0.0 means top alignment; a value of 1.0 means bottom alignment. Use gtk_widget_set_valign() instead. If you are using #GtkLabel, use #GtkLabel:yalign instead. The amount of space to add on the top and bottom of the widget, in pixels. Use gtk_widget_set_margin_top() and gtk_widget_set_margin_bottom() instead GtkModelButton is a button class that can use a #GAction as its model. In contrast to #GtkToggleButton or #GtkRadioButton, which can also be backed by a #GAction via the #GtkActionable:action-name property, GtkModelButton will adapt its appearance according to the kind of action it is backed by, and appear either as a plain, check or radio button. Model buttons are used when popovers from a menu model with gtk_popover_new_from_model(); they can also be used manually in a #GtkPopoverMenu. When the action is specified via the #GtkActionable:action-name and #GtkActionable:action-target properties, the role of the button (i.e. whether it is a plain, check or radio button) is determined by the type of the action and doesn't have to be explicitly specified with the #GtkModelButton:role property. The content of the button is specified by the #GtkModelButton:text and #GtkModelButton:icon properties. The appearance of model buttons can be influenced with the #GtkModelButton:centered and #GtkModelButton:iconic properties. Model buttons have built-in support for submenus in #GtkPopoverMenu. To make a GtkModelButton that opens a submenu when activated, set the #GtkModelButton:menu-name property. To make a button that goes back to the parent menu, you should set the #GtkModelButton:inverted property to place the submenu indicator at the opposite side. # Example |[ <object class="GtkPopoverMenu"> <child> <object class="GtkBox"> <property name="visible">True</property> <property name="margin">10</property> <child> <object class="GtkModelButton"> <property name="visible">True</property> <property name="action-name">view.cut</property> <property name="text" translatable="yes">Cut</property> </object> </child> <child> <object class="GtkModelButton"> <property name="visible">True</property> <property name="action-name">view.copy</property> <property name="text" translatable="yes">Copy</property> </object> </child> <child> <object class="GtkModelButton"> <property name="visible">True</property> <property name="action-name">view.paste</property> <property name="text" translatable="yes">Paste</property> </object> </child> </object> </child> </object> ]| # CSS nodes |[<!-- language="plain" --> modelbutton ├── <child> ╰── check ]| |[<!-- language="plain" --> modelbutton ├── <child> ╰── radio ]| |[<!-- language="plain" --> modelbutton ├── <child> ╰── arrow ]| GtkModelButton has a main CSS node with name modelbutton, and a subnode, which will have the name check, radio or arrow, depending on the role of the button and whether it has a menu name set. The subnode is positioned before or after the content nodes and gets the .left or .right style class, depending on where it is located. |[<!-- language="plain" --> button.model ├── <child> ╰── check ]| Iconic model buttons (see #GtkModelButton:iconic) change the name of their main node to button and add a .model style class to it. The indicator subnode is invisible in this case. Creates a new GtkModelButton. the newly created #GtkModelButton widget The state of the button. This is reflecting the state of the associated #GAction. Whether to render the button contents centered instead of left-aligned. This property should be set for title-like items. A #GIcon that will be used if iconic appearance for the button is desired. If this property is set, the button will show an icon if one is set. If no icon is set, the text will be used. This is typically used for horizontal sections of linked buttons. Whether to show the submenu indicator at the opposite side than normal. This property should be set for model buttons that 'go back' to a parent menu. The name of a submenu to open when the button is activated. If this is set, the button should not have an action associated with it. Specifies whether the button is a plain, check or radio button. When #GtkActionable:action-name is set, the role will be determined from the action and does not have to be set explicitly. The label for the button. If %TRUE, XML tags in the text of the button are interpreted as by pango_parse_markup() to format the enclosed spans of text. If %FALSE, the text will be displayed verbatim. A multihead-aware GTK+ module may have a gtk_module_display_init() function with this prototype. GTK+ calls this function for each opened display. an open #GdkDisplay Each GTK+ module must have a function gtk_module_init() with this prototype. This function is called after loading the module. GTK+ always passes %NULL for this argument GTK+ always passes %NULL for this argument This should not be accessed directly. Use the accessor functions below. Creates a new #GtkMountOperation a new #GtkMountOperation transient parent of the window, or %NULL Gets the transient parent used by the #GtkMountOperation the transient parent for windows shown by @op a #GtkMountOperation Gets the screen on which windows of the #GtkMountOperation will be shown. the screen on which windows of @op are shown a #GtkMountOperation Returns whether the #GtkMountOperation is currently displaying a window. %TRUE if @op is currently displaying a window a #GtkMountOperation Sets the transient parent for windows shown by the #GtkMountOperation. a #GtkMountOperation transient parent of the window, or %NULL Sets the screen to show windows of the #GtkMountOperation on. a #GtkMountOperation a #GdkScreen The parent class. Move forward or back by graphemes Move left or right by graphemes Move forward or back by words Move up or down lines (wrapped lines) Move to either end of a line Move up or down paragraphs (newline-ended lines) Move to either end of a paragraph Move by pages Move to ends of the buffer Move horizontally by pages Native dialogs are platform dialogs that don't use #GtkDialog or #GtkWindow. They are used in order to integrate better with a platform, by looking the same as other native applications and supporting platform specific features. The #GtkDialog functions cannot be used on such objects, but we need a similar API in order to drive them. The #GtkNativeDialog object is an API that allows you to do this. It allows you to set various common properties on the dialog, as well as show and hide it and get a #GtkNativeDialog::response signal when the user finished with the dialog. There is also a gtk_native_dialog_run() helper that makes it easy to run any native dialog in a modal way with a recursive mainloop, similar to gtk_dialog_run(). Hides the dialog if it is visilbe, aborting any interaction. Once this is called the #GtkNativeDialog::response signal will not be emitted until after the next call to gtk_native_dialog_show(). If the dialog is not visible this does nothing. a #GtkNativeDialog Shows the dialog on the display, allowing the user to interact with it. When the user accepts the state of the dialog the dialog will be automatically hidden and the #GtkNativeDialog::response signal will be emitted. Multiple calls while the dialog is visible will be ignored. a #GtkNativeDialog Destroys a dialog. When a dialog is destroyed, it will break any references it holds to other objects. If it is visible it will be hidden and any underlying window system resources will be destroyed. Note that this does not release any reference to the object (as opposed to destroying a GtkWindow) because there is no reference from the windowing system to the #GtkNativeDialog. a #GtkNativeDialog Returns whether the dialog is modal. See gtk_native_dialog_set_modal(). %TRUE if the dialog is set to be modal a #GtkNativeDialog Gets the title of the #GtkNativeDialog. the title of the dialog, or %NULL if none has been set explicitly. The returned string is owned by the widget and must not be modified or freed. a #GtkNativeDialog Fetches the transient parent for this window. See gtk_native_dialog_set_transient_for(). the transient parent for this window, or %NULL if no transient parent has been set. a #GtkNativeDialog Determines whether the dialog is visible. %TRUE if the dialog is visible a #GtkNativeDialog Hides the dialog if it is visilbe, aborting any interaction. Once this is called the #GtkNativeDialog::response signal will not be emitted until after the next call to gtk_native_dialog_show(). If the dialog is not visible this does nothing. a #GtkNativeDialog Blocks in a recursive main loop until @self emits the #GtkNativeDialog::response signal. It then returns the response ID from the ::response signal emission. Before entering the recursive main loop, gtk_native_dialog_run() calls gtk_native_dialog_show() on the dialog for you. After gtk_native_dialog_run() returns, then dialog will be hidden. Typical usage of this function might be: |[<!-- language="C" --> gint result = gtk_native_dialog_run (GTK_NATIVE_DIALOG (dialog)); switch (result) { case GTK_RESPONSE_ACCEPT: do_application_specific_something (); break; default: do_nothing_since_dialog_was_cancelled (); break; } g_object_unref (dialog); ]| Note that even though the recursive main loop gives the effect of a modal dialog (it prevents the user from interacting with other windows in the same window group while the dialog is run), callbacks such as timeouts, IO channel watches, DND drops, etc, will be triggered during a gtk_nautilus_dialog_run() call. response ID a #GtkNativeDialog Sets a dialog modal or non-modal. Modal dialogs prevent interaction with other windows in the same application. To keep modal dialogs on top of main application windows, use gtk_native_dialog_set_transient_for() to make the dialog transient for the parent; most [window managers][gtk-X11-arch] will then disallow lowering the dialog below the parent. a #GtkNativeDialog whether the window is modal Sets the title of the #GtkNativeDialog. a #GtkNativeDialog title of the dialog Dialog windows should be set transient for the main application window they were spawned from. This allows [window managers][gtk-X11-arch] to e.g. keep the dialog on top of the main window, or center the dialog over the main window. Passing %NULL for @parent unsets the current transient window. a #GtkNativeDialog parent window, or %NULL Shows the dialog on the display, allowing the user to interact with it. When the user accepts the state of the dialog the dialog will be automatically hidden and the #GtkNativeDialog::response signal will be emitted. Multiple calls while the dialog is visible will be ignored. a #GtkNativeDialog Whether the window should be modal with respect to its transient parent. The title of the dialog window The transient parent of the dialog, or %NULL for none. Whether the window is currenlty visible. Emitted when the user responds to the dialog. When this is called the dialog has been hidden. If you call gtk_native_dialog_hide() before the user responds to the dialog this signal will not be emitted. the response ID a #GtkNativeDialog a #GtkNativeDialog The #GtkNotebook widget is a #GtkContainer whose children are pages that can be switched between using tab labels along one edge. There are many configuration options for GtkNotebook. Among other things, you can choose on which edge the tabs appear (see gtk_notebook_set_tab_pos()), whether, if there are too many tabs to fit the notebook should be made bigger or scrolling arrows added (see gtk_notebook_set_scrollable()), and whether there will be a popup menu allowing the users to switch pages. (see gtk_notebook_popup_enable(), gtk_notebook_popup_disable()) # GtkNotebook as GtkBuildable The GtkNotebook implementation of the #GtkBuildable interface supports placing children into tabs by specifying “tab” as the “type” attribute of a <child> element. Note that the content of the tab must be created before the tab can be filled. A tab child can be specified without specifying a <child> type attribute. To add a child widget in the notebooks action area, specify "action-start" or “action-end” as the “type” attribute of the <child> element. An example of a UI definition fragment with GtkNotebook: |[ <object class="GtkNotebook"> <child> <object class="GtkLabel" id="notebook-content"> <property name="label">Content</property> </object> </child> <child type="tab"> <object class="GtkLabel" id="notebook-tab"> <property name="label">Tab</property> </object> </child> </object> ]| # CSS nodes |[<!-- language="plain" --> notebook ├── header.top │ ├── [<action widget>] │ ├── tabs │ │ ├── [arrow] │ │ ├── tab │ │ │ ╰── <tab label> ┊ ┊ ┊ │ │ ├── tab[.reorderable-page] │ │ │ ╰── <tab label> │ │ ╰── [arrow] │ ╰── [<action widget>] │ ╰── stack ├── <child> ┊ ╰── <child> ]| GtkNotebook has a main CSS node with name notebook, a subnode with name header and below that a subnode with name tabs which contains one subnode per tab with name tab. If action widgets are present, their CSS nodes are placed next to the tabs node. If the notebook is scrollable, CSS nodes with name arrow are placed as first and last child of the tabs node. The main node gets the .frame style class when the notebook has a border (see gtk_notebook_set_show_border()). The header node gets one of the style class .top, .bottom, .left or .right, depending on where the tabs are placed. For reorderable pages, the tab node gets the .reorderable-page class. A tab node gets the .dnd style class while it is moved with drag-and-drop. The nodes are always arranged from left-to-right, regarldess of text direction. Creates a new #GtkNotebook widget with no pages. the newly created #GtkNotebook Appends a page to @notebook. the index (starting from 0) of the appended page in the notebook, or -1 if function fails a #GtkNotebook the #GtkWidget to use as the contents of the page the #GtkWidget to be used as the label for the page, or %NULL to use the default label, “page N” Appends a page to @notebook, specifying the widget to use as the label in the popup menu. the index (starting from 0) of the appended page in the notebook, or -1 if function fails a #GtkNotebook the #GtkWidget to use as the contents of the page the #GtkWidget to be used as the label for the page, or %NULL to use the default label, “page N” the widget to use as a label for the page-switch menu, if that is enabled. If %NULL, and @tab_label is a #GtkLabel or %NULL, then the menu label will be a newly created label with the same text as @tab_label; if @tab_label is not a #GtkLabel, @menu_label must be specified if the page-switch menu is to be used. Removes the child from the notebook. This function is very similar to gtk_container_remove(), but additionally informs the notebook that the removal is happening as part of a tab DND operation, which should not be cancelled. a #GtkNotebook a child Gets one of the action widgets. See gtk_notebook_set_action_widget(). The action widget with the given @pack_type or %NULL when this action widget has not been set a #GtkNotebook pack type of the action widget to receive Returns the page number of the current page. the index (starting from 0) of the current page in the notebook. If the notebook has no pages, then -1 will be returned. a #GtkNotebook Gets the current group name for @notebook. the group name, or %NULL if none is set a #GtkNotebook Retrieves the menu label widget of the page containing @child. the menu label, or %NULL if the notebook page does not have a menu label other than the default (the tab label). a #GtkNotebook a widget contained in a page of @notebook Retrieves the text of the menu label for the page containing @child. the text of the tab label, or %NULL if the widget does not have a menu label other than the default menu label, or the menu label widget is not a #GtkLabel. The string is owned by the widget and must not be freed. a #GtkNotebook the child widget of a page of the notebook. Gets the number of pages in a notebook. the number of pages in the notebook a #GtkNotebook Returns the child widget contained in page number @page_num. the child widget, or %NULL if @page_num is out of bounds a #GtkNotebook the index of a page in the notebook, or -1 to get the last page Returns whether the tab label area has arrows for scrolling. See gtk_notebook_set_scrollable(). %TRUE if arrows for scrolling are present a #GtkNotebook Returns whether a bevel will be drawn around the notebook pages. See gtk_notebook_set_show_border(). %TRUE if the bevel is drawn a #GtkNotebook Returns whether the tabs of the notebook are shown. See gtk_notebook_set_show_tabs(). %TRUE if the tabs are shown a #GtkNotebook Returns whether the tab contents can be detached from @notebook. %TRUE if the tab is detachable. a #GtkNotebook a child #GtkWidget Returns the horizontal width of a tab border. this function returns zero horizontal width of a tab border a #GtkNotebook Returns the tab label widget for the page @child. %NULL is returned if @child is not in @notebook or if no tab label has specifically been set for @child. the tab label a #GtkNotebook the page Retrieves the text of the tab label for the page containing @child. the text of the tab label, or %NULL if the tab label widget is not a #GtkLabel. The string is owned by the widget and must not be freed. a #GtkNotebook a widget contained in a page of @notebook Gets the edge at which the tabs for switching pages in the notebook are drawn. the edge at which the tabs are drawn a #GtkNotebook Gets whether the tab can be reordered via drag and drop or not. %TRUE if the tab is reorderable. a #GtkNotebook a child #GtkWidget Returns the vertical width of a tab border. this function returns zero vertical width of a tab border a #GtkNotebook Insert a page into @notebook at the given position. the index (starting from 0) of the inserted page in the notebook, or -1 if function fails a #GtkNotebook the #GtkWidget to use as the contents of the page the #GtkWidget to be used as the label for the page, or %NULL to use the default label, “page N” the index (starting at 0) at which to insert the page, or -1 to append the page after all other pages Insert a page into @notebook at the given position, specifying the widget to use as the label in the popup menu. the index (starting from 0) of the inserted page in the notebook a #GtkNotebook the #GtkWidget to use as the contents of the page the #GtkWidget to be used as the label for the page, or %NULL to use the default label, “page N” the widget to use as a label for the page-switch menu, if that is enabled. If %NULL, and @tab_label is a #GtkLabel or %NULL, then the menu label will be a newly created label with the same text as @tab_label; if @tab_label is not a #GtkLabel, @menu_label must be specified if the page-switch menu is to be used. the index (starting at 0) at which to insert the page, or -1 to append the page after all other pages. Switches to the next page. Nothing happens if the current page is the last page. a #GtkNotebook Finds the index of the page which contains the given child widget. the index of the page containing @child, or -1 if @child is not in the notebook a #GtkNotebook a #GtkWidget Disables the popup menu. a #GtkNotebook Enables the popup menu: if the user clicks with the right mouse button on the tab labels, a menu with all the pages will be popped up. a #GtkNotebook Prepends a page to @notebook. the index (starting from 0) of the prepended page in the notebook, or -1 if function fails a #GtkNotebook the #GtkWidget to use as the contents of the page the #GtkWidget to be used as the label for the page, or %NULL to use the default label, “page N” Prepends a page to @notebook, specifying the widget to use as the label in the popup menu. the index (starting from 0) of the prepended page in the notebook, or -1 if function fails a #GtkNotebook the #GtkWidget to use as the contents of the page the #GtkWidget to be used as the label for the page, or %NULL to use the default label, “page N” the widget to use as a label for the page-switch menu, if that is enabled. If %NULL, and @tab_label is a #GtkLabel or %NULL, then the menu label will be a newly created label with the same text as @tab_label; if @tab_label is not a #GtkLabel, @menu_label must be specified if the page-switch menu is to be used. Switches to the previous page. Nothing happens if the current page is the first page. a #GtkNotebook Removes a page from the notebook given its index in the notebook. a #GtkNotebook the index of a notebook page, starting from 0. If -1, the last page will be removed. Reorders the page containing @child, so that it appears in position @position. If @position is greater than or equal to the number of children in the list or negative, @child will be moved to the end of the list. a #GtkNotebook the child to move the new position, or -1 to move to the end Sets @widget as one of the action widgets. Depending on the pack type the widget will be placed before or after the tabs. You can use a #GtkBox if you need to pack more than one widget on the same side. Note that action widgets are “internal” children of the notebook and thus not included in the list returned from gtk_container_foreach(). a #GtkNotebook a #GtkWidget pack type of the action widget Switches to the page number @page_num. Note that due to historical reasons, GtkNotebook refuses to switch to a page unless the child widget is visible. Therefore, it is recommended to show child widgets before adding them to a notebook. a #GtkNotebook index of the page to switch to, starting from 0. If negative, the last page will be used. If greater than the number of pages in the notebook, nothing will be done. Sets a group name for @notebook. Notebooks with the same name will be able to exchange tabs via drag and drop. A notebook with a %NULL group name will not be able to exchange tabs with any other notebook. a #GtkNotebook the name of the notebook group, or %NULL to unset it Changes the menu label for the page containing @child. a #GtkNotebook the child widget the menu label, or %NULL for default Creates a new label and sets it as the menu label of @child. a #GtkNotebook the child widget the label text Sets whether the tab label area will have arrows for scrolling if there are too many tabs to fit in the area. a #GtkNotebook %TRUE if scroll arrows should be added Sets whether a bevel will be drawn around the notebook pages. This only has a visual effect when the tabs are not shown. See gtk_notebook_set_show_tabs(). a #GtkNotebook %TRUE if a bevel should be drawn around the notebook Sets whether to show the tabs for the notebook or not. a #GtkNotebook %TRUE if the tabs should be shown Sets whether the tab can be detached from @notebook to another notebook or widget. Note that 2 notebooks must share a common group identificator (see gtk_notebook_set_group_name()) to allow automatic tabs interchange between them. If you want a widget to interact with a notebook through DnD (i.e.: accept dragged tabs from it) it must be set as a drop destination and accept the target “GTK_NOTEBOOK_TAB”. The notebook will fill the selection with a GtkWidget** pointing to the child widget that corresponds to the dropped tab. Note that you should use gtk_notebook_detach_tab() instead of gtk_container_remove() if you want to remove the tab from the source notebook as part of accepting a drop. Otherwise, the source notebook will think that the dragged tab was removed from underneath the ongoing drag operation, and will initiate a drag cancel animation. |[<!-- language="C" --> static void on_drag_data_received (GtkWidget *widget, GdkDragContext *context, gint x, gint y, GtkSelectionData *data, guint info, guint time, gpointer user_data) { GtkWidget *notebook; GtkWidget **child; notebook = gtk_drag_get_source_widget (context); child = (void*) gtk_selection_data_get_data (data); // process_widget (*child); gtk_notebook_detach_tab (GTK_NOTEBOOK (notebook), *child); } ]| If you want a notebook to accept drags from other widgets, you will have to set your own DnD code to do it. a #GtkNotebook a child #GtkWidget whether the tab is detachable or not Changes the tab label for @child. If %NULL is specified for @tab_label, then the page will have the label “page N”. a #GtkNotebook the page the tab label widget to use, or %NULL for default tab label Creates a new label and sets it as the tab label for the page containing @child. a #GtkNotebook the page the label text Sets the edge at which the tabs for switching pages in the notebook are drawn. a #GtkNotebook. the edge to draw the tabs at Sets whether the notebook tab can be reordered via drag and drop or not. a #GtkNotebook a child #GtkWidget whether the tab is reorderable or not Group name for tab drag and drop. The ::create-window signal is emitted when a detachable tab is dropped on the root window. A handler for this signal can create a window containing a notebook where the tab will be attached. It is also responsible for moving/resizing the window and adding the necessary properties to the notebook (e.g. the #GtkNotebook:group-name ). a #GtkNotebook that @page should be added to, or %NULL. the tab of @notebook that is being detached the X coordinate where the drop happens the Y coordinate where the drop happens the ::page-added signal is emitted in the notebook right after a page is added to the notebook. the child #GtkWidget affected the new page number for @child the ::page-removed signal is emitted in the notebook right after a page is removed from the notebook. the child #GtkWidget affected the @child page number the ::page-reordered signal is emitted in the notebook right after a page has been reordered. the child #GtkWidget affected the new page number for @child Emitted when the user or a function changes the current page. the new current page the index of the page Used to determine the layout of pages on a sheet when printing multiple pages per sheet. ![](layout-lrtb.png) ![](layout-lrbt.png) ![](layout-rltb.png) ![](layout-rlbt.png) ![](layout-tblr.png) ![](layout-tbrl.png) ![](layout-btlr.png) ![](layout-btrl.png) GtkNumerableIcon is a subclass of #GEmblemedIcon that can show a number or short string as an emblem. The number can be overlayed on top of another emblem, if desired. It supports theming by taking font and color information from a provided #GtkStyleContext; see gtk_numerable_icon_set_style_context(). Typical numerable icons: ![](numerableicon.png) ![](numerableicon2.png) Creates a new unthemed #GtkNumerableIcon. a new #GIcon a #GIcon to overlay on Creates a new #GtkNumerableIcon which will themed according to the passed #GtkStyleContext. This is a convenience constructor that calls gtk_numerable_icon_set_style_context() internally. a new #GIcon a #GIcon to overlay on a #GtkStyleContext Returns the #GIcon that was set as the base background image, or %NULL if there’s none. The caller of this function does not own a reference to the returned #GIcon. a #GIcon, or %NULL a #GtkNumerableIcon Returns the icon name used as the base background image, or %NULL if there’s none. an icon name, or %NULL a #GtkNumerableIcon Returns the value currently displayed by @self. the currently displayed value a #GtkNumerableIcon Returns the currently displayed label of the icon, or %NULL. the currently displayed label a #GtkNumerableIcon Returns the #GtkStyleContext used by the icon for theming, or %NULL if there’s none. a #GtkStyleContext, or %NULL. This object is internal to GTK+ and should not be unreffed. Use g_object_ref() if you want to keep it around a #GtkNumerableIcon Updates the icon to use @icon as the base background image. If @icon is %NULL, @self will go back using style information or default theming for its background image. If this method is called and an icon name was already set as background for the icon, @icon will be used, i.e. the last method called between gtk_numerable_icon_set_background_gicon() and gtk_numerable_icon_set_background_icon_name() has always priority. a #GtkNumerableIcon a #GIcon, or %NULL Updates the icon to use the icon named @icon_name from the current icon theme as the base background image. If @icon_name is %NULL, @self will go back using style information or default theming for its background image. If this method is called and a #GIcon was already set as background for the icon, @icon_name will be used, i.e. the last method called between gtk_numerable_icon_set_background_icon_name() and gtk_numerable_icon_set_background_gicon() has always priority. a #GtkNumerableIcon an icon name, or %NULL Sets the currently displayed value of @self to @count. The numeric value is always clamped to make it two digits, i.e. between -99 and 99. Setting a count of zero removes the emblem. If this method is called, and a label was already set on the icon, it will automatically be reset to %NULL before rendering the number, i.e. the last method called between gtk_numerable_icon_set_count() and gtk_numerable_icon_set_label() has always priority. a #GtkNumerableIcon a number between -99 and 99 Sets the currently displayed value of @self to the string in @label. Setting an empty label removes the emblem. Note that this is meant for displaying short labels, such as roman numbers, or single letters. For roman numbers, consider using the Unicode characters U+2160 - U+217F. Strings longer than two characters will likely not be rendered very well. If this method is called, and a number was already set on the icon, it will automatically be reset to zero before rendering the label, i.e. the last method called between gtk_numerable_icon_set_label() and gtk_numerable_icon_set_count() has always priority. a #GtkNumerableIcon a short label, or %NULL Updates the icon to fetch theme information from the given #GtkStyleContext. a #GtkNumerableIcon a #GtkStyleContext GtkOffscreenWindow is strictly intended to be used for obtaining snapshots of widgets that are not part of a normal widget hierarchy. Since #GtkOffscreenWindow is a toplevel widget you cannot obtain snapshots of a full window with it since you cannot pack a toplevel widget in another toplevel. The idea is to take a widget and manually set the state of it, add it to a GtkOffscreenWindow and then retrieve the snapshot as a #cairo_surface_t or #GdkPixbuf. GtkOffscreenWindow derives from #GtkWindow only as an implementation detail. Applications should not use any API specific to #GtkWindow to operate on this object. It should be treated as a #GtkBin that has no parent widget. When contained offscreen widgets are redrawn, GtkOffscreenWindow will emit a #GtkWidget::damage-event signal. Creates a toplevel container widget that is used to retrieve snapshots of widgets without showing them on the screen. A pointer to a #GtkWidget Retrieves a snapshot of the contained widget in the form of a #GdkPixbuf. This is a new pixbuf with a reference count of 1, and the application should unreference it once it is no longer needed. A #GdkPixbuf pointer, or %NULL. the #GtkOffscreenWindow contained widget. Retrieves a snapshot of the contained widget in the form of a #cairo_surface_t. If you need to keep this around over window resizes then you should add a reference to it. A #cairo_surface_t pointer to the offscreen surface, or %NULL. the #GtkOffscreenWindow contained widget. The parent class. The #GtkOrientable interface is implemented by all widgets that can be oriented horizontally or vertically. Historically, such widgets have been realized as subclasses of a common base class (e.g #GtkBox/#GtkHBox/#GtkVBox or #GtkScale/#GtkHScale/#GtkVScale). #GtkOrientable is more flexible in that it allows the orientation to be changed at runtime, allowing the widgets to “flip”. #GtkOrientable was introduced in GTK+ 2.16. Retrieves the orientation of the @orientable. the orientation of the @orientable. a #GtkOrientable Sets the orientation of the @orientable. a #GtkOrientable the orientable’s new orientation. The orientation of the orientable. Represents the orientation of widgets and other objects which can be switched between horizontal and vertical orientation on the fly, like #GtkToolbar or #GtkGesturePan. The element is in horizontal orientation. The element is in vertical orientation. GtkOverlay is a container which contains a single main child, on top of which it can place “overlay” widgets. The position of each overlay widget is determined by its #GtkWidget:halign and #GtkWidget:valign properties. E.g. a widget with both alignments set to %GTK_ALIGN_START will be placed at the top left corner of the GtkOverlay container, whereas an overlay with halign set to %GTK_ALIGN_CENTER and valign set to %GTK_ALIGN_END will be placed a the bottom edge of the GtkOverlay, horizontally centered. The position can be adjusted by setting the margin properties of the child to non-zero values. More complicated placement of overlays is possible by connecting to the #GtkOverlay::get-child-position signal. An overlay’s minimum and natural sizes are those of its main child. The sizes of overlay children are not considered when measuring these preferred sizes. # GtkOverlay as GtkBuildable The GtkOverlay implementation of the GtkBuildable interface supports placing a child as an overlay by specifying “overlay” as the “type” attribute of a `<child>` element. # CSS nodes GtkOverlay has a single CSS node with the name “overlay”. Overlay children whose alignments cause them to be positioned at an edge get the style classes “.left”, “.right”, “.top”, and/or “.bottom” according to their position. Creates a new #GtkOverlay. a new #GtkOverlay object. Adds @widget to @overlay. The widget will be stacked on top of the main widget added with gtk_container_add(). The position at which @widget is placed is determined from its #GtkWidget:halign and #GtkWidget:valign properties. a #GtkOverlay a #GtkWidget to be added to the container Convenience function to get the value of the #GtkOverlay:pass-through child property for @widget. whether the widget is a pass through child. a #GtkOverlay an overlay child of #GtkOverlay Moves @child to a new @index in the list of @overlay children. The list contains overlays in the order that these were added to @overlay by default. See also #GtkOverlay:index. A widget’s index in the @overlay children list determines which order the children are drawn if they overlap. The first child is drawn at the bottom. It also affects the default focus chain order. a #GtkOverlay the overlaid #GtkWidget to move the new index for @child in the list of overlay children of @overlay, starting from 0. If negative, indicates the end of the list Convenience function to set the value of the #GtkOverlay:pass-through child property for @widget. a #GtkOverlay an overlay child of #GtkOverlay whether the child should pass the input through The ::get-child-position signal is emitted to determine the position and size of any overlay child widgets. A handler for this signal should fill @allocation with the desired position and size for @widget, relative to the 'main' child of @overlay. The default handler for this signal uses the @widget's halign and valign properties to determine the position and gives the widget its natural size (except that an alignment of %GTK_ALIGN_FILL will cause the overlay to be full-width/height). If the main child is a #GtkScrolledWindow, the overlays are placed relative to its contents. %TRUE if the @allocation has been filled the child widget to position return location for the allocation The parent class. Name for the A3 paper size. Name for the A4 paper size. Name for the A5 paper size. Name for the B5 paper size. Name for the Executive paper size. Name for the Legal paper size. Name for the Letter paper size. The key used by the “Print to file” printer to store the file name of the output without the path to the directory and the file extension. The key used by the “Print to file” printer to store the directory to which the output should be written. The key used by the “Print to file” printer to store the format of the output. The supported values are “PS” and “PDF”. The key used by the “Print to file” printer to store the URI to which the output should be written. GTK+ itself supports only “file://” URIs. Use this priority for functionality related to size allocation. It is used internally by GTK+ to compute the sizes of widgets. This priority is higher than %GDK_PRIORITY_REDRAW to avoid resizing a widget which was just redrawn. Determines how widgets should be packed inside menubars and menuitems contained in menubars. Widgets are packed left-to-right Widgets are packed right-to-left Widgets are packed top-to-bottom Widgets are packed bottom-to-top Represents the packing location #GtkBox children. (See: #GtkVBox, #GtkHBox, and #GtkButtonBox). The child is packed into the start of the box The child is packed into the end of the box Struct defining a pad action entry. the type of pad feature that will trigger this action entry. the 0-indexed button/ring/strip number that will trigger this action entry. the mode that will trigger this action entry, or -1 for all modes. Human readable description of this action entry, this string should be deemed user-visible. action name that will be activated in the #GActionGroup. The type of a pad action. Action is triggered by a pad button Action is triggered by a pad ring Action is triggered by a pad strip #GtkPadController is an event controller for the pads found in drawing tablets (The collection of buttons and tactile sensors often found around the stylus-sensitive area). These buttons and sensors have no implicit meaning, and by default they perform no action, this event controller is provided to map those to #GAction objects, thus letting the application give those a more semantic meaning. Buttons and sensors are not constrained to triggering a single action, some %GDK_SOURCE_TABLET_PAD devices feature multiple "modes", all these input elements have one current mode, which may determine the final action being triggered. Pad devices often divide buttons and sensors into groups, all elements in a group share the same current mode, but different groups may have different modes. See gdk_device_pad_get_n_groups() and gdk_device_pad_get_group_n_modes(). Each of the actions that a given button/strip/ring performs for a given mode is defined by #GtkPadActionEntry, it contains an action name that will be looked up in the given #GActionGroup and activated whenever the specified input element and mode are triggered. A simple example of #GtkPadController usage, assigning button 1 in all modes and pad devices to an "invert-selection" action: |[ GtkPadActionEntry *pad_actions[] = { { GTK_PAD_ACTION_BUTTON, 1, -1, "Invert selection", "pad-actions.invert-selection" }, … }; … action_group = g_simple_action_group_new (); action = g_simple_action_new ("pad-actions.invert-selection", NULL); g_signal_connect (action, "activate", on_invert_selection_activated, NULL); g_action_map_add_action (G_ACTION_MAP (action_group), action); … pad_controller = gtk_pad_controller_new (window, action_group, NULL); ]| The actions belonging to rings/strips will be activated with a parameter of type %G_VARIANT_TYPE_DOUBLE bearing the value of the given axis, it is required that those are made stateful and accepting this #GVariantType. Creates a new #GtkPadController that will associate events from @pad to actions. A %NULL pad may be provided so the controller manages all pad devices generically, it is discouraged to mix #GtkPadController objects with %NULL and non-%NULL @pad argument on the same @window, as execution order is not guaranteed. The #GtkPadController is created with no mapped actions. In order to map pad events to actions, use gtk_pad_controller_set_action_entries() or gtk_pad_controller_set_action(). A newly created #GtkPadController a #GtkWindow #GActionGroup to trigger actions from A %GDK_SOURCE_TABLET_PAD device, or %NULL to handle all pads Adds an individual action to @controller. This action will only be activated if the given button/ring/strip number in @index is interacted while the current mode is @mode. -1 may be used for simple cases, so the action is triggered on all modes. The given @label should be considered user-visible, so internationalization rules apply. Some windowing systems may be able to use those for user feedback. a #GtkPadController the type of pad feature that will trigger this action the 0-indexed button/ring/strip number that will trigger this action the mode that will trigger this action, or -1 for all modes. Human readable description of this action, this string should be deemed user-visible. action name that will be activated in the #GActionGroup This is a convenience function to add a group of action entries on @controller. See #GtkPadActionEntry and gtk_pad_controller_set_action(). a #GtkPadController the action entries to set on @controller the number of elements in @entries See also gtk_print_settings_set_orientation(). Portrait mode. Landscape mode. Reverse portrait mode. Reverse landscape mode. See also gtk_print_settings_set_page_ranges(). start of page range. end of page range. See also gtk_print_job_set_page_set(). All pages. Even pages. Odd pages. A GtkPageSetup object stores the page size, orientation and margins. The idea is that you can get one of these from the page setup dialog and then pass it to the #GtkPrintOperation when printing. The benefit of splitting this out of the #GtkPrintSettings is that these affect the actual layout of the page, and thus need to be set long before user prints. ## Margins ## {#print-margins} The margins specified in this object are the “print margins”, i.e. the parts of the page that the printer cannot print on. These are different from the layout margins that a word processor uses; they are typically used to determine the minimal size for the layout margins. To obtain a #GtkPageSetup use gtk_page_setup_new() to get the defaults, or use gtk_print_run_page_setup_dialog() to show the page setup dialog and receive the resulting page setup. ## A page setup dialog |[<!-- language="C" --> static GtkPrintSettings *settings = NULL; static GtkPageSetup *page_setup = NULL; static void do_page_setup (void) { GtkPageSetup *new_page_setup; if (settings == NULL) settings = gtk_print_settings_new (); new_page_setup = gtk_print_run_page_setup_dialog (GTK_WINDOW (main_window), page_setup, settings); if (page_setup) g_object_unref (page_setup); page_setup = new_page_setup; } ]| Printing support was added in GTK+ 2.10. Creates a new #GtkPageSetup. a new #GtkPageSetup. Reads the page setup from the file @file_name. Returns a new #GtkPageSetup object with the restored page setup, or %NULL if an error occurred. See gtk_page_setup_to_file(). the restored #GtkPageSetup the filename to read the page setup from Desrialize a page setup from an a{sv} variant in the format produced by gtk_page_setup_to_gvariant(). a new #GtkPageSetup object an a{sv} #GVariant Reads the page setup from the group @group_name in the key file @key_file. Returns a new #GtkPageSetup object with the restored page setup, or %NULL if an error occurred. the restored #GtkPageSetup the #GKeyFile to retrieve the page_setup from the name of the group in the key_file to read, or %NULL to use the default name “Page Setup” Copies a #GtkPageSetup. a copy of @other the #GtkPageSetup to copy Gets the bottom margin in units of @unit. the bottom margin a #GtkPageSetup the unit for the return value Gets the left margin in units of @unit. the left margin a #GtkPageSetup the unit for the return value Gets the page orientation of the #GtkPageSetup. the page orientation a #GtkPageSetup Returns the page height in units of @unit. Note that this function takes orientation and margins into consideration. See gtk_page_setup_get_paper_height(). the page height. a #GtkPageSetup the unit for the return value Returns the page width in units of @unit. Note that this function takes orientation and margins into consideration. See gtk_page_setup_get_paper_width(). the page width. a #GtkPageSetup the unit for the return value Returns the paper height in units of @unit. Note that this function takes orientation, but not margins into consideration. See gtk_page_setup_get_page_height(). the paper height. a #GtkPageSetup the unit for the return value Gets the paper size of the #GtkPageSetup. the paper size a #GtkPageSetup Returns the paper width in units of @unit. Note that this function takes orientation, but not margins into consideration. See gtk_page_setup_get_page_width(). the paper width. a #GtkPageSetup the unit for the return value Gets the right margin in units of @unit. the right margin a #GtkPageSetup the unit for the return value Gets the top margin in units of @unit. the top margin a #GtkPageSetup the unit for the return value Reads the page setup from the file @file_name. See gtk_page_setup_to_file(). %TRUE on success a #GtkPageSetup the filename to read the page setup from Reads the page setup from the group @group_name in the key file @key_file. %TRUE on success a #GtkPageSetup the #GKeyFile to retrieve the page_setup from the name of the group in the key_file to read, or %NULL to use the default name “Page Setup” Sets the bottom margin of the #GtkPageSetup. a #GtkPageSetup the new bottom margin in units of @unit the units for @margin Sets the left margin of the #GtkPageSetup. a #GtkPageSetup the new left margin in units of @unit the units for @margin Sets the page orientation of the #GtkPageSetup. a #GtkPageSetup a #GtkPageOrientation value Sets the paper size of the #GtkPageSetup without changing the margins. See gtk_page_setup_set_paper_size_and_default_margins(). a #GtkPageSetup a #GtkPaperSize Sets the paper size of the #GtkPageSetup and modifies the margins according to the new paper size. a #GtkPageSetup a #GtkPaperSize Sets the right margin of the #GtkPageSetup. a #GtkPageSetup the new right margin in units of @unit the units for @margin Sets the top margin of the #GtkPageSetup. a #GtkPageSetup the new top margin in units of @unit the units for @margin This function saves the information from @setup to @file_name. %TRUE on success a #GtkPageSetup the file to save to Serialize page setup to an a{sv} variant. a new, floating, #GVariant a #GtkPageSetup This function adds the page setup from @setup to @key_file. a #GtkPageSetup the #GKeyFile to save the page setup to the group to add the settings to in @key_file, or %NULL to use the default name “Page Setup” The type of function that is passed to gtk_print_run_page_setup_dialog_async(). This function will be called when the page setup dialog is dismissed, and also serves as destroy notify for @data. the #GtkPageSetup that has been user data that has been passed to gtk_print_run_page_setup_dialog_async() Describes the panning direction of a #GtkGesturePan panned towards the left panned towards the right panned upwards panned downwards #GtkPaned has two panes, arranged either horizontally or vertically. The division between the two panes is adjustable by the user by dragging a handle. Child widgets are added to the panes of the widget with gtk_paned_pack1() and gtk_paned_pack2(). The division between the two children is set by default from the size requests of the children, but it can be adjusted by the user. A paned widget draws a separator between the two child widgets and a small handle that the user can drag to adjust the division. It does not draw any relief around the children or around the separator. (The space in which the separator is called the gutter.) Often, it is useful to put each child inside a #GtkFrame with the shadow type set to %GTK_SHADOW_IN so that the gutter appears as a ridge. No separator is drawn if one of the children is missing. Each child has two options that can be set, @resize and @shrink. If @resize is true, then when the #GtkPaned is resized, that child will expand or shrink along with the paned widget. If @shrink is true, then that child can be made smaller than its requisition by the user. Setting @shrink to %FALSE allows the application to set a minimum size. If @resize is false for both children, then this is treated as if @resize is true for both children. The application can set the position of the slider as if it were set by the user, by calling gtk_paned_set_position(). # CSS nodes |[<!-- language="plain" --> paned ├── <child> ├── separator[.wide] ╰── <child> ]| GtkPaned has a main CSS node with name paned, and a subnode for the separator with name separator. The subnode gets a .wide style class when the paned is supposed to be wide. In horizontal orientation, the nodes of the children are always arranged from left to right. So :first-child will always select the leftmost child, regardless of text direction. ## Creating a paned widget with minimum sizes. |[<!-- language="C" --> GtkWidget *hpaned = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL); GtkWidget *frame1 = gtk_frame_new (NULL); GtkWidget *frame2 = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame1), GTK_SHADOW_IN); gtk_frame_set_shadow_type (GTK_FRAME (frame2), GTK_SHADOW_IN); gtk_widget_set_size_request (hpaned, 200, -1); gtk_paned_pack1 (GTK_PANED (hpaned), frame1, TRUE, FALSE); gtk_widget_set_size_request (frame1, 50, -1); gtk_paned_pack2 (GTK_PANED (hpaned), frame2, FALSE, FALSE); gtk_widget_set_size_request (frame2, 50, -1); ]| Creates a new #GtkPaned widget. a new #GtkPaned. the paned’s orientation. Adds a child to the top or left pane with default parameters. This is equivalent to `gtk_paned_pack1 (paned, child, FALSE, TRUE)`. a paned widget the child to add Adds a child to the bottom or right pane with default parameters. This is equivalent to `gtk_paned_pack2 (paned, child, TRUE, TRUE)`. a paned widget the child to add Obtains the first child of the paned widget. first child, or %NULL if it is not set. a #GtkPaned widget Obtains the second child of the paned widget. second child, or %NULL if it is not set. a #GtkPaned widget Returns the #GdkWindow of the handle. This function is useful when handling button or motion events because it enables the callback to distinguish between the window of the paned, a child and the handle. the paned’s handle window. a #GtkPaned Obtains the position of the divider between the two panes. position of the divider a #GtkPaned widget Gets the #GtkPaned:wide-handle property. %TRUE if the paned should have a wide handle a #GtkPaned Adds a child to the top or left pane. a paned widget the child to add should this child expand when the paned widget is resized. can this child be made smaller than its requisition. Adds a child to the bottom or right pane. a paned widget the child to add should this child expand when the paned widget is resized. can this child be made smaller than its requisition. Sets the position of the divider between the two panes. a #GtkPaned widget pixel position of divider, a negative value means that the position is unset. Sets the #GtkPaned:wide-handle property. a #GtkPaned the new value for the #GtkPaned:wide-handle property The largest possible value for the position property. This property is derived from the size and shrinkability of the widget's children. The smallest possible value for the position property. This property is derived from the size and shrinkability of the widget's children. Setting this property to %TRUE indicates that the paned needs to provide stronger visual separation (e.g. because it separates between two notebooks, whose tab rows would otherwise merge visually). The ::accept-position signal is a [keybinding signal][GtkBindingSignal] which gets emitted to accept the current position of the handle when moving it using key bindings. The default binding for this signal is Return or Space. The ::cancel-position signal is a [keybinding signal][GtkBindingSignal] which gets emitted to cancel moving the position of the handle using key bindings. The position of the handle will be reset to the value prior to moving it. The default binding for this signal is Escape. The ::cycle-child-focus signal is a [keybinding signal][GtkBindingSignal] which gets emitted to cycle the focus between the children of the paned. The default binding is f6. whether cycling backward or forward The ::cycle-handle-focus signal is a [keybinding signal][GtkBindingSignal] which gets emitted to cycle whether the paned should grab focus to allow the user to change position of the handle by using key bindings. The default binding for this signal is f8. whether cycling backward or forward The ::move-handle signal is a [keybinding signal][GtkBindingSignal] which gets emitted to move the handle when the user is using key bindings to move it. a #GtkScrollType The ::toggle-handle-focus is a [keybinding signal][GtkBindingSignal] which gets emitted to accept the current position of the handle and then move focus to the next widget in the focus chain. The default binding is Tab. GtkPaperSize handles paper sizes. It uses the standard called [PWG 5101.1-2002 PWG: Standard for Media Standardized Names](http://www.pwg.org/standards.html) to name the paper sizes (and to get the data for the page sizes). In addition to standard paper sizes, GtkPaperSize allows to construct custom paper sizes with arbitrary dimensions. The #GtkPaperSize object stores not only the dimensions (width and height) of a paper size and its name, it also provides default [print margins][print-margins]. Printing support has been added in GTK+ 2.10. Creates a new #GtkPaperSize object by parsing a [PWG 5101.1-2002](ftp://ftp.pwg.org/pub/pwg/candidates/cs-pwgmsn10-20020226-5101.1.pdf) paper name. If @name is %NULL, the default paper size is returned, see gtk_paper_size_get_default(). a new #GtkPaperSize, use gtk_paper_size_free() to free it a paper size name, or %NULL Creates a new #GtkPaperSize object with the given parameters. a new #GtkPaperSize object, use gtk_paper_size_free() to free it the paper name the human-readable name the paper width, in units of @unit the paper height, in units of @unit the unit for @width and @height. not %GTK_UNIT_NONE. Deserialize a paper size from an a{sv} variant in the format produced by gtk_paper_size_to_gvariant(). a new #GtkPaperSize object an a{sv} #GVariant Creates a new #GtkPaperSize object by using IPP information. If @ipp_name is not a recognized paper name, @width and @height are used to construct a custom #GtkPaperSize object. a new #GtkPaperSize, use gtk_paper_size_free() to free it an IPP paper name the paper width, in points the paper height in points Reads a paper size from the group @group_name in the key file @key_file. a new #GtkPaperSize object with the restored paper size, or %NULL if an error occurred the #GKeyFile to retrieve the papersize from the name of the group in the key file to read, or %NULL to read the first group Creates a new #GtkPaperSize object by using PPD information. If @ppd_name is not a recognized PPD paper name, @ppd_display_name, @width and @height are used to construct a custom #GtkPaperSize object. a new #GtkPaperSize, use gtk_paper_size_free() to free it a PPD paper name the corresponding human-readable name the paper width, in points the paper height in points Copies an existing #GtkPaperSize. a copy of @other a #GtkPaperSize Free the given #GtkPaperSize object. a #GtkPaperSize Gets the default bottom margin for the #GtkPaperSize. the default bottom margin a #GtkPaperSize object the unit for the return value, not %GTK_UNIT_NONE Gets the default left margin for the #GtkPaperSize. the default left margin a #GtkPaperSize object the unit for the return value, not %GTK_UNIT_NONE Gets the default right margin for the #GtkPaperSize. the default right margin a #GtkPaperSize object the unit for the return value, not %GTK_UNIT_NONE Gets the default top margin for the #GtkPaperSize. the default top margin a #GtkPaperSize object the unit for the return value, not %GTK_UNIT_NONE Gets the human-readable name of the #GtkPaperSize. the human-readable name of @size a #GtkPaperSize object Gets the paper height of the #GtkPaperSize, in units of @unit. the paper height a #GtkPaperSize object the unit for the return value, not %GTK_UNIT_NONE Gets the name of the #GtkPaperSize. the name of @size a #GtkPaperSize object Gets the PPD name of the #GtkPaperSize, which may be %NULL. the PPD name of @size a #GtkPaperSize object Gets the paper width of the #GtkPaperSize, in units of @unit. the paper width a #GtkPaperSize object the unit for the return value, not %GTK_UNIT_NONE Returns %TRUE if @size is not a standard paper size. whether @size is a custom paper size. a #GtkPaperSize object Compares two #GtkPaperSize objects. %TRUE, if @size1 and @size2 represent the same paper size a #GtkPaperSize object another #GtkPaperSize object Returns %TRUE if @size is an IPP standard paper size. whether @size is not an IPP custom paper size. a #GtkPaperSize object Changes the dimensions of a @size to @width x @height. a custom #GtkPaperSize object the new width in units of @unit the new height in units of @unit the unit for @width and @height Serialize a paper size to an a{sv} variant. a new, floating, #GVariant a #GtkPaperSize This function adds the paper size from @size to @key_file. a #GtkPaperSize the #GKeyFile to save the paper size to the group to add the settings to in @key_file Returns the name of the default paper size, which depends on the current locale. the name of the default paper size. The string is owned by GTK+ and should not be modified. Creates a list of known paper sizes. a newly allocated list of newly allocated #GtkPaperSize objects whether to include custom paper sizes as defined in the page setup dialog Priorities for path lookups. See also gtk_binding_set_add_path(). Deprecated Deprecated Deprecated Deprecated Deprecated Deprecated Widget path types. See also gtk_binding_set_add_path(). Deprecated Deprecated Deprecated These flags serve two purposes. First, the application can call gtk_places_sidebar_set_open_flags() using these flags as a bitmask. This tells the sidebar that the application is able to open folders selected from the sidebar in various ways, for example, in new tabs or in new windows in addition to the normal mode. Second, when one of these values gets passed back to the application in the #GtkPlacesSidebar::open-location signal, it means that the application should open the selected location in the normal way, in a new tab, or in a new window. The sidebar takes care of determining the desired way to open the location, based on the modifier keys that the user is pressing at the time the selection is made. If the application never calls gtk_places_sidebar_set_open_flags(), then the sidebar will only use #GTK_PLACES_OPEN_NORMAL in the #GtkPlacesSidebar::open-location signal. This is the default mode of operation. This is the default mode that #GtkPlacesSidebar uses if no other flags are specified. It indicates that the calling application should open the selected location in the normal way, for example, in the folder view beside the sidebar. When passed to gtk_places_sidebar_set_open_flags(), this indicates that the application can open folders selected from the sidebar in new tabs. This value will be passed to the #GtkPlacesSidebar::open-location signal when the user selects that a location be opened in a new tab instead of in the standard fashion. Similar to @GTK_PLACES_OPEN_NEW_TAB, but indicates that the application can open folders in new windows. #GtkPlacesSidebar is a widget that displays a list of frequently-used places in the file system: the user’s home directory, the user’s bookmarks, and volumes and drives. This widget is used as a sidebar in #GtkFileChooser and may be used by file managers and similar programs. The places sidebar displays drives and volumes, and will automatically mount or unmount them when the user selects them. Applications can hook to various signals in the places sidebar to customize its behavior. For example, they can add extra commands to the context menu of the sidebar. While bookmarks are completely in control of the user, the places sidebar also allows individual applications to provide extra shortcut folders that are unique to each application. For example, a Paint program may want to add a shortcut for a Clipart folder. You can do this with gtk_places_sidebar_add_shortcut(). To make use of the places sidebar, an application at least needs to connect to the #GtkPlacesSidebar::open-location signal. This is emitted when the user selects in the sidebar a location to open. The application should also call gtk_places_sidebar_set_location() when it changes the currently-viewed location. # CSS nodes GtkPlacesSidebar uses a single CSS node with name placessidebar and style class .sidebar. Among the children of the places sidebar, the following style classes can be used: - .sidebar-new-bookmark-row for the 'Add new bookmark' row - .sidebar-placeholder-row for a row that is a placeholder - .has-open-popup when a popup is open for a row Creates a new #GtkPlacesSidebar widget. The application should connect to at least the #GtkPlacesSidebar::open-location signal to be notified when the user makes a selection in the sidebar. a newly created #GtkPlacesSidebar Applications may want to present some folders in the places sidebar if they could be immediately useful to users. For example, a drawing program could add a “/usr/share/clipart” location when the sidebar is being used in an “Insert Clipart” dialog box. This function adds the specified @location to a special place for immutable shortcuts. The shortcuts are application-specific; they are not shared across applications, and they are not persistent. If this function is called multiple times with different locations, then they are added to the sidebar’s list in the same order as the function is called. a places sidebar location to add as an application-specific shortcut Returns the value previously set with gtk_places_sidebar_set_local_only(). %TRUE if the sidebar will only show local files. a places sidebar Gets the currently selected location in the @sidebar. This can be %NULL when nothing is selected, for example, when gtk_places_sidebar_set_location() has been called with a location that is not among the sidebar’s list of places to show. You can use this function to get the selection in the @sidebar. Also, if you connect to the #GtkPlacesSidebar::populate-popup signal, you can use this function to get the location that is being referred to during the callbacks for your menu items. a #GFile with the selected location, or %NULL if nothing is visually selected. a places sidebar This function queries the bookmarks added by the user to the places sidebar, and returns one of them. This function is used by #GtkFileChooser to implement the “Alt-1”, “Alt-2”, etc. shortcuts, which activate the cooresponding bookmark. The bookmark specified by the index @n, or %NULL if no such index exist. Note that the indices start at 0, even though the file chooser starts them with the keyboard shortcut "Alt-1". a places sidebar index of the bookmark to query Gets the open flags. the #GtkPlacesOpenFlags of @sidebar a #GtkPlacesSidebar Returns the value previously set with gtk_places_sidebar_set_show_connect_to_server() It is recommended to group this functionality with the drives and network location under the new 'Other Location' item %TRUE if the sidebar will display a “Connect to Server” item. a places sidebar Returns the value previously set with gtk_places_sidebar_set_show_desktop() %TRUE if the sidebar will display a builtin shortcut to the desktop folder. a places sidebar Returns the value previously set with gtk_places_sidebar_set_show_enter_location() %TRUE if the sidebar will display an “Enter Location” item. a places sidebar Returns the value previously set with gtk_places_sidebar_set_show_other_locations() %TRUE if the sidebar will display an “Other Locations” item. a places sidebar Returns the value previously set with gtk_places_sidebar_set_show_recent() %TRUE if the sidebar will display a builtin shortcut for recent files a places sidebar Returns the value previously set with gtk_places_sidebar_set_show_starred_location() %TRUE if the sidebar will display a Starred item. a places sidebar Returns the value previously set with gtk_places_sidebar_set_show_trash() %TRUE if the sidebar will display a “Trash” item. a places sidebar Gets the list of shortcuts. A #GSList of #GFile of the locations that have been added as application-specific shortcuts with gtk_places_sidebar_add_shortcut(). To free this list, you can use |[<!-- language="C" --> g_slist_free_full (list, (GDestroyNotify) g_object_unref); ]| a places sidebar Removes an application-specific shortcut that has been previously been inserted with gtk_places_sidebar_add_shortcut(). If the @location is not a shortcut in the sidebar, then nothing is done. a places sidebar location to remove Make the GtkPlacesSidebar show drop targets, so it can show the available drop targets and a "new bookmark" row. This improves the Drag-and-Drop experience of the user and allows applications to show all available drop targets at once. This needs to be called when the application is aware of an ongoing drag that might target the sidebar. The drop-targets-visible state will be unset automatically if the drag finishes in the GtkPlacesSidebar. You only need to unset the state when the drag ends on some other widget on your application. a places sidebar. whether to show the valid targets or not. drag context used to ask the source about the action that wants to perform, so hints are more accurate. Sets whether the @sidebar should only show local files. a places sidebar whether to show only local files Sets the location that is being shown in the widgets surrounding the @sidebar, for example, in a folder view in a file manager. In turn, the @sidebar will highlight that location if it is being shown in the list of places, or it will unhighlight everything if the @location is not among the places in the list. a places sidebar location to select, or %NULL for no current path Sets the way in which the calling application can open new locations from the places sidebar. For example, some applications only open locations “directly” into their main view, while others may support opening locations in a new notebook tab or a new window. This function is used to tell the places @sidebar about the ways in which the application can open new locations, so that the sidebar can display (or not) the “Open in new tab” and “Open in new window” menu items as appropriate. When the #GtkPlacesSidebar::open-location signal is emitted, its flags argument will be set to one of the @flags that was passed in gtk_places_sidebar_set_open_flags(). Passing 0 for @flags will cause #GTK_PLACES_OPEN_NORMAL to always be sent to callbacks for the “open-location” signal. a places sidebar Bitmask of modes in which the calling application can open locations Sets whether the @sidebar should show an item for connecting to a network server; this is off by default. An application may want to turn this on if it implements a way for the user to connect to network servers directly. If you enable this, you should connect to the #GtkPlacesSidebar::show-connect-to-server signal. It is recommended to group this functionality with the drives and network location under the new 'Other Location' item a places sidebar whether to show an item for the Connect to Server command Sets whether the @sidebar should show an item for the Desktop folder. The default value for this option is determined by the desktop environment and the user’s configuration, but this function can be used to override it on a per-application basis. a places sidebar whether to show an item for the Desktop folder Sets whether the @sidebar should show an item for entering a location; this is off by default. An application may want to turn this on if manually entering URLs is an expected user action. If you enable this, you should connect to the #GtkPlacesSidebar::show-enter-location signal. a places sidebar whether to show an item to enter a location Sets whether the @sidebar should show an item for the application to show an Other Locations view; this is off by default. When set to %TRUE, persistent devices such as hard drives are hidden, otherwise they are shown in the sidebar. An application may want to turn this on if it implements a way for the user to see and interact with drives and network servers directly. If you enable this, you should connect to the #GtkPlacesSidebar::show-other-locations signal. a places sidebar whether to show an item for the Other Locations view Sets whether the @sidebar should show an item for recent files. The default value for this option is determined by the desktop environment, but this function can be used to override it on a per-application basis. a places sidebar whether to show an item for recent files If you enable this, you should connect to the #GtkPlacesSidebar::show-starred-location signal. a places sidebar whether to show an item for Starred files Sets whether the @sidebar should show an item for the Trash location. a places sidebar whether to show an item for the Trash location If :populate-all is %TRUE, the #GtkPlacesSidebar::populate-popup signal is also emitted for popovers. The places sidebar emits this signal when it needs to ask the application to pop up a menu to ask the user for which drag action to perform. the final drag action that the sidebar should pass to the drag side of the drag-and-drop operation. Possible drag actions that need to be asked for. When the user starts a drag-and-drop operation and the sidebar needs to ask the application for which drag action to perform, then the sidebar will emit this signal. The application can evaluate the @context for customary actions, or it can check the type of the files indicated by @source_file_list against the possible actions for the destination @dest_file. The drag action to use must be the return value of the signal handler. The drag action to use, for example, #GDK_ACTION_COPY or #GDK_ACTION_MOVE, or 0 if no action is allowed here (i.e. drops are not allowed in the specified @dest_file). #GdkDragContext with information about the drag operation #GFile with the tentative location that is being hovered for a drop List of #GFile that are being dragged The places sidebar emits this signal when the user completes a drag-and-drop operation and one of the sidebar's items is the destination. This item is in the @dest_file, and the @source_file_list has the list of files that are dropped into it and which should be copied/moved/etc. based on the specified @action. Destination #GFile. #GList of #GFile that got dropped. Drop action to perform. The places sidebar emits this signal when it starts a new operation because the user clicked on some location that needs mounting. In this way the application using the #GtkPlacesSidebar can track the progress of the operation and, for example, show a notification. the #GMountOperation that is going to start. The places sidebar emits this signal when the user selects a location in it. The calling application should display the contents of that location; for example, a file manager should show a list of files in the specified location. #GFile to which the caller should switch. a single value from #GtkPlacesOpenFlags specifying how the @location should be opened. The places sidebar emits this signal when the user invokes a contextual popup on one of its items. In the signal handler, the application may add extra items to the menu as appropriate. For example, a file manager may want to add a "Properties" command to the menu. It is not necessary to store the @selected_item for each menu item; during their callbacks, the application can use gtk_places_sidebar_get_location() to get the file to which the item refers. The @selected_item argument may be %NULL in case the selection refers to a volume. In this case, @selected_volume will be non-%NULL. In this case, the calling application will have to g_object_ref() the @selected_volume and keep it around to use it in the callback. The @container and all its contents are destroyed after the user dismisses the popup. The popup is re-created (and thus, this signal is emitted) every time the user activates the contextual menu. Before 3.18, the @container always was a #GtkMenu, and you were expected to add your items as #GtkMenuItems. Since 3.18, the popup may be implemented as a #GtkPopover, in which case @container will be something else, e.g. a #GtkBox, to which you may add #GtkModelButtons or other widgets, such as #GtkEntries, #GtkSpinButtons, etc. If your application can deal with this situation, you can set #GtkPlacesSidebar::populate-all to %TRUE to request that this signal is emitted for populating popovers as well. a #GtkMenu or another #GtkContainer #GFile with the item to which the popup should refer, or %NULL in the case of a @selected_volume. #GVolume if the selected item is a volume, or %NULL if it is a file. The places sidebar emits this signal when it needs the calling application to present an way to connect directly to a network server. For example, the application may bring up a dialog box asking for a URL like "sftp://ftp.example.com". It is up to the application to create the corresponding mount by using, for example, g_file_mount_enclosing_volume(). use the #GtkPlacesSidebar::show-other-locations signal to connect to network servers. The places sidebar emits this signal when it needs the calling application to present an way to directly enter a location. For example, the application may bring up a dialog box asking for a URL like "http://http.example.com". The places sidebar emits this signal when it needs the calling application to present an error message. Most of these messages refer to mounting or unmounting media, for example, when a drive cannot be started for some reason. primary message with a summary of the error to show. secondary message with details of the error to show. The places sidebar emits this signal when it needs the calling application to present a way to show other locations e.g. drives and network access points. For example, the application may bring up a page showing persistent volumes and discovered network addresses. use the #GtkPlacesSidebar::show-other-locations-with-flags which includes the open flags in order to allow the user to specify to open in a new tab or window, in a similar way than #GtkPlacesSidebar::open-location The places sidebar emits this signal when it needs the calling application to present a way to show other locations e.g. drives and network access points. For example, the application may bring up a page showing persistent volumes and discovered network addresses. a single value from #GtkPlacesOpenFlags specifying how it should be opened. The places sidebar emits this signal when it needs the calling application to present a way to show the starred files. In GNOME, starred files are implemented by setting the nao:predefined-tag-favorite tag in the tracker database. a single value from #GtkPlacesOpenFlags specifying how the starred file should be opened. The places sidebar emits this signal when it starts a new operation because the user for example ejected some drive or unmounted a mount. In this way the application using the #GtkPlacesSidebar can track the progress of the operation and, for example, show a notification. the #GMountOperation that is going to start. Together with #GtkSocket, #GtkPlug provides the ability to embed widgets from one process into another process in a fashion that is transparent to the user. One process creates a #GtkSocket widget and passes the ID of that widget’s window to the other process, which then creates a #GtkPlug with that window ID. Any widgets contained in the #GtkPlug then will appear inside the first application’s window. The communication between a #GtkSocket and a #GtkPlug follows the [XEmbed Protocol](http://www.freedesktop.org/Standards/xembed-spec). This protocol has also been implemented in other toolkits, e.g. Qt, allowing the same level of integration when embedding a Qt widget in GTK+ or vice versa. The #GtkPlug and #GtkSocket widgets are only available when GTK+ is compiled for the X11 platform and %GDK_WINDOWING_X11 is defined. They can only be used on a #GdkX11Display. To use #GtkPlug and #GtkSocket, you need to include the `gtk/gtkx.h` header. Creates a new plug widget inside the #GtkSocket identified by @socket_id. If @socket_id is 0, the plug is left “unplugged” and can later be plugged into a #GtkSocket by gtk_socket_add_id(). the new #GtkPlug widget. the window ID of the socket, or 0. Create a new plug widget inside the #GtkSocket identified by socket_id. the new #GtkPlug widget. the #GdkDisplay on which @socket_id is displayed the XID of the socket’s window. Finish the initialization of @plug for a given #GtkSocket identified by @socket_id. This function will generally only be used by classes deriving from #GtkPlug. a #GtkPlug. the XID of the socket’s window. Finish the initialization of @plug for a given #GtkSocket identified by @socket_id which is currently displayed on @display. This function will generally only be used by classes deriving from #GtkPlug. a #GtkPlug. the #GdkDisplay associated with @socket_id’s #GtkSocket. the XID of the socket’s window. Determines whether the plug is embedded in a socket. %TRUE if the plug is embedded in a socket a #GtkPlug Gets the window ID of a #GtkPlug widget, which can then be used to embed this window inside another window, for instance with gtk_socket_add_id(). the window ID for the plug a #GtkPlug. Retrieves the socket the plug is embedded in. the window of the socket, or %NULL a #GtkPlug %TRUE if the plug is embedded in a socket. The window of the socket the plug is embedded in. Gets emitted when the plug becomes embedded in a socket. Determines how the size should be computed to achieve the one of the visibility mode for the scrollbars. The scrollbar is always visible. The view size is independent of the content. The scrollbar will appear and disappear as necessary. For example, when all of a #GtkTreeView can not be seen. The scrollbar should never appear. In this mode the content determines the size. Don't show a scrollbar, but don't force the size to follow the content. This can be used e.g. to make multiple scrolled windows share a scrollbar. Since: 3.16 GtkPopover is a bubble-like context window, primarily meant to provide context-dependent information or options. Popovers are attached to a widget, passed at construction time on gtk_popover_new(), or updated afterwards through gtk_popover_set_relative_to(), by default they will point to the whole widget area, although this behavior can be changed through gtk_popover_set_pointing_to(). The position of a popover relative to the widget it is attached to can also be changed through gtk_popover_set_position(). By default, #GtkPopover performs a GTK+ grab, in order to ensure input events get redirected to it while it is shown, and also so the popover is dismissed in the expected situations (clicks outside the popover, or the Esc key being pressed). If no such modal behavior is desired on a popover, gtk_popover_set_modal() may be called on it to tweak its behavior. ## GtkPopover as menu replacement GtkPopover is often used to replace menus. To facilitate this, it supports being populated from a #GMenuModel, using gtk_popover_new_from_model(). In addition to all the regular menu model features, this function supports rendering sections in the model in a more compact form, as a row of icon buttons instead of menu items. To use this rendering, set the ”display-hint” attribute of the section to ”horizontal-buttons” and set the icons of your items with the ”verb-icon” attribute. |[ <section> <attribute name="display-hint">horizontal-buttons</attribute> <item> <attribute name="label">Cut</attribute> <attribute name="action">app.cut</attribute> <attribute name="verb-icon">edit-cut-symbolic</attribute> </item> <item> <attribute name="label">Copy</attribute> <attribute name="action">app.copy</attribute> <attribute name="verb-icon">edit-copy-symbolic</attribute> </item> <item> <attribute name="label">Paste</attribute> <attribute name="action">app.paste</attribute> <attribute name="verb-icon">edit-paste-symbolic</attribute> </item> </section> ]| # CSS nodes GtkPopover has a single css node called popover. It always gets the .background style class and it gets the .menu style class if it is menu-like (e.g. #GtkPopoverMenu or created using gtk_popover_new_from_model(). Particular uses of GtkPopover, such as touch selection popups or magnifiers in #GtkEntry or #GtkTextView get style classes like .touch-selection or .magnifier to differentiate from plain popovers. Creates a new popover to point to @relative_to a new #GtkPopover #GtkWidget the popover is related to Creates a #GtkPopover and populates it according to @model. The popover is pointed to the @relative_to widget. The created buttons are connected to actions found in the #GtkApplicationWindow to which the popover belongs - typically by means of being attached to a widget that is contained within the #GtkApplicationWindows widget hierarchy. Actions can also be added using gtk_widget_insert_action_group() on the menus attach widget or on any of its parent widgets. the new #GtkPopover #GtkWidget the popover is related to a #GMenuModel Establishes a binding between a #GtkPopover and a #GMenuModel. The contents of @popover are removed and then refilled with menu items according to @model. When @model changes, @popover is updated. Calling this function twice on @popover with different @model will cause the first binding to be replaced with a binding to the new model. If @model is %NULL then any previous binding is undone and all children are removed. If @action_namespace is non-%NULL then the effect is as if all actions mentioned in the @model have their names prefixed with the namespace, plus a dot. For example, if the action “quit” is mentioned and @action_namespace is “app” then the effective action name is “app.quit”. This function uses #GtkActionable to define the action name and target values on the created menu items. If you want to use an action group other than “app” and “win”, or if you want to use a #GtkMenuShell outside of a #GtkApplicationWindow, then you will need to attach your own action group to the widget hierarchy using gtk_widget_insert_action_group(). As an example, if you created a group with a “quit” action and inserted it with the name “mygroup” then you would use the action name “mygroup.quit” in your #GMenuModel. a #GtkPopover the #GMenuModel to bind to or %NULL to remove binding the namespace for actions in @model Returns the constraint for placing this popover. See gtk_popover_set_constrain_to(). the constraint for placing this popover. a #GtkPopover Gets the widget that should be set as the default while the popover is shown. the default widget, or %NULL if there is none a #GtkPopover Returns whether the popover is modal, see gtk_popover_set_modal to see the implications of this. #TRUE if @popover is modal a #GtkPopover If a rectangle to point to has been set, this function will return %TRUE and fill in @rect with such rectangle, otherwise it will return %FALSE and fill in @rect with the attached widget coordinates. %TRUE if a rectangle to point to was set. a #GtkPopover location to store the rectangle Returns the preferred position of @popover. The preferred position. a #GtkPopover Returns the widget @popover is currently attached to a #GtkWidget a #GtkPopover Returns whether show/hide transitions are enabled on this popover. You can show or hide the popover without transitions using gtk_widget_show() and gtk_widget_hide() while gtk_popover_popup() and gtk_popover_popdown() will use transitions. #TRUE if the show and hide transitions of the given popover are enabled, #FALSE otherwise. a #GtkPopover Pops @popover down.This is different than a gtk_widget_hide() call in that it shows the popover with a transition. If you want to hide the popover without a transition, use gtk_widget_hide(). a #GtkPopover Pops @popover up. This is different than a gtk_widget_show() call in that it shows the popover with a transition. If you want to show the popover without a transition, use gtk_widget_show(). a #GtkPopover Sets a constraint for positioning this popover. Note that not all platforms support placing popovers freely, and may already impose constraints. a #GtkPopover the new constraint Sets the widget that should be set as default widget while the popover is shown (see gtk_window_set_default()). #GtkPopover remembers the previous default widget and reestablishes it when the popover is dismissed. a #GtkPopover the new default widget, or %NULL Sets whether @popover is modal, a modal popover will grab all input within the toplevel and grab the keyboard focus on it when being displayed. Clicking outside the popover area or pressing Esc will dismiss the popover and ungrab input. a #GtkPopover #TRUE to make popover claim all input within the toplevel Sets the rectangle that @popover will point to, in the coordinate space of the widget @popover is attached to, see gtk_popover_set_relative_to(). a #GtkPopover rectangle to point to Sets the preferred position for @popover to appear. If the @popover is currently visible, it will be immediately updated. This preference will be respected where possible, although on lack of space (eg. if close to the window edges), the #GtkPopover may choose to appear on the opposite side a #GtkPopover preferred popover position Sets a new widget to be attached to @popover. If @popover is visible, the position will be updated. Note: the ownership of popovers is always given to their @relative_to widget, so if @relative_to is set to %NULL on an attached @popover, it will be detached from its previous widget, and consequently destroyed unless extra references are kept. a #GtkPopover a #GtkWidget Sets whether show/hide transitions are enabled on this popover You can show or hide the popover without transitions using gtk_widget_show() and gtk_widget_hide() while gtk_popover_popup() and gtk_popover_popdown() will use transitions. a #GtkPopover Whether transitions are enabled Sets a constraint for the popover position. Sets whether the popover is modal (so other elements in the window do not receive input while the popover is visible). Marks a specific rectangle to be pointed. Sets the preferred position of the popover. Sets the attached widget. Whether show/hide transitions are enabled for this popover. You can show or hide the popover without transitions using gtk_widget_show() and gtk_widget_hide() while gtk_popover_popup() and gtk_popover_popdown() will use transitions. This signal is emitted when the popover is dismissed either through API or user interaction. Describes constraints to positioning of popovers. More values may be added to this enumeration in the future. Don't constrain the popover position beyond what is imposed by the implementation Constrain the popover to the boundaries of the window that it is attached to GtkPopoverMenu is a subclass of #GtkPopover that treats its children like menus and allows switching between them. It is meant to be used primarily together with #GtkModelButton, but any widget can be used, such as #GtkSpinButton or #GtkScale. In this respect, GtkPopoverMenu is more flexible than popovers that are created from a #GMenuModel with gtk_popover_new_from_model(). To add a child as a submenu, set the #GtkPopoverMenu:submenu child property to the name of the submenu. To let the user open this submenu, add a #GtkModelButton whose #GtkModelButton:menu-name property is set to the name you've given to the submenu. By convention, the first child of a submenu should be a #GtkModelButton to switch back to the parent menu. Such a button should use the #GtkModelButton:inverted and #GtkModelButton:centered properties to achieve a title-like appearance and place the submenu indicator at the opposite side. To switch back to the main menu, use "main" as the menu name. # Example |[ <object class="GtkPopoverMenu"> <child> <object class="GtkBox"> <property name="visible">True</property> <property name="margin">10</property> <child> <object class="GtkModelButton"> <property name="visible">True</property> <property name="action-name">win.frob</property> <property name="text" translatable="yes">Frob</property> </object> </child> <child> <object class="GtkModelButton"> <property name="visible">True</property> <property name="menu-name">more</property> <property name="text" translatable="yes">More</property> </object> </child> </object> </child> <child> <object class="GtkBox"> <property name="visible">True</property> <property name="margin">10</property> <child> <object class="GtkModelButton"> <property name="visible">True</property> <property name="action-name">win.foo</property> <property name="text" translatable="yes">Foo</property> </object> </child> <child> <object class="GtkModelButton"> <property name="visible">True</property> <property name="action-name">win.bar</property> <property name="text" translatable="yes">Bar</property> </object> </child> </object> <packing> <property name="submenu">more</property> </packing> </child> </object> ]| Just like normal popovers created using gtk_popover_new_from_model, #GtkPopoverMenu instances have a single css node called "popover" and get the .menu style class. Creates a new popover menu. a new #GtkPopoverMenu Opens a submenu of the @popover. The @name must be one of the names given to the submenus of @popover with #GtkPopoverMenu:submenu, or "main" to switch back to the main menu. #GtkModelButton will open submenus automatically when the #GtkModelButton:menu-name property is set, so this function is only needed when you are using other kinds of widgets to initiate menu changes. a #GtkPopoverMenu the name of the menu to switch to Describes which edge of a widget a certain feature is positioned at, e.g. the tabs of a #GtkNotebook, the handle of a #GtkHandleBox or the label of a #GtkScale. The feature is at the left edge. The feature is at the right edge. The feature is at the top edge. The feature is at the bottom edge. A GtkPrintContext encapsulates context information that is required when drawing pages for printing, such as the cairo context and important parameters like page size and resolution. It also lets you easily create #PangoLayout and #PangoContext objects that match the font metrics of the cairo surface. GtkPrintContext objects gets passed to the #GtkPrintOperation::begin-print, #GtkPrintOperation::end-print, #GtkPrintOperation::request-page-setup and #GtkPrintOperation::draw-page signals on the #GtkPrintOperation. ## Using GtkPrintContext in a #GtkPrintOperation::draw-page callback |[<!-- language="C" --> static void draw_page (GtkPrintOperation *operation, GtkPrintContext *context, int page_nr) { cairo_t *cr; PangoLayout *layout; PangoFontDescription *desc; cr = gtk_print_context_get_cairo_context (context); // Draw a red rectangle, as wide as the paper (inside the margins) cairo_set_source_rgb (cr, 1.0, 0, 0); cairo_rectangle (cr, 0, 0, gtk_print_context_get_width (context), 50); cairo_fill (cr); // Draw some lines cairo_move_to (cr, 20, 10); cairo_line_to (cr, 40, 20); cairo_arc (cr, 60, 60, 20, 0, M_PI); cairo_line_to (cr, 80, 20); cairo_set_source_rgb (cr, 0, 0, 0); cairo_set_line_width (cr, 5); cairo_set_line_cap (cr, CAIRO_LINE_CAP_ROUND); cairo_set_line_join (cr, CAIRO_LINE_JOIN_ROUND); cairo_stroke (cr); // Draw some text layout = gtk_print_context_create_pango_layout (context); pango_layout_set_text (layout, "Hello World! Printing is easy", -1); desc = pango_font_description_from_string ("sans 28"); pango_layout_set_font_description (layout, desc); pango_font_description_free (desc); cairo_move_to (cr, 30, 20); pango_cairo_layout_path (cr, layout); // Font Outline cairo_set_source_rgb (cr, 0.93, 1.0, 0.47); cairo_set_line_width (cr, 0.5); cairo_stroke_preserve (cr); // Font Fill cairo_set_source_rgb (cr, 0, 0.0, 1.0); cairo_fill (cr); g_object_unref (layout); } ]| Printing support was added in GTK+ 2.10. Creates a new #PangoContext that can be used with the #GtkPrintContext. a new Pango context for @context a #GtkPrintContext Creates a new #PangoLayout that is suitable for use with the #GtkPrintContext. a new Pango layout for @context a #GtkPrintContext Obtains the cairo context that is associated with the #GtkPrintContext. the cairo context of @context a #GtkPrintContext Obtains the horizontal resolution of the #GtkPrintContext, in dots per inch. the horizontal resolution of @context a #GtkPrintContext Obtains the vertical resolution of the #GtkPrintContext, in dots per inch. the vertical resolution of @context a #GtkPrintContext Obtains the hardware printer margins of the #GtkPrintContext, in units. %TRUE if the hard margins were retrieved a #GtkPrintContext top hardware printer margin bottom hardware printer margin left hardware printer margin right hardware printer margin Obtains the height of the #GtkPrintContext, in pixels. the height of @context a #GtkPrintContext Obtains the #GtkPageSetup that determines the page dimensions of the #GtkPrintContext. the page setup of @context a #GtkPrintContext Returns a #PangoFontMap that is suitable for use with the #GtkPrintContext. the font map of @context a #GtkPrintContext Obtains the width of the #GtkPrintContext, in pixels. the width of @context a #GtkPrintContext Sets a new cairo context on a print context. This function is intended to be used when implementing an internal print preview, it is not needed for printing, since GTK+ itself creates a suitable cairo context in that case. a #GtkPrintContext the cairo context the horizontal resolution to use with @cr the vertical resolution to use with @cr See also gtk_print_settings_set_duplex(). No duplex. Horizontal duplex. Vertical duplex. Error codes that identify various errors that can occur while using the GTK+ printing support. An unspecified error occurred. An internal error occurred. A memory allocation failed. An error occurred while loading a page setup or paper size from a key file. Registers an error quark for #GtkPrintOperation if necessary. The error quark used for #GtkPrintOperation errors. GtkPrintOperation is the high-level, portable printing API. It looks a bit different than other GTK+ dialogs such as the #GtkFileChooser, since some platforms don’t expose enough infrastructure to implement a good print dialog. On such platforms, GtkPrintOperation uses the native print dialog. On platforms which do not provide a native print dialog, GTK+ uses its own, see #GtkPrintUnixDialog. The typical way to use the high-level printing API is to create a GtkPrintOperation object with gtk_print_operation_new() when the user selects to print. Then you set some properties on it, e.g. the page size, any #GtkPrintSettings from previous print operations, the number of pages, the current page, etc. Then you start the print operation by calling gtk_print_operation_run(). It will then show a dialog, let the user select a printer and options. When the user finished the dialog various signals will be emitted on the #GtkPrintOperation, the main one being #GtkPrintOperation::draw-page, which you are supposed to catch and render the page on the provided #GtkPrintContext using Cairo. # The high-level printing API |[<!-- language="C" --> static GtkPrintSettings *settings = NULL; static void do_print (void) { GtkPrintOperation *print; GtkPrintOperationResult res; print = gtk_print_operation_new (); if (settings != NULL) gtk_print_operation_set_print_settings (print, settings); g_signal_connect (print, "begin_print", G_CALLBACK (begin_print), NULL); g_signal_connect (print, "draw_page", G_CALLBACK (draw_page), NULL); res = gtk_print_operation_run (print, GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG, GTK_WINDOW (main_window), NULL); if (res == GTK_PRINT_OPERATION_RESULT_APPLY) { if (settings != NULL) g_object_unref (settings); settings = g_object_ref (gtk_print_operation_get_print_settings (print)); } g_object_unref (print); } ]| By default GtkPrintOperation uses an external application to do print preview. To implement a custom print preview, an application must connect to the preview signal. The functions gtk_print_operation_preview_render_page(), gtk_print_operation_preview_end_preview() and gtk_print_operation_preview_is_selected() are useful when implementing a print preview. Creates a new #GtkPrintOperation. a new #GtkPrintOperation Cancels a running print operation. This function may be called from a #GtkPrintOperation::begin-print, #GtkPrintOperation::paginate or #GtkPrintOperation::draw-page signal handler to stop the currently running print operation. a #GtkPrintOperation Signalize that drawing of particular page is complete. It is called after completion of page drawing (e.g. drawing in another thread). If gtk_print_operation_set_defer_drawing() was called before, then this function has to be called by application. In another case it is called by the library itself. a #GtkPrintOperation Returns the default page setup, see gtk_print_operation_set_default_page_setup(). the default page setup a #GtkPrintOperation Gets the value of #GtkPrintOperation:embed-page-setup property. whether page setup selection combos are embedded a #GtkPrintOperation Call this when the result of a print operation is %GTK_PRINT_OPERATION_RESULT_ERROR, either as returned by gtk_print_operation_run(), or in the #GtkPrintOperation::done signal handler. The returned #GError will contain more details on what went wrong. a #GtkPrintOperation Gets the value of #GtkPrintOperation:has-selection property. whether there is a selection a #GtkPrintOperation Returns the number of pages that will be printed. Note that this value is set during print preparation phase (%GTK_PRINT_STATUS_PREPARING), so this function should never be called before the data generation phase (%GTK_PRINT_STATUS_GENERATING_DATA). You can connect to the #GtkPrintOperation::status-changed signal and call gtk_print_operation_get_n_pages_to_print() when print status is %GTK_PRINT_STATUS_GENERATING_DATA. This is typically used to track the progress of print operation. the number of pages that will be printed a #GtkPrintOperation Returns the current print settings. Note that the return value is %NULL until either gtk_print_operation_set_print_settings() or gtk_print_operation_run() have been called. the current print settings of @op. a #GtkPrintOperation Returns the status of the print operation. Also see gtk_print_operation_get_status_string(). the status of the print operation a #GtkPrintOperation Returns a string representation of the status of the print operation. The string is translated and suitable for displaying the print status e.g. in a #GtkStatusbar. Use gtk_print_operation_get_status() to obtain a status value that is suitable for programmatic use. a string representation of the status of the print operation a #GtkPrintOperation Gets the value of #GtkPrintOperation:support-selection property. whether the application supports print of selection a #GtkPrintOperation A convenience function to find out if the print operation is finished, either successfully (%GTK_PRINT_STATUS_FINISHED) or unsuccessfully (%GTK_PRINT_STATUS_FINISHED_ABORTED). Note: when you enable print status tracking the print operation can be in a non-finished state even after done has been called, as the operation status then tracks the print job status on the printer. %TRUE, if the print operation is finished. a #GtkPrintOperation Runs the print operation, by first letting the user modify print settings in the print dialog, and then print the document. Normally that this function does not return until the rendering of all pages is complete. You can connect to the #GtkPrintOperation::status-changed signal on @op to obtain some information about the progress of the print operation. Furthermore, it may use a recursive mainloop to show the print dialog. If you call gtk_print_operation_set_allow_async() or set the #GtkPrintOperation:allow-async property the operation will run asynchronously if this is supported on the platform. The #GtkPrintOperation::done signal will be emitted with the result of the operation when the it is done (i.e. when the dialog is canceled, or when the print succeeds or fails). |[<!-- language="C" --> if (settings != NULL) gtk_print_operation_set_print_settings (print, settings); if (page_setup != NULL) gtk_print_operation_set_default_page_setup (print, page_setup); g_signal_connect (print, "begin-print", G_CALLBACK (begin_print), &data); g_signal_connect (print, "draw-page", G_CALLBACK (draw_page), &data); res = gtk_print_operation_run (print, GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG, parent, &error); if (res == GTK_PRINT_OPERATION_RESULT_ERROR) { error_dialog = gtk_message_dialog_new (GTK_WINDOW (parent), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE, "Error printing file:\n%s", error->message); g_signal_connect (error_dialog, "response", G_CALLBACK (gtk_widget_destroy), NULL); gtk_widget_show (error_dialog); g_error_free (error); } else if (res == GTK_PRINT_OPERATION_RESULT_APPLY) { if (settings != NULL) g_object_unref (settings); settings = g_object_ref (gtk_print_operation_get_print_settings (print)); } ]| Note that gtk_print_operation_run() can only be called once on a given #GtkPrintOperation. the result of the print operation. A return value of %GTK_PRINT_OPERATION_RESULT_APPLY indicates that the printing was completed successfully. In this case, it is a good idea to obtain the used print settings with gtk_print_operation_get_print_settings() and store them for reuse with the next print operation. A value of %GTK_PRINT_OPERATION_RESULT_IN_PROGRESS means the operation is running asynchronously, and will emit the #GtkPrintOperation::done signal when done. a #GtkPrintOperation the action to start Transient parent of the dialog Sets whether the gtk_print_operation_run() may return before the print operation is completed. Note that some platforms may not allow asynchronous operation. a #GtkPrintOperation %TRUE to allow asynchronous operation Sets the current page. If this is called before gtk_print_operation_run(), the user will be able to select to print only the current page. Note that this only makes sense for pre-paginated documents. a #GtkPrintOperation the current page, 0-based Sets the label for the tab holding custom widgets. a #GtkPrintOperation the label to use, or %NULL to use the default label Makes @default_page_setup the default page setup for @op. This page setup will be used by gtk_print_operation_run(), but it can be overridden on a per-page basis by connecting to the #GtkPrintOperation::request-page-setup signal. a #GtkPrintOperation a #GtkPageSetup, or %NULL Sets up the #GtkPrintOperation to wait for calling of gtk_print_operation_draw_page_finish() from application. It can be used for drawing page in another thread. This function must be called in the callback of “draw-page” signal. a #GtkPrintOperation Embed page size combo box and orientation combo box into page setup page. Selected page setup is stored as default page setup in #GtkPrintOperation. a #GtkPrintOperation %TRUE to embed page setup selection in the #GtkPrintUnixDialog Sets up the #GtkPrintOperation to generate a file instead of showing the print dialog. The indended use of this function is for implementing “Export to PDF” actions. Currently, PDF is the only supported format. “Print to PDF” support is independent of this and is done by letting the user pick the “Print to PDF” item from the list of printers in the print dialog. a #GtkPrintOperation the filename for the exported file Sets whether there is a selection to print. Application has to set number of pages to which the selection will draw by gtk_print_operation_set_n_pages() in a callback of #GtkPrintOperation::begin-print. a #GtkPrintOperation %TRUE indicates that a selection exists Sets the name of the print job. The name is used to identify the job (e.g. in monitoring applications like eggcups). If you don’t set a job name, GTK+ picks a default one by numbering successive print jobs. a #GtkPrintOperation a string that identifies the print job Sets the number of pages in the document. This must be set to a positive number before the rendering starts. It may be set in a #GtkPrintOperation::begin-print signal hander. Note that the page numbers passed to the #GtkPrintOperation::request-page-setup and #GtkPrintOperation::draw-page signals are 0-based, i.e. if the user chooses to print all pages, the last ::draw-page signal will be for page @n_pages - 1. a #GtkPrintOperation the number of pages Sets the print settings for @op. This is typically used to re-establish print settings from a previous print operation, see gtk_print_operation_run(). a #GtkPrintOperation #GtkPrintSettings If @show_progress is %TRUE, the print operation will show a progress dialog during the print operation. a #GtkPrintOperation %TRUE to show a progress dialog Sets whether selection is supported by #GtkPrintOperation. a #GtkPrintOperation %TRUE to support selection If track_status is %TRUE, the print operation will try to continue report on the status of the print job in the printer queues and printer. This can allow your application to show things like “out of paper” issues, and when the print job actually reaches the printer. This function is often implemented using some form of polling, so it should not be enabled unless needed. a #GtkPrintOperation %TRUE to track status after printing Sets up the transformation for the cairo context obtained from #GtkPrintContext in such a way that distances are measured in units of @unit. a #GtkPrintOperation the unit to use If @full_page is %TRUE, the transformation for the cairo context obtained from #GtkPrintContext puts the origin at the top left corner of the page (which may not be the top left corner of the sheet, depending on page orientation and the number of pages per sheet). Otherwise, the origin is at the top left corner of the imageable area (i.e. inside the margins). a #GtkPrintOperation %TRUE to set up the #GtkPrintContext for the full page Determines whether the print operation may run asynchronously or not. Some systems don't support asynchronous printing, but those that do will return %GTK_PRINT_OPERATION_RESULT_IN_PROGRESS as the status, and emit the #GtkPrintOperation::done signal when the operation is actually done. The Windows port does not support asynchronous operation at all (this is unlikely to change). On other platforms, all actions except for %GTK_PRINT_OPERATION_ACTION_EXPORT support asynchronous operation. The current page in the document. If this is set before gtk_print_operation_run(), the user will be able to select to print only the current page. Note that this only makes sense for pre-paginated documents. Used as the label of the tab containing custom widgets. Note that this property may be ignored on some platforms. If this is %NULL, GTK+ uses a default label. The #GtkPageSetup used by default. This page setup will be used by gtk_print_operation_run(), but it can be overridden on a per-page basis by connecting to the #GtkPrintOperation::request-page-setup signal. If %TRUE, page size combo box and orientation combo box are embedded into page setup page. The name of a file to generate instead of showing the print dialog. Currently, PDF is the only supported format. The intended use of this property is for implementing “Export to PDF” actions. “Print to PDF” support is independent of this and is done by letting the user pick the “Print to PDF” item from the list of printers in the print dialog. Determines whether there is a selection in your application. This can allow your application to print the selection. This is typically used to make a "Selection" button sensitive. A string used to identify the job (e.g. in monitoring applications like eggcups). If you don't set a job name, GTK+ picks a default one by numbering successive print jobs. The number of pages in the document. This must be set to a positive number before the rendering starts. It may be set in a #GtkPrintOperation::begin-print signal hander. Note that the page numbers passed to the #GtkPrintOperation::request-page-setup and #GtkPrintOperation::draw-page signals are 0-based, i.e. if the user chooses to print all pages, the last ::draw-page signal will be for page @n_pages - 1. The number of pages that will be printed. Note that this value is set during print preparation phase (%GTK_PRINT_STATUS_PREPARING), so this value should never be get before the data generation phase (%GTK_PRINT_STATUS_GENERATING_DATA). You can connect to the #GtkPrintOperation::status-changed signal and call gtk_print_operation_get_n_pages_to_print() when print status is %GTK_PRINT_STATUS_GENERATING_DATA. This is typically used to track the progress of print operation. The #GtkPrintSettings used for initializing the dialog. Setting this property is typically used to re-establish print settings from a previous print operation, see gtk_print_operation_run(). Determines whether to show a progress dialog during the print operation. The status of the print operation. A string representation of the status of the print operation. The string is translated and suitable for displaying the print status e.g. in a #GtkStatusbar. See the #GtkPrintOperation:status property for a status value that is suitable for programmatic use. If %TRUE, the print operation will support print of selection. This allows the print dialog to show a "Selection" button. If %TRUE, the print operation will try to continue report on the status of the print job in the printer queues and printer. This can allow your application to show things like “out of paper” issues, and when the print job actually reaches the printer. However, this is often implemented using polling, and should not be enabled unless needed. The transformation for the cairo context obtained from #GtkPrintContext is set up in such a way that distances are measured in units of @unit. If %TRUE, the transformation for the cairo context obtained from #GtkPrintContext puts the origin at the top left corner of the page (which may not be the top left corner of the sheet, depending on page orientation and the number of pages per sheet). Otherwise, the origin is at the top left corner of the imageable area (i.e. inside the margins). Emitted after the user has finished changing print settings in the dialog, before the actual rendering starts. A typical use for ::begin-print is to use the parameters from the #GtkPrintContext and paginate the document accordingly, and then set the number of pages with gtk_print_operation_set_n_pages(). the #GtkPrintContext for the current operation Emitted when displaying the print dialog. If you return a widget in a handler for this signal it will be added to a custom tab in the print dialog. You typically return a container widget with multiple widgets in it. The print dialog owns the returned widget, and its lifetime is not controlled by the application. However, the widget is guaranteed to stay around until the #GtkPrintOperation::custom-widget-apply signal is emitted on the operation. Then you can read out any information you need from the widgets. A custom widget that gets embedded in the print dialog, or %NULL Emitted right before #GtkPrintOperation::begin-print if you added a custom widget in the #GtkPrintOperation::create-custom-widget handler. When you get this signal you should read the information from the custom widgets, as the widgets are not guaraneed to be around at a later time. the custom widget added in create-custom-widget Emitted when the print operation run has finished doing everything required for printing. @result gives you information about what happened during the run. If @result is %GTK_PRINT_OPERATION_RESULT_ERROR then you can call gtk_print_operation_get_error() for more information. If you enabled print status tracking then gtk_print_operation_is_finished() may still return %FALSE after #GtkPrintOperation::done was emitted. the result of the print operation Emitted for every page that is printed. The signal handler must render the @page_nr's page onto the cairo context obtained from @context using gtk_print_context_get_cairo_context(). |[<!-- language="C" --> static void draw_page (GtkPrintOperation *operation, GtkPrintContext *context, gint page_nr, gpointer user_data) { cairo_t *cr; PangoLayout *layout; gdouble width, text_height; gint layout_height; PangoFontDescription *desc; cr = gtk_print_context_get_cairo_context (context); width = gtk_print_context_get_width (context); cairo_rectangle (cr, 0, 0, width, HEADER_HEIGHT); cairo_set_source_rgb (cr, 0.8, 0.8, 0.8); cairo_fill (cr); layout = gtk_print_context_create_pango_layout (context); desc = pango_font_description_from_string ("sans 14"); pango_layout_set_font_description (layout, desc); pango_font_description_free (desc); pango_layout_set_text (layout, "some text", -1); pango_layout_set_width (layout, width * PANGO_SCALE); pango_layout_set_alignment (layout, PANGO_ALIGN_CENTER); pango_layout_get_size (layout, NULL, &layout_height); text_height = (gdouble)layout_height / PANGO_SCALE; cairo_move_to (cr, width / 2, (HEADER_HEIGHT - text_height) / 2); pango_cairo_show_layout (cr, layout); g_object_unref (layout); } ]| Use gtk_print_operation_set_use_full_page() and gtk_print_operation_set_unit() before starting the print operation to set up the transformation of the cairo context according to your needs. the #GtkPrintContext for the current operation the number of the currently printed page (0-based) Emitted after all pages have been rendered. A handler for this signal can clean up any resources that have been allocated in the #GtkPrintOperation::begin-print handler. the #GtkPrintContext for the current operation Emitted after the #GtkPrintOperation::begin-print signal, but before the actual rendering starts. It keeps getting emitted until a connected signal handler returns %TRUE. The ::paginate signal is intended to be used for paginating a document in small chunks, to avoid blocking the user interface for a long time. The signal handler should update the number of pages using gtk_print_operation_set_n_pages(), and return %TRUE if the document has been completely paginated. If you don't need to do pagination in chunks, you can simply do it all in the ::begin-print handler, and set the number of pages from there. %TRUE if pagination is complete the #GtkPrintContext for the current operation Gets emitted when a preview is requested from the native dialog. The default handler for this signal uses an external viewer application to preview. To implement a custom print preview, an application must return %TRUE from its handler for this signal. In order to use the provided @context for the preview implementation, it must be given a suitable cairo context with gtk_print_context_set_cairo_context(). The custom preview implementation can use gtk_print_operation_preview_is_selected() and gtk_print_operation_preview_render_page() to find pages which are selected for print and render them. The preview must be finished by calling gtk_print_operation_preview_end_preview() (typically in response to the user clicking a close button). %TRUE if the listener wants to take over control of the preview the #GtkPrintOperationPreview for the current operation the #GtkPrintContext that will be used the #GtkWindow to use as window parent, or %NULL Emitted once for every page that is printed, to give the application a chance to modify the page setup. Any changes done to @setup will be in force only for printing this page. the #GtkPrintContext for the current operation the number of the currently printed page (0-based) the #GtkPageSetup Emitted at between the various phases of the print operation. See #GtkPrintStatus for the phases that are being discriminated. Use gtk_print_operation_get_status() to find out the current status. Emitted after change of selected printer. The actual page setup and print settings are passed to the custom widget, which can actualize itself according to this change. the custom widget added in create-custom-widget actual page setup actual print settings The @action parameter to gtk_print_operation_run() determines what action the print operation should perform. Show the print dialog. Start to print without showing the print dialog, based on the current print settings. Show the print preview. Export to a file. This requires the export-filename property to be set. The parent class. Ends a preview. This function must be called to finish a custom print preview. a #GtkPrintOperationPreview Returns whether the given page is included in the set of pages that have been selected for printing. %TRUE if the page has been selected for printing a #GtkPrintOperationPreview a page number Renders a page to the preview, using the print context that was passed to the #GtkPrintOperation::preview handler together with @preview. A custom iprint preview should use this function in its ::expose handler to render the currently selected page. Note that this function requires a suitable cairo context to be associated with the print context. a #GtkPrintOperationPreview the page to render Ends a preview. This function must be called to finish a custom print preview. a #GtkPrintOperationPreview Returns whether the given page is included in the set of pages that have been selected for printing. %TRUE if the page has been selected for printing a #GtkPrintOperationPreview a page number Renders a page to the preview, using the print context that was passed to the #GtkPrintOperation::preview handler together with @preview. A custom iprint preview should use this function in its ::expose handler to render the currently selected page. Note that this function requires a suitable cairo context to be associated with the print context. a #GtkPrintOperationPreview the page to render The ::got-page-size signal is emitted once for each page that gets rendered to the preview. A handler for this signal should update the @context according to @page_setup and set up a suitable cairo context, using gtk_print_context_set_cairo_context(). the current #GtkPrintContext the #GtkPageSetup for the current page The ::ready signal gets emitted once per preview operation, before the first page is rendered. A handler for this signal can be used for setup tasks. the current #GtkPrintContext a #GtkPrintOperationPreview the page to render %TRUE if the page has been selected for printing a #GtkPrintOperationPreview a page number a #GtkPrintOperationPreview A value of this type is returned by gtk_print_operation_run(). An error has occurred. The print settings should be stored. The print operation has been canceled, the print settings should not be stored. The print operation is not complete yet. This value will only be returned when running asynchronously. See also gtk_print_job_set_pages() All pages. Current page. Range of pages. Selected pages. See also gtk_print_settings_set_quality(). Low quality. Normal quality. High quality. Draft quality. A GtkPrintSettings object represents the settings of a print dialog in a system-independent way. The main use for this object is that once you’ve printed you can get a settings object that represents the settings the user chose, and the next time you print you can pass that object in so that the user doesn’t have to re-set all his settings. Its also possible to enumerate the settings so that you can easily save the settings for the next time your app runs, or even store them in a document. The predefined keys try to use shared values as much as possible so that moving such a document between systems still works. Printing support was added in GTK+ 2.10. Creates a new #GtkPrintSettings object. a new #GtkPrintSettings object Reads the print settings from @file_name. Returns a new #GtkPrintSettings object with the restored settings, or %NULL if an error occurred. If the file could not be loaded then error is set to either a #GFileError or #GKeyFileError. See gtk_print_settings_to_file(). the restored #GtkPrintSettings the filename to read the settings from Deserialize print settings from an a{sv} variant in the format produced by gtk_print_settings_to_gvariant(). a new #GtkPrintSettings object an a{sv} #GVariant Reads the print settings from the group @group_name in @key_file. Returns a new #GtkPrintSettings object with the restored settings, or %NULL if an error occurred. If the file could not be loaded then error is set to either a #GFileError or #GKeyFileError. the restored #GtkPrintSettings the #GKeyFile to retrieve the settings from the name of the group to use, or %NULL to use the default “Print Settings” Copies a #GtkPrintSettings object. a newly allocated copy of @other a #GtkPrintSettings Calls @func for each key-value pair of @settings. a #GtkPrintSettings the function to call user data for @func Looks up the string value associated with @key. the string value for @key a #GtkPrintSettings a key Returns the boolean represented by the value that is associated with @key. The string “true” represents %TRUE, any other string %FALSE. %TRUE, if @key maps to a true value. a #GtkPrintSettings a key Gets the value of %GTK_PRINT_SETTINGS_COLLATE. whether to collate the printed pages a #GtkPrintSettings Gets the value of %GTK_PRINT_SETTINGS_DEFAULT_SOURCE. the default source a #GtkPrintSettings Gets the value of %GTK_PRINT_SETTINGS_DITHER. the dithering that is used a #GtkPrintSettings Returns the double value associated with @key, or 0. the double value of @key a #GtkPrintSettings a key Returns the floating point number represented by the value that is associated with @key, or @default_val if the value does not represent a floating point number. Floating point numbers are parsed with g_ascii_strtod(). the floating point number associated with @key a #GtkPrintSettings a key the default value Gets the value of %GTK_PRINT_SETTINGS_DUPLEX. whether to print the output in duplex. a #GtkPrintSettings Gets the value of %GTK_PRINT_SETTINGS_FINISHINGS. the finishings a #GtkPrintSettings Returns the integer value of @key, or 0. the integer value of @key a #GtkPrintSettings a key Returns the value of @key, interpreted as an integer, or the default value. the integer value of @key a #GtkPrintSettings a key the default value Returns the value associated with @key, interpreted as a length. The returned value is converted to @units. the length value of @key, converted to @unit a #GtkPrintSettings a key the unit of the return value Gets the value of %GTK_PRINT_SETTINGS_MEDIA_TYPE. The set of media types is defined in PWG 5101.1-2002 PWG. the media type a #GtkPrintSettings Gets the value of %GTK_PRINT_SETTINGS_N_COPIES. the number of copies to print a #GtkPrintSettings Gets the value of %GTK_PRINT_SETTINGS_NUMBER_UP. the number of pages per sheet a #GtkPrintSettings Gets the value of %GTK_PRINT_SETTINGS_NUMBER_UP_LAYOUT. layout of page in number-up mode a #GtkPrintSettings Get the value of %GTK_PRINT_SETTINGS_ORIENTATION, converted to a #GtkPageOrientation. the orientation a #GtkPrintSettings Gets the value of %GTK_PRINT_SETTINGS_OUTPUT_BIN. the output bin a #GtkPrintSettings Gets the value of %GTK_PRINT_SETTINGS_PAGE_RANGES. an array of #GtkPageRanges. Use g_free() to free the array when it is no longer needed. a #GtkPrintSettings return location for the length of the returned array Gets the value of %GTK_PRINT_SETTINGS_PAGE_SET. the set of pages to print a #GtkPrintSettings Gets the value of %GTK_PRINT_SETTINGS_PAPER_HEIGHT, converted to @unit. the paper height, in units of @unit a #GtkPrintSettings the unit for the return value Gets the value of %GTK_PRINT_SETTINGS_PAPER_FORMAT, converted to a #GtkPaperSize. the paper size a #GtkPrintSettings Gets the value of %GTK_PRINT_SETTINGS_PAPER_WIDTH, converted to @unit. the paper width, in units of @unit a #GtkPrintSettings the unit for the return value Gets the value of %GTK_PRINT_SETTINGS_PRINT_PAGES. which pages to print a #GtkPrintSettings Convenience function to obtain the value of %GTK_PRINT_SETTINGS_PRINTER. the printer name a #GtkPrintSettings Gets the value of %GTK_PRINT_SETTINGS_PRINTER_LPI. the resolution in lpi (lines per inch) a #GtkPrintSettings Gets the value of %GTK_PRINT_SETTINGS_QUALITY. the print quality a #GtkPrintSettings Gets the value of %GTK_PRINT_SETTINGS_RESOLUTION. the resolution in dpi a #GtkPrintSettings Gets the value of %GTK_PRINT_SETTINGS_RESOLUTION_X. the horizontal resolution in dpi a #GtkPrintSettings Gets the value of %GTK_PRINT_SETTINGS_RESOLUTION_Y. the vertical resolution in dpi a #GtkPrintSettings Gets the value of %GTK_PRINT_SETTINGS_REVERSE. whether to reverse the order of the printed pages a #GtkPrintSettings Gets the value of %GTK_PRINT_SETTINGS_SCALE. the scale in percent a #GtkPrintSettings Gets the value of %GTK_PRINT_SETTINGS_USE_COLOR. whether to use color a #GtkPrintSettings Returns %TRUE, if a value is associated with @key. %TRUE, if @key has a value a #GtkPrintSettings a key Reads the print settings from @file_name. If the file could not be loaded then error is set to either a #GFileError or #GKeyFileError. See gtk_print_settings_to_file(). %TRUE on success a #GtkPrintSettings the filename to read the settings from Reads the print settings from the group @group_name in @key_file. If the file could not be loaded then error is set to either a #GFileError or #GKeyFileError. %TRUE on success a #GtkPrintSettings the #GKeyFile to retrieve the settings from the name of the group to use, or %NULL to use the default “Print Settings” Associates @value with @key. a #GtkPrintSettings a key a string value, or %NULL Sets @key to a boolean value. a #GtkPrintSettings a key a boolean Sets the value of %GTK_PRINT_SETTINGS_COLLATE. a #GtkPrintSettings whether to collate the output Sets the value of %GTK_PRINT_SETTINGS_DEFAULT_SOURCE. a #GtkPrintSettings the default source Sets the value of %GTK_PRINT_SETTINGS_DITHER. a #GtkPrintSettings the dithering that is used Sets @key to a double value. a #GtkPrintSettings a key a double value Sets the value of %GTK_PRINT_SETTINGS_DUPLEX. a #GtkPrintSettings a #GtkPrintDuplex value Sets the value of %GTK_PRINT_SETTINGS_FINISHINGS. a #GtkPrintSettings the finishings Sets @key to an integer value. a #GtkPrintSettings a key an integer Associates a length in units of @unit with @key. a #GtkPrintSettings a key a length the unit of @length Sets the value of %GTK_PRINT_SETTINGS_MEDIA_TYPE. The set of media types is defined in PWG 5101.1-2002 PWG. a #GtkPrintSettings the media type Sets the value of %GTK_PRINT_SETTINGS_N_COPIES. a #GtkPrintSettings the number of copies Sets the value of %GTK_PRINT_SETTINGS_NUMBER_UP. a #GtkPrintSettings the number of pages per sheet Sets the value of %GTK_PRINT_SETTINGS_NUMBER_UP_LAYOUT. a #GtkPrintSettings a #GtkNumberUpLayout value Sets the value of %GTK_PRINT_SETTINGS_ORIENTATION. a #GtkPrintSettings a page orientation Sets the value of %GTK_PRINT_SETTINGS_OUTPUT_BIN. a #GtkPrintSettings the output bin Sets the value of %GTK_PRINT_SETTINGS_PAGE_RANGES. a #GtkPrintSettings an array of #GtkPageRanges the length of @page_ranges Sets the value of %GTK_PRINT_SETTINGS_PAGE_SET. a #GtkPrintSettings a #GtkPageSet value Sets the value of %GTK_PRINT_SETTINGS_PAPER_HEIGHT. a #GtkPrintSettings the paper height the units of @height Sets the value of %GTK_PRINT_SETTINGS_PAPER_FORMAT, %GTK_PRINT_SETTINGS_PAPER_WIDTH and %GTK_PRINT_SETTINGS_PAPER_HEIGHT. a #GtkPrintSettings a paper size Sets the value of %GTK_PRINT_SETTINGS_PAPER_WIDTH. a #GtkPrintSettings the paper width the units of @width Sets the value of %GTK_PRINT_SETTINGS_PRINT_PAGES. a #GtkPrintSettings a #GtkPrintPages value Convenience function to set %GTK_PRINT_SETTINGS_PRINTER to @printer. a #GtkPrintSettings the printer name Sets the value of %GTK_PRINT_SETTINGS_PRINTER_LPI. a #GtkPrintSettings the resolution in lpi (lines per inch) Sets the value of %GTK_PRINT_SETTINGS_QUALITY. a #GtkPrintSettings a #GtkPrintQuality value Sets the values of %GTK_PRINT_SETTINGS_RESOLUTION, %GTK_PRINT_SETTINGS_RESOLUTION_X and %GTK_PRINT_SETTINGS_RESOLUTION_Y. a #GtkPrintSettings the resolution in dpi Sets the values of %GTK_PRINT_SETTINGS_RESOLUTION, %GTK_PRINT_SETTINGS_RESOLUTION_X and %GTK_PRINT_SETTINGS_RESOLUTION_Y. a #GtkPrintSettings the horizontal resolution in dpi the vertical resolution in dpi Sets the value of %GTK_PRINT_SETTINGS_REVERSE. a #GtkPrintSettings whether to reverse the output Sets the value of %GTK_PRINT_SETTINGS_SCALE. a #GtkPrintSettings the scale in percent Sets the value of %GTK_PRINT_SETTINGS_USE_COLOR. a #GtkPrintSettings whether to use color This function saves the print settings from @settings to @file_name. If the file could not be loaded then error is set to either a #GFileError or #GKeyFileError. %TRUE on success a #GtkPrintSettings the file to save to Serialize print settings to an a{sv} variant. a new, floating, #GVariant a #GtkPrintSettings This function adds the print settings from @settings to @key_file. a #GtkPrintSettings the #GKeyFile to save the print settings to the group to add the settings to in @key_file, or %NULL to use the default “Print Settings” Removes any value associated with @key. This has the same effect as setting the value to %NULL. a #GtkPrintSettings a key The status gives a rough indication of the completion of a running print operation. The printing has not started yet; this status is set initially, and while the print dialog is shown. This status is set while the begin-print signal is emitted and during pagination. This status is set while the pages are being rendered. The print job is being sent off to the printer. The print job has been sent to the printer, but is not printed for some reason, e.g. the printer may be stopped. Some problem has occurred during printing, e.g. a paper jam. The printer is processing the print job. The printing has been completed successfully. The printing has been aborted. The #GtkProgressBar is typically used to display the progress of a long running operation. It provides a visual clue that processing is underway. The GtkProgressBar can be used in two different modes: percentage mode and activity mode. When an application can determine how much work needs to take place (e.g. read a fixed number of bytes from a file) and can monitor its progress, it can use the GtkProgressBar in percentage mode and the user sees a growing bar indicating the percentage of the work that has been completed. In this mode, the application is required to call gtk_progress_bar_set_fraction() periodically to update the progress bar. When an application has no accurate way of knowing the amount of work to do, it can use the #GtkProgressBar in activity mode, which shows activity by a block moving back and forth within the progress area. In this mode, the application is required to call gtk_progress_bar_pulse() periodically to update the progress bar. There is quite a bit of flexibility provided to control the appearance of the #GtkProgressBar. Functions are provided to control the orientation of the bar, optional text can be displayed along with the bar, and the step size used in activity mode can be set. # CSS nodes |[<!-- language="plain" --> progressbar[.osd] ├── [text] ╰── trough[.empty][.full] ╰── progress[.pulse] ]| GtkProgressBar has a main CSS node with name progressbar and subnodes with names text and trough, of which the latter has a subnode named progress. The text subnode is only present if text is shown. The progress subnode has the style class .pulse when in activity mode. It gets the style classes .left, .right, .top or .bottom added when the progress 'touches' the corresponding end of the GtkProgressBar. The .osd class on the progressbar node is for use in overlays like the one Epiphany has for page loading progress. Creates a new #GtkProgressBar. a #GtkProgressBar. Returns the ellipsizing position of the progress bar. See gtk_progress_bar_set_ellipsize(). #PangoEllipsizeMode a #GtkProgressBar Returns the current fraction of the task that’s been completed. a fraction from 0.0 to 1.0 a #GtkProgressBar Gets the value set by gtk_progress_bar_set_inverted(). %TRUE if the progress bar is inverted a #GtkProgressBar Retrieves the pulse step set with gtk_progress_bar_set_pulse_step(). a fraction from 0.0 to 1.0 a #GtkProgressBar Gets the value of the #GtkProgressBar:show-text property. See gtk_progress_bar_set_show_text(). %TRUE if text is shown in the progress bar a #GtkProgressBar Retrieves the text that is displayed with the progress bar, if any, otherwise %NULL. The return value is a reference to the text, not a copy of it, so will become invalid if you change the text in the progress bar. text, or %NULL; this string is owned by the widget and should not be modified or freed. a #GtkProgressBar Indicates that some progress has been made, but you don’t know how much. Causes the progress bar to enter “activity mode,” where a block bounces back and forth. Each call to gtk_progress_bar_pulse() causes the block to move by a little bit (the amount of movement per pulse is determined by gtk_progress_bar_set_pulse_step()). a #GtkProgressBar Sets the mode used to ellipsize (add an ellipsis: "...") the text if there is not enough space to render the entire string. a #GtkProgressBar a #PangoEllipsizeMode Causes the progress bar to “fill in” the given fraction of the bar. The fraction should be between 0.0 and 1.0, inclusive. a #GtkProgressBar fraction of the task that’s been completed Progress bars normally grow from top to bottom or left to right. Inverted progress bars grow in the opposite direction. a #GtkProgressBar %TRUE to invert the progress bar Sets the fraction of total progress bar length to move the bouncing block for each call to gtk_progress_bar_pulse(). a #GtkProgressBar fraction between 0.0 and 1.0 Sets whether the progress bar will show text next to the bar. The shown text is either the value of the #GtkProgressBar:text property or, if that is %NULL, the #GtkProgressBar:fraction value, as a percentage. To make a progress bar that is styled and sized suitably for containing text (even if the actual text is blank), set #GtkProgressBar:show-text to %TRUE and #GtkProgressBar:text to the empty string (not %NULL). a #GtkProgressBar whether to show text Causes the given @text to appear next to the progress bar. If @text is %NULL and #GtkProgressBar:show-text is %TRUE, the current value of #GtkProgressBar:fraction will be displayed as a percentage. If @text is non-%NULL and #GtkProgressBar:show-text is %TRUE, the text will be displayed. In this case, it will not display the progress percentage. If @text is the empty string, the progress bar will still be styled and sized suitably for containing text, as long as #GtkProgressBar:show-text is %TRUE. a #GtkProgressBar a UTF-8 string, or %NULL The preferred place to ellipsize the string, if the progress bar does not have enough room to display the entire string, specified as a #PangoEllipsizeMode. Note that setting this property to a value other than %PANGO_ELLIPSIZE_NONE has the side-effect that the progress bar requests only enough space to display the ellipsis ("..."). Another means to set a progress bar's width is gtk_widget_set_size_request(). Sets whether the progress bar will show a text in addition to the bar itself. The shown text is either the value of the #GtkProgressBar:text property or, if that is %NULL, the #GtkProgressBar:fraction value, as a percentage. To make a progress bar that is styled and sized suitably for showing text (even if the actual text is blank), set #GtkProgressBar:show-text to %TRUE and #GtkProgressBar:text to the empty string (not %NULL). Describes the stage at which events are fed into a #GtkEventController. Events are not delivered automatically. Those can be manually fed through gtk_event_controller_handle_event(). This should only be used when full control about when, or whether the controller handles the event is needed. Events are delivered in the capture phase. The capture phase happens before the bubble phase, runs from the toplevel down to the event widget. This option should only be used on containers that might possibly handle events before their children do. Events are delivered in the bubble phase. The bubble phase happens after the capture phase, and before the default handlers are run. This phase runs from the event widget, up to the toplevel. Events are delivered in the default widget event handlers, note that widget implementations must chain up on button, motion, touch and grab broken handlers for controllers in this phase to be run. A #GtkRadioAction is similar to #GtkRadioMenuItem. A number of radio actions can be linked together so that only one may be active at any one time. Creates a new #GtkRadioAction object. To add the action to a #GtkActionGroup and set the accelerator for the action, call gtk_action_group_add_action_with_accel(). a new #GtkRadioAction A unique name for the action The label displayed in menu items and on buttons, or %NULL A tooltip for this action, or %NULL The stock icon to display in widgets representing this action, or %NULL The value which gtk_radio_action_get_current_value() should return if this action is selected. Obtains the value property of the currently active member of the group to which @action belongs. The value of the currently active group member a #GtkRadioAction Returns the list representing the radio group for this object. Note that the returned list is only valid until the next change to the group. A common way to set up a group of radio group is the following: |[<!-- language="C" --> GSList *group = NULL; GtkRadioAction *action; while ( ...more actions to add... /) { action = gtk_radio_action_new (...); gtk_radio_action_set_group (action, group); group = gtk_radio_action_get_group (action); } ]| the list representing the radio group for this object the action object Joins a radio action object to the group of another radio action object. Use this in language bindings instead of the gtk_radio_action_get_group() and gtk_radio_action_set_group() methods A common way to set up a group of radio actions is the following: |[<!-- language="C" --> GtkRadioAction *action; GtkRadioAction *last_action; while ( ...more actions to add... /) { action = gtk_radio_action_new (...); gtk_radio_action_join_group (action, last_action); last_action = action; } ]| the action object a radio action object whos group we are joining, or %NULL to remove the radio action from its group Sets the currently active group member to the member with value property @current_value. a #GtkRadioAction the new value Sets the radio group for the radio action object. the action object a list representing a radio group, or %NULL The value property of the currently active member of the group to which this action belongs. Sets a new group for a radio action. The value is an arbitrary integer which can be used as a convenient way to determine which action in the group is currently active in an ::activate or ::changed signal handler. See gtk_radio_action_get_current_value() and #GtkRadioActionEntry for convenient ways to get and set this property. The ::changed signal is emitted on every member of a radio group when the active member is changed. The signal gets emitted after the ::activate signals for the previous and current active members. the member of @action's group which has just been activated #GtkRadioActionEntry structs are used with gtk_action_group_add_radio_actions() to construct groups of radio actions. The name of the action. The stock id for the action, or the name of an icon from the icon theme. The label for the action. This field should typically be marked for translation, see gtk_action_group_set_translation_domain(). The accelerator for the action, in the format understood by gtk_accelerator_parse(). The tooltip for the action. This field should typically be marked for translation, see gtk_action_group_set_translation_domain(). The value to set on the radio action. See gtk_radio_action_get_current_value(). A single radio button performs the same basic function as a #GtkCheckButton, as its position in the object hierarchy reflects. It is only when multiple radio buttons are grouped together that they become a different user interface component in their own right. Every radio button is a member of some group of radio buttons. When one is selected, all other radio buttons in the same group are deselected. A #GtkRadioButton is one way of giving the user a choice from many options. Radio button widgets are created with gtk_radio_button_new(), passing %NULL as the argument if this is the first radio button in a group. In subsequent calls, the group you wish to add this button to should be passed as an argument. Optionally, gtk_radio_button_new_with_label() can be used if you want a text label on the radio button. Alternatively, when adding widgets to an existing group of radio buttons, use gtk_radio_button_new_from_widget() with a #GtkRadioButton that already has a group assigned to it. The convenience function gtk_radio_button_new_with_label_from_widget() is also provided. To retrieve the group a #GtkRadioButton is assigned to, use gtk_radio_button_get_group(). To remove a #GtkRadioButton from one group and make it part of a new one, use gtk_radio_button_set_group(). The group list does not need to be freed, as each #GtkRadioButton will remove itself and its list item when it is destroyed. # CSS nodes |[<!-- language="plain" --> radiobutton ├── radio ╰── <child> ]| A GtkRadioButton with indicator (see gtk_toggle_button_set_mode()) has a main CSS node with name radiobutton and a subnode with name radio. |[<!-- language="plain" --> button.radio ├── radio ╰── <child> ]| A GtkRadioButton without indicator changes the name of its main node to button and adds a .radio style class to it. The subnode is invisible in this case. ## How to create a group of two radio buttons. |[<!-- language="C" --> void create_radio_buttons (void) { GtkWidget *window, *radio1, *radio2, *box, *entry; window = gtk_window_new (GTK_WINDOW_TOPLEVEL); box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2); gtk_box_set_homogeneous (GTK_BOX (box), TRUE); // Create a radio button with a GtkEntry widget radio1 = gtk_radio_button_new (NULL); entry = gtk_entry_new (); gtk_container_add (GTK_CONTAINER (radio1), entry); // Create a radio button with a label radio2 = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (radio1), "I’m the second radio button."); // Pack them into a box, then show all the widgets gtk_box_pack_start (GTK_BOX (box), radio1); gtk_box_pack_start (GTK_BOX (box), radio2); gtk_container_add (GTK_CONTAINER (window), box); gtk_widget_show_all (window); return; } ]| When an unselected button in the group is clicked the clicked button receives the #GtkToggleButton::toggled signal, as does the previously selected button. Inside the #GtkToggleButton::toggled handler, gtk_toggle_button_get_active() can be used to determine if the button has been selected or deselected. Creates a new #GtkRadioButton. To be of any practical value, a widget should then be packed into the radio button. a new radio button an existing radio button group, or %NULL if you are creating a new group. Creates a new #GtkRadioButton, adding it to the same group as @radio_group_member. As with gtk_radio_button_new(), a widget should be packed into the radio button. a new radio button. an existing #GtkRadioButton. Creates a new #GtkRadioButton with a text label. a new radio button. an existing radio button group, or %NULL if you are creating a new group. the text label to display next to the radio button. Creates a new #GtkRadioButton with a text label, adding it to the same group as @radio_group_member. a new radio button. widget to get radio group from or %NULL a text string to display next to the radio button. Creates a new #GtkRadioButton containing a label, adding it to the same group as @group. The label will be created using gtk_label_new_with_mnemonic(), so underscores in @label indicate the mnemonic for the button. a new #GtkRadioButton the radio button group, or %NULL the text of the button, with an underscore in front of the mnemonic character Creates a new #GtkRadioButton containing a label. The label will be created using gtk_label_new_with_mnemonic(), so underscores in @label indicate the mnemonic for the button. a new #GtkRadioButton widget to get radio group from or %NULL the text of the button, with an underscore in front of the mnemonic character Retrieves the group assigned to a radio button. a linked list containing all the radio buttons in the same group as @radio_button. The returned list is owned by the radio button and must not be modified or freed. a #GtkRadioButton. Joins a #GtkRadioButton object to the group of another #GtkRadioButton object Use this in language bindings instead of the gtk_radio_button_get_group() and gtk_radio_button_set_group() methods A common way to set up a group of radio buttons is the following: |[<!-- language="C" --> GtkRadioButton *radio_button; GtkRadioButton *last_button; while (some_condition) { radio_button = gtk_radio_button_new (NULL); gtk_radio_button_join_group (radio_button, last_button); last_button = radio_button; } ]| the #GtkRadioButton object a radio button object whos group we are joining, or %NULL to remove the radio button from its group Sets a #GtkRadioButton’s group. It should be noted that this does not change the layout of your interface in any way, so if you are changing the group, it is likely you will need to re-arrange the user interface to reflect these changes. a #GtkRadioButton. an existing radio button group, such as one returned from gtk_radio_button_get_group(), or %NULL. Sets a new group for a radio button. Emitted when the group of radio buttons that a radio button belongs to changes. This is emitted when a radio button switches from being alone to being part of a group of 2 or more buttons, or vice-versa, and when a button is moved from one group of 2 or more buttons to a different one, but not when the composition of the group that a button belongs to changes. A radio menu item is a check menu item that belongs to a group. At each instant exactly one of the radio menu items from a group is selected. The group list does not need to be freed, as each #GtkRadioMenuItem will remove itself and its list item when it is destroyed. The correct way to create a group of radio menu items is approximatively this: ## How to create a group of radio menu items. |[<!-- language="C" --> GSList *group = NULL; GtkWidget *item; gint i; for (i = 0; i < 5; i++) { item = gtk_radio_menu_item_new_with_label (group, "This is an example"); group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (item)); if (i == 1) gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (item), TRUE); } ]| # CSS nodes |[<!-- language="plain" --> menuitem ├── radio.left ╰── <child> ]| GtkRadioMenuItem has a main CSS node with name menuitem, and a subnode with name radio, which gets the .left or .right style class. Creates a new #GtkRadioMenuItem. a new #GtkRadioMenuItem the group to which the radio menu item is to be attached, or %NULL Creates a new #GtkRadioMenuItem adding it to the same group as @group. The new #GtkRadioMenuItem An existing #GtkRadioMenuItem Creates a new #GtkRadioMenuItem whose child is a simple #GtkLabel. A new #GtkRadioMenuItem group the radio menu item is inside, or %NULL the text for the label Creates a new GtkRadioMenuItem whose child is a simple GtkLabel. The new #GtkRadioMenuItem is added to the same group as @group. The new #GtkRadioMenuItem an existing #GtkRadioMenuItem the text for the label Creates a new #GtkRadioMenuItem containing a label. The label will be created using gtk_label_new_with_mnemonic(), so underscores in @label indicate the mnemonic for the menu item. a new #GtkRadioMenuItem group the radio menu item is inside, or %NULL the text of the button, with an underscore in front of the mnemonic character Creates a new GtkRadioMenuItem containing a label. The label will be created using gtk_label_new_with_mnemonic(), so underscores in label indicate the mnemonic for the menu item. The new #GtkRadioMenuItem is added to the same group as @group. The new #GtkRadioMenuItem An existing #GtkRadioMenuItem the text of the button, with an underscore in front of the mnemonic character Returns the group to which the radio menu item belongs, as a #GList of #GtkRadioMenuItem. The list belongs to GTK+ and should not be freed. the group of @radio_menu_item a #GtkRadioMenuItem Joins a #GtkRadioMenuItem object to the group of another #GtkRadioMenuItem object. This function should be used by language bindings to avoid the memory manangement of the opaque #GSList of gtk_radio_menu_item_get_group() and gtk_radio_menu_item_set_group(). A common way to set up a group of #GtkRadioMenuItem instances is: |[ GtkRadioMenuItem *last_item = NULL; while ( ...more items to add... ) { GtkRadioMenuItem *radio_item; radio_item = gtk_radio_menu_item_new (...); gtk_radio_menu_item_join_group (radio_item, last_item); last_item = radio_item; } ]| a #GtkRadioMenuItem a #GtkRadioMenuItem whose group we are joining, or %NULL to remove the @radio_menu_item from its current group Sets the group of a radio menu item, or changes it. a #GtkRadioMenuItem. the new group, or %NULL. The radio menu item whose group this widget belongs to. A #GtkRadioToolButton is a #GtkToolItem that contains a radio button, that is, a button that is part of a group of toggle buttons where only one button can be active at a time. Use gtk_radio_tool_button_new() to create a new GtkRadioToolButton. Use gtk_radio_tool_button_new_from_widget() to create a new GtkRadioToolButton that is part of the same group as an existing GtkRadioToolButton. # CSS nodes GtkRadioToolButton has a single CSS node with name toolbutton. Creates a new #GtkRadioToolButton, adding it to @group. The new #GtkRadioToolButton An existing radio button group, or %NULL if you are creating a new group Creates a new #GtkRadioToolButton, adding it to @group. The new #GtkRadioToolButton will contain an icon and label from the stock item indicated by @stock_id. Use gtk_radio_tool_button_new() instead. The new #GtkRadioToolButton an existing radio button group, or %NULL if you are creating a new group the name of a stock item Creates a new #GtkRadioToolButton adding it to the same group as @gruup The new #GtkRadioToolButton An existing #GtkRadioToolButton, or %NULL Creates a new #GtkRadioToolButton adding it to the same group as @group. The new #GtkRadioToolButton will contain an icon and label from the stock item indicated by @stock_id. gtk_radio_tool_button_new_from_widget A new #GtkRadioToolButton An existing #GtkRadioToolButton. the name of a stock item Returns the radio button group @button belongs to. The group @button belongs to. a #GtkRadioToolButton Adds @button to @group, removing it from the group it belonged to before. a #GtkRadioToolButton an existing radio button group, or %NULL Sets a new group for a radio tool button. #GtkRange is the common base class for widgets which visualize an adjustment, e.g #GtkScale or #GtkScrollbar. Apart from signals for monitoring the parameters of the adjustment, #GtkRange provides properties and methods for influencing the sensitivity of the “steppers”. It also provides properties and methods for setting a “fill level” on range widgets. See gtk_range_set_fill_level(). Get the #GtkAdjustment which is the “model” object for #GtkRange. See gtk_range_set_adjustment() for details. The return value does not have a reference added, so should not be unreferenced. a #GtkAdjustment a #GtkRange Gets the current position of the fill level indicator. The current fill level A #GtkRange Gets the value set by gtk_range_set_flippable(). %TRUE if the range is flippable a #GtkRange Gets the value set by gtk_range_set_inverted(). %TRUE if the range is inverted a #GtkRange Gets the sensitivity policy for the stepper that points to the 'lower' end of the GtkRange’s adjustment. The lower stepper’s sensitivity policy. a #GtkRange This function is useful mainly for #GtkRange subclasses. See gtk_range_set_min_slider_size(). Use the min-height/min-width CSS properties on the slider node. The minimum size of the range’s slider. a #GtkRange This function returns the area that contains the range’s trough and its steppers, in widget->window coordinates. This function is useful mainly for #GtkRange subclasses. a #GtkRange return location for the range rectangle Gets whether the range is restricted to the fill level. %TRUE if @range is restricted to the fill level. A #GtkRange Gets the number of digits to round the value to when it changes. See #GtkRange::change-value. the number of digits to round to a #GtkRange Gets whether the range displays the fill level graphically. %TRUE if @range shows the fill level. A #GtkRange This function returns sliders range along the long dimension, in widget->window coordinates. This function is useful mainly for #GtkRange subclasses. a #GtkRange return location for the slider's start, or %NULL return location for the slider's end, or %NULL This function is useful mainly for #GtkRange subclasses. See gtk_range_set_slider_size_fixed(). whether the range’s slider has a fixed size. a #GtkRange Gets the sensitivity policy for the stepper that points to the 'upper' end of the GtkRange’s adjustment. The upper stepper’s sensitivity policy. a #GtkRange Gets the current value of the range. current value of the range. a #GtkRange Sets the adjustment to be used as the “model” object for this range widget. The adjustment indicates the current range value, the minimum and maximum range values, the step/page increments used for keybindings and scrolling, and the page size. The page size is normally 0 for #GtkScale and nonzero for #GtkScrollbar, and indicates the size of the visible area of the widget being scrolled. The page size affects the size of the scrollbar slider. a #GtkRange a #GtkAdjustment Set the new position of the fill level indicator. The “fill level” is probably best described by its most prominent use case, which is an indicator for the amount of pre-buffering in a streaming media player. In that use case, the value of the range would indicate the current play position, and the fill level would be the position up to which the file/stream has been downloaded. This amount of prebuffering can be displayed on the range’s trough and is themeable separately from the trough. To enable fill level display, use gtk_range_set_show_fill_level(). The range defaults to not showing the fill level. Additionally, it’s possible to restrict the range’s slider position to values which are smaller than the fill level. This is controller by gtk_range_set_restrict_to_fill_level() and is by default enabled. a #GtkRange the new position of the fill level indicator If a range is flippable, it will switch its direction if it is horizontal and its direction is %GTK_TEXT_DIR_RTL. See gtk_widget_get_direction(). a #GtkRange %TRUE to make the range flippable Sets the step and page sizes for the range. The step size is used when the user clicks the #GtkScrollbar arrows or moves #GtkScale via arrow keys. The page size is used for example when moving via Page Up or Page Down keys. a #GtkRange step size page size Ranges normally move from lower to higher values as the slider moves from top to bottom or left to right. Inverted ranges have higher values at the top or on the right rather than on the bottom or left. a #GtkRange %TRUE to invert the range Sets the sensitivity policy for the stepper that points to the 'lower' end of the GtkRange’s adjustment. a #GtkRange the lower stepper’s sensitivity policy. Sets the minimum size of the range’s slider. This function is useful mainly for #GtkRange subclasses. Use the min-height/min-width CSS properties on the slider node. a #GtkRange The slider’s minimum size Sets the allowable values in the #GtkRange, and clamps the range value to be between @min and @max. (If the range has a non-zero page size, it is clamped between @min and @max - page-size.) a #GtkRange minimum range value maximum range value Sets whether the slider is restricted to the fill level. See gtk_range_set_fill_level() for a general description of the fill level concept. A #GtkRange Whether the fill level restricts slider movement. Sets the number of digits to round the value to when it changes. See #GtkRange::change-value. a #GtkRange the precision in digits, or -1 Sets whether a graphical fill level is show on the trough. See gtk_range_set_fill_level() for a general description of the fill level concept. A #GtkRange Whether a fill level indicator graphics is shown. Sets whether the range’s slider has a fixed size, or a size that depends on its adjustment’s page size. This function is useful mainly for #GtkRange subclasses. a #GtkRange %TRUE to make the slider size constant Sets the sensitivity policy for the stepper that points to the 'upper' end of the GtkRange’s adjustment. a #GtkRange the upper stepper’s sensitivity policy. Sets the current value of the range; if the value is outside the minimum or maximum range values, it will be clamped to fit inside them. The range emits the #GtkRange::value-changed signal if the value changes. a #GtkRange new value of the range The fill level (e.g. prebuffering of a network stream). See gtk_range_set_fill_level(). The restrict-to-fill-level property controls whether slider movement is restricted to an upper boundary set by the fill level. See gtk_range_set_restrict_to_fill_level(). The number of digits to round the value to when it changes, or -1. See #GtkRange::change-value. The show-fill-level property controls whether fill level indicator graphics are displayed on the trough. See gtk_range_set_show_fill_level(). Emitted before clamping a value, to give the application a chance to adjust the bounds. the value before we clamp The #GtkRange::change-value signal is emitted when a scroll action is performed on a range. It allows an application to determine the type of scroll event that occurred and the resultant new value. The application can handle the event itself and return %TRUE to prevent further processing. Or, by returning %FALSE, it can pass the event to other handlers until the default GTK+ handler is reached. The value parameter is unrounded. An application that overrides the GtkRange::change-value signal is responsible for clamping the value to the desired number of decimal digits; the default GTK+ handler clamps the value based on #GtkRange:round-digits. %TRUE to prevent other handlers from being invoked for the signal, %FALSE to propagate the signal further the type of scroll action that was performed the new value resulting from the scroll action Virtual function that moves the slider. Used for keybindings. how to move the slider Emitted when the range value changes. Deprecated Deprecated Deprecated Deprecated Deprecated Deprecated quark-ified type identifier quark-ified property identifier like “GtkScrollbar::spacing” field similar to one found in #GtkSettingsValue field similar to one found in #GtkSettingsValue A #GtkRcPropertyParser for use with gtk_settings_install_property_parser() or gtk_widget_class_install_style_property_parser() which parses borders in the form `"{ left, right, top, bottom }"` for integers left, right, top and bottom. %TRUE if @gstring could be parsed and @property_value has been set to the resulting #GtkBorder. a #GParamSpec the #GString to be parsed a #GValue which must hold boxed values. A #GtkRcPropertyParser for use with gtk_settings_install_property_parser() or gtk_widget_class_install_style_property_parser() which parses a color given either by its name or in the form `{ red, green, blue }` where red, green and blue are integers between 0 and 65535 or floating-point numbers between 0 and 1. %TRUE if @gstring could be parsed and @property_value has been set to the resulting #GdkColor. a #GParamSpec the #GString to be parsed a #GValue which must hold #GdkColor values. A #GtkRcPropertyParser for use with gtk_settings_install_property_parser() or gtk_widget_class_install_style_property_parser() which parses a single enumeration value. The enumeration value can be specified by its name, its nickname or its numeric value. For consistency with flags parsing, the value may be surrounded by parentheses. %TRUE if @gstring could be parsed and @property_value has been set to the resulting #GEnumValue. a #GParamSpec the #GString to be parsed a #GValue which must hold enum values. A #GtkRcPropertyParser for use with gtk_settings_install_property_parser() or gtk_widget_class_install_style_property_parser() which parses flags. Flags can be specified by their name, their nickname or numerically. Multiple flags can be specified in the form `"( flag1 | flag2 | ... )"`. %TRUE if @gstring could be parsed and @property_value has been set to the resulting flags value. a #GParamSpec the #GString to be parsed a #GValue which must hold flags values. A #GtkRcPropertyParser for use with gtk_settings_install_property_parser() or gtk_widget_class_install_style_property_parser() which parses a requisition in the form `"{ width, height }"` for integers %width and %height. %TRUE if @gstring could be parsed and @property_value has been set to the resulting #GtkRequisition. a #GParamSpec the #GString to be parsed a #GValue which must hold boxed values. The #GtkRcStyle-struct is used to represent a set of information about the appearance of a widget. This can later be composited together with other #GtkRcStyle-struct<!-- -->s to form a #GtkStyle. Creates a new #GtkRcStyle with no fields set and a reference count of 1. Use #GtkCssProvider instead. the newly-created #GtkRcStyle Makes a copy of the specified #GtkRcStyle. This function will correctly copy an RC style that is a member of a class derived from #GtkRcStyle. Use #GtkCssProvider instead. the resulting #GtkRcStyle the style to copy Name Pixmap name A #PangoFontDescription #GtkRcFlags Foreground colors Background colors Text colors Base colors X thickness Y thickness The parent class. The #GtkRcTokenType enumeration represents the tokens in the RC file. It is exposed so that theme engines can reuse these tokens when parsing the theme-engine specific portions of a RC file. Use #GtkCssProvider instead. Deprecated Deprecated Deprecated Deprecated Deprecated Deprecated Deprecated Deprecated Deprecated Deprecated Deprecated Deprecated Deprecated Deprecated Deprecated Deprecated Deprecated Deprecated Deprecated Deprecated Deprecated Deprecated Deprecated Deprecated Deprecated Deprecated Deprecated Deprecated Deprecated Deprecated Deprecated Deprecated Deprecated Deprecated Deprecated Deprecated Deprecated Deprecated Deprecated Deprecated A #GtkRecentAction represents a list of recently used files, which can be shown by widgets such as #GtkRecentChooserDialog or #GtkRecentChooserMenu. To construct a submenu showing recently used files, use a #GtkRecentAction as the action for a <menuitem>. To construct a menu toolbutton showing the recently used files in the popup menu, use a #GtkRecentAction as the action for a <toolitem> element. Creates a new #GtkRecentAction object. To add the action to a #GtkActionGroup and set the accelerator for the action, call gtk_action_group_add_action_with_accel(). the newly created #GtkRecentAction. a unique name for the action the label displayed in menu items and on buttons, or %NULL a tooltip for the action, or %NULL the stock icon to display in widgets representing the action, or %NULL Creates a new #GtkRecentAction object. To add the action to a #GtkActionGroup and set the accelerator for the action, call gtk_action_group_add_action_with_accel(). the newly created #GtkRecentAction a unique name for the action the label displayed in menu items and on buttons, or %NULL a tooltip for the action, or %NULL the stock icon to display in widgets representing the action, or %NULL a #GtkRecentManager, or %NULL for using the default #GtkRecentManager Returns the value set by gtk_recent_chooser_menu_set_show_numbers(). %TRUE if numbers should be shown. a #GtkRecentAction Sets whether a number should be added to the items shown by the widgets representing @action. The numbers are shown to provide a unique character for a mnemonic to be used inside the menu item's label. Only the first ten items get a number to avoid clashes. a #GtkRecentAction %TRUE if the shown items should be numbered Whether the items should be displayed with a number. #GtkRecentChooser is an interface that can be implemented by widgets displaying the list of recently used files. In GTK+, the main objects that implement this interface are #GtkRecentChooserWidget, #GtkRecentChooserDialog and #GtkRecentChooserMenu. Recently used files are supported since GTK+ 2.10. Adds @filter to the list of #GtkRecentFilter objects held by @chooser. If no previous filter objects were defined, this function will call gtk_recent_chooser_set_filter(). a #GtkRecentChooser a #GtkRecentFilter Gets the URI currently selected by @chooser. a newly allocated string holding a URI. a #GtkRecentChooser Gets the list of recently used resources in form of #GtkRecentInfo objects. The return value of this function is affected by the “sort-type” and “limit” properties of @chooser. A newly allocated list of #GtkRecentInfo objects. You should use gtk_recent_info_unref() on every item of the list, and then free the list itself using g_list_free(). a #GtkRecentChooser Gets the #GtkRecentFilter objects held by @chooser. A singly linked list of #GtkRecentFilter objects. You should just free the returned list using g_slist_free(). a #GtkRecentChooser Removes @filter from the list of #GtkRecentFilter objects held by @chooser. a #GtkRecentChooser a #GtkRecentFilter Selects all the items inside @chooser, if the @chooser supports multiple selection. a #GtkRecentChooser Selects @uri inside @chooser. %TRUE if @uri was found. a #GtkRecentChooser a URI Sets @uri as the current URI for @chooser. %TRUE if the URI was found. a #GtkRecentChooser a URI Sets the comparison function used when sorting to be @sort_func. If the @chooser has the sort type set to #GTK_RECENT_SORT_CUSTOM then the chooser will sort using this function. To the comparison function will be passed two #GtkRecentInfo structs and @sort_data; @sort_func should return a positive integer if the first item comes before the second, zero if the two items are equal and a negative integer if the first item comes after the second. a #GtkRecentChooser the comparison function user data to pass to @sort_func, or %NULL destroy notifier for @sort_data, or %NULL Unselects all the items inside @chooser. a #GtkRecentChooser Unselects @uri inside @chooser. a #GtkRecentChooser a URI Adds @filter to the list of #GtkRecentFilter objects held by @chooser. If no previous filter objects were defined, this function will call gtk_recent_chooser_set_filter(). a #GtkRecentChooser a #GtkRecentFilter Gets the #GtkRecentInfo currently selected by @chooser. a #GtkRecentInfo. Use gtk_recent_info_unref() when when you have finished using it. a #GtkRecentChooser Gets the URI currently selected by @chooser. a newly allocated string holding a URI. a #GtkRecentChooser Gets the #GtkRecentFilter object currently used by @chooser to affect the display of the recently used resources. a #GtkRecentFilter object. a #GtkRecentChooser Gets the list of recently used resources in form of #GtkRecentInfo objects. The return value of this function is affected by the “sort-type” and “limit” properties of @chooser. A newly allocated list of #GtkRecentInfo objects. You should use gtk_recent_info_unref() on every item of the list, and then free the list itself using g_list_free(). a #GtkRecentChooser Gets the number of items returned by gtk_recent_chooser_get_items() and gtk_recent_chooser_get_uris(). A positive integer, or -1 meaning that all items are returned. a #GtkRecentChooser Gets whether only local resources should be shown in the recently used resources selector. See gtk_recent_chooser_set_local_only() %TRUE if only local resources should be shown. a #GtkRecentChooser Gets whether @chooser can select multiple items. %TRUE if @chooser can select more than one item. a #GtkRecentChooser Retrieves whether @chooser should show an icon near the resource. %TRUE if the icons should be displayed, %FALSE otherwise. a #GtkRecentChooser Retrieves whether @chooser should show the recently used resources that were not found. %TRUE if the resources not found should be displayed, and %FALSE otheriwse. a #GtkRecentChooser Returns whether @chooser should display recently used resources registered as private. %TRUE if the recent chooser should show private items, %FALSE otherwise. a #GtkRecentChooser Gets whether @chooser should display tooltips containing the full path of a recently user resource. %TRUE if the recent chooser should show tooltips, %FALSE otherwise. a #GtkRecentChooser Gets the value set by gtk_recent_chooser_set_sort_type(). the sorting order of the @chooser. a #GtkRecentChooser Gets the URI of the recently used resources. The return value of this function is affected by the “sort-type” and “limit” properties of @chooser. Since the returned array is %NULL terminated, @length may be %NULL. A newly allocated, %NULL-terminated array of strings. Use g_strfreev() to free it. a #GtkRecentChooser return location for a the length of the URI list, or %NULL Gets the #GtkRecentFilter objects held by @chooser. A singly linked list of #GtkRecentFilter objects. You should just free the returned list using g_slist_free(). a #GtkRecentChooser Removes @filter from the list of #GtkRecentFilter objects held by @chooser. a #GtkRecentChooser a #GtkRecentFilter Selects all the items inside @chooser, if the @chooser supports multiple selection. a #GtkRecentChooser Selects @uri inside @chooser. %TRUE if @uri was found. a #GtkRecentChooser a URI Sets @uri as the current URI for @chooser. %TRUE if the URI was found. a #GtkRecentChooser a URI Sets @filter as the current #GtkRecentFilter object used by @chooser to affect the displayed recently used resources. a #GtkRecentChooser a #GtkRecentFilter Sets the number of items that should be returned by gtk_recent_chooser_get_items() and gtk_recent_chooser_get_uris(). a #GtkRecentChooser a positive integer, or -1 for all items Sets whether only local resources, that is resources using the file:// URI scheme, should be shown in the recently used resources selector. If @local_only is %TRUE (the default) then the shown resources are guaranteed to be accessible through the operating system native file system. a #GtkRecentChooser %TRUE if only local files can be shown Sets whether @chooser can select multiple items. a #GtkRecentChooser %TRUE if @chooser can select more than one item Sets whether @chooser should show an icon near the resource when displaying it. a #GtkRecentChooser whether to show an icon near the resource Sets whether @chooser should display the recently used resources that it didn’t find. This only applies to local resources. a #GtkRecentChooser whether to show the local items we didn’t find Whether to show recently used resources marked registered as private. a #GtkRecentChooser %TRUE to show private items, %FALSE otherwise Sets whether to show a tooltips containing the full path of each recently used resource in a #GtkRecentChooser widget. a #GtkRecentChooser %TRUE if tooltips should be shown Sets the comparison function used when sorting to be @sort_func. If the @chooser has the sort type set to #GTK_RECENT_SORT_CUSTOM then the chooser will sort using this function. To the comparison function will be passed two #GtkRecentInfo structs and @sort_data; @sort_func should return a positive integer if the first item comes before the second, zero if the two items are equal and a negative integer if the first item comes after the second. a #GtkRecentChooser the comparison function user data to pass to @sort_func, or %NULL destroy notifier for @sort_data, or %NULL Changes the sorting order of the recently used resources list displayed by @chooser. a #GtkRecentChooser sort order that the chooser should use Unselects all the items inside @chooser. a #GtkRecentChooser Unselects @uri inside @chooser. a #GtkRecentChooser a URI The #GtkRecentFilter object to be used when displaying the recently used resources. The maximum number of recently used resources to be displayed, or -1 to display all items. Whether this #GtkRecentChooser should display only local (file:) resources. The #GtkRecentManager instance used by the #GtkRecentChooser to display the list of recently used resources. Allow the user to select multiple resources. Whether this #GtkRecentChooser should display an icon near the item. Whether this #GtkRecentChooser should display the recently used resources even if not present anymore. Setting this to %FALSE will perform a potentially expensive check on every local resource (every remote resource will always be displayed). Whether this #GtkRecentChooser should display a tooltip containing the full path of the recently used resources. Sorting order to be used when displaying the recently used resources. This signal is emitted when the user "activates" a recent item in the recent chooser. This can happen by double-clicking on an item in the recently used resources list, or by pressing `Enter`. This signal is emitted when there is a change in the set of selected recently used resources. This can happen when a user modifies the selection with the mouse or the keyboard, or when explicitly calling functions to change the selection. #GtkRecentChooserDialog is a dialog box suitable for displaying the recently used documents. This widgets works by putting a #GtkRecentChooserWidget inside a #GtkDialog. It exposes the #GtkRecentChooserIface interface, so you can use all the #GtkRecentChooser functions on the recent chooser dialog as well as those for #GtkDialog. Note that #GtkRecentChooserDialog does not have any methods of its own. Instead, you should use the functions that work on a #GtkRecentChooser. ## Typical usage ## {#gtkrecentchooser-typical-usage} In the simplest of cases, you can use the following code to use a #GtkRecentChooserDialog to select a recently used file: |[<!-- language="C" --> GtkWidget *dialog; gint res; dialog = gtk_recent_chooser_dialog_new ("Recent Documents", parent_window, _("_Cancel"), GTK_RESPONSE_CANCEL, _("_Open"), GTK_RESPONSE_ACCEPT, NULL); res = gtk_dialog_run (GTK_DIALOG (dialog)); if (res == GTK_RESPONSE_ACCEPT) { GtkRecentInfo *info; GtkRecentChooser *chooser = GTK_RECENT_CHOOSER (dialog); info = gtk_recent_chooser_get_current_item (chooser); open_file (gtk_recent_info_get_uri (info)); gtk_recent_info_unref (info); } gtk_widget_destroy (dialog); ]| Recently used files are supported since GTK+ 2.10. Creates a new #GtkRecentChooserDialog. This function is analogous to gtk_dialog_new_with_buttons(). a new #GtkRecentChooserDialog Title of the dialog, or %NULL Transient parent of the dialog, or %NULL, stock ID or text to go in the first button, or %NULL response ID for the first button, then additional (button, id) pairs, ending with %NULL Creates a new #GtkRecentChooserDialog with a specified recent manager. This is useful if you have implemented your own recent manager, or if you have a customized instance of a #GtkRecentManager object. a new #GtkRecentChooserDialog Title of the dialog, or %NULL Transient parent of the dialog, or %NULL, a #GtkRecentManager stock ID or text to go in the first button, or %NULL response ID for the first button, then additional (button, id) pairs, ending with %NULL These identify the various errors that can occur while calling #GtkRecentChooser functions. Indicates that a file does not exist Indicates a malformed URI %TRUE if the URI was found. a #GtkRecentChooser a URI a newly allocated string holding a URI. a #GtkRecentChooser %TRUE if @uri was found. a #GtkRecentChooser a URI a #GtkRecentChooser a URI a #GtkRecentChooser a #GtkRecentChooser A newly allocated list of #GtkRecentInfo objects. You should use gtk_recent_info_unref() on every item of the list, and then free the list itself using g_list_free(). a #GtkRecentChooser a #GtkRecentChooser a #GtkRecentFilter a #GtkRecentChooser a #GtkRecentFilter A singly linked list of #GtkRecentFilter objects. You should just free the returned list using g_slist_free(). a #GtkRecentChooser a #GtkRecentChooser the comparison function user data to pass to @sort_func, or %NULL destroy notifier for @sort_data, or %NULL #GtkRecentChooserMenu is a widget suitable for displaying recently used files inside a menu. It can be used to set a sub-menu of a #GtkMenuItem using gtk_menu_item_set_submenu(), or as the menu of a #GtkMenuToolButton. Note that #GtkRecentChooserMenu does not have any methods of its own. Instead, you should use the functions that work on a #GtkRecentChooser. Note also that #GtkRecentChooserMenu does not support multiple filters, as it has no way to let the user choose between them as the #GtkRecentChooserWidget and #GtkRecentChooserDialog widgets do. Thus using gtk_recent_chooser_add_filter() on a #GtkRecentChooserMenu widget will yield the same effects as using gtk_recent_chooser_set_filter(), replacing any currently set filter with the supplied filter; gtk_recent_chooser_remove_filter() will remove any currently set #GtkRecentFilter object and will unset the current filter; gtk_recent_chooser_list_filters() will return a list containing a single #GtkRecentFilter object. Recently used files are supported since GTK+ 2.10. Creates a new #GtkRecentChooserMenu widget. This kind of widget shows the list of recently used resources as a menu, each item as a menu item. Each item inside the menu might have an icon, representing its MIME type, and a number, for mnemonic access. This widget implements the #GtkRecentChooser interface. This widget creates its own #GtkRecentManager object. See the gtk_recent_chooser_menu_new_for_manager() function to know how to create a #GtkRecentChooserMenu widget bound to another #GtkRecentManager object. a new #GtkRecentChooserMenu Creates a new #GtkRecentChooserMenu widget using @manager as the underlying recently used resources manager. This is useful if you have implemented your own recent manager, or if you have a customized instance of a #GtkRecentManager object or if you wish to share a common #GtkRecentManager object among multiple #GtkRecentChooser widgets. a new #GtkRecentChooserMenu, bound to @manager. a #GtkRecentManager Returns the value set by gtk_recent_chooser_menu_set_show_numbers(). %TRUE if numbers should be shown. a #GtkRecentChooserMenu Sets whether a number should be added to the items of @menu. The numbers are shown to provide a unique character for a mnemonic to be used inside ten menu item’s label. Only the first the items get a number to avoid clashes. a #GtkRecentChooserMenu whether to show numbers Whether the first ten items in the menu should be prepended by a number acting as a unique mnemonic. #GtkRecentChooserWidget is a widget suitable for selecting recently used files. It is the main building block of a #GtkRecentChooserDialog. Most applications will only need to use the latter; you can use #GtkRecentChooserWidget as part of a larger window if you have special needs. Note that #GtkRecentChooserWidget does not have any methods of its own. Instead, you should use the functions that work on a #GtkRecentChooser. Recently used files are supported since GTK+ 2.10. Creates a new #GtkRecentChooserWidget object. This is an embeddable widget used to access the recently used resources list. a new #GtkRecentChooserWidget Creates a new #GtkRecentChooserWidget with a specified recent manager. This is useful if you have implemented your own recent manager, or if you have a customized instance of a #GtkRecentManager object. a new #GtkRecentChooserWidget a #GtkRecentManager Meta-data to be passed to gtk_recent_manager_add_full() when registering a recently used resource. a UTF-8 encoded string, containing the name of the recently used resource to be displayed, or %NULL; a UTF-8 encoded string, containing a short description of the resource, or %NULL; the MIME type of the resource; the name of the application that is registering this recently used resource; command line used to launch this resource; may contain the “\%f” and “\%u” escape characters which will be expanded to the resource file path and URI respectively when the command line is retrieved; a vector of strings containing groups names; whether this resource should be displayed only by the applications that have registered it or not. A #GtkRecentFilter can be used to restrict the files being shown in a #GtkRecentChooser. Files can be filtered based on their name (with gtk_recent_filter_add_pattern()), on their mime type (with gtk_file_filter_add_mime_type()), on the application that has registered them (with gtk_recent_filter_add_application()), or by a custom filter function (with gtk_recent_filter_add_custom()). Filtering by mime type handles aliasing and subclassing of mime types; e.g. a filter for text/plain also matches a file with mime type application/rtf, since application/rtf is a subclass of text/plain. Note that #GtkRecentFilter allows wildcards for the subtype of a mime type, so you can e.g. filter for image/\*. Normally, filters are used by adding them to a #GtkRecentChooser, see gtk_recent_chooser_add_filter(), but it is also possible to manually use a filter on a file with gtk_recent_filter_filter(). Recently used files are supported since GTK+ 2.10. ## GtkRecentFilter as GtkBuildable The GtkRecentFilter implementation of the GtkBuildable interface supports adding rules using the <mime-types>, <patterns> and <applications> elements and listing the rules within. Specifying a <mime-type>, <pattern> or <application> has the same effect as calling gtk_recent_filter_add_mime_type(), gtk_recent_filter_add_pattern() or gtk_recent_filter_add_application(). An example of a UI definition fragment specifying GtkRecentFilter rules: |[ <object class="GtkRecentFilter"> <mime-types> <mime-type>text/plain</mime-type> <mime-type>image/png</mime-type> </mime-types> <patterns> <pattern>*.txt</pattern> <pattern>*.png</pattern> </patterns> <applications> <application>gimp</application> <application>gedit</application> <application>glade</application> </applications> </object> ]| Creates a new #GtkRecentFilter with no rules added to it. Such filter does not accept any recently used resources, so is not particularly useful until you add rules with gtk_recent_filter_add_pattern(), gtk_recent_filter_add_mime_type(), gtk_recent_filter_add_application(), gtk_recent_filter_add_age(). To create a filter that accepts any recently used resource, use: |[<!-- language="C" --> GtkRecentFilter *filter = gtk_recent_filter_new (); gtk_recent_filter_add_pattern (filter, "*"); ]| a new #GtkRecentFilter Adds a rule that allows resources based on their age - that is, the number of days elapsed since they were last modified. a #GtkRecentFilter number of days Adds a rule that allows resources based on the name of the application that has registered them. a #GtkRecentFilter an application name Adds a rule to a filter that allows resources based on a custom callback function. The bitfield @needed which is passed in provides information about what sorts of information that the filter function needs; this allows GTK+ to avoid retrieving expensive information when it isn’t needed by the filter. a #GtkRecentFilter bitfield of flags indicating the information that the custom filter function needs. callback function; if the function returns %TRUE, then the file will be displayed. data to pass to @func function to call to free @data when it is no longer needed. Adds a rule that allows resources based on the name of the group to which they belong a #GtkRecentFilter a group name Adds a rule that allows resources based on their registered MIME type. a #GtkRecentFilter a MIME type Adds a rule that allows resources based on a pattern matching their display name. a #GtkRecentFilter a file pattern Adds a rule allowing image files in the formats supported by GdkPixbuf. a #GtkRecentFilter Tests whether a file should be displayed according to @filter. The #GtkRecentFilterInfo @filter_info should include the fields returned from gtk_recent_filter_get_needed(), and must set the #GtkRecentFilterInfo.contains field of @filter_info to indicate which fields have been set. This function will not typically be used by applications; it is intended principally for use in the implementation of #GtkRecentChooser. %TRUE if the file should be displayed a #GtkRecentFilter a #GtkRecentFilterInfo containing information about a recently used resource Gets the human-readable name for the filter. See gtk_recent_filter_set_name(). the name of the filter, or %NULL. The returned string is owned by the filter object and should not be freed. a #GtkRecentFilter Gets the fields that need to be filled in for the #GtkRecentFilterInfo passed to gtk_recent_filter_filter() This function will not typically be used by applications; it is intended principally for use in the implementation of #GtkRecentChooser. bitfield of flags indicating needed fields when calling gtk_recent_filter_filter() a #GtkRecentFilter Sets the human-readable name of the filter; this is the string that will be displayed in the recently used resources selector user interface if there is a selectable list of filters. a #GtkRecentFilter then human readable name of @filter These flags indicate what parts of a #GtkRecentFilterInfo struct are filled or need to be filled. the URI of the file being tested the string that will be used to display the file in the recent chooser the mime type of the file the list of applications that have registered the file the groups to which the file belongs to the number of days elapsed since the file has been registered The type of function that is used with custom filters, see gtk_recent_filter_add_custom(). %TRUE if the file should be displayed a #GtkRecentFilterInfo that is filled according to the @needed flags passed to gtk_recent_filter_add_custom() user data passed to gtk_recent_filter_add_custom() A GtkRecentFilterInfo struct is used to pass information about the tested file to gtk_recent_filter_filter(). #GtkRecentFilterFlags to indicate which fields are set. The URI of the file being tested. The string that will be used to display the file in the recent chooser. MIME type of the file. The list of applications that have registered the file. The groups to which the file belongs to. The number of days elapsed since the file has been registered. #GtkRecentInfo-struct contains private data only, and should be accessed using the provided API. #GtkRecentInfo constains all the meta-data associated with an entry in the recently used files list. Creates a #GAppInfo for the specified #GtkRecentInfo the newly created #GAppInfo, or %NULL. In case of error, @error will be set either with a %GTK_RECENT_MANAGER_ERROR or a %G_IO_ERROR a #GtkRecentInfo the name of the application that should be mapped to a #GAppInfo; if %NULL is used then the default application for the MIME type is used Checks whether the resource pointed by @info still exists. At the moment this check is done only on resources pointing to local files. %TRUE if the resource exists a #GtkRecentInfo Gets the timestamp (seconds from system’s Epoch) when the resource was added to the recently used resources list. the number of seconds elapsed from system’s Epoch when the resource was added to the list, or -1 on failure. a #GtkRecentInfo Gets the number of days elapsed since the last update of the resource pointed by @info. a positive integer containing the number of days elapsed since the time this resource was last modified a #GtkRecentInfo Gets the data regarding the application that has registered the resource pointed by @info. If the command line contains any escape characters defined inside the storage specification, they will be expanded. %TRUE if an application with @app_name has registered this resource inside the recently used list, or %FALSE otherwise. The @app_exec string is owned by the #GtkRecentInfo and should not be modified or freed a #GtkRecentInfo the name of the application that has registered this item return location for the string containing the command line return location for the number of times this item was registered return location for the timestamp this item was last registered for this application Retrieves the list of applications that have registered this resource. a newly allocated %NULL-terminated array of strings. Use g_strfreev() to free it. a #GtkRecentInfo return location for the length of the returned list Gets the (short) description of the resource. the description of the resource. The returned string is owned by the recent manager, and should not be freed. a #GtkRecentInfo Gets the name of the resource. If none has been defined, the basename of the resource is obtained. the display name of the resource. The returned string is owned by the recent manager, and should not be freed. a #GtkRecentInfo Retrieves the icon associated to the resource MIME type. a #GIcon containing the icon, or %NULL. Use g_object_unref() when finished using the icon a #GtkRecentInfo Returns all groups registered for the recently used item @info. The array of returned group names will be %NULL terminated, so length might optionally be %NULL. a newly allocated %NULL terminated array of strings. Use g_strfreev() to free it. a #GtkRecentInfo return location for the number of groups returned Retrieves the icon of size @size associated to the resource MIME type. a #GdkPixbuf containing the icon, or %NULL. Use g_object_unref() when finished using the icon. a #GtkRecentInfo the size of the icon in pixels Gets the MIME type of the resource. the MIME type of the resource. The returned string is owned by the recent manager, and should not be freed. a #GtkRecentInfo Gets the timestamp (seconds from system’s Epoch) when the meta-data for the resource was last modified. the number of seconds elapsed from system’s Epoch when the resource was last modified, or -1 on failure. a #GtkRecentInfo Gets the value of the “private” flag. Resources in the recently used list that have this flag set to %TRUE should only be displayed by the applications that have registered them. %TRUE if the private flag was found, %FALSE otherwise a #GtkRecentInfo Computes a valid UTF-8 string that can be used as the name of the item in a menu or list. For example, calling this function on an item that refers to “file:///foo/bar.txt” will yield “bar.txt”. A newly-allocated string in UTF-8 encoding free it with g_free() an #GtkRecentInfo Gets the URI of the resource. the URI of the resource. The returned string is owned by the recent manager, and should not be freed. a #GtkRecentInfo Gets a displayable version of the resource’s URI. If the resource is local, it returns a local path; if the resource is not local, it returns the UTF-8 encoded content of gtk_recent_info_get_uri(). a newly allocated UTF-8 string containing the resource’s URI or %NULL. Use g_free() when done using it. a #GtkRecentInfo Gets the timestamp (seconds from system’s Epoch) when the meta-data for the resource was last visited. the number of seconds elapsed from system’s Epoch when the resource was last visited, or -1 on failure. a #GtkRecentInfo Checks whether an application registered this resource using @app_name. %TRUE if an application with name @app_name was found, %FALSE otherwise a #GtkRecentInfo a string containing an application name Checks whether @group_name appears inside the groups registered for the recently used item @info. %TRUE if the group was found a #GtkRecentInfo name of a group Checks whether the resource is local or not by looking at the scheme of its URI. %TRUE if the resource is local a #GtkRecentInfo Gets the name of the last application that have registered the recently used resource represented by @info. an application name. Use g_free() to free it. a #GtkRecentInfo Checks whether two #GtkRecentInfo-struct point to the same resource. %TRUE if both #GtkRecentInfo-struct point to the same resource, %FALSE otherwise a #GtkRecentInfo a #GtkRecentInfo Increases the reference count of @recent_info by one. the recent info object with its reference count increased by one a #GtkRecentInfo Decreases the reference count of @info by one. If the reference count reaches zero, @info is deallocated, and the memory freed. a #GtkRecentInfo #GtkRecentManager provides a facility for adding, removing and looking up recently used files. Each recently used file is identified by its URI, and has meta-data associated to it, like the names and command lines of the applications that have registered it, the number of time each application has registered the same file, the mime type of the file and whether the file should be displayed only by the applications that have registered it. The recently used files list is per user. The #GtkRecentManager acts like a database of all the recently used files. You can create new #GtkRecentManager objects, but it is more efficient to use the default manager created by GTK+. Adding a new recently used file is as simple as: |[<!-- language="C" --> GtkRecentManager *manager; manager = gtk_recent_manager_get_default (); gtk_recent_manager_add_item (manager, file_uri); ]| The #GtkRecentManager will try to gather all the needed information from the file itself through GIO. Looking up the meta-data associated with a recently used file given its URI requires calling gtk_recent_manager_lookup_item(): |[<!-- language="C" --> GtkRecentManager *manager; GtkRecentInfo *info; GError *error = NULL; manager = gtk_recent_manager_get_default (); info = gtk_recent_manager_lookup_item (manager, file_uri, &error); if (error) { g_warning ("Could not find the file: %s", error->message); g_error_free (error); } else { // Use the info object gtk_recent_info_unref (info); } ]| In order to retrieve the list of recently used files, you can use gtk_recent_manager_get_items(), which returns a list of #GtkRecentInfo-structs. A #GtkRecentManager is the model used to populate the contents of one, or more #GtkRecentChooser implementations. Note that the maximum age of the recently used files list is controllable through the #GtkSettings:gtk-recent-files-max-age property. Recently used files are supported since GTK+ 2.10. Creates a new recent manager object. Recent manager objects are used to handle the list of recently used resources. A #GtkRecentManager object monitors the recently used resources list, and emits the “changed” signal each time something inside the list changes. #GtkRecentManager objects are expensive: be sure to create them only when needed. You should use gtk_recent_manager_get_default() instead. A newly created #GtkRecentManager object Gets a unique instance of #GtkRecentManager, that you can share in your application without caring about memory management. A unique #GtkRecentManager. Do not ref or unref it. Adds a new resource, pointed by @uri, into the recently used resources list, using the metadata specified inside the #GtkRecentData-struct passed in @recent_data. The passed URI will be used to identify this resource inside the list. In order to register the new recently used resource, metadata about the resource must be passed as well as the URI; the metadata is stored in a #GtkRecentData-struct, which must contain the MIME type of the resource pointed by the URI; the name of the application that is registering the item, and a command line to be used when launching the item. Optionally, a #GtkRecentData-struct might contain a UTF-8 string to be used when viewing the item instead of the last component of the URI; a short description of the item; whether the item should be considered private - that is, should be displayed only by the applications that have registered it. %TRUE if the new item was successfully added to the recently used resources list, %FALSE otherwise a #GtkRecentManager a valid URI metadata of the resource Adds a new resource, pointed by @uri, into the recently used resources list. This function automatically retrieves some of the needed metadata and setting other metadata to common default values; it then feeds the data to gtk_recent_manager_add_full(). See gtk_recent_manager_add_full() if you want to explicitly define the metadata for the resource pointed by @uri. %TRUE if the new item was successfully added to the recently used resources list a #GtkRecentManager a valid URI Gets the list of recently used resources. a list of newly allocated #GtkRecentInfo objects. Use gtk_recent_info_unref() on each item inside the list, and then free the list itself using g_list_free(). a #GtkRecentManager Checks whether there is a recently used resource registered with @uri inside the recent manager. %TRUE if the resource was found, %FALSE otherwise a #GtkRecentManager a URI Searches for a URI inside the recently used resources list, and returns a #GtkRecentInfo-struct containing informations about the resource like its MIME type, or its display name. a #GtkRecentInfo-struct containing information about the resource pointed by @uri, or %NULL if the URI was not registered in the recently used resources list. Free with gtk_recent_info_unref(). a #GtkRecentManager a URI Changes the location of a recently used resource from @uri to @new_uri. Please note that this function will not affect the resource pointed by the URIs, but only the URI used in the recently used resources list. %TRUE on success a #GtkRecentManager the URI of a recently used resource the new URI of the recently used resource, or %NULL to remove the item pointed by @uri in the list Purges every item from the recently used resources list. the number of items that have been removed from the recently used resources list a #GtkRecentManager Removes a resource pointed by @uri from the recently used resources list handled by a recent manager. %TRUE if the item pointed by @uri has been successfully removed by the recently used resources list, and %FALSE otherwise a #GtkRecentManager the URI of the item you wish to remove The full path to the file to be used to store and read the recently used resources list The size of the recently used resources list. Emitted when the current recently used resources manager changes its contents, either by calling gtk_recent_manager_add_item() or by another application. #GtkRecentManagerClass contains only private data. Error codes for #GtkRecentManager operations the URI specified does not exists in the recently used resources list. the URI specified is not valid. the supplied string is not UTF-8 encoded. no application has registered the specified item. failure while reading the recently used resources file. failure while writing the recently used resources file. unspecified error. Used to specify the sorting method to be applyed to the recently used resource list. Do not sort the returned list of recently used resources. Sort the returned list with the most recently used items first. Sort the returned list with the least recently used items first. Sort the returned list using a custom sorting function passed using gtk_recent_chooser_set_sort_func(). Describes a region within a widget. Region has an even number within a set. Region has an odd number within a set. Region is the first one within a set. Region is the last one within a set. Region is the only one within a set. Region is part of a sorted area. Indicated the relief to be drawn around a #GtkButton. Draw a normal relief. A half relief. Deprecated in 3.14, does the same as @GTK_RELIEF_NORMAL No relief. Represents a request of a screen object in a given orientation. These are primarily used in container implementations when allocating a natural size for children calling. See gtk_distribute_natural_allocation(). A client pointer The minimum size needed for allocation in a given orientation The natural size for allocation in a given orientation A #GtkRequisition-struct represents the desired size of a widget. See [GtkWidget’s geometry management section][geometry-management] for more information. the widget’s desired width the widget’s desired height Allocates a new #GtkRequisition-struct and initializes its elements to zero. a new empty #GtkRequisition. The newly allocated #GtkRequisition should be freed with gtk_requisition_free(). Copies a #GtkRequisition. a copy of @requisition a #GtkRequisition Frees a #GtkRequisition. a #GtkRequisition Pass resize request to the parent Queue resizes on this widget Resize immediately. Deprecated. Predefined values for use as response ids in gtk_dialog_add_button(). All predefined values are negative; GTK+ leaves values of 0 or greater for application-defined response ids. Returned if an action widget has no response id, or if the dialog gets programmatically hidden or destroyed Generic response id, not used by GTK+ dialogs Generic response id, not used by GTK+ dialogs Returned if the dialog is deleted Returned by OK buttons in GTK+ dialogs Returned by Cancel buttons in GTK+ dialogs Returned by Close buttons in GTK+ dialogs Returned by Yes buttons in GTK+ dialogs Returned by No buttons in GTK+ dialogs Returned by Apply buttons in GTK+ dialogs Returned by Help buttons in GTK+ dialogs The GtkRevealer widget is a container which animates the transition of its child from invisible to visible. The style of transition can be controlled with gtk_revealer_set_transition_type(). These animations respect the #GtkSettings:gtk-enable-animations setting. # CSS nodes GtkRevealer has a single CSS node with name revealer. The GtkRevealer widget was added in GTK+ 3.10. Creates a new #GtkRevealer. a newly created #GtkRevealer Returns whether the child is fully revealed, in other words whether the transition to the revealed state is completed. %TRUE if the child is fully revealed a #GtkRevealer Returns whether the child is currently revealed. See gtk_revealer_set_reveal_child(). This function returns %TRUE as soon as the transition is to the revealed state is started. To learn whether the child is fully revealed (ie the transition is completed), use gtk_revealer_get_child_revealed(). %TRUE if the child is revealed. a #GtkRevealer Returns the amount of time (in milliseconds) that transitions will take. the transition duration a #GtkRevealer Gets the type of animation that will be used for transitions in @revealer. the current transition type of @revealer a #GtkRevealer Tells the #GtkRevealer to reveal or conceal its child. The transition will be animated with the current transition type of @revealer. a #GtkRevealer %TRUE to reveal the child Sets the duration that transitions will take. a #GtkRevealer the new duration, in milliseconds Sets the type of animation that will be used for transitions in @revealer. Available types include various kinds of fades and slides. a #GtkRevealer the new transition type The parent class. These enumeration values describe the possible transitions when the child of a #GtkRevealer widget is shown or hidden. No transition Fade in Slide in from the left Slide in from the right Slide in from the bottom Slide in from the top The “About” item. ![](help-about.png) Use named icon &quot;help-about&quot; or the label &quot;_About&quot;. The “Add” item and icon. Use named icon &quot;list-add&quot; or the label &quot;_Add&quot;. The “Apply” item and icon. Do not use an icon. Use label &quot;_Apply&quot;. The “Bold” item and icon. Use named icon &quot;format-text-bold&quot;. The “Cancel” item and icon. Do not use an icon. Use label &quot;_Cancel&quot;. The “Caps Lock Warning” icon. Use named icon &quot;dialog-warning-symbolic&quot;. The “CD-Rom” item and icon. Use named icon &quot;media-optical&quot;. The “Clear” item and icon. Use named icon &quot;edit-clear&quot;. The “Close” item and icon. Use named icon &quot;window-close&quot; or the label &quot;_Close&quot;. The “Color Picker” item and icon. The “Connect” icon. The “Convert” item and icon. The “Copy” item and icon. Use the named icon &quot;edit-copy&quot; or the label &quot;_Copy&quot;. The “Cut” item and icon. Use the named icon &quot;edit-cut&quot; or the label &quot;Cu_t&quot;. The “Delete” item and icon. Use the named icon &quot;edit-delete&quot; or the label &quot;_Delete&quot;. The “Authentication” item and icon. Use named icon &quot;dialog-password&quot;. The “Error” item and icon. Use named icon &quot;dialog-error&quot;. The “Information” item and icon. Use named icon &quot;dialog-information&quot;. The “Question” item and icon. Use named icon &quot;dialog-question&quot;. The “Warning” item and icon. Use named icon &quot;dialog-warning&quot;. The “Directory” icon. Use named icon &quot;folder&quot;. The “Discard” item. The “Disconnect” icon. The “Drag-And-Drop” icon. The “Drag-And-Drop multiple” icon. The “Edit” item and icon. The “Execute” item and icon. Use named icon &quot;system-run&quot;. The “File” item and icon. Since 3.0, this item has a label, before it only had an icon. Use named icon &quot;text-x-generic&quot;. The “Find” item and icon. Use named icon &quot;edit-find&quot;. The “Find and Replace” item and icon. Use named icon &quot;edit-find-replace&quot;. The “Floppy” item and icon. The “Fullscreen” item and icon. Use named icon &quot;view-fullscreen&quot;. The “Bottom” item and icon. Use named icon &quot;go-bottom&quot;. The “First” item and icon. The icon has an RTL variant. Use named icon &quot;go-first&quot;. The “Last” item and icon. The icon has an RTL variant. Use named icon &quot;go-last&quot;. The “Top” item and icon. Use named icon &quot;go-top&quot;. The “Back” item and icon. The icon has an RTL variant. Use named icon &quot;go-previous&quot;. The “Down” item and icon. Use named icon &quot;go-down&quot;. The “Forward” item and icon. The icon has an RTL variant. Use named icon &quot;go-next&quot;. The “Up” item and icon. Use named icon &quot;go-up&quot;. The “Harddisk” item and icon. Use named icon &quot;drive-harddisk&quot;. The “Help” item and icon. Use named icon &quot;help-browser&quot;. The “Home” item and icon. Use named icon &quot;go-home&quot;. The “Indent” item and icon. The icon has an RTL variant. Use named icon &quot;format-indent-more&quot;. The “Index” item and icon. The “Info” item and icon. Use named icon &quot;dialog-information&quot;. The “Italic” item and icon. Use named icon &quot;format-text-italic&quot;. The “Jump to” item and icon. The icon has an RTL variant. Use named icon &quot;go-jump&quot;. The “Center” item and icon. Use named icon &quot;format-justify-center&quot;. The “Fill” item and icon. Use named icon &quot;format-justify-fill&quot;. The “Left” item and icon. Use named icon &quot;format-justify-left&quot;. The “Right” item and icon. Use named icon &quot;format-justify-right&quot;. The “Leave Fullscreen” item and icon. Use named icon &quot;view-restore&quot;. The “Media Forward” item and icon. The icon has an RTL variant. Use named icon &quot;media-seek-forward&quot; or the label &quot;_Forward&quot;. The “Media Next” item and icon. The icon has an RTL variant. Use named icon &quot;media-skip-forward&quot; or the label &quot;_Next&quot;. The “Media Pause” item and icon. Use named icon &quot;media-playback-pause&quot; or the label &quot;P_ause&quot;. The “Media Play” item and icon. The icon has an RTL variant. Use named icon &quot;media-playback-start&quot; or the label &quot;_Play&quot;. The “Media Previous” item and icon. The icon has an RTL variant. Use named icon &quot;media-skip-backward&quot; or the label &quot;Pre_vious&quot;. The “Media Record” item and icon. Use named icon &quot;media-record&quot; or the label &quot;_Record&quot;. The “Media Rewind” item and icon. The icon has an RTL variant. Use named icon &quot;media-seek-backward&quot; or the label &quot;R_ewind&quot;. The “Media Stop” item and icon. Use named icon &quot;media-playback-stop&quot; or the label &quot;_Stop&quot;. The “Missing image” icon. Use named icon &quot;image-missing&quot;. The “Network” item and icon. Use named icon &quot;network-workgroup&quot;. The “New” item and icon. Use named icon &quot;document-new&quot; or the label &quot;_New&quot;. The “No” item and icon. The “OK” item and icon. Do not use an icon. Use label &quot;_OK&quot;. The “Open” item and icon. Use named icon &quot;document-open&quot; or the label &quot;_Open&quot;. The “Landscape Orientation” item and icon. The “Portrait Orientation” item and icon. The “Reverse Landscape Orientation” item and icon. The “Reverse Portrait Orientation” item and icon. The “Page Setup” item and icon. Use named icon &quot;document-page-setup&quot; or the label &quot;Page Set_up&quot;. The “Paste” item and icon. Use named icon &quot;edit-paste&quot; or the label &quot;_Paste&quot;. The “Preferences” item and icon. Use named icon &quot;preferences-system&quot; or the label &quot;_Preferences&quot;. The “Print” item and icon. Use named icon &quot;document-print&quot; or the label &quot;_Print&quot;. The “Print Error” icon. Use named icon &quot;printer-error&quot;. The “Print Paused” icon. The “Print Preview” item and icon. Use label &quot;Pre_view&quot;. The “Print Report” icon. The “Print Warning” icon. The “Properties” item and icon. Use named icon &quot;document-properties&quot; or the label &quot;_Properties&quot;. The “Quit” item and icon. Use named icon &quot;application-exit&quot; or the label &quot;_Quit&quot;. The “Redo” item and icon. The icon has an RTL variant. Use named icon &quot;edit-redo&quot; or the label &quot;_Redo&quot;. The “Refresh” item and icon. Use named icon &quot;view-refresh&quot; or the label &quot;_Refresh&quot;. The “Remove” item and icon. Use named icon &quot;list-remove&quot; or the label &quot;_Remove&quot;. The “Revert” item and icon. The icon has an RTL variant. Use named icon &quot;document-revert&quot; or the label &quot;_Revert&quot;. The “Save” item and icon. Use named icon &quot;document-save&quot; or the label &quot;_Save&quot;. The “Save As” item and icon. Use named icon &quot;document-save-as&quot; or the label &quot;Save _As&quot;. The “Select All” item and icon. Use named icon &quot;edit-select-all&quot; or the label &quot;Select _All&quot;. The “Color” item and icon. The “Font” item and icon. The “Ascending” item and icon. Use named icon &quot;view-sort-ascending&quot;. The “Descending” item and icon. Use named icon &quot;view-sort-descending&quot;. The “Spell Check” item and icon. Use named icon &quot;tools-check-spelling&quot;. The “Stop” item and icon. Use named icon &quot;process-stop&quot; or the label &quot;_Stop&quot;. The “Strikethrough” item and icon. Use named icon &quot;format-text-strikethrough&quot; or the label &quot;_Strikethrough&quot;. The “Undelete” item and icon. The icon has an RTL variant. The “Underline” item and icon. Use named icon &quot;format-text-underline&quot; or the label &quot;_Underline&quot;. The “Undo” item and icon. The icon has an RTL variant. Use named icon &quot;edit-undo&quot; or the label &quot;_Undo&quot;. The “Unindent” item and icon. The icon has an RTL variant. Use named icon &quot;format-indent-less&quot;. The “Yes” item and icon. The “Zoom 100%” item and icon. Use named icon &quot;zoom-original&quot; or the label &quot;_Normal Size&quot;. The “Zoom to Fit” item and icon. Use named icon &quot;zoom-fit-best&quot; or the label &quot;Best _Fit&quot;. The “Zoom In” item and icon. Use named icon &quot;zoom-in&quot; or the label &quot;Zoom _In&quot;. The “Zoom Out” item and icon. Use named icon &quot;zoom-out&quot; or the label &quot;Zoom _Out&quot;. a #GtkStyle. A CSS class to match an accelerator. Refer to individual widget documentation for used style classes. A CSS class used when rendering an arrow element. Refer to individual widget documentation for used style classes. A CSS class to match the window background. Refer to individual widget documentation for used style classes. A CSS class to indicate an area at the bottom of a widget. Refer to individual widget documentation for used style classes. A CSS class to match buttons. Refer to individual widget documentation for used style classes. A CSS class to match calendars. Refer to individual widget documentation for used style classes. A CSS class to match content rendered in cell views. Refer to individual widget documentation for used style classes. A CSS class to match check boxes. Refer to individual widget documentation for used style classes. A CSS class to match combobox entries. Refer to individual widget documentation for used style classes. A CSS class to match context menus. Refer to individual widget documentation for used style classes. A CSS class that gets added to windows which have client-side decorations. Refer to individual widget documentation for used style classes. A CSS class used when rendering a drag handle for text selection. Refer to individual widget documentation for used style classes. A CSS class to match the default widget. Refer to individual widget documentation for used style classes. A CSS class used when an action (usually a button) is one that is expected to remove or destroy something visible to the user. Refer to individual widget documentation for used style classes. A CSS class to match dimmed labels. Refer to individual widget documentation for used style classes. A CSS class for a drag-and-drop indicator. Refer to individual widget documentation for used style classes. A CSS class defining a dock area. Refer to individual widget documentation for used style classes. A CSS class to match text entries. Refer to individual widget documentation for used style classes. A CSS class for an area displaying an error message, such as those in infobars. Refer to individual widget documentation for used style classes. A CSS class defining an expander, such as those in treeviews. Refer to individual widget documentation for used style classes. A CSS class that is added when widgets that usually have a frame or border (like buttons or entries) should appear without it. Refer to individual widget documentation for used style classes. A CSS class defining a frame delimiting content, such as #GtkFrame or the scrolled window frame around the scrollable area. Refer to individual widget documentation for used style classes. A CSS class defining a resize grip. Refer to individual widget documentation for used style classes. A CSS class to match a header element. Refer to individual widget documentation for used style classes. A CSS class defining a highlighted area, such as headings in assistants and calendars. Refer to individual widget documentation for used style classes. A CSS class for horizontally layered widgets. Refer to individual widget documentation for used style classes. A CSS class defining an image, such as the icon in an entry. Refer to individual widget documentation for used style classes. A CSS class for an area displaying an informational message, such as those in infobars. Refer to individual widget documentation for used style classes. A CSS class to match inline toolbars. Refer to individual widget documentation for used style classes. A CSS class used when rendering a drag handle for the insertion cursor position. Refer to individual widget documentation for used style classes. A CSS class to match labels. Refer to individual widget documentation for used style classes. A CSS class to indicate an area at the left of a widget. Refer to individual widget documentation for used style classes. A CSS class used when rendering a level indicator, such as a battery charge level, or a password strength. Refer to individual widget documentation for used style classes. A CSS class to match a linked area, such as a box containing buttons belonging to the same control. Refer to individual widget documentation for used style classes. A CSS class to match lists. Refer to individual widget documentation for used style classes. A CSS class to match list rows. Refer to individual widget documentation for used style classes. A CSS class defining marks in a widget, such as in scales. Refer to individual widget documentation for used style classes. A CSS class to match menus. Refer to individual widget documentation for used style classes. A CSS class to menubars. Refer to individual widget documentation for used style classes. A CSS class to match menu items. Refer to individual widget documentation for used style classes. A CSS class that is added to message dialogs. Refer to individual widget documentation for used style classes. A CSS class that is added to text view that should use a monospace font. Refer to individual widget documentation for used style classes. A CSS class used when an element needs the user attention, for instance a button in a stack switcher corresponding to a hidden page that changed state. Refer to individual widget documentation for used style classes. A CSS class defining a notebook. Refer to individual widget documentation for used style classes. A CSS class used when rendering an OSD (On Screen Display) element, on top of another container. Refer to individual widget documentation for used style classes. A CSS class that is added on the visual hints that happen when scrolling is attempted past the limits of a scrollable area. Refer to individual widget documentation for used style classes. A CSS class for a pane separator, such as those in #GtkPaned. Refer to individual widget documentation for used style classes. A CSS class that is added to areas that should look like paper. This is used in print previews and themes are encouraged to style it as black text on white background. Refer to individual widget documentation for used style classes. A CSS class that matches popovers. Refer to individual widget documentation for used style classes. A CSS class that is added to the toplevel windows used for menus. Refer to individual widget documentation for used style classes. A CSS class to match primary toolbars. Refer to individual widget documentation for used style classes. A CSS class to use when rendering activity as a progressbar. Refer to individual widget documentation for used style classes. A CSS class to use when rendering a pulse in an indeterminate progress bar. Refer to individual widget documentation for used style classes. A CSS class for an area displaying a question to the user, such as those in infobars. Refer to individual widget documentation for used style classes. A CSS class to match radio buttons. Refer to individual widget documentation for used style classes. A CSS class to match a raised control, such as a raised button on a toolbar. Refer to individual widget documentation for used style classes. A CSS class used to indicate a read-only state. Refer to individual widget documentation for used style classes. A CSS class to indicate an area at the right of a widget. Refer to individual widget documentation for used style classes. A CSS class to match the rubberband selection rectangle. Refer to individual widget documentation for used style classes. A CSS class to match scale widgets. Refer to individual widget documentation for used style classes. A CSS class to match scale widgets with marks attached, all the marks are above for horizontal #GtkScale. left for vertical #GtkScale. Refer to individual widget documentation for used style classes. A CSS class to match scale widgets with marks attached, all the marks are below for horizontal #GtkScale, right for vertical #GtkScale. Refer to individual widget documentation for used style classes. A CSS class to match scrollbars. Refer to individual widget documentation for used style classes. A CSS class to match the junction area between an horizontal and vertical scrollbar, when they’re both shown. Refer to individual widget documentation for used style classes. A CSS class for a separator. Refer to individual widget documentation for used style classes. A CSS class defining a sidebar, such as the left side in a file chooser. Refer to individual widget documentation for used style classes. A CSS class to match sliders. Refer to individual widget documentation for used style classes. A CSS class defining an spinbutton. Refer to individual widget documentation for used style classes. A CSS class to use when rendering activity as a “spinner”. Refer to individual widget documentation for used style classes. A CSS class to match statusbars. Refer to individual widget documentation for used style classes. A CSS class used for the subtitle label in a titlebar in a toplevel window. Refer to individual widget documentation for used style classes. A CSS class used when an action (usually a button) is the primary suggested action in a specific context. Refer to individual widget documentation for used style classes. A CSS class used for the title label in a titlebar in a toplevel window. Refer to individual widget documentation for used style classes. A CSS class used when rendering a titlebar in a toplevel window. Refer to individual widget documentation for used style classes. A CSS class to match toolbars. Refer to individual widget documentation for used style classes. A CSS class to match tooltip windows. Refer to individual widget documentation for used style classes. A CSS class to indicate an area at the top of a widget. Refer to individual widget documentation for used style classes. A CSS class for touch selection popups on entries and text views. Refer to individual widget documentation for used style classes. A CSS class to match troughs, as in scrollbars and progressbars. Refer to individual widget documentation for used style classes. A CSS class that is added on the visual hints that happen where content is 'scrolled off' and can be made visible by scrolling. Refer to individual widget documentation for used style classes. A CSS class for vertically layered widgets. Refer to individual widget documentation for used style classes. A CSS class defining a view, such as iconviews or treeviews. Refer to individual widget documentation for used style classes. A CSS class for an area displaying a warning message, such as those in infobars. Refer to individual widget documentation for used style classes. A CSS class to indicate that a UI element should be 'wide'. Used by #GtkPaned. Refer to individual widget documentation for used style classes. A property holding the background color of rendered elements as a #GdkRGBA. A property holding the element’s background as a #cairo_pattern_t. A property holding the element’s border color as a #GdkRGBA. A property holding the rendered element’s border radius in pixels as a #gint. A property holding the element’s border style as a #GtkBorderStyle. A property holding the rendered element’s border width in pixels as a #GtkBorder. The border is the intermediary spacing property of the padding/border/margin series. gtk_render_frame() uses this property to find out the frame line width, so #GtkWidgets rendering frames may need to add up this padding when requesting size A property holding the foreground color of rendered elements as a #GdkRGBA. A property holding the font properties used when rendering text as a #PangoFontDescription. A property holding the rendered element’s margin as a #GtkBorder. The margin is defined as the spacing between the border of the element and its surrounding elements. It is external to #GtkWidget's size allocations, and the most external spacing property of the padding/border/margin series. A property holding the rendered element’s padding as a #GtkBorder. The padding is defined as the spacing between the inner part of the element border and its child. It’s the innermost spacing property of the padding/border/margin series. A priority that can be used when adding a #GtkStyleProvider for application-specific style information. The priority used for default style information that is used in the absence of themes. Note that this is not very useful for providing default styling for custom style classes - themes are likely to override styling provided at this priority with catch-all `* {...}` rules. The priority used for style information provided via #GtkSettings. This priority is higher than #GTK_STYLE_PROVIDER_PRIORITY_THEME to let settings override themes. The priority used for style information provided by themes. The priority used for the style information from `XDG_CONFIG_HOME/gtk-3.0/gtk.css`. You should not use priorities higher than this, to give the user the last word. A widget region name to define a treeview column. Don't use regions. A widget region name to define a treeview column header. Don't use regions. A widget region name to define a treeview row. Don't use regions. A widget region name to define a notebook tab. Don't use regions. A GtkScale is a slider control used to select a numeric value. To use it, you’ll probably want to investigate the methods on its base class, #GtkRange, in addition to the methods for GtkScale itself. To set the value of a scale, you would normally use gtk_range_set_value(). To detect changes to the value, you would normally use the #GtkRange::value-changed signal. Note that using the same upper and lower bounds for the #GtkScale (through the #GtkRange methods) will hide the slider itself. This is useful for applications that want to show an undeterminate value on the scale, without changing the layout of the application (such as movie or music players). # GtkScale as GtkBuildable GtkScale supports a custom <marks> element, which can contain multiple <mark> elements. The “value” and “position” attributes have the same meaning as gtk_scale_add_mark() parameters of the same name. If the element is not empty, its content is taken as the markup to show at the mark. It can be translated with the usual ”translatable” and “context” attributes. # CSS nodes |[<!-- language="plain" --> scale[.fine-tune][.marks-before][.marks-after] ├── marks.top │ ├── mark │ ┊ ├── [label] │ ┊ ╰── indicator ┊ ┊ │ ╰── mark ├── [value] ├── contents │ ╰── trough │ ├── slider │ ├── [highlight] │ ╰── [fill] ╰── marks.bottom ├── mark ┊ ├── indicator ┊ ╰── [label] ╰── mark ]| GtkScale has a main CSS node with name scale and a subnode for its contents, with subnodes named trough and slider. The main node gets the style class .fine-tune added when the scale is in 'fine-tuning' mode. If the scale has an origin (see gtk_scale_set_has_origin()), there is a subnode with name highlight below the trough node that is used for rendering the highlighted part of the trough. If the scale is showing a fill level (see gtk_range_set_show_fill_level()), there is a subnode with name fill below the trough node that is used for rendering the filled in part of the trough. If marks are present, there is a marks subnode before or after the contents node, below which each mark gets a node with name mark. The marks nodes get either the .top or .bottom style class. The mark node has a subnode named indicator. If the mark has text, it also has a subnode named label. When the mark is either above or left of the scale, the label subnode is the first when present. Otherwise, the indicator subnode is the first. The main CSS node gets the 'marks-before' and/or 'marks-after' style classes added depending on what marks are present. If the scale is displaying the value (see #GtkScale:draw-value), there is subnode with name value. Creates a new #GtkScale. a new #GtkScale the scale’s orientation. the #GtkAdjustment which sets the range of the scale, or %NULL to create a new adjustment. Creates a new scale widget with the given orientation that lets the user input a number between @min and @max (including @min and @max) with the increment @step. @step must be nonzero; it’s the distance the slider moves when using the arrow keys to adjust the scale value. Note that the way in which the precision is derived works best if @step is a power of ten. If the resulting precision is not suitable for your needs, use gtk_scale_set_digits() to correct it. a new #GtkScale the scale’s orientation. minimum value maximum value step increment (tick size) used with keyboard shortcuts Obtains the coordinates where the scale will draw the #PangoLayout representing the text in the scale. Remember when using the #PangoLayout function you need to convert to and from pixels using PANGO_PIXELS() or #PANGO_SCALE. If the #GtkScale:draw-value property is %FALSE, the return values are undefined. a #GtkScale location to store X offset of layout, or %NULL location to store Y offset of layout, or %NULL Adds a mark at @value. A mark is indicated visually by drawing a tick mark next to the scale, and GTK+ makes it easy for the user to position the scale exactly at the marks value. If @markup is not %NULL, text is shown next to the tick mark. To remove marks from a scale, use gtk_scale_clear_marks(). a #GtkScale the value at which the mark is placed, must be between the lower and upper limits of the scales’ adjustment where to draw the mark. For a horizontal scale, #GTK_POS_TOP and %GTK_POS_LEFT are drawn above the scale, anything else below. For a vertical scale, #GTK_POS_LEFT and %GTK_POS_TOP are drawn to the left of the scale, anything else to the right. Text to be shown at the mark, using [Pango markup][PangoMarkupFormat], or %NULL Removes any marks that have been added with gtk_scale_add_mark(). a #GtkScale Gets the number of decimal places that are displayed in the value. the number of decimal places that are displayed a #GtkScale Returns whether the current value is displayed as a string next to the slider. whether the current value is displayed as a string a #GtkScale Returns whether the scale has an origin. %TRUE if the scale has an origin. a #GtkScale Gets the #PangoLayout used to display the scale. The returned object is owned by the scale so does not need to be freed by the caller. the #PangoLayout for this scale, or %NULL if the #GtkScale:draw-value property is %FALSE. A #GtkScale Obtains the coordinates where the scale will draw the #PangoLayout representing the text in the scale. Remember when using the #PangoLayout function you need to convert to and from pixels using PANGO_PIXELS() or #PANGO_SCALE. If the #GtkScale:draw-value property is %FALSE, the return values are undefined. a #GtkScale location to store X offset of layout, or %NULL location to store Y offset of layout, or %NULL Gets the position in which the current value is displayed. the position in which the current value is displayed a #GtkScale Sets the number of decimal places that are displayed in the value. Also causes the value of the adjustment to be rounded to this number of digits, so the retrieved value matches the displayed one, if #GtkScale:draw-value is %TRUE when the value changes. If you want to enforce rounding the value when #GtkScale:draw-value is %FALSE, you can set #GtkRange:round-digits instead. Note that rounding to a small number of digits can interfere with the smooth autoscrolling that is built into #GtkScale. As an alternative, you can use the #GtkScale::format-value signal to format the displayed value yourself. a #GtkScale the number of decimal places to display, e.g. use 1 to display 1.0, 2 to display 1.00, etc Specifies whether the current value is displayed as a string next to the slider. a #GtkScale %TRUE to draw the value If #GtkScale:has-origin is set to %TRUE (the default), the scale will highlight the part of the trough between the origin (bottom or left side) and the current value. a #GtkScale %TRUE if the scale has an origin Sets the position in which the current value is displayed. a #GtkScale the position in which the current value is displayed Signal which allows you to change how the scale value is displayed. Connect a signal handler which returns an allocated string representing @value. That string will then be used to display the scale's value. If no user-provided handlers are installed, the value will be displayed on its own, rounded according to the value of the #GtkScale:digits property. Here's an example signal handler which displays a value 1.0 as with "-->1.0<--". |[<!-- language="C" --> static gchar* format_value_callback (GtkScale *scale, gdouble value) { return g_strdup_printf ("-->\%0.*g<--", gtk_scale_get_digits (scale), value); } ]| allocated string representing @value the value to format #GtkScaleButton provides a button which pops up a scale widget. This kind of widget is commonly used for volume controls in multimedia applications, and GTK+ provides a #GtkVolumeButton subclass that is tailored for this use case. # CSS nodes GtkScaleButton has a single CSS node with name button. To differentiate it from a plain #GtkButton, it gets the .scale style class. The popup widget that contains the scale has a .scale-popup style class. Creates a #GtkScaleButton, with a range between @min and @max, with a stepping of @step. a new #GtkScaleButton a stock icon size (#GtkIconSize) the minimum value of the scale (usually 0) the maximum value of the scale (usually 100) the stepping of value when a scroll-wheel event, or up/down arrow event occurs (usually 2) a %NULL-terminated array of icon names, or %NULL if you want to set the list later with gtk_scale_button_set_icons() Gets the #GtkAdjustment associated with the #GtkScaleButton’s scale. See gtk_range_get_adjustment() for details. the adjustment associated with the scale a #GtkScaleButton Retrieves the minus button of the #GtkScaleButton. the minus button of the #GtkScaleButton as a #GtkButton a #GtkScaleButton Retrieves the plus button of the #GtkScaleButton. the plus button of the #GtkScaleButton as a #GtkButton a #GtkScaleButton Retrieves the popup of the #GtkScaleButton. the popup of the #GtkScaleButton a #GtkScaleButton Gets the current value of the scale button. current value of the scale button a #GtkScaleButton Sets the #GtkAdjustment to be used as a model for the #GtkScaleButton’s scale. See gtk_range_set_adjustment() for details. a #GtkScaleButton a #GtkAdjustment Sets the icons to be used by the scale button. For details, see the #GtkScaleButton:icons property. a #GtkScaleButton a %NULL-terminated array of icon names Sets the current value of the scale; if the value is outside the minimum or maximum range values, it will be clamped to fit inside them. The scale button emits the #GtkScaleButton::value-changed signal if the value changes. a #GtkScaleButton new value of the scale button The names of the icons to be used by the scale button. The first item in the array will be used in the button when the current value is the lowest value, the second item for the highest value. All the subsequent icons will be used for all the other values, spread evenly over the range of values. If there's only one icon name in the @icons array, it will be used for all the values. If only two icon names are in the @icons array, the first one will be used for the bottom 50% of the scale, and the second one for the top 50%. It is recommended to use at least 3 icons so that the #GtkScaleButton reflects the current value of the scale better for the users. The ::popdown signal is a [keybinding signal][GtkBindingSignal] which gets emitted to popdown the scale widget. The default binding for this signal is Escape. The ::popup signal is a [keybinding signal][GtkBindingSignal] which gets emitted to popup the scale widget. The default bindings for this signal are Space, Enter and Return. The ::value-changed signal is emitted when the value field has changed. the new value a #GtkScale location to store X offset of layout, or %NULL location to store Y offset of layout, or %NULL Scroll in steps. Scroll by pages. Scroll to ends. Scroll in horizontal steps. Scroll by horizontal pages. Scroll to the horizontal ends. Scrolling types. No scrolling. Jump to new location. Step backward. Step forward. Page backward. Page forward. Step up. Step down. Page up. Page down. Step to the left. Step to the right. Page to the left. Page to the right. Scroll to start. Scroll to end. #GtkScrollable is an interface that is implemented by widgets with native scrolling ability. To implement this interface you should override the #GtkScrollable:hadjustment and #GtkScrollable:vadjustment properties. ## Creating a scrollable widget All scrollable widgets should do the following. - When a parent widget sets the scrollable child widget’s adjustments, the widget should populate the adjustments’ #GtkAdjustment:lower, #GtkAdjustment:upper, #GtkAdjustment:step-increment, #GtkAdjustment:page-increment and #GtkAdjustment:page-size properties and connect to the #GtkAdjustment::value-changed signal. - Because its preferred size is the size for a fully expanded widget, the scrollable widget must be able to cope with underallocations. This means that it must accept any value passed to its #GtkWidgetClass.size_allocate() function. - When the parent allocates space to the scrollable child widget, the widget should update the adjustments’ properties with new values. - When any of the adjustments emits the #GtkAdjustment::value-changed signal, the scrollable widget should scroll its contents. Returns the size of a non-scrolling border around the outside of the scrollable. An example for this would be treeview headers. GTK+ can use this information to display overlayed graphics, like the overshoot indication, at the right position. %TRUE if @border has been set a #GtkScrollable return location for the results Returns the size of a non-scrolling border around the outside of the scrollable. An example for this would be treeview headers. GTK+ can use this information to display overlayed graphics, like the overshoot indication, at the right position. %TRUE if @border has been set a #GtkScrollable return location for the results Retrieves the #GtkAdjustment used for horizontal scrolling. horizontal #GtkAdjustment. a #GtkScrollable Gets the horizontal #GtkScrollablePolicy. The horizontal #GtkScrollablePolicy. a #GtkScrollable Retrieves the #GtkAdjustment used for vertical scrolling. vertical #GtkAdjustment. a #GtkScrollable Gets the vertical #GtkScrollablePolicy. The vertical #GtkScrollablePolicy. a #GtkScrollable Sets the horizontal adjustment of the #GtkScrollable. a #GtkScrollable a #GtkAdjustment Sets the #GtkScrollablePolicy to determine whether horizontal scrolling should start below the minimum width or below the natural width. a #GtkScrollable the horizontal #GtkScrollablePolicy Sets the vertical adjustment of the #GtkScrollable. a #GtkScrollable a #GtkAdjustment Sets the #GtkScrollablePolicy to determine whether vertical scrolling should start below the minimum height or below the natural height. a #GtkScrollable the vertical #GtkScrollablePolicy Horizontal #GtkAdjustment of the scrollable widget. This adjustment is shared between the scrollable widget and its parent. Determines whether horizontal scrolling should start once the scrollable widget is allocated less than its minimum width or less than its natural width. Verical #GtkAdjustment of the scrollable widget. This adjustment is shared between the scrollable widget and its parent. Determines whether vertical scrolling should start once the scrollable widget is allocated less than its minimum height or less than its natural height. %TRUE if @border has been set a #GtkScrollable return location for the results Defines the policy to be used in a scrollable widget when updating the scrolled window adjustments in a given orientation. Scrollable adjustments are based on the minimum size Scrollable adjustments are based on the natural size The #GtkScrollbar widget is a horizontal or vertical scrollbar, depending on the value of the #GtkOrientable:orientation property. Its position and movement are controlled by the adjustment that is passed to or created by gtk_scrollbar_new(). See #GtkAdjustment for more details. The #GtkAdjustment:value field sets the position of the thumb and must be between #GtkAdjustment:lower and #GtkAdjustment:upper - #GtkAdjustment:page-size. The #GtkAdjustment:page-size represents the size of the visible scrollable area. The fields #GtkAdjustment:step-increment and #GtkAdjustment:page-increment fields are added to or subtracted from the #GtkAdjustment:value when the user asks to move by a step (using e.g. the cursor arrow keys or, if present, the stepper buttons) or by a page (using e.g. the Page Down/Up keys). # CSS nodes |[<!-- language="plain" --> scrollbar[.fine-tune] ╰── contents ├── [button.up] ├── [button.down] ├── trough │ ╰── slider ├── [button.up] ╰── [button.down] ]| GtkScrollbar has a main CSS node with name scrollbar and a subnode for its contents, with subnodes named trough and slider. The main node gets the style class .fine-tune added when the scrollbar is in 'fine-tuning' mode. If steppers are enabled, they are represented by up to four additional subnodes with name button. These get the style classes .up and .down to indicate in which direction they are moving. Other style classes that may be added to scrollbars inside #GtkScrolledWindow include the positional classes (.left, .right, .top, .bottom) and style classes related to overlay scrolling (.overlay-indicator, .dragging, .hovering). Creates a new scrollbar with the given orientation. the new #GtkScrollbar. the scrollbar’s orientation. the #GtkAdjustment to use, or %NULL to create a new adjustment. GtkScrolledWindow is a container that accepts a single child widget, makes that child scrollable using either internally added scrollbars or externally associated adjustments, and optionally draws a frame around the child. Widgets with native scrolling support, i.e. those whose classes implement the #GtkScrollable interface, are added directly. For other types of widget, the class #GtkViewport acts as an adaptor, giving scrollability to other widgets. GtkScrolledWindow’s implementation of gtk_container_add() intelligently accounts for whether or not the added child is a #GtkScrollable. If it isn’t, #GtkScrolledWindow wraps the child in a #GtkViewport and adds that for you. Therefore, you can just add any child widget and not worry about the details. If gtk_container_add() has added a #GtkViewport for you, you can remove both your added child widget from the #GtkViewport, and the #GtkViewport from the GtkScrolledWindow, like this: |[<!-- language="C" --> GtkWidget *scrolled_window = gtk_scrolled_window_new (NULL, NULL); GtkWidget *child_widget = gtk_button_new (); // GtkButton is not a GtkScrollable, so GtkScrolledWindow will automatically // add a GtkViewport. gtk_container_add (GTK_CONTAINER (scrolled_window), child_widget); // Either of these will result in child_widget being unparented: gtk_container_remove (GTK_CONTAINER (scrolled_window), child_widget); // or gtk_container_remove (GTK_CONTAINER (scrolled_window), gtk_bin_get_child (GTK_BIN (scrolled_window))); ]| Unless #GtkScrolledWindow:policy is GTK_POLICY_NEVER or GTK_POLICY_EXTERNAL, GtkScrolledWindow adds internal #GtkScrollbar widgets around its child. The scroll position of the child, and if applicable the scrollbars, is controlled by the #GtkScrolledWindow:hadjustment and #GtkScrolledWindow:vadjustment that are associated with the GtkScrolledWindow. See the docs on #GtkScrollbar for the details, but note that the “step_increment” and “page_increment” fields are only effective if the policy causes scrollbars to be present. If a GtkScrolledWindow doesn’t behave quite as you would like, or doesn’t have exactly the right layout, it’s very possible to set up your own scrolling with #GtkScrollbar and for example a #GtkGrid. # Touch support GtkScrolledWindow has built-in support for touch devices. When a touchscreen is used, swiping will move the scrolled window, and will expose 'kinetic' behavior. This can be turned off with the #GtkScrolledWindow:kinetic-scrolling property if it is undesired. GtkScrolledWindow also displays visual 'overshoot' indication when the content is pulled beyond the end, and this situation can be captured with the #GtkScrolledWindow::edge-overshot signal. If no mouse device is present, the scrollbars will overlayed as narrow, auto-hiding indicators over the content. If traditional scrollbars are desired although no mouse is present, this behaviour can be turned off with the #GtkScrolledWindow:overlay-scrolling property. # CSS nodes GtkScrolledWindow has a main CSS node with name scrolledwindow. It uses subnodes with names overshoot and undershoot to draw the overflow and underflow indications. These nodes get the .left, .right, .top or .bottom style class added depending on where the indication is drawn. GtkScrolledWindow also sets the positional style classes (.left, .right, .top, .bottom) and style classes related to overlay scrolling (.overlay-indicator, .dragging, .hovering) on its scrollbars. If both scrollbars are visible, the area where they meet is drawn with a subnode named junction. Creates a new scrolled window. The two arguments are the scrolled window’s adjustments; these will be shared with the scrollbars and the child widget to keep the bars in sync with the child. Usually you want to pass %NULL for the adjustments, which will cause the scrolled window to create them for you. a new scrolled window horizontal adjustment vertical adjustment Used to add children without native scrolling capabilities. This is simply a convenience function; it is equivalent to adding the unscrollable child to a viewport, then adding the viewport to the scrolled window. If a child has native scrolling, use gtk_container_add() instead of this function. The viewport scrolls the child by moving its #GdkWindow, and takes the size of the child to be the size of its toplevel #GdkWindow. This will be very wrong for most widgets that support native scrolling; for example, if you add a widget such as #GtkTreeView with a viewport, the whole widget will scroll, including the column headings. Thus, widgets with native scrolling support should not be used with the #GtkViewport proxy. A widget supports scrolling natively if it implements the #GtkScrollable interface. gtk_container_add() will automatically add a #GtkViewport if the child doesn’t implement #GtkScrollable. a #GtkScrolledWindow the widget you want to scroll Return whether button presses are captured during kinetic scrolling. See gtk_scrolled_window_set_capture_button_press(). %TRUE if button presses are captured during kinetic scrolling a #GtkScrolledWindow Returns the horizontal scrollbar’s adjustment, used to connect the horizontal scrollbar to the child widget’s horizontal scroll functionality. the horizontal #GtkAdjustment a #GtkScrolledWindow Returns the horizontal scrollbar of @scrolled_window. the horizontal scrollbar of the scrolled window. a #GtkScrolledWindow Returns the specified kinetic scrolling behavior. the scrolling behavior flags. a #GtkScrolledWindow Returns the maximum content height set. the maximum content height, or -1 a #GtkScrolledWindow Returns the maximum content width set. the maximum content width, or -1 a #GtkScrolledWindow Gets the minimal content height of @scrolled_window, or -1 if not set. the minimal content height a #GtkScrolledWindow Gets the minimum content width of @scrolled_window, or -1 if not set. the minimum content width a #GtkScrolledWindow Returns whether overlay scrolling is enabled for this scrolled window. %TRUE if overlay scrolling is enabled a #GtkScrolledWindow Gets the placement of the contents with respect to the scrollbars for the scrolled window. See gtk_scrolled_window_set_placement(). the current placement value. See also gtk_scrolled_window_set_placement() and gtk_scrolled_window_unset_placement(). a #GtkScrolledWindow Retrieves the current policy values for the horizontal and vertical scrollbars. See gtk_scrolled_window_set_policy(). a #GtkScrolledWindow location to store the policy for the horizontal scrollbar, or %NULL location to store the policy for the vertical scrollbar, or %NULL Reports whether the natural height of the child will be calculated and propagated through the scrolled window’s requested natural height. whether natural height propagation is enabled. a #GtkScrolledWindow Reports whether the natural width of the child will be calculated and propagated through the scrolled window’s requested natural width. whether natural width propagation is enabled. a #GtkScrolledWindow Gets the shadow type of the scrolled window. See gtk_scrolled_window_set_shadow_type(). the current shadow type a #GtkScrolledWindow Returns the vertical scrollbar’s adjustment, used to connect the vertical scrollbar to the child widget’s vertical scroll functionality. the vertical #GtkAdjustment a #GtkScrolledWindow Returns the vertical scrollbar of @scrolled_window. the vertical scrollbar of the scrolled window. a #GtkScrolledWindow Changes the behaviour of @scrolled_window with regard to the initial event that possibly starts kinetic scrolling. When @capture_button_press is set to %TRUE, the event is captured by the scrolled window, and then later replayed if it is meant to go to the child widget. This should be enabled if any child widgets perform non-reversible actions on #GtkWidget::button-press-event. If they don't, and handle additionally handle #GtkWidget::grab-broken-event, it might be better to set @capture_button_press to %FALSE. This setting only has an effect if kinetic scrolling is enabled. a #GtkScrolledWindow %TRUE to capture button presses Sets the #GtkAdjustment for the horizontal scrollbar. a #GtkScrolledWindow the #GtkAdjustment to use, or %NULL to create a new one Turns kinetic scrolling on or off. Kinetic scrolling only applies to devices with source %GDK_SOURCE_TOUCHSCREEN. a #GtkScrolledWindow %TRUE to enable kinetic scrolling Sets the maximum height that @scrolled_window should keep visible. The @scrolled_window will grow up to this height before it starts scrolling the content. It is a programming error to set the maximum content height to a value smaller than #GtkScrolledWindow:min-content-height. a #GtkScrolledWindow the maximum content height Sets the maximum width that @scrolled_window should keep visible. The @scrolled_window will grow up to this width before it starts scrolling the content. It is a programming error to set the maximum content width to a value smaller than #GtkScrolledWindow:min-content-width. a #GtkScrolledWindow the maximum content width Sets the minimum height that @scrolled_window should keep visible. Note that this can and (usually will) be smaller than the minimum size of the content. It is a programming error to set the minimum content height to a value greater than #GtkScrolledWindow:max-content-height. a #GtkScrolledWindow the minimal content height Sets the minimum width that @scrolled_window should keep visible. Note that this can and (usually will) be smaller than the minimum size of the content. It is a programming error to set the minimum content width to a value greater than #GtkScrolledWindow:max-content-width. a #GtkScrolledWindow the minimal content width Enables or disables overlay scrolling for this scrolled window. a #GtkScrolledWindow whether to enable overlay scrolling Sets the placement of the contents with respect to the scrollbars for the scrolled window. The default is %GTK_CORNER_TOP_LEFT, meaning the child is in the top left, with the scrollbars underneath and to the right. Other values in #GtkCornerType are %GTK_CORNER_TOP_RIGHT, %GTK_CORNER_BOTTOM_LEFT, and %GTK_CORNER_BOTTOM_RIGHT. See also gtk_scrolled_window_get_placement() and gtk_scrolled_window_unset_placement(). a #GtkScrolledWindow position of the child window Sets the scrollbar policy for the horizontal and vertical scrollbars. The policy determines when the scrollbar should appear; it is a value from the #GtkPolicyType enumeration. If %GTK_POLICY_ALWAYS, the scrollbar is always present; if %GTK_POLICY_NEVER, the scrollbar is never present; if %GTK_POLICY_AUTOMATIC, the scrollbar is present only if needed (that is, if the slider part of the bar would be smaller than the trough — the display is larger than the page size). a #GtkScrolledWindow policy for horizontal bar policy for vertical bar Sets whether the natural height of the child should be calculated and propagated through the scrolled window’s requested natural height. a #GtkScrolledWindow whether to propagate natural height Sets whether the natural width of the child should be calculated and propagated through the scrolled window’s requested natural width. a #GtkScrolledWindow whether to propagate natural width Changes the type of shadow drawn around the contents of @scrolled_window. a #GtkScrolledWindow kind of shadow to draw around scrolled window contents Sets the #GtkAdjustment for the vertical scrollbar. a #GtkScrolledWindow the #GtkAdjustment to use, or %NULL to create a new one Unsets the placement of the contents with respect to the scrollbars for the scrolled window. If no window placement is set for a scrolled window, it defaults to %GTK_CORNER_TOP_LEFT. See also gtk_scrolled_window_set_placement() and gtk_scrolled_window_get_placement(). a #GtkScrolledWindow Whether kinetic scrolling is enabled or not. Kinetic scrolling only applies to devices with source %GDK_SOURCE_TOUCHSCREEN. The maximum content height of @scrolled_window, or -1 if not set. The maximum content width of @scrolled_window, or -1 if not set. The minimum content height of @scrolled_window, or -1 if not set. The minimum content width of @scrolled_window, or -1 if not set. Whether overlay scrolling is enabled or not. If it is, the scrollbars are only added as traditional widgets when a mouse is present. Otherwise, they are overlayed on top of the content, as narrow indicators. Note that overlay scrolling can also be globally disabled, with the #GtkSettings::gtk-overlay-scrolling setting. Whether the natural height of the child should be calculated and propagated through the scrolled window’s requested natural height. This is useful in cases where an attempt should be made to allocate exactly enough space for the natural size of the child. Whether the natural width of the child should be calculated and propagated through the scrolled window’s requested natural width. This is useful in cases where an attempt should be made to allocate exactly enough space for the natural size of the child. Whether "window-placement" should be used to determine the location of the contents with respect to the scrollbars. This value is ignored and #GtkScrolledWindow:window-placement value is always honored. The ::edge-overshot signal is emitted whenever user initiated scrolling makes the scrolled window firmly surpass (i.e. with some edge resistance) the lower or upper limits defined by the adjustment in that orientation. A similar behavior without edge resistance is provided by the #GtkScrolledWindow::edge-reached signal. Note: The @pos argument is LTR/RTL aware, so callers should be aware too if intending to provide behavior on horizontal edges. edge side that was hit The ::edge-reached signal is emitted whenever user-initiated scrolling makes the scrolled window exactly reach the lower or upper limits defined by the adjustment in that orientation. A similar behavior with edge resistance is provided by the #GtkScrolledWindow::edge-overshot signal. Note: The @pos argument is LTR/RTL aware, so callers should be aware too if intending to provide behavior on horizontal edges. edge side that was reached The ::move-focus-out signal is a [keybinding signal][GtkBindingSignal] which gets emitted when focus is moved away from the scrolled window by a keybinding. The #GtkWidget::move-focus signal is emitted with @direction_type on this scrolled window’s toplevel parent in the container hierarchy. The default bindings for this signal are `Ctrl + Tab` to move forward and `Ctrl + Shift + Tab` to move backward. either %GTK_DIR_TAB_FORWARD or %GTK_DIR_TAB_BACKWARD The ::scroll-child signal is a [keybinding signal][GtkBindingSignal] which gets emitted when a keybinding that scrolls is pressed. The horizontal or vertical adjustment is updated which triggers a signal that the scrolled window’s child may listen to and scroll itself. a #GtkScrollType describing how much to scroll whether the keybinding scrolls the child horizontally or not The parent class. #GtkSearchBar is a container made to have a search entry (possibly with additional connex widgets, such as drop-down menus, or buttons) built-in. The search bar would appear when a search is started through typing on the keyboard, or the application’s search mode is toggled on. For keyboard presses to start a search, events will need to be forwarded from the top-level window that contains the search bar. See gtk_search_bar_handle_event() for example code. Common shortcuts such as Ctrl+F should be handled as an application action, or through the menu items. You will also need to tell the search bar about which entry you are using as your search entry using gtk_search_bar_connect_entry(). The following example shows you how to create a more complex search entry. # CSS nodes GtkSearchBar has a single CSS node with name searchbar. ## Creating a search bar [A simple example](https://gitlab.gnome.org/GNOME/gtk/blob/gtk-3-24/examples/search-bar.c) Creates a #GtkSearchBar. You will need to tell it about which widget is going to be your text entry using gtk_search_bar_connect_entry(). a new #GtkSearchBar Connects the #GtkEntry widget passed as the one to be used in this search bar. The entry should be a descendant of the search bar. This is only required if the entry isn’t the direct child of the search bar (as in our main example). a #GtkSearchBar a #GtkEntry Returns whether the search mode is on or off. whether search mode is toggled on a #GtkSearchBar Returns whether the close button is shown. whether the close button is shown a #GtkSearchBar This function should be called when the top-level window which contains the search bar received a key event. If the key event is handled by the search bar, the bar will be shown, the entry populated with the entered text and %GDK_EVENT_STOP will be returned. The caller should ensure that events are not propagated further. If no entry has been connected to the search bar, using gtk_search_bar_connect_entry(), this function will return immediately with a warning. ## Showing the search bar on key presses |[<!-- language="C" --> static gboolean on_key_press_event (GtkWidget *widget, GdkEvent *event, gpointer user_data) { GtkSearchBar *bar = GTK_SEARCH_BAR (user_data); return gtk_search_bar_handle_event (bar, event); } static void create_toplevel (void) { GtkWidget *window = gtk_window_new (GTK_WINDOW_TOPLEVEL); GtkWindow *search_bar = gtk_search_bar_new (); // Add more widgets to the window... g_signal_connect (window, "key-press-event", G_CALLBACK (on_key_press_event), search_bar); } ]| %GDK_EVENT_STOP if the key press event resulted in text being entered in the search entry (and revealing the search bar if necessary), %GDK_EVENT_PROPAGATE otherwise. a #GtkSearchBar a #GdkEvent containing key press events Switches the search mode on or off. a #GtkSearchBar the new state of the search mode Shows or hides the close button. Applications that already have a “search” toggle button should not show a close button in their search bar, as it duplicates the role of the toggle button. a #GtkSearchBar whether the close button will be shown or not The parent class. #GtkSearchEntry is a subclass of #GtkEntry that has been tailored for use as a search entry. It will show an inactive symbolic “find” icon when the search entry is empty, and a symbolic “clear” icon when there is text. Clicking on the “clear” icon will empty the search entry. Note that the search/clear icon is shown using a secondary icon, and thus does not work if you are using the secondary icon position for some other purpose. To make filtering appear more reactive, it is a good idea to not react to every change in the entry text immediately, but only after a short delay. To support this, #GtkSearchEntry emits the #GtkSearchEntry::search-changed signal which can be used instead of the #GtkEditable::changed signal. The #GtkSearchEntry::previous-match, #GtkSearchEntry::next-match and #GtkSearchEntry::stop-search signals can be used to implement moving between search results and ending the search. Often, GtkSearchEntry will be fed events by means of being placed inside a #GtkSearchBar. If that is not the case, you can use gtk_search_entry_handle_event() to pass events. Creates a #GtkSearchEntry, with a find icon when the search field is empty, and a clear icon when it isn't. a new #GtkSearchEntry This function should be called when the top-level window which contains the search entry received a key event. If the entry is part of a #GtkSearchBar, it is preferable to call gtk_search_bar_handle_event() instead, which will reveal the entry in addition to passing the event to this function. If the key event is handled by the search entry and starts or continues a search, %GDK_EVENT_STOP will be returned. The caller should ensure that the entry is shown in this case, and not propagate the event further. %GDK_EVENT_STOP if the key press event resulted in a search beginning or continuing, %GDK_EVENT_PROPAGATE otherwise. a #GtkSearchEntry a key event The ::next-match signal is a [keybinding signal][GtkBindingSignal] which gets emitted when the user initiates a move to the next match for the current search string. Applications should connect to it, to implement moving between matches. The default bindings for this signal is Ctrl-g. The ::previous-match signal is a [keybinding signal][GtkBindingSignal] which gets emitted when the user initiates a move to the previous match for the current search string. Applications should connect to it, to implement moving between matches. The default bindings for this signal is Ctrl-Shift-g. The #GtkSearchEntry::search-changed signal is emitted with a short delay of 150 milliseconds after the last change to the entry text. The ::stop-search signal is a [keybinding signal][GtkBindingSignal] which gets emitted when the user stops a search via keyboard input. Applications should connect to it, to implement hiding the search entry in this case. The default bindings for this signal is Escape. Makes a copy of a #GtkSelectionData-struct and its data. a pointer to a copy of @data. a pointer to a #GtkSelectionData-struct. Frees a #GtkSelectionData-struct returned from gtk_selection_data_copy(). a pointer to a #GtkSelectionData-struct. Retrieves the raw data of the selection. the raw data of the selection. a pointer to a #GtkSelectionData-struct. Retrieves the data type of the selection. the data type of the selection. a pointer to a #GtkSelectionData-struct. Retrieves the raw data of the selection along with its length. the raw data of the selection a pointer to a #GtkSelectionData-struct. return location for length of the data segment Retrieves the display of the selection. the display of the selection. a pointer to a #GtkSelectionData-struct. Retrieves the format of the selection. the format of the selection. a pointer to a #GtkSelectionData-struct. Retrieves the length of the raw data of the selection. the length of the data of the selection. a pointer to a #GtkSelectionData-struct. Gets the contents of the selection data as a #GdkPixbuf. if the selection data contained a recognized image type and it could be converted to a #GdkPixbuf, a newly allocated pixbuf is returned, otherwise %NULL. If the result is non-%NULL it must be freed with g_object_unref(). a #GtkSelectionData Retrieves the selection #GdkAtom of the selection data. the selection #GdkAtom of the selection data. a pointer to a #GtkSelectionData-struct. Retrieves the target of the selection. the target of the selection. a pointer to a #GtkSelectionData-struct. Gets the contents of @selection_data as an array of targets. This can be used to interpret the results of getting the standard TARGETS target that is always supplied for any selection. %TRUE if @selection_data contains a valid array of targets, otherwise %FALSE. a #GtkSelectionData object location to store an array of targets. The result stored here must be freed with g_free(). location to store number of items in @targets. Gets the contents of the selection data as a UTF-8 string. if the selection data contained a recognized text type and it could be converted to UTF-8, a newly allocated string containing the converted text, otherwise %NULL. If the result is non-%NULL it must be freed with g_free(). a #GtkSelectionData Gets the contents of the selection data as array of URIs. if the selection data contains a list of URIs, a newly allocated %NULL-terminated string array containing the URIs, otherwise %NULL. If the result is non-%NULL it must be freed with g_strfreev(). a #GtkSelectionData Stores new data into a #GtkSelectionData object. Should only be called from a selection handler callback. Zero-terminates the stored data. a pointer to a #GtkSelectionData-struct. the type of selection data format (number of bits in a unit) pointer to the data (will be copied) length of the data Sets the contents of the selection from a #GdkPixbuf The pixbuf is converted to the form determined by @selection_data->target. %TRUE if the selection was successfully set, otherwise %FALSE. a #GtkSelectionData a #GdkPixbuf Sets the contents of the selection from a UTF-8 encoded string. The string is converted to the form determined by @selection_data->target. %TRUE if the selection was successfully set, otherwise %FALSE. a #GtkSelectionData a UTF-8 string the length of @str, or -1 if @str is nul-terminated. Sets the contents of the selection from a list of URIs. The string is converted to the form determined by @selection_data->target. %TRUE if the selection was successfully set, otherwise %FALSE. a #GtkSelectionData a %NULL-terminated array of strings holding URIs Given a #GtkSelectionData object holding a list of targets, determines if any of the targets in @targets can be used to provide a #GdkPixbuf. %TRUE if @selection_data holds a list of targets, and a suitable target for images is included, otherwise %FALSE. a #GtkSelectionData object whether to accept only targets for which GTK+ knows how to convert a pixbuf into the format Given a #GtkSelectionData object holding a list of targets, determines if any of the targets in @targets can be used to provide rich text. %TRUE if @selection_data holds a list of targets, and a suitable target for rich text is included, otherwise %FALSE. a #GtkSelectionData object a #GtkTextBuffer Given a #GtkSelectionData object holding a list of targets, determines if any of the targets in @targets can be used to provide text. %TRUE if @selection_data holds a list of targets, and a suitable target for text is included, otherwise %FALSE. a #GtkSelectionData object Given a #GtkSelectionData object holding a list of targets, determines if any of the targets in @targets can be used to provide a list or URIs. %TRUE if @selection_data holds a list of targets, and a suitable target for URI lists is included, otherwise %FALSE. a #GtkSelectionData object Used to control what selections users are allowed to make. No selection is possible. Zero or one element may be selected. Exactly one element is selected. In some circumstances, such as initially or during a search operation, it’s possible for no element to be selected with %GTK_SELECTION_BROWSE. What is really enforced is that the user can’t deselect a currently selected element except by selecting another element. Any number of elements may be selected. The Ctrl key may be used to enlarge the selection, and Shift key to select between the focus and the child pointed to. Some widgets may also allow Click-drag to select a range of elements. Determines how GTK+ handles the sensitivity of stepper arrows at the end of range widgets. The arrow is made insensitive if the thumb is at the end The arrow is always sensitive The arrow is always insensitive GtkSeparator is a horizontal or vertical separator widget, depending on the value of the #GtkOrientable:orientation property, used to group the widgets within a window. It displays a line with a shadow to make it appear sunken into the interface. # CSS nodes GtkSeparator has a single CSS node with name separator. The node gets one of the .horizontal or .vertical style classes. Creates a new #GtkSeparator with the given orientation. a new #GtkSeparator. the separator’s orientation. The #GtkSeparatorMenuItem is a separator used to group items within a menu. It displays a horizontal line with a shadow to make it appear sunken into the interface. # CSS nodes GtkSeparatorMenuItem has a single CSS node with name separator. Creates a new #GtkSeparatorMenuItem. a new #GtkSeparatorMenuItem. The parent class. A #GtkSeparatorToolItem is a #GtkToolItem that separates groups of other #GtkToolItems. Depending on the theme, a #GtkSeparatorToolItem will often look like a vertical line on horizontally docked toolbars. If the #GtkToolbar child property “expand” is %TRUE and the property #GtkSeparatorToolItem:draw is %FALSE, a #GtkSeparatorToolItem will act as a “spring” that forces other items to the ends of the toolbar. Use gtk_separator_tool_item_new() to create a new #GtkSeparatorToolItem. # CSS nodes GtkSeparatorToolItem has a single CSS node with name separator. Create a new #GtkSeparatorToolItem the new #GtkSeparatorToolItem Returns whether @item is drawn as a line, or just blank. See gtk_separator_tool_item_set_draw(). %TRUE if @item is drawn as a line, or just blank. a #GtkSeparatorToolItem Whether @item is drawn as a vertical line, or just blank. Setting this to %FALSE along with gtk_tool_item_set_expand() is useful to create an item that forces following items to the end of the toolbar. a #GtkSeparatorToolItem whether @item is drawn as a vertical line The parent class. GtkSettings provide a mechanism to share global settings between applications. On the X window system, this sharing is realized by an [XSettings](http://www.freedesktop.org/wiki/Specifications/xsettings-spec) manager that is usually part of the desktop environment, along with utilities that let the user change these settings. In the absence of an Xsettings manager, GTK+ reads default values for settings from `settings.ini` files in `/etc/gtk-3.0`, `$XDG_CONFIG_DIRS/gtk-3.0` and `$XDG_CONFIG_HOME/gtk-3.0`. These files must be valid key files (see #GKeyFile), and have a section called Settings. Themes can also provide default values for settings by installing a `settings.ini` file next to their `gtk.css` file. Applications can override system-wide settings by setting the property of the GtkSettings object with g_object_set(). This should be restricted to special cases though; GtkSettings are not meant as an application configuration facility. When doing so, you need to be aware that settings that are specific to individual widgets may not be available before the widget type has been realized at least once. The following example demonstrates a way to do this: |[<!-- language="C" --> gtk_init (&argc, &argv); // make sure the type is realized g_type_class_unref (g_type_class_ref (GTK_TYPE_IMAGE_MENU_ITEM)); g_object_set (gtk_settings_get_default (), "gtk-enable-animations", FALSE, NULL); ]| There is one GtkSettings instance per screen. It can be obtained with gtk_settings_get_for_screen(), but in many cases, it is more convenient to use gtk_widget_get_settings(). gtk_settings_get_default() returns the GtkSettings instance for the default screen. Gets the #GtkSettings object for the default GDK screen, creating it if necessary. See gtk_settings_get_for_screen(). a #GtkSettings object. If there is no default screen, then returns %NULL. Gets the #GtkSettings object for @screen, creating it if necessary. a #GtkSettings object. a #GdkScreen. This function is not useful outside GTK+. This function is not useful outside GTK+. Undoes the effect of calling g_object_set() to install an application-specific value for a setting. After this call, the setting will again follow the session-wide value for this setting. a #GtkSettings object the name of the setting to reset Use g_object_set() instead. Use g_object_set() instead. Use g_object_set() instead. Use g_object_set() instead. Holds a hash table representation of the #GtkSettings:gtk-color-scheme setting, mapping color names to #GdkColors. Will always return an empty hash table. Controls the direction of the sort indicators in sorted list and tree views. By default an arrow pointing down means the column is sorted in ascending order. When set to %TRUE, this order will be inverted. Whether the application prefers to use a dark theme. If a GTK+ theme includes a dark variant, it will be used instead of the configured theme. Some applications benefit from minimizing the amount of light pollution that interferes with the content. Good candidates for dark themes are photo and video editors that make the actual content get all the attention and minimize the distraction of the chrome. Dark themes should not be used for documents, where large spaces are white/light and the dark chrome creates too much contrast (web browser, text editor...). Whether mnemonics should be automatically shown and hidden when the user presses the mnemonic activator. This setting is ignored Whether images should be shown on buttons This setting is deprecated. Application developers control whether a button should show an icon or not, on a per-button basis. If a #GtkButton should show an icon, use the #GtkButton:always-show-image property of #GtkButton, and pack a #GtkImage inside the #GtkButton Whether menu accelerators can be changed by pressing a key over the menu item. This setting is ignored. Palette to use in the deprecated color selector. Only used by the deprecated color selector widget. A palette of named colors for use in themes. The format of the string is |[ name1: color1 name2: color2 ... ]| Color names must be acceptable as identifiers in the [gtkrc][gtk3-Resource-Files] syntax, and color specifications must be in the format accepted by gdk_color_parse(). Note that due to the way the color tables from different sources are merged, color specifications will be converted to hexadecimal form when getting this property. Starting with GTK+ 2.12, the entries can alternatively be separated by ';' instead of newlines: |[ name1: color1; name2: color2; ... ]| Color scheme support was dropped and is no longer supported. You can still set this property, but it will be ignored. Whether the cursor should blink. Also see the #GtkSettings:gtk-cursor-blink-timeout setting, which allows more flexible control over cursor blinking. Time after which the cursor stops blinking, in seconds. The timer is reset after each user interaction. Setting this to zero has the same effect as setting #GtkSettings:gtk-cursor-blink to %FALSE. This setting determines which buttons should be put in the titlebar of client-side decorated windows, and whether they should be placed at the left of right. The format of the string is button names, separated by commas. A colon separates the buttons that should appear on the left from those on the right. Recognized button names are minimize, maximize, close, icon (the window icon) and menu (a menu button for the fallback app menu). For example, "menu:minimize,maximize,close" specifies a menu on the left, and minimize, maximize and close buttons on the right. Note that buttons will only be shown when they are meaningful. E.g. a menu button only appears when the desktop shell does not show the app menu, and a close button only appears on a window that can be closed. Also note that the setting can be overridden with the #GtkHeaderBar:decoration-layout property. Whether builtin GTK+ dialogs such as the file chooser, the color chooser or the font chooser will use a header bar at the top to show action widgets, or an action area at the bottom. This setting does not affect custom dialogs using GtkDialog directly, or message dialogs. Whether menu items should have visible accelerators which can be activated. Whether to play any event sounds at all. See the [Sound Theme Specifications](http://www.freedesktop.org/wiki/Specifications/sound-theme-spec) for more information on event sounds and sound themes. GTK+ itself does not support event sounds, you have to use a loadable module like the one that comes with libcanberra. Whether to play event sounds as feedback to user input. See the [Sound Theme Specifications](http://www.freedesktop.org/wiki/Specifications/sound-theme-spec) for more information on event sounds and sound themes. GTK+ itself does not support event sounds, you have to use a loadable module like the one that comes with libcanberra. Whether labels and menu items should have visible mnemonics which can be activated. This setting can still be used for application overrides, but will be ignored in the future Whether a middle click on a mouse should paste the 'PRIMARY' clipboard content at the cursor location. Whether tooltips should be shown on widgets. This setting is ignored. How long to show the last input character in hidden entries. This value is in milliseconds. 0 disables showing the last char. 600 is a good value for enabling it. When %TRUE, keyboard navigation and other input-related errors will cause a beep. Since the error bell is implemented using gdk_window_beep(), the windowing system may offer ways to configure the error bell in many ways, such as flashing the window or similar visual effects. Name of a icon theme to fall back to. This setting is ignored. Name of the GtkFileChooser backend to use by default. This setting is ignored. #GtkFileChooser uses GIO by default. The default font to use. GTK+ uses the family name and size from this string. A list of icon sizes. The list is separated by colons, and item has the form: `size-name` = `width` , `height` E.g. "gtk-menu=16,16:gtk-button=20,20:gtk-dialog=48,48". GTK+ itself use the following named icon sizes: gtk-menu, gtk-button, gtk-small-toolbar, gtk-large-toolbar, gtk-dnd, gtk-dialog. Applications can register their own named icon sizes with gtk_icon_size_register(). This setting is ignored. Which IM (input method) module should be used by default. This is the input method that will be used if the user has not explicitly chosen another input method from the IM context menu. This also can be a colon-separated list of input methods, which GTK+ will try in turn until it finds one available on the system. See #GtkIMContext. How to draw the input method preedit string. This setting is ignored. How to draw the input method statusbar. This setting is ignored. When %TRUE, keyboard navigation should be able to reach all widgets by using the cursor keys only. Tab, Shift etc. keys can't be expected to be present on the used input device. Generally, the behavior for touchscreen input should be performed dynamically based on gdk_event_get_source_device(). Whether GTK+ should make sure that text can be navigated with a caret, even if it is not editable. This is useful when using a screen reader. When %TRUE, some widgets will wrap around when doing keyboard navigation, such as menus, menubars and notebooks. This setting is ignored. The time for a button or touch press to be considered a "long press". Keybinding to activate the menu bar. This setting can still be used for application overrides, but will be ignored in the future Delay before the submenus of a menu bar appear. This setting is ignored. Whether images should be shown in menu items This setting is deprecated. Application developers control whether or not a #GtkMenuItem should have an icon or not, on a per widget basis. Either use a #GtkMenuItem with a #GtkBox containing a #GtkImage and a #GtkAccelLabel, or describe your menus using a #GMenu XML description The time before hiding a submenu when the pointer is moving towards the submenu. This setting is ignored. Minimum time the pointer must stay over a menu item before the submenu appear. This setting is ignored. Whether scrolled windows may use overlayed scrolling indicators. If this is set to %FALSE, scrolled windows will have permanent scrollbars. If the value of this setting is %TRUE, clicking the primary button in a #GtkRange trough will move the slider, and hence set the range’s value, to the point that you clicked. If it is %FALSE, a primary click will cause the slider/value to move by the range’s page-size towards the point clicked. Whichever action you choose for the primary button, the other action will be available by holding Shift and primary-clicking, or (since GTK+ 3.22.25) clicking the middle mouse button. A comma-separated list of print backends to use in the print dialog. Available print backends depend on the GTK+ installation, and may include "file", "cups", "lpr" or "papi". A command to run for displaying the print preview. The command should contain a `%f` placeholder, which will get replaced by the path to the pdf file. The command may also contain a `%s` placeholder, which will get replaced by the path to a file containing the print settings in the format produced by gtk_print_settings_to_file(). The preview application is responsible for removing the pdf file and the print settings file when it is done. Whether GTK+ should keep track of items inside the recently used resources list. If set to %FALSE, the list will always be empty. The number of recently used files that should be displayed by default by #GtkRecentChooser implementations and by the #GtkFileChooser. A value of -1 means every recently used file stored. This setting is ignored The maximum age, in days, of the items inside the recently used resources list. Items older than this setting will be excised from the list. If set to 0, the list will always be empty; if set to -1, no item will be removed. Where the contents of scrolled windows are located with respect to the scrollbars, if not overridden by the scrolled window's own placement. This setting is ignored. This setting is ignored. This setting is ignored. The XDG sound theme to use for event sounds. See the [Sound Theme Specifications](http://www.freedesktop.org/wiki/Specifications/sound-theme-spec) for more information on event sounds and sound themes. GTK+ itself does not support event sounds, you have to use a loadable module like the one that comes with libcanberra. This setting is ignored. This setting is ignored. This setting is ignored. This setting determines the action to take when a double-click occurs on the titlebar of client-side decorated windows. Recognized actions are minimize, toggle-maximize, menu, lower or none. This setting determines the action to take when a middle-click occurs on the titlebar of client-side decorated windows. Recognized actions are minimize, toggle-maximize, menu, lower or none. This setting determines the action to take when a right-click occurs on the titlebar of client-side decorated windows. Recognized actions are minimize, toggle-maximize, menu, lower or none. The size of icons in default toolbars. This setting is ignored. The size of icons in default toolbars. This setting is ignored. Amount of time, in milliseconds, after which the browse mode will be disabled. See #GtkSettings:gtk-tooltip-browse-timeout for more information about browse mode. This setting is ignored. Controls the time after which tooltips will appear when browse mode is enabled, in milliseconds. Browse mode is enabled when the mouse pointer moves off an object where a tooltip was currently being displayed. If the mouse pointer hits another object before the browse mode timeout expires (see #GtkSettings:gtk-tooltip-browse-mode-timeout), it will take the amount of milliseconds specified by this setting to popup the tooltip for the new object. This setting is ignored. Time, in milliseconds, after which a tooltip could appear if the cursor is hovering on top of a widget. This setting is ignored. When %TRUE, there are no motion notify events delivered on this screen, and widgets can't use the pointer hovering them for any essential functionality. Generally, the behavior for touchscreen input should be performed dynamically based on gdk_event_get_source_device(). Whether 'focus rectangles' should be always visible, never visible, or hidden until the user starts to use the keyboard. This setting is ignored Origin should be something like “filename:linenumber” for rc files, or e.g. “XProperty” for other sources. Valid types are LONG, DOUBLE and STRING corresponding to the token parsed, or a GSTRING holding an unparsed statement Used to change the appearance of an outline typically provided by a #GtkFrame. Note that many themes do not differentiate the appearance of the various shadow types: Either their is no visible shadow (@GTK_SHADOW_NONE), or there is (any other value). No outline. The outline is bevelled inwards. The outline is bevelled outwards like a button. The outline has a sunken 3d appearance. The outline has a raised 3d appearance. #GtkShortcutLabel is a widget that represents a single keyboard shortcut or gesture in the user interface. Creates a new #GtkShortcutLabel with @accelerator set. a newly-allocated #GtkShortcutLabel the initial accelerator Retrieves the current accelerator of @self. the current accelerator. a #GtkShortcutLabel Retrieves the text that is displayed when no accelerator is set. the current text displayed when no accelerator is set. a #GtkShortcutLabel Sets the accelerator to be displayed by @self. a #GtkShortcutLabel the new accelerator Sets the text to be displayed by @self when no accelerator is set. a #GtkShortcutLabel the text to be displayed when no accelerator is set The accelerator that @self displays. See #GtkShortcutsShortcut:accelerator for the accepted syntax. The text that is displayed when no accelerator is set. GtkShortcutType specifies the kind of shortcut that is being described. More values may be added to this enumeration over time. The shortcut is a keyboard accelerator. The #GtkShortcutsShortcut:accelerator property will be used. The shortcut is a pinch gesture. GTK+ provides an icon and subtitle. The shortcut is a stretch gesture. GTK+ provides an icon and subtitle. The shortcut is a clockwise rotation gesture. GTK+ provides an icon and subtitle. The shortcut is a counterclockwise rotation gesture. GTK+ provides an icon and subtitle. The shortcut is a two-finger swipe gesture. GTK+ provides an icon and subtitle. The shortcut is a two-finger swipe gesture. GTK+ provides an icon and subtitle. The shortcut is a gesture. The #GtkShortcutsShortcut:icon property will be used. A GtkShortcutsGroup represents a group of related keyboard shortcuts or gestures. The group has a title. It may optionally be associated with a view of the application, which can be used to show only relevant shortcuts depending on the application context. This widget is only meant to be used with #GtkShortcutsWindow. The size group for the accelerator portion of shortcuts in this group. This is used internally by GTK+, and must not be modified by applications. A rough measure for the number of lines in this group. This is used internally by GTK+, and is not useful for applications. The title for this group of shortcuts. The size group for the textual portion of shortcuts in this group. This is used internally by GTK+, and must not be modified by applications. An optional view that the shortcuts in this group are relevant for. The group will be hidden if the #GtkShortcutsWindow:view-name property does not match the view of this group. Set this to %NULL to make the group always visible. A GtkShortcutsSection collects all the keyboard shortcuts and gestures for a major application mode. If your application needs multiple sections, you should give each section a unique #GtkShortcutsSection:section-name and a #GtkShortcutsSection:title that can be shown in the section selector of the GtkShortcutsWindow. The #GtkShortcutsSection:max-height property can be used to influence how the groups in the section are distributed over pages and columns. This widget is only meant to be used with #GtkShortcutsWindow. The maximum number of lines to allow per column. This property can be used to influence how the groups in this section are distributed across pages and columns. The default value of 15 should work in most cases. A unique name to identify this section among the sections added to the GtkShortcutsWindow. Setting the #GtkShortcutsWindow:section-name property to this string will make this section shown in the GtkShortcutsWindow. The string to show in the section selector of the GtkShortcutsWindow for this section. If there is only one section, you don't need to set a title, since the section selector will not be shown in this case. A view name to filter the groups in this section by. See #GtkShortcutsGroup:view. Applications are expected to use the #GtkShortcutsWindow:view-name property for this purpose. A GtkShortcutsShortcut represents a single keyboard shortcut or gesture with a short text. This widget is only meant to be used with #GtkShortcutsWindow. The size group for the accelerator portion of this shortcut. This is used internally by GTK+, and must not be modified by applications. The accelerator(s) represented by this object. This property is used if #GtkShortcutsShortcut:shortcut-type is set to #GTK_SHORTCUT_ACCELERATOR. The syntax of this property is (an extension of) the syntax understood by gtk_accelerator_parse(). Multiple accelerators can be specified by separating them with a space, but keep in mind that the available width is limited. It is also possible to specify ranges of shortcuts, using ... between the keys. Sequences of keys can be specified using a + or & between the keys. Examples: - A single shortcut: <ctl><alt>delete - Two alternative shortcuts: <shift>a Home - A range of shortcuts: <alt>1...<alt>9 - Several keys pressed together: Control_L&Control_R - A sequence of shortcuts or keys: <ctl>c+<ctl>x Use + instead of & when the keys may (or have to be) pressed sequentially (e.g use t+t for 'press the t key twice'). Note that <, > and & need to be escaped as &lt;, &gt; and &amp; when used in .ui files. A detailed action name. If this is set for a shortcut of type %GTK_SHORTCUT_ACCELERATOR, then GTK+ will use the accelerators that are associated with the action via gtk_application_set_accels_for_action(), and setting #GtkShortcutsShortcut::accelerator is not necessary. The text direction for which this shortcut is active. If the shortcut is used regardless of the text direction, set this property to #GTK_TEXT_DIR_NONE. An icon to represent the shortcut or gesture. This property is used if #GtkShortcutsShortcut:shortcut-type is set to #GTK_SHORTCUT_GESTURE. For the other predefined gesture types, GTK+ provides an icon on its own. %TRUE if an icon has been set. The type of shortcut that is represented. The subtitle for the shortcut or gesture. This is typically used for gestures and should be a short, one-line text that describes the gesture itself. For the predefined gesture types, GTK+ provides a subtitle on its own. %TRUE if a subtitle has been set. The textual description for the shortcut or gesture represented by this object. This should be a short string that can fit in a single line. The size group for the textual portion of this shortcut. This is used internally by GTK+, and must not be modified by applications. A GtkShortcutsWindow shows brief information about the keyboard shortcuts and gestures of an application. The shortcuts can be grouped, and you can have multiple sections in this window, corresponding to the major modes of your application. Additionally, the shortcuts can be filtered by the current view, to avoid showing information that is not relevant in the current application context. The recommended way to construct a GtkShortcutsWindow is with GtkBuilder, by populating a #GtkShortcutsWindow with one or more #GtkShortcutsSection objects, which contain #GtkShortcutsGroups that in turn contain objects of class #GtkShortcutsShortcut. # A simple example: ![](gedit-shortcuts.png) This example has as single section. As you can see, the shortcut groups are arranged in columns, and spread across several pages if there are too many to find on a single page. The .ui file for this example can be found [here](https://git.gnome.org/browse/gtk+/tree/demos/gtk-demo/shortcuts-gedit.ui). # An example with multiple views: ![](clocks-shortcuts.png) This example shows a #GtkShortcutsWindow that has been configured to show only the shortcuts relevant to the "stopwatch" view. The .ui file for this example can be found [here](https://git.gnome.org/browse/gtk+/tree/demos/gtk-demo/shortcuts-clocks.ui). # An example with multiple sections: ![](builder-shortcuts.png) This example shows a #GtkShortcutsWindow with two sections, "Editor Shortcuts" and "Terminal Shortcuts". The .ui file for this example can be found [here](https://git.gnome.org/browse/gtk+/tree/demos/gtk-demo/shortcuts-builder.ui). The name of the section to show. This should be the section-name of one of the #GtkShortcutsSection objects that are in this shortcuts window. The view name by which to filter the contents. This should correspond to the #GtkShortcutsGroup:view property of some of the #GtkShortcutsGroup objects that are inside this shortcuts window. Set this to %NULL to show all groups. The ::close signal is a [keybinding signal][GtkBindingSignal] which gets emitted when the user uses a keybinding to close the window. The default binding for this signal is the Escape key. The ::search signal is a [keybinding signal][GtkBindingSignal] which gets emitted when the user uses a keybinding to start a search. The default binding for this signal is Control-F. #GtkSizeGroup provides a mechanism for grouping a number of widgets together so they all request the same amount of space. This is typically useful when you want a column of widgets to have the same size, but you can’t use a #GtkGrid widget. In detail, the size requested for each widget in a #GtkSizeGroup is the maximum of the sizes that would have been requested for each widget in the size group if they were not in the size group. The mode of the size group (see gtk_size_group_set_mode()) determines whether this applies to the horizontal size, the vertical size, or both sizes. Note that size groups only affect the amount of space requested, not the size that the widgets finally receive. If you want the widgets in a #GtkSizeGroup to actually be the same size, you need to pack them in such a way that they get the size they request and not more. For example, if you are packing your widgets into a table, you would not include the %GTK_FILL flag. #GtkSizeGroup objects are referenced by each widget in the size group, so once you have added all widgets to a #GtkSizeGroup, you can drop the initial reference to the size group with g_object_unref(). If the widgets in the size group are subsequently destroyed, then they will be removed from the size group and drop their references on the size group; when all widgets have been removed, the size group will be freed. Widgets can be part of multiple size groups; GTK+ will compute the horizontal size of a widget from the horizontal requisition of all widgets that can be reached from the widget by a chain of size groups of type %GTK_SIZE_GROUP_HORIZONTAL or %GTK_SIZE_GROUP_BOTH, and the vertical size from the vertical requisition of all widgets that can be reached from the widget by a chain of size groups of type %GTK_SIZE_GROUP_VERTICAL or %GTK_SIZE_GROUP_BOTH. Note that only non-contextual sizes of every widget are ever consulted by size groups (since size groups have no knowledge of what size a widget will be allocated in one dimension, it cannot derive how much height a widget will receive for a given width). When grouping widgets that trade height for width in mode %GTK_SIZE_GROUP_VERTICAL or %GTK_SIZE_GROUP_BOTH: the height for the minimum width will be the requested height for all widgets in the group. The same is of course true when horizontally grouping width for height widgets. Widgets that trade height-for-width should set a reasonably large minimum width by way of #GtkLabel:width-chars for instance. Widgets with static sizes as well as widgets that grow (such as ellipsizing text) need no such considerations. # GtkSizeGroup as GtkBuildable Size groups can be specified in a UI definition by placing an <object> element with `class="GtkSizeGroup"` somewhere in the UI definition. The widgets that belong to the size group are specified by a <widgets> element that may contain multiple <widget> elements, one for each member of the size group. The ”name” attribute gives the id of the widget. An example of a UI definition fragment with GtkSizeGroup: |[ <object class="GtkSizeGroup"> <property name="mode">GTK_SIZE_GROUP_HORIZONTAL</property> <widgets> <widget name="radio1"/> <widget name="radio2"/> </widgets> </object> ]| Create a new #GtkSizeGroup. a newly created #GtkSizeGroup the mode for the new size group. Adds a widget to a #GtkSizeGroup. In the future, the requisition of the widget will be determined as the maximum of its requisition and the requisition of the other widgets in the size group. Whether this applies horizontally, vertically, or in both directions depends on the mode of the size group. See gtk_size_group_set_mode(). When the widget is destroyed or no longer referenced elsewhere, it will be removed from the size group. a #GtkSizeGroup the #GtkWidget to add Returns if invisible widgets are ignored when calculating the size. Measuring the size of hidden widgets has not worked reliably for a long time. In most cases, they will report a size of 0 nowadays, and thus, their size will not affect the other size group members. In effect, size groups will always operate as if this property was %TRUE. Use a #GtkStack instead to hide widgets while still having their size taken into account. %TRUE if invisible widgets are ignored. a #GtkSizeGroup Gets the current mode of the size group. See gtk_size_group_set_mode(). the current mode of the size group. a #GtkSizeGroup Returns the list of widgets associated with @size_group. a #GSList of widgets. The list is owned by GTK+ and should not be modified. a #GtkSizeGroup Removes a widget from a #GtkSizeGroup. a #GtkSizeGroup the #GtkWidget to remove Sets whether unmapped widgets should be ignored when calculating the size. Measuring the size of hidden widgets has not worked reliably for a long time. In most cases, they will report a size of 0 nowadays, and thus, their size will not affect the other size group members. In effect, size groups will always operate as if this property was %TRUE. Use a #GtkStack instead to hide widgets while still having their size taken into account. a #GtkSizeGroup whether unmapped widgets should be ignored when calculating the size Sets the #GtkSizeGroupMode of the size group. The mode of the size group determines whether the widgets in the size group should all have the same horizontal requisition (%GTK_SIZE_GROUP_HORIZONTAL) all have the same vertical requisition (%GTK_SIZE_GROUP_VERTICAL), or should all have the same requisition in both directions (%GTK_SIZE_GROUP_BOTH). a #GtkSizeGroup the mode to set for the size group. If %TRUE, unmapped widgets are ignored when determining the size of the group. Measuring the size of hidden widgets has not worked reliably for a long time. In most cases, they will report a size of 0 nowadays, and thus, their size will not affect the other size group members. In effect, size groups will always operate as if this property was %TRUE. Use a #GtkStack instead to hide widgets while still having their size taken into account. The mode of the size group determines the directions in which the size group affects the requested sizes of its component widgets. group has no effect group affects horizontal requisition group affects vertical requisition group affects both horizontal and vertical requisition Specifies a preference for height-for-width or width-for-height geometry management. Prefer height-for-width geometry management Prefer width-for-height geometry management Don’t trade height-for-width or width-for-height Together with #GtkPlug, #GtkSocket provides the ability to embed widgets from one process into another process in a fashion that is transparent to the user. One process creates a #GtkSocket widget and passes that widget’s window ID to the other process, which then creates a #GtkPlug with that window ID. Any widgets contained in the #GtkPlug then will appear inside the first application’s window. The socket’s window ID is obtained by using gtk_socket_get_id(). Before using this function, the socket must have been realized, and for hence, have been added to its parent. ## Obtaining the window ID of a socket. |[<!-- language="C" --> GtkWidget *socket = gtk_socket_new (); gtk_widget_show (socket); gtk_container_add (GTK_CONTAINER (parent), socket); // The following call is only necessary if one of // the ancestors of the socket is not yet visible. gtk_widget_realize (socket); g_print ("The ID of the sockets window is %#x\n", gtk_socket_get_id (socket)); ]| Note that if you pass the window ID of the socket to another process that will create a plug in the socket, you must make sure that the socket widget is not destroyed until that plug is created. Violating this rule will cause unpredictable consequences, the most likely consequence being that the plug will appear as a separate toplevel window. You can check if the plug has been created by using gtk_socket_get_plug_window(). If it returns a non-%NULL value, then the plug has been successfully created inside of the socket. When GTK+ is notified that the embedded window has been destroyed, then it will destroy the socket as well. You should always, therefore, be prepared for your sockets to be destroyed at any time when the main event loop is running. To prevent this from happening, you can connect to the #GtkSocket::plug-removed signal. The communication between a #GtkSocket and a #GtkPlug follows the [XEmbed Protocol](http://www.freedesktop.org/Standards/xembed-spec). This protocol has also been implemented in other toolkits, e.g. Qt, allowing the same level of integration when embedding a Qt widget in GTK or vice versa. The #GtkPlug and #GtkSocket widgets are only available when GTK+ is compiled for the X11 platform and %GDK_WINDOWING_X11 is defined. They can only be used on a #GdkX11Display. To use #GtkPlug and #GtkSocket, you need to include the `gtk/gtkx.h` header. Create a new empty #GtkSocket. the new #GtkSocket. Adds an XEMBED client, such as a #GtkPlug, to the #GtkSocket. The client may be in the same process or in a different process. To embed a #GtkPlug in a #GtkSocket, you can either create the #GtkPlug with `gtk_plug_new (0)`, call gtk_plug_get_id() to get the window ID of the plug, and then pass that to the gtk_socket_add_id(), or you can call gtk_socket_get_id() to get the window ID for the socket, and call gtk_plug_new() passing in that ID. The #GtkSocket must have already be added into a toplevel window before you can make this call. a #GtkSocket the Window of a client participating in the XEMBED protocol. Gets the window ID of a #GtkSocket widget, which can then be used to create a client embedded inside the socket, for instance with gtk_plug_new(). The #GtkSocket must have already be added into a toplevel window before you can make this call. the window ID for the socket a #GtkSocket. Retrieves the window of the plug. Use this to check if the plug has been created inside of the socket. the window of the plug if available, or %NULL a #GtkSocket. This signal is emitted when a client is successfully added to the socket. This signal is emitted when a client is removed from the socket. The default action is to destroy the #GtkSocket widget, so if you want to reuse it you must add a signal handler that returns %TRUE. %TRUE to stop other handlers from being invoked. Determines the direction of a sort. Sorting is in ascending order. Sorting is in descending order. A #GtkSpinButton is an ideal way to allow the user to set the value of some attribute. Rather than having to directly type a number into a #GtkEntry, GtkSpinButton allows the user to click on one of two arrows to increment or decrement the displayed value. A value can still be typed in, with the bonus that it can be checked to ensure it is in a given range. The main properties of a GtkSpinButton are through an adjustment. See the #GtkAdjustment section for more details about an adjustment's properties. Note that GtkSpinButton will by default make its entry large enough to accomodate the lower and upper bounds of the adjustment, which can lead to surprising results. Best practice is to set both the #GtkEntry:width-chars and #GtkEntry:max-width-chars poperties to the desired number of characters to display in the entry. # CSS nodes |[<!-- language="plain" --> spinbutton.horizontal ├── undershoot.left ├── undershoot.right ├── entry │ ╰── ... ├── button.down ╰── button.up ]| |[<!-- language="plain" --> spinbutton.vertical ├── undershoot.left ├── undershoot.right ├── button.up ├── entry │ ╰── ... ╰── button.down ]| GtkSpinButtons main CSS node has the name spinbutton. It creates subnodes for the entry and the two buttons, with these names. The button nodes have the style classes .up and .down. The GtkEntry subnodes (if present) are put below the entry node. The orientation of the spin button is reflected in the .vertical or .horizontal style class on the main node. ## Using a GtkSpinButton to get an integer |[<!-- language="C" --> // Provides a function to retrieve an integer value from a GtkSpinButton // and creates a spin button to model percentage values. gint grab_int_value (GtkSpinButton *button, gpointer user_data) { return gtk_spin_button_get_value_as_int (button); } void create_integer_spin_button (void) { GtkWidget *window, *button; GtkAdjustment *adjustment; adjustment = gtk_adjustment_new (50.0, 0.0, 100.0, 1.0, 5.0, 0.0); window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_container_set_border_width (GTK_CONTAINER (window), 5); // creates the spinbutton, with no decimal places button = gtk_spin_button_new (adjustment, 1.0, 0); gtk_container_add (GTK_CONTAINER (window), button); gtk_widget_show_all (window); } ]| ## Using a GtkSpinButton to get a floating point value |[<!-- language="C" --> // Provides a function to retrieve a floating point value from a // GtkSpinButton, and creates a high precision spin button. gfloat grab_float_value (GtkSpinButton *button, gpointer user_data) { return gtk_spin_button_get_value (button); } void create_floating_spin_button (void) { GtkWidget *window, *button; GtkAdjustment *adjustment; adjustment = gtk_adjustment_new (2.500, 0.0, 5.0, 0.001, 0.1, 0.0); window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_container_set_border_width (GTK_CONTAINER (window), 5); // creates the spinbutton, with three decimal places button = gtk_spin_button_new (adjustment, 0.001, 3); gtk_container_add (GTK_CONTAINER (window), button); gtk_widget_show_all (window); } ]| Creates a new #GtkSpinButton. The new spin button as a #GtkWidget the #GtkAdjustment object that this spin button should use, or %NULL specifies by how much the rate of change in the value will accelerate if you continue to hold down an up/down button or arrow key the number of decimal places to display This is a convenience constructor that allows creation of a numeric #GtkSpinButton without manually creating an adjustment. The value is initially set to the minimum value and a page increment of 10 * @step is the default. The precision of the spin button is equivalent to the precision of @step. Note that the way in which the precision is derived works best if @step is a power of ten. If the resulting precision is not suitable for your needs, use gtk_spin_button_set_digits() to correct it. The new spin button as a #GtkWidget Minimum allowable value Maximum allowable value Increment added or subtracted by spinning the widget Changes the properties of an existing spin button. The adjustment, climb rate, and number of decimal places are updated accordingly. a #GtkSpinButton a #GtkAdjustment to replace the spin button’s existing adjustment, or %NULL to leave its current adjustment unchanged the new climb rate the number of decimal places to display in the spin button Get the adjustment associated with a #GtkSpinButton the #GtkAdjustment of @spin_button a #GtkSpinButton Fetches the precision of @spin_button. See gtk_spin_button_set_digits(). the current precision a #GtkSpinButton Gets the current step and page the increments used by @spin_button. See gtk_spin_button_set_increments(). a #GtkSpinButton location to store step increment, or %NULL location to store page increment, or %NULL Returns whether non-numeric text can be typed into the spin button. See gtk_spin_button_set_numeric(). %TRUE if only numeric text can be entered a #GtkSpinButton Gets the range allowed for @spin_button. See gtk_spin_button_set_range(). a #GtkSpinButton location to store minimum allowed value, or %NULL location to store maximum allowed value, or %NULL Returns whether the values are corrected to the nearest step. See gtk_spin_button_set_snap_to_ticks(). %TRUE if values are snapped to the nearest step a #GtkSpinButton Gets the update behavior of a spin button. See gtk_spin_button_set_update_policy(). the current update policy a #GtkSpinButton Get the value in the @spin_button. the value of @spin_button a #GtkSpinButton Get the value @spin_button represented as an integer. the value of @spin_button a #GtkSpinButton Returns whether the spin button’s value wraps around to the opposite limit when the upper or lower limit of the range is exceeded. See gtk_spin_button_set_wrap(). %TRUE if the spin button wraps around a #GtkSpinButton Replaces the #GtkAdjustment associated with @spin_button. a #GtkSpinButton a #GtkAdjustment to replace the existing adjustment Set the precision to be displayed by @spin_button. Up to 20 digit precision is allowed. a #GtkSpinButton the number of digits after the decimal point to be displayed for the spin button’s value Sets the step and page increments for spin_button. This affects how quickly the value changes when the spin button’s arrows are activated. a #GtkSpinButton increment applied for a button 1 press. increment applied for a button 2 press. Sets the flag that determines if non-numeric text can be typed into the spin button. a #GtkSpinButton flag indicating if only numeric entry is allowed Sets the minimum and maximum allowable values for @spin_button. If the current value is outside this range, it will be adjusted to fit within the range, otherwise it will remain unchanged. a #GtkSpinButton minimum allowable value maximum allowable value Sets the policy as to whether values are corrected to the nearest step increment when a spin button is activated after providing an invalid value. a #GtkSpinButton a flag indicating if invalid values should be corrected Sets the update behavior of a spin button. This determines whether the spin button is always updated or only when a valid value is set. a #GtkSpinButton a #GtkSpinButtonUpdatePolicy value Sets the value of @spin_button. a #GtkSpinButton the new value Sets the flag that determines if a spin button value wraps around to the opposite limit when the upper or lower limit of the range is exceeded. a #GtkSpinButton a flag indicating if wrapping behavior is performed Increment or decrement a spin button’s value in a specified direction by a specified amount. a #GtkSpinButton a #GtkSpinType indicating the direction to spin step increment to apply in the specified direction Manually force an update of the spin button. a #GtkSpinButton The ::change-value signal is a [keybinding signal][GtkBindingSignal] which gets emitted when the user initiates a value change. Applications should not connect to it, but may emit it with g_signal_emit_by_name() if they need to control the cursor programmatically. The default bindings for this signal are Up/Down and PageUp and/PageDown. a #GtkScrollType to specify the speed and amount of change The ::input signal can be used to influence the conversion of the users input into a double value. The signal handler is expected to use gtk_entry_get_text() to retrieve the text of the entry and set @new_value to the new value. The default conversion uses g_strtod(). %TRUE for a successful conversion, %FALSE if the input was not handled, and %GTK_INPUT_ERROR if the conversion failed. return location for the new value The ::output signal can be used to change to formatting of the value that is displayed in the spin buttons entry. |[<!-- language="C" --> // show leading zeros static gboolean on_output (GtkSpinButton *spin, gpointer data) { GtkAdjustment *adjustment; gchar *text; int value; adjustment = gtk_spin_button_get_adjustment (spin); value = (int)gtk_adjustment_get_value (adjustment); text = g_strdup_printf ("%02d", value); gtk_entry_set_text (GTK_ENTRY (spin), text); g_free (text); return TRUE; } ]| %TRUE if the value has been displayed The ::value-changed signal is emitted when the value represented by @spinbutton changes. Also see the #GtkSpinButton::output signal. The ::wrapped signal is emitted right after the spinbutton wraps from its maximum to minimum value or vice-versa. The spin button update policy determines whether the spin button displays values even if they are outside the bounds of its adjustment. See gtk_spin_button_set_update_policy(). When refreshing your #GtkSpinButton, the value is always displayed When refreshing your #GtkSpinButton, the value is only displayed if it is valid within the bounds of the spin button's adjustment The values of the GtkSpinType enumeration are used to specify the change to make in gtk_spin_button_spin(). Increment by the adjustments step increment. Decrement by the adjustments step increment. Increment by the adjustments page increment. Decrement by the adjustments page increment. Go to the adjustments lower bound. Go to the adjustments upper bound. Change by a specified amount. A GtkSpinner widget displays an icon-size spinning animation. It is often used as an alternative to a #GtkProgressBar for displaying indefinite activity, instead of actual progress. To start the animation, use gtk_spinner_start(), to stop it use gtk_spinner_stop(). # CSS nodes GtkSpinner has a single CSS node with the name spinner. When the animation is active, the :checked pseudoclass is added to this node. Returns a new spinner widget. Not yet started. a new #GtkSpinner Starts the animation of the spinner. a #GtkSpinner Stops the animation of the spinner. a #GtkSpinner The GtkStack widget is a container which only shows one of its children at a time. In contrast to GtkNotebook, GtkStack does not provide a means for users to change the visible child. Instead, the #GtkStackSwitcher widget can be used with GtkStack to provide this functionality. Transitions between pages can be animated as slides or fades. This can be controlled with gtk_stack_set_transition_type(). These animations respect the #GtkSettings:gtk-enable-animations setting. The GtkStack widget was added in GTK+ 3.10. # CSS nodes GtkStack has a single CSS node named stack. Creates a new #GtkStack container. a new #GtkStack Adds a child to @stack. The child is identified by the @name. a #GtkStack the widget to add the name for @child Adds a child to @stack. The child is identified by the @name. The @title will be used by #GtkStackSwitcher to represent @child in a tab bar, so it should be short. a #GtkStack the widget to add the name for @child a human-readable title for @child Finds the child of the #GtkStack with the name given as the argument. Returns %NULL if there is no child with this name. the requested child of the #GtkStack a #GtkStack the name of the child to find Gets whether @stack is horizontally homogeneous. See gtk_stack_set_hhomogeneous(). whether @stack is horizontally homogeneous. a #GtkStack Gets whether @stack is homogeneous. See gtk_stack_set_homogeneous(). whether @stack is homogeneous. a #GtkStack Returns wether the #GtkStack is set up to interpolate between the sizes of children on page switch. %TRUE if child sizes are interpolated A #GtkStack Returns the amount of time (in milliseconds) that transitions between pages in @stack will take. the transition duration a #GtkStack Returns whether the @stack is currently in a transition from one page to another. %TRUE if the transition is currently running, %FALSE otherwise. a #GtkStack Gets the type of animation that will be used for transitions between pages in @stack. the current transition type of @stack a #GtkStack Gets whether @stack is vertically homogeneous. See gtk_stack_set_vhomogeneous(). whether @stack is vertically homogeneous. a #GtkStack Gets the currently visible child of @stack, or %NULL if there are no visible children. the visible child of the #GtkStack a #GtkStack Returns the name of the currently visible child of @stack, or %NULL if there is no visible child. the name of the visible child of the #GtkStack a #GtkStack Sets the #GtkStack to be horizontally homogeneous or not. If it is homogeneous, the #GtkStack will request the same width for all its children. If it isn't, the stack may change width when a different child becomes visible. a #GtkStack %TRUE to make @stack horizontally homogeneous Sets the #GtkStack to be homogeneous or not. If it is homogeneous, the #GtkStack will request the same size for all its children. If it isn't, the stack may change size when a different child becomes visible. Since 3.16, homogeneity can be controlled separately for horizontal and vertical size, with the #GtkStack:hhomogeneous and #GtkStack:vhomogeneous. a #GtkStack %TRUE to make @stack homogeneous Sets whether or not @stack will interpolate its size when changing the visible child. If the #GtkStack:interpolate-size property is set to %TRUE, @stack will interpolate its size between the current one and the one it'll take after changing the visible child, according to the set transition duration. A #GtkStack the new value Sets the duration that transitions between pages in @stack will take. a #GtkStack the new duration, in milliseconds Sets the type of animation that will be used for transitions between pages in @stack. Available types include various kinds of fades and slides. The transition type can be changed without problems at runtime, so it is possible to change the animation based on the page that is about to become current. a #GtkStack the new transition type Sets the #GtkStack to be vertically homogeneous or not. If it is homogeneous, the #GtkStack will request the same height for all its children. If it isn't, the stack may change height when a different child becomes visible. a #GtkStack %TRUE to make @stack vertically homogeneous Makes @child the visible child of @stack. If @child is different from the currently visible child, the transition between the two will be animated with the current transition type of @stack. Note that the @child widget has to be visible itself (see gtk_widget_show()) in order to become the visible child of @stack. a #GtkStack a child of @stack Makes the child with the given name visible. Note that the child widget has to be visible itself (see gtk_widget_show()) in order to become the visible child of @stack. a #GtkStack the name of the child to make visible the transition type to use Makes the child with the given name visible. If @child is different from the currently visible child, the transition between the two will be animated with the current transition type of @stack. Note that the child widget has to be visible itself (see gtk_widget_show()) in order to become the visible child of @stack. a #GtkStack the name of the child to make visible %TRUE if the stack allocates the same width for all children. %TRUE if the stack allocates the same height for all children. A GtkStackSidebar enables you to quickly and easily provide a consistent "sidebar" object for your user interface. In order to use a GtkStackSidebar, you simply use a GtkStack to organize your UI flow, and add the sidebar to your sidebar area. You can use gtk_stack_sidebar_set_stack() to connect the #GtkStackSidebar to the #GtkStack. # CSS nodes GtkStackSidebar has a single CSS node with name stacksidebar and style class .sidebar. When circumstances require it, GtkStackSidebar adds the .needs-attention style class to the widgets representing the stack pages. Creates a new sidebar. the new #GtkStackSidebar Retrieves the stack. See gtk_stack_sidebar_set_stack(). the associated #GtkStack or %NULL if none has been set explicitly a #GtkStackSidebar Set the #GtkStack associated with this #GtkStackSidebar. The sidebar widget will automatically update according to the order (packing) and items within the given #GtkStack. a #GtkStackSidebar a #GtkStack The GtkStackSwitcher widget acts as a controller for a #GtkStack; it shows a row of buttons to switch between the various pages of the associated stack widget. All the content for the buttons comes from the child properties of the #GtkStack; the button visibility in a #GtkStackSwitcher widget is controlled by the visibility of the child in the #GtkStack. It is possible to associate multiple #GtkStackSwitcher widgets with the same #GtkStack widget. The GtkStackSwitcher widget was added in 3.10. # CSS nodes GtkStackSwitcher has a single CSS node named stackswitcher and style class .stack-switcher. When circumstances require it, GtkStackSwitcher adds the .needs-attention style class to the widgets representing the stack pages. Create a new #GtkStackSwitcher. a new #GtkStackSwitcher. Retrieves the stack. See gtk_stack_switcher_set_stack(). the stack, or %NULL if none has been set explicitly. a #GtkStackSwitcher Sets the stack to control. a #GtkStackSwitcher a #GtkStack Use the "icon-size" property to change the size of the image displayed when a #GtkStackSwitcher is displaying icons. These enumeration values describe the possible transitions between pages in a #GtkStack widget. New values may be added to this enumeration over time. No transition A cross-fade Slide from left to right Slide from right to left Slide from bottom up Slide from top down Slide from left or right according to the children order Slide from top down or bottom up according to the order Cover the old page by sliding up. Since 3.12 Cover the old page by sliding down. Since: 3.12 Cover the old page by sliding to the left. Since: 3.12 Cover the old page by sliding to the right. Since: 3.12 Uncover the new page by sliding up. Since 3.12 Uncover the new page by sliding down. Since: 3.12 Uncover the new page by sliding to the left. Since: 3.12 Uncover the new page by sliding to the right. Since: 3.12 Cover the old page sliding up or uncover the new page sliding down, according to order. Since: 3.12 Cover the old page sliding down or uncover the new page sliding up, according to order. Since: 3.14 Cover the old page sliding left or uncover the new page sliding right, according to order. Since: 3.14 Cover the old page sliding right or uncover the new page sliding left, according to order. Since: 3.14 Describes a widget state. Widget states are used to match the widget against CSS pseudo-classes. Note that GTK extends the regular CSS classes and sometimes uses different names. State during normal operation. Widget is active. Widget has a mouse pointer over it. Widget is selected. Widget is insensitive. Widget is inconsistent. Widget has the keyboard focus. Widget is in a background toplevel window. Widget is in left-to-right text direction. Since 3.8 Widget is in right-to-left text direction. Since 3.8 Widget is a link. Since 3.12 The location the widget points to has already been visited. Since 3.12 Widget is checked. Since 3.14 Widget is highlighted as a drop target for DND. Since 3.20 This type indicates the current state of a widget; the state determines how the widget is drawn. The #GtkStateType enumeration is also used to identify different colors in a #GtkStyle for drawing, so states can be used for subparts of a widget as well as entire widgets. All APIs that are using this enumeration have been deprecated in favor of alternatives using #GtkStateFlags. State during normal operation. State of a currently active widget, such as a depressed button. State indicating that the mouse pointer is over the widget and the widget will respond to mouse clicks. State of a selected item, such the selected row in a list. State indicating that the widget is unresponsive to user actions. The widget is inconsistent, such as checkbuttons or radiobuttons that aren’t either set to %TRUE nor %FALSE, or buttons requiring the user attention. The widget has the keyboard focus. The “system tray” or notification area is normally used for transient icons that indicate some special state. For example, a system tray icon might appear to tell the user that they have new mail, or have an incoming instant message, or something along those lines. The basic idea is that creating an icon in the notification area is less annoying than popping up a dialog. A #GtkStatusIcon object can be used to display an icon in a “system tray”. The icon can have a tooltip, and the user can interact with it by activating it or popping up a context menu. It is very important to notice that status icons depend on the existence of a notification area being available to the user; you should not use status icons as the only way to convey critical information regarding your application, as the notification area may not exist on the user's environment, or may have been removed. You should always check that a status icon has been embedded into a notification area by using gtk_status_icon_is_embedded(), and gracefully recover if the function returns %FALSE. On X11, the implementation follows the [FreeDesktop System Tray Specification](http://www.freedesktop.org/wiki/Specifications/systemtray-spec). Implementations of the “tray” side of this specification can be found e.g. in the GNOME 2 and KDE panel applications. Note that a GtkStatusIcon is not a widget, but just a #GObject. Making it a widget would be impractical, since the system tray on Windows doesn’t allow to embed arbitrary widgets. GtkStatusIcon has been deprecated in 3.14. You should consider using notifications or more modern platform-specific APIs instead. GLib provides the #GNotification API which works well with #GtkApplication on multiple platforms and environments, and should be the preferred mechanism to notify the users of transient status updates. See this [HowDoI](https://wiki.gnome.org/HowDoI/GNotification) for code examples. Creates an empty status icon object. Use #GNotification and #GtkApplication to provide status notifications a new #GtkStatusIcon Creates a status icon displaying the file @filename. The image will be scaled down to fit in the available space in the notification area, if necessary. Use #GNotification and #GtkApplication to provide status notifications a new #GtkStatusIcon a filename Creates a status icon displaying a #GIcon. If the icon is a themed icon, it will be updated when the theme changes. Use #GNotification and #GtkApplication to provide status notifications a new #GtkStatusIcon a #GIcon Creates a status icon displaying an icon from the current icon theme. If the current icon theme is changed, the icon will be updated appropriately. Use #GNotification and #GtkApplication to provide status notifications a new #GtkStatusIcon an icon name Creates a status icon displaying @pixbuf. The image will be scaled down to fit in the available space in the notification area, if necessary. Use #GNotification and #GtkApplication to provide status notifications a new #GtkStatusIcon a #GdkPixbuf Creates a status icon displaying a stock icon. Sample stock icon names are #GTK_STOCK_OPEN, #GTK_STOCK_QUIT. You can register your own stock icon names, see gtk_icon_factory_add_default() and gtk_icon_factory_add(). Use #GNotification and #GtkApplication to provide status notifications a new #GtkStatusIcon a stock icon id Menu positioning function to use with gtk_menu_popup() to position @menu aligned to the status icon @user_data. Use #GNotification and #GtkApplication to provide status notifications; notifications do not have menus, but can have buttons, and actions associated with each button the #GtkMenu return location for the x position return location for the y position whether the first menu item should be offset (pushed in) to be aligned with the menu popup position (only useful for GtkOptionMenu). the status icon to position the menu on Obtains information about the location of the status icon on screen. This information can be used to e.g. position popups like notification bubbles. See gtk_status_icon_position_menu() for a more convenient alternative for positioning menus. Note that some platforms do not allow GTK+ to provide this information, and even on platforms that do allow it, the information is not reliable unless the status icon is embedded in a notification area, see gtk_status_icon_is_embedded(). Use #GNotification and #GtkApplication to provide status notifications; there is no direct replacement for this function, as the platform is responsible for the presentation of notifications %TRUE if the location information has been filled in a #GtkStatusIcon return location for the screen, or %NULL if the information is not needed return location for the area occupied by the status icon, or %NULL return location for the orientation of the panel in which the status icon is embedded, or %NULL. A panel at the top or bottom of the screen is horizontal, a panel at the left or right is vertical. Retrieves the #GIcon being displayed by the #GtkStatusIcon. The storage type of the status icon must be %GTK_IMAGE_EMPTY or %GTK_IMAGE_GICON (see gtk_status_icon_get_storage_type()). The caller of this function does not own a reference to the returned #GIcon. If this function fails, @icon is left unchanged; Use #GNotification and #GtkApplication to provide status notifications; there is no direct replacement for this function the displayed icon, or %NULL if the image is empty a #GtkStatusIcon Returns the current value of the has-tooltip property. See #GtkStatusIcon:has-tooltip for more information. Use #GNotification and #GtkApplication to provide status notifications; there is no direct replacement for this function current value of has-tooltip on @status_icon. a #GtkStatusIcon Gets the name of the icon being displayed by the #GtkStatusIcon. The storage type of the status icon must be %GTK_IMAGE_EMPTY or %GTK_IMAGE_ICON_NAME (see gtk_status_icon_get_storage_type()). The returned string is owned by the #GtkStatusIcon and should not be freed or modified. Use #GNotification and #GtkApplication to provide status notifications; there is no direct replacement for this function name of the displayed icon, or %NULL if the image is empty. a #GtkStatusIcon Gets the #GdkPixbuf being displayed by the #GtkStatusIcon. The storage type of the status icon must be %GTK_IMAGE_EMPTY or %GTK_IMAGE_PIXBUF (see gtk_status_icon_get_storage_type()). The caller of this function does not own a reference to the returned pixbuf. Use #GNotification and #GtkApplication to provide status notifications; there is no direct replacement for this function the displayed pixbuf, or %NULL if the image is empty. a #GtkStatusIcon Returns the #GdkScreen associated with @status_icon. Use #GNotification and #GtkApplication to provide status notifications; there is no direct replacement for this function, as notifications are managed by the platform a #GdkScreen. a #GtkStatusIcon Gets the size in pixels that is available for the image. Stock icons and named icons adapt their size automatically if the size of the notification area changes. For other storage types, the size-changed signal can be used to react to size changes. Note that the returned size is only meaningful while the status icon is embedded (see gtk_status_icon_is_embedded()). Use #GNotification and #GtkApplication to provide status notifications; there is no direct replacement for this function, as the representation of a notification is left to the platform the size that is available for the image a #GtkStatusIcon Gets the id of the stock icon being displayed by the #GtkStatusIcon. The storage type of the status icon must be %GTK_IMAGE_EMPTY or %GTK_IMAGE_STOCK (see gtk_status_icon_get_storage_type()). The returned string is owned by the #GtkStatusIcon and should not be freed or modified. Use gtk_status_icon_get_icon_name() instead. stock id of the displayed stock icon, or %NULL if the image is empty. a #GtkStatusIcon Gets the type of representation being used by the #GtkStatusIcon to store image data. If the #GtkStatusIcon has no image data, the return value will be %GTK_IMAGE_EMPTY. Use #GNotification and #GtkApplication to provide status notifications; there is no direct replacement for this function, and #GNotification only supports #GIcon instances the image representation being used a #GtkStatusIcon Gets the title of this tray icon. See gtk_status_icon_set_title(). Use #GNotification and #GtkApplication to provide status notifications; there is no direct replacement for this function the title of the status icon a #GtkStatusIcon Gets the contents of the tooltip for @status_icon. Use #GNotification and #GtkApplication to provide status notifications; there is no direct replacement for this function the tooltip text, or %NULL. You should free the returned string with g_free() when done. a #GtkStatusIcon Gets the contents of the tooltip for @status_icon. Use #GNotification and #GtkApplication to provide status notifications; there is no direct replacement for this function the tooltip text, or %NULL. You should free the returned string with g_free() when done. a #GtkStatusIcon Returns whether the status icon is visible or not. Note that being visible does not guarantee that the user can actually see the icon, see also gtk_status_icon_is_embedded(). Use #GNotification and #GtkApplication to provide status notifications; there is no direct replacement for this function %TRUE if the status icon is visible a #GtkStatusIcon This function is only useful on the X11/freedesktop.org platform. It returns a window ID for the widget in the underlying status icon implementation. This is useful for the Galago notification service, which can send a window ID in the protocol in order for the server to position notification windows pointing to a status icon reliably. This function is not intended for other use cases which are more likely to be met by one of the non-X11 specific methods, such as gtk_status_icon_position_menu(). Use #GNotification and #GtkApplication to provide status notifications; there is no direct replacement for this function An 32 bit unsigned integer identifier for the underlying X11 Window a #GtkStatusIcon Returns whether the status icon is embedded in a notification area. Use #GNotification and #GtkApplication to provide status notifications; there is no direct replacement for this function %TRUE if the status icon is embedded in a notification area. a #GtkStatusIcon Makes @status_icon display the file @filename. See gtk_status_icon_new_from_file() for details. Use #GNotification and #GtkApplication to provide status notifications; you can use g_notification_set_icon() to associate a #GIcon with a notification a #GtkStatusIcon a filename Makes @status_icon display the #GIcon. See gtk_status_icon_new_from_gicon() for details. Use #GNotification and #GtkApplication to provide status notifications; you can use g_notification_set_icon() to associate a #GIcon with a notification a #GtkStatusIcon a GIcon Makes @status_icon display the icon named @icon_name from the current icon theme. See gtk_status_icon_new_from_icon_name() for details. Use #GNotification and #GtkApplication to provide status notifications; you can use g_notification_set_icon() to associate a #GIcon with a notification a #GtkStatusIcon an icon name Makes @status_icon display @pixbuf. See gtk_status_icon_new_from_pixbuf() for details. Use #GNotification and #GtkApplication to provide status notifications; you can use g_notification_set_icon() to associate a #GIcon with a notification a #GtkStatusIcon a #GdkPixbuf or %NULL Makes @status_icon display the stock icon with the id @stock_id. See gtk_status_icon_new_from_stock() for details. Use gtk_status_icon_set_from_icon_name() instead. a #GtkStatusIcon a stock icon id Sets the has-tooltip property on @status_icon to @has_tooltip. See #GtkStatusIcon:has-tooltip for more information. Use #GNotification and #GtkApplication to provide status notifications; there is no direct replacement for this function, but notifications can display an arbitrary amount of text using g_notification_set_body() a #GtkStatusIcon whether or not @status_icon has a tooltip Sets the name of this tray icon. This should be a string identifying this icon. It is may be used for sorting the icons in the tray and will not be shown to the user. Use #GNotification and #GtkApplication to provide status notifications; there is no direct replacement for this function, as notifications are associated with a unique application identifier by #GApplication a #GtkStatusIcon the name Sets the #GdkScreen where @status_icon is displayed; if the icon is already mapped, it will be unmapped, and then remapped on the new screen. Use #GNotification and #GtkApplication to provide status notifications; there is no direct replacement for this function, as GTK typically only has one #GdkScreen and notifications are managed by the platform a #GtkStatusIcon a #GdkScreen Sets the title of this tray icon. This should be a short, human-readable, localized string describing the tray icon. It may be used by tools like screen readers to render the tray icon. Use #GNotification and #GtkApplication to provide status notifications; you should use g_notification_set_title() and g_notification_set_body() to present text inside your notification a #GtkStatusIcon the title Sets @markup as the contents of the tooltip, which is marked up with the [Pango text markup language][PangoMarkupFormat]. This function will take care of setting #GtkStatusIcon:has-tooltip to %TRUE and of the default handler for the #GtkStatusIcon::query-tooltip signal. See also the #GtkStatusIcon:tooltip-markup property and gtk_tooltip_set_markup(). Use #GNotification and #GtkApplication to provide status notifications; there is no direct replacement for this function a #GtkStatusIcon the contents of the tooltip for @status_icon, or %NULL Sets @text as the contents of the tooltip. This function will take care of setting #GtkStatusIcon:has-tooltip to %TRUE and of the default handler for the #GtkStatusIcon::query-tooltip signal. See also the #GtkStatusIcon:tooltip-text property and gtk_tooltip_set_text(). Use #GNotification and #GtkApplication to provide status notifications; there is no direct replacement for this function a #GtkStatusIcon the contents of the tooltip for @status_icon Shows or hides a status icon. Use #GNotification and #GtkApplication to provide status notifications; there is no direct replacement for this function, as notifications are managed by the platform a #GtkStatusIcon %TRUE to show the status icon, %FALSE to hide it %TRUE if the statusicon is embedded in a notification area. The #GIcon displayed in the #GtkStatusIcon. For themed icons, the image will be updated automatically if the theme changes. Enables or disables the emission of #GtkStatusIcon::query-tooltip on @status_icon. A value of %TRUE indicates that @status_icon can have a tooltip, in this case the status icon will be queried using #GtkStatusIcon::query-tooltip to determine whether it will provide a tooltip or not. Note that setting this property to %TRUE for the first time will change the event masks of the windows of this status icon to include leave-notify and motion-notify events. This will not be undone when the property is set to %FALSE again. Whether this property is respected is platform dependent. For plain text tooltips, use #GtkStatusIcon:tooltip-text in preference. The orientation of the tray in which the statusicon is embedded. Use #GtkStatusIcon:icon-name instead. The title of this tray icon. This should be a short, human-readable, localized string describing the tray icon. It may be used by tools like screen readers to render the tray icon. Sets the text of tooltip to be the given string, which is marked up with the [Pango text markup language][PangoMarkupFormat]. Also see gtk_tooltip_set_markup(). This is a convenience property which will take care of getting the tooltip shown if the given string is not %NULL. #GtkStatusIcon:has-tooltip will automatically be set to %TRUE and the default handler for the #GtkStatusIcon::query-tooltip signal will take care of displaying the tooltip. On some platforms, embedded markup will be ignored. Sets the text of tooltip to be the given string. Also see gtk_tooltip_set_text(). This is a convenience property which will take care of getting the tooltip shown if the given string is not %NULL. #GtkStatusIcon:has-tooltip will automatically be set to %TRUE and the default handler for the #GtkStatusIcon::query-tooltip signal will take care of displaying the tooltip. Note that some platforms have limitations on the length of tooltips that they allow on status icons, e.g. Windows only shows the first 64 characters. Gets emitted when the user activates the status icon. If and how status icons can activated is platform-dependent. Unlike most G_SIGNAL_ACTION signals, this signal is meant to be used by applications and should be wrapped by language bindings. The ::button-press-event signal will be emitted when a button (typically from a mouse) is pressed. Whether this event is emitted is platform-dependent. Use the ::activate and ::popup-menu signals in preference. %TRUE to stop other handlers from being invoked for the event. %FALSE to propagate the event further. the #GdkEventButton which triggered this signal The ::button-release-event signal will be emitted when a button (typically from a mouse) is released. Whether this event is emitted is platform-dependent. Use the ::activate and ::popup-menu signals in preference. %TRUE to stop other handlers from being invoked for the event. %FALSE to propagate the event further. the #GdkEventButton which triggered this signal Gets emitted when the user brings up the context menu of the status icon. Whether status icons can have context menus and how these are activated is platform-dependent. The @button and @activate_time parameters should be passed as the last to arguments to gtk_menu_popup(). Unlike most G_SIGNAL_ACTION signals, this signal is meant to be used by applications and should be wrapped by language bindings. the button that was pressed, or 0 if the signal is not emitted in response to a button press event the timestamp of the event that triggered the signal emission Emitted when the hover timeout has expired with the cursor hovering above @status_icon; or emitted when @status_icon got focus in keyboard mode. Using the given coordinates, the signal handler should determine whether a tooltip should be shown for @status_icon. If this is the case %TRUE should be returned, %FALSE otherwise. Note that if @keyboard_mode is %TRUE, the values of @x and @y are undefined and should not be used. The signal handler is free to manipulate @tooltip with the therefore destined function calls. Whether this signal is emitted is platform-dependent. For plain text tooltips, use #GtkStatusIcon:tooltip-text in preference. %TRUE if @tooltip should be shown right now, %FALSE otherwise. the x coordinate of the cursor position where the request has been emitted, relative to @status_icon the y coordinate of the cursor position where the request has been emitted, relative to @status_icon %TRUE if the tooltip was trigged using the keyboard a #GtkTooltip The ::scroll-event signal is emitted when a button in the 4 to 7 range is pressed. Wheel mice are usually configured to generate button press events for buttons 4 and 5 when the wheel is turned. Whether this event is emitted is platform-dependent. %TRUE to stop other handlers from being invoked for the event. %FALSE to propagate the event further. the #GdkEventScroll which triggered this signal Gets emitted when the size available for the image changes, e.g. because the notification area got resized. %TRUE if the icon was updated for the new size. Otherwise, GTK+ will scale the icon as necessary. the new size A #GtkStatusbar is usually placed along the bottom of an application's main #GtkWindow. It may provide a regular commentary of the application's status (as is usually the case in a web browser, for example), or may be used to simply output a message when the status changes, (when an upload is complete in an FTP client, for example). Status bars in GTK+ maintain a stack of messages. The message at the top of the each bar’s stack is the one that will currently be displayed. Any messages added to a statusbar’s stack must specify a context id that is used to uniquely identify the source of a message. This context id can be generated by gtk_statusbar_get_context_id(), given a message and the statusbar that it will be added to. Note that messages are stored in a stack, and when choosing which message to display, the stack structure is adhered to, regardless of the context identifier of a message. One could say that a statusbar maintains one stack of messages for display purposes, but allows multiple message producers to maintain sub-stacks of the messages they produced (via context ids). Status bars are created using gtk_statusbar_new(). Messages are added to the bar’s stack with gtk_statusbar_push(). The message at the top of the stack can be removed using gtk_statusbar_pop(). A message can be removed from anywhere in the stack if its message id was recorded at the time it was added. This is done using gtk_statusbar_remove(). # CSS node GtkStatusbar has a single CSS node with name statusbar. Creates a new #GtkStatusbar ready for messages. the new #GtkStatusbar Returns a new context identifier, given a description of the actual context. Note that the description is not shown in the UI. an integer id a #GtkStatusbar textual description of what context the new message is being used in Retrieves the box containing the label widget. a #GtkBox a #GtkStatusbar Removes the first message in the #GtkStatusbar’s stack with the given context id. Note that this may not change the displayed message, if the message at the top of the stack has a different context id. a #GtkStatusbar a context identifier Pushes a new message onto a statusbar’s stack. a message id that can be used with gtk_statusbar_remove(). a #GtkStatusbar the message’s context id, as returned by gtk_statusbar_get_context_id() the message to add to the statusbar Forces the removal of a message from a statusbar’s stack. The exact @context_id and @message_id must be specified. a #GtkStatusbar a context identifier a message identifier, as returned by gtk_statusbar_push() Forces the removal of all messages from a statusbar's stack with the exact @context_id. a #GtkStatusbar a context identifier Is emitted whenever a new message is popped off a statusbar's stack. the context id of the relevant message/statusbar the message that was just popped Is emitted whenever a new message gets pushed onto a statusbar's stack. the context id of the relevant message/statusbar the message that was pushed Identifier. User visible label. Modifier type for keyboard accelerator Keyboard accelerator Translation domain of the menu or toolbar item Copies a stock item, mostly useful for language bindings and not in applications. a new #GtkStockItem a #GtkStockItem Frees a stock item allocated on the heap, such as one returned by gtk_stock_item_copy(). Also frees the fields inside the stock item, if they are not %NULL. a #GtkStockItem A #GtkStyle object encapsulates the information that provides the look and feel for a widget. > In GTK+ 3.0, GtkStyle has been deprecated and replaced by > #GtkStyleContext. Each #GtkWidget has an associated #GtkStyle object that is used when rendering that widget. Also, a #GtkStyle holds information for the five possible widget states though not every widget supports all five states; see #GtkStateType. Usually the #GtkStyle for a widget is the same as the default style that is set by GTK+ and modified the theme engine. Usually applications should not need to use or modify the #GtkStyle of their widgets. Creates a new #GtkStyle. Use #GtkStyleContext a new #GtkStyle. Renders the icon specified by @source at the given @size according to the given parameters and returns the result in a pixbuf. Use gtk_render_icon_pixbuf() instead a newly-created #GdkPixbuf containing the rendered icon a #GtkStyle the #GtkIconSource specifying the icon to render a text direction a state the size to render the icon at (#GtkIconSize). A size of `(GtkIconSize)-1` means render at the size of the source and don’t scale. the widget a style detail Sets the background of @window to the background color or pixmap specified by @style for the given state. Use gtk_style_context_set_background() instead a #GtkStyle a #GdkWindow a state Use #GtkStyleContext instead Attaches a style to a window; this process allocates the colors and creates the GC’s for the style - it specializes it to a particular visual. The process may involve the creation of a new style if the style has already been attached to a window with a different style and visual. Since this function may return a new object, you have to use it in the following way: `style = gtk_style_attach (style, window)` Use gtk_widget_style_attach() instead Either @style, or a newly-created #GtkStyle. If the style is newly created, the style parameter will be unref'ed, and the new style will have a reference count belonging to the caller. a #GtkStyle. a #GdkWindow. Creates a copy of the passed in #GtkStyle object. Use #GtkStyleContext instead a copy of @style a #GtkStyle Detaches a style from a window. If the style is not attached to any windows anymore, it is unrealized. See gtk_style_attach(). Use #GtkStyleContext instead a #GtkStyle Gets the values of a multiple style properties for @widget_type from @style. a #GtkStyle the #GType of a descendant of #GtkWidget the name of the first style property to get pairs of property names and locations to return the property values, starting with the location for @first_property_name, terminated by %NULL. Queries the value of a style property corresponding to a widget class is in the given style. a #GtkStyle the #GType of a descendant of #GtkWidget the name of the style property to get a #GValue where the value of the property being queried will be stored Non-vararg variant of gtk_style_get(). Used primarily by language bindings. a #GtkStyle the #GType of a descendant of #GtkWidget the name of the first style property to get a va_list of pairs of property names and locations to return the property values, starting with the location for @first_property_name. Returns whether @style has an associated #GtkStyleContext. %TRUE if @style has a #GtkStyleContext a #GtkStyle Looks up @color_name in the style’s logical color mappings, filling in @color and returning %TRUE if found, otherwise returning %FALSE. Do not cache the found mapping, because it depends on the #GtkStyle and might change when a theme switch occurs. Use gtk_style_context_lookup_color() instead %TRUE if the mapping was found. a #GtkStyle the name of the logical color to look up the #GdkColor to fill in Looks up @stock_id in the icon factories associated with @style and the default icon factory, returning an icon set if found, otherwise %NULL. Use gtk_style_context_lookup_icon_set() instead icon set of @stock_id a #GtkStyle an icon name Renders the icon specified by @source at the given @size according to the given parameters and returns the result in a pixbuf. Use gtk_render_icon_pixbuf() instead a newly-created #GdkPixbuf containing the rendered icon a #GtkStyle the #GtkIconSource specifying the icon to render a text direction a state the size to render the icon at (#GtkIconSize). A size of `(GtkIconSize)-1` means render at the size of the source and don’t scale. the widget a style detail Sets the background of @window to the background color or pixmap specified by @style for the given state. Use gtk_style_context_set_background() instead a #GtkStyle a #GdkWindow a state Set of foreground #GdkColor Set of background #GdkColor Set of light #GdkColor Set of dark #GdkColor Set of mid #GdkColor Set of text #GdkColor Set of base #GdkColor Color halfway between text/base #GdkColor to use for black #GdkColor to use for white #PangoFontDescription Thickness in X direction Thickness in Y direction Set of background #cairo_pattern_t Emitted when the style has been initialized for a particular visual. Connecting to this signal is probably seldom useful since most of the time applications and widgets only deal with styles that have been already realized. Emitted when the aspects of the style specific to a particular visual is being cleaned up. A connection to this signal can be useful if a widget wants to cache objects as object data on #GtkStyle. This signal provides a convenient place to free such cached objects. The parent class. a #GtkStyle a #GdkWindow a state a newly-created #GdkPixbuf containing the rendered icon a #GtkStyle the #GtkIconSource specifying the icon to render a text direction a state the size to render the icon at (#GtkIconSize). A size of `(GtkIconSize)-1` means render at the size of the source and don’t scale. the widget a style detail #GtkStyleContext is an object that stores styling information affecting a widget defined by #GtkWidgetPath. In order to construct the final style information, #GtkStyleContext queries information from all attached #GtkStyleProviders. Style providers can be either attached explicitly to the context through gtk_style_context_add_provider(), or to the screen through gtk_style_context_add_provider_for_screen(). The resulting style is a combination of all providers’ information in priority order. For GTK+ widgets, any #GtkStyleContext returned by gtk_widget_get_style_context() will already have a #GtkWidgetPath, a #GdkScreen and RTL/LTR information set. The style context will also be updated automatically if any of these settings change on the widget. If you are using the theming layer standalone, you will need to set a widget path and a screen yourself to the created style context through gtk_style_context_set_path() and possibly gtk_style_context_set_screen(). See the “Foreign drawing“ example in gtk3-demo. # Style Classes # {#gtkstylecontext-classes} Widgets can add style classes to their context, which can be used to associate different styles by class. The documentation for individual widgets lists which style classes it uses itself, and which style classes may be added by applications to affect their appearance. GTK+ defines macros for a number of style classes. # Style Regions Widgets can also add regions with flags to their context. This feature is deprecated and will be removed in a future GTK+ update. Please use style classes instead. GTK+ defines macros for a number of style regions. # Custom styling in UI libraries and applications If you are developing a library with custom #GtkWidgets that render differently than standard components, you may need to add a #GtkStyleProvider yourself with the %GTK_STYLE_PROVIDER_PRIORITY_FALLBACK priority, either a #GtkCssProvider or a custom object implementing the #GtkStyleProvider interface. This way themes may still attempt to style your UI elements in a different way if needed so. If you are using custom styling on an applications, you probably want then to make your style information prevail to the theme’s, so you must use a #GtkStyleProvider with the %GTK_STYLE_PROVIDER_PRIORITY_APPLICATION priority, keep in mind that the user settings in `XDG_CONFIG_HOME/gtk-3.0/gtk.css` will still take precedence over your changes, as it uses the %GTK_STYLE_PROVIDER_PRIORITY_USER priority. Creates a standalone #GtkStyleContext, this style context won’t be attached to any widget, so you may want to call gtk_style_context_set_path() yourself. This function is only useful when using the theming layer separated from GTK+, if you are using #GtkStyleContext to theme #GtkWidgets, use gtk_widget_get_style_context() in order to get a style context ready to theme the widget. A newly created #GtkStyleContext. Adds a global style provider to @screen, which will be used in style construction for all #GtkStyleContexts under @screen. GTK+ uses this to make styling information from #GtkSettings available. Note: If both priorities are the same, A #GtkStyleProvider added through gtk_style_context_add_provider() takes precedence over another added through this function. a #GdkScreen a #GtkStyleProvider the priority of the style provider. The lower it is, the earlier it will be used in the style construction. Typically this will be in the range between %GTK_STYLE_PROVIDER_PRIORITY_FALLBACK and %GTK_STYLE_PROVIDER_PRIORITY_USER Removes @provider from the global style providers list in @screen. a #GdkScreen a #GtkStyleProvider This function recomputes the styles for all widgets under a particular #GdkScreen. This is useful when some global parameter has changed that affects the appearance of all widgets, because when a widget gets a new style, it will both redraw and recompute any cached information about its appearance. As an example, it is used when the color scheme changes in the related #GtkSettings object. a #GdkScreen Adds a style class to @context, so posterior calls to gtk_style_context_get() or any of the gtk_render_*() functions will make use of this new class for styling. In the CSS file format, a #GtkEntry defining a “search” class, would be matched by: |[ <!-- language="CSS" --> entry.search { ... } ]| While any widget defining a “search” class would be matched by: |[ <!-- language="CSS" --> .search { ... } ]| a #GtkStyleContext class name to use in styling Adds a style provider to @context, to be used in style construction. Note that a style provider added by this function only affects the style of the widget to which @context belongs. If you want to affect the style of all widgets, use gtk_style_context_add_provider_for_screen(). Note: If both priorities are the same, a #GtkStyleProvider added through this function takes precedence over another added through gtk_style_context_add_provider_for_screen(). a #GtkStyleContext a #GtkStyleProvider the priority of the style provider. The lower it is, the earlier it will be used in the style construction. Typically this will be in the range between %GTK_STYLE_PROVIDER_PRIORITY_FALLBACK and %GTK_STYLE_PROVIDER_PRIORITY_USER Adds a region to @context, so posterior calls to gtk_style_context_get() or any of the gtk_render_*() functions will make use of this new region for styling. In the CSS file format, a #GtkTreeView defining a “row” region, would be matched by: |[ <!-- language="CSS" --> treeview row { ... } ]| Pseudo-classes are used for matching @flags, so the two following rules: |[ <!-- language="CSS" --> treeview row:nth-child(even) { ... } treeview row:nth-child(odd) { ... } ]| would apply to even and odd rows, respectively. Region names must only contain lowercase letters and “-”, starting always with a lowercase letter. a #GtkStyleContext region name to use in styling flags that apply to the region Stops all running animations for @region_id and all animatable regions underneath. A %NULL @region_id will stop all ongoing animations in @context, when dealing with a #GtkStyleContext obtained through gtk_widget_get_style_context(), this is normally done for you in all circumstances you would expect all widget to be stopped, so this should be only used in complex widgets with different animatable regions. This function does nothing. a #GtkStyleContext animatable region to stop, or %NULL. See gtk_style_context_push_animatable_region() Retrieves several style property values from @context for a given state. See gtk_style_context_get_property() for details. a #GtkStyleContext state to retrieve the property values for property name /return value pairs, followed by %NULL Gets the background color for a given state. This function is far less useful than it seems, and it should not be used in newly written code. CSS has no concept of "background color", as a background can be an image, or a gradient, or any other pattern including solid colors. The only reason why you would call gtk_style_context_get_background_color() is to use the returned value to draw the background with it; the correct way to achieve this result is to use gtk_render_background() instead, along with CSS style classes to modify the color to be rendered. Use gtk_render_background() instead. a #GtkStyleContext state to retrieve the color for return value for the background color Gets the border for a given state as a #GtkBorder. See gtk_style_context_get_property() and #GTK_STYLE_PROPERTY_BORDER_WIDTH for details. a #GtkStyleContext state to retrieve the border for return value for the border settings Gets the border color for a given state. Use gtk_render_frame() instead. a #GtkStyleContext state to retrieve the color for return value for the border color Gets the foreground color for a given state. See gtk_style_context_get_property() and #GTK_STYLE_PROPERTY_COLOR for details. a #GtkStyleContext state to retrieve the color for return value for the foreground color Returns the widget direction used for rendering. Use gtk_style_context_get_state() and check for #GTK_STATE_FLAG_DIR_LTR and #GTK_STATE_FLAG_DIR_RTL instead. the widget direction a #GtkStyleContext Returns the font description for a given state. The returned object is const and will remain valid until the #GtkStyleContext::changed signal happens. Use gtk_style_context_get() for "font" or subproperties instead. the #PangoFontDescription for the given state. This object is owned by GTK+ and should not be freed. a #GtkStyleContext state to retrieve the font for Returns the #GdkFrameClock to which @context is attached. a #GdkFrameClock, or %NULL if @context does not have an attached frame clock. a #GtkStyleContext Returns the sides where rendered elements connect visually with others. the junction sides a #GtkStyleContext Gets the margin for a given state as a #GtkBorder. See gtk_style_property_get() and #GTK_STYLE_PROPERTY_MARGIN for details. a #GtkStyleContext state to retrieve the border for return value for the margin settings Gets the padding for a given state as a #GtkBorder. See gtk_style_context_get() and #GTK_STYLE_PROPERTY_PADDING for details. a #GtkStyleContext state to retrieve the padding for return value for the padding settings Gets the parent context set via gtk_style_context_set_parent(). See that function for details. the parent context or %NULL a #GtkStyleContext Returns the widget path used for style matching. A #GtkWidgetPath a #GtkStyleContext Gets a style property from @context for the given state. Note that not all CSS properties that are supported by GTK+ can be retrieved in this way, since they may not be representable as #GValue. GTK+ defines macros for a number of properties that can be used with this function. Note that passing a state other than the current state of @context is not recommended unless the style context has been saved with gtk_style_context_save(). When @value is no longer needed, g_value_unset() must be called to free any allocated memory. a #GtkStyleContext style property name state to retrieve the property value for return location for the style property value Returns the scale used for assets. the scale a #GtkStyleContext Returns the #GdkScreen to which @context is attached. a #GdkScreen. a #GtkStyleContext Queries the location in the CSS where @property was defined for the current @context. Note that the state to be queried is taken from gtk_style_context_get_state(). If the location is not available, %NULL will be returned. The location might not be available for various reasons, such as the property being overridden, @property not naming a supported CSS property or tracking of definitions being disabled for performance reasons. Shorthand CSS properties cannot be queried for a location and will always return %NULL. %NULL or the section where a value for @property was defined a #GtkStyleContext style property name Returns the state used for style matching. This method should only be used to retrieve the #GtkStateFlags to pass to #GtkStyleContext methods, like gtk_style_context_get_padding(). If you need to retrieve the current state of a #GtkWidget, use gtk_widget_get_state_flags(). the state flags a #GtkStyleContext Retrieves several widget style properties from @context according to the current style. a #GtkStyleContext property name /return value pairs, followed by %NULL Gets the value for a widget style property. When @value is no longer needed, g_value_unset() must be called to free any allocated memory. a #GtkStyleContext the name of the widget style property Return location for the property value Retrieves several widget style properties from @context according to the current style. a #GtkStyleContext va_list of property name/return location pairs, followed by %NULL Retrieves several style property values from @context for a given state. See gtk_style_context_get_property() for details. a #GtkStyleContext state to retrieve the property values for va_list of property name/return location pairs, followed by %NULL Returns %TRUE if @context currently has defined the given class name. %TRUE if @context has @class_name defined a #GtkStyleContext a class name Returns %TRUE if @context has the region defined. If @flags_return is not %NULL, it is set to the flags affecting the region. %TRUE if region is defined a #GtkStyleContext a region name return location for region flags Invalidates @context style information, so it will be reconstructed again. It is useful if you modify the @context and need the new information immediately. Style contexts are invalidated automatically. a #GtkStyleContext. Returns the list of classes currently defined in @context. a #GList of strings with the currently defined classes. The contents of the list are owned by GTK+, but you must free the list itself with g_list_free() when you are done with it. a #GtkStyleContext Returns the list of regions currently defined in @context. a #GList of strings with the currently defined regions. The contents of the list are owned by GTK+, but you must free the list itself with g_list_free() when you are done with it. a #GtkStyleContext Looks up and resolves a color name in the @context color map. %TRUE if @color_name was found and resolved, %FALSE otherwise a #GtkStyleContext color name to lookup Return location for the looked up color Looks up @stock_id in the icon factories associated to @context and the default icon factory, returning an icon set if found, otherwise %NULL. Use gtk_icon_theme_lookup_icon() instead. The looked up %GtkIconSet, or %NULL a #GtkStyleContext an icon name Notifies a state change on @context, so if the current style makes use of transition animations, one will be started so all rendered elements under @region_id are animated for state @state being set to value @state_value. The @window parameter is used in order to invalidate the rendered area as the animation runs, so make sure it is the same window that is being rendered on by the gtk_render_*() functions. If @region_id is %NULL, all rendered elements using @context will be affected by this state transition. As a practical example, a #GtkButton notifying a state transition on the prelight state: |[ <!-- language="C" --> gtk_style_context_notify_state_change (context, gtk_widget_get_window (widget), NULL, GTK_STATE_PRELIGHT, button->in_button); ]| Can be handled in the CSS file like this: |[ <!-- language="CSS" --> button { background-color: #f00 } button:hover { background-color: #fff; transition: 200ms linear } ]| This combination will animate the button background from red to white if a pointer enters the button, and back to red if the pointer leaves the button. Note that @state is used when finding the transition parameters, which is why the style places the transition under the :hover pseudo-class. This function does nothing. a #GtkStyleContext a #GdkWindow animatable region to notify on, or %NULL. See gtk_style_context_push_animatable_region() state to trigger transition for %TRUE if @state is the state we are changing to, %FALSE if we are changing away from it Pops an animatable region from @context. See gtk_style_context_push_animatable_region(). This function does nothing. a #GtkStyleContext Pushes an animatable region, so all further gtk_render_*() calls between this call and the following gtk_style_context_pop_animatable_region() will potentially show transition animations for this region if gtk_style_context_notify_state_change() is called for a given state, and the current theme/style defines transition animations for state changes. The @region_id used must be unique in @context so the themes can uniquely identify rendered elements subject to a state transition. This function does nothing. a #GtkStyleContext unique identifier for the animatable region Removes @class_name from @context. a #GtkStyleContext class name to remove Removes @provider from the style providers list in @context. a #GtkStyleContext a #GtkStyleProvider Removes a region from @context. a #GtkStyleContext region name to unset Restores @context state to a previous stage. See gtk_style_context_save(). a #GtkStyleContext Saves the @context state, so temporary modifications done through gtk_style_context_add_class(), gtk_style_context_remove_class(), gtk_style_context_set_state(), etc. can quickly be reverted in one go through gtk_style_context_restore(). The matching call to gtk_style_context_restore() must be done before GTK returns to the main loop. a #GtkStyleContext This function is analogous to gdk_window_scroll(), and should be called together with it so the invalidation areas for any ongoing animation are scrolled together with it. This function does nothing. a #GtkStyleContext a #GdkWindow used previously in gtk_style_context_notify_state_change() Amount to scroll in the X axis Amount to scroll in the Y axis Sets the background of @window to the background pattern or color specified in @context for its current state. Use gtk_render_background() instead. Note that clients still using this function are now responsible for calling this function again whenever @context is invalidated. a #GtkStyleContext a #GdkWindow Sets the reading direction for rendering purposes. If you are using a #GtkStyleContext returned from gtk_widget_get_style_context(), you do not need to call this yourself. Use gtk_style_context_set_state() with #GTK_STATE_FLAG_DIR_LTR and #GTK_STATE_FLAG_DIR_RTL instead. a #GtkStyleContext the new direction. Attaches @context to the given frame clock. The frame clock is used for the timing of animations. If you are using a #GtkStyleContext returned from gtk_widget_get_style_context(), you do not need to call this yourself. a #GdkFrameClock a #GdkFrameClock Sets the sides where rendered elements (mostly through gtk_render_frame()) will visually connect with other visual elements. This is merely a hint that may or may not be honored by themes. Container widgets are expected to set junction hints as appropriate for their children, so it should not normally be necessary to call this function manually. a #GtkStyleContext sides where rendered elements are visually connected to other elements Sets the parent style context for @context. The parent style context is used to implement [inheritance](http://www.w3.org/TR/css3-cascade/#inheritance) of properties. If you are using a #GtkStyleContext returned from gtk_widget_get_style_context(), the parent will be set for you. a #GtkStyleContext the new parent or %NULL Sets the #GtkWidgetPath used for style matching. As a consequence, the style will be regenerated to match the new given path. If you are using a #GtkStyleContext returned from gtk_widget_get_style_context(), you do not need to call this yourself. a #GtkStyleContext a #GtkWidgetPath Sets the scale to use when getting image assets for the style. a #GtkStyleContext scale Attaches @context to the given screen. The screen is used to add style information from “global” style providers, such as the screen’s #GtkSettings instance. If you are using a #GtkStyleContext returned from gtk_widget_get_style_context(), you do not need to call this yourself. a #GtkStyleContext a #GdkScreen Sets the state to be used for style matching. a #GtkStyleContext state to represent Returns %TRUE if there is a transition animation running for the current region (see gtk_style_context_push_animatable_region()). If @progress is not %NULL, the animation progress will be returned there, 0.0 means the state is closest to being unset, while 1.0 means it’s closest to being set. This means transition animation will run from 0 to 1 when @state is being set and from 1 to 0 when it’s being unset. This function always returns %FALSE %TRUE if there is a running transition animation for @state. a #GtkStyleContext a widget state return location for the transition progress Converts the style context into a string representation. The string representation always includes information about the name, state, id, visibility and style classes of the CSS node that is backing @context. Depending on the flags, more information may be included. This function is intended for testing and debugging of the CSS implementation in GTK+. There are no guarantees about the format of the returned string, it may change. a newly allocated string representing @context a #GtkStyleContext Flags that determine what to print Sets or gets the style context’s parent. See gtk_style_context_set_parent() for details. The ::changed signal is emitted when there is a change in the #GtkStyleContext. For a #GtkStyleContext returned by gtk_widget_get_style_context(), the #GtkWidget::style-updated signal/vfunc might be more convenient to use. This signal is useful when using the theming layer standalone. Flags that modify the behavior of gtk_style_context_to_string(). New values may be added to this enumeration. Print the entire tree of CSS nodes starting at the style context's node Show the values of the CSS properties for each node GtkStyleProperties provides the storage for style information that is used by #GtkStyleContext and other #GtkStyleProvider implementations. Before style properties can be stored in GtkStyleProperties, they must be registered with gtk_style_properties_register_property(). Unless you are writing a #GtkStyleProvider implementation, you are unlikely to use this API directly, as gtk_style_context_get() and its variants are the preferred way to access styling information from widget implementations and theming engine implementations should use the APIs provided by #GtkThemingEngine instead. #GtkStyleProperties has been deprecated in GTK 3.16. The CSS machinery does not use it anymore and all users of this object have been deprecated. Returns a newly created #GtkStyleProperties #GtkStyleProperties are deprecated. a new #GtkStyleProperties Returns %TRUE if a property has been registered, if @pspec or @parse_func are not %NULL, the #GParamSpec and parsing function will be respectively returned. This code could only look up custom properties and those are deprecated. %TRUE if the property is registered, %FALSE otherwise property name to look up return location for the parse function return location for the #GParamSpec Registers a property so it can be used in the CSS file format. This function is the low-level equivalent of gtk_theming_engine_register_property(), if you are implementing a theming engine, you want to use that function instead. Code should use the default properties provided by CSS. parsing function to use, or %NULL the #GParamSpec for the new property Clears all style information from @props. #GtkStyleProperties are deprecated. a #GtkStyleProperties Retrieves several style property values from @props for a given state. #GtkStyleProperties are deprecated. a #GtkStyleProperties state to retrieve the property values for property name /return value pairs, followed by %NULL Gets a style property from @props for the given state. When done with @value, g_value_unset() needs to be called to free any allocated memory. #GtkStyleProperties are deprecated. %TRUE if the property exists in @props, %FALSE otherwise a #GtkStyleProperties style property name state to retrieve the property value for return location for the style property value. Retrieves several style property values from @props for a given state. #GtkStyleProperties are deprecated. a #GtkStyleProperties state to retrieve the property values for va_list of property name/return location pairs, followed by %NULL Returns the symbolic color that is mapped to @name. #GtkSymbolicColor is deprecated. The mapped color a #GtkStyleProperties color name to lookup Maps @color so it can be referenced by @name. See gtk_style_properties_lookup_color() #GtkSymbolicColor is deprecated. a #GtkStyleProperties color name #GtkSymbolicColor to map @name to Merges into @props all the style information contained in @props_to_merge. If @replace is %TRUE, the values will be overwritten, if it is %FALSE, the older values will prevail. #GtkStyleProperties are deprecated. a #GtkStyleProperties a second #GtkStyleProperties whether to replace values or not Sets several style properties on @props. #GtkStyleProperties are deprecated. a #GtkStyleProperties state to set the values for property name/value pairs, followed by %NULL Sets a styling property in @props. #GtkStyleProperties are deprecated. a #GtkStyleProperties styling property to set state to set the value for new value for the property Sets several style properties on @props. #GtkStyleProperties are deprecated. a #GtkStyleProperties state to set the values for va_list of property name/value pairs, followed by %NULL Unsets a style property in @props. #GtkStyleProperties are deprecated. a #GtkStyleProperties property to unset state to unset GtkStyleProvider is an interface used to provide style information to a #GtkStyleContext. See gtk_style_context_add_provider() and gtk_style_context_add_provider_for_screen(). Returns the #GtkIconFactory defined to be in use for @path, or %NULL if none is defined. Will always return %NULL for all GTK-provided style providers. The icon factory to use for @path, or %NULL a #GtkStyleProvider #GtkWidgetPath to query Returns the style settings affecting a widget defined by @path, or %NULL if @provider doesn’t contemplate styling @path. Will always return %NULL for all GTK-provided style providers as the interface cannot correctly work the way CSS is specified. a #GtkStyleProperties containing the style settings affecting @path a #GtkStyleProvider #GtkWidgetPath to query Looks up a widget style property as defined by @provider for the widget represented by @path. %TRUE if the property was found and has a value, %FALSE otherwise a #GtkStyleProvider #GtkWidgetPath to query state to query the style property for The #GParamSpec to query return location for the property value Returns the #GtkIconFactory defined to be in use for @path, or %NULL if none is defined. Will always return %NULL for all GTK-provided style providers. The icon factory to use for @path, or %NULL a #GtkStyleProvider #GtkWidgetPath to query Returns the style settings affecting a widget defined by @path, or %NULL if @provider doesn’t contemplate styling @path. Will always return %NULL for all GTK-provided style providers as the interface cannot correctly work the way CSS is specified. a #GtkStyleProperties containing the style settings affecting @path a #GtkStyleProvider #GtkWidgetPath to query Looks up a widget style property as defined by @provider for the widget represented by @path. %TRUE if the property was found and has a value, %FALSE otherwise a #GtkStyleProvider #GtkWidgetPath to query state to query the style property for The #GParamSpec to query return location for the property value a #GtkStyleProperties containing the style settings affecting @path a #GtkStyleProvider #GtkWidgetPath to query %TRUE if the property was found and has a value, %FALSE otherwise a #GtkStyleProvider #GtkWidgetPath to query state to query the style property for The #GParamSpec to query return location for the property value The icon factory to use for @path, or %NULL a #GtkStyleProvider #GtkWidgetPath to query #GtkSwitch is a widget that has two states: on or off. The user can control which state should be active by clicking the empty area, or by dragging the handle. GtkSwitch can also handle situations where the underlying state changes with a delay. See #GtkSwitch::state-set for details. # CSS nodes |[<!-- language="plain" --> switch ╰── slider ]| GtkSwitch has two css nodes, the main node with the name switch and a subnode named slider. Neither of them is using any style classes. Creates a new #GtkSwitch widget. the newly created #GtkSwitch instance Gets whether the #GtkSwitch is in its “on” or “off” state. %TRUE if the #GtkSwitch is active, and %FALSE otherwise a #GtkSwitch Gets the underlying state of the #GtkSwitch. the underlying state a #GtkSwitch Changes the state of @sw to the desired one. a #GtkSwitch %TRUE if @sw should be active, and %FALSE otherwise Sets the underlying state of the #GtkSwitch. Normally, this is the same as #GtkSwitch:active, unless the switch is set up for delayed state changes. This function is typically called from a #GtkSwitch::state-set signal handler. See #GtkSwitch::state-set for details. a #GtkSwitch the new state Whether the #GtkSwitch widget is in its on or off state. The backend state that is controlled by the switch. See #GtkSwitch::state-set for details. The ::activate signal on GtkSwitch is an action signal and emitting it causes the switch to animate. Applications should never connect to this signal, but use the notify::active signal. The ::state-set signal on GtkSwitch is emitted to change the underlying state. It is emitted when the user changes the switch position. The default handler keeps the state in sync with the #GtkSwitch:active property. To implement delayed state change, applications can connect to this signal, initiate the change of the underlying state, and call gtk_switch_set_state() when the underlying state change is complete. The signal handler should return %TRUE to prevent the default handler from running. Visually, the underlying state is represented by the trough color of the switch, while the #GtkSwitch:active property is represented by the position of the switch. %TRUE to stop the signal emission the new state of the switch The parent class. GtkSymbolicColor is a boxed type that represents a symbolic color. It is the result of parsing a [color expression][gtkcssprovider-symbolic-colors]. To obtain the color represented by a GtkSymbolicColor, it has to be resolved with gtk_symbolic_color_resolve(), which replaces all symbolic color references by the colors they refer to (in a given context) and evaluates mix, shade and other expressions, resulting in a #GdkRGBA value. It is not normally necessary to deal directly with #GtkSymbolicColors, since they are mostly used behind the scenes by #GtkStyleContext and #GtkCssProvider. #GtkSymbolicColor is deprecated. Symbolic colors are considered an implementation detail of GTK+. Creates a symbolic color by modifying the relative alpha value of @color. A factor < 1.0 would resolve to a more transparent color, while > 1.0 would resolve to a more opaque color. #GtkSymbolicColor is deprecated. A newly created #GtkSymbolicColor another #GtkSymbolicColor factor to apply to @color alpha Creates a symbolic color pointing to a literal color. #GtkSymbolicColor is deprecated. a newly created #GtkSymbolicColor a #GdkRGBA Creates a symbolic color defined as a mix of another two colors. a mix factor of 0 would resolve to @color1, while a factor of 1 would resolve to @color2. #GtkSymbolicColor is deprecated. A newly created #GtkSymbolicColor color to mix another color to mix mix factor Creates a symbolic color pointing to an unresolved named color. See gtk_style_context_lookup_color() and gtk_style_properties_lookup_color(). #GtkSymbolicColor is deprecated. a newly created #GtkSymbolicColor color name Creates a symbolic color defined as a shade of another color. A factor > 1.0 would resolve to a brighter color, while < 1.0 would resolve to a darker color. #GtkSymbolicColor is deprecated. A newly created #GtkSymbolicColor another #GtkSymbolicColor shading factor to apply to @color Creates a symbolic color based on the current win32 theme. Note that while this call is available on all platforms the actual value returned is not reliable on non-win32 platforms. #GtkSymbolicColor is deprecated. A newly created #GtkSymbolicColor The theme class to pull color from The color id Increases the reference count of @color #GtkSymbolicColor is deprecated. the same @color a #GtkSymbolicColor If @color is resolvable, @resolved_color will be filled in with the resolved color, and %TRUE will be returned. Generally, if @color can’t be resolved, it is due to it being defined on top of a named color that doesn’t exist in @props. When @props is %NULL, resolving of named colors will fail, so if your @color is or references such a color, this function will return %FALSE. #GtkSymbolicColor is deprecated. %TRUE if the color has been resolved a #GtkSymbolicColor #GtkStyleProperties to use when resolving named colors, or %NULL return location for the resolved color Converts the given @color to a string representation. This is useful both for debugging and for serialization of strings. The format of the string may change between different versions of GTK, but it is guaranteed that the GTK css parser is able to read the string and create the same symbolic color from it. #GtkSymbolicColor is deprecated. a new string representing @color color to convert to a string Decreases the reference count of @color, freeing its memory if the reference count reaches 0. #GtkSymbolicColor is deprecated. a #GtkSymbolicColor The priority at which the text view validates onscreen lines in an idle job in the background. The GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID can be used to make a #GtkTreeSortable use the default sort function. See also gtk_tree_sortable_set_sort_column_id() The GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID can be used to make a #GtkTreeSortable use no sorting. See also gtk_tree_sortable_set_sort_column_id() The #GtkTable functions allow the programmer to arrange widgets in rows and columns, making it easy to align many widgets next to each other, horizontally and vertically. Tables are created with a call to gtk_table_new(), the size of which can later be changed with gtk_table_resize(). Widgets can be added to a table using gtk_table_attach() or the more convenient (but slightly less flexible) gtk_table_attach_defaults(). To alter the space next to a specific row, use gtk_table_set_row_spacing(), and for a column, gtk_table_set_col_spacing(). The gaps between all rows or columns can be changed by calling gtk_table_set_row_spacings() or gtk_table_set_col_spacings() respectively. Note that spacing is added between the children, while padding added by gtk_table_attach() is added on either side of the widget it belongs to. gtk_table_set_homogeneous(), can be used to set whether all cells in the table will resize themselves to the size of the largest widget in the table. > #GtkTable has been deprecated. Use #GtkGrid instead. It provides the same > capabilities as GtkTable for arranging widgets in a rectangular grid, but > does support height-for-width geometry management. Used to create a new table widget. An initial size must be given by specifying how many rows and columns the table should have, although this can be changed later with gtk_table_resize(). @rows and @columns must both be in the range 1 .. 65535. For historical reasons, 0 is accepted as well and is silently interpreted as 1. Use gtk_grid_new(). A pointer to the newly created table widget. The number of rows the new table should have. The number of columns the new table should have. If set to %TRUE, all table cells are resized to the size of the cell containing the largest widget. Adds a widget to a table. The number of “cells” that a widget will occupy is specified by @left_attach, @right_attach, @top_attach and @bottom_attach. These each represent the leftmost, rightmost, uppermost and lowest column and row numbers of the table. (Columns and rows are indexed from zero). To make a button occupy the lower right cell of a 2x2 table, use |[ gtk_table_attach (table, button, 1, 2, // left, right attach 1, 2, // top, bottom attach xoptions, yoptions, xpadding, ypadding); ]| If you want to make the button span the entire bottom row, use @left_attach == 0 and @right_attach = 2 instead. Use gtk_grid_attach() with #GtkGrid. Note that the attach arguments differ between those two functions. The #GtkTable to add a new widget to. The widget to add. the column number to attach the left side of a child widget to. the column number to attach the right side of a child widget to. the row number to attach the top of a child widget to. the row number to attach the bottom of a child widget to. Used to specify the properties of the child widget when the table is resized. The same as xoptions, except this field determines behaviour of vertical resizing. An integer value specifying the padding on the left and right of the widget being added to the table. The amount of padding above and below the child widget. As there are many options associated with gtk_table_attach(), this convenience function provides the programmer with a means to add children to a table with identical padding and expansion options. The values used for the #GtkAttachOptions are `GTK_EXPAND | GTK_FILL`, and the padding is set to 0. Use gtk_grid_attach() with #GtkGrid. Note that the attach arguments differ between those two functions. The table to add a new child widget to. The child widget to add. The column number to attach the left side of the child widget to. The column number to attach the right side of the child widget to. The row number to attach the top of the child widget to. The row number to attach the bottom of the child widget to. Gets the amount of space between column @col, and column @col + 1. See gtk_table_set_col_spacing(). #GtkGrid does not offer a replacement for this functionality. the column spacing a #GtkTable a column in the table, 0 indicates the first column Gets the default column spacing for the table. This is the spacing that will be used for newly added columns. (See gtk_table_set_col_spacings()) Use gtk_grid_get_column_spacing() with #GtkGrid. the default column spacing a #GtkTable Gets the default row spacing for the table. This is the spacing that will be used for newly added rows. (See gtk_table_set_row_spacings()) Use gtk_grid_get_row_spacing() with #GtkGrid. the default row spacing a #GtkTable Returns whether the table cells are all constrained to the same width and height. (See gtk_table_set_homogeneous ()) Use gtk_grid_get_row_homogeneous() and gtk_grid_get_column_homogeneous() with #GtkGrid. %TRUE if the cells are all constrained to the same size a #GtkTable Gets the amount of space between row @row, and row @row + 1. See gtk_table_set_row_spacing(). #GtkGrid does not offer a replacement for this functionality. the row spacing a #GtkTable a row in the table, 0 indicates the first row Gets the number of rows and columns in the table. #GtkGrid does not expose the number of columns and rows. a #GtkTable return location for the number of rows, or %NULL return location for the number of columns, or %NULL If you need to change a table’s size after it has been created, this function allows you to do so. #GtkGrid resizes automatically. The #GtkTable you wish to change the size of. The new number of rows. The new number of columns. Alters the amount of space between a given table column and the following column. Use gtk_widget_set_margin_start() and gtk_widget_set_margin_end() on the widgets contained in the row if you need this functionality. #GtkGrid does not support per-row spacing. a #GtkTable. the column whose spacing should be changed. number of pixels that the spacing should take up. Sets the space between every column in @table equal to @spacing. Use gtk_grid_set_column_spacing() with #GtkGrid. a #GtkTable. the number of pixels of space to place between every column in the table. Changes the homogenous property of table cells, ie. whether all cells are an equal size or not. Use gtk_grid_set_row_homogeneous() and gtk_grid_set_column_homogeneous() with #GtkGrid. The #GtkTable you wish to set the homogeneous properties of. Set to %TRUE to ensure all table cells are the same size. Set to %FALSE if this is not your desired behaviour. Changes the space between a given table row and the subsequent row. Use gtk_widget_set_margin_top() and gtk_widget_set_margin_bottom() on the widgets contained in the row if you need this functionality. #GtkGrid does not support per-row spacing. a #GtkTable containing the row whose properties you wish to change. row number whose spacing will be changed. number of pixels that the spacing should take up. Sets the space between every row in @table equal to @spacing. Use gtk_grid_set_row_spacing() with #GtkGrid. a #GtkTable. the number of pixels of space to place between every row in the table. A #GtkTargetEntry represents a single type of data than can be supplied for by a widget for a selection or for supplied or received during drag-and-drop. a string representation of the target type #GtkTargetFlags for DND an application-assigned integer ID which will get passed as a parameter to e.g the #GtkWidget::selection-get signal. It allows the application to identify the target type without extensive string compares. Makes a new #GtkTargetEntry. a pointer to a new #GtkTargetEntry. Free with gtk_target_entry_free() String identifier for target Set of flags, see #GtkTargetFlags an ID that will be passed back to the application Makes a copy of a #GtkTargetEntry and its data. a pointer to a copy of @data. Free with gtk_target_entry_free() a pointer to a #GtkTargetEntry Frees a #GtkTargetEntry returned from gtk_target_entry_new() or gtk_target_entry_copy(). a pointer to a #GtkTargetEntry. The #GtkTargetFlags enumeration is used to specify constraints on a #GtkTargetEntry. If this is set, the target will only be selected for drags within a single application. If this is set, the target will only be selected for drags within a single widget. If this is set, the target will not be selected for drags within a single application. If this is set, the target will not be selected for drags withing a single widget. A #GtkTargetList-struct is a reference counted list of #GtkTargetPair and should be treated as opaque. Creates a new #GtkTargetList from an array of #GtkTargetEntry. the new #GtkTargetList. Pointer to an array of #GtkTargetEntry number of entries in @targets. Appends another target to a #GtkTargetList. a #GtkTargetList the interned atom representing the target the flags for this target an ID that will be passed back to the application Appends the image targets supported by #GtkSelectionData to the target list. All targets are added with the same @info. a #GtkTargetList an ID that will be passed back to the application whether to add only targets for which GTK+ knows how to convert a pixbuf into the format Appends the rich text targets registered with gtk_text_buffer_register_serialize_format() or gtk_text_buffer_register_deserialize_format() to the target list. All targets are added with the same @info. a #GtkTargetList an ID that will be passed back to the application if %TRUE, then deserializable rich text formats will be added, serializable formats otherwise. a #GtkTextBuffer. Prepends a table of #GtkTargetEntry to a target list. a #GtkTargetList the table of #GtkTargetEntry number of targets in the table Appends the text targets supported by #GtkSelectionData to the target list. All targets are added with the same @info. a #GtkTargetList an ID that will be passed back to the application Appends the URI targets supported by #GtkSelectionData to the target list. All targets are added with the same @info. a #GtkTargetList an ID that will be passed back to the application Looks up a given target in a #GtkTargetList. %TRUE if the target was found, otherwise %FALSE a #GtkTargetList an interned atom representing the target to search for a pointer to the location to store application info for target, or %NULL Increases the reference count of a #GtkTargetList by one. the passed in #GtkTargetList. a #GtkTargetList Removes a target from a target list. a #GtkTargetList the interned atom representing the target Decreases the reference count of a #GtkTargetList by one. If the resulting reference count is zero, frees the list. a #GtkTargetList A #GtkTargetPair is used to represent the same information as a table of #GtkTargetEntry, but in an efficient form. #GdkAtom representation of the target type #GtkTargetFlags for DND an application-assigned integer ID which will get passed as a parameter to e.g the #GtkWidget::selection-get signal. It allows the application to identify the target type without extensive string compares. A #GtkTearoffMenuItem is a special #GtkMenuItem which is used to tear off and reattach its menu. When its menu is shown normally, the #GtkTearoffMenuItem is drawn as a dotted line indicating that the menu can be torn off. Activating it causes its menu to be torn off and displayed in its own window as a tearoff menu. When its menu is shown as a tearoff menu, the #GtkTearoffMenuItem is drawn as a dotted line which has a left pointing arrow graphic indicating that the tearoff menu can be reattached. Activating it will erase the tearoff menu window. > #GtkTearoffMenuItem is deprecated and should not be used in newly > written code. Menus are not meant to be torn around. Creates a new #GtkTearoffMenuItem. #GtkTearoffMenuItem is deprecated and should not be used in newly written code. a new #GtkTearoffMenuItem. The parent class. Background #GdkColor. Foreground #GdkColor. Super/subscript rise, can be negative. #PangoUnderline Strikethrough style Whether to use background-related values; this is irrelevant for the values struct when in a tag, but is used for the composite values struct; it’s true if any of the tags being composited had background stuff set. This are only used when we are actually laying out and rendering a paragraph; not when a #GtkTextAppearance is part of a #GtkTextAttributes. This are only used when we are actually laying out and rendering a paragraph; not when a #GtkTextAppearance is part of a #GtkTextAttributes. Using #GtkTextAttributes directly should rarely be necessary. It’s primarily useful with gtk_text_iter_get_attributes(). As with most GTK+ structs, the fields in this struct should only be read, never modified directly. #GtkTextAppearance for text. #GtkJustification for text. #GtkTextDirection for text. #PangoFontDescription for text. Font scale factor. Width of the left margin in pixels. Width of the right margin in pixels. Amount to indent the paragraph, in pixels. Pixels of blank space above paragraphs. Pixels of blank space below paragraphs. Pixels of blank space between wrapped lines in a paragraph. Custom #PangoTabArray for this text. #GtkWrapMode for text. #PangoLanguage for text. Hide the text. Background is fit to full line height rather than baseline +/- ascent/descent (font height). Can edit this text. Whether to disable font fallback. Extra space to insert between graphemes, in Pango units Creates a #GtkTextAttributes, which describes a set of properties on some text. a new #GtkTextAttributes, free with gtk_text_attributes_unref(). Copies @src and returns a new #GtkTextAttributes. a copy of @src, free with gtk_text_attributes_unref() a #GtkTextAttributes to be copied Copies the values from @src to @dest so that @dest has the same values as @src. Frees existing values in @dest. a #GtkTextAttributes another #GtkTextAttributes Increments the reference count on @values. the #GtkTextAttributes that were passed in a #GtkTextAttributes Decrements the reference count on @values, freeing the structure if the reference count reaches 0. a #GtkTextAttributes You may wish to begin by reading the [text widget conceptual overview][TextWidget] which gives an overview of all the objects and data types related to the text widget and how they work together. Creates a new text buffer. a new text buffer a tag table, or %NULL to create a new one Emits the “apply-tag” signal on @buffer. The default handler for the signal applies @tag to the given range. @start and @end do not have to be in order. a #GtkTextBuffer a #GtkTextTag one bound of range to be tagged other bound of range to be tagged Called to indicate that the buffer operations between here and a call to gtk_text_buffer_end_user_action() are part of a single user-visible operation. The operations between gtk_text_buffer_begin_user_action() and gtk_text_buffer_end_user_action() can then be grouped when creating an undo stack. #GtkTextBuffer maintains a count of calls to gtk_text_buffer_begin_user_action() that have not been closed with a call to gtk_text_buffer_end_user_action(), and emits the “begin-user-action” and “end-user-action” signals only for the outermost pair of calls. This allows you to build user actions from other user actions. The “interactive” buffer mutation functions, such as gtk_text_buffer_insert_interactive(), automatically call begin/end user action around the buffer operations they perform, so there's no need to add extra calls if you user action consists solely of a single call to one of those functions. a #GtkTextBuffer Should be paired with a call to gtk_text_buffer_begin_user_action(). See that function for a full explanation. a #GtkTextBuffer Inserts a child widget anchor into the text buffer at @iter. The anchor will be counted as one character in character counts, and when obtaining the buffer contents as a string, will be represented by the Unicode “object replacement character” 0xFFFC. Note that the “slice” variants for obtaining portions of the buffer as a string include this character for child anchors, but the “text” variants do not. E.g. see gtk_text_buffer_get_slice() and gtk_text_buffer_get_text(). Consider gtk_text_buffer_create_child_anchor() as a more convenient alternative to this function. The buffer will add a reference to the anchor, so you can unref it after insertion. a #GtkTextBuffer location to insert the anchor a #GtkTextChildAnchor Inserts an image into the text buffer at @iter. The image will be counted as one character in character counts, and when obtaining the buffer contents as a string, will be represented by the Unicode “object replacement character” 0xFFFC. Note that the “slice” variants for obtaining portions of the buffer as a string include this character for pixbufs, but the “text” variants do not. e.g. see gtk_text_buffer_get_slice() and gtk_text_buffer_get_text(). a #GtkTextBuffer location to insert the pixbuf a #GdkPixbuf Emits the “remove-tag” signal. The default handler for the signal removes all occurrences of @tag from the given range. @start and @end don’t have to be in order. a #GtkTextBuffer a #GtkTextTag one bound of range to be untagged other bound of range to be untagged Adds the mark at position @where. The mark must not be added to another buffer, and if its name is not %NULL then there must not be another mark in the buffer with the same name. Emits the #GtkTextBuffer::mark-set signal as notification of the mark's initial placement. a #GtkTextBuffer the mark to add location to place mark Adds @clipboard to the list of clipboards in which the selection contents of @buffer are available. In most cases, @clipboard will be the #GtkClipboard of type %GDK_SELECTION_PRIMARY for a view of @buffer. a #GtkTextBuffer a #GtkClipboard Emits the “apply-tag” signal on @buffer. The default handler for the signal applies @tag to the given range. @start and @end do not have to be in order. a #GtkTextBuffer a #GtkTextTag one bound of range to be tagged other bound of range to be tagged Calls gtk_text_tag_table_lookup() on the buffer’s tag table to get a #GtkTextTag, then calls gtk_text_buffer_apply_tag(). a #GtkTextBuffer name of a named #GtkTextTag one bound of range to be tagged other bound of range to be tagged Performs the appropriate action as if the user hit the delete key with the cursor at the position specified by @iter. In the normal case a single character will be deleted, but when combining accents are involved, more than one character can be deleted, and when precomposed character and accent combinations are involved, less than one character will be deleted. Because the buffer is modified, all outstanding iterators become invalid after calling this function; however, the @iter will be re-initialized to point to the location where text was deleted. %TRUE if the buffer was modified a #GtkTextBuffer a position in @buffer whether the deletion is caused by user interaction whether the buffer is editable by default Called to indicate that the buffer operations between here and a call to gtk_text_buffer_end_user_action() are part of a single user-visible operation. The operations between gtk_text_buffer_begin_user_action() and gtk_text_buffer_end_user_action() can then be grouped when creating an undo stack. #GtkTextBuffer maintains a count of calls to gtk_text_buffer_begin_user_action() that have not been closed with a call to gtk_text_buffer_end_user_action(), and emits the “begin-user-action” and “end-user-action” signals only for the outermost pair of calls. This allows you to build user actions from other user actions. The “interactive” buffer mutation functions, such as gtk_text_buffer_insert_interactive(), automatically call begin/end user action around the buffer operations they perform, so there's no need to add extra calls if you user action consists solely of a single call to one of those functions. a #GtkTextBuffer Copies the currently-selected text to a clipboard. a #GtkTextBuffer the #GtkClipboard object to copy to This is a convenience function which simply creates a child anchor with gtk_text_child_anchor_new() and inserts it into the buffer with gtk_text_buffer_insert_child_anchor(). The new anchor is owned by the buffer; no reference count is returned to the caller of gtk_text_buffer_create_child_anchor(). the created child anchor a #GtkTextBuffer location in the buffer Creates a mark at position @where. If @mark_name is %NULL, the mark is anonymous; otherwise, the mark can be retrieved by name using gtk_text_buffer_get_mark(). If a mark has left gravity, and text is inserted at the mark’s current location, the mark will be moved to the left of the newly-inserted text. If the mark has right gravity (@left_gravity = %FALSE), the mark will end up on the right of newly-inserted text. The standard left-to-right cursor is a mark with right gravity (when you type, the cursor stays on the right side of the text you’re typing). The caller of this function does not own a reference to the returned #GtkTextMark, so you can ignore the return value if you like. Marks are owned by the buffer and go away when the buffer does. Emits the #GtkTextBuffer::mark-set signal as notification of the mark's initial placement. the new #GtkTextMark object a #GtkTextBuffer name for mark, or %NULL location to place mark whether the mark has left gravity Creates a tag and adds it to the tag table for @buffer. Equivalent to calling gtk_text_tag_new() and then adding the tag to the buffer’s tag table. The returned tag is owned by the buffer’s tag table, so the ref count will be equal to one. If @tag_name is %NULL, the tag is anonymous. If @tag_name is non-%NULL, a tag called @tag_name must not already exist in the tag table for this buffer. The @first_property_name argument and subsequent arguments are a list of properties to set on the tag, as with g_object_set(). a new tag a #GtkTextBuffer name of the new tag, or %NULL name of first property to set, or %NULL %NULL-terminated list of property names and values Copies the currently-selected text to a clipboard, then deletes said text if it’s editable. a #GtkTextBuffer the #GtkClipboard object to cut to default editability of the buffer Deletes text between @start and @end. The order of @start and @end is not actually relevant; gtk_text_buffer_delete() will reorder them. This function actually emits the “delete-range” signal, and the default handler of that signal deletes the text. Because the buffer is modified, all outstanding iterators become invalid after calling this function; however, the @start and @end will be re-initialized to point to the location where text was deleted. a #GtkTextBuffer a position in @buffer another position in @buffer Deletes all editable text in the given range. Calls gtk_text_buffer_delete() for each editable sub-range of [@start,@end). @start and @end are revalidated to point to the location of the last deleted range, or left untouched if no text was deleted. whether some text was actually deleted a #GtkTextBuffer start of range to delete end of range whether the buffer is editable by default Deletes @mark, so that it’s no longer located anywhere in the buffer. Removes the reference the buffer holds to the mark, so if you haven’t called g_object_ref() on the mark, it will be freed. Even if the mark isn’t freed, most operations on @mark become invalid, until it gets added to a buffer again with gtk_text_buffer_add_mark(). Use gtk_text_mark_get_deleted() to find out if a mark has been removed from its buffer. The #GtkTextBuffer::mark-deleted signal will be emitted as notification after the mark is deleted. a #GtkTextBuffer a #GtkTextMark in @buffer Deletes the mark named @name; the mark must exist. See gtk_text_buffer_delete_mark() for details. a #GtkTextBuffer name of a mark in @buffer Deletes the range between the “insert” and “selection_bound” marks, that is, the currently-selected text. If @interactive is %TRUE, the editability of the selection will be considered (users can’t delete uneditable text). whether there was a non-empty selection to delete a #GtkTextBuffer whether the deletion is caused by user interaction whether the buffer is editable by default This function deserializes rich text in format @format and inserts it at @iter. @formats to be used must be registered using gtk_text_buffer_register_deserialize_format() or gtk_text_buffer_register_deserialize_tagset() beforehand. %TRUE on success, %FALSE otherwise. the #GtkTextBuffer @format is registered with the #GtkTextBuffer to deserialize into the rich text format to use for deserializing insertion point for the deserialized text data to deserialize length of @data This functions returns the value set with gtk_text_buffer_deserialize_set_can_create_tags() whether deserializing this format may create tags a #GtkTextBuffer a #GdkAtom representing a registered rich text format Use this function to allow a rich text deserialization function to create new tags in the receiving buffer. Note that using this function is almost always a bad idea, because the rich text functions you register should know how to map the rich text format they handler to your text buffers set of tags. The ability of creating new (arbitrary!) tags in the receiving buffer is meant for special rich text formats like the internal one that is registered using gtk_text_buffer_register_deserialize_tagset(), because that format is essentially a dump of the internal structure of the source buffer, including its tag names. You should allow creation of tags only if you know what you are doing, e.g. if you defined a tagset name for your application suite’s text buffers and you know that it’s fine to receive new tags from these buffers, because you know that your application can handle the newly created tags. a #GtkTextBuffer a #GdkAtom representing a registered rich text format whether deserializing this format may create tags Should be paired with a call to gtk_text_buffer_begin_user_action(). See that function for a full explanation. a #GtkTextBuffer Retrieves the first and last iterators in the buffer, i.e. the entire buffer lies within the range [@start,@end). a #GtkTextBuffer iterator to initialize with first position in the buffer iterator to initialize with the end iterator Gets the number of characters in the buffer; note that characters and bytes are not the same, you can’t e.g. expect the contents of the buffer in string form to be this many bytes long. The character count is cached, so this function is very fast. number of characters in the buffer a #GtkTextBuffer This function returns the list of targets this text buffer can provide for copying and as DND source. The targets in the list are added with @info values from the #GtkTextBufferTargetInfo enum, using gtk_target_list_add_rich_text_targets() and gtk_target_list_add_text_targets(). the #GtkTargetList a #GtkTextBuffer This function returns the rich text deserialize formats registered with @buffer using gtk_text_buffer_register_deserialize_format() or gtk_text_buffer_register_deserialize_tagset() an array of #GdkAtoms representing the registered formats. a #GtkTextBuffer return location for the number of formats Initializes @iter with the “end iterator,” one past the last valid character in the text buffer. If dereferenced with gtk_text_iter_get_char(), the end iterator has a character value of 0. The entire buffer lies in the range from the first position in the buffer (call gtk_text_buffer_get_start_iter() to get character position 0) to the end iterator. a #GtkTextBuffer iterator to initialize Indicates whether the buffer has some text currently selected. %TRUE if the there is text selected a #GtkTextBuffer Returns the mark that represents the cursor (insertion point). Equivalent to calling gtk_text_buffer_get_mark() to get the mark named “insert”, but very slightly more efficient, and involves less typing. insertion point mark a #GtkTextBuffer Obtains the location of @anchor within @buffer. a #GtkTextBuffer an iterator to be initialized a child anchor that appears in @buffer Initializes @iter to the start of the given line. If @line_number is greater than the number of lines in the @buffer, the end iterator is returned. a #GtkTextBuffer iterator to initialize line number counting from 0 Obtains an iterator pointing to @byte_index within the given line. @byte_index must be the start of a UTF-8 character. Note bytes, not characters; UTF-8 may encode one character as multiple bytes. Before the 3.20 version, it was not allowed to pass an invalid location. Since the 3.20 version, if @line_number is greater than the number of lines in the @buffer, the end iterator is returned. And if @byte_index is off the end of the line, the iterator at the end of the line is returned. a #GtkTextBuffer iterator to initialize line number counting from 0 byte index from start of line Obtains an iterator pointing to @char_offset within the given line. Note characters, not bytes; UTF-8 may encode one character as multiple bytes. Before the 3.20 version, it was not allowed to pass an invalid location. Since the 3.20 version, if @line_number is greater than the number of lines in the @buffer, the end iterator is returned. And if @char_offset is off the end of the line, the iterator at the end of the line is returned. a #GtkTextBuffer iterator to initialize line number counting from 0 char offset from start of line Initializes @iter with the current position of @mark. a #GtkTextBuffer iterator to initialize a #GtkTextMark in @buffer Initializes @iter to a position @char_offset chars from the start of the entire buffer. If @char_offset is -1 or greater than the number of characters in the buffer, @iter is initialized to the end iterator, the iterator one past the last valid character in the buffer. a #GtkTextBuffer iterator to initialize char offset from start of buffer, counting from 0, or -1 Obtains the number of lines in the buffer. This value is cached, so the function is very fast. number of lines in the buffer a #GtkTextBuffer Returns the mark named @name in buffer @buffer, or %NULL if no such mark exists in the buffer. a #GtkTextMark, or %NULL a #GtkTextBuffer a mark name Indicates whether the buffer has been modified since the last call to gtk_text_buffer_set_modified() set the modification flag to %FALSE. Used for example to enable a “save” function in a text editor. %TRUE if the buffer has been modified a #GtkTextBuffer This function returns the list of targets this text buffer supports for pasting and as DND destination. The targets in the list are added with @info values from the #GtkTextBufferTargetInfo enum, using gtk_target_list_add_rich_text_targets() and gtk_target_list_add_text_targets(). the #GtkTargetList a #GtkTextBuffer Returns the mark that represents the selection bound. Equivalent to calling gtk_text_buffer_get_mark() to get the mark named “selection_bound”, but very slightly more efficient, and involves less typing. The currently-selected text in @buffer is the region between the “selection_bound” and “insert” marks. If “selection_bound” and “insert” are in the same place, then there is no current selection. gtk_text_buffer_get_selection_bounds() is another convenient function for handling the selection, if you just want to know whether there’s a selection and what its bounds are. selection bound mark a #GtkTextBuffer Returns %TRUE if some text is selected; places the bounds of the selection in @start and @end (if the selection has length 0, then @start and @end are filled in with the same value). @start and @end will be in ascending order. If @start and @end are NULL, then they are not filled in, but the return value still indicates whether text is selected. whether the selection has nonzero length a #GtkTextBuffer a #GtkTextBuffer iterator to initialize with selection start iterator to initialize with selection end This function returns the rich text serialize formats registered with @buffer using gtk_text_buffer_register_serialize_format() or gtk_text_buffer_register_serialize_tagset() an array of #GdkAtoms representing the registered formats. a #GtkTextBuffer return location for the number of formats Returns the text in the range [@start,@end). Excludes undisplayed text (text marked with tags that set the invisibility attribute) if @include_hidden_chars is %FALSE. The returned string includes a 0xFFFC character whenever the buffer contains embedded images, so byte and character indexes into the returned string do correspond to byte and character indexes into the buffer. Contrast with gtk_text_buffer_get_text(). Note that 0xFFFC can occur in normal text as well, so it is not a reliable indicator that a pixbuf or widget is in the buffer. an allocated UTF-8 string a #GtkTextBuffer start of a range end of a range whether to include invisible text Initialized @iter with the first position in the text buffer. This is the same as using gtk_text_buffer_get_iter_at_offset() to get the iter at character offset 0. a #GtkTextBuffer iterator to initialize Get the #GtkTextTagTable associated with this buffer. the buffer’s tag table a #GtkTextBuffer Returns the text in the range [@start,@end). Excludes undisplayed text (text marked with tags that set the invisibility attribute) if @include_hidden_chars is %FALSE. Does not include characters representing embedded images, so byte and character indexes into the returned string do not correspond to byte and character indexes into the buffer. Contrast with gtk_text_buffer_get_slice(). an allocated UTF-8 string a #GtkTextBuffer start of a range end of a range whether to include invisible text Inserts @len bytes of @text at position @iter. If @len is -1, @text must be nul-terminated and will be inserted in its entirety. Emits the “insert-text” signal; insertion actually occurs in the default handler for the signal. @iter is invalidated when insertion occurs (because the buffer contents change), but the default signal handler revalidates it to point to the end of the inserted text. a #GtkTextBuffer a position in the buffer text in UTF-8 format length of text in bytes, or -1 Simply calls gtk_text_buffer_insert(), using the current cursor position as the insertion point. a #GtkTextBuffer text in UTF-8 format length of text, in bytes Inserts a child widget anchor into the text buffer at @iter. The anchor will be counted as one character in character counts, and when obtaining the buffer contents as a string, will be represented by the Unicode “object replacement character” 0xFFFC. Note that the “slice” variants for obtaining portions of the buffer as a string include this character for child anchors, but the “text” variants do not. E.g. see gtk_text_buffer_get_slice() and gtk_text_buffer_get_text(). Consider gtk_text_buffer_create_child_anchor() as a more convenient alternative to this function. The buffer will add a reference to the anchor, so you can unref it after insertion. a #GtkTextBuffer location to insert the anchor a #GtkTextChildAnchor Like gtk_text_buffer_insert(), but the insertion will not occur if @iter is at a non-editable location in the buffer. Usually you want to prevent insertions at ineditable locations if the insertion results from a user action (is interactive). @default_editable indicates the editability of text that doesn't have a tag affecting editability applied to it. Typically the result of gtk_text_view_get_editable() is appropriate here. whether text was actually inserted a #GtkTextBuffer a position in @buffer some UTF-8 text length of text in bytes, or -1 default editability of buffer Calls gtk_text_buffer_insert_interactive() at the cursor position. @default_editable indicates the editability of text that doesn't have a tag affecting editability applied to it. Typically the result of gtk_text_view_get_editable() is appropriate here. whether text was actually inserted a #GtkTextBuffer text in UTF-8 format length of text in bytes, or -1 default editability of buffer Inserts the text in @markup at position @iter. @markup will be inserted in its entirety and must be nul-terminated and valid UTF-8. Emits the #GtkTextBuffer::insert-text signal, possibly multiple times; insertion actually occurs in the default handler for the signal. @iter will point to the end of the inserted text on return. a #GtkTextBuffer location to insert the markup a nul-terminated UTF-8 string containing [Pango markup][PangoMarkupFormat] length of @markup in bytes, or -1 Inserts an image into the text buffer at @iter. The image will be counted as one character in character counts, and when obtaining the buffer contents as a string, will be represented by the Unicode “object replacement character” 0xFFFC. Note that the “slice” variants for obtaining portions of the buffer as a string include this character for pixbufs, but the “text” variants do not. e.g. see gtk_text_buffer_get_slice() and gtk_text_buffer_get_text(). a #GtkTextBuffer location to insert the pixbuf a #GdkPixbuf Copies text, tags, and pixbufs between @start and @end (the order of @start and @end doesn’t matter) and inserts the copy at @iter. Used instead of simply getting/inserting text because it preserves images and tags. If @start and @end are in a different buffer from @buffer, the two buffers must share the same tag table. Implemented via emissions of the insert_text and apply_tag signals, so expect those. a #GtkTextBuffer a position in @buffer a position in a #GtkTextBuffer another position in the same buffer as @start Same as gtk_text_buffer_insert_range(), but does nothing if the insertion point isn’t editable. The @default_editable parameter indicates whether the text is editable at @iter if no tags enclosing @iter affect editability. Typically the result of gtk_text_view_get_editable() is appropriate here. whether an insertion was possible at @iter a #GtkTextBuffer a position in @buffer a position in a #GtkTextBuffer another position in the same buffer as @start default editability of the buffer Inserts @text into @buffer at @iter, applying the list of tags to the newly-inserted text. The last tag specified must be %NULL to terminate the list. Equivalent to calling gtk_text_buffer_insert(), then gtk_text_buffer_apply_tag() on the inserted text; gtk_text_buffer_insert_with_tags() is just a convenience function. a #GtkTextBuffer an iterator in @buffer UTF-8 text length of @text, or -1 first tag to apply to @text %NULL-terminated list of tags to apply Same as gtk_text_buffer_insert_with_tags(), but allows you to pass in tag names instead of tag objects. a #GtkTextBuffer position in @buffer UTF-8 text length of @text, or -1 name of a tag to apply to @text more tag names Moves @mark to the new location @where. Emits the #GtkTextBuffer::mark-set signal as notification of the move. a #GtkTextBuffer a #GtkTextMark new location for @mark in @buffer Moves the mark named @name (which must exist) to location @where. See gtk_text_buffer_move_mark() for details. a #GtkTextBuffer name of a mark new location for mark Pastes the contents of a clipboard. If @override_location is %NULL, the pasted text will be inserted at the cursor position, or the buffer selection will be replaced if the selection is non-empty. Note: pasting is asynchronous, that is, we’ll ask for the paste data and return, and at some point later after the main loop runs, the paste data will be inserted. a #GtkTextBuffer the #GtkClipboard to paste from location to insert pasted text, or %NULL whether the buffer is editable by default This function moves the “insert” and “selection_bound” marks simultaneously. If you move them to the same place in two steps with gtk_text_buffer_move_mark(), you will temporarily select a region in between their old and new locations, which can be pretty inefficient since the temporarily-selected region will force stuff to be recalculated. This function moves them as a unit, which can be optimized. a #GtkTextBuffer where to put the cursor This function registers a rich text deserialization @function along with its @mime_type with the passed @buffer. the #GdkAtom that corresponds to the newly registered format’s mime-type. a #GtkTextBuffer the format’s mime-type the deserialize function to register @function’s user_data a function to call when @user_data is no longer needed This function registers GTK+’s internal rich text serialization format with the passed @buffer. See gtk_text_buffer_register_serialize_tagset() for details. the #GdkAtom that corresponds to the newly registered format’s mime-type. a #GtkTextBuffer an optional tagset name, on %NULL This function registers a rich text serialization @function along with its @mime_type with the passed @buffer. the #GdkAtom that corresponds to the newly registered format’s mime-type. a #GtkTextBuffer the format’s mime-type the serialize function to register @function’s user_data a function to call when @user_data is no longer needed This function registers GTK+’s internal rich text serialization format with the passed @buffer. The internal format does not comply to any standard rich text format and only works between #GtkTextBuffer instances. It is capable of serializing all of a text buffer’s tags and embedded pixbufs. This function is just a wrapper around gtk_text_buffer_register_serialize_format(). The mime type used for registering is “application/x-gtk-text-buffer-rich-text”, or “application/x-gtk-text-buffer-rich-text;format=@tagset_name” if a @tagset_name was passed. The @tagset_name can be used to restrict the transfer of rich text to buffers with compatible sets of tags, in order to avoid unknown tags from being pasted. It is probably the common case to pass an identifier != %NULL here, since the %NULL tagset requires the receiving buffer to deal with with pasting of arbitrary tags. the #GdkAtom that corresponds to the newly registered format’s mime-type. a #GtkTextBuffer an optional tagset name, on %NULL Removes all tags in the range between @start and @end. Be careful with this function; it could remove tags added in code unrelated to the code you’re currently writing. That is, using this function is probably a bad idea if you have two or more unrelated code sections that add tags. a #GtkTextBuffer one bound of range to be untagged other bound of range to be untagged Removes a #GtkClipboard added with gtk_text_buffer_add_selection_clipboard(). a #GtkTextBuffer a #GtkClipboard added to @buffer by gtk_text_buffer_add_selection_clipboard() Emits the “remove-tag” signal. The default handler for the signal removes all occurrences of @tag from the given range. @start and @end don’t have to be in order. a #GtkTextBuffer a #GtkTextTag one bound of range to be untagged other bound of range to be untagged Calls gtk_text_tag_table_lookup() on the buffer’s tag table to get a #GtkTextTag, then calls gtk_text_buffer_remove_tag(). a #GtkTextBuffer name of a #GtkTextTag one bound of range to be untagged other bound of range to be untagged This function moves the “insert” and “selection_bound” marks simultaneously. If you move them in two steps with gtk_text_buffer_move_mark(), you will temporarily select a region in between their old and new locations, which can be pretty inefficient since the temporarily-selected region will force stuff to be recalculated. This function moves them as a unit, which can be optimized. a #GtkTextBuffer where to put the “insert” mark where to put the “selection_bound” mark This function serializes the portion of text between @start and @end in the rich text format represented by @format. @formats to be used must be registered using gtk_text_buffer_register_serialize_format() or gtk_text_buffer_register_serialize_tagset() beforehand. the serialized data, encoded as @format the #GtkTextBuffer @format is registered with the #GtkTextBuffer to serialize the rich text format to use for serializing start of block of text to serialize end of block of test to serialize return location for the length of the serialized data Used to keep track of whether the buffer has been modified since the last time it was saved. Whenever the buffer is saved to disk, call gtk_text_buffer_set_modified (@buffer, FALSE). When the buffer is modified, it will automatically toggled on the modified bit again. When the modified bit flips, the buffer emits the #GtkTextBuffer::modified-changed signal. a #GtkTextBuffer modification flag setting Deletes current contents of @buffer, and inserts @text instead. If @len is -1, @text must be nul-terminated. @text must be valid UTF-8. a #GtkTextBuffer UTF-8 text to insert length of @text in bytes This function unregisters a rich text format that was previously registered using gtk_text_buffer_register_deserialize_format() or gtk_text_buffer_register_deserialize_tagset(). a #GtkTextBuffer a #GdkAtom representing a registered rich text format. This function unregisters a rich text format that was previously registered using gtk_text_buffer_register_serialize_format() or gtk_text_buffer_register_serialize_tagset() a #GtkTextBuffer a #GdkAtom representing a registered rich text format. The list of targets this buffer supports for clipboard copying and as DND source. The position of the insert mark (as offset from the beginning of the buffer). It is useful for getting notified when the cursor moves. Whether the buffer has some text currently selected. The list of targets this buffer supports for clipboard pasting and as DND destination. The text content of the buffer. Without child widgets and images, see gtk_text_buffer_get_text() for more information. The ::apply-tag signal is emitted to apply a tag to a range of text in a #GtkTextBuffer. Applying actually occurs in the default handler. Note that if your handler runs before the default handler it must not invalidate the @start and @end iters (or has to revalidate them). See also: gtk_text_buffer_apply_tag(), gtk_text_buffer_insert_with_tags(), gtk_text_buffer_insert_range(). the applied tag the start of the range the tag is applied to the end of the range the tag is applied to The ::begin-user-action signal is emitted at the beginning of a single user-visible operation on a #GtkTextBuffer. See also: gtk_text_buffer_begin_user_action(), gtk_text_buffer_insert_interactive(), gtk_text_buffer_insert_range_interactive(), gtk_text_buffer_delete_interactive(), gtk_text_buffer_backspace(), gtk_text_buffer_delete_selection(). The ::changed signal is emitted when the content of a #GtkTextBuffer has changed. The ::delete-range signal is emitted to delete a range from a #GtkTextBuffer. Note that if your handler runs before the default handler it must not invalidate the @start and @end iters (or has to revalidate them). The default signal handler revalidates the @start and @end iters to both point to the location where text was deleted. Handlers which run after the default handler (see g_signal_connect_after()) do not have access to the deleted text. See also: gtk_text_buffer_delete(). the start of the range to be deleted the end of the range to be deleted The ::end-user-action signal is emitted at the end of a single user-visible operation on the #GtkTextBuffer. See also: gtk_text_buffer_end_user_action(), gtk_text_buffer_insert_interactive(), gtk_text_buffer_insert_range_interactive(), gtk_text_buffer_delete_interactive(), gtk_text_buffer_backspace(), gtk_text_buffer_delete_selection(), gtk_text_buffer_backspace(). The ::insert-child-anchor signal is emitted to insert a #GtkTextChildAnchor in a #GtkTextBuffer. Insertion actually occurs in the default handler. Note that if your handler runs before the default handler it must not invalidate the @location iter (or has to revalidate it). The default signal handler revalidates it to be placed after the inserted @anchor. See also: gtk_text_buffer_insert_child_anchor(). position to insert @anchor in @textbuffer the #GtkTextChildAnchor to be inserted The ::insert-pixbuf signal is emitted to insert a #GdkPixbuf in a #GtkTextBuffer. Insertion actually occurs in the default handler. Note that if your handler runs before the default handler it must not invalidate the @location iter (or has to revalidate it). The default signal handler revalidates it to be placed after the inserted @pixbuf. See also: gtk_text_buffer_insert_pixbuf(). position to insert @pixbuf in @textbuffer the #GdkPixbuf to be inserted The ::insert-text signal is emitted to insert text in a #GtkTextBuffer. Insertion actually occurs in the default handler. Note that if your handler runs before the default handler it must not invalidate the @location iter (or has to revalidate it). The default signal handler revalidates it to point to the end of the inserted text. See also: gtk_text_buffer_insert(), gtk_text_buffer_insert_range(). position to insert @text in @textbuffer the UTF-8 text to be inserted length of the inserted text in bytes The ::mark-deleted signal is emitted as notification after a #GtkTextMark is deleted. See also: gtk_text_buffer_delete_mark(). The mark that was deleted The ::mark-set signal is emitted as notification after a #GtkTextMark is set. See also: gtk_text_buffer_create_mark(), gtk_text_buffer_move_mark(). The location of @mark in @textbuffer The mark that is set The ::modified-changed signal is emitted when the modified bit of a #GtkTextBuffer flips. See also: gtk_text_buffer_set_modified(). The paste-done signal is emitted after paste operation has been completed. This is useful to properly scroll the view to the end of the pasted text. See gtk_text_buffer_paste_clipboard() for more details. the #GtkClipboard pasted from The ::remove-tag signal is emitted to remove all occurrences of @tag from a range of text in a #GtkTextBuffer. Removal actually occurs in the default handler. Note that if your handler runs before the default handler it must not invalidate the @start and @end iters (or has to revalidate them). See also: gtk_text_buffer_remove_tag(). the tag to be removed the start of the range the tag is removed from the end of the range the tag is removed from The object class structure needs to be the first. a #GtkTextBuffer location to insert the pixbuf a #GdkPixbuf a #GtkTextBuffer location to insert the anchor a #GtkTextChildAnchor a #GtkTextBuffer a #GtkTextTag one bound of range to be tagged other bound of range to be tagged a #GtkTextBuffer a #GtkTextTag one bound of range to be untagged other bound of range to be untagged a #GtkTextBuffer a #GtkTextBuffer A function that is called to deserialize rich text that has been serialized with gtk_text_buffer_serialize(), and insert it at @iter. %TRUE on success, %FALSE otherwise the #GtkTextBuffer the format is registered with the #GtkTextBuffer to deserialize into insertion point for the deserialized text data to deserialize length of @data %TRUE if deserializing may create tags user data that was specified when registering the format A function that is called to serialize the content of a text buffer. It must return the serialized form of the content. a newly-allocated array of guint8 which contains the serialized data, or %NULL if an error occurred the #GtkTextBuffer for which the format is registered the #GtkTextBuffer to serialize start of the block of text to serialize end of the block of text to serialize Return location for the length of the serialized data user data that was specified when registering the format These values are used as “info” for the targets contained in the lists returned by gtk_text_buffer_get_copy_target_list() and gtk_text_buffer_get_paste_target_list(). The values counts down from `-1` to avoid clashes with application added drag destinations which usually start at 0. Buffer contents Rich text Text A #GtkTextChildAnchor is a spot in the buffer where child widgets can be “anchored” (inserted inline, as if they were characters). The anchor can have multiple widgets anchored, to allow for multiple views. Creates a new #GtkTextChildAnchor. Usually you would then insert it into a #GtkTextBuffer with gtk_text_buffer_insert_child_anchor(). To perform the creation and insertion in one step, use the convenience function gtk_text_buffer_create_child_anchor(). a new #GtkTextChildAnchor Determines whether a child anchor has been deleted from the buffer. Keep in mind that the child anchor will be unreferenced when removed from the buffer, so you need to hold your own reference (with g_object_ref()) if you plan to use this function — otherwise all deleted child anchors will also be finalized. %TRUE if the child anchor has been deleted from its buffer a #GtkTextChildAnchor Gets a list of all widgets anchored at this child anchor. The returned list should be freed with g_list_free(). list of widgets anchored at @anchor a #GtkTextChildAnchor Reading directions for text. No direction. Left to right text direction. Right to left text direction. Granularity types that extend the text selection. Use the #GtkTextView::extend-selection signal to customize the selection. Selects the current word. It is triggered by a double-click for example. Selects the current line. It is triggered by a triple-click for example. You may wish to begin by reading the [text widget conceptual overview][TextWidget] which gives an overview of all the objects and data types related to the text widget and how they work together. Assigns the value of @other to @iter. This function is not useful in applications, because iterators can be assigned with `GtkTextIter i = j;`. The function is used by language bindings. a #GtkTextIter another #GtkTextIter Moves backward by one character offset. Returns %TRUE if movement was possible; if @iter was the first in the buffer (character offset 0), gtk_text_iter_backward_char() returns %FALSE for convenience when writing loops. whether movement was possible an iterator Moves @count characters backward, if possible (if @count would move past the start or end of the buffer, moves to the start or end of the buffer). The return value indicates whether the iterator moved onto a dereferenceable position; if the iterator didn’t move, or moved onto the end iterator, then %FALSE is returned. If @count is 0, the function does nothing and returns %FALSE. whether @iter moved and is dereferenceable an iterator number of characters to move Like gtk_text_iter_forward_cursor_position(), but moves backward. %TRUE if we moved a #GtkTextIter Moves up to @count cursor positions. See gtk_text_iter_forward_cursor_position() for details. %TRUE if we moved and the new position is dereferenceable a #GtkTextIter number of positions to move Same as gtk_text_iter_forward_find_char(), but goes backward from @iter. whether a match was found a #GtkTextIter function to be called on each character user data for @pred search limit, or %NULL for none Moves @iter to the start of the previous line. Returns %TRUE if @iter could be moved; i.e. if @iter was at character offset 0, this function returns %FALSE. Therefore if @iter was already on line 0, but not at the start of the line, @iter is snapped to the start of the line and the function returns %TRUE. (Note that this implies that in a loop calling this function, the line number may not change on every iteration, if your first iteration is on line 0.) whether @iter moved an iterator Moves @count lines backward, if possible (if @count would move past the start or end of the buffer, moves to the start or end of the buffer). The return value indicates whether the iterator moved onto a dereferenceable position; if the iterator didn’t move, or moved onto the end iterator, then %FALSE is returned. If @count is 0, the function does nothing and returns %FALSE. If @count is negative, moves forward by 0 - @count lines. whether @iter moved and is dereferenceable a #GtkTextIter number of lines to move backward Same as gtk_text_iter_forward_search(), but moves backward. @match_end will never be set to a #GtkTextIter located after @iter, even if there is a possible @match_start before or at @iter. whether a match was found a #GtkTextIter where the search begins search string bitmask of flags affecting the search return location for start of match, or %NULL return location for end of match, or %NULL location of last possible @match_start, or %NULL for start of buffer Moves backward to the previous sentence start; if @iter is already at the start of a sentence, moves backward to the next one. Sentence boundaries are determined by Pango and should be correct for nearly any language (if not, the correct fix would be to the Pango text boundary algorithms). %TRUE if @iter moved and is not the end iterator a #GtkTextIter Calls gtk_text_iter_backward_sentence_start() up to @count times, or until it returns %FALSE. If @count is negative, moves forward instead of backward. %TRUE if @iter moved and is not the end iterator a #GtkTextIter number of sentences to move Moves backward to the next toggle (on or off) of the #GtkTextTag @tag, or to the next toggle of any tag if @tag is %NULL. If no matching tag toggles are found, returns %FALSE, otherwise %TRUE. Does not return toggles located at @iter, only toggles before @iter. Sets @iter to the location of the toggle, or the start of the buffer if no toggle is found. whether we found a tag toggle before @iter a #GtkTextIter a #GtkTextTag, or %NULL Moves @iter forward to the previous visible cursor position. See gtk_text_iter_backward_cursor_position() for details. %TRUE if we moved and the new position is dereferenceable a #GtkTextIter Moves up to @count visible cursor positions. See gtk_text_iter_backward_cursor_position() for details. %TRUE if we moved and the new position is dereferenceable a #GtkTextIter number of positions to move Moves @iter to the start of the previous visible line. Returns %TRUE if @iter could be moved; i.e. if @iter was at character offset 0, this function returns %FALSE. Therefore if @iter was already on line 0, but not at the start of the line, @iter is snapped to the start of the line and the function returns %TRUE. (Note that this implies that in a loop calling this function, the line number may not change on every iteration, if your first iteration is on line 0.) whether @iter moved an iterator Moves @count visible lines backward, if possible (if @count would move past the start or end of the buffer, moves to the start or end of the buffer). The return value indicates whether the iterator moved onto a dereferenceable position; if the iterator didn’t move, or moved onto the end iterator, then %FALSE is returned. If @count is 0, the function does nothing and returns %FALSE. If @count is negative, moves forward by 0 - @count lines. whether @iter moved and is dereferenceable a #GtkTextIter number of lines to move backward Moves backward to the previous visible word start. (If @iter is currently on a word start, moves backward to the next one after that.) Word breaks are determined by Pango and should be correct for nearly any language (if not, the correct fix would be to the Pango word break algorithms). %TRUE if @iter moved and is not the end iterator a #GtkTextIter Calls gtk_text_iter_backward_visible_word_start() up to @count times. %TRUE if @iter moved and is not the end iterator a #GtkTextIter number of times to move Moves backward to the previous word start. (If @iter is currently on a word start, moves backward to the next one after that.) Word breaks are determined by Pango and should be correct for nearly any language (if not, the correct fix would be to the Pango word break algorithms). %TRUE if @iter moved and is not the end iterator a #GtkTextIter Calls gtk_text_iter_backward_word_start() up to @count times. %TRUE if @iter moved and is not the end iterator a #GtkTextIter number of times to move Returns %TRUE if @tag is toggled on at exactly this point. If @tag is %NULL, returns %TRUE if any tag is toggled on at this point. Note that if gtk_text_iter_begins_tag() returns %TRUE, it means that @iter is at the beginning of the tagged range, and that the character at @iter is inside the tagged range. In other words, unlike gtk_text_iter_ends_tag(), if gtk_text_iter_begins_tag() returns %TRUE, gtk_text_iter_has_tag() will also return %TRUE for the same parameters. Use gtk_text_iter_starts_tag() instead. whether @iter is the start of a range tagged with @tag an iterator a #GtkTextTag, or %NULL Considering the default editability of the buffer, and tags that affect editability, determines whether text inserted at @iter would be editable. If text inserted at @iter would be editable then the user should be allowed to insert text at @iter. gtk_text_buffer_insert_interactive() uses this function to decide whether insertions are allowed at a given position. whether text inserted at @iter would be editable an iterator %TRUE if text is editable by default A qsort()-style function that returns negative if @lhs is less than @rhs, positive if @lhs is greater than @rhs, and 0 if they’re equal. Ordering is in character offset order, i.e. the first character in the buffer is less than the second character in the buffer. -1 if @lhs is less than @rhs, 1 if @lhs is greater, 0 if they are equal a #GtkTextIter another #GtkTextIter Creates a dynamically-allocated copy of an iterator. This function is not useful in applications, because iterators can be copied with a simple assignment (`GtkTextIter i = j;`). The function is used by language bindings. a copy of the @iter, free with gtk_text_iter_free() an iterator Returns whether the character at @iter is within an editable region of text. Non-editable text is “locked” and can’t be changed by the user via #GtkTextView. This function is simply a convenience wrapper around gtk_text_iter_get_attributes(). If no tags applied to this text affect editability, @default_setting will be returned. You don’t want to use this function to decide whether text can be inserted at @iter, because for insertion you don’t want to know whether the char at @iter is inside an editable range, you want to know whether a new character inserted at @iter would be inside an editable range. Use gtk_text_iter_can_insert() to handle this case. whether @iter is inside an editable range an iterator %TRUE if text is editable by default Returns %TRUE if @iter points to the start of the paragraph delimiter characters for a line (delimiters will be either a newline, a carriage return, a carriage return followed by a newline, or a Unicode paragraph separator character). Note that an iterator pointing to the \n of a \r\n pair will not be counted as the end of a line, the line ends before the \r. The end iterator is considered to be at the end of a line, even though there are no paragraph delimiter chars there. whether @iter is at the end of a line an iterator Determines whether @iter ends a sentence. Sentence boundaries are determined by Pango and should be correct for nearly any language (if not, the correct fix would be to the Pango text boundary algorithms). %TRUE if @iter is at the end of a sentence. a #GtkTextIter Returns %TRUE if @tag is toggled off at exactly this point. If @tag is %NULL, returns %TRUE if any tag is toggled off at this point. Note that if gtk_text_iter_ends_tag() returns %TRUE, it means that @iter is at the end of the tagged range, but that the character at @iter is outside the tagged range. In other words, unlike gtk_text_iter_starts_tag(), if gtk_text_iter_ends_tag() returns %TRUE, gtk_text_iter_has_tag() will return %FALSE for the same parameters. whether @iter is the end of a range tagged with @tag an iterator a #GtkTextTag, or %NULL Determines whether @iter ends a natural-language word. Word breaks are determined by Pango and should be correct for nearly any language (if not, the correct fix would be to the Pango word break algorithms). %TRUE if @iter is at the end of a word a #GtkTextIter Tests whether two iterators are equal, using the fastest possible mechanism. This function is very fast; you can expect it to perform better than e.g. getting the character offset for each iterator and comparing the offsets yourself. Also, it’s a bit faster than gtk_text_iter_compare(). %TRUE if the iterators point to the same place in the buffer a #GtkTextIter another #GtkTextIter Moves @iter forward by one character offset. Note that images embedded in the buffer occupy 1 character slot, so gtk_text_iter_forward_char() may actually move onto an image instead of a character, if you have images in your buffer. If @iter is the end iterator or one character before it, @iter will now point at the end iterator, and gtk_text_iter_forward_char() returns %FALSE for convenience when writing loops. whether @iter moved and is dereferenceable an iterator Moves @count characters if possible (if @count would move past the start or end of the buffer, moves to the start or end of the buffer). The return value indicates whether the new position of @iter is different from its original position, and dereferenceable (the last iterator in the buffer is not dereferenceable). If @count is 0, the function does nothing and returns %FALSE. whether @iter moved and is dereferenceable an iterator number of characters to move, may be negative Moves @iter forward by a single cursor position. Cursor positions are (unsurprisingly) positions where the cursor can appear. Perhaps surprisingly, there may not be a cursor position between all characters. The most common example for European languages would be a carriage return/newline sequence. For some Unicode characters, the equivalent of say the letter “a” with an accent mark will be represented as two characters, first the letter then a "combining mark" that causes the accent to be rendered; so the cursor can’t go between those two characters. See also the #PangoLogAttr-struct and pango_break() function. %TRUE if we moved and the new position is dereferenceable a #GtkTextIter Moves up to @count cursor positions. See gtk_text_iter_forward_cursor_position() for details. %TRUE if we moved and the new position is dereferenceable a #GtkTextIter number of positions to move Advances @iter, calling @pred on each character. If @pred returns %TRUE, returns %TRUE and stops scanning. If @pred never returns %TRUE, @iter is set to @limit if @limit is non-%NULL, otherwise to the end iterator. whether a match was found a #GtkTextIter a function to be called on each character user data for @pred search limit, or %NULL for none Moves @iter to the start of the next line. If the iter is already on the last line of the buffer, moves the iter to the end of the current line. If after the operation, the iter is at the end of the buffer and not dereferencable, returns %FALSE. Otherwise, returns %TRUE. whether @iter can be dereferenced an iterator Moves @count lines forward, if possible (if @count would move past the start or end of the buffer, moves to the start or end of the buffer). The return value indicates whether the iterator moved onto a dereferenceable position; if the iterator didn’t move, or moved onto the end iterator, then %FALSE is returned. If @count is 0, the function does nothing and returns %FALSE. If @count is negative, moves backward by 0 - @count lines. whether @iter moved and is dereferenceable a #GtkTextIter number of lines to move forward Searches forward for @str. Any match is returned by setting @match_start to the first character of the match and @match_end to the first character after the match. The search will not continue past @limit. Note that a search is a linear or O(n) operation, so you may wish to use @limit to avoid locking up your UI on large buffers. @match_start will never be set to a #GtkTextIter located before @iter, even if there is a possible @match_end after or at @iter. whether a match was found start of search a search string flags affecting how the search is done return location for start of match, or %NULL return location for end of match, or %NULL location of last possible @match_end, or %NULL for the end of the buffer Moves forward to the next sentence end. (If @iter is at the end of a sentence, moves to the next end of sentence.) Sentence boundaries are determined by Pango and should be correct for nearly any language (if not, the correct fix would be to the Pango text boundary algorithms). %TRUE if @iter moved and is not the end iterator a #GtkTextIter Calls gtk_text_iter_forward_sentence_end() @count times (or until gtk_text_iter_forward_sentence_end() returns %FALSE). If @count is negative, moves backward instead of forward. %TRUE if @iter moved and is not the end iterator a #GtkTextIter number of sentences to move Moves @iter forward to the “end iterator,” which points one past the last valid character in the buffer. gtk_text_iter_get_char() called on the end iterator returns 0, which is convenient for writing loops. a #GtkTextIter Moves the iterator to point to the paragraph delimiter characters, which will be either a newline, a carriage return, a carriage return/newline in sequence, or the Unicode paragraph separator character. If the iterator is already at the paragraph delimiter characters, moves to the paragraph delimiter characters for the next line. If @iter is on the last line in the buffer, which does not end in paragraph delimiters, moves to the end iterator (end of the last line), and returns %FALSE. %TRUE if we moved and the new location is not the end iterator a #GtkTextIter Moves forward to the next toggle (on or off) of the #GtkTextTag @tag, or to the next toggle of any tag if @tag is %NULL. If no matching tag toggles are found, returns %FALSE, otherwise %TRUE. Does not return toggles located at @iter, only toggles after @iter. Sets @iter to the location of the toggle, or to the end of the buffer if no toggle is found. whether we found a tag toggle after @iter a #GtkTextIter a #GtkTextTag, or %NULL Moves @iter forward to the next visible cursor position. See gtk_text_iter_forward_cursor_position() for details. %TRUE if we moved and the new position is dereferenceable a #GtkTextIter Moves up to @count visible cursor positions. See gtk_text_iter_forward_cursor_position() for details. %TRUE if we moved and the new position is dereferenceable a #GtkTextIter number of positions to move Moves @iter to the start of the next visible line. Returns %TRUE if there was a next line to move to, and %FALSE if @iter was simply moved to the end of the buffer and is now not dereferenceable, or if @iter was already at the end of the buffer. whether @iter can be dereferenced an iterator Moves @count visible lines forward, if possible (if @count would move past the start or end of the buffer, moves to the start or end of the buffer). The return value indicates whether the iterator moved onto a dereferenceable position; if the iterator didn’t move, or moved onto the end iterator, then %FALSE is returned. If @count is 0, the function does nothing and returns %FALSE. If @count is negative, moves backward by 0 - @count lines. whether @iter moved and is dereferenceable a #GtkTextIter number of lines to move forward Moves forward to the next visible word end. (If @iter is currently on a word end, moves forward to the next one after that.) Word breaks are determined by Pango and should be correct for nearly any language (if not, the correct fix would be to the Pango word break algorithms). %TRUE if @iter moved and is not the end iterator a #GtkTextIter Calls gtk_text_iter_forward_visible_word_end() up to @count times. %TRUE if @iter moved and is not the end iterator a #GtkTextIter number of times to move Moves forward to the next word end. (If @iter is currently on a word end, moves forward to the next one after that.) Word breaks are determined by Pango and should be correct for nearly any language (if not, the correct fix would be to the Pango word break algorithms). %TRUE if @iter moved and is not the end iterator a #GtkTextIter Calls gtk_text_iter_forward_word_end() up to @count times. %TRUE if @iter moved and is not the end iterator a #GtkTextIter number of times to move Free an iterator allocated on the heap. This function is intended for use in language bindings, and is not especially useful for applications, because iterators can simply be allocated on the stack. a dynamically-allocated iterator Computes the effect of any tags applied to this spot in the text. The @values parameter should be initialized to the default settings you wish to use if no tags are in effect. You’d typically obtain the defaults from gtk_text_view_get_default_attributes(). gtk_text_iter_get_attributes() will modify @values, applying the effects of any tags present at @iter. If any tags affected @values, the function returns %TRUE. %TRUE if @values was modified an iterator a #GtkTextAttributes to be filled in Returns the #GtkTextBuffer this iterator is associated with. the buffer an iterator Returns the number of bytes in the line containing @iter, including the paragraph delimiters. number of bytes in the line an iterator The Unicode character at this iterator is returned. (Equivalent to operator* on a C++ iterator.) If the element at this iterator is a non-character element, such as an image embedded in the buffer, the Unicode “unknown” character 0xFFFC is returned. If invoked on the end iterator, zero is returned; zero is not a valid Unicode character. So you can write a loop which ends when gtk_text_iter_get_char() returns 0. a Unicode character, or 0 if @iter is not dereferenceable an iterator Returns the number of characters in the line containing @iter, including the paragraph delimiters. number of characters in the line an iterator If the location at @iter contains a child anchor, the anchor is returned (with no new reference count added). Otherwise, %NULL is returned. the anchor at @iter an iterator A convenience wrapper around gtk_text_iter_get_attributes(), which returns the language in effect at @iter. If no tags affecting language apply to @iter, the return value is identical to that of gtk_get_default_language(). language in effect at @iter an iterator Returns the line number containing the iterator. Lines in a #GtkTextBuffer are numbered beginning with 0 for the first line in the buffer. a line number an iterator Returns the byte index of the iterator, counting from the start of a newline-terminated line. Remember that #GtkTextBuffer encodes text in UTF-8, and that characters can require a variable number of bytes to represent. distance from start of line, in bytes an iterator Returns the character offset of the iterator, counting from the start of a newline-terminated line. The first character on the line has offset 0. offset from start of line an iterator Returns a list of all #GtkTextMark at this location. Because marks are not iterable (they don’t take up any "space" in the buffer, they are just marks in between iterable locations), multiple marks can exist in the same place. The returned list is not in any meaningful order. list of #GtkTextMark an iterator Returns the character offset of an iterator. Each character in a #GtkTextBuffer has an offset, starting with 0 for the first character in the buffer. Use gtk_text_buffer_get_iter_at_offset() to convert an offset back into an iterator. a character offset an iterator If the element at @iter is a pixbuf, the pixbuf is returned (with no new reference count added). Otherwise, %NULL is returned. the pixbuf at @iter an iterator Returns the text in the given range. A “slice” is an array of characters encoded in UTF-8 format, including the Unicode “unknown” character 0xFFFC for iterable non-character elements in the buffer, such as images. Because images are encoded in the slice, byte and character offsets in the returned array will correspond to byte offsets in the text buffer. Note that 0xFFFC can occur in normal text as well, so it is not a reliable indicator that a pixbuf or widget is in the buffer. slice of text from the buffer iterator at start of a range iterator at end of a range Returns a list of tags that apply to @iter, in ascending order of priority (highest-priority tags are last). The #GtkTextTag in the list don’t have a reference added, but you have to free the list itself. list of #GtkTextTag a #GtkTextIter Returns text in the given range. If the range contains non-text elements such as images, the character and byte offsets in the returned string will not correspond to character and byte offsets in the buffer. If you want offsets to correspond, see gtk_text_iter_get_slice(). array of characters from the buffer iterator at start of a range iterator at end of a range Returns a list of #GtkTextTag that are toggled on or off at this point. (If @toggled_on is %TRUE, the list contains tags that are toggled on.) If a tag is toggled on at @iter, then some non-empty range of characters following @iter has that tag applied to it. If a tag is toggled off, then some non-empty range following @iter does not have the tag applied to it. tags toggled at this point an iterator %TRUE to get toggled-on tags Returns the number of bytes from the start of the line to the given @iter, not counting bytes that are invisible due to tags with the “invisible” flag toggled on. byte index of @iter with respect to the start of the line a #GtkTextIter Returns the offset in characters from the start of the line to the given @iter, not counting characters that are invisible due to tags with the “invisible” flag toggled on. offset in visible characters from the start of the line a #GtkTextIter Like gtk_text_iter_get_slice(), but invisible text is not included. Invisible text is usually invisible because a #GtkTextTag with the “invisible” attribute turned on has been applied to it. slice of text from the buffer iterator at start of range iterator at end of range Like gtk_text_iter_get_text(), but invisible text is not included. Invisible text is usually invisible because a #GtkTextTag with the “invisible” attribute turned on has been applied to it. string containing visible text in the range iterator at start of range iterator at end of range Returns %TRUE if @iter points to a character that is part of a range tagged with @tag. See also gtk_text_iter_starts_tag() and gtk_text_iter_ends_tag(). whether @iter is tagged with @tag an iterator a #GtkTextTag Checks whether @iter falls in the range [@start, @end). @start and @end must be in ascending order. %TRUE if @iter is in the range a #GtkTextIter start of range end of range Determines whether @iter is inside a sentence (as opposed to in between two sentences, e.g. after a period and before the first letter of the next sentence). Sentence boundaries are determined by Pango and should be correct for nearly any language (if not, the correct fix would be to the Pango text boundary algorithms). %TRUE if @iter is inside a sentence. a #GtkTextIter Determines whether the character pointed by @iter is part of a natural-language word (as opposed to say inside some whitespace). Word breaks are determined by Pango and should be correct for nearly any language (if not, the correct fix would be to the Pango word break algorithms). Note that if gtk_text_iter_starts_word() returns %TRUE, then this function returns %TRUE too, since @iter points to the first character of the word. %TRUE if @iter is inside a word a #GtkTextIter See gtk_text_iter_forward_cursor_position() or #PangoLogAttr or pango_break() for details on what a cursor position is. %TRUE if the cursor can be placed at @iter a #GtkTextIter Returns %TRUE if @iter is the end iterator, i.e. one past the last dereferenceable iterator in the buffer. gtk_text_iter_is_end() is the most efficient way to check whether an iterator is the end iterator. whether @iter is the end iterator an iterator Returns %TRUE if @iter is the first iterator in the buffer, that is if @iter has a character offset of 0. whether @iter is the first in the buffer an iterator Swaps the value of @first and @second if @second comes before @first in the buffer. That is, ensures that @first and @second are in sequence. Most text buffer functions that take a range call this automatically on your behalf, so there’s no real reason to call it yourself in those cases. There are some exceptions, such as gtk_text_iter_in_range(), that expect a pre-sorted range. a #GtkTextIter another #GtkTextIter Moves iterator @iter to the start of the line @line_number. If @line_number is negative or larger than the number of lines in the buffer, moves @iter to the start of the last line in the buffer. a #GtkTextIter line number (counted from 0) Same as gtk_text_iter_set_line_offset(), but works with a byte index. The given byte index must be at the start of a character, it can’t be in the middle of a UTF-8 encoded character. a #GtkTextIter a byte index relative to the start of @iter’s current line Moves @iter within a line, to a new character (not byte) offset. The given character offset must be less than or equal to the number of characters in the line; if equal, @iter moves to the start of the next line. See gtk_text_iter_set_line_index() if you have a byte index rather than a character offset. a #GtkTextIter a character offset relative to the start of @iter’s current line Sets @iter to point to @char_offset. @char_offset counts from the start of the entire text buffer, starting with 0. a #GtkTextIter a character number Like gtk_text_iter_set_line_index(), but the index is in visible bytes, i.e. text with a tag making it invisible is not counted in the index. a #GtkTextIter a byte index Like gtk_text_iter_set_line_offset(), but the offset is in visible characters, i.e. text with a tag making it invisible is not counted in the offset. a #GtkTextIter a character offset Returns %TRUE if @iter begins a paragraph, i.e. if gtk_text_iter_get_line_offset() would return 0. However this function is potentially more efficient than gtk_text_iter_get_line_offset() because it doesn’t have to compute the offset, it just has to see whether it’s 0. whether @iter begins a line an iterator Determines whether @iter begins a sentence. Sentence boundaries are determined by Pango and should be correct for nearly any language (if not, the correct fix would be to the Pango text boundary algorithms). %TRUE if @iter is at the start of a sentence. a #GtkTextIter Returns %TRUE if @tag is toggled on at exactly this point. If @tag is %NULL, returns %TRUE if any tag is toggled on at this point. Note that if gtk_text_iter_starts_tag() returns %TRUE, it means that @iter is at the beginning of the tagged range, and that the character at @iter is inside the tagged range. In other words, unlike gtk_text_iter_ends_tag(), if gtk_text_iter_starts_tag() returns %TRUE, gtk_text_iter_has_tag() will also return %TRUE for the same parameters. whether @iter is the start of a range tagged with @tag an iterator a #GtkTextTag, or %NULL Determines whether @iter begins a natural-language word. Word breaks are determined by Pango and should be correct for nearly any language (if not, the correct fix would be to the Pango word break algorithms). %TRUE if @iter is at the start of a word a #GtkTextIter This is equivalent to (gtk_text_iter_starts_tag() || gtk_text_iter_ends_tag()), i.e. it tells you whether a range with @tag applied to it begins or ends at @iter. whether @tag is toggled on or off at @iter an iterator a #GtkTextTag, or %NULL You may wish to begin by reading the [text widget conceptual overview][TextWidget] which gives an overview of all the objects and data types related to the text widget and how they work together. A #GtkTextMark is like a bookmark in a text buffer; it preserves a position in the text. You can convert the mark to an iterator using gtk_text_buffer_get_iter_at_mark(). Unlike iterators, marks remain valid across buffer mutations, because their behavior is defined when text is inserted or deleted. When text containing a mark is deleted, the mark remains in the position originally occupied by the deleted text. When text is inserted at a mark, a mark with “left gravity” will be moved to the beginning of the newly-inserted text, and a mark with “right gravity” will be moved to the end. Note that “left” and “right” here refer to logical direction (left is the toward the start of the buffer); in some languages such as Hebrew the logically-leftmost text is not actually on the left when displayed. Marks are reference counted, but the reference count only controls the validity of the memory; marks can be deleted from the buffer at any time with gtk_text_buffer_delete_mark(). Once deleted from the buffer, a mark is essentially useless. Marks optionally have names; these can be convenient to avoid passing the #GtkTextMark object around. Marks are typically created using the gtk_text_buffer_create_mark() function. Creates a text mark. Add it to a buffer using gtk_text_buffer_add_mark(). If @name is %NULL, the mark is anonymous; otherwise, the mark can be retrieved by name using gtk_text_buffer_get_mark(). If a mark has left gravity, and text is inserted at the mark’s current location, the mark will be moved to the left of the newly-inserted text. If the mark has right gravity (@left_gravity = %FALSE), the mark will end up on the right of newly-inserted text. The standard left-to-right cursor is a mark with right gravity (when you type, the cursor stays on the right side of the text you’re typing). new #GtkTextMark mark name or %NULL whether the mark should have left gravity Gets the buffer this mark is located inside, or %NULL if the mark is deleted. the mark’s #GtkTextBuffer a #GtkTextMark Returns %TRUE if the mark has been removed from its buffer with gtk_text_buffer_delete_mark(). See gtk_text_buffer_add_mark() for a way to add it to a buffer again. whether the mark is deleted a #GtkTextMark Determines whether the mark has left gravity. %TRUE if the mark has left gravity, %FALSE otherwise a #GtkTextMark Returns the mark name; returns NULL for anonymous marks. mark name a #GtkTextMark Returns %TRUE if the mark is visible (i.e. a cursor is displayed for it). %TRUE if visible a #GtkTextMark Sets the visibility of @mark; the insertion point is normally visible, i.e. you can see it as a vertical bar. Also, the text widget uses a visible mark to indicate where a drop will occur when dragging-and-dropping text. Most other marks are not visible. Marks are not visible by default. a #GtkTextMark visibility of mark Whether the mark has left gravity. When text is inserted at the mark’s current location, if the mark has left gravity it will be moved to the left of the newly-inserted text, otherwise to the right. The name of the mark or %NULL if the mark is anonymous. Flags affecting how a search is done. If neither #GTK_TEXT_SEARCH_VISIBLE_ONLY nor #GTK_TEXT_SEARCH_TEXT_ONLY are enabled, the match must be exact; the special 0xFFFC character will match embedded pixbufs or child widgets. Search only visible data. A search match may have invisible text interspersed. Search only text. A match may have pixbufs or child widgets mixed inside the matched range. The text will be matched regardless of what case it is in. You may wish to begin by reading the [text widget conceptual overview][TextWidget] which gives an overview of all the objects and data types related to the text widget and how they work together. Tags should be in the #GtkTextTagTable for a given #GtkTextBuffer before using them with that buffer. gtk_text_buffer_create_tag() is the best way to create tags. See “gtk3-demo” for numerous examples. For each property of #GtkTextTag, there is a “set” property, e.g. “font-set” corresponds to “font”. These “set” properties reflect whether a property has been set or not. They are maintained by GTK+ and you should not set them independently. Creates a #GtkTextTag. Configure the tag using object arguments, i.e. using g_object_set(). a new #GtkTextTag tag name, or %NULL Emits the “event” signal on the #GtkTextTag. result of signal emission (whether the event was handled) a #GtkTextTag object that received the event, such as a widget the event location where the event was received Emits the #GtkTextTagTable::tag-changed signal on the #GtkTextTagTable where the tag is included. The signal is already emitted when setting a #GtkTextTag property. This function is useful for a #GtkTextTag subclass. a #GtkTextTag. whether the change affects the #GtkTextView layout. Emits the “event” signal on the #GtkTextTag. result of signal emission (whether the event was handled) a #GtkTextTag object that received the event, such as a widget the event location where the event was received Get the tag priority. The tag’s priority. a #GtkTextTag Sets the priority of a #GtkTextTag. Valid priorities start at 0 and go to one less than gtk_text_tag_table_get_size(). Each tag in a table has a unique priority; setting the priority of one tag shifts the priorities of all the other tags in the table to maintain a unique priority for each tag. Higher priority tags “win” if two tags both set the same text attribute. When adding a tag to a tag table, it will be assigned the highest priority in the table by default; so normally the precedence of a set of tags is the order in which they were added to the table, or created with gtk_text_buffer_create_tag(), which adds the tag to the buffer’s table automatically. a #GtkTextTag the new priority Whether the margins accumulate or override each other. When set to %TRUE the margins of this tag are added to the margins of any other non-accumulative margins present. When set to %FALSE the margins override one another (the default). Background color as a #GdkColor. Use #GtkTextTag:background-rgba instead. Background color as a #GdkRGBA. Whether font fallback is enabled. When set to %TRUE, other fonts will be substituted where the current font is missing glyphs. Font description as string, e.g. \"Sans Italic 12\". Note that the initial value of this property depends on the internals of #PangoFontDescription. OpenType font features, as a string. Foreground color as a #GdkColor. Use #GtkTextTag:foreground-rgba instead. Foreground color as a #GdkRGBA. Whether this text is hidden. Note that there may still be problems with the support for invisible text, in particular when navigating programmatically inside a buffer containing invisible segments. The language this text is in, as an ISO code. Pango can use this as a hint when rendering the text. If not set, an appropriate default will be used. Note that the initial value of this property depends on the current locale, see also gtk_get_default_language(). Extra spacing between graphemes, in Pango units. The paragraph background color as a string. The paragraph background color as a #GdkColor. Use #GtkTextTag:paragraph-background-rgba instead. The paragraph background color as a #GdkRGBA. This property modifies the color of strikeouts. If not set, strikeouts will use the forground color. If the #GtkTextTag:strikethrough-rgba property has been set. This property modifies the color of underlines. If not set, underlines will use the forground color. If #GtkTextTag:underline is set to %PANGO_UNDERLINE_ERROR, an alternate color may be applied instead of the foreground. Setting this property will always override those defaults. If the #GtkTextTag:underline-rgba property has been set. The ::event signal is emitted when an event occurs on a region of the buffer marked with this tag. %TRUE to stop other handlers from being invoked for the event. %FALSE to propagate the event further. the object the event was fired from (typically a #GtkTextView) the event which triggered the signal a #GtkTextIter pointing at the location the event occurred result of signal emission (whether the event was handled) a #GtkTextTag object that received the event, such as a widget the event location where the event was received You may wish to begin by reading the [text widget conceptual overview][TextWidget] which gives an overview of all the objects and data types related to the text widget and how they work together. # GtkTextTagTables as GtkBuildable The GtkTextTagTable implementation of the GtkBuildable interface supports adding tags by specifying “tag” as the “type” attribute of a <child> element. An example of a UI definition fragment specifying tags: |[ <object class="GtkTextTagTable"> <child type="tag"> <object class="GtkTextTag"/> </child> </object> ]| Creates a new #GtkTextTagTable. The table contains no tags by default. a new #GtkTextTagTable Add a tag to the table. The tag is assigned the highest priority in the table. @tag must not be in a tag table already, and may not have the same name as an already-added tag. %TRUE on success. a #GtkTextTagTable a #GtkTextTag Calls @func on each tag in @table, with user data @data. Note that the table may not be modified while iterating over it (you can’t add/remove tags). a #GtkTextTagTable a function to call on each tag user data Returns the size of the table (number of tags) number of tags in @table a #GtkTextTagTable Look up a named tag. The tag, or %NULL if none by that name is in the table. a #GtkTextTagTable name of a tag Remove a tag from the table. If a #GtkTextBuffer has @table as its tag table, the tag is removed from the buffer. The table’s reference to the tag is removed, so the tag will end up destroyed if you don’t have a reference to it. a #GtkTextTagTable a #GtkTextTag the added tag. the changed tag. whether the change affects the #GtkTextView layout. the removed tag. the #GtkTextTag data passed to gtk_text_tag_table_foreach() You may wish to begin by reading the [text widget conceptual overview][TextWidget] which gives an overview of all the objects and data types related to the text widget and how they work together. # CSS nodes |[<!-- language="plain" --> textview.view ├── border.top ├── border.left ├── text │ ╰── [selection] ├── border.right ├── border.bottom ╰── [window.popup] ]| GtkTextView has a main css node with name textview and style class .view, and subnodes for each of the border windows, and the main text area, with names border and text, respectively. The border nodes each get one of the style classes .left, .right, .top or .bottom. A node representing the selection will appear below the text node. If a context menu is opened, the window node will appear as a subnode of the main node. Creates a new #GtkTextView. If you don’t call gtk_text_view_set_buffer() before using the text view, an empty default buffer will be created for you. Get the buffer with gtk_text_view_get_buffer(). If you want to specify your own buffer, consider gtk_text_view_new_with_buffer(). a new #GtkTextView Creates a new #GtkTextView widget displaying the buffer @buffer. One buffer can be shared among many widgets. @buffer may be %NULL to create a default buffer, in which case this function is equivalent to gtk_text_view_new(). The text view adds its own reference count to the buffer; it does not take over an existing reference. a new #GtkTextView. a #GtkTextBuffer Adds a child widget in the text buffer, at the given @anchor. a #GtkTextView a #GtkWidget a #GtkTextChildAnchor in the #GtkTextBuffer for @text_view Adds a child at fixed coordinates in one of the text widget's windows. The window must have nonzero size (see gtk_text_view_set_border_window_size()). Note that the child coordinates are given relative to scrolling. When placing a child in #GTK_TEXT_WINDOW_WIDGET, scrolling is irrelevant, the child floats above all scrollable areas. But when placing a child in one of the scrollable windows (border windows or text window) it will move with the scrolling as needed. a #GtkTextView a #GtkWidget which window the child should appear in X position of child in window coordinates Y position of child in window coordinates Moves the given @iter backward by one display (wrapped) line. A display line is different from a paragraph. Paragraphs are separated by newlines or other paragraph separator characters. Display lines are created by line-wrapping a paragraph. If wrapping is turned off, display lines and paragraphs will be the same. Display lines are divided differently for each view, since they depend on the view’s width; paragraphs are the same in all views, since they depend on the contents of the #GtkTextBuffer. %TRUE if @iter was moved and is not on the end iterator a #GtkTextView a #GtkTextIter Moves the given @iter backward to the next display line start. A display line is different from a paragraph. Paragraphs are separated by newlines or other paragraph separator characters. Display lines are created by line-wrapping a paragraph. If wrapping is turned off, display lines and paragraphs will be the same. Display lines are divided differently for each view, since they depend on the view’s width; paragraphs are the same in all views, since they depend on the contents of the #GtkTextBuffer. %TRUE if @iter was moved and is not on the end iterator a #GtkTextView a #GtkTextIter Converts coordinate (@buffer_x, @buffer_y) to coordinates for the window @win, and stores the result in (@window_x, @window_y). Note that you can’t convert coordinates for a nonexisting window (see gtk_text_view_set_border_window_size()). a #GtkTextView a #GtkTextWindowType, except %GTK_TEXT_WINDOW_PRIVATE buffer x coordinate buffer y coordinate window x coordinate return location or %NULL window y coordinate return location or %NULL Moves the given @iter forward by one display (wrapped) line. A display line is different from a paragraph. Paragraphs are separated by newlines or other paragraph separator characters. Display lines are created by line-wrapping a paragraph. If wrapping is turned off, display lines and paragraphs will be the same. Display lines are divided differently for each view, since they depend on the view’s width; paragraphs are the same in all views, since they depend on the contents of the #GtkTextBuffer. %TRUE if @iter was moved and is not on the end iterator a #GtkTextView a #GtkTextIter Moves the given @iter forward to the next display line end. A display line is different from a paragraph. Paragraphs are separated by newlines or other paragraph separator characters. Display lines are created by line-wrapping a paragraph. If wrapping is turned off, display lines and paragraphs will be the same. Display lines are divided differently for each view, since they depend on the view’s width; paragraphs are the same in all views, since they depend on the contents of the #GtkTextBuffer. %TRUE if @iter was moved and is not on the end iterator a #GtkTextView a #GtkTextIter Returns whether pressing the Tab key inserts a tab characters. gtk_text_view_set_accepts_tab(). %TRUE if pressing the Tab key inserts a tab character, %FALSE if pressing the Tab key moves the keyboard focus. A #GtkTextView Gets the width of the specified border window. See gtk_text_view_set_border_window_size(). width of window a #GtkTextView window to return size from Gets the bottom margin for text in the @text_view. bottom margin in pixels a #GtkTextView Returns the #GtkTextBuffer being displayed by this text view. The reference count on the buffer is not incremented; the caller of this function won’t own a new reference. a #GtkTextBuffer a #GtkTextView Given an @iter within a text layout, determine the positions of the strong and weak cursors if the insertion point is at that iterator. The position of each cursor is stored as a zero-width rectangle. The strong cursor location is the location where characters of the directionality equal to the base direction of the paragraph are inserted. The weak cursor location is the location where characters of the directionality opposite to the base direction of the paragraph are inserted. If @iter is %NULL, the actual cursor position is used. Note that if @iter happens to be the actual cursor position, and there is currently an IM preedit sequence being entered, the returned locations will be adjusted to account for the preedit cursor’s offset within the preedit sequence. The rectangle position is in buffer coordinates; use gtk_text_view_buffer_to_window_coords() to convert these coordinates to coordinates for one of the windows in the text view. a #GtkTextView a #GtkTextIter location to store the strong cursor position (may be %NULL) location to store the weak cursor position (may be %NULL) Find out whether the cursor should be displayed. whether the insertion mark is visible a #GtkTextView Obtains a copy of the default text attributes. These are the attributes used for text unless a tag overrides them. You’d typically pass the default attributes in to gtk_text_iter_get_attributes() in order to get the attributes in effect at a given text position. The return value is a copy owned by the caller of this function, and should be freed with gtk_text_attributes_unref(). a new #GtkTextAttributes a #GtkTextView Returns the default editability of the #GtkTextView. Tags in the buffer may override this setting for some ranges of text. whether text is editable by default a #GtkTextView Gets the horizontal-scrolling #GtkAdjustment. Use gtk_scrollable_get_hadjustment() pointer to the horizontal #GtkAdjustment a #GtkTextView Gets the default indentation of paragraphs in @text_view. Tags in the view’s buffer may override the default. The indentation may be negative. number of pixels of indentation a #GtkTextView Gets the value of the #GtkTextView:input-hints property. a #GtkTextView Gets the value of the #GtkTextView:input-purpose property. a #GtkTextView Retrieves the iterator at buffer coordinates @x and @y. Buffer coordinates are coordinates for the entire buffer, not just the currently-displayed portion. If you have coordinates from an event, you have to convert those to buffer coordinates with gtk_text_view_window_to_buffer_coords(). %TRUE if the position is over text a #GtkTextView a #GtkTextIter x position, in buffer coordinates y position, in buffer coordinates Retrieves the iterator pointing to the character at buffer coordinates @x and @y. Buffer coordinates are coordinates for the entire buffer, not just the currently-displayed portion. If you have coordinates from an event, you have to convert those to buffer coordinates with gtk_text_view_window_to_buffer_coords(). Note that this is different from gtk_text_view_get_iter_at_location(), which returns cursor locations, i.e. positions between characters. %TRUE if the position is over text a #GtkTextView a #GtkTextIter if non-%NULL, location to store an integer indicating where in the grapheme the user clicked. It will either be zero, or the number of characters in the grapheme. 0 represents the trailing edge of the grapheme. x position, in buffer coordinates y position, in buffer coordinates Gets a rectangle which roughly contains the character at @iter. The rectangle position is in buffer coordinates; use gtk_text_view_buffer_to_window_coords() to convert these coordinates to coordinates for one of the windows in the text view. a #GtkTextView a #GtkTextIter bounds of the character at @iter Gets the default justification of paragraphs in @text_view. Tags in the buffer may override the default. default justification a #GtkTextView Gets the default left margin size of paragraphs in the @text_view. Tags in the buffer may override the default. left margin in pixels a #GtkTextView Gets the #GtkTextIter at the start of the line containing the coordinate @y. @y is in buffer coordinates, convert from window coordinates with gtk_text_view_window_to_buffer_coords(). If non-%NULL, @line_top will be filled with the coordinate of the top edge of the line. a #GtkTextView a #GtkTextIter a y coordinate return location for top coordinate of the line Gets the y coordinate of the top of the line containing @iter, and the height of the line. The coordinate is a buffer coordinate; convert to window coordinates with gtk_text_view_buffer_to_window_coords(). a #GtkTextView a #GtkTextIter return location for a y coordinate return location for a height Gets the value of the #GtkTextView:monospace property. %TRUE if monospace fonts are desired a #GtkTextView Returns whether the #GtkTextView is in overwrite mode or not. whether @text_view is in overwrite mode or not. a #GtkTextView Gets the default number of pixels to put above paragraphs. Adding this function with gtk_text_view_get_pixels_below_lines() is equal to the line space between each paragraph. default number of pixels above paragraphs a #GtkTextView Gets the value set by gtk_text_view_set_pixels_below_lines(). The line space is the sum of the value returned by this function and the value returned by gtk_text_view_get_pixels_above_lines(). default number of blank pixels below paragraphs a #GtkTextView Gets the value set by gtk_text_view_set_pixels_inside_wrap(). default number of pixels of blank space between wrapped lines a #GtkTextView Gets the default right margin for text in @text_view. Tags in the buffer may override the default. right margin in pixels a #GtkTextView Gets the default tabs for @text_view. Tags in the buffer may override the defaults. The returned array will be %NULL if “standard” (8-space) tabs are used. Free the return value with pango_tab_array_free(). copy of default tab array, or %NULL if “standard" tabs are used; must be freed with pango_tab_array_free(). a #GtkTextView Gets the top margin for text in the @text_view. top margin in pixels a #GtkTextView Gets the vertical-scrolling #GtkAdjustment. Use gtk_scrollable_get_vadjustment() pointer to the vertical #GtkAdjustment a #GtkTextView Fills @visible_rect with the currently-visible region of the buffer, in buffer coordinates. Convert to window coordinates with gtk_text_view_buffer_to_window_coords(). a #GtkTextView rectangle to fill Retrieves the #GdkWindow corresponding to an area of the text view; possible windows include the overall widget window, child windows on the left, right, top, bottom, and the window that displays the text buffer. Windows are %NULL and nonexistent if their width or height is 0, and are nonexistent before the widget has been realized. a #GdkWindow, or %NULL a #GtkTextView window to get Usually used to find out which window an event corresponds to. If you connect to an event signal on @text_view, this function should be called on `event->window` to see which window it was. the window type. a #GtkTextView a window type Gets the line wrapping for the view. the line wrap setting a #GtkTextView Allow the #GtkTextView input method to internally handle key press and release events. If this function returns %TRUE, then no further processing should be done for this key event. See gtk_im_context_filter_keypress(). Note that you are expected to call this function from your handler when overriding key event handling. This is needed in the case when you need to insert your own key handling between the input method and the default key event handling of the #GtkTextView. |[<!-- language="C" --> static gboolean gtk_foo_bar_key_press_event (GtkWidget *widget, GdkEventKey *event) { guint keyval; gdk_event_get_keyval ((GdkEvent*)event, &keyval); if (keyval == GDK_KEY_Return || keyval == GDK_KEY_KP_Enter) { if (gtk_text_view_im_context_filter_keypress (GTK_TEXT_VIEW (widget), event)) return TRUE; } // Do some stuff return GTK_WIDGET_CLASS (gtk_foo_bar_parent_class)->key_press_event (widget, event); } ]| %TRUE if the input method handled the key event. a #GtkTextView the key event Updates the position of a child, as for gtk_text_view_add_child_in_window(). a #GtkTextView child widget already added to the text view new X position in window coordinates new Y position in window coordinates Moves a mark within the buffer so that it's located within the currently-visible text area. %TRUE if the mark moved (wasn’t already onscreen) a #GtkTextView a #GtkTextMark Move the iterator a given number of characters visually, treating it as the strong cursor position. If @count is positive, then the new strong cursor position will be @count positions to the right of the old cursor position. If @count is negative then the new strong cursor position will be @count positions to the left of the old cursor position. In the presence of bi-directional text, the correspondence between logical and visual order will depend on the direction of the current run, and there may be jumps when the cursor is moved off of the end of a run. %TRUE if @iter moved and is not on the end iterator a #GtkTextView a #GtkTextIter number of characters to move (negative moves left, positive moves right) Moves the cursor to the currently visible region of the buffer, it it isn’t there already. %TRUE if the cursor had to be moved. a #GtkTextView Ensures that the cursor is shown (i.e. not in an 'off' blink interval) and resets the time that it will stay blinking (or visible, in case blinking is disabled). This function should be called in response to user input (e.g. from derived classes that override the textview's #GtkWidget::key-press-event handler). a #GtkTextView Reset the input method context of the text view if needed. This can be necessary in the case where modifying the buffer would confuse on-going input method behavior. a #GtkTextView Scrolls @text_view the minimum distance such that @mark is contained within the visible area of the widget. a #GtkTextView a mark in the buffer for @text_view Scrolls @text_view so that @iter is on the screen in the position indicated by @xalign and @yalign. An alignment of 0.0 indicates left or top, 1.0 indicates right or bottom, 0.5 means center. If @use_align is %FALSE, the text scrolls the minimal distance to get the mark onscreen, possibly not scrolling at all. The effective screen for purposes of this function is reduced by a margin of size @within_margin. Note that this function uses the currently-computed height of the lines in the text buffer. Line heights are computed in an idle handler; so this function may not have the desired effect if it’s called before the height computations. To avoid oddness, consider using gtk_text_view_scroll_to_mark() which saves a point to be scrolled to after line validation. %TRUE if scrolling occurred a #GtkTextView a #GtkTextIter margin as a [0.0,0.5) fraction of screen size whether to use alignment arguments (if %FALSE, just get the mark onscreen) horizontal alignment of mark within visible area vertical alignment of mark within visible area Scrolls @text_view so that @mark is on the screen in the position indicated by @xalign and @yalign. An alignment of 0.0 indicates left or top, 1.0 indicates right or bottom, 0.5 means center. If @use_align is %FALSE, the text scrolls the minimal distance to get the mark onscreen, possibly not scrolling at all. The effective screen for purposes of this function is reduced by a margin of size @within_margin. a #GtkTextView a #GtkTextMark margin as a [0.0,0.5) fraction of screen size whether to use alignment arguments (if %FALSE, just get the mark onscreen) horizontal alignment of mark within visible area vertical alignment of mark within visible area Sets the behavior of the text widget when the Tab key is pressed. If @accepts_tab is %TRUE, a tab character is inserted. If @accepts_tab is %FALSE the keyboard focus is moved to the next widget in the focus chain. A #GtkTextView %TRUE if pressing the Tab key should insert a tab character, %FALSE, if pressing the Tab key should move the keyboard focus. Sets the width of %GTK_TEXT_WINDOW_LEFT or %GTK_TEXT_WINDOW_RIGHT, or the height of %GTK_TEXT_WINDOW_TOP or %GTK_TEXT_WINDOW_BOTTOM. Automatically destroys the corresponding window if the size is set to 0, and creates the window if the size is set to non-zero. This function can only be used for the “border windows”, and it won’t work with %GTK_TEXT_WINDOW_WIDGET, %GTK_TEXT_WINDOW_TEXT, or %GTK_TEXT_WINDOW_PRIVATE. a #GtkTextView window to affect width or height of the window Sets the bottom margin for text in @text_view. Note that this function is confusingly named. In CSS terms, the value set here is padding. a #GtkTextView bottom margin in pixels Sets @buffer as the buffer being displayed by @text_view. The previous buffer displayed by the text view is unreferenced, and a reference is added to @buffer. If you owned a reference to @buffer before passing it to this function, you must remove that reference yourself; #GtkTextView will not “adopt” it. a #GtkTextView a #GtkTextBuffer Toggles whether the insertion point should be displayed. A buffer with no editable text probably shouldn’t have a visible cursor, so you may want to turn the cursor off. Note that this property may be overridden by the #GtkSettings:gtk-keynave-use-caret settings. a #GtkTextView whether to show the insertion cursor Sets the default editability of the #GtkTextView. You can override this default setting with tags in the buffer, using the “editable” attribute of tags. a #GtkTextView whether it’s editable Sets the default indentation for paragraphs in @text_view. Tags in the buffer may override the default. a #GtkTextView indentation in pixels Sets the #GtkTextView:input-hints property, which allows input methods to fine-tune their behaviour. a #GtkTextView the hints Sets the #GtkTextView:input-purpose property which can be used by on-screen keyboards and other input methods to adjust their behaviour. a #GtkTextView the purpose Sets the default justification of text in @text_view. Tags in the view’s buffer may override the default. a #GtkTextView justification Sets the default left margin for text in @text_view. Tags in the buffer may override the default. Note that this function is confusingly named. In CSS terms, the value set here is padding. a #GtkTextView left margin in pixels Sets the #GtkTextView:monospace property, which indicates that the text view should use monospace fonts. a #GtkTextView %TRUE to request monospace styling Changes the #GtkTextView overwrite mode. a #GtkTextView %TRUE to turn on overwrite mode, %FALSE to turn it off Sets the default number of blank pixels above paragraphs in @text_view. Tags in the buffer for @text_view may override the defaults. a #GtkTextView pixels above paragraphs Sets the default number of pixels of blank space to put below paragraphs in @text_view. May be overridden by tags applied to @text_view’s buffer. a #GtkTextView pixels below paragraphs Sets the default number of pixels of blank space to leave between display/wrapped lines within a paragraph. May be overridden by tags in @text_view’s buffer. a #GtkTextView default number of pixels between wrapped lines Sets the default right margin for text in the text view. Tags in the buffer may override the default. Note that this function is confusingly named. In CSS terms, the value set here is padding. a #GtkTextView right margin in pixels Sets the default tab stops for paragraphs in @text_view. Tags in the buffer may override the default. a #GtkTextView tabs as a #PangoTabArray Sets the top margin for text in @text_view. Note that this function is confusingly named. In CSS terms, the value set here is padding. a #GtkTextView top margin in pixels Sets the line wrapping for the view. a #GtkTextView a #GtkWrapMode Determines whether @iter is at the start of a display line. See gtk_text_view_forward_display_line() for an explanation of display lines vs. paragraphs. %TRUE if @iter begins a wrapped line a #GtkTextView a #GtkTextIter Converts coordinates on the window identified by @win to buffer coordinates, storing the result in (@buffer_x,@buffer_y). Note that you can’t convert coordinates for a nonexisting window (see gtk_text_view_set_border_window_size()). a #GtkTextView a #GtkTextWindowType except %GTK_TEXT_WINDOW_PRIVATE window x coordinate window y coordinate buffer x coordinate return location or %NULL buffer y coordinate return location or %NULL The bottom margin for text in the text view. Note that this property is confusingly named. In CSS terms, the value set here is padding, and it is applied in addition to the padding from the theme. Don't confuse this property with #GtkWidget:margin-bottom. Which IM (input method) module should be used for this text_view. See #GtkIMContext. Setting this to a non-%NULL value overrides the system-wide IM module setting. See the GtkSettings #GtkSettings:gtk-im-module property. Additional hints (beyond #GtkTextView:input-purpose) that allow input methods to fine-tune their behaviour. The purpose of this text field. This property can be used by on-screen keyboards and other input methods to adjust their behaviour. The default left margin for text in the text view. Tags in the buffer may override the default. Note that this property is confusingly named. In CSS terms, the value set here is padding, and it is applied in addition to the padding from the theme. Don't confuse this property with #GtkWidget:margin-left. If :populate-all is %TRUE, the #GtkTextView::populate-popup signal is also emitted for touch popups. The default right margin for text in the text view. Tags in the buffer may override the default. Note that this property is confusingly named. In CSS terms, the value set here is padding, and it is applied in addition to the padding from the theme. Don't confuse this property with #GtkWidget:margin-right. The top margin for text in the text view. Note that this property is confusingly named. In CSS terms, the value set here is padding, and it is applied in addition to the padding from the theme. Don't confuse this property with #GtkWidget:margin-top. The ::backspace signal is a [keybinding signal][GtkBindingSignal] which gets emitted when the user asks for it. The default bindings for this signal are Backspace and Shift-Backspace. The ::copy-clipboard signal is a [keybinding signal][GtkBindingSignal] which gets emitted to copy the selection to the clipboard. The default bindings for this signal are Ctrl-c and Ctrl-Insert. The ::cut-clipboard signal is a [keybinding signal][GtkBindingSignal] which gets emitted to cut the selection to the clipboard. The default bindings for this signal are Ctrl-x and Shift-Delete. The ::delete-from-cursor signal is a [keybinding signal][GtkBindingSignal] which gets emitted when the user initiates a text deletion. If the @type is %GTK_DELETE_CHARS, GTK+ deletes the selection if there is one, otherwise it deletes the requested number of characters. The default bindings for this signal are Delete for deleting a character, Ctrl-Delete for deleting a word and Ctrl-Backspace for deleting a word backwords. the granularity of the deletion, as a #GtkDeleteType the number of @type units to delete The ::extend-selection signal is emitted when the selection needs to be extended at @location. %GDK_EVENT_STOP to stop other handlers from being invoked for the event. %GDK_EVENT_PROPAGATE to propagate the event further. the granularity type the location where to extend the selection where the selection should start where the selection should end The ::insert-at-cursor signal is a [keybinding signal][GtkBindingSignal] which gets emitted when the user initiates the insertion of a fixed string at the cursor. This signal has no default bindings. the string to insert The ::insert-emoji signal is a [keybinding signal][GtkBindingSignal] which gets emitted to present the Emoji chooser for the @text_view. The default bindings for this signal are Ctrl-. and Ctrl-; The ::move-cursor signal is a [keybinding signal][GtkBindingSignal] which gets emitted when the user initiates a cursor movement. If the cursor is not visible in @text_view, this signal causes the viewport to be moved instead. Applications should not connect to it, but may emit it with g_signal_emit_by_name() if they need to control the cursor programmatically. The default bindings for this signal come in two variants, the variant with the Shift modifier extends the selection, the variant without the Shift modifer does not. There are too many key combinations to list them all here. - Arrow keys move by individual characters/lines - Ctrl-arrow key combinations move by words/paragraphs - Home/End keys move to the ends of the buffer - PageUp/PageDown keys move vertically by pages - Ctrl-PageUp/PageDown keys move horizontally by pages the granularity of the move, as a #GtkMovementStep the number of @step units to move %TRUE if the move should extend the selection The ::move-viewport signal is a [keybinding signal][GtkBindingSignal] which can be bound to key combinations to allow the user to move the viewport, i.e. change what part of the text view is visible in a containing scrolled window. There are no default bindings for this signal. the granularity of the movement, as a #GtkScrollStep the number of @step units to move The ::paste-clipboard signal is a [keybinding signal][GtkBindingSignal] which gets emitted to paste the contents of the clipboard into the text view. The default bindings for this signal are Ctrl-v and Shift-Insert. The ::populate-popup signal gets emitted before showing the context menu of the text view. If you need to add items to the context menu, connect to this signal and append your items to the @popup, which will be a #GtkMenu in this case. If #GtkTextView:populate-all is %TRUE, this signal will also be emitted to populate touch popups. In this case, @popup will be a different container, e.g. a #GtkToolbar. The signal handler should not make assumptions about the type of @widget, but check whether @popup is a #GtkMenu or #GtkToolbar or another kind of container. the container that is being populated If an input method is used, the typed text will not immediately be committed to the buffer. So if you are interested in the text, connect to this signal. This signal is only emitted if the text at the given position is actually editable. the current preedit string The ::select-all signal is a [keybinding signal][GtkBindingSignal] which gets emitted to select or unselect the complete contents of the text view. The default bindings for this signal are Ctrl-a and Ctrl-/ for selecting and Shift-Ctrl-a and Ctrl-\ for unselecting. %TRUE to select, %FALSE to unselect The ::set-anchor signal is a [keybinding signal][GtkBindingSignal] which gets emitted when the user initiates setting the "anchor" mark. The "anchor" mark gets placed at the same position as the "insert" mark. This signal has no default bindings. The ::toggle-cursor-visible signal is a [keybinding signal][GtkBindingSignal] which gets emitted to toggle the #GtkTextView:cursor-visible property. The default binding for this signal is F7. The ::toggle-overwrite signal is a [keybinding signal][GtkBindingSignal] which gets emitted to toggle the overwrite mode of the text view. The default bindings for this signal is Insert. The object class structure needs to be the first Used to reference the layers of #GtkTextView for the purpose of customized drawing with the ::draw_layer vfunc. Old deprecated layer, use %GTK_TEXT_VIEW_LAYER_BELOW_TEXT instead Old deprecated layer, use %GTK_TEXT_VIEW_LAYER_ABOVE_TEXT instead The layer rendered below the text (but above the background). Since: 3.20 The layer rendered above the text. Since: 3.20 Used to reference the parts of #GtkTextView. Invalid value, used as a marker Window that floats over scrolling areas. Scrollable text window. Left side border window. Right side border window. Top border window. Bottom border window. #GtkThemingEngine was the object used for rendering themed content in GTK+ widgets. It used to allow overriding GTK+'s default implementation of rendering functions by allowing engines to be loaded as modules. #GtkThemingEngine has been deprecated in GTK+ 3.14 and will be ignored for rendering. The advancements in CSS theming are good enough to allow themers to achieve their goals without the need to modify source code. Loads and initializes a theming engine module from the standard directories. A theming engine, or %NULL if the engine @name doesn’t exist. Theme engine name to load Registers a property so it can be used in the CSS file format, on the CSS file the property will look like "-${@name_space}-${property_name}". being ${property_name} the given to @pspec. @name_space will usually be the theme engine name. For any type a @parse_func may be provided, being this function used for turning any property value (between “:” and “;”) in CSS to the #GValue needed. For basic types there is already builtin parsing support, so %NULL may be provided for these cases. Engines must ensure property registration happens exactly once, usually GTK+ deals with theming engines as singletons, so this should be guaranteed to happen once, but bear this in mind when creating #GtkThemeEngines yourself. In order to make use of the custom registered properties in the CSS file, make sure the engine is loaded first by specifying the engine property, either in a previous rule or within the same one. |[ * { engine: someengine; -SomeEngine-custom-property: 2; } ]| Code should use the default properties provided by CSS. namespace for the property name parsing function to use, or %NULL the #GParamSpec for the new property Retrieves several style property values that apply to the currently rendered element. a #GtkThemingEngine state to retrieve values for property name /return value pairs, followed by %NULL Gets the background color for a given state. a #GtkThemingEngine state to retrieve the color for return value for the background color Gets the border for a given state as a #GtkBorder. a #GtkThemingEngine state to retrieve the border for return value for the border settings Gets the border color for a given state. a #GtkThemingEngine state to retrieve the color for return value for the border color Gets the foreground color for a given state. a #GtkThemingEngine state to retrieve the color for return value for the foreground color Returns the widget direction used for rendering. Use gtk_theming_engine_get_state() and check for #GTK_STATE_FLAG_DIR_LTR and #GTK_STATE_FLAG_DIR_RTL instead. the widget direction a #GtkThemingEngine Returns the font description for a given state. Use gtk_theming_engine_get() the #PangoFontDescription for the given state. This object is owned by GTK+ and should not be freed. a #GtkThemingEngine state to retrieve the font for Returns the widget direction used for rendering. the widget direction a #GtkThemingEngine Gets the margin for a given state as a #GtkBorder. a #GtkThemingEngine state to retrieve the border for return value for the margin settings Gets the padding for a given state as a #GtkBorder. a #GtkThemingEngine state to retrieve the padding for return value for the padding settings Returns the widget path used for style matching. A #GtkWidgetPath a #GtkThemingEngine Gets a property value as retrieved from the style settings that apply to the currently rendered element. a #GtkThemingEngine the property name state to retrieve the value for return location for the property value, you must free this memory using g_value_unset() once you are done with it. Returns the #GdkScreen to which @engine currently rendering to. a #GdkScreen, or %NULL. a #GtkThemingEngine returns the state used when rendering. the state flags a #GtkThemingEngine Retrieves several widget style properties from @engine according to the currently rendered content’s style. a #GtkThemingEngine property name /return value pairs, followed by %NULL Gets the value for a widget style property. a #GtkThemingEngine the name of the widget style property Return location for the property value, free with g_value_unset() after use. Retrieves several widget style properties from @engine according to the currently rendered content’s style. a #GtkThemingEngine va_list of property name/return location pairs, followed by %NULL Retrieves several style property values that apply to the currently rendered element. a #GtkThemingEngine state to retrieve values for va_list of property name/return location pairs, followed by %NULL Returns %TRUE if the currently rendered contents have defined the given class name. %TRUE if @engine has @class_name defined a #GtkThemingEngine class name to look up Returns %TRUE if the currently rendered contents have the region defined. If @flags_return is not %NULL, it is set to the flags affecting the region. %TRUE if region is defined a #GtkThemingEngine a region name return location for region flags Looks up and resolves a color name in the current style’s color map. %TRUE if @color_name was found and resolved, %FALSE otherwise a #GtkThemingEngine color name to lookup Return location for the looked up color Returns %TRUE if there is a transition animation running for the current region (see gtk_style_context_push_animatable_region()). If @progress is not %NULL, the animation progress will be returned there, 0.0 means the state is closest to being %FALSE, while 1.0 means it’s closest to being %TRUE. This means transition animations will run from 0 to 1 when @state is being set to %TRUE and from 1 to 0 when it’s being set to %FALSE. Always returns %FALSE %TRUE if there is a running transition animation for @state. a #GtkThemingEngine a widget state return location for the transition progress The theming engine name, this name will be used when registering custom properties, for a theming engine named "Clearlooks" registering a "glossy" custom property, it could be referenced in the CSS file as |[ -Clearlooks-glossy: true; ]| Base class for theming engines. The parent class. Callback type for adding a function to update animations. See gtk_widget_add_tick_callback(). %G_SOURCE_CONTINUE if the tick callback should continue to be called, %G_SOURCE_REMOVE if the tick callback should be removed. the widget the frame clock for the widget (same as calling gtk_widget_get_frame_clock()) user data passed to gtk_widget_add_tick_callback(). A #GtkToggleAction corresponds roughly to a #GtkCheckMenuItem. It has an “active” state specifying whether the action has been checked or not. Creates a new #GtkToggleAction object. To add the action to a #GtkActionGroup and set the accelerator for the action, call gtk_action_group_add_action_with_accel(). a new #GtkToggleAction A unique name for the action The label displayed in menu items and on buttons, or %NULL A tooltip for the action, or %NULL The stock icon to display in widgets representing the action, or %NULL Emits the “toggled” signal on the toggle action. the action object Returns the checked state of the toggle action. the checked state of the toggle action the action object Returns whether the action should have proxies like a radio action. whether the action should have proxies like a radio action. the action object Sets the checked state on the toggle action. the action object whether the action should be checked or not Sets whether the action should have proxies like a radio action. the action object whether the action should have proxies like a radio action Emits the “toggled” signal on the toggle action. the action object Whether the toggle action should be active. Whether the proxies for this action look like radio action proxies. This is an appearance property and thus only applies if #GtkActivatable:use-action-appearance is %TRUE. Should be connected if you wish to perform an action whenever the #GtkToggleAction state is changed. the action object #GtkToggleActionEntry structs are used with gtk_action_group_add_toggle_actions() to construct toggle actions. The name of the action. The stock id for the action, or the name of an icon from the icon theme. The label for the action. This field should typically be marked for translation, see gtk_action_group_set_translation_domain(). The accelerator for the action, in the format understood by gtk_accelerator_parse(). The tooltip for the action. This field should typically be marked for translation, see gtk_action_group_set_translation_domain(). The function to call when the action is activated. The initial state of the toggle action. A #GtkToggleButton is a #GtkButton which will remain “pressed-in” when clicked. Clicking again will cause the toggle button to return to its normal state. A toggle button is created by calling either gtk_toggle_button_new() or gtk_toggle_button_new_with_label(). If using the former, it is advisable to pack a widget, (such as a #GtkLabel and/or a #GtkImage), into the toggle button’s container. (See #GtkButton for more information). The state of a #GtkToggleButton can be set specifically using gtk_toggle_button_set_active(), and retrieved using gtk_toggle_button_get_active(). To simply switch the state of a toggle button, use gtk_toggle_button_toggled(). # CSS nodes GtkToggleButton has a single CSS node with name button. To differentiate it from a plain #GtkButton, it gets the .toggle style class. ## Creating two #GtkToggleButton widgets. |[<!-- language="C" --> static void output_state (GtkToggleButton *source, gpointer user_data) { printf ("Active: %d\n", gtk_toggle_button_get_active (source)); } void make_toggles (void) { GtkWidget *window, *toggle1, *toggle2; GtkWidget *box; const char *text; window = gtk_window_new (GTK_WINDOW_TOPLEVEL); box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12); text = "Hi, I’m a toggle button."; toggle1 = gtk_toggle_button_new_with_label (text); // Makes this toggle button invisible gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (toggle1), TRUE); g_signal_connect (toggle1, "toggled", G_CALLBACK (output_state), NULL); gtk_container_add (GTK_CONTAINER (box), toggle1); text = "Hi, I’m a toggle button."; toggle2 = gtk_toggle_button_new_with_label (text); gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (toggle2), FALSE); g_signal_connect (toggle2, "toggled", G_CALLBACK (output_state), NULL); gtk_container_add (GTK_CONTAINER (box), toggle2); gtk_container_add (GTK_CONTAINER (window), box); gtk_widget_show_all (window); } ]| Creates a new toggle button. A widget should be packed into the button, as in gtk_button_new(). a new toggle button. Creates a new toggle button with a text label. a new toggle button. a string containing the message to be placed in the toggle button. Creates a new #GtkToggleButton containing a label. The label will be created using gtk_label_new_with_mnemonic(), so underscores in @label indicate the mnemonic for the button. a new #GtkToggleButton the text of the button, with an underscore in front of the mnemonic character Emits the #GtkToggleButton::toggled signal on the #GtkToggleButton. There is no good reason for an application ever to call this function. a #GtkToggleButton. Queries a #GtkToggleButton and returns its current state. Returns %TRUE if the toggle button is pressed in and %FALSE if it is raised. a #gboolean value. a #GtkToggleButton. Gets the value set by gtk_toggle_button_set_inconsistent(). %TRUE if the button is displayed as inconsistent, %FALSE otherwise a #GtkToggleButton Retrieves whether the button is displayed as a separate indicator and label. See gtk_toggle_button_set_mode(). %TRUE if the togglebutton is drawn as a separate indicator and label. a #GtkToggleButton Sets the status of the toggle button. Set to %TRUE if you want the GtkToggleButton to be “pressed in”, and %FALSE to raise it. This action causes the #GtkToggleButton::toggled signal and the #GtkButton::clicked signal to be emitted. a #GtkToggleButton. %TRUE or %FALSE. If the user has selected a range of elements (such as some text or spreadsheet cells) that are affected by a toggle button, and the current values in that range are inconsistent, you may want to display the toggle in an “in between” state. This function turns on “in between” display. Normally you would turn off the inconsistent state again if the user toggles the toggle button. This has to be done manually, gtk_toggle_button_set_inconsistent() only affects visual appearance, it doesn’t affect the semantics of the button. a #GtkToggleButton %TRUE if state is inconsistent Sets whether the button is displayed as a separate indicator and label. You can call this function on a checkbutton or a radiobutton with @draw_indicator = %FALSE to make the button look like a normal button. This can be used to create linked strip of buttons that work like a #GtkStackSwitcher. This function only affects instances of classes like #GtkCheckButton and #GtkRadioButton that derive from #GtkToggleButton, not instances of #GtkToggleButton itself. a #GtkToggleButton if %TRUE, draw the button as a separate indicator and label; if %FALSE, draw the button like a normal button Emits the #GtkToggleButton::toggled signal on the #GtkToggleButton. There is no good reason for an application ever to call this function. a #GtkToggleButton. Should be connected if you wish to perform an action whenever the #GtkToggleButton's state is changed. a #GtkToggleButton. A #GtkToggleToolButton is a #GtkToolItem that contains a toggle button. Use gtk_toggle_tool_button_new() to create a new GtkToggleToolButton. # CSS nodes GtkToggleToolButton has a single CSS node with name togglebutton. Returns a new #GtkToggleToolButton a newly created #GtkToggleToolButton Creates a new #GtkToggleToolButton containing the image and text from a stock item. Some stock ids have preprocessor macros like #GTK_STOCK_OK and #GTK_STOCK_APPLY. It is an error if @stock_id is not a name of a stock item. Use gtk_toggle_tool_button_new() instead. A new #GtkToggleToolButton the name of the stock item Queries a #GtkToggleToolButton and returns its current state. Returns %TRUE if the toggle button is pressed in and %FALSE if it is raised. %TRUE if the toggle tool button is pressed in, %FALSE if not a #GtkToggleToolButton Sets the status of the toggle tool button. Set to %TRUE if you want the GtkToggleButton to be “pressed in”, and %FALSE to raise it. This action causes the toggled signal to be emitted. a #GtkToggleToolButton whether @button should be active If the toggle tool button should be pressed in. Emitted whenever the toggle tool button changes state. The parent class. #GtkToolButtons are #GtkToolItems containing buttons. Use gtk_tool_button_new() to create a new #GtkToolButton. The label of a #GtkToolButton is determined by the properties #GtkToolButton:label-widget, #GtkToolButton:label, and #GtkToolButton:stock-id. If #GtkToolButton:label-widget is non-%NULL, then that widget is used as the label. Otherwise, if #GtkToolButton:label is non-%NULL, that string is used as the label. Otherwise, if #GtkToolButton:stock-id is non-%NULL, the label is determined by the stock item. Otherwise, the button does not have a label. The icon of a #GtkToolButton is determined by the properties #GtkToolButton:icon-widget and #GtkToolButton:stock-id. If #GtkToolButton:icon-widget is non-%NULL, then that widget is used as the icon. Otherwise, if #GtkToolButton:stock-id is non-%NULL, the icon is determined by the stock item. Otherwise, the button does not have a icon. # CSS nodes GtkToolButton has a single CSS node with name toolbutton. Creates a new #GtkToolButton using @icon_widget as contents and @label as label. A new #GtkToolButton a widget that will be used as the button contents, or %NULL a string that will be used as label, or %NULL Creates a new #GtkToolButton containing the image and text from a stock item. Some stock ids have preprocessor macros like #GTK_STOCK_OK and #GTK_STOCK_APPLY. It is an error if @stock_id is not a name of a stock item. Use gtk_tool_button_new() together with gtk_image_new_from_icon_name() instead. A new #GtkToolButton the name of the stock item Returns the name of the themed icon for the tool button, see gtk_tool_button_set_icon_name(). the icon name or %NULL if the tool button has no themed icon a #GtkToolButton Return the widget used as icon widget on @button. See gtk_tool_button_set_icon_widget(). The widget used as icon on @button, or %NULL. a #GtkToolButton Returns the label used by the tool button, or %NULL if the tool button doesn’t have a label. or uses a the label from a stock item. The returned string is owned by GTK+, and must not be modified or freed. The label, or %NULL a #GtkToolButton Returns the widget used as label on @button. See gtk_tool_button_set_label_widget(). The widget used as label on @button, or %NULL. a #GtkToolButton Returns the name of the stock item. See gtk_tool_button_set_stock_id(). The returned string is owned by GTK+ and must not be freed or modifed. Use gtk_tool_button_get_icon_name() instead. the name of the stock item for @button. a #GtkToolButton Returns whether underscores in the label property are used as mnemonics on menu items on the overflow menu. See gtk_tool_button_set_use_underline(). %TRUE if underscores in the label property are used as mnemonics on menu items on the overflow menu. a #GtkToolButton Sets the icon for the tool button from a named themed icon. See the docs for #GtkIconTheme for more details. The #GtkToolButton:icon-name property only has an effect if not overridden by non-%NULL #GtkToolButton:label-widget, #GtkToolButton:icon-widget and #GtkToolButton:stock-id properties. a #GtkToolButton the name of the themed icon Sets @icon as the widget used as icon on @button. If @icon_widget is %NULL the icon is determined by the #GtkToolButton:stock-id property. If the #GtkToolButton:stock-id property is also %NULL, @button will not have an icon. a #GtkToolButton the widget used as icon, or %NULL Sets @label as the label used for the tool button. The #GtkToolButton:label property only has an effect if not overridden by a non-%NULL #GtkToolButton:label-widget property. If both the #GtkToolButton:label-widget and #GtkToolButton:label properties are %NULL, the label is determined by the #GtkToolButton:stock-id property. If the #GtkToolButton:stock-id property is also %NULL, @button will not have a label. a #GtkToolButton a string that will be used as label, or %NULL. Sets @label_widget as the widget that will be used as the label for @button. If @label_widget is %NULL the #GtkToolButton:label property is used as label. If #GtkToolButton:label is also %NULL, the label in the stock item determined by the #GtkToolButton:stock-id property is used as label. If #GtkToolButton:stock-id is also %NULL, @button does not have a label. a #GtkToolButton the widget used as label, or %NULL Sets the name of the stock item. See gtk_tool_button_new_from_stock(). The stock_id property only has an effect if not overridden by non-%NULL #GtkToolButton:label-widget and #GtkToolButton:icon-widget properties. Use gtk_tool_button_set_icon_name() instead. a #GtkToolButton a name of a stock item, or %NULL If set, an underline in the label property indicates that the next character should be used for the mnemonic accelerator key in the overflow menu. For example, if the label property is “_Open” and @use_underline is %TRUE, the label on the tool button will be “Open” and the item on the overflow menu will have an underlined “O”. Labels shown on tool buttons never have mnemonics on them; this property only affects the menu item on the overflow menu. a #GtkToolButton whether the button label has the form “_Open” The name of the themed icon displayed on the item. This property only has an effect if not overridden by #GtkToolButton:label-widget, #GtkToolButton:icon-widget or #GtkToolButton:stock-id properties. Use #GtkToolButton:icon-name instead. This signal is emitted when the tool button is clicked with the mouse or activated with the keyboard. The parent class. #GtkToolItems are widgets that can appear on a toolbar. To create a toolbar item that contain something else than a button, use gtk_tool_item_new(). Use gtk_container_add() to add a child widget to the tool item. For toolbar items that contain buttons, see the #GtkToolButton, #GtkToggleToolButton and #GtkRadioToolButton classes. See the #GtkToolbar class for a description of the toolbar widget, and #GtkToolShell for a description of the tool shell interface. Creates a new #GtkToolItem the new #GtkToolItem Emits the signal #GtkToolItem::toolbar_reconfigured on @tool_item. #GtkToolbar and other #GtkToolShell implementations use this function to notify children, when some aspect of their configuration changes. a #GtkToolItem Returns the ellipsize mode used for @tool_item. Custom subclasses of #GtkToolItem should call this function to find out how text should be ellipsized. a #PangoEllipsizeMode indicating how text in @tool_item should be ellipsized. a #GtkToolItem Returns whether @tool_item is allocated extra space. See gtk_tool_item_set_expand(). %TRUE if @tool_item is allocated extra space. a #GtkToolItem Returns whether @tool_item is the same size as other homogeneous items. See gtk_tool_item_set_homogeneous(). %TRUE if the item is the same size as other homogeneous items. a #GtkToolItem Returns the icon size used for @tool_item. Custom subclasses of #GtkToolItem should call this function to find out what size icons they should use. a #GtkIconSize indicating the icon size used for @tool_item a #GtkToolItem Returns whether @tool_item is considered important. See gtk_tool_item_set_is_important() %TRUE if @tool_item is considered important. a #GtkToolItem Returns the orientation used for @tool_item. Custom subclasses of #GtkToolItem should call this function to find out what size icons they should use. a #GtkOrientation indicating the orientation used for @tool_item a #GtkToolItem If @menu_item_id matches the string passed to gtk_tool_item_set_proxy_menu_item() return the corresponding #GtkMenuItem. Custom subclasses of #GtkToolItem should use this function to update their menu item when the #GtkToolItem changes. That the @menu_item_ids must match ensures that a #GtkToolItem will not inadvertently change a menu item that they did not create. The #GtkMenuItem passed to gtk_tool_item_set_proxy_menu_item(), if the @menu_item_ids match. a #GtkToolItem a string used to identify the menu item Returns the relief style of @tool_item. See gtk_button_set_relief(). Custom subclasses of #GtkToolItem should call this function in the handler of the #GtkToolItem::toolbar_reconfigured signal to find out the relief style of buttons. a #GtkReliefStyle indicating the relief style used for @tool_item. a #GtkToolItem Returns the text alignment used for @tool_item. Custom subclasses of #GtkToolItem should call this function to find out how text should be aligned. a #gfloat indicating the horizontal text alignment used for @tool_item a #GtkToolItem: Returns the text orientation used for @tool_item. Custom subclasses of #GtkToolItem should call this function to find out how text should be orientated. a #GtkOrientation indicating the text orientation used for @tool_item a #GtkToolItem Returns the size group used for labels in @tool_item. Custom subclasses of #GtkToolItem should call this function and use the size group for labels. a #GtkSizeGroup a #GtkToolItem Returns the toolbar style used for @tool_item. Custom subclasses of #GtkToolItem should call this function in the handler of the GtkToolItem::toolbar_reconfigured signal to find out in what style the toolbar is displayed and change themselves accordingly Possibilities are: - %GTK_TOOLBAR_BOTH, meaning the tool item should show both an icon and a label, stacked vertically - %GTK_TOOLBAR_ICONS, meaning the toolbar shows only icons - %GTK_TOOLBAR_TEXT, meaning the tool item should only show text - %GTK_TOOLBAR_BOTH_HORIZ, meaning the tool item should show both an icon and a label, arranged horizontally A #GtkToolbarStyle indicating the toolbar style used for @tool_item. a #GtkToolItem Returns whether @tool_item has a drag window. See gtk_tool_item_set_use_drag_window(). %TRUE if @tool_item uses a drag window. a #GtkToolItem Returns whether the @tool_item is visible on toolbars that are docked horizontally. %TRUE if @tool_item is visible on toolbars that are docked horizontally. a #GtkToolItem Returns whether @tool_item is visible when the toolbar is docked vertically. See gtk_tool_item_set_visible_vertical(). Whether @tool_item is visible when the toolbar is docked vertically a #GtkToolItem Calling this function signals to the toolbar that the overflow menu item for @tool_item has changed. If the overflow menu is visible when this function it called, the menu will be rebuilt. The function must be called when the tool item changes what it will do in response to the #GtkToolItem::create-menu-proxy signal. a #GtkToolItem Returns the #GtkMenuItem that was last set by gtk_tool_item_set_proxy_menu_item(), ie. the #GtkMenuItem that is going to appear in the overflow menu. The #GtkMenuItem that is going to appear in the overflow menu for @tool_item. a #GtkToolItem Sets whether @tool_item is allocated extra space when there is more room on the toolbar then needed for the items. The effect is that the item gets bigger when the toolbar gets bigger and smaller when the toolbar gets smaller. a #GtkToolItem Whether @tool_item is allocated extra space Sets whether @tool_item is to be allocated the same size as other homogeneous items. The effect is that all homogeneous items will have the same width as the widest of the items. a #GtkToolItem whether @tool_item is the same size as other homogeneous items Sets whether @tool_item should be considered important. The #GtkToolButton class uses this property to determine whether to show or hide its label when the toolbar style is %GTK_TOOLBAR_BOTH_HORIZ. The result is that only tool buttons with the “is_important” property set have labels, an effect known as “priority text” a #GtkToolItem whether the tool item should be considered important Sets the #GtkMenuItem used in the toolbar overflow menu. The @menu_item_id is used to identify the caller of this function and should also be used with gtk_tool_item_get_proxy_menu_item(). See also #GtkToolItem::create-menu-proxy. a #GtkToolItem a string used to identify @menu_item a #GtkMenuItem to use in the overflow menu, or %NULL Sets the markup text to be displayed as tooltip on the item. See gtk_widget_set_tooltip_markup(). a #GtkToolItem markup text to be used as tooltip for @tool_item Sets the text to be displayed as tooltip on the item. See gtk_widget_set_tooltip_text(). a #GtkToolItem text to be used as tooltip for @tool_item Sets whether @tool_item has a drag window. When %TRUE the toolitem can be used as a drag source through gtk_drag_source_set(). When @tool_item has a drag window it will intercept all events, even those that would otherwise be sent to a child of @tool_item. a #GtkToolItem Whether @tool_item has a drag window. Sets whether @tool_item is visible when the toolbar is docked horizontally. a #GtkToolItem Whether @tool_item is visible when in horizontal mode Sets whether @tool_item is visible when the toolbar is docked vertically. Some tool items, such as text entries, are too wide to be useful on a vertically docked toolbar. If @visible_vertical is %FALSE @tool_item will not appear on toolbars that are docked vertically. a #GtkToolItem whether @tool_item is visible when the toolbar is in vertical mode Emits the signal #GtkToolItem::toolbar_reconfigured on @tool_item. #GtkToolbar and other #GtkToolShell implementations use this function to notify children, when some aspect of their configuration changes. a #GtkToolItem This signal is emitted when the toolbar needs information from @tool_item about whether the item should appear in the toolbar overflow menu. In response the tool item should either - call gtk_tool_item_set_proxy_menu_item() with a %NULL pointer and return %TRUE to indicate that the item should not appear in the overflow menu - call gtk_tool_item_set_proxy_menu_item() with a new menu item and return %TRUE, or - return %FALSE to indicate that the signal was not handled by the item. This means that the item will not appear in the overflow menu unless a later handler installs a menu item. The toolbar may cache the result of this signal. When the tool item changes how it will respond to this signal it must call gtk_tool_item_rebuild_menu() to invalidate the cache and ensure that the toolbar rebuilds its overflow menu. %TRUE if the signal was handled, %FALSE if not This signal is emitted when some property of the toolbar that the item is a child of changes. For custom subclasses of #GtkToolItem, the default handler of this signal use the functions - gtk_tool_shell_get_orientation() - gtk_tool_shell_get_style() - gtk_tool_shell_get_icon_size() - gtk_tool_shell_get_relief_style() to find out what the toolbar should look like and change themselves accordingly. The parent class. a #GtkToolItem A #GtkToolItemGroup is used together with #GtkToolPalette to add #GtkToolItems to a palette like container with different categories and drag and drop support. # CSS nodes GtkToolItemGroup has a single CSS node named toolitemgroup. Creates a new tool item group with label @label. a new #GtkToolItemGroup. the label of the new group Gets whether @group is collapsed or expanded. %TRUE if @group is collapsed, %FALSE if it is expanded a GtkToolItemGroup Gets the tool item at position (x, y). the #GtkToolItem at position (x, y) a #GtkToolItemGroup the x position the y position Gets the ellipsization mode of @group. the #PangoEllipsizeMode of @group a #GtkToolItemGroup Gets the relief mode of the header button of @group. the #GtkReliefStyle a #GtkToolItemGroup Gets the position of @item in @group as index. the index of @item in @group or -1 if @item is no child of @group a #GtkToolItemGroup a #GtkToolItem Gets the label of @group. the label of @group. The label is an internal string of @group and must not be modified. Note that %NULL is returned if a custom label has been set with gtk_tool_item_group_set_label_widget() a #GtkToolItemGroup Gets the label widget of @group. See gtk_tool_item_group_set_label_widget(). the label widget of @group a #GtkToolItemGroup Gets the number of tool items in @group. the number of tool items in @group a #GtkToolItemGroup Gets the tool item at @index in group. the #GtkToolItem at index a #GtkToolItemGroup the index Inserts @item at @position in the list of children of @group. a #GtkToolItemGroup the #GtkToolItem to insert into @group the position of @item in @group, starting with 0. The position -1 means end of list. Sets whether the @group should be collapsed or expanded. a #GtkToolItemGroup whether the @group should be collapsed or expanded Sets the ellipsization mode which should be used by labels in @group. a #GtkToolItemGroup the #PangoEllipsizeMode labels in @group should use Set the button relief of the group header. See gtk_button_set_relief() for details. a #GtkToolItemGroup the #GtkReliefStyle Sets the position of @item in the list of children of @group. a #GtkToolItemGroup the #GtkToolItem to move to a new position, should be a child of @group. the new position of @item in @group, starting with 0. The position -1 means end of list. Sets the label of the tool item group. The label is displayed in the header of the group. a #GtkToolItemGroup the new human-readable label of of the group Sets the label of the tool item group. The label widget is displayed in the header of the group, in place of the usual label. a #GtkToolItemGroup the widget to be displayed in place of the usual label The parent class. A #GtkToolPalette allows you to add #GtkToolItems to a palette-like container with different categories and drag and drop support. A #GtkToolPalette is created with a call to gtk_tool_palette_new(). #GtkToolItems cannot be added directly to a #GtkToolPalette - instead they are added to a #GtkToolItemGroup which can than be added to a #GtkToolPalette. To add a #GtkToolItemGroup to a #GtkToolPalette, use gtk_container_add(). |[<!-- language="C" --> GtkWidget *palette, *group; GtkToolItem *item; palette = gtk_tool_palette_new (); group = gtk_tool_item_group_new (_("Test Category")); gtk_container_add (GTK_CONTAINER (palette), group); item = gtk_tool_button_new (NULL, _("_Open")); gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (item), "document-open"); gtk_tool_item_group_insert (GTK_TOOL_ITEM_GROUP (group), item, -1); ]| The easiest way to use drag and drop with #GtkToolPalette is to call gtk_tool_palette_add_drag_dest() with the desired drag source @palette and the desired drag target @widget. Then gtk_tool_palette_get_drag_item() can be used to get the dragged item in the #GtkWidget::drag-data-received signal handler of the drag target. |[<!-- language="C" --> static void passive_canvas_drag_data_received (GtkWidget *widget, GdkDragContext *context, gint x, gint y, GtkSelectionData *selection, guint info, guint time, gpointer data) { GtkWidget *palette; GtkWidget *item; // Get the dragged item palette = gtk_widget_get_ancestor (gtk_drag_get_source_widget (context), GTK_TYPE_TOOL_PALETTE); if (palette != NULL) item = gtk_tool_palette_get_drag_item (GTK_TOOL_PALETTE (palette), selection); // Do something with item } GtkWidget *target, palette; palette = gtk_tool_palette_new (); target = gtk_drawing_area_new (); g_signal_connect (G_OBJECT (target), "drag-data-received", G_CALLBACK (passive_canvas_drag_data_received), NULL); gtk_tool_palette_add_drag_dest (GTK_TOOL_PALETTE (palette), target, GTK_DEST_DEFAULT_ALL, GTK_TOOL_PALETTE_DRAG_ITEMS, GDK_ACTION_COPY); ]| # CSS nodes GtkToolPalette has a single CSS node named toolpalette. Creates a new tool palette. a new #GtkToolPalette Get the target entry for a dragged #GtkToolItemGroup. the #GtkTargetEntry for a dragged group Gets the target entry for a dragged #GtkToolItem. the #GtkTargetEntry for a dragged item. Sets @palette as drag source (see gtk_tool_palette_set_drag_source()) and sets @widget as a drag destination for drags from @palette. See gtk_drag_dest_set(). a #GtkToolPalette a #GtkWidget which should be a drag destination for @palette the flags that specify what actions GTK+ should take for drops on that widget the #GtkToolPaletteDragTargets which the widget should support the #GdkDragActions which the widget should suppport Get the dragged item from the selection. This could be a #GtkToolItem or a #GtkToolItemGroup. the dragged item in selection a #GtkToolPalette a #GtkSelectionData Gets the group at position (x, y). the #GtkToolItemGroup at position or %NULL if there is no such group a #GtkToolPalette the x position the y position Gets the item at position (x, y). See gtk_tool_palette_get_drop_group(). the #GtkToolItem at position or %NULL if there is no such item a #GtkToolPalette the x position the y position Gets whether @group is exclusive or not. See gtk_tool_palette_set_exclusive(). %TRUE if @group is exclusive a #GtkToolPalette a #GtkToolItemGroup which is a child of palette Gets whether group should be given extra space. See gtk_tool_palette_set_expand(). %TRUE if group should be given extra space, %FALSE otherwise a #GtkToolPalette a #GtkToolItemGroup which is a child of palette Gets the position of @group in @palette as index. See gtk_tool_palette_set_group_position(). the index of group or -1 if @group is not a child of @palette a #GtkToolPalette a #GtkToolItemGroup Gets the horizontal adjustment of the tool palette. Use gtk_scrollable_get_hadjustment() the horizontal adjustment of @palette a #GtkToolPalette Gets the size of icons in the tool palette. See gtk_tool_palette_set_icon_size(). the #GtkIconSize of icons in the tool palette a #GtkToolPalette Gets the style (icons, text or both) of items in the tool palette. the #GtkToolbarStyle of items in the tool palette. a #GtkToolPalette Gets the vertical adjustment of the tool palette. Use gtk_scrollable_get_vadjustment() the vertical adjustment of @palette a #GtkToolPalette Sets the tool palette as a drag source. Enables all groups and items in the tool palette as drag sources on button 1 and button 3 press with copy and move actions. See gtk_drag_source_set(). a #GtkToolPalette the #GtkToolPaletteDragTargets which the widget should support Sets whether the group should be exclusive or not. If an exclusive group is expanded all other groups are collapsed. a #GtkToolPalette a #GtkToolItemGroup which is a child of palette whether the group should be exclusive or not Sets whether the group should be given extra space. a #GtkToolPalette a #GtkToolItemGroup which is a child of palette whether the group should be given extra space Sets the position of the group as an index of the tool palette. If position is 0 the group will become the first child, if position is -1 it will become the last child. a #GtkToolPalette a #GtkToolItemGroup which is a child of palette a new index for group Sets the size of icons in the tool palette. a #GtkToolPalette the #GtkIconSize that icons in the tool palette shall have Sets the style (text, icons or both) of items in the tool palette. a #GtkToolPalette the #GtkToolbarStyle that items in the tool palette shall have Unsets the tool palette icon size set with gtk_tool_palette_set_icon_size(), so that user preferences will be used to determine the icon size. a #GtkToolPalette Unsets a toolbar style set with gtk_tool_palette_set_style(), so that user preferences will be used to determine the toolbar style. a #GtkToolPalette The size of the icons in a tool palette. When this property is set, it overrides the default setting. This should only be used for special-purpose tool palettes, normal application tool palettes should respect the user preferences for the size of icons. Is %TRUE if the #GtkToolPalette:icon-size property has been set. The style of items in the tool palette. The parent class. Flags used to specify the supported drag targets. Support drag of items. Support drag of groups. The #GtkToolShell interface allows container widgets to provide additional information when embedding #GtkToolItem widgets. Retrieves the current ellipsize mode for the tool shell. Tool items must not call this function directly, but rely on gtk_tool_item_get_ellipsize_mode() instead. the current ellipsize mode of @shell a #GtkToolShell Retrieves the current orientation for the tool shell. Tool items must not call this function directly, but rely on gtk_tool_item_get_orientation() instead. the current orientation of @shell a #GtkToolShell Returns the relief style of buttons on @shell. Tool items must not call this function directly, but rely on gtk_tool_item_get_relief_style() instead. The relief style of buttons on @shell. a #GtkToolShell Retrieves whether the tool shell has text, icons, or both. Tool items must not call this function directly, but rely on gtk_tool_item_get_toolbar_style() instead. the current style of @shell a #GtkToolShell Retrieves the current text alignment for the tool shell. Tool items must not call this function directly, but rely on gtk_tool_item_get_text_alignment() instead. the current text alignment of @shell a #GtkToolShell Retrieves the current text orientation for the tool shell. Tool items must not call this function directly, but rely on gtk_tool_item_get_text_orientation() instead. the current text orientation of @shell a #GtkToolShell Retrieves the current text size group for the tool shell. Tool items must not call this function directly, but rely on gtk_tool_item_get_text_size_group() instead. the current text size group of @shell a #GtkToolShell Calling this function signals the tool shell that the overflow menu item for tool items have changed. If there is an overflow menu and if it is visible when this function it called, the menu will be rebuilt. Tool items must not call this function directly, but rely on gtk_tool_item_rebuild_menu() instead. a #GtkToolShell Retrieves the current ellipsize mode for the tool shell. Tool items must not call this function directly, but rely on gtk_tool_item_get_ellipsize_mode() instead. the current ellipsize mode of @shell a #GtkToolShell Retrieves the icon size for the tool shell. Tool items must not call this function directly, but rely on gtk_tool_item_get_icon_size() instead. the current size (#GtkIconSize) for icons of @shell a #GtkToolShell Retrieves the current orientation for the tool shell. Tool items must not call this function directly, but rely on gtk_tool_item_get_orientation() instead. the current orientation of @shell a #GtkToolShell Returns the relief style of buttons on @shell. Tool items must not call this function directly, but rely on gtk_tool_item_get_relief_style() instead. The relief style of buttons on @shell. a #GtkToolShell Retrieves whether the tool shell has text, icons, or both. Tool items must not call this function directly, but rely on gtk_tool_item_get_toolbar_style() instead. the current style of @shell a #GtkToolShell Retrieves the current text alignment for the tool shell. Tool items must not call this function directly, but rely on gtk_tool_item_get_text_alignment() instead. the current text alignment of @shell a #GtkToolShell Retrieves the current text orientation for the tool shell. Tool items must not call this function directly, but rely on gtk_tool_item_get_text_orientation() instead. the current text orientation of @shell a #GtkToolShell Retrieves the current text size group for the tool shell. Tool items must not call this function directly, but rely on gtk_tool_item_get_text_size_group() instead. the current text size group of @shell a #GtkToolShell Calling this function signals the tool shell that the overflow menu item for tool items have changed. If there is an overflow menu and if it is visible when this function it called, the menu will be rebuilt. Tool items must not call this function directly, but rely on gtk_tool_item_rebuild_menu() instead. a #GtkToolShell Virtual function table for the #GtkToolShell interface. the current orientation of @shell a #GtkToolShell the current style of @shell a #GtkToolShell The relief style of buttons on @shell. a #GtkToolShell a #GtkToolShell the current text orientation of @shell a #GtkToolShell the current text alignment of @shell a #GtkToolShell the current ellipsize mode of @shell a #GtkToolShell the current text size group of @shell a #GtkToolShell A toolbar is created with a call to gtk_toolbar_new(). A toolbar can contain instances of a subclass of #GtkToolItem. To add a #GtkToolItem to the a toolbar, use gtk_toolbar_insert(). To remove an item from the toolbar use gtk_container_remove(). To add a button to the toolbar, add an instance of #GtkToolButton. Toolbar items can be visually grouped by adding instances of #GtkSeparatorToolItem to the toolbar. If the GtkToolbar child property “expand” is #TRUE and the property #GtkSeparatorToolItem:draw is set to #FALSE, the effect is to force all following items to the end of the toolbar. By default, a toolbar can be shrunk, upon which it will add an arrow button to show an overflow menu offering access to any #GtkToolItem child that has a proxy menu item. To disable this and request enough size for all children, call gtk_toolbar_set_show_arrow() to set #GtkToolbar:show-arrow to %FALSE. Creating a context menu for the toolbar can be done by connecting to the #GtkToolbar::popup-context-menu signal. # CSS nodes GtkToolbar has a single CSS node with name toolbar. Creates a new toolbar. the newly-created toolbar. Returns the position corresponding to the indicated point on @toolbar. This is useful when dragging items to the toolbar: this function returns the position a new item should be inserted. @x and @y are in @toolbar coordinates. The position corresponding to the point (@x, @y) on the toolbar. a #GtkToolbar x coordinate of a point on the toolbar y coordinate of a point on the toolbar Retrieves the icon size for the toolbar. See gtk_toolbar_set_icon_size(). the current icon size for the icons on the toolbar. a #GtkToolbar Returns the position of @item on the toolbar, starting from 0. It is an error if @item is not a child of the toolbar. the position of item on the toolbar. a #GtkToolbar a #GtkToolItem that is a child of @toolbar Returns the number of items on the toolbar. the number of items on the toolbar a #GtkToolbar Returns the @n'th item on @toolbar, or %NULL if the toolbar does not contain an @n'th item. The @n'th #GtkToolItem on @toolbar, or %NULL if there isn’t an @n'th item. a #GtkToolbar A position on the toolbar Returns the relief style of buttons on @toolbar. See gtk_button_set_relief(). The relief style of buttons on @toolbar. a #GtkToolbar Returns whether the toolbar has an overflow menu. See gtk_toolbar_set_show_arrow(). %TRUE if the toolbar has an overflow menu. a #GtkToolbar Retrieves whether the toolbar has text, icons, or both . See gtk_toolbar_set_style(). the current style of @toolbar a #GtkToolbar Insert a #GtkToolItem into the toolbar at position @pos. If @pos is 0 the item is prepended to the start of the toolbar. If @pos is negative, the item is appended to the end of the toolbar. a #GtkToolbar a #GtkToolItem the position of the new item Highlights @toolbar to give an idea of what it would look like if @item was added to @toolbar at the position indicated by @index_. If @item is %NULL, highlighting is turned off. In that case @index_ is ignored. The @tool_item passed to this function must not be part of any widget hierarchy. When an item is set as drop highlight item it can not added to any widget hierarchy or used as highlight item for another toolbar. a #GtkToolbar a #GtkToolItem, or %NULL to turn of highlighting a position on @toolbar This function sets the size of stock icons in the toolbar. You can call it both before you add the icons and after they’ve been added. The size you set will override user preferences for the default icon size. This should only be used for special-purpose toolbars, normal application toolbars should respect the user preferences for the size of icons. A #GtkToolbar The #GtkIconSize that stock icons in the toolbar shall have. Sets whether to show an overflow menu when @toolbar isn’t allocated enough size to show all of its items. If %TRUE, items which can’t fit in @toolbar, and which have a proxy menu item set by gtk_tool_item_set_proxy_menu_item() or #GtkToolItem::create-menu-proxy, will be available in an overflow menu, which can be opened by an added arrow button. If %FALSE, @toolbar will request enough size to fit all of its child items without any overflow. a #GtkToolbar Whether to show an overflow menu Alters the view of @toolbar to display either icons only, text only, or both. a #GtkToolbar. the new style for @toolbar. Unsets toolbar icon size set with gtk_toolbar_set_icon_size(), so that user preferences will be used to determine the icon size. a #GtkToolbar Unsets a toolbar style set with gtk_toolbar_set_style(), so that user preferences will be used to determine the toolbar style. a #GtkToolbar The size of the icons in a toolbar is normally determined by the toolbar-icon-size setting. When this property is set, it overrides the setting. This should only be used for special-purpose toolbars, normal application toolbars should respect the user preferences for the size of icons. Is %TRUE if the icon-size property has been set. A keybinding signal used internally by GTK+. This signal can't be used in application code %TRUE if the signal was handled, %FALSE if not %TRUE if the first item should be focused Emitted when the orientation of the toolbar changes. the new #GtkOrientation of the toolbar Emitted when the user right-clicks the toolbar or uses the keybinding to display a popup menu. Application developers should handle this signal if they want to display a context menu on the toolbar. The context-menu should appear at the coordinates given by @x and @y. The mouse button number is given by the @button parameter. If the menu was popped up using the keybaord, @button is -1. return %TRUE if the signal was handled, %FALSE if not the x coordinate of the point where the menu should appear the y coordinate of the point where the menu should appear the mouse button the user pressed, or -1 Emitted when the style of the toolbar changes. the new #GtkToolbarStyle of the toolbar Whether spacers are vertical lines or just blank. Use blank spacers. Use vertical lines for spacers. Used to customize the appearance of a #GtkToolbar. Note that setting the toolbar style overrides the user’s preferences for the default toolbar style. Note that if the button has only a label set and GTK_TOOLBAR_ICONS is used, the label will be visible, and vice versa. Buttons display only icons in the toolbar. Buttons display only text labels in the toolbar. Buttons display text and icons in the toolbar. Buttons display icons and text alongside each other, rather than vertically stacked Basic tooltips can be realized simply by using gtk_widget_set_tooltip_text() or gtk_widget_set_tooltip_markup() without any explicit tooltip object. When you need a tooltip with a little more fancy contents, like adding an image, or you want the tooltip to have different contents per #GtkTreeView row or cell, you will have to do a little more work: - Set the #GtkWidget:has-tooltip property to %TRUE, this will make GTK+ monitor the widget for motion and related events which are needed to determine when and where to show a tooltip. - Connect to the #GtkWidget::query-tooltip signal. This signal will be emitted when a tooltip is supposed to be shown. One of the arguments passed to the signal handler is a GtkTooltip object. This is the object that we are about to display as a tooltip, and can be manipulated in your callback using functions like gtk_tooltip_set_icon(). There are functions for setting the tooltip’s markup, setting an image from a named icon, or even putting in a custom widget. Return %TRUE from your query-tooltip handler. This causes the tooltip to be show. If you return %FALSE, it will not be shown. In the probably rare case where you want to have even more control over the tooltip that is about to be shown, you can set your own #GtkWindow which will be used as tooltip window. This works as follows: - Set #GtkWidget:has-tooltip and connect to #GtkWidget::query-tooltip as before. Use gtk_widget_set_tooltip_window() to set a #GtkWindow created by you as tooltip window. - In the #GtkWidget::query-tooltip callback you can access your window using gtk_widget_get_tooltip_window() and manipulate as you wish. The semantics of the return value are exactly as before, return %TRUE to show the window, %FALSE to not show it. Triggers a new tooltip query on @display, in order to update the current visible tooltip, or to show/hide the current tooltip. This function is useful to call when, for example, the state of the widget changed by a key press. a #GdkDisplay Replaces the widget packed into the tooltip with @custom_widget. @custom_widget does not get destroyed when the tooltip goes away. By default a box with a #GtkImage and #GtkLabel is embedded in the tooltip, which can be configured using gtk_tooltip_set_markup() and gtk_tooltip_set_icon(). a #GtkTooltip a #GtkWidget, or %NULL to unset the old custom widget. Sets the icon of the tooltip (which is in front of the text) to be @pixbuf. If @pixbuf is %NULL, the image will be hidden. a #GtkTooltip a #GdkPixbuf, or %NULL Sets the icon of the tooltip (which is in front of the text) to be the icon indicated by @gicon with the size indicated by @size. If @gicon is %NULL, the image will be hidden. a #GtkTooltip a #GIcon representing the icon, or %NULL a stock icon size (#GtkIconSize) Sets the icon of the tooltip (which is in front of the text) to be the icon indicated by @icon_name with the size indicated by @size. If @icon_name is %NULL, the image will be hidden. a #GtkTooltip an icon name, or %NULL a stock icon size (#GtkIconSize) Sets the icon of the tooltip (which is in front of the text) to be the stock item indicated by @stock_id with the size indicated by @size. If @stock_id is %NULL, the image will be hidden. Use gtk_tooltip_set_icon_from_icon_name() instead. a #GtkTooltip a stock id, or %NULL a stock icon size (#GtkIconSize) Sets the text of the tooltip to be @markup, which is marked up with the [Pango text markup language][PangoMarkupFormat]. If @markup is %NULL, the label will be hidden. a #GtkTooltip a markup string (see [Pango markup format][PangoMarkupFormat]) or %NULL Sets the text of the tooltip to be @text. If @text is %NULL, the label will be hidden. See also gtk_tooltip_set_markup(). a #GtkTooltip a text string or %NULL Sets the area of the widget, where the contents of this tooltip apply, to be @rect (in widget coordinates). This is especially useful for properly setting tooltips on #GtkTreeView rows and cells, #GtkIconViews, etc. For setting tooltips on #GtkTreeView, please refer to the convenience functions for this: gtk_tree_view_set_tooltip_row() and gtk_tree_view_set_tooltip_cell(). a #GtkTooltip a #GdkRectangle List of children. The function used to translate messages in e.g. #GtkIconFactory and #GtkActionGroup. the translated message The id of the message. In #GtkActionGroup this will be a label or tooltip from a #GtkActionEntry. user data passed in when registering the function A function to set the properties of a cell instead of just using the straight mapping between the cell and the model. This is useful for customizing the cell renderer. For example, a function might get an integer from the @tree_model, and render it to the “text” attribute of “cell” by converting it to its written equivalent. This is set by calling gtk_tree_view_column_set_cell_data_func() A #GtkTreeViewColumn The #GtkCellRenderer that is being rendered by @tree_column The #GtkTreeModel being rendered A #GtkTreeIter of the current row rendered user data Asks the #GtkTreeDragDest to insert a row before the path @dest, deriving the contents of the row from @selection_data. If @dest is outside the tree so that inserting before it is impossible, %FALSE will be returned. Also, %FALSE may be returned if the new row is not created for some model-specific reason. Should robustly handle a @dest no longer found in the model! whether a new row was created before position @dest a #GtkTreeDragDest row to drop in front of data to drop Determines whether a drop is possible before the given @dest_path, at the same depth as @dest_path. i.e., can we drop the data in @selection_data at that location. @dest_path does not have to exist; the return value will almost certainly be %FALSE if the parent of @dest_path doesn’t exist, though. %TRUE if a drop is possible before @dest_path a #GtkTreeDragDest destination row the data being dragged Asks the #GtkTreeDragDest to insert a row before the path @dest, deriving the contents of the row from @selection_data. If @dest is outside the tree so that inserting before it is impossible, %FALSE will be returned. Also, %FALSE may be returned if the new row is not created for some model-specific reason. Should robustly handle a @dest no longer found in the model! whether a new row was created before position @dest a #GtkTreeDragDest row to drop in front of data to drop Determines whether a drop is possible before the given @dest_path, at the same depth as @dest_path. i.e., can we drop the data in @selection_data at that location. @dest_path does not have to exist; the return value will almost certainly be %FALSE if the parent of @dest_path doesn’t exist, though. %TRUE if a drop is possible before @dest_path a #GtkTreeDragDest destination row the data being dragged whether a new row was created before position @dest a #GtkTreeDragDest row to drop in front of data to drop %TRUE if a drop is possible before @dest_path a #GtkTreeDragDest destination row the data being dragged Asks the #GtkTreeDragSource to delete the row at @path, because it was moved somewhere else via drag-and-drop. Returns %FALSE if the deletion fails because @path no longer exists, or for some model-specific reason. Should robustly handle a @path no longer found in the model! %TRUE if the row was successfully deleted a #GtkTreeDragSource row that was being dragged Asks the #GtkTreeDragSource to fill in @selection_data with a representation of the row at @path. @selection_data->target gives the required type of the data. Should robustly handle a @path no longer found in the model! %TRUE if data of the required type was provided a #GtkTreeDragSource row that was dragged a #GtkSelectionData to fill with data from the dragged row Asks the #GtkTreeDragSource whether a particular row can be used as the source of a DND operation. If the source doesn’t implement this interface, the row is assumed draggable. %TRUE if the row can be dragged a #GtkTreeDragSource row on which user is initiating a drag Asks the #GtkTreeDragSource to delete the row at @path, because it was moved somewhere else via drag-and-drop. Returns %FALSE if the deletion fails because @path no longer exists, or for some model-specific reason. Should robustly handle a @path no longer found in the model! %TRUE if the row was successfully deleted a #GtkTreeDragSource row that was being dragged Asks the #GtkTreeDragSource to fill in @selection_data with a representation of the row at @path. @selection_data->target gives the required type of the data. Should robustly handle a @path no longer found in the model! %TRUE if data of the required type was provided a #GtkTreeDragSource row that was dragged a #GtkSelectionData to fill with data from the dragged row Asks the #GtkTreeDragSource whether a particular row can be used as the source of a DND operation. If the source doesn’t implement this interface, the row is assumed draggable. %TRUE if the row can be dragged a #GtkTreeDragSource row on which user is initiating a drag %TRUE if the row can be dragged a #GtkTreeDragSource row on which user is initiating a drag %TRUE if data of the required type was provided a #GtkTreeDragSource row that was dragged a #GtkSelectionData to fill with data from the dragged row %TRUE if the row was successfully deleted a #GtkTreeDragSource row that was being dragged The #GtkTreeIter is the primary structure for accessing a #GtkTreeModel. Models are expected to put a unique integer in the @stamp member, and put model-specific data in the three @user_data members. a unique stamp to catch invalid iterators model-specific data model-specific data model-specific data Creates a dynamically allocated tree iterator as a copy of @iter. This function is not intended for use in applications, because you can just copy the structs by value (`GtkTreeIter new_iter = iter;`). You must free this iter with gtk_tree_iter_free(). a newly-allocated copy of @iter a #GtkTreeIter-struct Frees an iterator that has been allocated by gtk_tree_iter_copy(). This function is mainly used for language bindings. a dynamically allocated tree iterator A GtkTreeIterCompareFunc should return a negative integer, zero, or a positive integer if @a sorts before @b, @a sorts with @b, or @a sorts after @b respectively. If two iters compare as equal, their order in the sorted model is undefined. In order to ensure that the #GtkTreeSortable behaves as expected, the GtkTreeIterCompareFunc must define a partial order on the model, i.e. it must be reflexive, antisymmetric and transitive. For example, if @model is a product catalogue, then a compare function for the “price” column could be one which returns `price_of(@a) - price_of(@b)`. a negative integer, zero or a positive integer depending on whether @a sorts before, with or after @b The #GtkTreeModel the comparison is within A #GtkTreeIter in @model Another #GtkTreeIter in @model Data passed when the compare func is assigned e.g. by gtk_tree_sortable_set_sort_func() The #GtkTreeModel interface defines a generic tree interface for use by the #GtkTreeView widget. It is an abstract interface, and is designed to be usable with any appropriate data structure. The programmer just has to implement this interface on their own data type for it to be viewable by a #GtkTreeView widget. The model is represented as a hierarchical tree of strongly-typed, columned data. In other words, the model can be seen as a tree where every node has different values depending on which column is being queried. The type of data found in a column is determined by using the GType system (ie. #G_TYPE_INT, #GTK_TYPE_BUTTON, #G_TYPE_POINTER, etc). The types are homogeneous per column across all nodes. It is important to note that this interface only provides a way of examining a model and observing changes. The implementation of each individual model decides how and if changes are made. In order to make life simpler for programmers who do not need to write their own specialized model, two generic models are provided — the #GtkTreeStore and the #GtkListStore. To use these, the developer simply pushes data into these models as necessary. These models provide the data structure as well as all appropriate tree interfaces. As a result, implementing drag and drop, sorting, and storing data is trivial. For the vast majority of trees and lists, these two models are sufficient. Models are accessed on a node/column level of granularity. One can query for the value of a model at a certain node and a certain column on that node. There are two structures used to reference a particular node in a model. They are the #GtkTreePath-struct and the #GtkTreeIter-struct (“iter” is short for iterator). Most of the interface consists of operations on a #GtkTreeIter-struct. A path is essentially a potential node. It is a location on a model that may or may not actually correspond to a node on a specific model. The #GtkTreePath-struct can be converted into either an array of unsigned integers or a string. The string form is a list of numbers separated by a colon. Each number refers to the offset at that level. Thus, the path `0` refers to the root node and the path `2:4` refers to the fifth child of the third node. By contrast, a #GtkTreeIter-struct is a reference to a specific node on a specific model. It is a generic struct with an integer and three generic pointers. These are filled in by the model in a model-specific way. One can convert a path to an iterator by calling gtk_tree_model_get_iter(). These iterators are the primary way of accessing a model and are similar to the iterators used by #GtkTextBuffer. They are generally statically allocated on the stack and only used for a short time. The model interface defines a set of operations using them for navigating the model. It is expected that models fill in the iterator with private data. For example, the #GtkListStore model, which is internally a simple linked list, stores a list node in one of the pointers. The #GtkTreeModelSort stores an array and an offset in two of the pointers. Additionally, there is an integer field. This field is generally filled with a unique stamp per model. This stamp is for catching errors resulting from using invalid iterators with a model. The lifecycle of an iterator can be a little confusing at first. Iterators are expected to always be valid for as long as the model is unchanged (and doesn’t emit a signal). The model is considered to own all outstanding iterators and nothing needs to be done to free them from the user’s point of view. Additionally, some models guarantee that an iterator is valid for as long as the node it refers to is valid (most notably the #GtkTreeStore and #GtkListStore). Although generally uninteresting, as one always has to allow for the case where iterators do not persist beyond a signal, some very important performance enhancements were made in the sort model. As a result, the #GTK_TREE_MODEL_ITERS_PERSIST flag was added to indicate this behavior. To help show some common operation of a model, some examples are provided. The first example shows three ways of getting the iter at the location `3:2:5`. While the first method shown is easier, the second is much more common, as you often get paths from callbacks. ## Acquiring a #GtkTreeIter-struct |[<!-- language="C" --> // Three ways of getting the iter pointing to the location GtkTreePath *path; GtkTreeIter iter; GtkTreeIter parent_iter; // get the iterator from a string gtk_tree_model_get_iter_from_string (model, &iter, "3:2:5"); // get the iterator from a path path = gtk_tree_path_new_from_string ("3:2:5"); gtk_tree_model_get_iter (model, &iter, path); gtk_tree_path_free (path); // walk the tree to find the iterator gtk_tree_model_iter_nth_child (model, &iter, NULL, 3); parent_iter = iter; gtk_tree_model_iter_nth_child (model, &iter, &parent_iter, 2); parent_iter = iter; gtk_tree_model_iter_nth_child (model, &iter, &parent_iter, 5); ]| This second example shows a quick way of iterating through a list and getting a string and an integer from each row. The populate_model() function used below is not shown, as it is specific to the #GtkListStore. For information on how to write such a function, see the #GtkListStore documentation. ## Reading data from a #GtkTreeModel |[<!-- language="C" --> enum { STRING_COLUMN, INT_COLUMN, N_COLUMNS }; ... GtkTreeModel *list_store; GtkTreeIter iter; gboolean valid; gint row_count = 0; // make a new list_store list_store = gtk_list_store_new (N_COLUMNS, G_TYPE_STRING, G_TYPE_INT); // Fill the list store with data populate_model (list_store); // Get the first iter in the list, check it is valid and walk // through the list, reading each row. valid = gtk_tree_model_get_iter_first (list_store, &iter); while (valid) { gchar *str_data; gint int_data; // Make sure you terminate calls to gtk_tree_model_get() with a “-1” value gtk_tree_model_get (list_store, &iter, STRING_COLUMN, &str_data, INT_COLUMN, &int_data, -1); // Do something with the data g_print ("Row %d: (%s,%d)\n", row_count, str_data, int_data); g_free (str_data); valid = gtk_tree_model_iter_next (list_store, &iter); row_count++; } ]| The #GtkTreeModel interface contains two methods for reference counting: gtk_tree_model_ref_node() and gtk_tree_model_unref_node(). These two methods are optional to implement. The reference counting is meant as a way for views to let models know when nodes are being displayed. #GtkTreeView will take a reference on a node when it is visible, which means the node is either in the toplevel or expanded. Being displayed does not mean that the node is currently directly visible to the user in the viewport. Based on this reference counting scheme a caching model, for example, can decide whether or not to cache a node based on the reference count. A file-system based model would not want to keep the entire file hierarchy in memory, but just the folders that are currently expanded in every current view. When working with reference counting, the following rules must be taken into account: - Never take a reference on a node without owning a reference on its parent. This means that all parent nodes of a referenced node must be referenced as well. - Outstanding references on a deleted node are not released. This is not possible because the node has already been deleted by the time the row-deleted signal is received. - Models are not obligated to emit a signal on rows of which none of its siblings are referenced. To phrase this differently, signals are only required for levels in which nodes are referenced. For the root level however, signals must be emitted at all times (however the root level is always referenced when any view is attached). Returns the type of the column. the type of the column a #GtkTreeModel the column index Returns a set of flags supported by this interface. The flags are a bitwise combination of #GtkTreeModelFlags. The flags supported should not change during the lifetime of the @tree_model. the flags supported by this interface a #GtkTreeModel Sets @iter to a valid iterator pointing to @path. If @path does not exist, @iter is set to an invalid iterator and %FALSE is returned. %TRUE, if @iter was set a #GtkTreeModel the uninitialized #GtkTreeIter-struct the #GtkTreePath-struct Returns the number of columns supported by @tree_model. the number of columns a #GtkTreeModel Returns a newly-created #GtkTreePath-struct referenced by @iter. This path should be freed with gtk_tree_path_free(). a newly-created #GtkTreePath-struct a #GtkTreeModel the #GtkTreeIter-struct Initializes and sets @value to that at @column. When done with @value, g_value_unset() needs to be called to free any allocated memory. a #GtkTreeModel the #GtkTreeIter-struct the column to lookup the value at an empty #GValue to set Sets @iter to point to the first child of @parent. If @parent has no children, %FALSE is returned and @iter is set to be invalid. @parent will remain a valid node after this function has been called. If @parent is %NULL returns the first node, equivalent to `gtk_tree_model_get_iter_first (tree_model, iter);` %TRUE, if @iter has been set to the first child a #GtkTreeModel the new #GtkTreeIter-struct to be set to the child the #GtkTreeIter-struct, or %NULL Returns %TRUE if @iter has children, %FALSE otherwise. %TRUE if @iter has children a #GtkTreeModel the #GtkTreeIter-struct to test for children Returns the number of children that @iter has. As a special case, if @iter is %NULL, then the number of toplevel nodes is returned. the number of children of @iter a #GtkTreeModel the #GtkTreeIter-struct, or %NULL Sets @iter to point to the node following it at the current level. If there is no next @iter, %FALSE is returned and @iter is set to be invalid. %TRUE if @iter has been changed to the next node a #GtkTreeModel the #GtkTreeIter-struct Sets @iter to be the child of @parent, using the given index. The first index is 0. If @n is too big, or @parent has no children, @iter is set to an invalid iterator and %FALSE is returned. @parent will remain a valid node after this function has been called. As a special case, if @parent is %NULL, then the @n-th root node is set. %TRUE, if @parent has an @n-th child a #GtkTreeModel the #GtkTreeIter-struct to set to the nth child the #GtkTreeIter-struct to get the child from, or %NULL. the index of the desired child Sets @iter to be the parent of @child. If @child is at the toplevel, and doesn’t have a parent, then @iter is set to an invalid iterator and %FALSE is returned. @child will remain a valid node after this function has been called. @iter will be initialized before the lookup is performed, so @child and @iter cannot point to the same memory location. %TRUE, if @iter is set to the parent of @child a #GtkTreeModel the new #GtkTreeIter-struct to set to the parent the #GtkTreeIter-struct Sets @iter to point to the previous node at the current level. If there is no previous @iter, %FALSE is returned and @iter is set to be invalid. %TRUE if @iter has been changed to the previous node a #GtkTreeModel the #GtkTreeIter-struct Lets the tree ref the node. This is an optional method for models to implement. To be more specific, models may ignore this call as it exists primarily for performance reasons. This function is primarily meant as a way for views to let caching models know when nodes are being displayed (and hence, whether or not to cache that node). Being displayed means a node is in an expanded branch, regardless of whether the node is currently visible in the viewport. For example, a file-system based model would not want to keep the entire file-hierarchy in memory, just the sections that are currently being displayed by every current view. A model should be expected to be able to get an iter independent of its reffed state. a #GtkTreeModel the #GtkTreeIter-struct Emits the #GtkTreeModel::row-changed signal on @tree_model. a #GtkTreeModel a #GtkTreePath-struct pointing to the changed row a valid #GtkTreeIter-struct pointing to the changed row Emits the #GtkTreeModel::row-deleted signal on @tree_model. This should be called by models after a row has been removed. The location pointed to by @path should be the location that the row previously was at. It may not be a valid location anymore. Nodes that are deleted are not unreffed, this means that any outstanding references on the deleted node should not be released. a #GtkTreeModel a #GtkTreePath-struct pointing to the previous location of the deleted row Emits the #GtkTreeModel::row-has-child-toggled signal on @tree_model. This should be called by models after the child state of a node changes. a #GtkTreeModel a #GtkTreePath-struct pointing to the changed row a valid #GtkTreeIter-struct pointing to the changed row Emits the #GtkTreeModel::row-inserted signal on @tree_model. a #GtkTreeModel a #GtkTreePath-struct pointing to the inserted row a valid #GtkTreeIter-struct pointing to the inserted row Emits the #GtkTreeModel::rows-reordered signal on @tree_model. This should be called by models when their rows have been reordered. a #GtkTreeModel a #GtkTreePath-struct pointing to the tree node whose children have been reordered a valid #GtkTreeIter-struct pointing to the node whose children have been reordered, or %NULL if the depth of @path is 0 an array of integers mapping the current position of each child to its old position before the re-ordering, i.e. @new_order`[newpos] = oldpos` Lets the tree unref the node. This is an optional method for models to implement. To be more specific, models may ignore this call as it exists primarily for performance reasons. For more information on what this means, see gtk_tree_model_ref_node(). Please note that nodes that are deleted are not unreffed. a #GtkTreeModel the #GtkTreeIter-struct Creates a new #GtkTreeModel, with @child_model as the child_model and @root as the virtual root. A new #GtkTreeModel. A #GtkTreeModel. A #GtkTreePath or %NULL. Calls func on each node in model in a depth-first fashion. If @func returns %TRUE, then the tree ceases to be walked, and gtk_tree_model_foreach() returns. a #GtkTreeModel a function to be called on each row user data to passed to @func Gets the value of one or more cells in the row referenced by @iter. The variable argument list should contain integer column numbers, each column number followed by a place to store the value being retrieved. The list is terminated by a -1. For example, to get a value from column 0 with type %G_TYPE_STRING, you would write: `gtk_tree_model_get (model, iter, 0, &place_string_here, -1)`, where `place_string_here` is a #gchararray to be filled with the string. Returned values with type %G_TYPE_OBJECT have to be unreferenced, values with type %G_TYPE_STRING or %G_TYPE_BOXED have to be freed. Other values are passed by value. a #GtkTreeModel a row in @tree_model pairs of column number and value return locations, terminated by -1 Returns the type of the column. the type of the column a #GtkTreeModel the column index Returns a set of flags supported by this interface. The flags are a bitwise combination of #GtkTreeModelFlags. The flags supported should not change during the lifetime of the @tree_model. the flags supported by this interface a #GtkTreeModel Sets @iter to a valid iterator pointing to @path. If @path does not exist, @iter is set to an invalid iterator and %FALSE is returned. %TRUE, if @iter was set a #GtkTreeModel the uninitialized #GtkTreeIter-struct the #GtkTreePath-struct Initializes @iter with the first iterator in the tree (the one at the path "0") and returns %TRUE. Returns %FALSE if the tree is empty. %TRUE, if @iter was set a #GtkTreeModel the uninitialized #GtkTreeIter-struct Sets @iter to a valid iterator pointing to @path_string, if it exists. Otherwise, @iter is left invalid and %FALSE is returned. %TRUE, if @iter was set a #GtkTreeModel an uninitialized #GtkTreeIter-struct a string representation of a #GtkTreePath-struct Returns the number of columns supported by @tree_model. the number of columns a #GtkTreeModel Returns a newly-created #GtkTreePath-struct referenced by @iter. This path should be freed with gtk_tree_path_free(). a newly-created #GtkTreePath-struct a #GtkTreeModel the #GtkTreeIter-struct Generates a string representation of the iter. This string is a “:” separated list of numbers. For example, “4:10:0:3” would be an acceptable return value for this string. a newly-allocated string. Must be freed with g_free(). a #GtkTreeModel a #GtkTreeIter-struct See gtk_tree_model_get(), this version takes a va_list for language bindings to use. a #GtkTreeModel a row in @tree_model va_list of column/return location pairs Initializes and sets @value to that at @column. When done with @value, g_value_unset() needs to be called to free any allocated memory. a #GtkTreeModel the #GtkTreeIter-struct the column to lookup the value at an empty #GValue to set Sets @iter to point to the first child of @parent. If @parent has no children, %FALSE is returned and @iter is set to be invalid. @parent will remain a valid node after this function has been called. If @parent is %NULL returns the first node, equivalent to `gtk_tree_model_get_iter_first (tree_model, iter);` %TRUE, if @iter has been set to the first child a #GtkTreeModel the new #GtkTreeIter-struct to be set to the child the #GtkTreeIter-struct, or %NULL Returns %TRUE if @iter has children, %FALSE otherwise. %TRUE if @iter has children a #GtkTreeModel the #GtkTreeIter-struct to test for children Returns the number of children that @iter has. As a special case, if @iter is %NULL, then the number of toplevel nodes is returned. the number of children of @iter a #GtkTreeModel the #GtkTreeIter-struct, or %NULL Sets @iter to point to the node following it at the current level. If there is no next @iter, %FALSE is returned and @iter is set to be invalid. %TRUE if @iter has been changed to the next node a #GtkTreeModel the #GtkTreeIter-struct Sets @iter to be the child of @parent, using the given index. The first index is 0. If @n is too big, or @parent has no children, @iter is set to an invalid iterator and %FALSE is returned. @parent will remain a valid node after this function has been called. As a special case, if @parent is %NULL, then the @n-th root node is set. %TRUE, if @parent has an @n-th child a #GtkTreeModel the #GtkTreeIter-struct to set to the nth child the #GtkTreeIter-struct to get the child from, or %NULL. the index of the desired child Sets @iter to be the parent of @child. If @child is at the toplevel, and doesn’t have a parent, then @iter is set to an invalid iterator and %FALSE is returned. @child will remain a valid node after this function has been called. @iter will be initialized before the lookup is performed, so @child and @iter cannot point to the same memory location. %TRUE, if @iter is set to the parent of @child a #GtkTreeModel the new #GtkTreeIter-struct to set to the parent the #GtkTreeIter-struct Sets @iter to point to the previous node at the current level. If there is no previous @iter, %FALSE is returned and @iter is set to be invalid. %TRUE if @iter has been changed to the previous node a #GtkTreeModel the #GtkTreeIter-struct Lets the tree ref the node. This is an optional method for models to implement. To be more specific, models may ignore this call as it exists primarily for performance reasons. This function is primarily meant as a way for views to let caching models know when nodes are being displayed (and hence, whether or not to cache that node). Being displayed means a node is in an expanded branch, regardless of whether the node is currently visible in the viewport. For example, a file-system based model would not want to keep the entire file-hierarchy in memory, just the sections that are currently being displayed by every current view. A model should be expected to be able to get an iter independent of its reffed state. a #GtkTreeModel the #GtkTreeIter-struct Emits the #GtkTreeModel::row-changed signal on @tree_model. a #GtkTreeModel a #GtkTreePath-struct pointing to the changed row a valid #GtkTreeIter-struct pointing to the changed row Emits the #GtkTreeModel::row-deleted signal on @tree_model. This should be called by models after a row has been removed. The location pointed to by @path should be the location that the row previously was at. It may not be a valid location anymore. Nodes that are deleted are not unreffed, this means that any outstanding references on the deleted node should not be released. a #GtkTreeModel a #GtkTreePath-struct pointing to the previous location of the deleted row Emits the #GtkTreeModel::row-has-child-toggled signal on @tree_model. This should be called by models after the child state of a node changes. a #GtkTreeModel a #GtkTreePath-struct pointing to the changed row a valid #GtkTreeIter-struct pointing to the changed row Emits the #GtkTreeModel::row-inserted signal on @tree_model. a #GtkTreeModel a #GtkTreePath-struct pointing to the inserted row a valid #GtkTreeIter-struct pointing to the inserted row Emits the #GtkTreeModel::rows-reordered signal on @tree_model. This should be called by models when their rows have been reordered. a #GtkTreeModel a #GtkTreePath-struct pointing to the tree node whose children have been reordered a valid #GtkTreeIter-struct pointing to the node whose children have been reordered, or %NULL if the depth of @path is 0 an array of integers mapping the current position of each child to its old position before the re-ordering, i.e. @new_order`[newpos] = oldpos` Emits the #GtkTreeModel::rows-reordered signal on @tree_model. This should be called by models when their rows have been reordered. a #GtkTreeModel a #GtkTreePath-struct pointing to the tree node whose children have been reordered a valid #GtkTreeIter-struct pointing to the node whose children have been reordered, or %NULL if the depth of @path is 0 an array of integers mapping the current position of each child to its old position before the re-ordering, i.e. @new_order`[newpos] = oldpos` length of @new_order array Lets the tree unref the node. This is an optional method for models to implement. To be more specific, models may ignore this call as it exists primarily for performance reasons. For more information on what this means, see gtk_tree_model_ref_node(). Please note that nodes that are deleted are not unreffed. a #GtkTreeModel the #GtkTreeIter-struct This signal is emitted when a row in the model has changed. a #GtkTreePath-struct identifying the changed row a valid #GtkTreeIter-struct pointing to the changed row This signal is emitted when a row has been deleted. Note that no iterator is passed to the signal handler, since the row is already deleted. This should be called by models after a row has been removed. The location pointed to by @path should be the location that the row previously was at. It may not be a valid location anymore. a #GtkTreePath-struct identifying the row This signal is emitted when a row has gotten the first child row or lost its last child row. a #GtkTreePath-struct identifying the row a valid #GtkTreeIter-struct pointing to the row This signal is emitted when a new row has been inserted in the model. Note that the row may still be empty at this point, since it is a common pattern to first insert an empty row, and then fill it with the desired values. a #GtkTreePath-struct identifying the new row a valid #GtkTreeIter-struct pointing to the new row This signal is emitted when the children of a node in the #GtkTreeModel have been reordered. Note that this signal is not emitted when rows are reordered by DND, since this is implemented by removing and then reinserting the row. a #GtkTreePath-struct identifying the tree node whose children have been reordered a valid #GtkTreeIter-struct pointing to the node whose children have been reordered, or %NULL if the depth of @path is 0 an array of integers mapping the current position of each child to its old position before the re-ordering, i.e. @new_order`[newpos] = oldpos` A #GtkTreeModelFilter is a tree model which wraps another tree model, and can do the following things: - Filter specific rows, based on data from a “visible column”, a column storing booleans indicating whether the row should be filtered or not, or based on the return value of a “visible function”, which gets a model, iter and user_data and returns a boolean indicating whether the row should be filtered or not. - Modify the “appearance” of the model, using a modify function. This is extremely powerful and allows for just changing some values and also for creating a completely different model based on the given child model. - Set a different root node, also known as a “virtual root”. You can pass in a #GtkTreePath indicating the root node for the filter at construction time. The basic API is similar to #GtkTreeModelSort. For an example on its usage, see the section on #GtkTreeModelSort. When using #GtkTreeModelFilter, it is important to realize that #GtkTreeModelFilter maintains an internal cache of all nodes which are visible in its clients. The cache is likely to be a subtree of the tree exposed by the child model. #GtkTreeModelFilter will not cache the entire child model when unnecessary to not compromise the caching mechanism that is exposed by the reference counting scheme. If the child model implements reference counting, unnecessary signals may not be emitted because of reference counting rule 3, see the #GtkTreeModel documentation. (Note that e.g. #GtkTreeStore does not implement reference counting and will always emit all signals, even when the receiving node is not visible). Because of this, limitations for possible visible functions do apply. In general, visible functions should only use data or properties from the node for which the visibility state must be determined, its siblings or its parents. Usually, having a dependency on the state of any child node is not possible, unless references are taken on these explicitly. When no such reference exists, no signals may be received for these child nodes (see reference couting rule number 3 in the #GtkTreeModel section). Determining the visibility state of a given node based on the state of its child nodes is a frequently occurring use case. Therefore, #GtkTreeModelFilter explicitly supports this. For example, when a node does not have any children, you might not want the node to be visible. As soon as the first row is added to the node’s child level (or the last row removed), the node’s visibility should be updated. This introduces a dependency from the node on its child nodes. In order to accommodate this, #GtkTreeModelFilter must make sure the necessary signals are received from the child model. This is achieved by building, for all nodes which are exposed as visible nodes to #GtkTreeModelFilter's clients, the child level (if any) and take a reference on the first node in this level. Furthermore, for every row-inserted, row-changed or row-deleted signal (also these which were not handled because the node was not cached), #GtkTreeModelFilter will check if the visibility state of any parent node has changed. Beware, however, that this explicit support is limited to these two cases. For example, if you want a node to be visible only if two nodes in a child’s child level (2 levels deeper) are visible, you are on your own. In this case, either rely on #GtkTreeStore to emit all signals because it does not implement reference counting, or for models that do implement reference counting, obtain references on these child levels yourself. Creates a new #GtkTreeModel, with @child_model as the child_model and @root as the virtual root. A new #GtkTreeModel. A #GtkTreeModel. A #GtkTreePath or %NULL. This function should almost never be called. It clears the @filter of any cached iterators that haven’t been reffed with gtk_tree_model_ref_node(). This might be useful if the child model being filtered is static (and doesn’t change often) and there has been a lot of unreffed access to nodes. As a side effect of this function, all unreffed iters will be invalid. A #GtkTreeModelFilter. Sets @filter_iter to point to the row in @filter that corresponds to the row pointed at by @child_iter. If @filter_iter was not set, %FALSE is returned. %TRUE, if @filter_iter was set, i.e. if @child_iter is a valid iterator pointing to a visible row in child model. A #GtkTreeModelFilter. An uninitialized #GtkTreeIter. A valid #GtkTreeIter pointing to a row on the child model. Converts @child_path to a path relative to @filter. That is, @child_path points to a path in the child model. The rerturned path will point to the same row in the filtered model. If @child_path isn’t a valid path on the child model or points to a row which is not visible in @filter, then %NULL is returned. A newly allocated #GtkTreePath, or %NULL. A #GtkTreeModelFilter. A #GtkTreePath to convert. Sets @child_iter to point to the row pointed to by @filter_iter. A #GtkTreeModelFilter. An uninitialized #GtkTreeIter. A valid #GtkTreeIter pointing to a row on @filter. Converts @filter_path to a path on the child model of @filter. That is, @filter_path points to a location in @filter. The returned path will point to the same location in the model not being filtered. If @filter_path does not point to a location in the child model, %NULL is returned. A newly allocated #GtkTreePath, or %NULL. A #GtkTreeModelFilter. A #GtkTreePath to convert. Returns a pointer to the child model of @filter. A pointer to a #GtkTreeModel. A #GtkTreeModelFilter. Emits ::row_changed for each row in the child model, which causes the filter to re-evaluate whether a row is visible or not. A #GtkTreeModelFilter. With the @n_columns and @types parameters, you give an array of column types for this model (which will be exposed to the parent model/view). The @func, @data and @destroy parameters are for specifying the modify function. The modify function will get called for each data access, the goal of the modify function is to return the data which should be displayed at the location specified using the parameters of the modify function. Note that gtk_tree_model_filter_set_modify_func() can only be called once for a given filter model. A #GtkTreeModelFilter. The number of columns in the filter model. The #GTypes of the columns. A #GtkTreeModelFilterModifyFunc User data to pass to the modify function, or %NULL. Destroy notifier of @data, or %NULL. Sets @column of the child_model to be the column where @filter should look for visibility information. @columns should be a column of type %G_TYPE_BOOLEAN, where %TRUE means that a row is visible, and %FALSE if not. Note that gtk_tree_model_filter_set_visible_func() or gtk_tree_model_filter_set_visible_column() can only be called once for a given filter model. A #GtkTreeModelFilter A #gint which is the column containing the visible information Sets the visible function used when filtering the @filter to be @func. The function should return %TRUE if the given row should be visible and %FALSE otherwise. If the condition calculated by the function changes over time (e.g. because it depends on some global parameters), you must call gtk_tree_model_filter_refilter() to keep the visibility information of the model up-to-date. Note that @func is called whenever a row is inserted, when it may still be empty. The visible function should therefore take special care of empty rows, like in the example below. |[<!-- language="C" --> static gboolean visible_func (GtkTreeModel *model, GtkTreeIter *iter, gpointer data) { // Visible if row is non-empty and first column is “HI” gchar *str; gboolean visible = FALSE; gtk_tree_model_get (model, iter, 0, &str, -1); if (str && strcmp (str, "HI") == 0) visible = TRUE; g_free (str); return visible; } ]| Note that gtk_tree_model_filter_set_visible_func() or gtk_tree_model_filter_set_visible_column() can only be called once for a given filter model. A #GtkTreeModelFilter A #GtkTreeModelFilterVisibleFunc, the visible function User data to pass to the visible function, or %NULL Destroy notifier of @data, or %NULL A function which calculates display values from raw values in the model. It must fill @value with the display value for the column @column in the row indicated by @iter. Since this function is called for each data access, it’s not a particularly efficient operation. the #GtkTreeModelFilter a #GtkTreeIter pointing to the row whose display values are determined A #GValue which is already initialized for with the correct type for the column @column. the column whose display value is determined user data given to gtk_tree_model_filter_set_modify_func() A function which decides whether the row indicated by @iter is visible. Whether the row indicated by @iter is visible. the child model of the #GtkTreeModelFilter a #GtkTreeIter pointing to the row in @model whose visibility is determined user data given to gtk_tree_model_filter_set_visible_func() These flags indicate various properties of a #GtkTreeModel. They are returned by gtk_tree_model_get_flags(), and must be static for the lifetime of the object. A more complete description of #GTK_TREE_MODEL_ITERS_PERSIST can be found in the overview of this section. iterators survive all signals emitted by the tree the model is a list only, and never has children Type of the callback passed to gtk_tree_model_foreach() to iterate over the rows in a tree model. %TRUE to stop iterating, %FALSE to continue the #GtkTreeModel being iterated the current #GtkTreePath the current #GtkTreeIter The user data passed to gtk_tree_model_foreach() a #GtkTreeModel a #GtkTreePath-struct pointing to the changed row a valid #GtkTreeIter-struct pointing to the changed row a #GtkTreeModel a #GtkTreePath-struct pointing to the inserted row a valid #GtkTreeIter-struct pointing to the inserted row a #GtkTreeModel a #GtkTreePath-struct pointing to the changed row a valid #GtkTreeIter-struct pointing to the changed row a #GtkTreeModel a #GtkTreePath-struct pointing to the previous location of the deleted row a #GtkTreeModel a #GtkTreePath-struct pointing to the tree node whose children have been reordered a valid #GtkTreeIter-struct pointing to the node whose children have been reordered, or %NULL if the depth of @path is 0 an array of integers mapping the current position of each child to its old position before the re-ordering, i.e. @new_order`[newpos] = oldpos` the flags supported by this interface a #GtkTreeModel the number of columns a #GtkTreeModel the type of the column a #GtkTreeModel the column index %TRUE, if @iter was set a #GtkTreeModel the uninitialized #GtkTreeIter-struct the #GtkTreePath-struct a newly-created #GtkTreePath-struct a #GtkTreeModel the #GtkTreeIter-struct a #GtkTreeModel the #GtkTreeIter-struct the column to lookup the value at an empty #GValue to set %TRUE if @iter has been changed to the next node a #GtkTreeModel the #GtkTreeIter-struct %TRUE if @iter has been changed to the previous node a #GtkTreeModel the #GtkTreeIter-struct %TRUE, if @iter has been set to the first child a #GtkTreeModel the new #GtkTreeIter-struct to be set to the child the #GtkTreeIter-struct, or %NULL %TRUE if @iter has children a #GtkTreeModel the #GtkTreeIter-struct to test for children the number of children of @iter a #GtkTreeModel the #GtkTreeIter-struct, or %NULL %TRUE, if @parent has an @n-th child a #GtkTreeModel the #GtkTreeIter-struct to set to the nth child the #GtkTreeIter-struct to get the child from, or %NULL. the index of the desired child %TRUE, if @iter is set to the parent of @child a #GtkTreeModel the new #GtkTreeIter-struct to set to the parent the #GtkTreeIter-struct a #GtkTreeModel the #GtkTreeIter-struct a #GtkTreeModel the #GtkTreeIter-struct The #GtkTreeModelSort is a model which implements the #GtkTreeSortable interface. It does not hold any data itself, but rather is created with a child model and proxies its data. It has identical column types to this child model, and the changes in the child are propagated. The primary purpose of this model is to provide a way to sort a different model without modifying it. Note that the sort function used by #GtkTreeModelSort is not guaranteed to be stable. The use of this is best demonstrated through an example. In the following sample code we create two #GtkTreeView widgets each with a view of the same data. As the model is wrapped here by a #GtkTreeModelSort, the two #GtkTreeViews can each sort their view of the data without affecting the other. By contrast, if we simply put the same model in each widget, then sorting the first would sort the second. ## Using a #GtkTreeModelSort |[<!-- language="C" --> { GtkTreeView *tree_view1; GtkTreeView *tree_view2; GtkTreeModel *sort_model1; GtkTreeModel *sort_model2; GtkTreeModel *child_model; // get the child model child_model = get_my_model (); // Create the first tree sort_model1 = gtk_tree_model_sort_new_with_model (child_model); tree_view1 = gtk_tree_view_new_with_model (sort_model1); // Create the second tree sort_model2 = gtk_tree_model_sort_new_with_model (child_model); tree_view2 = gtk_tree_view_new_with_model (sort_model2); // Now we can sort the two models independently gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (sort_model1), COLUMN_1, GTK_SORT_ASCENDING); gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (sort_model2), COLUMN_1, GTK_SORT_DESCENDING); } ]| To demonstrate how to access the underlying child model from the sort model, the next example will be a callback for the #GtkTreeSelection #GtkTreeSelection::changed signal. In this callback, we get a string from COLUMN_1 of the model. We then modify the string, find the same selected row on the child model, and change the row there. ## Accessing the child model of in a selection changed callback |[<!-- language="C" --> void selection_changed (GtkTreeSelection *selection, gpointer data) { GtkTreeModel *sort_model = NULL; GtkTreeModel *child_model; GtkTreeIter sort_iter; GtkTreeIter child_iter; char *some_data = NULL; char *modified_data; // Get the current selected row and the model. if (! gtk_tree_selection_get_selected (selection, &sort_model, &sort_iter)) return; // Look up the current value on the selected row and get // a new value to change it to. gtk_tree_model_get (GTK_TREE_MODEL (sort_model), &sort_iter, COLUMN_1, &some_data, -1); modified_data = change_the_data (some_data); g_free (some_data); // Get an iterator on the child model, instead of the sort model. gtk_tree_model_sort_convert_iter_to_child_iter (GTK_TREE_MODEL_SORT (sort_model), &child_iter, &sort_iter); // Get the child model and change the value of the row. In this // example, the child model is a GtkListStore. It could be any other // type of model, though. child_model = gtk_tree_model_sort_get_model (GTK_TREE_MODEL_SORT (sort_model)); gtk_list_store_set (GTK_LIST_STORE (child_model), &child_iter, COLUMN_1, &modified_data, -1); g_free (modified_data); } ]| Creates a new #GtkTreeModelSort, with @child_model as the child model. A new #GtkTreeModelSort. A #GtkTreeModel This function should almost never be called. It clears the @tree_model_sort of any cached iterators that haven’t been reffed with gtk_tree_model_ref_node(). This might be useful if the child model being sorted is static (and doesn’t change often) and there has been a lot of unreffed access to nodes. As a side effect of this function, all unreffed iters will be invalid. A #GtkTreeModelSort Sets @sort_iter to point to the row in @tree_model_sort that corresponds to the row pointed at by @child_iter. If @sort_iter was not set, %FALSE is returned. Note: a boolean is only returned since 2.14. %TRUE, if @sort_iter was set, i.e. if @sort_iter is a valid iterator pointer to a visible row in the child model. A #GtkTreeModelSort An uninitialized #GtkTreeIter. A valid #GtkTreeIter pointing to a row on the child model Converts @child_path to a path relative to @tree_model_sort. That is, @child_path points to a path in the child model. The returned path will point to the same row in the sorted model. If @child_path isn’t a valid path on the child model, then %NULL is returned. A newly allocated #GtkTreePath, or %NULL A #GtkTreeModelSort A #GtkTreePath to convert Sets @child_iter to point to the row pointed to by @sorted_iter. A #GtkTreeModelSort An uninitialized #GtkTreeIter A valid #GtkTreeIter pointing to a row on @tree_model_sort. Converts @sorted_path to a path on the child model of @tree_model_sort. That is, @sorted_path points to a location in @tree_model_sort. The returned path will point to the same location in the model not being sorted. If @sorted_path does not point to a location in the child model, %NULL is returned. A newly allocated #GtkTreePath, or %NULL A #GtkTreeModelSort A #GtkTreePath to convert Returns the model the #GtkTreeModelSort is sorting. the "child model" being sorted a #GtkTreeModelSort > This function is slow. Only use it for debugging and/or testing > purposes. Checks if the given iter is a valid iter for this #GtkTreeModelSort. %TRUE if the iter is valid, %FALSE if the iter is invalid. A #GtkTreeModelSort. A #GtkTreeIter. This resets the default sort function to be in the “unsorted” state. That is, it is in the same order as the child model. It will re-sort the model to be in the same order as the child model only if the #GtkTreeModelSort is in “unsorted” state. A #GtkTreeModelSort Creates a new #GtkTreePath-struct. This refers to a row. A newly created #GtkTreePath-struct. Creates a new #GtkTreePath-struct. The string representation of this path is “0”. A new #GtkTreePath-struct Creates a new path with @first_index and @varargs as indices. A newly created #GtkTreePath-struct first integer list of integers terminated by -1 Creates a new path with the given @indices array of @length. A newly created #GtkTreePath-struct array of indices length of @indices array Creates a new #GtkTreePath-struct initialized to @path. @path is expected to be a colon separated list of numbers. For example, the string “10:4:0” would create a path of depth 3 pointing to the 11th child of the root node, the 5th child of that 11th child, and the 1st child of that 5th child. If an invalid path string is passed in, %NULL is returned. A newly-created #GtkTreePath-struct, or %NULL The string representation of a path Appends a new index to a path. As a result, the depth of the path is increased. a #GtkTreePath-struct the index Compares two paths. If @a appears before @b in a tree, then -1 is returned. If @b appears before @a, then 1 is returned. If the two nodes are equal, then 0 is returned. the relative positions of @a and @b a #GtkTreePath-struct a #GtkTreePath-struct to compare with Creates a new #GtkTreePath-struct as a copy of @path. a new #GtkTreePath-struct a #GtkTreePath-struct Moves @path to point to the first child of the current path. a #GtkTreePath-struct Frees @path. If @path is %NULL, it simply returns. a #GtkTreePath-struct Returns the current depth of @path. The depth of @path a #GtkTreePath-struct Returns the current indices of @path. This is an array of integers, each representing a node in a tree. This value should not be freed. The length of the array can be obtained with gtk_tree_path_get_depth(). The current indices, or %NULL a #GtkTreePath-struct Returns the current indices of @path. This is an array of integers, each representing a node in a tree. It also returns the number of elements in the array. The array should not be freed. The current indices, or %NULL a #GtkTreePath-struct return location for number of elements returned in the integer array, or %NULL Returns %TRUE if @descendant is a descendant of @path. %TRUE if @descendant is contained inside @path a #GtkTreePath-struct another #GtkTreePath-struct Returns %TRUE if @path is a descendant of @ancestor. %TRUE if @ancestor contains @path somewhere below it a #GtkTreePath-struct another #GtkTreePath-struct Moves the @path to point to the next node at the current depth. a #GtkTreePath-struct Prepends a new index to a path. As a result, the depth of the path is increased. a #GtkTreePath-struct the index Moves the @path to point to the previous node at the current depth, if it exists. %TRUE if @path has a previous node, and the move was made a #GtkTreePath-struct Generates a string representation of the path. This string is a “:” separated list of numbers. For example, “4:10:0:3” would be an acceptable return value for this string. A newly-allocated string. Must be freed with g_free(). A #GtkTreePath-struct Moves the @path to point to its parent node, if it has a parent. %TRUE if @path has a parent, and the move was made a #GtkTreePath-struct A GtkTreeRowReference tracks model changes so that it always refers to the same row (a #GtkTreePath refers to a position, not a fixed row). Create a new GtkTreeRowReference with gtk_tree_row_reference_new(). Creates a row reference based on @path. This reference will keep pointing to the node pointed to by @path, so long as it exists. Any changes that occur on @model are propagated, and the path is updated appropriately. If @path isn’t a valid path in @model, then %NULL is returned. a newly allocated #GtkTreeRowReference, or %NULL a #GtkTreeModel a valid #GtkTreePath-struct to monitor You do not need to use this function. Creates a row reference based on @path. This reference will keep pointing to the node pointed to by @path, so long as it exists. If @path isn’t a valid path in @model, then %NULL is returned. However, unlike references created with gtk_tree_row_reference_new(), it does not listen to the model for changes. The creator of the row reference must do this explicitly using gtk_tree_row_reference_inserted(), gtk_tree_row_reference_deleted(), gtk_tree_row_reference_reordered(). These functions must be called exactly once per proxy when the corresponding signal on the model is emitted. This single call updates all row references for that proxy. Since built-in GTK+ objects like #GtkTreeView already use this mechanism internally, using them as the proxy object will produce unpredictable results. Further more, passing the same object as @model and @proxy doesn’t work for reasons of internal implementation. This type of row reference is primarily meant by structures that need to carefully monitor exactly when a row reference updates itself, and is not generally needed by most applications. a newly allocated #GtkTreeRowReference, or %NULL a proxy #GObject a #GtkTreeModel a valid #GtkTreePath-struct to monitor Copies a #GtkTreeRowReference. a copy of @reference a #GtkTreeRowReference Free’s @reference. @reference may be %NULL a #GtkTreeRowReference, or %NULL Returns the model that the row reference is monitoring. the model a #GtkTreeRowReference Returns a path that the row reference currently points to, or %NULL if the path pointed to is no longer valid. a current path, or %NULL a #GtkTreeRowReference Returns %TRUE if the @reference is non-%NULL and refers to a current valid path. %TRUE if @reference points to a valid path a #GtkTreeRowReference, or %NULL Lets a set of row reference created by gtk_tree_row_reference_new_proxy() know that the model emitted the #GtkTreeModel::row-deleted signal. a #GObject the path position that was deleted Lets a set of row reference created by gtk_tree_row_reference_new_proxy() know that the model emitted the #GtkTreeModel::row-inserted signal. a #GObject the row position that was inserted Lets a set of row reference created by gtk_tree_row_reference_new_proxy() know that the model emitted the #GtkTreeModel::rows-reordered signal. a #GObject the parent path of the reordered signal the iter pointing to the parent of the reordered the new order of rows The #GtkTreeSelection object is a helper object to manage the selection for a #GtkTreeView widget. The #GtkTreeSelection object is automatically created when a new #GtkTreeView widget is created, and cannot exist independently of this widget. The primary reason the #GtkTreeSelection objects exists is for cleanliness of code and API. That is, there is no conceptual reason all these functions could not be methods on the #GtkTreeView widget instead of a separate function. The #GtkTreeSelection object is gotten from a #GtkTreeView by calling gtk_tree_view_get_selection(). It can be manipulated to check the selection status of the tree, as well as select and deselect individual rows. Selection is done completely view side. As a result, multiple views of the same model can have completely different selections. Additionally, you cannot change the selection of a row on the model that is not currently displayed by the view without expanding its parents first. One of the important things to remember when monitoring the selection of a view is that the #GtkTreeSelection::changed signal is mostly a hint. That is, it may only emit one signal when a range of rows is selected. Additionally, it may on occasion emit a #GtkTreeSelection::changed signal when nothing has happened (mostly as a result of programmers calling select_row on an already selected row). Returns the number of rows that have been selected in @tree. The number of rows selected. A #GtkTreeSelection. Gets the selection mode for @selection. See gtk_tree_selection_set_mode(). the current selection mode a #GtkTreeSelection Returns the current selection function. The function. A #GtkTreeSelection. Sets @iter to the currently selected node if @selection is set to #GTK_SELECTION_SINGLE or #GTK_SELECTION_BROWSE. @iter may be NULL if you just want to test if @selection has any selected nodes. @model is filled with the current model as a convenience. This function will not work if you use @selection is #GTK_SELECTION_MULTIPLE. TRUE, if there is a selected node. A #GtkTreeSelection. A pointer to set to the #GtkTreeModel, or NULL. The #GtkTreeIter, or NULL. Creates a list of path of all selected rows. Additionally, if you are planning on modifying the model after calling this function, you may want to convert the returned list into a list of #GtkTreeRowReferences. To do this, you can use gtk_tree_row_reference_new(). To free the return value, use: |[<!-- language="C" --> g_list_free_full (list, (GDestroyNotify) gtk_tree_path_free); ]| A #GList containing a #GtkTreePath for each selected row. A #GtkTreeSelection. A pointer to set to the #GtkTreeModel, or %NULL. Returns the tree view associated with @selection. A #GtkTreeView A #GtkTreeSelection Returns the user data for the selection function. The user data. A #GtkTreeSelection. Returns %TRUE if the row at @iter is currently selected. %TRUE, if @iter is selected A #GtkTreeSelection A valid #GtkTreeIter Returns %TRUE if the row pointed to by @path is currently selected. If @path does not point to a valid location, %FALSE is returned %TRUE if @path is selected. A #GtkTreeSelection. A #GtkTreePath to check selection on. Selects all the nodes. @selection must be set to #GTK_SELECTION_MULTIPLE mode. A #GtkTreeSelection. Selects the specified iterator. A #GtkTreeSelection. The #GtkTreeIter to be selected. Select the row at @path. A #GtkTreeSelection. The #GtkTreePath to be selected. Selects a range of nodes, determined by @start_path and @end_path inclusive. @selection must be set to #GTK_SELECTION_MULTIPLE mode. A #GtkTreeSelection. The initial node of the range. The final node of the range. Calls a function for each selected node. Note that you cannot modify the tree or selection from within this function. As a result, gtk_tree_selection_get_selected_rows() might be more useful. A #GtkTreeSelection. The function to call for each selected node. user data to pass to the function. Sets the selection mode of the @selection. If the previous type was #GTK_SELECTION_MULTIPLE, then the anchor is kept selected, if it was previously selected. A #GtkTreeSelection. The selection mode Sets the selection function. If set, this function is called before any node is selected or unselected, giving some control over which nodes are selected. The select function should return %TRUE if the state of the node may be toggled, and %FALSE if the state of the node should be left unchanged. A #GtkTreeSelection. The selection function. May be %NULL The selection function’s data. May be %NULL The destroy function for user data. May be %NULL Unselects all the nodes. A #GtkTreeSelection. Unselects the specified iterator. A #GtkTreeSelection. The #GtkTreeIter to be unselected. Unselects the row at @path. A #GtkTreeSelection. The #GtkTreePath to be unselected. Unselects a range of nodes, determined by @start_path and @end_path inclusive. A #GtkTreeSelection. The initial node of the range. The initial node of the range. Selection mode. See gtk_tree_selection_set_mode() for more information on this property. Emitted whenever the selection has (possibly) changed. Please note that this signal is mostly a hint. It may only be emitted once when a range of rows are selected, and it may occasionally be emitted when nothing has happened. The parent class. A function used by gtk_tree_selection_selected_foreach() to map all selected rows. It will be called on every selected row in the view. The #GtkTreeModel being viewed The #GtkTreePath of a selected row A #GtkTreeIter pointing to a selected row user data A function used by gtk_tree_selection_set_select_function() to filter whether or not a row may be selected. It is called whenever a row's state might change. A return value of %TRUE indicates to @selection that it is okay to change the selection. %TRUE, if the selection state of the row can be toggled A #GtkTreeSelection A #GtkTreeModel being viewed The #GtkTreePath of the row in question %TRUE, if the path is currently selected user data #GtkTreeSortable is an interface to be implemented by tree models which support sorting. The #GtkTreeView uses the methods provided by this interface to sort the model. Fills in @sort_column_id and @order with the current sort column and the order. It returns %TRUE unless the @sort_column_id is %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID or %GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID. %TRUE if the sort column is not one of the special sort column ids. A #GtkTreeSortable The sort column id to be filled in The #GtkSortType to be filled in Returns %TRUE if the model has a default sort function. This is used primarily by GtkTreeViewColumns in order to determine if a model can go back to the default state, or not. %TRUE, if the model has a default sort function A #GtkTreeSortable Sets the default comparison function used when sorting to be @sort_func. If the current sort column id of @sortable is %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, then the model will sort using this function. If @sort_func is %NULL, then there will be no default comparison function. This means that once the model has been sorted, it can’t go back to the default state. In this case, when the current sort column id of @sortable is %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, the model will be unsorted. A #GtkTreeSortable The comparison function User data to pass to @sort_func, or %NULL Destroy notifier of @user_data, or %NULL Sets the current sort column to be @sort_column_id. The @sortable will resort itself to reflect this change, after emitting a #GtkTreeSortable::sort-column-changed signal. @sort_column_id may either be a regular column id, or one of the following special values: - %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID: the default sort function will be used, if it is set - %GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID: no sorting will occur A #GtkTreeSortable the sort column id to set The sort order of the column Sets the comparison function used when sorting to be @sort_func. If the current sort column id of @sortable is the same as @sort_column_id, then the model will sort using this function. A #GtkTreeSortable the sort column id to set the function for The comparison function User data to pass to @sort_func, or %NULL Destroy notifier of @user_data, or %NULL Emits a #GtkTreeSortable::sort-column-changed signal on @sortable. A #GtkTreeSortable Fills in @sort_column_id and @order with the current sort column and the order. It returns %TRUE unless the @sort_column_id is %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID or %GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID. %TRUE if the sort column is not one of the special sort column ids. A #GtkTreeSortable The sort column id to be filled in The #GtkSortType to be filled in Returns %TRUE if the model has a default sort function. This is used primarily by GtkTreeViewColumns in order to determine if a model can go back to the default state, or not. %TRUE, if the model has a default sort function A #GtkTreeSortable Sets the default comparison function used when sorting to be @sort_func. If the current sort column id of @sortable is %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, then the model will sort using this function. If @sort_func is %NULL, then there will be no default comparison function. This means that once the model has been sorted, it can’t go back to the default state. In this case, when the current sort column id of @sortable is %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, the model will be unsorted. A #GtkTreeSortable The comparison function User data to pass to @sort_func, or %NULL Destroy notifier of @user_data, or %NULL Sets the current sort column to be @sort_column_id. The @sortable will resort itself to reflect this change, after emitting a #GtkTreeSortable::sort-column-changed signal. @sort_column_id may either be a regular column id, or one of the following special values: - %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID: the default sort function will be used, if it is set - %GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID: no sorting will occur A #GtkTreeSortable the sort column id to set The sort order of the column Sets the comparison function used when sorting to be @sort_func. If the current sort column id of @sortable is the same as @sort_column_id, then the model will sort using this function. A #GtkTreeSortable the sort column id to set the function for The comparison function User data to pass to @sort_func, or %NULL Destroy notifier of @user_data, or %NULL Emits a #GtkTreeSortable::sort-column-changed signal on @sortable. A #GtkTreeSortable The ::sort-column-changed signal is emitted when the sort column or sort order of @sortable is changed. The signal is emitted before the contents of @sortable are resorted. A #GtkTreeSortable %TRUE if the sort column is not one of the special sort column ids. A #GtkTreeSortable The sort column id to be filled in The #GtkSortType to be filled in A #GtkTreeSortable the sort column id to set The sort order of the column A #GtkTreeSortable the sort column id to set the function for The comparison function User data to pass to @sort_func, or %NULL Destroy notifier of @user_data, or %NULL A #GtkTreeSortable The comparison function User data to pass to @sort_func, or %NULL Destroy notifier of @user_data, or %NULL %TRUE, if the model has a default sort function A #GtkTreeSortable The #GtkTreeStore object is a list model for use with a #GtkTreeView widget. It implements the #GtkTreeModel interface, and consequentially, can use all of the methods available there. It also implements the #GtkTreeSortable interface so it can be sorted by the view. Finally, it also implements the tree [drag and drop][gtk3-GtkTreeView-drag-and-drop] interfaces. # GtkTreeStore as GtkBuildable The GtkTreeStore implementation of the #GtkBuildable interface allows to specify the model columns with a <columns> element that may contain multiple <column> elements, each specifying one model column. The “type” attribute specifies the data type for the column. An example of a UI Definition fragment for a tree store: |[ <object class="GtkTreeStore"> <columns> <column type="gchararray"/> <column type="gchararray"/> <column type="gint"/> </columns> </object> ]| Creates a new tree store as with @n_columns columns each of the types passed in. Note that only types derived from standard GObject fundamental types are supported. As an example, `gtk_tree_store_new (3, G_TYPE_INT, G_TYPE_STRING, GDK_TYPE_PIXBUF);` will create a new #GtkTreeStore with three columns, of type #gint, #gchararray, and #GdkPixbuf respectively. a new #GtkTreeStore number of columns in the tree store all #GType types for the columns, from first to last Non vararg creation function. Used primarily by language bindings. a new #GtkTreeStore number of columns in the tree store an array of #GType types for the columns, from first to last Appends a new row to @tree_store. If @parent is non-%NULL, then it will append the new row after the last child of @parent, otherwise it will append a row to the top level. @iter will be changed to point to this new row. The row will be empty after this function is called. To fill in values, you need to call gtk_tree_store_set() or gtk_tree_store_set_value(). A #GtkTreeStore An unset #GtkTreeIter to set to the appended row A valid #GtkTreeIter, or %NULL Removes all rows from @tree_store a #GtkTreeStore Creates a new row at @position. If parent is non-%NULL, then the row will be made a child of @parent. Otherwise, the row will be created at the toplevel. If @position is -1 or is larger than the number of rows at that level, then the new row will be inserted to the end of the list. @iter will be changed to point to this new row. The row will be empty after this function is called. To fill in values, you need to call gtk_tree_store_set() or gtk_tree_store_set_value(). A #GtkTreeStore An unset #GtkTreeIter to set to the new row A valid #GtkTreeIter, or %NULL position to insert the new row, or -1 for last Inserts a new row after @sibling. If @sibling is %NULL, then the row will be prepended to @parent ’s children. If @parent and @sibling are %NULL, then the row will be prepended to the toplevel. If both @sibling and @parent are set, then @parent must be the parent of @sibling. When @sibling is set, @parent is optional. @iter will be changed to point to this new row. The row will be empty after this function is called. To fill in values, you need to call gtk_tree_store_set() or gtk_tree_store_set_value(). A #GtkTreeStore An unset #GtkTreeIter to set to the new row A valid #GtkTreeIter, or %NULL A valid #GtkTreeIter, or %NULL Inserts a new row before @sibling. If @sibling is %NULL, then the row will be appended to @parent ’s children. If @parent and @sibling are %NULL, then the row will be appended to the toplevel. If both @sibling and @parent are set, then @parent must be the parent of @sibling. When @sibling is set, @parent is optional. @iter will be changed to point to this new row. The row will be empty after this function is called. To fill in values, you need to call gtk_tree_store_set() or gtk_tree_store_set_value(). A #GtkTreeStore An unset #GtkTreeIter to set to the new row A valid #GtkTreeIter, or %NULL A valid #GtkTreeIter, or %NULL Creates a new row at @position. @iter will be changed to point to this new row. If @position is -1, or larger than the number of rows on the list, then the new row will be appended to the list. The row will be filled with the values given to this function. Calling `gtk_tree_store_insert_with_values (tree_store, iter, position, ...)` has the same effect as calling |[<!-- language="C" --> gtk_tree_store_insert (tree_store, iter, position); gtk_tree_store_set (tree_store, iter, ...); ]| with the different that the former will only emit a row_inserted signal, while the latter will emit row_inserted, row_changed and if the tree store is sorted, rows_reordered. Since emitting the rows_reordered signal repeatedly can affect the performance of the program, gtk_tree_store_insert_with_values() should generally be preferred when inserting rows in a sorted tree store. A #GtkTreeStore An unset #GtkTreeIter to set the new row, or %NULL. A valid #GtkTreeIter, or %NULL position to insert the new row, or -1 to append after existing rows pairs of column number and value, terminated with -1 A variant of gtk_tree_store_insert_with_values() which takes the columns and values as two arrays, instead of varargs. This function is mainly intended for language bindings. A #GtkTreeStore An unset #GtkTreeIter to set the new row, or %NULL. A valid #GtkTreeIter, or %NULL position to insert the new row, or -1 for last an array of column numbers an array of GValues the length of the @columns and @values arrays Returns %TRUE if @iter is an ancestor of @descendant. That is, @iter is the parent (or grandparent or great-grandparent) of @descendant. %TRUE, if @iter is an ancestor of @descendant A #GtkTreeStore A valid #GtkTreeIter A valid #GtkTreeIter Returns the depth of @iter. This will be 0 for anything on the root level, 1 for anything down a level, etc. The depth of @iter A #GtkTreeStore A valid #GtkTreeIter WARNING: This function is slow. Only use it for debugging and/or testing purposes. Checks if the given iter is a valid iter for this #GtkTreeStore. %TRUE if the iter is valid, %FALSE if the iter is invalid. A #GtkTreeStore. A #GtkTreeIter. Moves @iter in @tree_store to the position after @position. @iter and @position should be in the same level. Note that this function only works with unsorted stores. If @position is %NULL, @iter will be moved to the start of the level. A #GtkTreeStore. A #GtkTreeIter. A #GtkTreeIter. Moves @iter in @tree_store to the position before @position. @iter and @position should be in the same level. Note that this function only works with unsorted stores. If @position is %NULL, @iter will be moved to the end of the level. A #GtkTreeStore. A #GtkTreeIter. A #GtkTreeIter or %NULL. Prepends a new row to @tree_store. If @parent is non-%NULL, then it will prepend the new row before the first child of @parent, otherwise it will prepend a row to the top level. @iter will be changed to point to this new row. The row will be empty after this function is called. To fill in values, you need to call gtk_tree_store_set() or gtk_tree_store_set_value(). A #GtkTreeStore An unset #GtkTreeIter to set to the prepended row A valid #GtkTreeIter, or %NULL Removes @iter from @tree_store. After being removed, @iter is set to the next valid row at that level, or invalidated if it previously pointed to the last one. %TRUE if @iter is still valid, %FALSE if not. A #GtkTreeStore A valid #GtkTreeIter Reorders the children of @parent in @tree_store to follow the order indicated by @new_order. Note that this function only works with unsorted stores. A #GtkTreeStore A #GtkTreeIter, or %NULL an array of integers mapping the new position of each child to its old position before the re-ordering, i.e. @new_order`[newpos] = oldpos`. Sets the value of one or more cells in the row referenced by @iter. The variable argument list should contain integer column numbers, each column number followed by the value to be set. The list is terminated by a -1. For example, to set column 0 with type %G_TYPE_STRING to “Foo”, you would write `gtk_tree_store_set (store, iter, 0, "Foo", -1)`. The value will be referenced by the store if it is a %G_TYPE_OBJECT, and it will be copied if it is a %G_TYPE_STRING or %G_TYPE_BOXED. A #GtkTreeStore A valid #GtkTreeIter for the row being modified pairs of column number and value, terminated with -1 This function is meant primarily for #GObjects that inherit from #GtkTreeStore, and should only be used when constructing a new #GtkTreeStore. It will not function after a row has been added, or a method on the #GtkTreeModel interface is called. A #GtkTreeStore Number of columns for the tree store An array of #GType types, one for each column See gtk_tree_store_set(); this version takes a va_list for use by language bindings. A #GtkTreeStore A valid #GtkTreeIter for the row being modified va_list of column/value pairs Sets the data in the cell specified by @iter and @column. The type of @value must be convertible to the type of the column. a #GtkTreeStore A valid #GtkTreeIter for the row being modified column number to modify new value for the cell A variant of gtk_tree_store_set_valist() which takes the columns and values as two arrays, instead of varargs. This function is mainly intended for language bindings or in case the number of columns to change is not known until run-time. A #GtkTreeStore A valid #GtkTreeIter for the row being modified an array of column numbers an array of GValues the length of the @columns and @values arrays Swaps @a and @b in the same level of @tree_store. Note that this function only works with unsorted stores. A #GtkTreeStore. A #GtkTreeIter. Another #GtkTreeIter. Widget that displays any object that implements the #GtkTreeModel interface. Please refer to the [tree widget conceptual overview][TreeWidget] for an overview of all the objects and data types related to the tree widget and how they work together. Several different coordinate systems are exposed in the GtkTreeView API. These are: ![](tree-view-coordinates.png) Coordinate systems in GtkTreeView API: - Widget coordinates: Coordinates relative to the widget (usually `widget->window`). - Bin window coordinates: Coordinates relative to the window that GtkTreeView renders to. - Tree coordinates: Coordinates relative to the entire scrollable area of GtkTreeView. These coordinates start at (0, 0) for row 0 of the tree. Several functions are available for converting between the different coordinate systems. The most common translations are between widget and bin window coordinates and between bin window and tree coordinates. For the former you can use gtk_tree_view_convert_widget_to_bin_window_coords() (and vice versa), for the latter gtk_tree_view_convert_bin_window_to_tree_coords() (and vice versa). # GtkTreeView as GtkBuildable The GtkTreeView implementation of the GtkBuildable interface accepts #GtkTreeViewColumn objects as <child> elements and exposes the internal #GtkTreeSelection in UI definitions. An example of a UI definition fragment with GtkTreeView: |[ <object class="GtkTreeView" id="treeview"> <property name="model">liststore1</property> <child> <object class="GtkTreeViewColumn" id="test-column"> <property name="title">Test</property> <child> <object class="GtkCellRendererText" id="test-renderer"/> <attributes> <attribute name="text">1</attribute> </attributes> </child> </object> </child> <child internal-child="selection"> <object class="GtkTreeSelection" id="selection"> <signal name="changed" handler="on_treeview_selection_changed"/> </object> </child> </object> ]| # CSS nodes |[<!-- language="plain" --> treeview.view ├── header │ ├── <column header> ┊ ┊ │ ╰── <column header> │ ╰── [rubberband] ]| GtkTreeView has a main CSS node with name treeview and style class .view. It has a subnode with name header, which is the parent for all the column header widgets' CSS nodes. For rubberband selection, a subnode with name rubberband is used. Creates a new #GtkTreeView widget. A newly created #GtkTreeView widget. Creates a new #GtkTreeView widget with the model initialized to @model. A newly created #GtkTreeView widget. the model. Activates the cell determined by @path and @column. A #GtkTreeView The #GtkTreePath to be activated. The #GtkTreeViewColumn to be activated. Appends @column to the list of columns. If @tree_view has “fixed_height” mode enabled, then @column must have its “sizing” property set to be GTK_TREE_VIEW_COLUMN_FIXED. The number of columns in @tree_view after appending. A #GtkTreeView. The #GtkTreeViewColumn to add. Recursively collapses all visible, expanded nodes in @tree_view. A #GtkTreeView. Collapses a row (hides its child rows, if they exist). %TRUE if the row was collapsed. a #GtkTreeView path to a row in the @tree_view Resizes all columns to their optimal width. Only works after the treeview has been realized. A #GtkTreeView. Converts bin_window coordinates to coordinates for the tree (the full scrollable area of the tree). a #GtkTreeView X coordinate relative to bin_window Y coordinate relative to bin_window return location for tree X coordinate return location for tree Y coordinate Converts bin_window coordinates (see gtk_tree_view_get_bin_window()) to widget relative coordinates. a #GtkTreeView bin_window X coordinate bin_window Y coordinate return location for widget X coordinate return location for widget Y coordinate Converts tree coordinates (coordinates in full scrollable area of the tree) to bin_window coordinates. a #GtkTreeView tree X coordinate tree Y coordinate return location for X coordinate relative to bin_window return location for Y coordinate relative to bin_window Converts tree coordinates (coordinates in full scrollable area of the tree) to widget coordinates. a #GtkTreeView X coordinate relative to the tree Y coordinate relative to the tree return location for widget X coordinate return location for widget Y coordinate Converts widget coordinates to coordinates for the bin_window (see gtk_tree_view_get_bin_window()). a #GtkTreeView X coordinate relative to the widget Y coordinate relative to the widget return location for bin_window X coordinate return location for bin_window Y coordinate Converts widget coordinates to coordinates for the tree (the full scrollable area of the tree). a #GtkTreeView X coordinate relative to the widget Y coordinate relative to the widget return location for tree X coordinate return location for tree Y coordinate Creates a #cairo_surface_t representation of the row at @path. This image is used for a drag icon. a newly-allocated surface of the drag icon. a #GtkTreeView a #GtkTreePath in @tree_view Turns @tree_view into a drop destination for automatic DND. Calling this method sets #GtkTreeView:reorderable to %FALSE. a #GtkTreeView the table of targets that the drag will support the number of items in @targets the bitmask of possible actions for a drag from this widget Turns @tree_view into a drag source for automatic DND. Calling this method sets #GtkTreeView:reorderable to %FALSE. a #GtkTreeView Mask of allowed buttons to start drag the table of targets that the drag will support the number of items in @targets the bitmask of possible actions for a drag from this widget Recursively expands all nodes in the @tree_view. A #GtkTreeView. Opens the row so its children are visible. %TRUE if the row existed and had children a #GtkTreeView path to a row whether to recursively expand, or just expand immediate children Expands the row at @path. This will also expand all parent rows of @path as necessary. A #GtkTreeView. path to a row. Gets the setting set by gtk_tree_view_set_activate_on_single_click(). %TRUE if row-activated will be emitted on a single click a #GtkTreeView Fills the bounding rectangle in bin_window coordinates for the cell at the row specified by @path and the column specified by @column. If @path is %NULL, or points to a node not found in the tree, the @y and @height fields of the rectangle will be filled with 0. If @column is %NULL, the @x and @width fields will be filled with 0. The returned rectangle is equivalent to the @background_area passed to gtk_cell_renderer_render(). These background areas tile to cover the entire bin window. Contrast with the @cell_area, returned by gtk_tree_view_get_cell_area(), which returns only the cell itself, excluding surrounding borders and the tree expander area. a #GtkTreeView a #GtkTreePath for the row, or %NULL to get only horizontal coordinates a #GtkTreeViewColumn for the column, or %NULL to get only vertical coordiantes rectangle to fill with cell background rect Returns the window that @tree_view renders to. This is used primarily to compare to `event->window` to confirm that the event on @tree_view is on the right window. A #GdkWindow, or %NULL when @tree_view hasn’t been realized yet. A #GtkTreeView Fills the bounding rectangle in bin_window coordinates for the cell at the row specified by @path and the column specified by @column. If @path is %NULL, or points to a path not currently displayed, the @y and @height fields of the rectangle will be filled with 0. If @column is %NULL, the @x and @width fields will be filled with 0. The sum of all cell rects does not cover the entire tree; there are extra pixels in between rows, for example. The returned rectangle is equivalent to the @cell_area passed to gtk_cell_renderer_render(). This function is only valid if @tree_view is realized. a #GtkTreeView a #GtkTreePath for the row, or %NULL to get only horizontal coordinates a #GtkTreeViewColumn for the column, or %NULL to get only vertical coordinates rectangle to fill with cell rect Gets the #GtkTreeViewColumn at the given position in the #tree_view. The #GtkTreeViewColumn, or %NULL if the position is outside the range of columns. A #GtkTreeView. The position of the column, counting from 0. Returns a #GList of all the #GtkTreeViewColumn s currently in @tree_view. The returned list must be freed with g_list_free (). A list of #GtkTreeViewColumn s A #GtkTreeView Fills in @path and @focus_column with the current path and focus column. If the cursor isn’t currently set, then *@path will be %NULL. If no column currently has focus, then *@focus_column will be %NULL. The returned #GtkTreePath must be freed with gtk_tree_path_free() when you are done with it. A #GtkTreeView A pointer to be filled with the current cursor path, or %NULL A pointer to be filled with the current focus column, or %NULL Determines the destination row for a given position. @drag_x and @drag_y are expected to be in widget coordinates. This function is only meaningful if @tree_view is realized. Therefore this function will always return %FALSE if @tree_view is not realized or does not have a model. whether there is a row at the given position, %TRUE if this is indeed the case. a #GtkTreeView the position to determine the destination row for the position to determine the destination row for Return location for the path of the highlighted row, or %NULL. Return location for the drop position, or %NULL Gets information about the row that is highlighted for feedback. a #GtkTreeView Return location for the path of the highlighted row, or %NULL. Return location for the drop position, or %NULL Returns whether or not the tree allows to start interactive searching by typing in text. whether or not to let the user search interactively A #GtkTreeView Returns whether or not tree lines are drawn in @tree_view. %TRUE if tree lines are drawn in @tree_view, %FALSE otherwise. a #GtkTreeView. Returns the column that is the current expander column. This column has the expander arrow drawn next to it. The expander column. A #GtkTreeView Returns whether fixed height mode is turned on for @tree_view. %TRUE if @tree_view is in fixed height mode a #GtkTreeView Returns which grid lines are enabled in @tree_view. a #GtkTreeViewGridLines value indicating which grid lines are enabled. a #GtkTreeView Gets the #GtkAdjustment currently being used for the horizontal aspect. Use gtk_scrollable_get_hadjustment() A #GtkAdjustment object, or %NULL if none is currently being used. A #GtkTreeView Returns whether all header columns are clickable. %TRUE if all header columns are clickable, otherwise %FALSE A #GtkTreeView. Returns %TRUE if the headers on the @tree_view are visible. Whether the headers are visible or not. A #GtkTreeView. Returns whether hover expansion mode is turned on for @tree_view. %TRUE if @tree_view is in hover expansion mode a #GtkTreeView Returns whether hover selection mode is turned on for @tree_view. %TRUE if @tree_view is in hover selection mode a #GtkTreeView Returns the amount, in pixels, of extra indentation for child levels in @tree_view. the amount of extra indentation for child levels in @tree_view. A return value of 0 means that this feature is disabled. a #GtkTreeView. Returns the model the #GtkTreeView is based on. Returns %NULL if the model is unset. A #GtkTreeModel, or %NULL if none is currently being used. a #GtkTreeView Queries the number of columns in the given @tree_view. The number of columns in the @tree_view a #GtkTreeView Finds the path at the point (@x, @y), relative to bin_window coordinates (please see gtk_tree_view_get_bin_window()). That is, @x and @y are relative to an events coordinates. @x and @y must come from an event on the @tree_view only where `event->window == gtk_tree_view_get_bin_window ()`. It is primarily for things like popup menus. If @path is non-%NULL, then it will be filled with the #GtkTreePath at that point. This path should be freed with gtk_tree_path_free(). If @column is non-%NULL, then it will be filled with the column at that point. @cell_x and @cell_y return the coordinates relative to the cell background (i.e. the @background_area passed to gtk_cell_renderer_render()). This function is only meaningful if @tree_view is realized. Therefore this function will always return %FALSE if @tree_view is not realized or does not have a model. For converting widget coordinates (eg. the ones you get from GtkWidget::query-tooltip), please see gtk_tree_view_convert_widget_to_bin_window_coords(). %TRUE if a row exists at that coordinate. A #GtkTreeView. The x position to be identified (relative to bin_window). The y position to be identified (relative to bin_window). A pointer to a #GtkTreePath pointer to be filled in, or %NULL A pointer to a #GtkTreeViewColumn pointer to be filled in, or %NULL A pointer where the X coordinate relative to the cell can be placed, or %NULL A pointer where the Y coordinate relative to the cell can be placed, or %NULL Retrieves whether the user can reorder the tree via drag-and-drop. See gtk_tree_view_set_reorderable(). %TRUE if the tree can be reordered. a #GtkTreeView Returns the current row separator function. the current row separator function. a #GtkTreeView Returns whether rubber banding is turned on for @tree_view. If the selection mode is #GTK_SELECTION_MULTIPLE, rubber banding will allow the user to select multiple rows by dragging the mouse. %TRUE if rubber banding in @tree_view is enabled. a #GtkTreeView Gets the setting set by gtk_tree_view_set_rules_hint(). %TRUE if the hint is set a #GtkTreeView Gets the column searched on by the interactive search code. the column the interactive search code searches in. A #GtkTreeView Returns the #GtkEntry which is currently in use as interactive search entry for @tree_view. In case the built-in entry is being used, %NULL will be returned. the entry currently in use as search entry. A #GtkTreeView Returns the compare function currently in use. the currently used compare function for the search code. A #GtkTreeView Returns the positioning function currently in use. the currently used function for positioning the search dialog. A #GtkTreeView Gets the #GtkTreeSelection associated with @tree_view. A #GtkTreeSelection object. A #GtkTreeView. Returns whether or not expanders are drawn in @tree_view. %TRUE if expanders are drawn in @tree_view, %FALSE otherwise. a #GtkTreeView. Returns the column of @tree_view’s model which is being used for displaying tooltips on @tree_view’s rows. the index of the tooltip column that is currently being used, or -1 if this is disabled. a #GtkTreeView This function is supposed to be used in a #GtkWidget::query-tooltip signal handler for #GtkTreeView. The @x, @y and @keyboard_tip values which are received in the signal handler, should be passed to this function without modification. The return value indicates whether there is a tree view row at the given coordinates (%TRUE) or not (%FALSE) for mouse tooltips. For keyboard tooltips the row returned will be the cursor row. When %TRUE, then any of @model, @path and @iter which have been provided will be set to point to that row and the corresponding model. @x and @y will always be converted to be relative to @tree_view’s bin_window if @keyboard_tooltip is %FALSE. whether or not the given tooltip context points to a row. a #GtkTreeView the x coordinate (relative to widget coordinates) the y coordinate (relative to widget coordinates) whether this is a keyboard tooltip or not a pointer to receive a #GtkTreeModel or %NULL a pointer to receive a #GtkTreePath or %NULL a pointer to receive a #GtkTreeIter or %NULL Gets the #GtkAdjustment currently being used for the vertical aspect. Use gtk_scrollable_get_vadjustment() A #GtkAdjustment object, or %NULL if none is currently being used. A #GtkTreeView Sets @start_path and @end_path to be the first and last visible path. Note that there may be invisible paths in between. The paths should be freed with gtk_tree_path_free() after use. %TRUE, if valid paths were placed in @start_path and @end_path. A #GtkTreeView Return location for start of region, or %NULL. Return location for end of region, or %NULL. Fills @visible_rect with the currently-visible region of the buffer, in tree coordinates. Convert to bin_window coordinates with gtk_tree_view_convert_tree_to_bin_window_coords(). Tree coordinates start at 0,0 for row 0 of the tree, and cover the entire scrollable area of the tree. a #GtkTreeView rectangle to fill This inserts the @column into the @tree_view at @position. If @position is -1, then the column is inserted at the end. If @tree_view has “fixed_height” mode enabled, then @column must have its “sizing” property set to be GTK_TREE_VIEW_COLUMN_FIXED. The number of columns in @tree_view after insertion. A #GtkTreeView. The #GtkTreeViewColumn to be inserted. The position to insert @column in. Creates a new #GtkTreeViewColumn and inserts it into the @tree_view at @position. If @position is -1, then the newly created column is inserted at the end. The column is initialized with the attributes given. If @tree_view has “fixed_height” mode enabled, then the new column will have its sizing property set to be GTK_TREE_VIEW_COLUMN_FIXED. The number of columns in @tree_view after insertion. A #GtkTreeView The position to insert the new column in The title to set the header to The #GtkCellRenderer A %NULL-terminated list of attributes Convenience function that inserts a new column into the #GtkTreeView with the given cell renderer and a #GtkTreeCellDataFunc to set cell renderer attributes (normally using data from the model). See also gtk_tree_view_column_set_cell_data_func(), gtk_tree_view_column_pack_start(). If @tree_view has “fixed_height” mode enabled, then the new column will have its “sizing” property set to be GTK_TREE_VIEW_COLUMN_FIXED. number of columns in the tree view post-insert a #GtkTreeView Position to insert, -1 for append column title cell renderer for column function to set attributes of cell renderer data for @func destroy notifier for @data Determine whether the point (@x, @y) in @tree_view is blank, that is no cell content nor an expander arrow is drawn at the location. If so, the location can be considered as the background. You might wish to take special action on clicks on the background, such as clearing a current selection, having a custom context menu or starting rubber banding. The @x and @y coordinate that are provided must be relative to bin_window coordinates. That is, @x and @y must come from an event on @tree_view where `event->window == gtk_tree_view_get_bin_window ()`. For converting widget coordinates (eg. the ones you get from GtkWidget::query-tooltip), please see gtk_tree_view_convert_widget_to_bin_window_coords(). The @path, @column, @cell_x and @cell_y arguments will be filled in likewise as for gtk_tree_view_get_path_at_pos(). Please see gtk_tree_view_get_path_at_pos() for more information. %TRUE if the area at the given coordinates is blank, %FALSE otherwise. A #GtkTreeView The x position to be identified (relative to bin_window) The y position to be identified (relative to bin_window) A pointer to a #GtkTreePath pointer to be filled in, or %NULL A pointer to a #GtkTreeViewColumn pointer to be filled in, or %NULL A pointer where the X coordinate relative to the cell can be placed, or %NULL A pointer where the Y coordinate relative to the cell can be placed, or %NULL Returns whether a rubber banding operation is currently being done in @tree_view. %TRUE if a rubber banding operation is currently being done in @tree_view. a #GtkTreeView Calls @func on all expanded rows. A #GtkTreeView A function to be called User data to be passed to the function. Moves @column to be after to @base_column. If @base_column is %NULL, then @column is placed in the first position. A #GtkTreeView The #GtkTreeViewColumn to be moved. The #GtkTreeViewColumn to be moved relative to, or %NULL. Removes @column from @tree_view. The number of columns in @tree_view after removing. A #GtkTreeView. The #GtkTreeViewColumn to remove. Activates the cell determined by @path and @column. A #GtkTreeView The #GtkTreePath to be activated. The #GtkTreeViewColumn to be activated. Returns %TRUE if the node pointed to by @path is expanded in @tree_view. %TRUE if #path is expanded. A #GtkTreeView. A #GtkTreePath to test expansion state. Moves the alignments of @tree_view to the position specified by @column and @path. If @column is %NULL, then no horizontal scrolling occurs. Likewise, if @path is %NULL no vertical scrolling occurs. At a minimum, one of @column or @path need to be non-%NULL. @row_align determines where the row is placed, and @col_align determines where @column is placed. Both are expected to be between 0.0 and 1.0. 0.0 means left/top alignment, 1.0 means right/bottom alignment, 0.5 means center. If @use_align is %FALSE, then the alignment arguments are ignored, and the tree does the minimum amount of work to scroll the cell onto the screen. This means that the cell will be scrolled to the edge closest to its current position. If the cell is currently visible on the screen, nothing is done. This function only works if the model is set, and @path is a valid row on the model. If the model changes before the @tree_view is realized, the centered path will be modified to reflect this change. A #GtkTreeView. The path of the row to move to, or %NULL. The #GtkTreeViewColumn to move horizontally to, or %NULL. whether to use alignment arguments, or %FALSE. The vertical alignment of the row specified by @path. The horizontal alignment of the column specified by @column. Scrolls the tree view such that the top-left corner of the visible area is @tree_x, @tree_y, where @tree_x and @tree_y are specified in tree coordinates. The @tree_view must be realized before this function is called. If it isn't, you probably want to be using gtk_tree_view_scroll_to_cell(). If either @tree_x or @tree_y are -1, then that direction isn’t scrolled. a #GtkTreeView X coordinate of new top-left pixel of visible area, or -1 Y coordinate of new top-left pixel of visible area, or -1 Cause the #GtkTreeView::row-activated signal to be emitted on a single click instead of a double click. a #GtkTreeView %TRUE to emit row-activated on a single click Sets a user function for determining where a column may be dropped when dragged. This function is called on every column pair in turn at the beginning of a column drag to determine where a drop can take place. The arguments passed to @func are: the @tree_view, the #GtkTreeViewColumn being dragged, the two #GtkTreeViewColumn s determining the drop spot, and @user_data. If either of the #GtkTreeViewColumn arguments for the drop spot are %NULL, then they indicate an edge. If @func is set to be %NULL, then @tree_view reverts to the default behavior of allowing all columns to be dropped everywhere. A #GtkTreeView. A function to determine which columns are reorderable, or %NULL. User data to be passed to @func, or %NULL Destroy notifier for @user_data, or %NULL Sets the current keyboard focus to be at @path, and selects it. This is useful when you want to focus the user’s attention on a particular row. If @focus_column is not %NULL, then focus is given to the column specified by it. Additionally, if @focus_column is specified, and @start_editing is %TRUE, then editing should be started in the specified cell. This function is often followed by @gtk_widget_grab_focus (@tree_view) in order to give keyboard focus to the widget. Please note that editing can only happen when the widget is realized. If @path is invalid for @model, the current cursor (if any) will be unset and the function will return without failing. A #GtkTreeView A #GtkTreePath A #GtkTreeViewColumn, or %NULL %TRUE if the specified cell should start being edited. Sets the current keyboard focus to be at @path, and selects it. This is useful when you want to focus the user’s attention on a particular row. If @focus_column is not %NULL, then focus is given to the column specified by it. If @focus_column and @focus_cell are not %NULL, and @focus_column contains 2 or more editable or activatable cells, then focus is given to the cell specified by @focus_cell. Additionally, if @focus_column is specified, and @start_editing is %TRUE, then editing should be started in the specified cell. This function is often followed by @gtk_widget_grab_focus (@tree_view) in order to give keyboard focus to the widget. Please note that editing can only happen when the widget is realized. If @path is invalid for @model, the current cursor (if any) will be unset and the function will return without failing. A #GtkTreeView A #GtkTreePath A #GtkTreeViewColumn, or %NULL A #GtkCellRenderer, or %NULL %TRUE if the specified cell should start being edited. This function should almost never be used. It is meant for private use by ATK for determining the number of visible children that are removed when the user collapses a row, or a row is deleted. Accessibility does not need the function anymore. A #GtkTreeView Function to be called when a view row is destroyed, or %NULL User data to be passed to @func, or %NULL Destroy notifier for @data, or %NULL Sets the row that is highlighted for feedback. If @path is %NULL, an existing highlight is removed. a #GtkTreeView The path of the row to highlight, or %NULL Specifies whether to drop before, after or into the row If @enable_search is set, then the user can type in text to search through the tree interactively (this is sometimes called "typeahead find"). Note that even if this is %FALSE, the user can still initiate a search using the “start-interactive-search” key binding. A #GtkTreeView %TRUE, if the user can search interactively Sets whether to draw lines interconnecting the expanders in @tree_view. This does not have any visible effects for lists. a #GtkTreeView %TRUE to enable tree line drawing, %FALSE otherwise. Sets the column to draw the expander arrow at. It must be in @tree_view. If @column is %NULL, then the expander arrow is always at the first visible column. If you do not want expander arrow to appear in your tree, set the expander column to a hidden column. A #GtkTreeView %NULL, or the column to draw the expander arrow at. Enables or disables the fixed height mode of @tree_view. Fixed height mode speeds up #GtkTreeView by assuming that all rows have the same height. Only enable this option if all rows are the same height and all columns are of type %GTK_TREE_VIEW_COLUMN_FIXED. a #GtkTreeView %TRUE to enable fixed height mode Sets which grid lines to draw in @tree_view. a #GtkTreeView a #GtkTreeViewGridLines value indicating which grid lines to enable. Sets the #GtkAdjustment for the current horizontal aspect. Use gtk_scrollable_set_hadjustment() A #GtkTreeView The #GtkAdjustment to set, or %NULL Allow the column title buttons to be clicked. A #GtkTreeView. %TRUE if the columns are clickable. Sets the visibility state of the headers. A #GtkTreeView. %TRUE if the headers are visible Enables or disables the hover expansion mode of @tree_view. Hover expansion makes rows expand or collapse if the pointer moves over them. a #GtkTreeView %TRUE to enable hover selection mode Enables or disables the hover selection mode of @tree_view. Hover selection makes the selected row follow the pointer. Currently, this works only for the selection modes %GTK_SELECTION_SINGLE and %GTK_SELECTION_BROWSE. a #GtkTreeView %TRUE to enable hover selection mode Sets the amount of extra indentation for child levels to use in @tree_view in addition to the default indentation. The value should be specified in pixels, a value of 0 disables this feature and in this case only the default indentation will be used. This does not have any visible effects for lists. a #GtkTreeView the amount, in pixels, of extra indentation in @tree_view. Sets the model for a #GtkTreeView. If the @tree_view already has a model set, it will remove it before setting the new model. If @model is %NULL, then it will unset the old model. A #GtkTreeView. The model. This function is a convenience function to allow you to reorder models that support the #GtkTreeDragSourceIface and the #GtkTreeDragDestIface. Both #GtkTreeStore and #GtkListStore support these. If @reorderable is %TRUE, then the user can reorder the model by dragging and dropping rows. The developer can listen to these changes by connecting to the model’s #GtkTreeModel::row-inserted and #GtkTreeModel::row-deleted signals. The reordering is implemented by setting up the tree view as a drag source and destination. Therefore, drag and drop can not be used in a reorderable view for any other purpose. This function does not give you any degree of control over the order -- any reordering is allowed. If more control is needed, you should probably handle drag and drop manually. A #GtkTreeView. %TRUE, if the tree can be reordered. Sets the row separator function, which is used to determine whether a row should be drawn as a separator. If the row separator function is %NULL, no separators are drawn. This is the default value. a #GtkTreeView a #GtkTreeViewRowSeparatorFunc user data to pass to @func, or %NULL destroy notifier for @data, or %NULL Enables or disables rubber banding in @tree_view. If the selection mode is #GTK_SELECTION_MULTIPLE, rubber banding will allow the user to select multiple rows by dragging the mouse. a #GtkTreeView %TRUE to enable rubber banding Sets a hint for the theme to draw even/odd rows in the @tree_view with different colors, also known as "zebra striping". This function tells the GTK+ theme that the user interface for your application requires users to read across tree rows and associate cells with one another. Do not use it just because you prefer the appearance of the ruled tree; that’s a question for the theme. Some themes will draw tree rows in alternating colors even when rules are turned off, and users who prefer that appearance all the time can choose those themes. You should call this function only as a semantic hint to the theme engine that your tree makes alternating colors useful from a functional standpoint (since it has lots of columns, generally). a #GtkTreeView %TRUE if the tree requires reading across rows Sets @column as the column where the interactive search code should search in for the current model. If the search column is set, users can use the “start-interactive-search” key binding to bring up search popup. The enable-search property controls whether simply typing text will also start an interactive search. Note that @column refers to a column of the current model. The search column is reset to -1 when the model is changed. A #GtkTreeView the column of the model to search in, or -1 to disable searching Sets the entry which the interactive search code will use for this @tree_view. This is useful when you want to provide a search entry in our interface at all time at a fixed position. Passing %NULL for @entry will make the interactive search code use the built-in popup entry again. A #GtkTreeView the entry the interactive search code of @tree_view should use or %NULL Sets the compare function for the interactive search capabilities; note that somewhat like strcmp() returning 0 for equality #GtkTreeViewSearchEqualFunc returns %FALSE on matches. A #GtkTreeView the compare function to use during the search user data to pass to @search_equal_func, or %NULL Destroy notifier for @search_user_data, or %NULL Sets the function to use when positioning the search dialog. A #GtkTreeView the function to use to position the search dialog, or %NULL to use the default search position function user data to pass to @func, or %NULL Destroy notifier for @data, or %NULL Sets whether to draw and enable expanders and indent child rows in @tree_view. When disabled there will be no expanders visible in trees and there will be no way to expand and collapse rows by default. Also note that hiding the expanders will disable the default indentation. You can set a custom indentation in this case using gtk_tree_view_set_level_indentation(). This does not have any visible effects for lists. a #GtkTreeView %TRUE to enable expander drawing, %FALSE otherwise. Sets the tip area of @tooltip to the area @path, @column and @cell have in common. For example if @path is %NULL and @column is set, the tip area will be set to the full area covered by @column. See also gtk_tooltip_set_tip_area(). Note that if @path is not specified and @cell is set and part of a column containing the expander, the tooltip might not show and hide at the correct position. In such cases @path must be set to the current node under the mouse cursor for this function to operate correctly. See also gtk_tree_view_set_tooltip_column() for a simpler alternative. a #GtkTreeView a #GtkTooltip a #GtkTreePath or %NULL a #GtkTreeViewColumn or %NULL a #GtkCellRenderer or %NULL If you only plan to have simple (text-only) tooltips on full rows, you can use this function to have #GtkTreeView handle these automatically for you. @column should be set to the column in @tree_view’s model containing the tooltip texts, or -1 to disable this feature. When enabled, #GtkWidget:has-tooltip will be set to %TRUE and @tree_view will connect a #GtkWidget::query-tooltip signal handler. Note that the signal handler sets the text with gtk_tooltip_set_markup(), so &, <, etc have to be escaped in the text. a #GtkTreeView an integer, which is a valid column number for @tree_view’s model Sets the tip area of @tooltip to be the area covered by the row at @path. See also gtk_tree_view_set_tooltip_column() for a simpler alternative. See also gtk_tooltip_set_tip_area(). a #GtkTreeView a #GtkTooltip a #GtkTreePath Sets the #GtkAdjustment for the current vertical aspect. Use gtk_scrollable_set_vadjustment() A #GtkTreeView The #GtkAdjustment to set, or %NULL Undoes the effect of gtk_tree_view_enable_model_drag_dest(). Calling this method sets #GtkTreeView:reorderable to %FALSE. a #GtkTreeView Undoes the effect of gtk_tree_view_enable_model_drag_source(). Calling this method sets #GtkTreeView:reorderable to %FALSE. a #GtkTreeView The activate-on-single-click property specifies whether the "row-activated" signal will be emitted after a single click. Setting the ::fixed-height-mode property to %TRUE speeds up #GtkTreeView by assuming that all rows have the same height. Only enable this option if all rows are the same height. Please see gtk_tree_view_set_fixed_height_mode() for more information on this option. Enables or disables the hover expansion mode of @tree_view. Hover expansion makes rows expand or collapse if the pointer moves over them. This mode is primarily intended for treeviews in popups, e.g. in #GtkComboBox or #GtkEntryCompletion. Enables or disables the hover selection mode of @tree_view. Hover selection makes the selected row follow the pointer. Currently, this works only for the selection modes %GTK_SELECTION_SINGLE and %GTK_SELECTION_BROWSE. This mode is primarily intended for treeviews in popups, e.g. in #GtkComboBox or #GtkEntryCompletion. Extra indentation for each level. Sets a hint to the theme to draw rows in alternating colors. The theme is responsible for drawing rows using zebra striping %TRUE if the view has expanders. The number of columns of the treeview has changed. The position of the cursor (focused cell) has changed. The #GtkTreeView::move-cursor signal is a [keybinding signal][GtkBindingSignal] which gets emitted when the user presses one of the cursor keys. Applications should not connect to it, but may emit it with g_signal_emit_by_name() if they need to control the cursor programmatically. In contrast to gtk_tree_view_set_cursor() and gtk_tree_view_set_cursor_on_cell() when moving horizontally #GtkTreeView::move-cursor does not reset the current selection. %TRUE if @step is supported, %FALSE otherwise. the granularity of the move, as a #GtkMovementStep. %GTK_MOVEMENT_LOGICAL_POSITIONS, %GTK_MOVEMENT_VISUAL_POSITIONS, %GTK_MOVEMENT_DISPLAY_LINES, %GTK_MOVEMENT_PAGES and %GTK_MOVEMENT_BUFFER_ENDS are supported. %GTK_MOVEMENT_LOGICAL_POSITIONS and %GTK_MOVEMENT_VISUAL_POSITIONS are treated identically. the direction to move: +1 to move forwards; -1 to move backwards. The resulting movement is undefined for all other values. The "row-activated" signal is emitted when the method gtk_tree_view_row_activated() is called, when the user double clicks a treeview row with the "activate-on-single-click" property set to %FALSE, or when the user single clicks a row when the "activate-on-single-click" property set to %TRUE. It is also emitted when a non-editable row is selected and one of the keys: Space, Shift+Space, Return or Enter is pressed. For selection handling refer to the [tree widget conceptual overview][TreeWidget] as well as #GtkTreeSelection. the #GtkTreePath for the activated row the #GtkTreeViewColumn in which the activation occurred The given row has been collapsed (child nodes are hidden). the tree iter of the collapsed row a tree path that points to the row The given row has been expanded (child nodes are shown). the tree iter of the expanded row a tree path that points to the row The given row is about to be collapsed (hide its children nodes). Use this signal if you need to control the collapsibility of individual rows. %FALSE to allow collapsing, %TRUE to reject the tree iter of the row to collapse a tree path that points to the row The given row is about to be expanded (show its children nodes). Use this signal if you need to control the expandability of individual rows. %FALSE to allow expansion, %TRUE to reject the tree iter of the row to expand a tree path that points to the row A #GtkTreeView The #GtkTreePath to be activated. The #GtkTreeViewColumn to be activated. The GtkTreeViewColumn object represents a visible column in a #GtkTreeView widget. It allows to set properties of the column header, and functions as a holding pen for the cell renderers which determine how the data in the column is displayed. Please refer to the [tree widget conceptual overview][TreeWidget] for an overview of all the objects and data types related to the tree widget and how they work together. Creates a new #GtkTreeViewColumn. A newly created #GtkTreeViewColumn. Creates a new #GtkTreeViewColumn using @area to render its cells. A newly created #GtkTreeViewColumn. the #GtkCellArea that the newly created column should use to layout cells. Creates a new #GtkTreeViewColumn with a number of default values. This is equivalent to calling gtk_tree_view_column_set_title(), gtk_tree_view_column_pack_start(), and gtk_tree_view_column_set_attributes() on the newly created #GtkTreeViewColumn. Here’s a simple example: |[<!-- language="C" --> enum { TEXT_COLUMN, COLOR_COLUMN, N_COLUMNS }; // ... { GtkTreeViewColumn *column; GtkCellRenderer *renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("Title", renderer, "text", TEXT_COLUMN, "foreground", COLOR_COLUMN, NULL); } ]| A newly created #GtkTreeViewColumn. The title to set the header to The #GtkCellRenderer A %NULL-terminated list of attributes Emits the “clicked” signal on the column. This function will only work if @tree_column is clickable. a #GtkTreeViewColumn Adds an attribute mapping to the list in @tree_column. The @column is the column of the model to get a value from, and the @attribute is the parameter on @cell_renderer to be set from the value. So for example if column 2 of the model contains strings, you could have the “text” attribute of a #GtkCellRendererText get its values from column 2. A #GtkTreeViewColumn. the #GtkCellRenderer to set attributes on An attribute on the renderer The column position on the model to get the attribute from. Obtains the horizontal position and size of a cell in a column. If the cell is not found in the column, @start_pos and @width are not changed and %FALSE is returned. %TRUE if @cell belongs to @tree_column. a #GtkTreeViewColumn a #GtkCellRenderer return location for the horizontal position of @cell within @tree_column, may be %NULL return location for the width of @cell, may be %NULL Obtains the width and height needed to render the column. This is used primarily by the #GtkTreeView. A #GtkTreeViewColumn. The area a cell in the column will be allocated, or %NULL location to return x offset of a cell relative to @cell_area, or %NULL location to return y offset of a cell relative to @cell_area, or %NULL location to return width needed to render a cell, or %NULL location to return height needed to render a cell, or %NULL Returns %TRUE if any of the cells packed into the @tree_column are visible. For this to be meaningful, you must first initialize the cells with gtk_tree_view_column_cell_set_cell_data() %TRUE, if any of the cells packed into the @tree_column are currently visible A #GtkTreeViewColumn Sets the cell renderer based on the @tree_model and @iter. That is, for every attribute mapping in @tree_column, it will get a value from the set column on the @iter, and use that value to set the attribute on the cell renderer. This is used primarily by the #GtkTreeView. A #GtkTreeViewColumn. The #GtkTreeModel to to get the cell renderers attributes from. The #GtkTreeIter to to get the cell renderer’s attributes from. %TRUE, if the row has children %TRUE, if the row has visible children Unsets all the mappings on all renderers on the @tree_column. A #GtkTreeViewColumn Clears all existing attributes previously set with gtk_tree_view_column_set_attributes(). a #GtkTreeViewColumn a #GtkCellRenderer to clear the attribute mapping on. Emits the “clicked” signal on the column. This function will only work if @tree_column is clickable. a #GtkTreeViewColumn Sets the current keyboard focus to be at @cell, if the column contains 2 or more editable and activatable cells. A #GtkTreeViewColumn A #GtkCellRenderer Returns the current x alignment of @tree_column. This value can range between 0.0 and 1.0. The current alignent of @tree_column. A #GtkTreeViewColumn. Returns the button used in the treeview column header The button for the column header. A #GtkTreeViewColumn Returns %TRUE if the user can click on the header for the column. %TRUE if user can click the column header. a #GtkTreeViewColumn Returns %TRUE if the column expands to fill available space. %TRUE if the column expands to fill available space. A #GtkTreeViewColumn. Gets the fixed width of the column. This may not be the actual displayed width of the column; for that, use gtk_tree_view_column_get_width(). The fixed width of the column. A #GtkTreeViewColumn. Returns the maximum width in pixels of the @tree_column, or -1 if no maximum width is set. The maximum width of the @tree_column. A #GtkTreeViewColumn. Returns the minimum width in pixels of the @tree_column, or -1 if no minimum width is set. The minimum width of the @tree_column. A #GtkTreeViewColumn. Returns %TRUE if the @tree_column can be reordered by the user. %TRUE if the @tree_column can be reordered by the user. A #GtkTreeViewColumn Returns %TRUE if the @tree_column can be resized by the end user. %TRUE, if the @tree_column can be resized. A #GtkTreeViewColumn Returns the current type of @tree_column. The type of @tree_column. A #GtkTreeViewColumn. Gets the logical @sort_column_id that the model sorts on when this column is selected for sorting. See gtk_tree_view_column_set_sort_column_id(). the current @sort_column_id for this column, or -1 if this column can’t be used for sorting. a #GtkTreeViewColumn Gets the value set by gtk_tree_view_column_set_sort_indicator(). whether the sort indicator arrow is displayed a #GtkTreeViewColumn Gets the value set by gtk_tree_view_column_set_sort_order(). the sort order the sort indicator is indicating a #GtkTreeViewColumn Returns the spacing of @tree_column. the spacing of @tree_column. A #GtkTreeViewColumn. Returns the title of the widget. the title of the column. This string should not be modified or freed. A #GtkTreeViewColumn. Returns the #GtkTreeView wherein @tree_column has been inserted. If @column is currently not inserted in any tree view, %NULL is returned. The tree view wherein @column has been inserted if any, %NULL otherwise. A #GtkTreeViewColumn Returns %TRUE if @tree_column is visible. whether the column is visible or not. If it is visible, then the tree will show the column. A #GtkTreeViewColumn. Returns the #GtkWidget in the button on the column header. If a custom widget has not been set then %NULL is returned. The #GtkWidget in the column header, or %NULL A #GtkTreeViewColumn. Returns the current size of @tree_column in pixels. The current width of @tree_column. A #GtkTreeViewColumn. Returns the current X offset of @tree_column in pixels. The current X offset of @tree_column. A #GtkTreeViewColumn. Adds the @cell to end of the column. If @expand is %FALSE, then the @cell is allocated no more space than it needs. Any unused space is divided evenly between cells for which @expand is %TRUE. A #GtkTreeViewColumn. The #GtkCellRenderer. %TRUE if @cell is to be given extra space allocated to @tree_column. Packs the @cell into the beginning of the column. If @expand is %FALSE, then the @cell is allocated no more space than it needs. Any unused space is divided evenly between cells for which @expand is %TRUE. A #GtkTreeViewColumn. The #GtkCellRenderer. %TRUE if @cell is to be given extra space allocated to @tree_column. Flags the column, and the cell renderers added to this column, to have their sizes renegotiated. A #GtkTreeViewColumn Sets the alignment of the title or custom widget inside the column header. The alignment determines its location inside the button -- 0.0 for left, 0.5 for center, 1.0 for right. A #GtkTreeViewColumn. The alignment, which is between [0.0 and 1.0] inclusive. Sets the attributes in the list as the attributes of @tree_column. The attributes should be in attribute/column order, as in gtk_tree_view_column_add_attribute(). All existing attributes are removed, and replaced with the new attributes. A #GtkTreeViewColumn the #GtkCellRenderer we’re setting the attributes of A %NULL-terminated list of attributes Sets the #GtkTreeCellDataFunc to use for the column. This function is used instead of the standard attributes mapping for setting the column value, and should set the value of @tree_column's cell renderer as appropriate. @func may be %NULL to remove an older one. A #GtkTreeViewColumn A #GtkCellRenderer The #GtkTreeCellDataFunc to use. The user data for @func. The destroy notification for @func_data Sets the header to be active if @clickable is %TRUE. When the header is active, then it can take keyboard focus, and can be clicked. A #GtkTreeViewColumn. %TRUE if the header is active. Sets the column to take available extra space. This space is shared equally amongst all columns that have the expand set to %TRUE. If no column has this option set, then the last column gets all extra space. By default, every column is created with this %FALSE. Along with “fixed-width”, the “expand” property changes when the column is resized by the user. A #GtkTreeViewColumn. %TRUE if the column should expand to fill available space. If @fixed_width is not -1, sets the fixed width of @tree_column; otherwise unsets it. The effective value of @fixed_width is clamped between the minimum and maximum width of the column; however, the value stored in the “fixed-width” property is not clamped. If the column sizing is #GTK_TREE_VIEW_COLUMN_GROW_ONLY or #GTK_TREE_VIEW_COLUMN_AUTOSIZE, setting a fixed width overrides the automatically calculated width. Note that @fixed_width is only a hint to GTK+; the width actually allocated to the column may be greater or less than requested. Along with “expand”, the “fixed-width” property changes when the column is resized by the user. A #GtkTreeViewColumn. The new fixed width, in pixels, or -1. Sets the maximum width of the @tree_column. If @max_width is -1, then the maximum width is unset. Note, the column can actually be wider than max width if it’s the last column in a view. In this case, the column expands to fill any extra space. A #GtkTreeViewColumn. The maximum width of the column in pixels, or -1. Sets the minimum width of the @tree_column. If @min_width is -1, then the minimum width is unset. A #GtkTreeViewColumn. The minimum width of the column in pixels, or -1. If @reorderable is %TRUE, then the column can be reordered by the end user dragging the header. A #GtkTreeViewColumn %TRUE, if the column can be reordered. If @resizable is %TRUE, then the user can explicitly resize the column by grabbing the outer edge of the column button. If resizable is %TRUE and sizing mode of the column is #GTK_TREE_VIEW_COLUMN_AUTOSIZE, then the sizing mode is changed to #GTK_TREE_VIEW_COLUMN_GROW_ONLY. A #GtkTreeViewColumn %TRUE, if the column can be resized Sets the growth behavior of @tree_column to @type. A #GtkTreeViewColumn. The #GtkTreeViewColumnSizing. Sets the logical @sort_column_id that this column sorts on when this column is selected for sorting. Doing so makes the column header clickable. a #GtkTreeViewColumn The @sort_column_id of the model to sort on. Call this function with a @setting of %TRUE to display an arrow in the header button indicating the column is sorted. Call gtk_tree_view_column_set_sort_order() to change the direction of the arrow. a #GtkTreeViewColumn %TRUE to display an indicator that the column is sorted Changes the appearance of the sort indicator. This does not actually sort the model. Use gtk_tree_view_column_set_sort_column_id() if you want automatic sorting support. This function is primarily for custom sorting behavior, and should be used in conjunction with gtk_tree_sortable_set_sort_column_id() to do that. For custom models, the mechanism will vary. The sort indicator changes direction to indicate normal sort or reverse sort. Note that you must have the sort indicator enabled to see anything when calling this function; see gtk_tree_view_column_set_sort_indicator(). a #GtkTreeViewColumn sort order that the sort indicator should indicate Sets the spacing field of @tree_column, which is the number of pixels to place between cell renderers packed into it. A #GtkTreeViewColumn. distance between cell renderers in pixels. Sets the title of the @tree_column. If a custom widget has been set, then this value is ignored. A #GtkTreeViewColumn. The title of the @tree_column. Sets the visibility of @tree_column. A #GtkTreeViewColumn. %TRUE if the @tree_column is visible. Sets the widget in the header to be @widget. If widget is %NULL, then the header button is set with a #GtkLabel set to the title of @tree_column. A #GtkTreeViewColumn. A child #GtkWidget, or %NULL. The #GtkCellArea used to layout cell renderers for this column. If no area is specified when creating the tree view column with gtk_tree_view_column_new_with_area() a horizontally oriented #GtkCellAreaBox will be used. Logical sort column ID this column sorts on when selected for sorting. Setting the sort column ID makes the column header clickable. Set to -1 to make the column unsortable. a #GtkTreeViewColumn Function type for determining whether @column can be dropped in a particular spot (as determined by @prev_column and @next_column). In left to right locales, @prev_column is on the left of the potential drop spot, and @next_column is on the right. In right to left mode, this is reversed. This function should return %TRUE if the spot is a valid drop spot. Please note that returning %TRUE does not actually indicate that the column drop was made, but is meant only to indicate a possible drop spot to the user. %TRUE, if @column can be dropped in this spot A #GtkTreeView The #GtkTreeViewColumn being dragged A #GtkTreeViewColumn on one side of @column A #GtkTreeViewColumn on the other side of @column user data The sizing method the column uses to determine its width. Please note that @GTK_TREE_VIEW_COLUMN_AUTOSIZE are inefficient for large views, and can make columns appear choppy. Columns only get bigger in reaction to changes in the model Columns resize to be the optimal size everytime the model changes. Columns are a fixed numbers of pixels wide. An enum for determining where a dropped row goes. dropped row is inserted before dropped row is inserted after dropped row becomes a child or is inserted before dropped row becomes a child or is inserted after Used to indicate which grid lines to draw in a tree view. No grid lines. Horizontal grid lines. Vertical grid lines. Horizontal and vertical grid lines. Function used for gtk_tree_view_map_expanded_rows(). A #GtkTreeView The path that’s expanded user data Function type for determining whether the row pointed to by @iter should be rendered as a separator. A common way to implement this is to have a boolean column in the model, whose values the #GtkTreeViewRowSeparatorFunc returns. %TRUE if the row is a separator the #GtkTreeModel a #GtkTreeIter pointing at a row in @model user data A function used for checking whether a row in @model matches a search key string entered by the user. Note the return value is reversed from what you would normally expect, though it has some similarity to strcmp() returning 0 for equal strings. %FALSE if the row matches, %TRUE otherwise. the #GtkTreeModel being searched the search column set by gtk_tree_view_set_search_column() the key string to compare with a #GtkTreeIter pointing the row of @model that should be compared with @key. user data from gtk_tree_view_set_search_equal_func() > GtkUIManager is deprecated since GTK+ 3.10. To construct user interfaces > from XML definitions, you should use #GtkBuilder, #GMenuModel, et al. To > work with actions, use #GAction, #GtkActionable et al. These newer classes > support richer functionality and integration with various desktop shells. > It should be possible to migrate most/all functionality from GtkUIManager. A #GtkUIManager constructs a user interface (menus and toolbars) from one or more UI definitions, which reference actions from one or more action groups. # UI Definitions # {#XML-UI} The UI definitions are specified in an XML format which can be roughly described by the following DTD. > Do not confuse the GtkUIManager UI Definitions described here with > the similarly named [GtkBuilder UI Definitions][BUILDER-UI]. |[ <!ELEMENT ui (menubar|toolbar|popup|accelerator)* > <!ELEMENT menubar (menuitem|separator|placeholder|menu)* > <!ELEMENT menu (menuitem|separator|placeholder|menu)* > <!ELEMENT popup (menuitem|separator|placeholder|menu)* > <!ELEMENT toolbar (toolitem|separator|placeholder)* > <!ELEMENT placeholder (menuitem|toolitem|separator|placeholder|menu)* > <!ELEMENT menuitem EMPTY > <!ELEMENT toolitem (menu?) > <!ELEMENT separator EMPTY > <!ELEMENT accelerator EMPTY > <!ATTLIST menubar name #IMPLIED action #IMPLIED > <!ATTLIST toolbar name #IMPLIED action #IMPLIED > <!ATTLIST popup name #IMPLIED action #IMPLIED accelerators (true|false) #IMPLIED > <!ATTLIST placeholder name #IMPLIED action #IMPLIED > <!ATTLIST separator name #IMPLIED action #IMPLIED expand (true|false) #IMPLIED > <!ATTLIST menu name #IMPLIED action #REQUIRED position (top|bot) #IMPLIED > <!ATTLIST menuitem name #IMPLIED action #REQUIRED position (top|bot) #IMPLIED always-show-image (true|false) #IMPLIED > <!ATTLIST toolitem name #IMPLIED action #REQUIRED position (top|bot) #IMPLIED > <!ATTLIST accelerator name #IMPLIED action #REQUIRED > ]| There are some additional restrictions beyond those specified in the DTD, e.g. every toolitem must have a toolbar in its anchestry and every menuitem must have a menubar or popup in its anchestry. Since a #GMarkupParser is used to parse the UI description, it must not only be valid XML, but valid markup. If a name is not specified, it defaults to the action. If an action is not specified either, the element name is used. The name and action attributes must not contain “/” characters after parsing (since that would mess up path lookup) and must be usable as XML attributes when enclosed in doublequotes, thus they must not “"” characters or references to the &quot; entity. # A UI definition # |[ <ui> <menubar> <menu name="FileMenu" action="FileMenuAction"> <menuitem name="New" action="New2Action" /> <placeholder name="FileMenuAdditions" /> </menu> <menu name="JustifyMenu" action="JustifyMenuAction"> <menuitem name="Left" action="justify-left"/> <menuitem name="Centre" action="justify-center"/> <menuitem name="Right" action="justify-right"/> <menuitem name="Fill" action="justify-fill"/> </menu> </menubar> <toolbar action="toolbar1"> <placeholder name="JustifyToolItems"> <separator/> <toolitem name="Left" action="justify-left"/> <toolitem name="Centre" action="justify-center"/> <toolitem name="Right" action="justify-right"/> <toolitem name="Fill" action="justify-fill"/> <separator/> </placeholder> </toolbar> </ui> ]| The constructed widget hierarchy is very similar to the element tree of the XML, with the exception that placeholders are merged into their parents. The correspondence of XML elements to widgets should be almost obvious: - menubar a #GtkMenuBar - toolbar a #GtkToolbar - popup a toplevel #GtkMenu - menu a #GtkMenu attached to a menuitem - menuitem a #GtkMenuItem subclass, the exact type depends on the action - toolitem a #GtkToolItem subclass, the exact type depends on the action. Note that toolitem elements may contain a menu element, but only if their associated action specifies a #GtkMenuToolButton as proxy. - separator a #GtkSeparatorMenuItem or #GtkSeparatorToolItem - accelerator a keyboard accelerator The “position” attribute determines where a constructed widget is positioned wrt. to its siblings in the partially constructed tree. If it is “top”, the widget is prepended, otherwise it is appended. # UI Merging # {#UI-Merging} The most remarkable feature of #GtkUIManager is that it can overlay a set of menuitems and toolitems over another one, and demerge them later. Merging is done based on the names of the XML elements. Each element is identified by a path which consists of the names of its anchestors, separated by slashes. For example, the menuitem named “Left” in the example above has the path `/ui/menubar/JustifyMenu/Left` and the toolitem with the same name has path `/ui/toolbar1/JustifyToolItems/Left`. # Accelerators # Every action has an accelerator path. Accelerators are installed together with menuitem proxies, but they can also be explicitly added with <accelerator> elements in the UI definition. This makes it possible to have accelerators for actions even if they have no visible proxies. # Smart Separators # {#Smart-Separators} The separators created by #GtkUIManager are “smart”, i.e. they do not show up in the UI unless they end up between two visible menu or tool items. Separators which are located at the very beginning or end of the menu or toolbar containing them, or multiple separators next to each other, are hidden. This is a useful feature, since the merging of UI elements from multiple sources can make it hard or impossible to determine in advance whether a separator will end up in such an unfortunate position. For separators in toolbars, you can set `expand="true"` to turn them from a small, visible separator to an expanding, invisible one. Toolitems following an expanding separator are effectively right-aligned. # Empty Menus Submenus pose similar problems to separators inconnection with merging. It is impossible to know in advance whether they will end up empty after merging. #GtkUIManager offers two ways to treat empty submenus: - make them disappear by hiding the menu item they’re attached to - add an insensitive “Empty” item The behaviour is chosen based on the “hide_if_empty” property of the action to which the submenu is associated. # GtkUIManager as GtkBuildable # {#GtkUIManager-BUILDER-UI} The GtkUIManager implementation of the GtkBuildable interface accepts GtkActionGroup objects as <child> elements in UI definitions. A GtkUIManager UI definition as described above can be embedded in an GtkUIManager <object> element in a GtkBuilder UI definition. The widgets that are constructed by a GtkUIManager can be embedded in other parts of the constructed user interface with the help of the “constructor” attribute. See the example below. ## An embedded GtkUIManager UI definition |[ <object class="GtkUIManager" id="uiman"> <child> <object class="GtkActionGroup" id="actiongroup"> <child> <object class="GtkAction" id="file"> <property name="label">_File</property> </object> </child> </object> </child> <ui> <menubar name="menubar1"> <menu action="file"> </menu> </menubar> </ui> </object> <object class="GtkWindow" id="main-window"> <child> <object class="GtkMenuBar" id="menubar1" constructor="uiman"/> </child> </object> ]| Creates a new ui manager object. a new ui manager object. Looks up an action by following a path. See gtk_ui_manager_get_widget() for more information about paths. the action whose proxy widget is found by following the path, or %NULL if no widget was found. a #GtkUIManager a path Looks up a widget by following a path. The path consists of the names specified in the XML description of the UI. separated by “/”. Elements which don’t have a name or action attribute in the XML (e.g. <popup>) can be addressed by their XML element name (e.g. "popup"). The root element ("/ui") can be omitted in the path. Note that the widget found by following a path that ends in a <menu>; element is the menuitem to which the menu is attached, not the menu it manages. Also note that the widgets constructed by a ui manager are not tied to the lifecycle of the ui manager. If you add the widgets returned by this function to some container or explicitly ref them, they will survive the destruction of the ui manager. the widget found by following the path, or %NULL if no widget was found a #GtkUIManager a path Adds a UI element to the current contents of @manager. If @type is %GTK_UI_MANAGER_AUTO, GTK+ inserts a menuitem, toolitem or separator if such an element can be inserted at the place determined by @path. Otherwise @type must indicate an element that can be inserted at the place determined by @path. If @path points to a menuitem or toolitem, the new element will be inserted before or after this item, depending on @top. a #GtkUIManager the merge id for the merged UI, see gtk_ui_manager_new_merge_id() a path the name for the added UI element the name of the action to be proxied, or %NULL to add a separator the type of UI element to add. if %TRUE, the UI element is added before its siblings, otherwise it is added after its siblings. Parses a file containing a [UI definition][XML-UI] and merges it with the current contents of @manager. The merge id for the merged UI. The merge id can be used to unmerge the UI with gtk_ui_manager_remove_ui(). If an error occurred, the return value is 0. a #GtkUIManager object the name of the file to parse Parses a resource file containing a [UI definition][XML-UI] and merges it with the current contents of @manager. The merge id for the merged UI. The merge id can be used to unmerge the UI with gtk_ui_manager_remove_ui(). If an error occurred, the return value is 0. a #GtkUIManager object the resource path of the file to parse Parses a string containing a [UI definition][XML-UI] and merges it with the current contents of @manager. An enclosing <ui> element is added if it is missing. The merge id for the merged UI. The merge id can be used to unmerge the UI with gtk_ui_manager_remove_ui(). If an error occurred, the return value is 0. a #GtkUIManager object the string to parse the length of @buffer (may be -1 if @buffer is nul-terminated) Makes sure that all pending updates to the UI have been completed. This may occasionally be necessary, since #GtkUIManager updates the UI in an idle function. A typical example where this function is useful is to enforce that the menubar and toolbar have been added to the main window before showing it: |[<!-- language="C" --> gtk_container_add (GTK_CONTAINER (window), vbox); g_signal_connect (merge, "add-widget", G_CALLBACK (add_widget), vbox); gtk_ui_manager_add_ui_from_file (merge, "my-menus"); gtk_ui_manager_add_ui_from_file (merge, "my-toolbars"); gtk_ui_manager_ensure_update (merge); gtk_widget_show (window); ]| a #GtkUIManager Returns the #GtkAccelGroup associated with @manager. the #GtkAccelGroup. a #GtkUIManager object Looks up an action by following a path. See gtk_ui_manager_get_widget() for more information about paths. the action whose proxy widget is found by following the path, or %NULL if no widget was found. a #GtkUIManager a path Returns the list of action groups associated with @manager. a #GList of action groups. The list is owned by GTK+ and should not be modified. a #GtkUIManager object Returns whether menus generated by this #GtkUIManager will have tearoff menu items. Tearoff menus are deprecated and should not be used in newly written code. whether tearoff menu items are added a #GtkUIManager Obtains a list of all toplevel widgets of the requested types. a newly-allocated #GSList of all toplevel widgets of the requested types. Free the returned list with g_slist_free(). a #GtkUIManager specifies the types of toplevel widgets to include. Allowed types are #GTK_UI_MANAGER_MENUBAR, #GTK_UI_MANAGER_TOOLBAR and #GTK_UI_MANAGER_POPUP. Creates a [UI definition][XML-UI] of the merged UI. A newly allocated string containing an XML representation of the merged UI. a #GtkUIManager Looks up a widget by following a path. The path consists of the names specified in the XML description of the UI. separated by “/”. Elements which don’t have a name or action attribute in the XML (e.g. <popup>) can be addressed by their XML element name (e.g. "popup"). The root element ("/ui") can be omitted in the path. Note that the widget found by following a path that ends in a <menu>; element is the menuitem to which the menu is attached, not the menu it manages. Also note that the widgets constructed by a ui manager are not tied to the lifecycle of the ui manager. If you add the widgets returned by this function to some container or explicitly ref them, they will survive the destruction of the ui manager. the widget found by following the path, or %NULL if no widget was found a #GtkUIManager a path Inserts an action group into the list of action groups associated with @manager. Actions in earlier groups hide actions with the same name in later groups. If @pos is larger than the number of action groups in @manager, or negative, @action_group will be inserted at the end of the internal list. a #GtkUIManager object the action group to be inserted the position at which the group will be inserted. Returns an unused merge id, suitable for use with gtk_ui_manager_add_ui(). an unused merge id. a #GtkUIManager Removes an action group from the list of action groups associated with @manager. a #GtkUIManager object the action group to be removed Unmerges the part of @manager's content identified by @merge_id. a #GtkUIManager object a merge id as returned by gtk_ui_manager_add_ui_from_string() Sets the “add_tearoffs” property, which controls whether menus generated by this #GtkUIManager will have tearoff menu items. Note that this only affects regular menus. Generated popup menus never have tearoff menu items. Tearoff menus are deprecated and should not be used in newly written code. a #GtkUIManager whether tearoff menu items are added The "add-tearoffs" property controls whether generated menus have tearoff menu items. Note that this only affects regular menus. Generated popup menus never have tearoff menu items. Tearoff menus are deprecated and should not be used in newly written code. The ::actions-changed signal is emitted whenever the set of actions changes. The ::add-widget signal is emitted for each generated menubar and toolbar. It is not emitted for generated popup menus, which can be obtained by gtk_ui_manager_get_widget(). the added widget The ::connect-proxy signal is emitted after connecting a proxy to an action in the group. This is intended for simple customizations for which a custom action class would be too clumsy, e.g. showing tooltips for menuitems in the statusbar. the action the proxy The ::disconnect-proxy signal is emitted after disconnecting a proxy from an action in the group. the action the proxy The ::post-activate signal is emitted just after the @action is activated. This is intended for applications to get notification just after any action is activated. the action The ::pre-activate signal is emitted just before the @action is activated. This is intended for applications to get notification just before any action is activated. the action the widget found by following the path, or %NULL if no widget was found a #GtkUIManager a path the action whose proxy widget is found by following the path, or %NULL if no widget was found. a #GtkUIManager a path These enumeration values are used by gtk_ui_manager_add_ui() to determine what UI element to create. Pick the type of the UI element according to context. Create a menubar. Create a menu. Create a toolbar. Insert a placeholder. Create a popup menu. Create a menuitem. Create a toolitem. Create a separator. Install an accelerator. Same as %GTK_UI_MANAGER_POPUP, but the actions’ accelerators are shown. See also gtk_print_settings_set_paper_width(). No units. Dimensions in points. Dimensions in inches. Dimensions in millimeters A #GtkVBox is a container that organizes child widgets into a single column. Use the #GtkBox packing interface to determine the arrangement, spacing, height, and alignment of #GtkVBox children. All children are allocated the same width. GtkVBox has been deprecated. You can use #GtkBox with a #GtkOrientable:orientation set to %GTK_ORIENTATION_VERTICAL instead when calling gtk_box_new(), which is a very quick and easy change. If you have derived your own classes from GtkVBox, you can change the inheritance to derive directly from #GtkBox, and set the #GtkOrientable:orientation property to %GTK_ORIENTATION_VERTICAL in your instance init function, with a call like: |[<!-- language="C" --> gtk_orientable_set_orientation (GTK_ORIENTABLE (object), GTK_ORIENTATION_VERTICAL); ]| If you have a grid-like layout composed of nested boxes, and you don’t need first-child or last-child styling, the recommendation is to switch to #GtkGrid. For more information about migrating to #GtkGrid, see [Migrating from other containers to GtkGrid][gtk-migrating-GtkGrid]. Creates a new #GtkVBox. You can use gtk_box_new() with %GTK_ORIENTATION_VERTICAL instead, which is a quick and easy change. But the recommendation is to switch to #GtkGrid, since #GtkBox is going to go away eventually. See [Migrating from other containers to GtkGrid][gtk-migrating-GtkGrid]. a new #GtkVBox. %TRUE if all children are to be given equal space allotments. the number of pixels to place by default between children. Creates a new vertical button box. Use gtk_button_box_new() with %GTK_ORIENTATION_VERTICAL instead a new button box #GtkWidget. The VPaned widget is a container widget with two children arranged vertically. The division between the two panes is adjustable by the user by dragging a handle. See #GtkPaned for details. GtkVPaned has been deprecated, use #GtkPaned instead. Create a new #GtkVPaned Use gtk_paned_new() with %GTK_ORIENTATION_VERTICAL instead the new #GtkVPaned The #GtkVScale widget is used to allow the user to select a value using a vertical slider. To create one, use gtk_hscale_new_with_range(). The position to show the current value, and the number of decimal places shown can be set using the parent #GtkScale class’s functions. GtkVScale has been deprecated, use #GtkScale instead. Creates a new #GtkVScale. Use gtk_scale_new() with %GTK_ORIENTATION_VERTICAL instead a new #GtkVScale. the #GtkAdjustment which sets the range of the scale. Creates a new vertical scale widget that lets the user input a number between @min and @max (including @min and @max) with the increment @step. @step must be nonzero; it’s the distance the slider moves when using the arrow keys to adjust the scale value. Note that the way in which the precision is derived works best if @step is a power of ten. If the resulting precision is not suitable for your needs, use gtk_scale_set_digits() to correct it. Use gtk_scale_new_with_range() with %GTK_ORIENTATION_VERTICAL instead a new #GtkVScale minimum value maximum value step increment (tick size) used with keyboard shortcuts The #GtkVScrollbar widget is a widget arranged vertically creating a scrollbar. See #GtkScrollbar for details on scrollbars. #GtkAdjustment pointers may be added to handle the adjustment of the scrollbar or it may be left %NULL in which case one will be created for you. See #GtkScrollbar for a description of what the fields in an adjustment represent for a scrollbar. GtkVScrollbar has been deprecated, use #GtkScrollbar instead. Creates a new vertical scrollbar. Use gtk_scrollbar_new() with %GTK_ORIENTATION_VERTICAL instead the new #GtkVScrollbar the #GtkAdjustment to use, or %NULL to create a new adjustment The #GtkVSeparator widget is a vertical separator, used to group the widgets within a window. It displays a vertical line with a shadow to make it appear sunken into the interface. GtkVSeparator has been deprecated, use #GtkSeparator instead. Creates a new #GtkVSeparator. Use gtk_separator_new() with %GTK_ORIENTATION_VERTICAL instead a new #GtkVSeparator. The #GtkViewport widget acts as an adaptor class, implementing scrollability for child widgets that lack their own scrolling capabilities. Use GtkViewport to scroll child widgets such as #GtkGrid, #GtkBox, and so on. If a widget has native scrolling abilities, such as #GtkTextView, #GtkTreeView or #GtkIconView, it can be added to a #GtkScrolledWindow with gtk_container_add(). If a widget does not, you must first add the widget to a #GtkViewport, then add the viewport to the scrolled window. gtk_container_add() does this automatically if a child that does not implement #GtkScrollable is added to a #GtkScrolledWindow, so you can ignore the presence of the viewport. The GtkViewport will start scrolling content only if allocated less than the child widget’s minimum size in a given orientation. # CSS nodes GtkViewport has a single CSS node with name viewport. Creates a new #GtkViewport with the given adjustments, or with default adjustments if none are given. a new #GtkViewport horizontal adjustment vertical adjustment Gets the bin window of the #GtkViewport. a #GdkWindow a #GtkViewport Returns the horizontal adjustment of the viewport. Use gtk_scrollable_get_hadjustment() the horizontal adjustment of @viewport. a #GtkViewport. Gets the shadow type of the #GtkViewport. See gtk_viewport_set_shadow_type(). the shadow type a #GtkViewport Returns the vertical adjustment of the viewport. Use gtk_scrollable_get_vadjustment() the vertical adjustment of @viewport. a #GtkViewport. Gets the view window of the #GtkViewport. a #GdkWindow a #GtkViewport Sets the horizontal adjustment of the viewport. Use gtk_scrollable_set_hadjustment() a #GtkViewport. a #GtkAdjustment. Sets the shadow type of the viewport. a #GtkViewport. the new shadow type. Sets the vertical adjustment of the viewport. Use gtk_scrollable_set_vadjustment() a #GtkViewport. a #GtkAdjustment. The parent class. #GtkVolumeButton is a subclass of #GtkScaleButton that has been tailored for use as a volume control widget with suitable icons, tooltips and accessible labels. Creates a #GtkVolumeButton, with a range between 0.0 and 1.0, with a stepping of 0.02. Volume values can be obtained and modified using the functions from #GtkScaleButton. a new #GtkVolumeButton Whether to use symbolic icons as the icons. Note that if the symbolic icons are not available in your installed theme, then the normal (potentially colorful) icons will be used. GtkWidget is the base class all widgets in GTK+ derive from. It manages the widget lifecycle, states and style. # Height-for-width Geometry Management # {#geometry-management} GTK+ uses a height-for-width (and width-for-height) geometry management system. Height-for-width means that a widget can change how much vertical space it needs, depending on the amount of horizontal space that it is given (and similar for width-for-height). The most common example is a label that reflows to fill up the available width, wraps to fewer lines, and therefore needs less height. Height-for-width geometry management is implemented in GTK+ by way of five virtual methods: - #GtkWidgetClass.get_request_mode() - #GtkWidgetClass.get_preferred_width() - #GtkWidgetClass.get_preferred_height() - #GtkWidgetClass.get_preferred_height_for_width() - #GtkWidgetClass.get_preferred_width_for_height() - #GtkWidgetClass.get_preferred_height_and_baseline_for_width() There are some important things to keep in mind when implementing height-for-width and when using it in container implementations. The geometry management system will query a widget hierarchy in only one orientation at a time. When widgets are initially queried for their minimum sizes it is generally done in two initial passes in the #GtkSizeRequestMode chosen by the toplevel. For example, when queried in the normal %GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH mode: First, the default minimum and natural width for each widget in the interface will be computed using gtk_widget_get_preferred_width(). Because the preferred widths for each container depend on the preferred widths of their children, this information propagates up the hierarchy, and finally a minimum and natural width is determined for the entire toplevel. Next, the toplevel will use the minimum width to query for the minimum height contextual to that width using gtk_widget_get_preferred_height_for_width(), which will also be a highly recursive operation. The minimum height for the minimum width is normally used to set the minimum size constraint on the toplevel (unless gtk_window_set_geometry_hints() is explicitly used instead). After the toplevel window has initially requested its size in both dimensions it can go on to allocate itself a reasonable size (or a size previously specified with gtk_window_set_default_size()). During the recursive allocation process it’s important to note that request cycles will be recursively executed while container widgets allocate their children. Each container widget, once allocated a size, will go on to first share the space in one orientation among its children and then request each child's height for its target allocated width or its width for allocated height, depending. In this way a #GtkWidget will typically be requested its size a number of times before actually being allocated a size. The size a widget is finally allocated can of course differ from the size it has requested. For this reason, #GtkWidget caches a small number of results to avoid re-querying for the same sizes in one allocation cycle. See [GtkContainer’s geometry management section][container-geometry-management] to learn more about how height-for-width allocations are performed by container widgets. If a widget does move content around to intelligently use up the allocated size then it must support the request in both #GtkSizeRequestModes even if the widget in question only trades sizes in a single orientation. For instance, a #GtkLabel that does height-for-width word wrapping will not expect to have #GtkWidgetClass.get_preferred_height() called because that call is specific to a width-for-height request. In this case the label must return the height required for its own minimum possible width. By following this rule any widget that handles height-for-width or width-for-height requests will always be allocated at least enough space to fit its own content. Here are some examples of how a %GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH widget generally deals with width-for-height requests, for #GtkWidgetClass.get_preferred_height() it will do: |[<!-- language="C" --> static void foo_widget_get_preferred_height (GtkWidget *widget, gint *min_height, gint *nat_height) { if (i_am_in_height_for_width_mode) { gint min_width, nat_width; GTK_WIDGET_GET_CLASS (widget)->get_preferred_width (widget, &min_width, &nat_width); GTK_WIDGET_GET_CLASS (widget)->get_preferred_height_for_width (widget, min_width, min_height, nat_height); } else { ... some widgets do both. For instance, if a GtkLabel is rotated to 90 degrees it will return the minimum and natural height for the rotated label here. } } ]| And in #GtkWidgetClass.get_preferred_width_for_height() it will simply return the minimum and natural width: |[<!-- language="C" --> static void foo_widget_get_preferred_width_for_height (GtkWidget *widget, gint for_height, gint *min_width, gint *nat_width) { if (i_am_in_height_for_width_mode) { GTK_WIDGET_GET_CLASS (widget)->get_preferred_width (widget, min_width, nat_width); } else { ... again if a widget is sometimes operating in width-for-height mode (like a rotated GtkLabel) it can go ahead and do its real width for height calculation here. } } ]| Often a widget needs to get its own request during size request or allocation. For example, when computing height it may need to also compute width. Or when deciding how to use an allocation, the widget may need to know its natural size. In these cases, the widget should be careful to call its virtual methods directly, like this: |[<!-- language="C" --> GTK_WIDGET_GET_CLASS(widget)->get_preferred_width (widget, &min, &natural); ]| It will not work to use the wrapper functions, such as gtk_widget_get_preferred_width() inside your own size request implementation. These return a request adjusted by #GtkSizeGroup and by the #GtkWidgetClass.adjust_size_request() virtual method. If a widget used the wrappers inside its virtual method implementations, then the adjustments (such as widget margins) would be applied twice. GTK+ therefore does not allow this and will warn if you try to do it. Of course if you are getting the size request for another widget, such as a child of a container, you must use the wrapper APIs. Otherwise, you would not properly consider widget margins, #GtkSizeGroup, and so forth. Since 3.10 GTK+ also supports baseline vertical alignment of widgets. This means that widgets are positioned such that the typographical baseline of widgets in the same row are aligned. This happens if a widget supports baselines, has a vertical alignment of %GTK_ALIGN_BASELINE, and is inside a container that supports baselines and has a natural “row” that it aligns to the baseline, or a baseline assigned to it by the grandparent. Baseline alignment support for a widget is done by the #GtkWidgetClass.get_preferred_height_and_baseline_for_width() virtual function. It allows you to report a baseline in combination with the minimum and natural height. If there is no baseline you can return -1 to indicate this. The default implementation of this virtual function calls into the #GtkWidgetClass.get_preferred_height() and #GtkWidgetClass.get_preferred_height_for_width(), so if baselines are not supported it doesn’t need to be implemented. If a widget ends up baseline aligned it will be allocated all the space in the parent as if it was %GTK_ALIGN_FILL, but the selected baseline can be found via gtk_widget_get_allocated_baseline(). If this has a value other than -1 you need to align the widget such that the baseline appears at the position. # Style Properties #GtkWidget introduces “style properties” - these are basically object properties that are stored not on the object, but in the style object associated to the widget. Style properties are set in [resource files][gtk3-Resource-Files]. This mechanism is used for configuring such things as the location of the scrollbar arrows through the theme, giving theme authors more control over the look of applications without the need to write a theme engine in C. Use gtk_widget_class_install_style_property() to install style properties for a widget class, gtk_widget_class_find_style_property() or gtk_widget_class_list_style_properties() to get information about existing style properties and gtk_widget_style_get_property(), gtk_widget_style_get() or gtk_widget_style_get_valist() to obtain the value of a style property. # GtkWidget as GtkBuildable The GtkWidget implementation of the GtkBuildable interface supports a custom <accelerator> element, which has attributes named ”key”, ”modifiers” and ”signal” and allows to specify accelerators. An example of a UI definition fragment specifying an accelerator: |[ <object class="GtkButton"> <accelerator key="q" modifiers="GDK_CONTROL_MASK" signal="clicked"/> </object> ]| In addition to accelerators, GtkWidget also support a custom <accessible> element, which supports actions and relations. Properties on the accessible implementation of an object can be set by accessing the internal child “accessible” of a #GtkWidget. An example of a UI definition fragment specifying an accessible: |[ <object class="GtkLabel" id="label1"/> <property name="label">I am a Label for a Button</property> </object> <object class="GtkButton" id="button1"> <accessibility> <action action_name="click" translatable="yes">Click the button.</action> <relation target="label1" type="labelled-by"/> </accessibility> <child internal-child="accessible"> <object class="AtkObject" id="a11y-button1"> <property name="accessible-name">Clickable Button</property> </object> </child> </object> ]| Finally, GtkWidget allows style information such as style classes to be associated with widgets, using the custom <style> element: |[ <object class="GtkButton" id="button1"> <style> <class name="my-special-button-class"/> <class name="dark-button"/> </style> </object> ]| # Building composite widgets from template XML ## {#composite-templates} GtkWidget exposes some facilities to automate the procedure of creating composite widgets using #GtkBuilder interface description language. To create composite widgets with #GtkBuilder XML, one must associate the interface description with the widget class at class initialization time using gtk_widget_class_set_template(). The interface description semantics expected in composite template descriptions is slightly different from regular #GtkBuilder XML. Unlike regular interface descriptions, gtk_widget_class_set_template() will expect a <template> tag as a direct child of the toplevel <interface> tag. The <template> tag must specify the “class” attribute which must be the type name of the widget. Optionally, the “parent” attribute may be specified to specify the direct parent type of the widget type, this is ignored by the GtkBuilder but required for Glade to introspect what kind of properties and internal children exist for a given type when the actual type does not exist. The XML which is contained inside the <template> tag behaves as if it were added to the <object> tag defining @widget itself. You may set properties on @widget by inserting <property> tags into the <template> tag, and also add <child> tags to add children and extend @widget in the normal way you would with <object> tags. Additionally, <object> tags can also be added before and after the initial <template> tag in the normal way, allowing one to define auxiliary objects which might be referenced by other widgets declared as children of the <template> tag. An example of a GtkBuilder Template Definition: |[ <interface> <template class="FooWidget" parent="GtkBox"> <property name="orientation">GTK_ORIENTATION_HORIZONTAL</property> <property name="spacing">4</property> <child> <object class="GtkButton" id="hello_button"> <property name="label">Hello World</property> <signal name="clicked" handler="hello_button_clicked" object="FooWidget" swapped="yes"/> </object> </child> <child> <object class="GtkButton" id="goodbye_button"> <property name="label">Goodbye World</property> </object> </child> </template> </interface> ]| Typically, you'll place the template fragment into a file that is bundled with your project, using #GResource. In order to load the template, you need to call gtk_widget_class_set_template_from_resource() from the class initialization of your #GtkWidget type: |[<!-- language="C" --> static void foo_widget_class_init (FooWidgetClass *klass) { // ... gtk_widget_class_set_template_from_resource (GTK_WIDGET_CLASS (klass), "/com/example/ui/foowidget.ui"); } ]| You will also need to call gtk_widget_init_template() from the instance initialization function: |[<!-- language="C" --> static void foo_widget_init (FooWidget *self) { // ... gtk_widget_init_template (GTK_WIDGET (self)); } ]| You can access widgets defined in the template using the gtk_widget_get_template_child() function, but you will typically declare a pointer in the instance private data structure of your type using the same name as the widget in the template definition, and call gtk_widget_class_bind_template_child_private() with that name, e.g. |[<!-- language="C" --> typedef struct { GtkWidget *hello_button; GtkWidget *goodbye_button; } FooWidgetPrivate; G_DEFINE_TYPE_WITH_PRIVATE (FooWidget, foo_widget, GTK_TYPE_BOX) static void foo_widget_class_init (FooWidgetClass *klass) { // ... gtk_widget_class_set_template_from_resource (GTK_WIDGET_CLASS (klass), "/com/example/ui/foowidget.ui"); gtk_widget_class_bind_template_child_private (GTK_WIDGET_CLASS (klass), FooWidget, hello_button); gtk_widget_class_bind_template_child_private (GTK_WIDGET_CLASS (klass), FooWidget, goodbye_button); } static void foo_widget_init (FooWidget *widget) { } ]| You can also use gtk_widget_class_bind_template_callback() to connect a signal callback defined in the template with a function visible in the scope of the class, e.g. |[<!-- language="C" --> // the signal handler has the instance and user data swapped // because of the swapped="yes" attribute in the template XML static void hello_button_clicked (FooWidget *self, GtkButton *button) { g_print ("Hello, world!\n"); } static void foo_widget_class_init (FooWidgetClass *klass) { // ... gtk_widget_class_set_template_from_resource (GTK_WIDGET_CLASS (klass), "/com/example/ui/foowidget.ui"); gtk_widget_class_bind_template_callback (GTK_WIDGET_CLASS (klass), hello_button_clicked); } ]| This is a convenience function for creating a widget and setting its properties in one go. For example you might write: `gtk_widget_new (GTK_TYPE_LABEL, "label", "Hello World", "xalign", 0.0, NULL)` to create a left-aligned label. Equivalent to g_object_new(), but returns a widget so you don’t have to cast the object yourself. a new #GtkWidget of type @widget_type type ID of the widget to create name of first property to set value of first property, followed by more properties, %NULL-terminated Obtains the current default reading direction. See gtk_widget_set_default_direction(). the current default direction. Returns the default style used by all widgets initially. Use #GtkStyleContext instead, and gtk_css_provider_get_default() to obtain a #GtkStyleProvider with the default widget style information. the default style. This #GtkStyle object is owned by GTK+ and should not be modified or freed. Cancels the effect of a previous call to gtk_widget_push_composite_child(). Use gtk_widget_class_set_template(), or don’t use this API at all. Makes all newly-created widgets as composite children until the corresponding gtk_widget_pop_composite_child() call. A composite child is a child that’s an implementation detail of the container it’s inside and should not be visible to people using the container. Composite children aren’t treated differently by GTK+ (but see gtk_container_foreach() vs. gtk_container_forall()), but e.g. GUI builders might want to treat them in a different way. This API never really worked well and was mostly unused, now we have a more complete mechanism for composite children, see gtk_widget_class_set_template(). Sets the default reading direction for widgets where the direction has not been explicitly set by gtk_widget_set_direction(). the new default direction. This cannot be %GTK_TEXT_DIR_NONE. Determines whether an accelerator that activates the signal identified by @signal_id can currently be activated. This is done by emitting the #GtkWidget::can-activate-accel signal on @widget; if the signal isn’t overridden by a handler or in a derived widget, then the default check is that the widget must be sensitive, and the widget and all its ancestors mapped. %TRUE if the accelerator can be activated. a #GtkWidget the ID of a signal installed on @widget Emits a #GtkWidget::child-notify signal for the [child property][child-properties] @child_property on @widget. This is the analogue of g_object_notify() for child properties. Also see gtk_container_child_notify(). a #GtkWidget the name of a child property installed on the class of @widget’s parent Destroys a widget. When a widget is destroyed all references it holds on other objects will be released: - if the widget is inside a container, it will be removed from its parent - if the widget is a container, all its children will be destroyed, recursively - if the widget is a top level, it will be removed from the list of top level widgets that GTK+ maintains internally It's expected that all references held on the widget will also be released; you should connect to the #GtkWidget::destroy signal if you hold a reference to @widget and you wish to remove it when this function is called. It is not necessary to do so if you are implementing a #GtkContainer, as you'll be able to use the #GtkContainerClass.remove() virtual function for that. It's important to notice that gtk_widget_destroy() will only cause the @widget to be finalized if no additional references, acquired using g_object_ref(), are held on it. In case additional references are in place, the @widget will be in an "inert" state after calling this function; @widget will still point to valid memory, allowing you to release the references you hold, but you may not query the widget's own state. You should typically call this function on top level widgets, and rarely on child widgets. See also: gtk_container_remove() a #GtkWidget Rarely-used function. This function is used to emit the event signals on a widget (those signals should never be emitted without using this function to do so). If you want to synthesize an event though, don’t use this function; instead, use gtk_main_do_event() so the event will behave as if it were in the event queue. Don’t synthesize expose events; instead, use gdk_window_invalidate_rect() to invalidate a region of the window. return from the event signal emission (%TRUE if the event was handled) a #GtkWidget a #GdkEvent Returns the accessible object that describes the widget to an assistive technology. If accessibility support is not available, this #AtkObject instance may be a no-op. Likewise, if no class-specific #AtkObject implementation is available for the widget instance in question, it will inherit an #AtkObject implementation from the first ancestor class for which such an implementation is defined. The documentation of the [ATK](http://developer.gnome.org/atk/stable/) library contains more information about accessible objects and their uses. the #AtkObject associated with @widget a #GtkWidget Retrieves a widget’s initial minimum and natural height. This call is specific to width-for-height requests. The returned request will be modified by the GtkWidgetClass::adjust_size_request virtual method and by any #GtkSizeGroups that have been applied. That is, the returned request is the one that should be used for layout, not necessarily the one returned by the widget itself. a #GtkWidget instance location to store the minimum height, or %NULL location to store the natural height, or %NULL Retrieves a widget’s minimum and natural height and the corresponding baselines if it would be given the specified @width, or the default height if @width is -1. The baselines may be -1 which means that no baseline is requested for this widget. The returned request will be modified by the GtkWidgetClass::adjust_size_request and GtkWidgetClass::adjust_baseline_request virtual methods and by any #GtkSizeGroups that have been applied. That is, the returned request is the one that should be used for layout, not necessarily the one returned by the widget itself. a #GtkWidget instance the width which is available for allocation, or -1 if none location for storing the minimum height, or %NULL location for storing the natural height, or %NULL location for storing the baseline for the minimum height, or %NULL location for storing the baseline for the natural height, or %NULL Retrieves a widget’s minimum and natural height if it would be given the specified @width. The returned request will be modified by the GtkWidgetClass::adjust_size_request virtual method and by any #GtkSizeGroups that have been applied. That is, the returned request is the one that should be used for layout, not necessarily the one returned by the widget itself. a #GtkWidget instance the width which is available for allocation location for storing the minimum height, or %NULL location for storing the natural height, or %NULL Retrieves a widget’s initial minimum and natural width. This call is specific to height-for-width requests. The returned request will be modified by the GtkWidgetClass::adjust_size_request virtual method and by any #GtkSizeGroups that have been applied. That is, the returned request is the one that should be used for layout, not necessarily the one returned by the widget itself. a #GtkWidget instance location to store the minimum width, or %NULL location to store the natural width, or %NULL Retrieves a widget’s minimum and natural width if it would be given the specified @height. The returned request will be modified by the GtkWidgetClass::adjust_size_request virtual method and by any #GtkSizeGroups that have been applied. That is, the returned request is the one that should be used for layout, not necessarily the one returned by the widget itself. a #GtkWidget instance the height which is available for allocation location for storing the minimum width, or %NULL location for storing the natural width, or %NULL Gets whether the widget prefers a height-for-width layout or a width-for-height layout. #GtkBin widgets generally propagate the preference of their child, container widgets need to request something either in context of their children or in context of their allocation capabilities. The #GtkSizeRequestMode preferred by @widget. a #GtkWidget instance Causes @widget to have the keyboard focus for the #GtkWindow it's inside. @widget must be a focusable widget, such as a #GtkEntry; something like #GtkFrame won’t work. More precisely, it must have the %GTK_CAN_FOCUS flag set. Use gtk_widget_set_can_focus() to modify that flag. The widget also needs to be realized and mapped. This is indicated by the related signals. Grabbing the focus immediately after creating the widget will likely fail and cause critical warnings. a #GtkWidget Reverses the effects of gtk_widget_show(), causing the widget to be hidden (invisible to the user). a #GtkWidget This function should be called whenever keyboard navigation within a single widget hits a boundary. The function emits the #GtkWidget::keynav-failed signal on the widget and its return value should be interpreted in a way similar to the return value of gtk_widget_child_focus(): When %TRUE is returned, stay in the widget, the failed keyboard navigation is OK and/or there is nowhere we can/should move the focus to. When %FALSE is returned, the caller should continue with keyboard navigation outside the widget, e.g. by calling gtk_widget_child_focus() on the widget’s toplevel. The default ::keynav-failed handler returns %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD. For the other values of #GtkDirectionType it returns %TRUE. Whenever the default handler returns %TRUE, it also calls gtk_widget_error_bell() to notify the user of the failed keyboard navigation. A use case for providing an own implementation of ::keynav-failed (either by connecting to it or by overriding it) would be a row of #GtkEntry widgets where the user should be able to navigate the entire row with the cursor keys, as e.g. known from user interfaces that require entering license keys. %TRUE if stopping keyboard navigation is fine, %FALSE if the emitting widget should try to handle the keyboard navigation attempt in its parent container(s). a #GtkWidget direction of focus movement This function is only for use in widget implementations. Causes a widget to be mapped if it isn’t already. a #GtkWidget Emits the #GtkWidget::mnemonic-activate signal. %TRUE if the signal has been handled a #GtkWidget %TRUE if there are other widgets with the same mnemonic Invalidates the area of @widget defined by @region by calling gdk_window_invalidate_region() on the widget’s window and all its child windows. Once the main loop becomes idle (after the current batch of events has been processed, roughly), the window will receive expose events for the union of all regions that have been invalidated. Normally you would only use this function in widget implementations. You might also use it to schedule a redraw of a #GtkDrawingArea or some portion thereof. a #GtkWidget region to draw Creates the GDK (windowing system) resources associated with a widget. For example, @widget->window will be created when a widget is realized. Normally realization happens implicitly; if you show a widget and all its parent containers, then the widget will be realized and mapped automatically. Realizing a widget requires all the widget’s parent widgets to be realized; calling gtk_widget_realize() realizes the widget’s parents in addition to @widget itself. If a widget is not yet inside a toplevel window when you realize it, bad things will happen. This function is primarily used in widget implementations, and isn’t very useful otherwise. Many times when you think you might need it, a better approach is to connect to a signal that will be called after the widget is realized automatically, such as #GtkWidget::draw. Or simply g_signal_connect () to the #GtkWidget::realize signal. a #GtkWidget Flags a widget to be displayed. Any widget that isn’t shown will not appear on the screen. If you want to show all the widgets in a container, it’s easier to call gtk_widget_show_all() on the container, instead of individually showing the widgets. Remember that you have to show the containers containing a widget, in addition to the widget itself, before it will appear onscreen. When a toplevel container is shown, it is immediately realized and mapped; other shown widgets are realized and mapped when their toplevel container is realized and mapped. a #GtkWidget Recursively shows a widget, and any child widgets (if the widget is a container). a #GtkWidget This function is only used by #GtkContainer subclasses, to assign a size and position to their child widgets. In this function, the allocation may be adjusted. It will be forced to a 1x1 minimum size, and the adjust_size_allocation virtual method on the child will be used to adjust the allocation. Standard adjustments include removing the widget’s margins, and applying the widget’s #GtkWidget:halign and #GtkWidget:valign properties. For baseline support in containers you need to use gtk_widget_size_allocate_with_baseline() instead. a #GtkWidget position and size to be allocated to @widget This function is only for use in widget implementations. Causes a widget to be unmapped if it’s currently mapped. a #GtkWidget This function is only useful in widget implementations. Causes a widget to be unrealized (frees all GDK resources associated with the widget, such as @widget->window). a #GtkWidget For widgets that can be “activated” (buttons, menu items, etc.) this function activates them. Activation is what happens when you press Enter on a widget during key navigation. If @widget isn't activatable, the function returns %FALSE. %TRUE if the widget was activatable a #GtkWidget that’s activatable Installs an accelerator for this @widget in @accel_group that causes @accel_signal to be emitted if the accelerator is activated. The @accel_group needs to be added to the widget’s toplevel via gtk_window_add_accel_group(), and the signal must be of type %G_SIGNAL_ACTION. Accelerators added through this function are not user changeable during runtime. If you want to support accelerators that can be changed by the user, use gtk_accel_map_add_entry() and gtk_widget_set_accel_path() or gtk_menu_item_set_accel_path() instead. widget to install an accelerator on widget signal to emit on accelerator activation accel group for this widget, added to its toplevel GDK keyval of the accelerator modifier key combination of the accelerator flag accelerators, e.g. %GTK_ACCEL_VISIBLE Adds the device events in the bitfield @events to the event mask for @widget. See gtk_widget_set_device_events() for details. a #GtkWidget a #GdkDevice an event mask, see #GdkEventMask Adds the events in the bitfield @events to the event mask for @widget. See gtk_widget_set_events() and the [input handling overview][event-masks] for details. a #GtkWidget an event mask, see #GdkEventMask Adds a widget to the list of mnemonic labels for this widget. (See gtk_widget_list_mnemonic_labels()). Note the list of mnemonic labels for the widget is cleared when the widget is destroyed, so the caller must make sure to update its internal state at this point as well, by using a connection to the #GtkWidget::destroy signal or a weak notifier. a #GtkWidget a #GtkWidget that acts as a mnemonic label for @widget Queues an animation frame update and adds a callback to be called before each frame. Until the tick callback is removed, it will be called frequently (usually at the frame rate of the output device or as quickly as the application can be repainted, whichever is slower). For this reason, is most suitable for handling graphics that change every frame or every few frames. The tick callback does not automatically imply a relayout or repaint. If you want a repaint or relayout, and aren’t changing widget properties that would trigger that (for example, changing the text of a #GtkLabel), then you will have to call gtk_widget_queue_resize() or gtk_widget_queue_draw_area() yourself. gdk_frame_clock_get_frame_time() should generally be used for timing continuous animations and gdk_frame_timings_get_predicted_presentation_time() if you are trying to display isolated frames at particular times. This is a more convenient alternative to connecting directly to the #GdkFrameClock::update signal of #GdkFrameClock, since you don't have to worry about when a #GdkFrameClock is assigned to a widget. an id for the connection of this callback. Remove the callback by passing it to gtk_widget_remove_tick_callback() a #GtkWidget function to call for updating animations data to pass to @callback function to call to free @user_data when the callback is removed. Determines whether an accelerator that activates the signal identified by @signal_id can currently be activated. This is done by emitting the #GtkWidget::can-activate-accel signal on @widget; if the signal isn’t overridden by a handler or in a derived widget, then the default check is that the widget must be sensitive, and the widget and all its ancestors mapped. %TRUE if the accelerator can be activated. a #GtkWidget the ID of a signal installed on @widget This function is used by custom widget implementations; if you're writing an app, you’d use gtk_widget_grab_focus() to move the focus to a particular widget, and gtk_container_set_focus_chain() to change the focus tab order. So you may want to investigate those functions instead. gtk_widget_child_focus() is called by containers as the user moves around the window using keyboard shortcuts. @direction indicates what kind of motion is taking place (up, down, left, right, tab forward, tab backward). gtk_widget_child_focus() emits the #GtkWidget::focus signal; widgets override the default handler for this signal in order to implement appropriate focus behavior. The default ::focus handler for a widget should return %TRUE if moving in @direction left the focus on a focusable location inside that widget, and %FALSE if moving in @direction moved the focus outside the widget. If returning %TRUE, widgets normally call gtk_widget_grab_focus() to place the focus accordingly; if returning %FALSE, they don’t modify the current focus location. %TRUE if focus ended up inside @widget a #GtkWidget direction of focus movement Emits a #GtkWidget::child-notify signal for the [child property][child-properties] @child_property on @widget. This is the analogue of g_object_notify() for child properties. Also see gtk_container_child_notify(). a #GtkWidget the name of a child property installed on the class of @widget’s parent Same as gtk_widget_path(), but always uses the name of a widget’s type, never uses a custom name set with gtk_widget_set_name(). Use gtk_widget_get_path() instead a #GtkWidget location to store the length of the class path, or %NULL location to store the class path as an allocated string, or %NULL location to store the reverse class path as an allocated string, or %NULL Computes whether a container should give this widget extra space when possible. Containers should check this, rather than looking at gtk_widget_get_hexpand() or gtk_widget_get_vexpand(). This function already checks whether the widget is visible, so visibility does not need to be checked separately. Non-visible widgets are not expanded. The computed expand value uses either the expand setting explicitly set on the widget itself, or, if none has been explicitly set, the widget may expand if some of its children do. whether widget tree rooted here should be expanded the widget expand direction Creates a new #PangoContext with the appropriate font map, font options, font description, and base direction for drawing text for this widget. See also gtk_widget_get_pango_context(). the new #PangoContext a #GtkWidget Creates a new #PangoLayout with the appropriate font map, font description, and base direction for drawing text for this widget. If you keep a #PangoLayout created in this way around, you need to re-create it when the widget #PangoContext is replaced. This can be tracked by using the #GtkWidget::screen-changed signal on the widget. the new #PangoLayout a #GtkWidget text to set on the layout (can be %NULL) Destroys a widget. When a widget is destroyed all references it holds on other objects will be released: - if the widget is inside a container, it will be removed from its parent - if the widget is a container, all its children will be destroyed, recursively - if the widget is a top level, it will be removed from the list of top level widgets that GTK+ maintains internally It's expected that all references held on the widget will also be released; you should connect to the #GtkWidget::destroy signal if you hold a reference to @widget and you wish to remove it when this function is called. It is not necessary to do so if you are implementing a #GtkContainer, as you'll be able to use the #GtkContainerClass.remove() virtual function for that. It's important to notice that gtk_widget_destroy() will only cause the @widget to be finalized if no additional references, acquired using g_object_ref(), are held on it. In case additional references are in place, the @widget will be in an "inert" state after calling this function; @widget will still point to valid memory, allowing you to release the references you hold, but you may not query the widget's own state. You should typically call this function on top level widgets, and rarely on child widgets. See also: gtk_container_remove() a #GtkWidget This function sets *@widget_pointer to %NULL if @widget_pointer != %NULL. It’s intended to be used as a callback connected to the “destroy” signal of a widget. You connect gtk_widget_destroyed() as a signal handler, and pass the address of your widget variable as user data. Then when the widget is destroyed, the variable will be set to %NULL. Useful for example to avoid multiple copies of the same dialog. a #GtkWidget address of a variable that contains @widget Returns %TRUE if @device has been shadowed by a GTK+ device grab on another widget, so it would stop sending events to @widget. This may be used in the #GtkWidget::grab-notify signal to check for specific devices. See gtk_device_grab_add(). %TRUE if there is an ongoing grab on @device by another #GtkWidget than @widget. a #GtkWidget a #GdkDevice This function is equivalent to gtk_drag_begin_with_coordinates(), passing -1, -1 as coordinates. Use gtk_drag_begin_with_coordinates() instead the context for this drag the source widget The targets (data formats) in which the source can provide the data A bitmask of the allowed drag actions for this drag The button the user clicked to start the drag The event that triggered the start of the drag, or %NULL if none can be obtained. Initiates a drag on the source side. The function only needs to be used when the application is starting drags itself, and is not needed when gtk_drag_source_set() is used. The @event is used to retrieve the timestamp that will be used internally to grab the pointer. If @event is %NULL, then %GDK_CURRENT_TIME will be used. However, you should try to pass a real event in all cases, since that can be used to get information about the drag. Generally there are three cases when you want to start a drag by hand by calling this function: 1. During a #GtkWidget::button-press-event handler, if you want to start a drag immediately when the user presses the mouse button. Pass the @event that you have in your #GtkWidget::button-press-event handler. 2. During a #GtkWidget::motion-notify-event handler, if you want to start a drag when the mouse moves past a certain threshold distance after a button-press. Pass the @event that you have in your #GtkWidget::motion-notify-event handler. 3. During a timeout handler, if you want to start a drag after the mouse button is held down for some time. Try to save the last event that you got from the mouse, using gdk_event_copy(), and pass it to this function (remember to free the event with gdk_event_free() when you are done). If you really cannot pass a real event, pass %NULL instead. the context for this drag the source widget The targets (data formats) in which the source can provide the data A bitmask of the allowed drag actions for this drag The button the user clicked to start the drag The event that triggered the start of the drag, or %NULL if none can be obtained. The initial x coordinate to start dragging from, in the coordinate space of @widget. If -1 is passed, the coordinates are retrieved from @event or the current pointer position The initial y coordinate to start dragging from, in the coordinate space of @widget. If -1 is passed, the coordinates are retrieved from @event or the current pointer position Checks to see if a mouse drag starting at (@start_x, @start_y) and ending at (@current_x, @current_y) has passed the GTK+ drag threshold, and thus should trigger the beginning of a drag-and-drop operation. %TRUE if the drag threshold has been passed. a #GtkWidget X coordinate of start of drag Y coordinate of start of drag current X coordinate current Y coordinate Add the image targets supported by #GtkSelectionData to the target list of the drag destination. The targets are added with @info = 0. If you need another value, use gtk_target_list_add_image_targets() and gtk_drag_dest_set_target_list(). a #GtkWidget that’s a drag destination Add the text targets supported by #GtkSelectionData to the target list of the drag destination. The targets are added with @info = 0. If you need another value, use gtk_target_list_add_text_targets() and gtk_drag_dest_set_target_list(). a #GtkWidget that’s a drag destination Add the URI targets supported by #GtkSelectionData to the target list of the drag destination. The targets are added with @info = 0. If you need another value, use gtk_target_list_add_uri_targets() and gtk_drag_dest_set_target_list(). a #GtkWidget that’s a drag destination Looks for a match between the supported targets of @context and the @dest_target_list, returning the first matching target, otherwise returning %GDK_NONE. @dest_target_list should usually be the return value from gtk_drag_dest_get_target_list(), but some widgets may have different valid targets for different parts of the widget; in that case, they will have to implement a drag_motion handler that passes the correct target list to this function. first target that the source offers and the dest can accept, or %GDK_NONE drag destination widget drag context list of droppable targets, or %NULL to use gtk_drag_dest_get_target_list (@widget). Returns the list of targets this widget can accept from drag-and-drop. the #GtkTargetList, or %NULL if none a #GtkWidget Returns whether the widget has been configured to always emit #GtkWidget::drag-motion signals. %TRUE if the widget always emits #GtkWidget::drag-motion events a #GtkWidget that’s a drag destination Sets a widget as a potential drop destination, and adds default behaviors. The default behaviors listed in @flags have an effect similar to installing default handlers for the widget’s drag-and-drop signals (#GtkWidget::drag-motion, #GtkWidget::drag-drop, ...). They all exist for convenience. When passing #GTK_DEST_DEFAULT_ALL for instance it is sufficient to connect to the widget’s #GtkWidget::drag-data-received signal to get primitive, but consistent drag-and-drop support. Things become more complicated when you try to preview the dragged data, as described in the documentation for #GtkWidget::drag-motion. The default behaviors described by @flags make some assumptions, that can conflict with your own signal handlers. For instance #GTK_DEST_DEFAULT_DROP causes invokations of gdk_drag_status() in the context of #GtkWidget::drag-motion, and invokations of gtk_drag_finish() in #GtkWidget::drag-data-received. Especially the later is dramatic, when your own #GtkWidget::drag-motion handler calls gtk_drag_get_data() to inspect the dragged data. There’s no way to set a default action here, you can use the #GtkWidget::drag-motion callback for that. Here’s an example which selects the action to use depending on whether the control key is pressed or not: |[<!-- language="C" --> static void drag_motion (GtkWidget *widget, GdkDragContext *context, gint x, gint y, guint time) { GdkModifierType mask; gdk_window_get_pointer (gtk_widget_get_window (widget), NULL, NULL, &mask); if (mask & GDK_CONTROL_MASK) gdk_drag_status (context, GDK_ACTION_COPY, time); else gdk_drag_status (context, GDK_ACTION_MOVE, time); } ]| a #GtkWidget which types of default drag behavior to use a pointer to an array of #GtkTargetEntrys indicating the drop types that this @widget will accept, or %NULL. Later you can access the list with gtk_drag_dest_get_target_list() and gtk_drag_dest_find_target(). the number of entries in @targets a bitmask of possible actions for a drop onto this @widget. Sets this widget as a proxy for drops to another window. a #GtkWidget the window to which to forward drag events the drag protocol which the @proxy_window accepts (You can use gdk_drag_get_protocol() to determine this) If %TRUE, send the same coordinates to the destination, because it is an embedded subwindow. Sets the target types that this widget can accept from drag-and-drop. The widget must first be made into a drag destination with gtk_drag_dest_set(). a #GtkWidget that’s a drag destination list of droppable targets, or %NULL for none Tells the widget to emit #GtkWidget::drag-motion and #GtkWidget::drag-leave events regardless of the targets and the %GTK_DEST_DEFAULT_MOTION flag. This may be used when a widget wants to do generic actions regardless of the targets that the source offers. a #GtkWidget that’s a drag destination whether to accept all targets Clears information about a drop destination set with gtk_drag_dest_set(). The widget will no longer receive notification of drags. a #GtkWidget Gets the data associated with a drag. When the data is received or the retrieval fails, GTK+ will emit a #GtkWidget::drag-data-received signal. Failure of the retrieval is indicated by the length field of the @selection_data signal parameter being negative. However, when gtk_drag_get_data() is called implicitely because the %GTK_DEST_DEFAULT_DROP was set, then the widget will not receive notification of failed drops. the widget that will receive the #GtkWidget::drag-data-received signal the drag context the target (form of the data) to retrieve a timestamp for retrieving the data. This will generally be the time received in a #GtkWidget::drag-motion or #GtkWidget::drag-drop signal Highlights a widget as a currently hovered drop target. To end the highlight, call gtk_drag_unhighlight(). GTK+ calls this automatically if %GTK_DEST_DEFAULT_HIGHLIGHT is set. a widget to highlight Add the writable image targets supported by #GtkSelectionData to the target list of the drag source. The targets are added with @info = 0. If you need another value, use gtk_target_list_add_image_targets() and gtk_drag_source_set_target_list(). a #GtkWidget that’s is a drag source Add the text targets supported by #GtkSelectionData to the target list of the drag source. The targets are added with @info = 0. If you need another value, use gtk_target_list_add_text_targets() and gtk_drag_source_set_target_list(). a #GtkWidget that’s is a drag source Add the URI targets supported by #GtkSelectionData to the target list of the drag source. The targets are added with @info = 0. If you need another value, use gtk_target_list_add_uri_targets() and gtk_drag_source_set_target_list(). a #GtkWidget that’s is a drag source Gets the list of targets this widget can provide for drag-and-drop. the #GtkTargetList, or %NULL if none a #GtkWidget Sets up a widget so that GTK+ will start a drag operation when the user clicks and drags on the widget. The widget must have a window. a #GtkWidget the bitmask of buttons that can start the drag the table of targets that the drag will support, may be %NULL the number of items in @targets the bitmask of possible actions for a drag from this widget Sets the icon that will be used for drags from a particular source to @icon. See the docs for #GtkIconTheme for more details. a #GtkWidget A #GIcon Sets the icon that will be used for drags from a particular source to a themed icon. See the docs for #GtkIconTheme for more details. a #GtkWidget name of icon to use Sets the icon that will be used for drags from a particular widget from a #GdkPixbuf. GTK+ retains a reference for @pixbuf and will release it when it is no longer needed. a #GtkWidget the #GdkPixbuf for the drag icon Sets the icon that will be used for drags from a particular source to a stock icon. Use gtk_drag_source_set_icon_name() instead. a #GtkWidget the ID of the stock icon to use Changes the target types that this widget offers for drag-and-drop. The widget must first be made into a drag source with gtk_drag_source_set(). a #GtkWidget that’s a drag source list of draggable targets, or %NULL for none Undoes the effects of gtk_drag_source_set(). a #GtkWidget Removes a highlight set by gtk_drag_highlight() from a widget. a widget to remove the highlight from Draws @widget to @cr. The top left corner of the widget will be drawn to the currently set origin point of @cr. You should pass a cairo context as @cr argument that is in an original state. Otherwise the resulting drawing is undefined. For example changing the operator using cairo_set_operator() or the line width using cairo_set_line_width() might have unwanted side effects. You may however change the context’s transform matrix - like with cairo_scale(), cairo_translate() or cairo_set_matrix() and clip region with cairo_clip() prior to calling this function. Also, it is fine to modify the context with cairo_save() and cairo_push_group() prior to calling this function. Note that special-purpose widgets may contain special code for rendering to the screen and might appear differently on screen and when rendered using gtk_widget_draw(). the widget to draw. It must be drawable (see gtk_widget_is_drawable()) and a size must have been allocated. a cairo context to draw to Ensures that @widget has a style (@widget->style). Not a very useful function; most of the time, if you want the style, the widget is realized, and realized widgets are guaranteed to have a style already. Use #GtkStyleContext instead a #GtkWidget Notifies the user about an input-related error on this widget. If the #GtkSettings:gtk-error-bell setting is %TRUE, it calls gdk_window_beep(), otherwise it does nothing. Note that the effect of gdk_window_beep() can be configured in many ways, depending on the windowing backend and the desktop environment or window manager that is used. a #GtkWidget Rarely-used function. This function is used to emit the event signals on a widget (those signals should never be emitted without using this function to do so). If you want to synthesize an event though, don’t use this function; instead, use gtk_main_do_event() so the event will behave as if it were in the event queue. Don’t synthesize expose events; instead, use gdk_window_invalidate_rect() to invalidate a region of the window. return from the event signal emission (%TRUE if the event was handled) a #GtkWidget a #GdkEvent Stops emission of #GtkWidget::child-notify signals on @widget. The signals are queued until gtk_widget_thaw_child_notify() is called on @widget. This is the analogue of g_object_freeze_notify() for child properties. a #GtkWidget Returns the accessible object that describes the widget to an assistive technology. If accessibility support is not available, this #AtkObject instance may be a no-op. Likewise, if no class-specific #AtkObject implementation is available for the widget instance in question, it will inherit an #AtkObject implementation from the first ancestor class for which such an implementation is defined. The documentation of the [ATK](http://developer.gnome.org/atk/stable/) library contains more information about accessible objects and their uses. the #AtkObject associated with @widget a #GtkWidget Retrieves the #GActionGroup that was registered using @prefix. The resulting #GActionGroup may have been registered to @widget or any #GtkWidget in its ancestry. If no action group was found matching @prefix, then %NULL is returned. A #GActionGroup or %NULL. A #GtkWidget The “prefix” of the action group. Returns the baseline that has currently been allocated to @widget. This function is intended to be used when implementing handlers for the #GtkWidget::draw function, and when allocating child widgets in #GtkWidget::size_allocate. the baseline of the @widget, or -1 if none the widget to query Returns the height that has currently been allocated to @widget. This function is intended to be used when implementing handlers for the #GtkWidget::draw function. the height of the @widget the widget to query Retrieves the widget’s allocated size. This function returns the last values passed to gtk_widget_size_allocate_with_baseline(). The value differs from the size returned in gtk_widget_get_allocation() in that functions like gtk_widget_set_halign() can adjust the allocation, but not the value returned by this function. If a widget is not visible, its allocated size is 0. a #GtkWidget a pointer to a #GtkAllocation to copy to a pointer to an integer to copy to Returns the width that has currently been allocated to @widget. This function is intended to be used when implementing handlers for the #GtkWidget::draw function. the width of the @widget the widget to query Retrieves the widget’s allocation. Note, when implementing a #GtkContainer: a widget’s allocation will be its “adjusted” allocation, that is, the widget’s parent container typically calls gtk_widget_size_allocate() with an allocation, and that allocation is then adjusted (to handle margin and alignment for example) before assignment to the widget. gtk_widget_get_allocation() returns the adjusted allocation that was actually assigned to the widget. The adjusted allocation is guaranteed to be completely contained within the gtk_widget_size_allocate() allocation, however. So a #GtkContainer is guaranteed that its children stay inside the assigned bounds, but not that they have exactly the bounds the container assigned. There is no way to get the original allocation assigned by gtk_widget_size_allocate(), since it isn’t stored; if a container implementation needs that information it will have to track it itself. a #GtkWidget a pointer to a #GtkAllocation to copy to Gets the first ancestor of @widget with type @widget_type. For example, `gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)` gets the first #GtkBox that’s an ancestor of @widget. No reference will be added to the returned widget; it should not be unreferenced. See note about checking for a toplevel #GtkWindow in the docs for gtk_widget_get_toplevel(). Note that unlike gtk_widget_is_ancestor(), gtk_widget_get_ancestor() considers @widget to be an ancestor of itself. the ancestor widget, or %NULL if not found a #GtkWidget ancestor type Determines whether the application intends to draw on the widget in an #GtkWidget::draw handler. See gtk_widget_set_app_paintable() %TRUE if the widget is app paintable a #GtkWidget Determines whether @widget can be a default widget. See gtk_widget_set_can_default(). %TRUE if @widget can be a default widget, %FALSE otherwise a #GtkWidget Determines whether @widget can own the input focus. See gtk_widget_set_can_focus(). %TRUE if @widget can own the input focus, %FALSE otherwise a #GtkWidget This function is only for use in widget implementations. Obtains @widget->requisition, unless someone has forced a particular geometry on the widget (e.g. with gtk_widget_set_size_request()), in which case it returns that geometry instead of the widget's requisition. This function differs from gtk_widget_size_request() in that it retrieves the last size request value from @widget->requisition, while gtk_widget_size_request() actually calls the "size_request" method on @widget to compute the size request and fill in @widget->requisition, and only then returns @widget->requisition. Because this function does not call the “size_request” method, it can only be used when you know that @widget->requisition is up-to-date, that is, gtk_widget_size_request() has been called since the last time a resize was queued. In general, only container implementations have this information; applications should use gtk_widget_size_request(). Use gtk_widget_get_preferred_size() instead. a #GtkWidget a #GtkRequisition to be filled in Gets the value set with gtk_widget_set_child_visible(). If you feel a need to use this function, your code probably needs reorganization. This function is only useful for container implementations and never should be called by an application. %TRUE if the widget is mapped with the parent. a #GtkWidget Retrieves the widget’s clip area. The clip area is the area in which all of @widget's drawing will happen. Other toolkits call it the bounding box. Historically, in GTK+ the clip area has been equal to the allocation retrieved via gtk_widget_get_allocation(). a #GtkWidget a pointer to a #GtkAllocation to copy to Returns the clipboard object for the given selection to be used with @widget. @widget must have a #GdkDisplay associated with it, so must be attached to a toplevel window. the appropriate clipboard object. If no clipboard already exists, a new one will be created. Once a clipboard object has been created, it is persistent for all time. a #GtkWidget a #GdkAtom which identifies the clipboard to use. %GDK_SELECTION_CLIPBOARD gives the default clipboard. Another common value is %GDK_SELECTION_PRIMARY, which gives the primary X selection. Obtains the composite name of a widget. Use gtk_widget_class_set_template(), or don’t use this API at all. the composite name of @widget, or %NULL if @widget is not a composite child. The string should be freed when it is no longer needed. a #GtkWidget Returns whether @device can interact with @widget and its children. See gtk_widget_set_device_enabled(). %TRUE is @device is enabled for @widget a #GtkWidget a #GdkDevice Returns the events mask for the widget corresponding to an specific device. These are the events that the widget will receive when @device operates on it. device event mask for @widget a #GtkWidget a #GdkDevice Gets the reading direction for a particular widget. See gtk_widget_set_direction(). the reading direction for the widget. a #GtkWidget Get the #GdkDisplay for the toplevel window associated with this widget. This function can only be called after the widget has been added to a widget hierarchy with a #GtkWindow at the top. In general, you should only create display specific resources when a widget has been realized, and you should free those resources when the widget is unrealized. the #GdkDisplay for the toplevel for this widget. a #GtkWidget Determines whether the widget is double buffered. See gtk_widget_set_double_buffered() %TRUE if the widget is double buffered a #GtkWidget Returns the event mask (see #GdkEventMask) for the widget. These are the events that the widget will receive. Note: Internally, the widget event mask will be the logical OR of the event mask set through gtk_widget_set_events() or gtk_widget_add_events(), and the event mask necessary to cater for every #GtkEventController created for the widget. event mask for @widget a #GtkWidget Returns whether the widget should grab focus when it is clicked with the mouse. See gtk_widget_set_focus_on_click(). %TRUE if the widget should grab focus when it is clicked with the mouse. a #GtkWidget Gets the font map that has been set with gtk_widget_set_font_map(). A #PangoFontMap, or %NULL a #GtkWidget Returns the #cairo_font_options_t used for Pango rendering. When not set, the defaults font options for the #GdkScreen will be used. the #cairo_font_options_t or %NULL if not set a #GtkWidget Obtains the frame clock for a widget. The frame clock is a global “ticker” that can be used to drive animations and repaints. The most common reason to get the frame clock is to call gdk_frame_clock_get_frame_time(), in order to get a time to use for animating. For example you might record the start of the animation with an initial value from gdk_frame_clock_get_frame_time(), and then update the animation by calling gdk_frame_clock_get_frame_time() again during each repaint. gdk_frame_clock_request_phase() will result in a new frame on the clock, but won’t necessarily repaint any widgets. To repaint a widget, you have to use gtk_widget_queue_draw() which invalidates the widget (thus scheduling it to receive a draw on the next frame). gtk_widget_queue_draw() will also end up requesting a frame on the appropriate frame clock. A widget’s frame clock will not change while the widget is mapped. Reparenting a widget (which implies a temporary unmap) can change the widget’s frame clock. Unrealized widgets do not have a frame clock. a #GdkFrameClock, or %NULL if widget is unrealized a #GtkWidget Gets the value of the #GtkWidget:halign property. For backwards compatibility reasons this method will never return %GTK_ALIGN_BASELINE, but instead it will convert it to %GTK_ALIGN_FILL. Baselines are not supported for horizontal alignment. the horizontal alignment of @widget a #GtkWidget Returns the current value of the has-tooltip property. See #GtkWidget:has-tooltip for more information. current value of has-tooltip on @widget. a #GtkWidget Determines whether @widget has a #GdkWindow of its own. See gtk_widget_set_has_window(). %TRUE if @widget has a window, %FALSE otherwise a #GtkWidget Gets whether the widget would like any available extra horizontal space. When a user resizes a #GtkWindow, widgets with expand=TRUE generally receive the extra space. For example, a list or scrollable area or document in your window would often be set to expand. Containers should use gtk_widget_compute_expand() rather than this function, to see whether a widget, or any of its children, has the expand flag set. If any child of a widget wants to expand, the parent may ask to expand also. This function only looks at the widget’s own hexpand flag, rather than computing whether the entire widget tree rooted at this widget wants to expand. whether hexpand flag is set the widget Gets whether gtk_widget_set_hexpand() has been used to explicitly set the expand flag on this widget. If hexpand is set, then it overrides any computed expand value based on child widgets. If hexpand is not set, then the expand value depends on whether any children of the widget would like to expand. There are few reasons to use this function, but it’s here for completeness and consistency. whether hexpand has been explicitly set the widget Whether the widget is mapped. %TRUE if the widget is mapped, %FALSE otherwise. a #GtkWidget Gets the value of the #GtkWidget:margin-bottom property. The bottom margin of @widget a #GtkWidget Gets the value of the #GtkWidget:margin-end property. The end margin of @widget a #GtkWidget Gets the value of the #GtkWidget:margin-left property. Use gtk_widget_get_margin_start() instead. The left margin of @widget a #GtkWidget Gets the value of the #GtkWidget:margin-right property. Use gtk_widget_get_margin_end() instead. The right margin of @widget a #GtkWidget Gets the value of the #GtkWidget:margin-start property. The start margin of @widget a #GtkWidget Gets the value of the #GtkWidget:margin-top property. The top margin of @widget a #GtkWidget Returns the modifier mask the @widget’s windowing system backend uses for a particular purpose. See gdk_keymap_get_modifier_mask(). the modifier mask used for @intent. a #GtkWidget the use case for the modifier mask Returns the current modifier style for the widget. (As set by gtk_widget_modify_style().) If no style has previously set, a new #GtkRcStyle will be created with all values unset, and set as the modifier style for the widget. If you make changes to this rc style, you must call gtk_widget_modify_style(), passing in the returned rc style, to make sure that your changes take effect. Caution: passing the style back to gtk_widget_modify_style() will normally end up destroying it, because gtk_widget_modify_style() copies the passed-in style and sets the copy as the new modifier style, thus dropping any reference to the old modifier style. Add a reference to the modifier style if you want to keep it alive. Use #GtkStyleContext with a custom #GtkStyleProvider instead the modifier style for the widget. This rc style is owned by the widget. If you want to keep a pointer to value this around, you must add a refcount using g_object_ref(). a #GtkWidget Retrieves the name of a widget. See gtk_widget_set_name() for the significance of widget names. name of the widget. This string is owned by GTK+ and should not be modified or freed a #GtkWidget Returns the current value of the #GtkWidget:no-show-all property, which determines whether calls to gtk_widget_show_all() will affect this widget. the current value of the “no-show-all” property. a #GtkWidget Fetches the requested opacity for this widget. See gtk_widget_set_opacity(). the requested opacity for this widget. a #GtkWidget Gets a #PangoContext with the appropriate font map, font description, and base direction for this widget. Unlike the context returned by gtk_widget_create_pango_context(), this context is owned by the widget (it can be used until the screen for the widget changes or the widget is removed from its toplevel), and will be updated to match any changes to the widget’s attributes. This can be tracked by using the #GtkWidget::screen-changed signal on the widget. the #PangoContext for the widget. a #GtkWidget Returns the parent container of @widget. the parent container of @widget, or %NULL a #GtkWidget Gets @widget’s parent window, or %NULL if it does not have one. the parent window of @widget, or %NULL if it does not have a parent window. a #GtkWidget. Returns the #GtkWidgetPath representing @widget, if the widget is not connected to a toplevel widget, a partial path will be created. The #GtkWidgetPath representing @widget a #GtkWidget Obtains the location of the mouse pointer in widget coordinates. Widget coordinates are a bit odd; for historical reasons, they are defined as @widget->window coordinates for widgets that return %TRUE for gtk_widget_get_has_window(); and are relative to @widget->allocation.x, @widget->allocation.y otherwise. Use gdk_window_get_device_position() instead. a #GtkWidget return location for the X coordinate, or %NULL return location for the Y coordinate, or %NULL Retrieves a widget’s initial minimum and natural height. This call is specific to width-for-height requests. The returned request will be modified by the GtkWidgetClass::adjust_size_request virtual method and by any #GtkSizeGroups that have been applied. That is, the returned request is the one that should be used for layout, not necessarily the one returned by the widget itself. a #GtkWidget instance location to store the minimum height, or %NULL location to store the natural height, or %NULL Retrieves a widget’s minimum and natural height and the corresponding baselines if it would be given the specified @width, or the default height if @width is -1. The baselines may be -1 which means that no baseline is requested for this widget. The returned request will be modified by the GtkWidgetClass::adjust_size_request and GtkWidgetClass::adjust_baseline_request virtual methods and by any #GtkSizeGroups that have been applied. That is, the returned request is the one that should be used for layout, not necessarily the one returned by the widget itself. a #GtkWidget instance the width which is available for allocation, or -1 if none location for storing the minimum height, or %NULL location for storing the natural height, or %NULL location for storing the baseline for the minimum height, or %NULL location for storing the baseline for the natural height, or %NULL Retrieves a widget’s minimum and natural height if it would be given the specified @width. The returned request will be modified by the GtkWidgetClass::adjust_size_request virtual method and by any #GtkSizeGroups that have been applied. That is, the returned request is the one that should be used for layout, not necessarily the one returned by the widget itself. a #GtkWidget instance the width which is available for allocation location for storing the minimum height, or %NULL location for storing the natural height, or %NULL Retrieves the minimum and natural size of a widget, taking into account the widget’s preference for height-for-width management. This is used to retrieve a suitable size by container widgets which do not impose any restrictions on the child placement. It can be used to deduce toplevel window and menu sizes as well as child widgets in free-form containers such as GtkLayout. Handle with care. Note that the natural height of a height-for-width widget will generally be a smaller size than the minimum height, since the required height for the natural width is generally smaller than the required height for the minimum width. Use gtk_widget_get_preferred_height_and_baseline_for_width() if you want to support baseline alignment. a #GtkWidget instance location for storing the minimum size, or %NULL location for storing the natural size, or %NULL Retrieves a widget’s initial minimum and natural width. This call is specific to height-for-width requests. The returned request will be modified by the GtkWidgetClass::adjust_size_request virtual method and by any #GtkSizeGroups that have been applied. That is, the returned request is the one that should be used for layout, not necessarily the one returned by the widget itself. a #GtkWidget instance location to store the minimum width, or %NULL location to store the natural width, or %NULL Retrieves a widget’s minimum and natural width if it would be given the specified @height. The returned request will be modified by the GtkWidgetClass::adjust_size_request virtual method and by any #GtkSizeGroups that have been applied. That is, the returned request is the one that should be used for layout, not necessarily the one returned by the widget itself. a #GtkWidget instance the height which is available for allocation location for storing the minimum width, or %NULL location for storing the natural width, or %NULL Determines whether @widget is realized. %TRUE if @widget is realized, %FALSE otherwise a #GtkWidget Determines whether @widget is always treated as the default widget within its toplevel when it has the focus, even if another widget is the default. See gtk_widget_set_receives_default(). %TRUE if @widget acts as the default widget when focused, %FALSE otherwise a #GtkWidget Gets whether the widget prefers a height-for-width layout or a width-for-height layout. #GtkBin widgets generally propagate the preference of their child, container widgets need to request something either in context of their children or in context of their allocation capabilities. The #GtkSizeRequestMode preferred by @widget. a #GtkWidget instance Retrieves the widget’s requisition. This function should only be used by widget implementations in order to figure whether the widget’s requisition has actually changed after some internal state change (so that they can call gtk_widget_queue_resize() instead of gtk_widget_queue_draw()). Normally, gtk_widget_size_request() should be used. The #GtkRequisition cache on the widget was removed, If you need to cache sizes across requests and allocations, add an explicit cache to the widget in question instead. a #GtkWidget a pointer to a #GtkRequisition to copy to Get the root window where this widget is located. This function can only be called after the widget has been added to a widget hierarchy with #GtkWindow at the top. The root window is useful for such purposes as creating a popup #GdkWindow associated with the window. In general, you should only create display specific resources when a widget has been realized, and you should free those resources when the widget is unrealized. Use gdk_screen_get_root_window() instead the #GdkWindow root window for the toplevel for this widget. a #GtkWidget Retrieves the internal scale factor that maps from window coordinates to the actual device pixels. On traditional systems this is 1, on high density outputs, it can be a higher value (typically 2). See gdk_window_get_scale_factor(). the scale factor for @widget a #GtkWidget Get the #GdkScreen from the toplevel window associated with this widget. This function can only be called after the widget has been added to a widget hierarchy with a #GtkWindow at the top. In general, you should only create screen specific resources when a widget has been realized, and you should free those resources when the widget is unrealized. the #GdkScreen for the toplevel for this widget. a #GtkWidget Returns the widget’s sensitivity (in the sense of returning the value that has been set using gtk_widget_set_sensitive()). The effective sensitivity of a widget is however determined by both its own and its parent widget’s sensitivity. See gtk_widget_is_sensitive(). %TRUE if the widget is sensitive a #GtkWidget Gets the settings object holding the settings used for this widget. Note that this function can only be called when the #GtkWidget is attached to a toplevel, since the settings object is specific to a particular #GdkScreen. the relevant #GtkSettings object a #GtkWidget Gets the size request that was explicitly set for the widget using gtk_widget_set_size_request(). A value of -1 stored in @width or @height indicates that that dimension has not been set explicitly and the natural requisition of the widget will be used instead. See gtk_widget_set_size_request(). To get the size a widget will actually request, call gtk_widget_get_preferred_size() instead of this function. a #GtkWidget return location for width, or %NULL return location for height, or %NULL Returns the widget’s state. See gtk_widget_set_state(). Use gtk_widget_get_state_flags() instead. the state of @widget. a #GtkWidget Returns the widget state as a flag set. It is worth mentioning that the effective %GTK_STATE_FLAG_INSENSITIVE state will be returned, that is, also based on parent insensitivity, even if @widget itself is sensitive. Also note that if you are looking for a way to obtain the #GtkStateFlags to pass to a #GtkStyleContext method, you should look at gtk_style_context_get_state(). The state flags for widget a #GtkWidget Simply an accessor function that returns @widget->style. Use #GtkStyleContext instead the widget’s #GtkStyle a #GtkWidget Returns the style context associated to @widget. The returned object is guaranteed to be the same for the lifetime of @widget. a #GtkStyleContext. This memory is owned by @widget and must not be freed. a #GtkWidget Returns %TRUE if @widget is multiple pointer aware. See gtk_widget_set_support_multidevice() for more information. %TRUE if @widget is multidevice aware. a #GtkWidget Fetch an object build from the template XML for @widget_type in this @widget instance. This will only report children which were previously declared with gtk_widget_class_bind_template_child_full() or one of its variants. This function is only meant to be called for code which is private to the @widget_type which declared the child and is meant for language bindings which cannot easily make use of the GObject structure offsets. The object built in the template XML with the id @name A #GtkWidget The #GType to get a template child for The “id” of the child defined in the template XML Gets the contents of the tooltip for @widget. the tooltip text, or %NULL. You should free the returned string with g_free() when done. a #GtkWidget Gets the contents of the tooltip for @widget. the tooltip text, or %NULL. You should free the returned string with g_free() when done. a #GtkWidget Returns the #GtkWindow of the current tooltip. This can be the GtkWindow created by default, or the custom tooltip window set using gtk_widget_set_tooltip_window(). The #GtkWindow of the current tooltip. a #GtkWidget This function returns the topmost widget in the container hierarchy @widget is a part of. If @widget has no parent widgets, it will be returned as the topmost widget. No reference will be added to the returned widget; it should not be unreferenced. Note the difference in behavior vs. gtk_widget_get_ancestor(); `gtk_widget_get_ancestor (widget, GTK_TYPE_WINDOW)` would return %NULL if @widget wasn’t inside a toplevel window, and if the window was inside a #GtkWindow-derived widget which was in turn inside the toplevel #GtkWindow. While the second case may seem unlikely, it actually happens when a #GtkPlug is embedded inside a #GtkSocket within the same application. To reliably find the toplevel #GtkWindow, use gtk_widget_get_toplevel() and call GTK_IS_WINDOW() on the result. For instance, to get the title of a widget's toplevel window, one might use: |[<!-- language="C" --> static const char * get_widget_toplevel_title (GtkWidget *widget) { GtkWidget *toplevel = gtk_widget_get_toplevel (widget); if (GTK_IS_WINDOW (toplevel)) { return gtk_window_get_title (GTK_WINDOW (toplevel)); } return NULL; } ]| the topmost ancestor of @widget, or @widget itself if there’s no ancestor. a #GtkWidget Gets the value of the #GtkWidget:valign property. For backwards compatibility reasons this method will never return %GTK_ALIGN_BASELINE, but instead it will convert it to %GTK_ALIGN_FILL. If your widget want to support baseline aligned children it must use gtk_widget_get_valign_with_baseline(), or `g_object_get (widget, "valign", &value, NULL)`, which will also report the true value. the vertical alignment of @widget, ignoring baseline alignment a #GtkWidget Gets the value of the #GtkWidget:valign property, including %GTK_ALIGN_BASELINE. the vertical alignment of @widget a #GtkWidget Gets whether the widget would like any available extra vertical space. See gtk_widget_get_hexpand() for more detail. whether vexpand flag is set the widget Gets whether gtk_widget_set_vexpand() has been used to explicitly set the expand flag on this widget. See gtk_widget_get_hexpand_set() for more detail. whether vexpand has been explicitly set the widget Determines whether the widget is visible. If you want to take into account whether the widget’s parent is also marked as visible, use gtk_widget_is_visible() instead. This function does not check if the widget is obscured in any way. See gtk_widget_set_visible(). %TRUE if the widget is visible a #GtkWidget Gets the visual that will be used to render @widget. the visual for @widget a #GtkWidget Returns the widget’s window if it is realized, %NULL otherwise @widget’s window. a #GtkWidget Makes @widget the current grabbed widget. This means that interaction with other widgets in the same application is blocked and mouse as well as keyboard events are delivered to this widget. If @widget is not sensitive, it is not set as the current grabbed widget and this function does nothing. The widget that grabs keyboard and pointer events Causes @widget to become the default widget. @widget must be able to be a default widget; typically you would ensure this yourself by calling gtk_widget_set_can_default() with a %TRUE value. The default widget is activated when the user presses Enter in a window. Default widgets must be activatable, that is, gtk_widget_activate() should affect them. Note that #GtkEntry widgets require the “activates-default” property set to %TRUE before they activate the default widget when Enter is pressed and the #GtkEntry is focused. a #GtkWidget Causes @widget to have the keyboard focus for the #GtkWindow it's inside. @widget must be a focusable widget, such as a #GtkEntry; something like #GtkFrame won’t work. More precisely, it must have the %GTK_CAN_FOCUS flag set. Use gtk_widget_set_can_focus() to modify that flag. The widget also needs to be realized and mapped. This is indicated by the related signals. Grabbing the focus immediately after creating the widget will likely fail and cause critical warnings. a #GtkWidget Removes the grab from the given widget. You have to pair calls to gtk_grab_add() and gtk_grab_remove(). If @widget does not have the grab, this function does nothing. The widget which gives up the grab Determines whether @widget is the current default widget within its toplevel. See gtk_widget_set_can_default(). %TRUE if @widget is the current default widget within its toplevel, %FALSE otherwise a #GtkWidget Determines if the widget has the global input focus. See gtk_widget_is_focus() for the difference between having the global input focus, and only having the focus within a toplevel. %TRUE if the widget has the global input focus. a #GtkWidget Determines whether the widget is currently grabbing events, so it is the only widget receiving input events (keyboard and mouse). See also gtk_grab_add(). %TRUE if the widget is in the grab_widgets stack a #GtkWidget Determines if the widget style has been looked up through the rc mechanism. Use #GtkStyleContext instead %TRUE if the widget has been looked up through the rc mechanism, %FALSE otherwise. a #GtkWidget Checks whether there is a #GdkScreen is associated with this widget. All toplevel widgets have an associated screen, and all widgets added into a hierarchy with a toplevel window at the top. %TRUE if there is a #GdkScreen associated with the widget. a #GtkWidget Determines if the widget should show a visible indication that it has the global input focus. This is a convenience function for use in ::draw handlers that takes into account whether focus indication should currently be shown in the toplevel window of @widget. See gtk_window_get_focus_visible() for more information about focus indication. To find out if the widget has the global input focus, use gtk_widget_has_focus(). %TRUE if the widget should display a “focus rectangle” a #GtkWidget Reverses the effects of gtk_widget_show(), causing the widget to be hidden (invisible to the user). a #GtkWidget Utility function; intended to be connected to the #GtkWidget::delete-event signal on a #GtkWindow. The function calls gtk_widget_hide() on its argument, then returns %TRUE. If connected to ::delete-event, the result is that clicking the close button for a window (on the window frame, top right corner usually) will hide but not destroy the window. By default, GTK+ destroys windows when ::delete-event is received. %TRUE a #GtkWidget Returns whether the widget is currently being destroyed. This information can sometimes be used to avoid doing unnecessary work. %TRUE if @widget is being destroyed a #GtkWidget Creates and initializes child widgets defined in templates. This function must be called in the instance initializer for any class which assigned itself a template using gtk_widget_class_set_template() It is important to call this function in the instance initializer of a #GtkWidget subclass and not in #GObject.constructed() or #GObject.constructor() for two reasons. One reason is that generally derived widgets will assume that parent class composite widgets have been created in their instance initializers. Another reason is that when calling g_object_new() on a widget with composite templates, it’s important to build the composite widgets before the construct properties are set. Properties passed to g_object_new() should take precedence over properties set in the private template XML. a #GtkWidget Sets an input shape for this widget’s GDK window. This allows for windows which react to mouse click in a nonrectangular region, see gdk_window_input_shape_combine_region() for more information. a #GtkWidget shape to be added, or %NULL to remove an existing shape Inserts @group into @widget. Children of @widget that implement #GtkActionable can then be associated with actions in @group by setting their “action-name” to @prefix.`action-name`. If @group is %NULL, a previously inserted group for @name is removed from @widget. a #GtkWidget the prefix for actions in @group a #GActionGroup, or %NULL Computes the intersection of a @widget’s area and @area, storing the intersection in @intersection, and returns %TRUE if there was an intersection. @intersection may be %NULL if you’re only interested in whether there was an intersection. %TRUE if there was an intersection a #GtkWidget a rectangle rectangle to store intersection of @widget and @area Determines whether @widget is somewhere inside @ancestor, possibly with intermediate containers. %TRUE if @ancestor contains @widget as a child, grandchild, great grandchild, etc. a #GtkWidget another #GtkWidget Whether @widget can rely on having its alpha channel drawn correctly. On X11 this function returns whether a compositing manager is running for @widget’s screen. Please note that the semantics of this call will change in the future if used on a widget that has a composited window in its hierarchy (as set by gdk_window_set_composited()). Use gdk_screen_is_composited() instead. %TRUE if the widget can rely on its alpha channel being drawn correctly. a #GtkWidget Determines whether @widget can be drawn to. A widget can be drawn to if it is mapped and visible. %TRUE if @widget is drawable, %FALSE otherwise a #GtkWidget Determines if the widget is the focus widget within its toplevel. (This does not mean that the #GtkWidget:has-focus property is necessarily set; #GtkWidget:has-focus will only be set if the toplevel widget additionally has the global input focus.) %TRUE if the widget is the focus widget. a #GtkWidget Returns the widget’s effective sensitivity, which means it is sensitive itself and also its parent widget is sensitive %TRUE if the widget is effectively sensitive a #GtkWidget Determines whether @widget is a toplevel widget. Currently only #GtkWindow and #GtkInvisible (and out-of-process #GtkPlugs) are toplevel widgets. Toplevel widgets have no parent widget. %TRUE if @widget is a toplevel, %FALSE otherwise a #GtkWidget Determines whether the widget and all its parents are marked as visible. This function does not check if the widget is obscured in any way. See also gtk_widget_get_visible() and gtk_widget_set_visible() %TRUE if the widget and all its parents are visible a #GtkWidget This function should be called whenever keyboard navigation within a single widget hits a boundary. The function emits the #GtkWidget::keynav-failed signal on the widget and its return value should be interpreted in a way similar to the return value of gtk_widget_child_focus(): When %TRUE is returned, stay in the widget, the failed keyboard navigation is OK and/or there is nowhere we can/should move the focus to. When %FALSE is returned, the caller should continue with keyboard navigation outside the widget, e.g. by calling gtk_widget_child_focus() on the widget’s toplevel. The default ::keynav-failed handler returns %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD. For the other values of #GtkDirectionType it returns %TRUE. Whenever the default handler returns %TRUE, it also calls gtk_widget_error_bell() to notify the user of the failed keyboard navigation. A use case for providing an own implementation of ::keynav-failed (either by connecting to it or by overriding it) would be a row of #GtkEntry widgets where the user should be able to navigate the entire row with the cursor keys, as e.g. known from user interfaces that require entering license keys. %TRUE if stopping keyboard navigation is fine, %FALSE if the emitting widget should try to handle the keyboard navigation attempt in its parent container(s). a #GtkWidget direction of focus movement Lists the closures used by @widget for accelerator group connections with gtk_accel_group_connect_by_path() or gtk_accel_group_connect(). The closures can be used to monitor accelerator changes on @widget, by connecting to the @GtkAccelGroup::accel-changed signal of the #GtkAccelGroup of a closure which can be found out with gtk_accel_group_from_accel_closure(). a newly allocated #GList of closures widget to list accelerator closures for Retrieves a %NULL-terminated array of strings containing the prefixes of #GActionGroup's available to @widget. a %NULL-terminated array of strings. A #GtkWidget Returns a newly allocated list of the widgets, normally labels, for which this widget is the target of a mnemonic (see for example, gtk_label_set_mnemonic_widget()). The widgets in the list are not individually referenced. If you want to iterate through the list and perform actions involving callbacks that might destroy the widgets, you must call `g_list_foreach (result, (GFunc)g_object_ref, NULL)` first, and then unref all the widgets afterwards. the list of mnemonic labels; free this list with g_list_free() when you are done with it. a #GtkWidget This function is only for use in widget implementations. Causes a widget to be mapped if it isn’t already. a #GtkWidget Emits the #GtkWidget::mnemonic-activate signal. %TRUE if the signal has been handled a #GtkWidget %TRUE if there are other widgets with the same mnemonic Sets the base color for a widget in a particular state. All other style values are left untouched. The base color is the background color used along with the text color (see gtk_widget_modify_text()) for widgets such as #GtkEntry and #GtkTextView. See also gtk_widget_modify_style(). > Note that “no window” widgets (which have the %GTK_NO_WINDOW > flag set) draw on their parent container’s window and thus may > not draw any background themselves. This is the case for e.g. > #GtkLabel. > > To modify the background of such widgets, you have to set the > base color on their parent; if you want to set the background > of a rectangular area around a label, try placing the label in > a #GtkEventBox widget and setting the base color on that. Use gtk_widget_override_background_color() instead a #GtkWidget the state for which to set the base color the color to assign (does not need to be allocated), or %NULL to undo the effect of previous calls to of gtk_widget_modify_base(). Sets the background color for a widget in a particular state. All other style values are left untouched. See also gtk_widget_modify_style(). > Note that “no window” widgets (which have the %GTK_NO_WINDOW > flag set) draw on their parent container’s window and thus may > not draw any background themselves. This is the case for e.g. > #GtkLabel. > > To modify the background of such widgets, you have to set the > background color on their parent; if you want to set the background > of a rectangular area around a label, try placing the label in > a #GtkEventBox widget and setting the background color on that. Use gtk_widget_override_background_color() instead a #GtkWidget the state for which to set the background color the color to assign (does not need to be allocated), or %NULL to undo the effect of previous calls to of gtk_widget_modify_bg(). Sets the cursor color to use in a widget, overriding the #GtkWidget cursor-color and secondary-cursor-color style properties. All other style values are left untouched. See also gtk_widget_modify_style(). Use gtk_widget_override_cursor() instead. a #GtkWidget the color to use for primary cursor (does not need to be allocated), or %NULL to undo the effect of previous calls to of gtk_widget_modify_cursor(). the color to use for secondary cursor (does not need to be allocated), or %NULL to undo the effect of previous calls to of gtk_widget_modify_cursor(). Sets the foreground color for a widget in a particular state. All other style values are left untouched. See also gtk_widget_modify_style(). Use gtk_widget_override_color() instead a #GtkWidget the state for which to set the foreground color the color to assign (does not need to be allocated), or %NULL to undo the effect of previous calls to of gtk_widget_modify_fg(). Sets the font to use for a widget. All other style values are left untouched. See also gtk_widget_modify_style(). Use gtk_widget_override_font() instead a #GtkWidget the font description to use, or %NULL to undo the effect of previous calls to gtk_widget_modify_font() Modifies style values on the widget. Modifications made using this technique take precedence over style values set via an RC file, however, they will be overridden if a style is explicitly set on the widget using gtk_widget_set_style(). The #GtkRcStyle-struct is designed so each field can either be set or unset, so it is possible, using this function, to modify some style values and leave the others unchanged. Note that modifications made with this function are not cumulative with previous calls to gtk_widget_modify_style() or with such functions as gtk_widget_modify_fg(). If you wish to retain previous values, you must first call gtk_widget_get_modifier_style(), make your modifications to the returned style, then call gtk_widget_modify_style() with that style. On the other hand, if you first call gtk_widget_modify_style(), subsequent calls to such functions gtk_widget_modify_fg() will have a cumulative effect with the initial modifications. Use #GtkStyleContext with a custom #GtkStyleProvider instead a #GtkWidget the #GtkRcStyle-struct holding the style modifications Sets the text color for a widget in a particular state. All other style values are left untouched. The text color is the foreground color used along with the base color (see gtk_widget_modify_base()) for widgets such as #GtkEntry and #GtkTextView. See also gtk_widget_modify_style(). Use gtk_widget_override_color() instead a #GtkWidget the state for which to set the text color the color to assign (does not need to be allocated), or %NULL to undo the effect of previous calls to of gtk_widget_modify_text(). Sets the background color to use for a widget. All other style values are left untouched. See gtk_widget_override_color(). This function is not useful in the context of CSS-based rendering. If you wish to change the way a widget renders its background you should use a custom CSS style, through an application-specific #GtkStyleProvider and a CSS style class. You can also override the default drawing of a widget through the #GtkWidget::draw signal, and use Cairo to draw a specific color, regardless of the CSS style. a #GtkWidget the state for which to set the background color the color to assign, or %NULL to undo the effect of previous calls to gtk_widget_override_background_color() Sets the color to use for a widget. All other style values are left untouched. This function does not act recursively. Setting the color of a container does not affect its children. Note that some widgets that you may not think of as containers, for instance #GtkButtons, are actually containers. This API is mostly meant as a quick way for applications to change a widget appearance. If you are developing a widgets library and intend this change to be themeable, it is better done by setting meaningful CSS classes in your widget/container implementation through gtk_style_context_add_class(). This way, your widget library can install a #GtkCssProvider with the %GTK_STYLE_PROVIDER_PRIORITY_FALLBACK priority in order to provide a default styling for those widgets that need so, and this theming may fully overridden by the user’s theme. Note that for complex widgets this may bring in undesired results (such as uniform background color everywhere), in these cases it is better to fully style such widgets through a #GtkCssProvider with the %GTK_STYLE_PROVIDER_PRIORITY_APPLICATION priority. Use a custom style provider and style classes instead a #GtkWidget the state for which to set the color the color to assign, or %NULL to undo the effect of previous calls to gtk_widget_override_color() Sets the cursor color to use in a widget, overriding the cursor-color and secondary-cursor-color style properties. All other style values are left untouched. See also gtk_widget_modify_style(). Note that the underlying properties have the #GdkColor type, so the alpha value in @primary and @secondary will be ignored. This function is not useful in the context of CSS-based rendering. If you wish to change the color used to render the primary and secondary cursors you should use a custom CSS style, through an application-specific #GtkStyleProvider and a CSS style class. a #GtkWidget the color to use for primary cursor (does not need to be allocated), or %NULL to undo the effect of previous calls to of gtk_widget_override_cursor(). the color to use for secondary cursor (does not need to be allocated), or %NULL to undo the effect of previous calls to of gtk_widget_override_cursor(). Sets the font to use for a widget. All other style values are left untouched. See gtk_widget_override_color(). This function is not useful in the context of CSS-based rendering. If you wish to change the font a widget uses to render its text you should use a custom CSS style, through an application-specific #GtkStyleProvider and a CSS style class. a #GtkWidget the font description to use, or %NULL to undo the effect of previous calls to gtk_widget_override_font() Sets a symbolic color for a widget. All other style values are left untouched. See gtk_widget_override_color() for overriding the foreground or background color. This function is not useful in the context of CSS-based rendering. If you wish to change the color used to render symbolic icons you should use a custom CSS style, through an application-specific #GtkStyleProvider and a CSS style class. a #GtkWidget the name of the symbolic color to modify the color to assign (does not need to be allocated), or %NULL to undo the effect of previous calls to gtk_widget_override_symbolic_color() Obtains the full path to @widget. The path is simply the name of a widget and all its parents in the container hierarchy, separated by periods. The name of a widget comes from gtk_widget_get_name(). Paths are used to apply styles to a widget in gtkrc configuration files. Widget names are the type of the widget by default (e.g. “GtkButton”) or can be set to an application-specific value with gtk_widget_set_name(). By setting the name of a widget, you allow users or theme authors to apply styles to that specific widget in their gtkrc file. @path_reversed_p fills in the path in reverse order, i.e. starting with @widget’s name instead of starting with the name of @widget’s outermost ancestor. Use gtk_widget_get_path() instead a #GtkWidget location to store length of the path, or %NULL location to store allocated path string, or %NULL location to store allocated reverse path string, or %NULL This function is only for use in widget implementations. Flags the widget for a rerun of the GtkWidgetClass::size_allocate function. Use this function instead of gtk_widget_queue_resize() when the @widget's size request didn't change but it wants to reposition its contents. An example user of this function is gtk_widget_set_halign(). a #GtkWidget Mark @widget as needing to recompute its expand flags. Call this function when setting legacy expand child properties on the child of a container. See gtk_widget_compute_expand(). a #GtkWidget Equivalent to calling gtk_widget_queue_draw_area() for the entire area of a widget. a #GtkWidget Convenience function that calls gtk_widget_queue_draw_region() on the region created from the given coordinates. The region here is specified in widget coordinates. Widget coordinates are a bit odd; for historical reasons, they are defined as @widget->window coordinates for widgets that return %TRUE for gtk_widget_get_has_window(), and are relative to @widget->allocation.x, @widget->allocation.y otherwise. @width or @height may be 0, in this case this function does nothing. Negative values for @width and @height are not allowed. a #GtkWidget x coordinate of upper-left corner of rectangle to redraw y coordinate of upper-left corner of rectangle to redraw width of region to draw height of region to draw Invalidates the area of @widget defined by @region by calling gdk_window_invalidate_region() on the widget’s window and all its child windows. Once the main loop becomes idle (after the current batch of events has been processed, roughly), the window will receive expose events for the union of all regions that have been invalidated. Normally you would only use this function in widget implementations. You might also use it to schedule a redraw of a #GtkDrawingArea or some portion thereof. a #GtkWidget region to draw This function is only for use in widget implementations. Flags a widget to have its size renegotiated; should be called when a widget for some reason has a new size request. For example, when you change the text in a #GtkLabel, #GtkLabel queues a resize to ensure there’s enough space for the new text. Note that you cannot call gtk_widget_queue_resize() on a widget from inside its implementation of the GtkWidgetClass::size_allocate virtual method. Calls to gtk_widget_queue_resize() from inside GtkWidgetClass::size_allocate will be silently ignored. a #GtkWidget This function works like gtk_widget_queue_resize(), except that the widget is not invalidated. a #GtkWidget Creates the GDK (windowing system) resources associated with a widget. For example, @widget->window will be created when a widget is realized. Normally realization happens implicitly; if you show a widget and all its parent containers, then the widget will be realized and mapped automatically. Realizing a widget requires all the widget’s parent widgets to be realized; calling gtk_widget_realize() realizes the widget’s parents in addition to @widget itself. If a widget is not yet inside a toplevel window when you realize it, bad things will happen. This function is primarily used in widget implementations, and isn’t very useful otherwise. Many times when you think you might need it, a better approach is to connect to a signal that will be called after the widget is realized automatically, such as #GtkWidget::draw. Or simply g_signal_connect () to the #GtkWidget::realize signal. a #GtkWidget Computes the intersection of a @widget’s area and @region, returning the intersection. The result may be empty, use cairo_region_is_empty() to check. Use gtk_widget_get_allocation() and cairo_region_intersect_rectangle() to get the same behavior. A newly allocated region holding the intersection of @widget and @region. a #GtkWidget a #cairo_region_t, in the same coordinate system as @widget->allocation. That is, relative to @widget->window for widgets which return %FALSE from gtk_widget_get_has_window(); relative to the parent window of @widget->window otherwise. Registers a #GdkWindow with the widget and sets it up so that the widget receives events for it. Call gtk_widget_unregister_window() when destroying the window. Before 3.8 you needed to call gdk_window_set_user_data() directly to set this up. This is now deprecated and you should use gtk_widget_register_window() instead. Old code will keep working as is, although some new features like transparency might not work perfectly. a #GtkWidget a #GdkWindow Removes an accelerator from @widget, previously installed with gtk_widget_add_accelerator(). whether an accelerator was installed and could be removed widget to install an accelerator on accel group for this widget GDK keyval of the accelerator modifier key combination of the accelerator Removes a widget from the list of mnemonic labels for this widget. (See gtk_widget_list_mnemonic_labels()). The widget must have previously been added to the list with gtk_widget_add_mnemonic_label(). a #GtkWidget a #GtkWidget that was previously set as a mnemonic label for @widget with gtk_widget_add_mnemonic_label(). Removes a tick callback previously registered with gtk_widget_add_tick_callback(). a #GtkWidget an id returned by gtk_widget_add_tick_callback() A convenience function that uses the theme settings for @widget to look up @stock_id and render it to a pixbuf. @stock_id should be a stock icon ID such as #GTK_STOCK_OPEN or #GTK_STOCK_OK. @size should be a size such as #GTK_ICON_SIZE_MENU. @detail should be a string that identifies the widget or code doing the rendering, so that theme engines can special-case rendering for that widget or code. The pixels in the returned #GdkPixbuf are shared with the rest of the application and should not be modified. The pixbuf should be freed after use with g_object_unref(). Use gtk_widget_render_icon_pixbuf() instead. a new pixbuf, or %NULL if the stock ID wasn’t known a #GtkWidget a stock ID a stock size (#GtkIconSize). A size of `(GtkIconSize)-1` means render at the size of the source and don’t scale (if there are multiple source sizes, GTK+ picks one of the available sizes). render detail to pass to theme engine A convenience function that uses the theme engine and style settings for @widget to look up @stock_id and render it to a pixbuf. @stock_id should be a stock icon ID such as #GTK_STOCK_OPEN or #GTK_STOCK_OK. @size should be a size such as #GTK_ICON_SIZE_MENU. The pixels in the returned #GdkPixbuf are shared with the rest of the application and should not be modified. The pixbuf should be freed after use with g_object_unref(). Use gtk_icon_theme_load_icon() instead. a new pixbuf, or %NULL if the stock ID wasn’t known a #GtkWidget a stock ID a stock size (#GtkIconSize). A size of `(GtkIconSize)-1` means render at the size of the source and don’t scale (if there are multiple source sizes, GTK+ picks one of the available sizes). Moves a widget from one #GtkContainer to another, handling reference count issues to avoid destroying the widget. Use gtk_container_remove() and gtk_container_add(). a #GtkWidget a #GtkContainer to move the widget into Reset the styles of @widget and all descendents, so when they are looked up again, they get the correct values for the currently loaded RC file settings. This function is not useful for applications. Use #GtkStyleContext instead, and gtk_widget_reset_style() a #GtkWidget. Updates the style context of @widget and all descendants by updating its widget path. #GtkContainers may want to use this on a child when reordering it in a way that a different style might apply to it. See also gtk_container_get_path_for_child(). a #GtkWidget Very rarely-used function. This function is used to emit an expose event on a widget. This function is not normally used directly. The only time it is used is when propagating an expose event to a windowless child widget (gtk_widget_get_has_window() is %FALSE), and that is normally done using gtk_container_propagate_draw(). If you want to force an area of a window to be redrawn, use gdk_window_invalidate_rect() or gdk_window_invalidate_region(). To cause the redraw to be done immediately, follow that call with a call to gdk_window_process_updates(). Application and widget code should not handle expose events directly; invalidation should use the #GtkWidget API, and drawing should only happen inside #GtkWidget::draw implementations return from the event signal emission (%TRUE if the event was handled) a #GtkWidget a expose #GdkEvent Sends the focus change @event to @widget This function is not meant to be used by applications. The only time it should be used is when it is necessary for a #GtkWidget to assign focus to a widget that is semantically owned by the first widget even though it’s not a direct child - for instance, a search entry in a floating window similar to the quick search in #GtkTreeView. An example of its usage is: |[<!-- language="C" --> GdkEvent *fevent = gdk_event_new (GDK_FOCUS_CHANGE); fevent->focus_change.type = GDK_FOCUS_CHANGE; fevent->focus_change.in = TRUE; fevent->focus_change.window = _gtk_widget_get_window (widget); if (fevent->focus_change.window != NULL) g_object_ref (fevent->focus_change.window); gtk_widget_send_focus_change (widget, fevent); gdk_event_free (event); ]| the return value from the event signal emission: %TRUE if the event was handled, and %FALSE otherwise a #GtkWidget a #GdkEvent of type GDK_FOCUS_CHANGE Given an accelerator group, @accel_group, and an accelerator path, @accel_path, sets up an accelerator in @accel_group so whenever the key binding that is defined for @accel_path is pressed, @widget will be activated. This removes any accelerators (for any accelerator group) installed by previous calls to gtk_widget_set_accel_path(). Associating accelerators with paths allows them to be modified by the user and the modifications to be saved for future use. (See gtk_accel_map_save().) This function is a low level function that would most likely be used by a menu creation system like #GtkUIManager. If you use #GtkUIManager, setting up accelerator paths will be done automatically. Even when you you aren’t using #GtkUIManager, if you only want to set up accelerators on menu items gtk_menu_item_set_accel_path() provides a somewhat more convenient interface. Note that @accel_path string will be stored in a #GQuark. Therefore, if you pass a static string, you can save some memory by interning it first with g_intern_static_string(). a #GtkWidget path used to look up the accelerator a #GtkAccelGroup. Sets the widget’s allocation. This should not be used directly, but from within a widget’s size_allocate method. The allocation set should be the “adjusted” or actual allocation. If you’re implementing a #GtkContainer, you want to use gtk_widget_size_allocate() instead of gtk_widget_set_allocation(). The GtkWidgetClass::adjust_size_allocation virtual method adjusts the allocation inside gtk_widget_size_allocate() to create an adjusted allocation. a #GtkWidget a pointer to a #GtkAllocation to copy from Sets whether the application intends to draw on the widget in an #GtkWidget::draw handler. This is a hint to the widget and does not affect the behavior of the GTK+ core; many widgets ignore this flag entirely. For widgets that do pay attention to the flag, such as #GtkEventBox and #GtkWindow, the effect is to suppress default themed drawing of the widget's background. (Children of the widget will still be drawn.) The application is then entirely responsible for drawing the widget background. Note that the background is still drawn when the widget is mapped. a #GtkWidget %TRUE if the application will paint on the widget Specifies whether @widget can be a default widget. See gtk_widget_grab_default() for details about the meaning of “default”. a #GtkWidget whether or not @widget can be a default widget. Specifies whether @widget can own the input focus. See gtk_widget_grab_focus() for actually setting the input focus on a widget. a #GtkWidget whether or not @widget can own the input focus. Sets whether @widget should be mapped along with its when its parent is mapped and @widget has been shown with gtk_widget_show(). The child visibility can be set for widget before it is added to a container with gtk_widget_set_parent(), to avoid mapping children unnecessary before immediately unmapping them. However it will be reset to its default state of %TRUE when the widget is removed from a container. Note that changing the child visibility of a widget does not queue a resize on the widget. Most of the time, the size of a widget is computed from all visible children, whether or not they are mapped. If this is not the case, the container can queue a resize itself. This function is only useful for container implementations and never should be called by an application. a #GtkWidget if %TRUE, @widget should be mapped along with its parent. Sets the widget’s clip. This must not be used directly, but from within a widget’s size_allocate method. It must be called after gtk_widget_set_allocation() (or after chaining up to the parent class), because that function resets the clip. The clip set should be the area that @widget draws on. If @widget is a #GtkContainer, the area must contain all children's clips. If this function is not called by @widget during a ::size-allocate handler, the clip will be set to @widget's allocation. a #GtkWidget a pointer to a #GtkAllocation to copy from Sets a widgets composite name. The widget must be a composite child of its parent; see gtk_widget_push_composite_child(). Use gtk_widget_class_set_template(), or don’t use this API at all. a #GtkWidget. the name to set Enables or disables a #GdkDevice to interact with @widget and all its children. It does so by descending through the #GdkWindow hierarchy and enabling the same mask that is has for core events (i.e. the one that gdk_window_get_events() returns). a #GtkWidget a #GdkDevice whether to enable the device Sets the device event mask (see #GdkEventMask) for a widget. The event mask determines which events a widget will receive from @device. Keep in mind that different widgets have different default event masks, and by changing the event mask you may disrupt a widget’s functionality, so be careful. This function must be called while a widget is unrealized. Consider gtk_widget_add_device_events() for widgets that are already realized, or if you want to preserve the existing event mask. This function can’t be used with windowless widgets (which return %FALSE from gtk_widget_get_has_window()); to get events on those widgets, place them inside a #GtkEventBox and receive events on the event box. a #GtkWidget a #GdkDevice event mask Sets the reading direction on a particular widget. This direction controls the primary direction for widgets containing text, and also the direction in which the children of a container are packed. The ability to set the direction is present in order so that correct localization into languages with right-to-left reading directions can be done. Generally, applications will let the default reading direction present, except for containers where the containers are arranged in an order that is explicitly visual rather than logical (such as buttons for text justification). If the direction is set to %GTK_TEXT_DIR_NONE, then the value set by gtk_widget_set_default_direction() will be used. a #GtkWidget the new direction Widgets are double buffered by default; you can use this function to turn off the buffering. “Double buffered” simply means that gdk_window_begin_draw_frame() and gdk_window_end_draw_frame() are called automatically around expose events sent to the widget. gdk_window_begin_draw_frame() diverts all drawing to a widget's window to an offscreen buffer, and gdk_window_end_draw_frame() draws the buffer to the screen. The result is that users see the window update in one smooth step, and don’t see individual graphics primitives being rendered. In very simple terms, double buffered widgets don’t flicker, so you would only use this function to turn off double buffering if you had special needs and really knew what you were doing. Note: if you turn off double-buffering, you have to handle expose events, since even the clearing to the background color or pixmap will not happen automatically (as it is done in gdk_window_begin_draw_frame()). In 3.10 GTK and GDK have been restructured for translucent drawing. Since then expose events for double-buffered widgets are culled into a single event to the toplevel GDK window. If you now unset double buffering, you will cause a separate rendering pass for every widget. This will likely cause rendering problems - in particular related to stacking - and usually increases rendering times significantly. This function does not work under non-X11 backends or with non-native windows. It should not be used in newly written code. a #GtkWidget %TRUE to double-buffer a widget Sets the event mask (see #GdkEventMask) for a widget. The event mask determines which events a widget will receive. Keep in mind that different widgets have different default event masks, and by changing the event mask you may disrupt a widget’s functionality, so be careful. This function must be called while a widget is unrealized. Consider gtk_widget_add_events() for widgets that are already realized, or if you want to preserve the existing event mask. This function can’t be used with widgets that have no window. (See gtk_widget_get_has_window()). To get events on those widgets, place them inside a #GtkEventBox and receive events on the event box. a #GtkWidget event mask Sets whether the widget should grab focus when it is clicked with the mouse. Making mouse clicks not grab focus is useful in places like toolbars where you don’t want the keyboard focus removed from the main area of the application. a #GtkWidget whether the widget should grab focus when clicked with the mouse Sets the font map to use for Pango rendering. When not set, the widget will inherit the font map from its parent. a #GtkWidget a #PangoFontMap, or %NULL to unset any previously set font map Sets the #cairo_font_options_t used for Pango rendering in this widget. When not set, the default font options for the #GdkScreen will be used. a #GtkWidget a #cairo_font_options_t, or %NULL to unset any previously set default font options. Sets the horizontal alignment of @widget. See the #GtkWidget:halign property. a #GtkWidget the horizontal alignment Sets the has-tooltip property on @widget to @has_tooltip. See #GtkWidget:has-tooltip for more information. a #GtkWidget whether or not @widget has a tooltip. Specifies whether @widget has a #GdkWindow of its own. Note that all realized widgets have a non-%NULL “window” pointer (gtk_widget_get_window() never returns a %NULL window when a widget is realized), but for many of them it’s actually the #GdkWindow of one of its parent widgets. Widgets that do not create a %window for themselves in #GtkWidget::realize must announce this by calling this function with @has_window = %FALSE. This function should only be called by widget implementations, and they should call it in their init() function. a #GtkWidget whether or not @widget has a window. Sets whether the widget would like any available extra horizontal space. When a user resizes a #GtkWindow, widgets with expand=TRUE generally receive the extra space. For example, a list or scrollable area or document in your window would often be set to expand. Call this function to set the expand flag if you would like your widget to become larger horizontally when the window has extra room. By default, widgets automatically expand if any of their children want to expand. (To see if a widget will automatically expand given its current children and state, call gtk_widget_compute_expand(). A container can decide how the expandability of children affects the expansion of the container by overriding the compute_expand virtual method on #GtkWidget.). Setting hexpand explicitly with this function will override the automatic expand behavior. This function forces the widget to expand or not to expand, regardless of children. The override occurs because gtk_widget_set_hexpand() sets the hexpand-set property (see gtk_widget_set_hexpand_set()) which causes the widget’s hexpand value to be used, rather than looking at children and widget state. the widget whether to expand Sets whether the hexpand flag (see gtk_widget_get_hexpand()) will be used. The hexpand-set property will be set automatically when you call gtk_widget_set_hexpand() to set hexpand, so the most likely reason to use this function would be to unset an explicit expand flag. If hexpand is set, then it overrides any computed expand value based on child widgets. If hexpand is not set, then the expand value depends on whether any children of the widget would like to expand. There are few reasons to use this function, but it’s here for completeness and consistency. the widget value for hexpand-set property Marks the widget as being mapped. This function should only ever be called in a derived widget's “map” or “unmap” implementation. a #GtkWidget %TRUE to mark the widget as mapped Sets the bottom margin of @widget. See the #GtkWidget:margin-bottom property. a #GtkWidget the bottom margin Sets the end margin of @widget. See the #GtkWidget:margin-end property. a #GtkWidget the end margin Sets the left margin of @widget. See the #GtkWidget:margin-left property. Use gtk_widget_set_margin_start() instead. a #GtkWidget the left margin Sets the right margin of @widget. See the #GtkWidget:margin-right property. Use gtk_widget_set_margin_end() instead. a #GtkWidget the right margin Sets the start margin of @widget. See the #GtkWidget:margin-start property. a #GtkWidget the start margin Sets the top margin of @widget. See the #GtkWidget:margin-top property. a #GtkWidget the top margin Widgets can be named, which allows you to refer to them from a CSS file. You can apply a style to widgets with a particular name in the CSS file. See the documentation for the CSS syntax (on the same page as the docs for #GtkStyleContext). Note that the CSS syntax has certain special characters to delimit and represent elements in a selector (period, #, >, *...), so using these will make your widget impossible to match by name. Any combination of alphanumeric symbols, dashes and underscores will suffice. a #GtkWidget name for the widget Sets the #GtkWidget:no-show-all property, which determines whether calls to gtk_widget_show_all() will affect this widget. This is mostly for use in constructing widget hierarchies with externally controlled visibility, see #GtkUIManager. a #GtkWidget the new value for the “no-show-all” property Request the @widget to be rendered partially transparent, with opacity 0 being fully transparent and 1 fully opaque. (Opacity values are clamped to the [0,1] range.). This works on both toplevel widget, and child widgets, although there are some limitations: For toplevel widgets this depends on the capabilities of the windowing system. On X11 this has any effect only on X screens with a compositing manager running. See gtk_widget_is_composited(). On Windows it should work always, although setting a window’s opacity after the window has been shown causes it to flicker once on Windows. For child widgets it doesn’t work if any affected widget has a native window, or disables double buffering. a #GtkWidget desired opacity, between 0 and 1 This function is useful only when implementing subclasses of #GtkContainer. Sets the container as the parent of @widget, and takes care of some details such as updating the state and style of the child to reflect its new location. The opposite function is gtk_widget_unparent(). a #GtkWidget parent container Sets a non default parent window for @widget. For #GtkWindow classes, setting a @parent_window effects whether the window is a toplevel window or can be embedded into other widgets. For #GtkWindow classes, this needs to be called before the window is realized. a #GtkWidget. the new parent window. Marks the widget as being realized. This function must only be called after all #GdkWindows for the @widget have been created and registered. This function should only ever be called in a derived widget's “realize” or “unrealize” implementation. a #GtkWidget %TRUE to mark the widget as realized Specifies whether @widget will be treated as the default widget within its toplevel when it has the focus, even if another widget is the default. See gtk_widget_grab_default() for details about the meaning of “default”. a #GtkWidget whether or not @widget can be a default widget. Sets whether the entire widget is queued for drawing when its size allocation changes. By default, this setting is %TRUE and the entire widget is redrawn on every size change. If your widget leaves the upper left unchanged when made bigger, turning this setting off will improve performance. Note that for widgets where gtk_widget_get_has_window() is %FALSE setting this flag to %FALSE turns off all allocation on resizing: the widget will not even redraw if its position changes; this is to allow containers that don’t draw anything to avoid excess invalidations. If you set this flag on a widget with no window that does draw on @widget->window, you are responsible for invalidating both the old and new allocation of the widget when the widget is moved and responsible for invalidating regions newly when the widget increases size. a #GtkWidget if %TRUE, the entire widget will be redrawn when it is allocated to a new size. Otherwise, only the new portion of the widget will be redrawn. Sets the sensitivity of a widget. A widget is sensitive if the user can interact with it. Insensitive widgets are “grayed out” and the user can’t interact with them. Insensitive widgets are known as “inactive”, “disabled”, or “ghosted” in some other toolkits. a #GtkWidget %TRUE to make the widget sensitive Sets the minimum size of a widget; that is, the widget’s size request will be at least @width by @height. You can use this function to force a widget to be larger than it normally would be. In most cases, gtk_window_set_default_size() is a better choice for toplevel windows than this function; setting the default size will still allow users to shrink the window. Setting the size request will force them to leave the window at least as large as the size request. When dealing with window sizes, gtk_window_set_geometry_hints() can be a useful function as well. Note the inherent danger of setting any fixed size - themes, translations into other languages, different fonts, and user action can all change the appropriate size for a given widget. So, it's basically impossible to hardcode a size that will always be correct. The size request of a widget is the smallest size a widget can accept while still functioning well and drawing itself correctly. However in some strange cases a widget may be allocated less than its requested size, and in many cases a widget may be allocated more space than it requested. If the size request in a given direction is -1 (unset), then the “natural” size request of the widget will be used instead. The size request set here does not include any margin from the #GtkWidget properties margin-left, margin-right, margin-top, and margin-bottom, but it does include pretty much all other padding or border properties set by any subclass of #GtkWidget. a #GtkWidget width @widget should request, or -1 to unset height @widget should request, or -1 to unset This function is for use in widget implementations. Sets the state of a widget (insensitive, prelighted, etc.) Usually you should set the state using wrapper functions such as gtk_widget_set_sensitive(). Use gtk_widget_set_state_flags() instead. a #GtkWidget new state for @widget This function is for use in widget implementations. Turns on flag values in the current widget state (insensitive, prelighted, etc.). This function accepts the values %GTK_STATE_FLAG_DIR_LTR and %GTK_STATE_FLAG_DIR_RTL but ignores them. If you want to set the widget's direction, use gtk_widget_set_direction(). It is worth mentioning that any other state than %GTK_STATE_FLAG_INSENSITIVE, will be propagated down to all non-internal children if @widget is a #GtkContainer, while %GTK_STATE_FLAG_INSENSITIVE itself will be propagated down to all #GtkContainer children by different means than turning on the state flag down the hierarchy, both gtk_widget_get_state_flags() and gtk_widget_is_sensitive() will make use of these. a #GtkWidget State flags to turn on Whether to clear state before turning on @flags Used to set the #GtkStyle for a widget (@widget->style). Since GTK 3, this function does nothing, the passed in style is ignored. Use #GtkStyleContext instead a #GtkWidget a #GtkStyle, or %NULL to remove the effect of a previous call to gtk_widget_set_style() and go back to the default style Enables or disables multiple pointer awareness. If this setting is %TRUE, @widget will start receiving multiple, per device enter/leave events. Note that if custom #GdkWindows are created in #GtkWidget::realize, gdk_window_set_support_multidevice() will have to be called manually on them. a #GtkWidget %TRUE to support input from multiple devices. Sets @markup as the contents of the tooltip, which is marked up with the [Pango text markup language][PangoMarkupFormat]. This function will take care of setting #GtkWidget:has-tooltip to %TRUE and of the default handler for the #GtkWidget::query-tooltip signal. See also the #GtkWidget:tooltip-markup property and gtk_tooltip_set_markup(). a #GtkWidget the contents of the tooltip for @widget, or %NULL Sets @text as the contents of the tooltip. This function will take care of setting #GtkWidget:has-tooltip to %TRUE and of the default handler for the #GtkWidget::query-tooltip signal. See also the #GtkWidget:tooltip-text property and gtk_tooltip_set_text(). a #GtkWidget the contents of the tooltip for @widget Replaces the default window used for displaying tooltips with @custom_window. GTK+ will take care of showing and hiding @custom_window at the right moment, to behave likewise as the default tooltip window. If @custom_window is %NULL, the default tooltip window will be used. a #GtkWidget a #GtkWindow, or %NULL Sets the vertical alignment of @widget. See the #GtkWidget:valign property. a #GtkWidget the vertical alignment Sets whether the widget would like any available extra vertical space. See gtk_widget_set_hexpand() for more detail. the widget whether to expand Sets whether the vexpand flag (see gtk_widget_get_vexpand()) will be used. See gtk_widget_set_hexpand_set() for more detail. the widget value for vexpand-set property Sets the visibility state of @widget. Note that setting this to %TRUE doesn’t mean the widget is actually viewable, see gtk_widget_get_visible(). This function simply calls gtk_widget_show() or gtk_widget_hide() but is nicer to use when the visibility of the widget depends on some condition. a #GtkWidget whether the widget should be shown or not Sets the visual that should be used for by widget and its children for creating #GdkWindows. The visual must be on the same #GdkScreen as returned by gtk_widget_get_screen(), so handling the #GtkWidget::screen-changed signal is necessary. Setting a new @visual will not cause @widget to recreate its windows, so you should call this function before @widget is realized. a #GtkWidget visual to be used or %NULL to unset a previous one Sets a widget’s window. This function should only be used in a widget’s #GtkWidget::realize implementation. The %window passed is usually either new window created with gdk_window_new(), or the window of its parent widget as returned by gtk_widget_get_parent_window(). Widgets must indicate whether they will create their own #GdkWindow by calling gtk_widget_set_has_window(). This is usually done in the widget’s init() function. Note that this function does not add any reference to @window. a #GtkWidget a #GdkWindow Sets a shape for this widget’s GDK window. This allows for transparent windows etc., see gdk_window_shape_combine_region() for more information. a #GtkWidget shape to be added, or %NULL to remove an existing shape Flags a widget to be displayed. Any widget that isn’t shown will not appear on the screen. If you want to show all the widgets in a container, it’s easier to call gtk_widget_show_all() on the container, instead of individually showing the widgets. Remember that you have to show the containers containing a widget, in addition to the widget itself, before it will appear onscreen. When a toplevel container is shown, it is immediately realized and mapped; other shown widgets are realized and mapped when their toplevel container is realized and mapped. a #GtkWidget Recursively shows a widget, and any child widgets (if the widget is a container). a #GtkWidget Shows a widget. If the widget is an unmapped toplevel widget (i.e. a #GtkWindow that has not yet been shown), enter the main loop and wait for the window to actually be mapped. Be careful; because the main loop is running, anything can happen during this function. a #GtkWidget This function is only used by #GtkContainer subclasses, to assign a size and position to their child widgets. In this function, the allocation may be adjusted. It will be forced to a 1x1 minimum size, and the adjust_size_allocation virtual method on the child will be used to adjust the allocation. Standard adjustments include removing the widget’s margins, and applying the widget’s #GtkWidget:halign and #GtkWidget:valign properties. For baseline support in containers you need to use gtk_widget_size_allocate_with_baseline() instead. a #GtkWidget position and size to be allocated to @widget This function is only used by #GtkContainer subclasses, to assign a size, position and (optionally) baseline to their child widgets. In this function, the allocation and baseline may be adjusted. It will be forced to a 1x1 minimum size, and the adjust_size_allocation virtual and adjust_baseline_allocation methods on the child will be used to adjust the allocation and baseline. Standard adjustments include removing the widget's margins, and applying the widget’s #GtkWidget:halign and #GtkWidget:valign properties. If the child widget does not have a valign of %GTK_ALIGN_BASELINE the baseline argument is ignored and -1 is used instead. a #GtkWidget position and size to be allocated to @widget The baseline of the child, or -1 This function is typically used when implementing a #GtkContainer subclass. Obtains the preferred size of a widget. The container uses this information to arrange its child widgets and decide what size allocations to give them with gtk_widget_size_allocate(). You can also call this function from an application, with some caveats. Most notably, getting a size request requires the widget to be associated with a screen, because font information may be needed. Multihead-aware applications should keep this in mind. Also remember that the size request is not necessarily the size a widget will actually be allocated. Use gtk_widget_get_preferred_size() instead. a #GtkWidget a #GtkRequisition to be filled in This function attaches the widget’s #GtkStyle to the widget's #GdkWindow. It is a replacement for |[ widget->style = gtk_style_attach (widget->style, widget->window); ]| and should only ever be called in a derived widget’s “realize” implementation which does not chain up to its parent class' “realize” implementation, because one of the parent classes (finally #GtkWidget) would attach the style itself. This step is unnecessary with #GtkStyleContext. a #GtkWidget Gets the values of a multiple style properties of @widget. a #GtkWidget the name of the first property to get pairs of property names and locations to return the property values, starting with the location for @first_property_name, terminated by %NULL. Gets the value of a style property of @widget. a #GtkWidget the name of a style property location to return the property value Non-vararg variant of gtk_widget_style_get(). Used primarily by language bindings. a #GtkWidget the name of the first property to get a va_list of pairs of property names and locations to return the property values, starting with the location for @first_property_name. Reverts the effect of a previous call to gtk_widget_freeze_child_notify(). This causes all queued #GtkWidget::child-notify signals on @widget to be emitted. a #GtkWidget Translate coordinates relative to @src_widget’s allocation to coordinates relative to @dest_widget’s allocations. In order to perform this operation, both widgets must be realized, and must share a common toplevel. %FALSE if either widget was not realized, or there was no common ancestor. In this case, nothing is stored in *@dest_x and *@dest_y. Otherwise %TRUE. a #GtkWidget a #GtkWidget X position relative to @src_widget Y position relative to @src_widget location to store X position relative to @dest_widget location to store Y position relative to @dest_widget Triggers a tooltip query on the display where the toplevel of @widget is located. See gtk_tooltip_trigger_tooltip_query() for more information. a #GtkWidget This function is only for use in widget implementations. Causes a widget to be unmapped if it’s currently mapped. a #GtkWidget This function is only for use in widget implementations. Should be called by implementations of the remove method on #GtkContainer, to dissociate a child from the container. a #GtkWidget This function is only useful in widget implementations. Causes a widget to be unrealized (frees all GDK resources associated with the widget, such as @widget->window). a #GtkWidget Unregisters a #GdkWindow from the widget that was previously set up with gtk_widget_register_window(). You need to call this when the window is no longer used by the widget, such as when you destroy it. a #GtkWidget a #GdkWindow This function is for use in widget implementations. Turns off flag values for the current widget state (insensitive, prelighted, etc.). See gtk_widget_set_state_flags(). a #GtkWidget State flags to turn off Whether the widget is double buffered. Widgets should not use this property. Whether to expand in both directions. Setting this sets both #GtkWidget:hexpand and #GtkWidget:vexpand Whether the widget should grab focus when it is clicked with the mouse. This property is only relevant for widgets that can take focus. Before 3.20, several widgets (GtkButton, GtkFileChooserButton, GtkComboBox) implemented this property individually. How to distribute horizontal space if widget gets extra space, see #GtkAlign Enables or disables the emission of #GtkWidget::query-tooltip on @widget. A value of %TRUE indicates that @widget can have a tooltip, in this case the widget will be queried using #GtkWidget::query-tooltip to determine whether it will provide a tooltip or not. Note that setting this property to %TRUE for the first time will change the event masks of the GdkWindows of this widget to include leave-notify and motion-notify events. This cannot and will not be undone when the property is set to %FALSE again. Whether to expand horizontally. See gtk_widget_set_hexpand(). Whether to use the #GtkWidget:hexpand property. See gtk_widget_get_hexpand_set(). Sets all four sides' margin at once. If read, returns max margin on any side. Margin on bottom side of widget. This property adds margin outside of the widget's normal size request, the margin will be added in addition to the size from gtk_widget_set_size_request() for example. Margin on end of widget, horizontally. This property supports left-to-right and right-to-left text directions. This property adds margin outside of the widget's normal size request, the margin will be added in addition to the size from gtk_widget_set_size_request() for example. Margin on left side of widget. This property adds margin outside of the widget's normal size request, the margin will be added in addition to the size from gtk_widget_set_size_request() for example. Use #GtkWidget:margin-start instead. Margin on right side of widget. This property adds margin outside of the widget's normal size request, the margin will be added in addition to the size from gtk_widget_set_size_request() for example. Use #GtkWidget:margin-end instead. Margin on start of widget, horizontally. This property supports left-to-right and right-to-left text directions. This property adds margin outside of the widget's normal size request, the margin will be added in addition to the size from gtk_widget_set_size_request() for example. Margin on top side of widget. This property adds margin outside of the widget's normal size request, the margin will be added in addition to the size from gtk_widget_set_size_request() for example. The requested opacity of the widget. See gtk_widget_set_opacity() for more details about window opacity. Before 3.8 this was only available in GtkWindow The scale factor of the widget. See gtk_widget_get_scale_factor() for more details about widget scaling. The style of the widget, which contains information about how it will look (colors, etc). Use #GtkStyleContext instead Sets the text of tooltip to be the given string, which is marked up with the [Pango text markup language][PangoMarkupFormat]. Also see gtk_tooltip_set_markup(). This is a convenience property which will take care of getting the tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip will automatically be set to %TRUE and there will be taken care of #GtkWidget::query-tooltip in the default signal handler. Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup are set, the last one wins. Sets the text of tooltip to be the given string. Also see gtk_tooltip_set_text(). This is a convenience property which will take care of getting the tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip will automatically be set to %TRUE and there will be taken care of #GtkWidget::query-tooltip in the default signal handler. Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup are set, the last one wins. How to distribute vertical space if widget gets extra space, see #GtkAlign Whether to expand vertically. See gtk_widget_set_vexpand(). Whether to use the #GtkWidget:vexpand property. See gtk_widget_get_vexpand_set(). The widget's window if it is realized, %NULL otherwise. The ::button-press-event signal will be emitted when a button (typically from a mouse) is pressed. To receive this signal, the #GdkWindow associated to the widget needs to enable the #GDK_BUTTON_PRESS_MASK mask. This signal will be sent to the grab widget if there is one. %TRUE to stop other handlers from being invoked for the event. %FALSE to propagate the event further. the #GdkEventButton which triggered this signal. The ::button-release-event signal will be emitted when a button (typically from a mouse) is released. To receive this signal, the #GdkWindow associated to the widget needs to enable the #GDK_BUTTON_RELEASE_MASK mask. This signal will be sent to the grab widget if there is one. %TRUE to stop other handlers from being invoked for the event. %FALSE to propagate the event further. the #GdkEventButton which triggered this signal. Determines whether an accelerator that activates the signal identified by @signal_id can currently be activated. This signal is present to allow applications and derived widgets to override the default #GtkWidget handling for determining whether an accelerator can be activated. %TRUE if the signal can be activated. the ID of a signal installed on @widget The ::child-notify signal is emitted for each [child property][child-properties] that has changed on an object. The signal's detail holds the property name. the #GParamSpec of the changed child property The ::composited-changed signal is emitted when the composited status of @widgets screen changes. See gdk_screen_is_composited(). Use GdkScreen::composited-changed instead. The ::configure-event signal will be emitted when the size, position or stacking of the @widget's window has changed. To receive this signal, the #GdkWindow associated to the widget needs to enable the #GDK_STRUCTURE_MASK mask. GDK will enable this mask automatically for all new windows. %TRUE to stop other handlers from being invoked for the event. %FALSE to propagate the event further. the #GdkEventConfigure which triggered this signal. Emitted when a redirected window belonging to @widget gets drawn into. The region/area members of the event shows what area of the redirected drawable was drawn into. %TRUE to stop other handlers from being invoked for the event. %FALSE to propagate the event further. the #GdkEventExpose event The ::delete-event signal is emitted if a user requests that a toplevel window is closed. The default handler for this signal destroys the window. Connecting gtk_widget_hide_on_delete() to this signal will cause the window to be hidden instead, so that it can later be shown again without reconstructing it. %TRUE to stop other handlers from being invoked for the event. %FALSE to propagate the event further. the event which triggered this signal Signals that all holders of a reference to the widget should release the reference that they hold. May result in finalization of the widget if all references are released. This signal is not suitable for saving widget state. The ::destroy-event signal is emitted when a #GdkWindow is destroyed. You rarely get this signal, because most widgets disconnect themselves from their window before they destroy it, so no widget owns the window at destroy time. To receive this signal, the #GdkWindow associated to the widget needs to enable the #GDK_STRUCTURE_MASK mask. GDK will enable this mask automatically for all new windows. %TRUE to stop other handlers from being invoked for the event. %FALSE to propagate the event further. the event which triggered this signal The ::direction-changed signal is emitted when the text direction of a widget changes. the previous text direction of @widget The ::drag-begin signal is emitted on the drag source when a drag is started. A typical reason to connect to this signal is to set up a custom drag icon with e.g. gtk_drag_source_set_icon_pixbuf(). Note that some widgets set up a drag icon in the default handler of this signal, so you may have to use g_signal_connect_after() to override what the default handler did. the drag context The ::drag-data-delete signal is emitted on the drag source when a drag with the action %GDK_ACTION_MOVE is successfully completed. The signal handler is responsible for deleting the data that has been dropped. What "delete" means depends on the context of the drag operation. the drag context The ::drag-data-get signal is emitted on the drag source when the drop site requests the data which is dragged. It is the responsibility of the signal handler to fill @data with the data in the format which is indicated by @info. See gtk_selection_data_set() and gtk_selection_data_set_text(). the drag context the #GtkSelectionData to be filled with the dragged data the info that has been registered with the target in the #GtkTargetList the timestamp at which the data was requested The ::drag-data-received signal is emitted on the drop site when the dragged data has been received. If the data was received in order to determine whether the drop will be accepted, the handler is expected to call gdk_drag_status() and not finish the drag. If the data was received in response to a #GtkWidget::drag-drop signal (and this is the last target to be received), the handler for this signal is expected to process the received data and then call gtk_drag_finish(), setting the @success parameter depending on whether the data was processed successfully. Applications must create some means to determine why the signal was emitted and therefore whether to call gdk_drag_status() or gtk_drag_finish(). The handler may inspect the selected action with gdk_drag_context_get_selected_action() before calling gtk_drag_finish(), e.g. to implement %GDK_ACTION_ASK as shown in the following example: |[<!-- language="C" --> void drag_data_received (GtkWidget *widget, GdkDragContext *context, gint x, gint y, GtkSelectionData *data, guint info, guint time) { if ((data->length >= 0) && (data->format == 8)) { GdkDragAction action; // handle data here action = gdk_drag_context_get_selected_action (context); if (action == GDK_ACTION_ASK) { GtkWidget *dialog; gint response; dialog = gtk_message_dialog_new (NULL, GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_INFO, GTK_BUTTONS_YES_NO, "Move the data ?\n"); response = gtk_dialog_run (GTK_DIALOG (dialog)); gtk_widget_destroy (dialog); if (response == GTK_RESPONSE_YES) action = GDK_ACTION_MOVE; else action = GDK_ACTION_COPY; } gtk_drag_finish (context, TRUE, action == GDK_ACTION_MOVE, time); } else gtk_drag_finish (context, FALSE, FALSE, time); } ]| the drag context where the drop happened where the drop happened the received data the info that has been registered with the target in the #GtkTargetList the timestamp at which the data was received The ::drag-drop signal is emitted on the drop site when the user drops the data onto the widget. The signal handler must determine whether the cursor position is in a drop zone or not. If it is not in a drop zone, it returns %FALSE and no further processing is necessary. Otherwise, the handler returns %TRUE. In this case, the handler must ensure that gtk_drag_finish() is called to let the source know that the drop is done. The call to gtk_drag_finish() can be done either directly or in a #GtkWidget::drag-data-received handler which gets triggered by calling gtk_drag_get_data() to receive the data for one or more of the supported targets. whether the cursor position is in a drop zone the drag context the x coordinate of the current cursor position the y coordinate of the current cursor position the timestamp of the motion event The ::drag-end signal is emitted on the drag source when a drag is finished. A typical reason to connect to this signal is to undo things done in #GtkWidget::drag-begin. the drag context The ::drag-failed signal is emitted on the drag source when a drag has failed. The signal handler may hook custom code to handle a failed DnD operation based on the type of error, it returns %TRUE is the failure has been already handled (not showing the default "drag operation failed" animation), otherwise it returns %FALSE. %TRUE if the failed drag operation has been already handled. the drag context the result of the drag operation The ::drag-leave signal is emitted on the drop site when the cursor leaves the widget. A typical reason to connect to this signal is to undo things done in #GtkWidget::drag-motion, e.g. undo highlighting with gtk_drag_unhighlight(). Likewise, the #GtkWidget::drag-leave signal is also emitted before the ::drag-drop signal, for instance to allow cleaning up of a preview item created in the #GtkWidget::drag-motion signal handler. the drag context the timestamp of the motion event The ::drag-motion signal is emitted on the drop site when the user moves the cursor over the widget during a drag. The signal handler must determine whether the cursor position is in a drop zone or not. If it is not in a drop zone, it returns %FALSE and no further processing is necessary. Otherwise, the handler returns %TRUE. In this case, the handler is responsible for providing the necessary information for displaying feedback to the user, by calling gdk_drag_status(). If the decision whether the drop will be accepted or rejected can't be made based solely on the cursor position and the type of the data, the handler may inspect the dragged data by calling gtk_drag_get_data() and defer the gdk_drag_status() call to the #GtkWidget::drag-data-received handler. Note that you must pass #GTK_DEST_DEFAULT_DROP, #GTK_DEST_DEFAULT_MOTION or #GTK_DEST_DEFAULT_ALL to gtk_drag_dest_set() when using the drag-motion signal that way. Also note that there is no drag-enter signal. The drag receiver has to keep track of whether he has received any drag-motion signals since the last #GtkWidget::drag-leave and if not, treat the drag-motion signal as an "enter" signal. Upon an "enter", the handler will typically highlight the drop site with gtk_drag_highlight(). |[<!-- language="C" --> static void drag_motion (GtkWidget *widget, GdkDragContext *context, gint x, gint y, guint time) { GdkAtom target; PrivateData *private_data = GET_PRIVATE_DATA (widget); if (!private_data->drag_highlight) { private_data->drag_highlight = 1; gtk_drag_highlight (widget); } target = gtk_drag_dest_find_target (widget, context, NULL); if (target == GDK_NONE) gdk_drag_status (context, 0, time); else { private_data->pending_status = gdk_drag_context_get_suggested_action (context); gtk_drag_get_data (widget, context, target, time); } return TRUE; } static void drag_data_received (GtkWidget *widget, GdkDragContext *context, gint x, gint y, GtkSelectionData *selection_data, guint info, guint time) { PrivateData *private_data = GET_PRIVATE_DATA (widget); if (private_data->suggested_action) { private_data->suggested_action = 0; // We are getting this data due to a request in drag_motion, // rather than due to a request in drag_drop, so we are just // supposed to call gdk_drag_status(), not actually paste in // the data. str = gtk_selection_data_get_text (selection_data); if (!data_is_acceptable (str)) gdk_drag_status (context, 0, time); else gdk_drag_status (context, private_data->suggested_action, time); } else { // accept the drop } } ]| whether the cursor position is in a drop zone the drag context the x coordinate of the current cursor position the y coordinate of the current cursor position the timestamp of the motion event This signal is emitted when a widget is supposed to render itself. The @widget's top left corner must be painted at the origin of the passed in context and be sized to the values returned by gtk_widget_get_allocated_width() and gtk_widget_get_allocated_height(). Signal handlers connected to this signal can modify the cairo context passed as @cr in any way they like and don't need to restore it. The signal emission takes care of calling cairo_save() before and cairo_restore() after invoking the handler. The signal handler will get a @cr with a clip region already set to the widget's dirty region, i.e. to the area that needs repainting. Complicated widgets that want to avoid redrawing themselves completely can get the full extents of the clip region with gdk_cairo_get_clip_rectangle(), or they can get a finer-grained representation of the dirty region with cairo_copy_clip_rectangle_list(). %TRUE to stop other handlers from being invoked for the event. %FALSE to propagate the event further. the cairo context to draw to The ::enter-notify-event will be emitted when the pointer enters the @widget's window. To receive this signal, the #GdkWindow associated to the widget needs to enable the #GDK_ENTER_NOTIFY_MASK mask. This signal will be sent to the grab widget if there is one. %TRUE to stop other handlers from being invoked for the event. %FALSE to propagate the event further. the #GdkEventCrossing which triggered this signal. The GTK+ main loop will emit three signals for each GDK event delivered to a widget: one generic ::event signal, another, more specific, signal that matches the type of event delivered (e.g. #GtkWidget::key-press-event) and finally a generic #GtkWidget::event-after signal. %TRUE to stop other handlers from being invoked for the event and to cancel the emission of the second specific ::event signal. %FALSE to propagate the event further and to allow the emission of the second signal. The ::event-after signal is emitted regardless of the return value. the #GdkEvent which triggered this signal After the emission of the #GtkWidget::event signal and (optionally) the second more specific signal, ::event-after will be emitted regardless of the previous two signals handlers return values. the #GdkEvent which triggered this signal %TRUE to stop other handlers from being invoked for the event. %FALSE to propagate the event further. The ::focus-in-event signal will be emitted when the keyboard focus enters the @widget's window. To receive this signal, the #GdkWindow associated to the widget needs to enable the #GDK_FOCUS_CHANGE_MASK mask. %TRUE to stop other handlers from being invoked for the event. %FALSE to propagate the event further. the #GdkEventFocus which triggered this signal. The ::focus-out-event signal will be emitted when the keyboard focus leaves the @widget's window. To receive this signal, the #GdkWindow associated to the widget needs to enable the #GDK_FOCUS_CHANGE_MASK mask. %TRUE to stop other handlers from being invoked for the event. %FALSE to propagate the event further. the #GdkEventFocus which triggered this signal. Emitted when a pointer or keyboard grab on a window belonging to @widget gets broken. On X11, this happens when the grab window becomes unviewable (i.e. it or one of its ancestors is unmapped), or if the same application grabs the pointer or keyboard again. %TRUE to stop other handlers from being invoked for the event. %FALSE to propagate the event further. the #GdkEventGrabBroken event The ::grab-notify signal is emitted when a widget becomes shadowed by a GTK+ grab (not a pointer or keyboard grab) on another widget, or when it becomes unshadowed due to a grab being removed. A widget is shadowed by a gtk_grab_add() when the topmost grab widget in the grab stack of its window group is not its ancestor. %FALSE if the widget becomes shadowed, %TRUE if it becomes unshadowed The ::hide signal is emitted when @widget is hidden, for example with gtk_widget_hide(). The ::hierarchy-changed signal is emitted when the anchored state of a widget changes. A widget is “anchored” when its toplevel ancestor is a #GtkWindow. This signal is emitted when a widget changes from un-anchored to anchored or vice-versa. the previous toplevel ancestor, or %NULL if the widget was previously unanchored The ::key-press-event signal is emitted when a key is pressed. The signal emission will reoccur at the key-repeat rate when the key is kept pressed. To receive this signal, the #GdkWindow associated to the widget needs to enable the #GDK_KEY_PRESS_MASK mask. This signal will be sent to the grab widget if there is one. %TRUE to stop other handlers from being invoked for the event. %FALSE to propagate the event further. the #GdkEventKey which triggered this signal. The ::key-release-event signal is emitted when a key is released. To receive this signal, the #GdkWindow associated to the widget needs to enable the #GDK_KEY_RELEASE_MASK mask. This signal will be sent to the grab widget if there is one. %TRUE to stop other handlers from being invoked for the event. %FALSE to propagate the event further. the #GdkEventKey which triggered this signal. Gets emitted if keyboard navigation fails. See gtk_widget_keynav_failed() for details. %TRUE if stopping keyboard navigation is fine, %FALSE if the emitting widget should try to handle the keyboard navigation attempt in its parent container(s). the direction of movement The ::leave-notify-event will be emitted when the pointer leaves the @widget's window. To receive this signal, the #GdkWindow associated to the widget needs to enable the #GDK_LEAVE_NOTIFY_MASK mask. This signal will be sent to the grab widget if there is one. %TRUE to stop other handlers from being invoked for the event. %FALSE to propagate the event further. the #GdkEventCrossing which triggered this signal. The ::map signal is emitted when @widget is going to be mapped, that is when the widget is visible (which is controlled with gtk_widget_set_visible()) and all its parents up to the toplevel widget are also visible. Once the map has occurred, #GtkWidget::map-event will be emitted. The ::map signal can be used to determine whether a widget will be drawn, for instance it can resume an animation that was stopped during the emission of #GtkWidget::unmap. The ::map-event signal will be emitted when the @widget's window is mapped. A window is mapped when it becomes visible on the screen. To receive this signal, the #GdkWindow associated to the widget needs to enable the #GDK_STRUCTURE_MASK mask. GDK will enable this mask automatically for all new windows. %TRUE to stop other handlers from being invoked for the event. %FALSE to propagate the event further. the #GdkEventAny which triggered this signal. The default handler for this signal activates @widget if @group_cycling is %FALSE, or just makes @widget grab focus if @group_cycling is %TRUE. %TRUE to stop other handlers from being invoked for the event. %FALSE to propagate the event further. %TRUE if there are other widgets with the same mnemonic The ::motion-notify-event signal is emitted when the pointer moves over the widget's #GdkWindow. To receive this signal, the #GdkWindow associated to the widget needs to enable the #GDK_POINTER_MOTION_MASK mask. This signal will be sent to the grab widget if there is one. %TRUE to stop other handlers from being invoked for the event. %FALSE to propagate the event further. the #GdkEventMotion which triggered this signal. The ::parent-set signal is emitted when a new parent has been set on a widget. the previous parent, or %NULL if the widget just got its initial parent. This signal gets emitted whenever a widget should pop up a context menu. This usually happens through the standard key binding mechanism; by pressing a certain key while a widget is focused, the user can cause the widget to pop up a menu. For example, the #GtkEntry widget creates a menu with clipboard commands. See the [Popup Menu Migration Checklist][checklist-popup-menu] for an example of how to use this signal. %TRUE if a menu was activated The ::property-notify-event signal will be emitted when a property on the @widget's window has been changed or deleted. To receive this signal, the #GdkWindow associated to the widget needs to enable the #GDK_PROPERTY_CHANGE_MASK mask. %TRUE to stop other handlers from being invoked for the event. %FALSE to propagate the event further. the #GdkEventProperty which triggered this signal. To receive this signal the #GdkWindow associated to the widget needs to enable the #GDK_PROXIMITY_IN_MASK mask. This signal will be sent to the grab widget if there is one. %TRUE to stop other handlers from being invoked for the event. %FALSE to propagate the event further. the #GdkEventProximity which triggered this signal. To receive this signal the #GdkWindow associated to the widget needs to enable the #GDK_PROXIMITY_OUT_MASK mask. This signal will be sent to the grab widget if there is one. %TRUE to stop other handlers from being invoked for the event. %FALSE to propagate the event further. the #GdkEventProximity which triggered this signal. Emitted when #GtkWidget:has-tooltip is %TRUE and the hover timeout has expired with the cursor hovering "above" @widget; or emitted when @widget got focus in keyboard mode. Using the given coordinates, the signal handler should determine whether a tooltip should be shown for @widget. If this is the case %TRUE should be returned, %FALSE otherwise. Note that if @keyboard_mode is %TRUE, the values of @x and @y are undefined and should not be used. The signal handler is free to manipulate @tooltip with the therefore destined function calls. %TRUE if @tooltip should be shown right now, %FALSE otherwise. the x coordinate of the cursor position where the request has been emitted, relative to @widget's left side the y coordinate of the cursor position where the request has been emitted, relative to @widget's top %TRUE if the tooltip was triggered using the keyboard a #GtkTooltip The ::realize signal is emitted when @widget is associated with a #GdkWindow, which means that gtk_widget_realize() has been called or the widget has been mapped (that is, it is going to be drawn). The ::screen-changed signal gets emitted when the screen of a widget has changed. the previous screen, or %NULL if the widget was not associated with a screen before The ::scroll-event signal is emitted when a button in the 4 to 7 range is pressed. Wheel mice are usually configured to generate button press events for buttons 4 and 5 when the wheel is turned. To receive this signal, the #GdkWindow associated to the widget needs to enable the #GDK_SCROLL_MASK mask. This signal will be sent to the grab widget if there is one. %TRUE to stop other handlers from being invoked for the event. %FALSE to propagate the event further. the #GdkEventScroll which triggered this signal. The ::selection-clear-event signal will be emitted when the the @widget's window has lost ownership of a selection. %TRUE to stop other handlers from being invoked for the event. %FALSE to propagate the event further. the #GdkEventSelection which triggered this signal. %TRUE to stop other handlers from being invoked for the event. %FALSE to propagate the event further. The ::selection-request-event signal will be emitted when another client requests ownership of the selection owned by the @widget's window. %TRUE to stop other handlers from being invoked for the event. %FALSE to propagate the event further. the #GdkEventSelection which triggered this signal. The ::show signal is emitted when @widget is shown, for example with gtk_widget_show(). %TRUE to stop other handlers from being invoked for the event. %FALSE to propagate the event further. the region which has been allocated to the widget. The ::state-changed signal is emitted when the widget state changes. See gtk_widget_get_state(). Use #GtkWidget::state-flags-changed instead. the previous state The ::state-flags-changed signal is emitted when the widget state changes, see gtk_widget_get_state_flags(). The previous state flags. The ::style-set signal is emitted when a new style has been set on a widget. Note that style-modifying functions like gtk_widget_modify_base() also cause this signal to be emitted. Note that this signal is emitted for changes to the deprecated #GtkStyle. To track changes to the #GtkStyleContext associated with a widget, use the #GtkWidget::style-updated signal. Use the #GtkWidget::style-updated signal the previous style, or %NULL if the widget just got its initial style The ::style-updated signal is a convenience signal that is emitted when the #GtkStyleContext::changed signal is emitted on the @widget's associated #GtkStyleContext as returned by gtk_widget_get_style_context(). Note that style-modifying functions like gtk_widget_override_color() also cause this signal to be emitted. The ::unmap signal is emitted when @widget is going to be unmapped, which means that either it or any of its parents up to the toplevel widget have been set as hidden. As ::unmap indicates that a widget will not be shown any longer, it can be used to, for example, stop an animation on the widget. The ::unmap-event signal will be emitted when the @widget's window is unmapped. A window is unmapped when it becomes invisible on the screen. To receive this signal, the #GdkWindow associated to the widget needs to enable the #GDK_STRUCTURE_MASK mask. GDK will enable this mask automatically for all new windows. %TRUE to stop other handlers from being invoked for the event. %FALSE to propagate the event further. the #GdkEventAny which triggered this signal The ::unrealize signal is emitted when the #GdkWindow associated with @widget is destroyed, which means that gtk_widget_unrealize() has been called or the widget has been unmapped (that is, it is going to be hidden). The ::visibility-notify-event will be emitted when the @widget's window is obscured or unobscured. To receive this signal the #GdkWindow associated to the widget needs to enable the #GDK_VISIBILITY_NOTIFY_MASK mask. Modern composited windowing systems with pervasive transparency make it impossible to track the visibility of a window reliably, so this signal can not be guaranteed to provide useful information. %TRUE to stop other handlers from being invoked for the event. %FALSE to propagate the event further. the #GdkEventVisibility which triggered this signal. The ::window-state-event will be emitted when the state of the toplevel window associated to the @widget changes. To receive this signal the #GdkWindow associated to the widget needs to enable the #GDK_STRUCTURE_MASK mask. GDK will enable this mask automatically for all new windows. %TRUE to stop other handlers from being invoked for the event. %FALSE to propagate the event further. the #GdkEventWindowState which triggered this signal. The object class structure needs to be the first element in the widget class structure in order for the class mechanism to work correctly. This allows a GtkWidgetClass pointer to be cast to a GObjectClass pointer. The signal to emit when a widget of this class is activated, gtk_widget_activate() handles the emission. Implementation of this signal is optional. a #GtkWidget a #GtkWidget a #GtkWidget a #GtkWidget a #GtkWidget a #GtkWidget a #GtkWidget a #GtkWidget a #GtkWidget position and size to be allocated to @widget a #GtkWidget the name of a child property installed on the class of @widget’s parent The #GtkSizeRequestMode preferred by @widget. a #GtkWidget instance a #GtkWidget instance location to store the minimum height, or %NULL location to store the natural height, or %NULL a #GtkWidget instance the height which is available for allocation location for storing the minimum width, or %NULL location for storing the natural width, or %NULL a #GtkWidget instance location to store the minimum width, or %NULL location to store the natural width, or %NULL a #GtkWidget instance the width which is available for allocation location for storing the minimum height, or %NULL location for storing the natural height, or %NULL %TRUE if the signal has been handled a #GtkWidget %TRUE if there are other widgets with the same mnemonic a #GtkWidget %TRUE if stopping keyboard navigation is fine, %FALSE if the emitting widget should try to handle the keyboard navigation attempt in its parent container(s). a #GtkWidget direction of focus movement return from the event signal emission (%TRUE if the event was handled) a #GtkWidget a #GdkEvent the #AtkObject associated with @widget a #GtkWidget %TRUE if the accelerator can be activated. a #GtkWidget the ID of a signal installed on @widget a #GtkWidget instance the width which is available for allocation, or -1 if none location for storing the minimum height, or %NULL location for storing the natural height, or %NULL location for storing the baseline for the minimum height, or %NULL location for storing the baseline for the natural height, or %NULL a #GtkWidget region to draw Declares a @callback_symbol to handle @callback_name from the template XML defined for @widget_type. See gtk_builder_add_callback_symbol(). Note that this must be called from a composite widget classes class initializer after calling gtk_widget_class_set_template(). A #GtkWidgetClass The name of the callback as expected in the template XML The callback symbol Automatically assign an object declared in the class template XML to be set to a location on a freshly built instance’s private data, or alternatively accessible via gtk_widget_get_template_child(). The struct can point either into the public instance, then you should use G_STRUCT_OFFSET(WidgetType, member) for @struct_offset, or in the private struct, then you should use G_PRIVATE_OFFSET(WidgetType, member). An explicit strong reference will be held automatically for the duration of your instance’s life cycle, it will be released automatically when #GObjectClass.dispose() runs on your instance and if a @struct_offset that is != 0 is specified, then the automatic location in your instance public or private data will be set to %NULL. You can however access an automated child pointer the first time your classes #GObjectClass.dispose() runs, or alternatively in #GtkWidgetClass.destroy(). If @internal_child is specified, #GtkBuildableIface.get_internal_child() will be automatically implemented by the #GtkWidget class so there is no need to implement it manually. The wrapper macros gtk_widget_class_bind_template_child(), gtk_widget_class_bind_template_child_internal(), gtk_widget_class_bind_template_child_private() and gtk_widget_class_bind_template_child_internal_private() might be more convenient to use. Note that this must be called from a composite widget classes class initializer after calling gtk_widget_class_set_template(). A #GtkWidgetClass The “id” of the child defined in the template XML Whether the child should be accessible as an “internal-child” when this class is used in GtkBuilder XML The structure offset into the composite widget’s instance public or private structure where the automated child pointer should be set, or 0 to not assign the pointer. Finds a style property of a widget class by name. the #GParamSpec of the style property or %NULL if @class has no style property with that name. a #GtkWidgetClass the name of the style property to find Gets the name used by this class for matching in CSS code. See gtk_widget_class_set_css_name() for details. the CSS name of the given class class to set the name on Installs a style property on a widget class. The parser for the style property is determined by the value type of @pspec. a #GtkWidgetClass the #GParamSpec for the property Installs a style property on a widget class. a #GtkWidgetClass the #GParamSpec for the style property the parser for the style property Returns all style properties of a widget class. a newly allocated array of #GParamSpec*. The array must be freed with g_free(). a #GtkWidgetClass location to return the number of style properties found Sets the default #AtkRole to be set on accessibles created for widgets of @widget_class. Accessibles may decide to not honor this setting if their role reporting is more refined. Calls to gtk_widget_class_set_accessible_type() will reset this value. In cases where you want more fine-grained control over the role of accessibles created for @widget_class, you should provide your own accessible type and use gtk_widget_class_set_accessible_type() instead. If @role is #ATK_ROLE_INVALID, the default role will not be changed and the accessible’s default role will be used instead. This function should only be called from class init functions of widgets. class to set the accessible role for The role to use for accessibles created for @widget_class Sets the type to be used for creating accessibles for widgets of @widget_class. The given @type must be a subtype of the type used for accessibles of the parent class. This function should only be called from class init functions of widgets. class to set the accessible type for The object type that implements the accessible for @widget_class For use in language bindings, this will override the default #GtkBuilderConnectFunc to be used when parsing GtkBuilder XML from this class’s template data. Note that this must be called from a composite widget classes class initializer after calling gtk_widget_class_set_template(). A #GtkWidgetClass The #GtkBuilderConnectFunc to use when connecting signals in the class template The data to pass to @connect_func The #GDestroyNotify to free @connect_data, this will only be used at class finalization time, when no classes of type @widget_type are in use anymore. Sets the name to be used for CSS matching of widgets. If this function is not called for a given class, the name of the parent class is used. class to set the name on name to use This should be called at class initialization time to specify the GtkBuilder XML to be used to extend a widget. For convenience, gtk_widget_class_set_template_from_resource() is also provided. Note that any class that installs templates must call gtk_widget_init_template() in the widget’s instance initializer. A #GtkWidgetClass A #GBytes holding the #GtkBuilder XML A convenience function to call gtk_widget_class_set_template(). Note that any class that installs templates must call gtk_widget_init_template() in the widget’s instance initializer. A #GtkWidgetClass The name of the resource to load the template from Kinds of widget-specific help. Used by the ::show-help signal. Tooltip. What’s this. GtkWidgetPath is a boxed type that represents a widget hierarchy from the topmost widget, typically a toplevel, to any child. This widget path abstraction is used in #GtkStyleContext on behalf of the real widget in order to query style information. If you are using GTK+ widgets, you probably will not need to use this API directly, as there is gtk_widget_get_path(), and the style context returned by gtk_widget_get_style_context() will be automatically updated on widget hierarchy changes. The widget path generation is generally simple: ## Defining a button within a window |[<!-- language="C" --> { GtkWidgetPath *path; path = gtk_widget_path_new (); gtk_widget_path_append_type (path, GTK_TYPE_WINDOW); gtk_widget_path_append_type (path, GTK_TYPE_BUTTON); } ]| Although more complex information, such as widget names, or different classes (property that may be used by other widget types) and intermediate regions may be included: ## Defining the first tab widget in a notebook |[<!-- language="C" --> { GtkWidgetPath *path; guint pos; path = gtk_widget_path_new (); pos = gtk_widget_path_append_type (path, GTK_TYPE_NOTEBOOK); gtk_widget_path_iter_add_region (path, pos, "tab", GTK_REGION_EVEN | GTK_REGION_FIRST); pos = gtk_widget_path_append_type (path, GTK_TYPE_LABEL); gtk_widget_path_iter_set_name (path, pos, "first tab label"); } ]| All this information will be used to match the style information that applies to the described widget. Returns an empty widget path. A newly created, empty, #GtkWidgetPath Appends the data from @widget to the widget hierarchy represented by @path. This function is a shortcut for adding information from @widget to the given @path. This includes setting the name or adding the style classes from @widget. the position where the data was inserted a widget path the widget to append to the widget path Appends a widget type to the widget hierarchy represented by @path. the position where the element was inserted a #GtkWidgetPath widget type to append Appends a widget type with all its siblings to the widget hierarchy represented by @path. Using this function instead of gtk_widget_path_append_type() will allow the CSS theming to use sibling matches in selectors and apply :nth-child() pseudo classes. In turn, it requires a lot more care in widget implementations as widgets need to make sure to call gtk_widget_reset_style() on all involved widgets when the @siblings path changes. the position where the element was inserted. the widget path to append to a widget path describing a list of siblings. This path may not contain any siblings itself and it must not be modified afterwards. index into @siblings for where the added element is positioned. Returns a copy of @path a copy of @path a #GtkWidgetPath Decrements the reference count on @path, freeing the structure if the reference count reaches 0. a #GtkWidgetPath Returns the topmost object type, that is, the object type this path is representing. The object type a #GtkWidget Returns %TRUE if any of the parents of the widget represented in @path is of type @type, or any subtype of it. %TRUE if any parent is of type @type a #GtkWidgetPath widget type to check in parents Returns %TRUE if the widget type represented by this path is @type, or a subtype of it. %TRUE if the widget represented by @path is of type @type a #GtkWidgetPath widget type to match Adds the class @name to the widget at position @pos in the hierarchy defined in @path. See gtk_style_context_add_class(). a #GtkWidget position to modify, -1 for the path head a class name Adds the region @name to the widget at position @pos in the hierarchy defined in @path. See gtk_style_context_add_region(). Region names must only contain lowercase letters and “-”, starting always with a lowercase letter. The use of regions is deprecated. a #GtkWidgetPath position to modify, -1 for the path head region name flags affecting the region Removes all classes from the widget at position @pos in the hierarchy defined in @path. a #GtkWidget position to modify, -1 for the path head Removes all regions from the widget at position @pos in the hierarchy defined in @path. The use of regions is deprecated. a #GtkWidgetPath position to modify, -1 for the path head Returns the name corresponding to the widget found at the position @pos in the widget hierarchy defined by @path The widget name, or %NULL if none was set. a #GtkWidgetPath position to get the widget name for, -1 for the path head Returns the object name that is at position @pos in the widget hierarchy defined in @path. the name or %NULL a #GtkWidgetPath position to get the object name for, -1 for the path head Returns the object #GType that is at position @pos in the widget hierarchy defined in @path. a widget type a #GtkWidgetPath position to get the object type for, -1 for the path head Returns the index into the list of siblings for the element at @pos as returned by gtk_widget_path_iter_get_siblings(). If that function would return %NULL because the element at @pos has no siblings, this function will return 0. 0 or the index into the list of siblings for the element at @pos. a #GtkWidgetPath position to get the sibling index for, -1 for the path head Returns the list of siblings for the element at @pos. If the element was not added with siblings, %NULL is returned. %NULL or the list of siblings for the element at @pos. a #GtkWidgetPath position to get the siblings for, -1 for the path head Returns the state flags corresponding to the widget found at the position @pos in the widget hierarchy defined by @path The state flags a #GtkWidgetPath position to get the state for, -1 for the path head Returns %TRUE if the widget at position @pos has the class @name defined, %FALSE otherwise. %TRUE if the class @name is defined for the widget at @pos a #GtkWidgetPath position to query, -1 for the path head class name Returns %TRUE if the widget at position @pos has the name @name, %FALSE otherwise. %TRUE if the widget at @pos has this name a #GtkWidgetPath position to query, -1 for the path head a widget name See gtk_widget_path_iter_has_class(). This is a version that operates with GQuarks. %TRUE if the widget at @pos has the class defined. a #GtkWidgetPath position to query, -1 for the path head class name as a #GQuark See gtk_widget_path_iter_has_name(). This is a version that operates on #GQuarks. %TRUE if the widget at @pos has this name a #GtkWidgetPath position to query, -1 for the path head widget name as a #GQuark See gtk_widget_path_iter_has_region(). This is a version that operates with GQuarks. The use of regions is deprecated. %TRUE if the widget at @pos has the region defined. a #GtkWidgetPath position to query, -1 for the path head region name as a #GQuark return location for the region flags Returns %TRUE if the widget at position @pos has the class @name defined, %FALSE otherwise. The use of regions is deprecated. %TRUE if the class @name is defined for the widget at @pos a #GtkWidgetPath position to query, -1 for the path head region name return location for the region flags Returns a list with all the class names defined for the widget at position @pos in the hierarchy defined in @path. The list of classes, This is a list of strings, the #GSList contents are owned by GTK+, but you should use g_slist_free() to free the list itself. a #GtkWidgetPath position to query, -1 for the path head Returns a list with all the region names defined for the widget at position @pos in the hierarchy defined in @path. The use of regions is deprecated. The list of regions, This is a list of strings, the #GSList contents are owned by GTK+, but you should use g_slist_free() to free the list itself. a #GtkWidgetPath position to query, -1 for the path head Removes the class @name from the widget at position @pos in the hierarchy defined in @path. a #GtkWidgetPath position to modify, -1 for the path head class name Removes the region @name from the widget at position @pos in the hierarchy defined in @path. The use of regions is deprecated. a #GtkWidgetPath position to modify, -1 for the path head region name Sets the widget name for the widget found at position @pos in the widget hierarchy defined by @path. a #GtkWidgetPath position to modify, -1 for the path head widget name Sets the object name for a given position in the widget hierarchy defined by @path. When set, the object name overrides the object type when matching CSS. a #GtkWidgetPath position to modify, -1 for the path head object name to set or %NULL to unset Sets the object type for a given position in the widget hierarchy defined by @path. a #GtkWidgetPath position to modify, -1 for the path head object type to set Sets the widget name for the widget found at position @pos in the widget hierarchy defined by @path. If you want to update just a single state flag, you need to do this manually, as this function updates all state flags. ## Setting a flag |[<!-- language="C" --> gtk_widget_path_iter_set_state (path, pos, gtk_widget_path_iter_get_state (path, pos) | flag); ]| ## Unsetting a flag |[<!-- language="C" --> gtk_widget_path_iter_set_state (path, pos, gtk_widget_path_iter_get_state (path, pos) & ~flag); ]| a #GtkWidgetPath position to modify, -1 for the path head state flags Returns the number of #GtkWidget #GTypes between the represented widget and its topmost container. the number of elements in the path a #GtkWidgetPath Prepends a widget type to the widget hierachy represented by @path. a #GtkWidgetPath widget type to prepend Increments the reference count on @path. @path itself. a #GtkWidgetPath Dumps the widget path into a string representation. It tries to match the CSS style as closely as possible (Note that there might be paths that cannot be represented in CSS). The main use of this code is for debugging purposes, so that you can g_print() the path or dump it in a gdb session. A new string describing @path. the path Decrements the reference count on @path, freeing the structure if the reference count reaches 0. a #GtkWidgetPath A GtkWindow is a toplevel window which can contain other widgets. Windows normally have decorations that are under the control of the windowing system and allow the user to manipulate the window (resize it, move it, close it,...). # GtkWindow as GtkBuildable The GtkWindow implementation of the #GtkBuildable interface supports a custom <accel-groups> element, which supports any number of <group> elements representing the #GtkAccelGroup objects you want to add to your window (synonymous with gtk_window_add_accel_group(). It also supports the <initial-focus> element, whose name property names the widget to receive the focus when the window is mapped. An example of a UI definition fragment with accel groups: |[ <object class="GtkWindow"> <accel-groups> <group name="accelgroup1"/> </accel-groups> <initial-focus name="thunderclap"/> </object> ... <object class="GtkAccelGroup" id="accelgroup1"/> ]| The GtkWindow implementation of the #GtkBuildable interface supports setting a child as the titlebar by specifying “titlebar” as the “type” attribute of a <child> element. # CSS nodes |[<!-- language="plain" --> window.background ├── decoration ├── <titlebar child>.titlebar [.default-decoration] ╰── <child> ]| GtkWindow has a main CSS node with name window and style class .background, and a subnode with name decoration. Style classes that are typically used with the main CSS node are .csd (when client-side decorations are in use), .solid-csd (for client-side decorations without invisible borders), .ssd (used by mutter when rendering server-side decorations). GtkWindow also represents window states with the following style classes on the main node: .tiled, .maximized, .fullscreen. Specialized types of window often add their own discriminating style classes, such as .popup or .tooltip. GtkWindow adds the .titlebar and .default-decoration style classes to the widget that is added as a titlebar child. Creates a new #GtkWindow, which is a toplevel window that can contain other widgets. Nearly always, the type of the window should be #GTK_WINDOW_TOPLEVEL. If you’re implementing something like a popup menu from scratch (which is a bad idea, just use #GtkMenu), you might use #GTK_WINDOW_POPUP. #GTK_WINDOW_POPUP is not for dialogs, though in some other toolkits dialogs are called “popups”. In GTK+, #GTK_WINDOW_POPUP means a pop-up menu or pop-up tooltip. On X11, popup windows are not controlled by the [window manager][gtk-X11-arch]. If you simply want an undecorated window (no window borders), use gtk_window_set_decorated(), don’t use #GTK_WINDOW_POPUP. All top-level windows created by gtk_window_new() are stored in an internal top-level window list. This list can be obtained from gtk_window_list_toplevels(). Due to Gtk+ keeping a reference to the window internally, gtk_window_new() does not return a reference to the caller. To delete a #GtkWindow, call gtk_widget_destroy(). a new #GtkWindow. type of window Gets the value set by gtk_window_set_default_icon_list(). The list is a copy and should be freed with g_list_free(), but the pixbufs in the list have not had their reference count incremented. copy of default icon list Returns the fallback icon name for windows that has been set with gtk_window_set_default_icon_name(). The returned string is owned by GTK+ and should not be modified. It is only valid until the next call to gtk_window_set_default_icon_name(). the fallback icon name for windows Returns a list of all existing toplevel windows. The widgets in the list are not individually referenced. If you want to iterate through the list and perform actions involving callbacks that might destroy the widgets, you must call `g_list_foreach (result, (GFunc)g_object_ref, NULL)` first, and then unref all the widgets afterwards. list of toplevel widgets By default, after showing the first #GtkWindow, GTK+ calls gdk_notify_startup_complete(). Call this function to disable the automatic startup notification. You might do this if your first window is a splash screen, and you want to delay notification until after your real main window has been shown, for example. In that example, you would disable startup notification temporarily, show your splash screen, then re-enable it so that showing the main window would automatically result in notification. %TRUE to automatically do startup notification Sets an icon to be used as fallback for windows that haven't had gtk_window_set_icon() called on them from a pixbuf. the icon Sets an icon to be used as fallback for windows that haven't had gtk_window_set_icon_list() called on them from a file on disk. Warns on failure if @err is %NULL. %TRUE if setting the icon succeeded. location of icon file Sets an icon list to be used as fallback for windows that haven't had gtk_window_set_icon_list() called on them to set up a window-specific icon list. This function allows you to set up the icon for all windows in your app at once. See gtk_window_set_icon_list() for more details. a list of #GdkPixbuf Sets an icon to be used as fallback for windows that haven't had gtk_window_set_icon_list() called on them from a named themed icon, see gtk_window_set_icon_name(). the name of the themed icon Opens or closes the [interactive debugger][interactive-debugging], which offers access to the widget hierarchy of the application and to useful debugging tools. %TRUE to enable interactive debugging If @focus is not the current focus widget, and is focusable, sets it as the focus widget for the window. If @focus is %NULL, unsets the focus widget for this window. To set the focus to a particular widget in the toplevel, it is usually more convenient to use gtk_widget_grab_focus() instead of this function. a #GtkWindow widget to be the new focus widget, or %NULL to unset any focus widget for the toplevel window. Activates the default widget for the window, unless the current focused widget has been configured to receive the default action (see gtk_widget_set_receives_default()), in which case the focused widget is activated. %TRUE if a widget got activated. a #GtkWindow Activates the current focused widget within the window. %TRUE if a widget got activated. a #GtkWindow Activates mnemonics and accelerators for this #GtkWindow. This is normally called by the default ::key_press_event handler for toplevel windows, however in some cases it may be useful to call this directly when overriding the standard key handling for a toplevel window. %TRUE if a mnemonic or accelerator was found and activated. a #GtkWindow a #GdkEventKey Associate @accel_group with @window, such that calling gtk_accel_groups_activate() on @window will activate accelerators in @accel_group. window to attach accelerator group to a #GtkAccelGroup Adds a mnemonic to this window. a #GtkWindow the mnemonic the widget that gets activated by the mnemonic Starts moving a window. This function is used if an application has window movement grips. When GDK can support it, the window movement will be done using the standard mechanism for the [window manager][gtk-X11-arch] or windowing system. Otherwise, GDK will try to emulate window movement, potentially not all that well, depending on the windowing system. a #GtkWindow mouse button that initiated the drag X position where the user clicked to initiate the drag, in root window coordinates Y position where the user clicked to initiate the drag timestamp from the click event that initiated the drag Starts resizing a window. This function is used if an application has window resizing controls. When GDK can support it, the resize will be done using the standard mechanism for the [window manager][gtk-X11-arch] or windowing system. Otherwise, GDK will try to emulate window resizing, potentially not all that well, depending on the windowing system. a #GtkWindow position of the resize control mouse button that initiated the drag X position where the user clicked to initiate the drag, in root window coordinates Y position where the user clicked to initiate the drag timestamp from the click event that initiated the drag Requests that the window is closed, similar to what happens when a window manager close button is clicked. This function can be used with close buttons in custom titlebars. a #GtkWindow Asks to deiconify (i.e. unminimize) the specified @window. Note that you shouldn’t assume the window is definitely deiconified afterward, because other entities (e.g. the user or [window manager][gtk-X11-arch])) could iconify it again before your code which assumes deiconification gets to run. You can track iconification via the “window-state-event” signal on #GtkWidget. a #GtkWindow Asks to place @window in the fullscreen state. Note that you shouldn’t assume the window is definitely full screen afterward, because other entities (e.g. the user or [window manager][gtk-X11-arch]) could unfullscreen it again, and not all window managers honor requests to fullscreen windows. But normally the window will end up fullscreen. Just don’t write code that crashes if not. You can track the fullscreen state via the “window-state-event” signal on #GtkWidget. a #GtkWindow Asks to place @window in the fullscreen state. Note that you shouldn't assume the window is definitely full screen afterward. You can track the fullscreen state via the "window-state-event" signal on #GtkWidget. a #GtkWindow a #GdkScreen to draw to which monitor to go fullscreen on Gets the value set by gtk_window_set_accept_focus(). %TRUE if window should receive the input focus a #GtkWindow Gets the #GtkApplication associated with the window (if any). a #GtkApplication, or %NULL a #GtkWindow Fetches the attach widget for this window. See gtk_window_set_attached_to(). the widget where the window is attached, or %NULL if the window is not attached to any widget. a #GtkWindow Returns whether the window has been set to have decorations such as a title bar via gtk_window_set_decorated(). %TRUE if the window has been set to have decorations a #GtkWindow Gets the default size of the window. A value of -1 for the width or height indicates that a default size has not been explicitly set for that dimension, so the “natural” size of the window will be used. a #GtkWindow location to store the default width, or %NULL location to store the default height, or %NULL Returns the default widget for @window. See gtk_window_set_default() for more details. the default widget, or %NULL if there is none. a #GtkWindow Returns whether the window has been set to have a close button via gtk_window_set_deletable(). %TRUE if the window has been set to have a close button a #GtkWindow Returns whether the window will be destroyed with its transient parent. See gtk_window_set_destroy_with_parent (). %TRUE if the window will be destroyed with its transient parent. a #GtkWindow Retrieves the current focused widget within the window. Note that this is the widget that would have the focus if the toplevel window focused; if the toplevel window is not focused then `gtk_widget_has_focus (widget)` will not be %TRUE for the widget. the currently focused widget, or %NULL if there is none. a #GtkWindow Gets the value set by gtk_window_set_focus_on_map(). %TRUE if window should receive the input focus when mapped. a #GtkWindow Gets the value of the #GtkWindow:focus-visible property. %TRUE if “focus rectangles” are supposed to be visible in this window. a #GtkWindow Gets the value set by gtk_window_set_gravity(). window gravity a #GtkWindow Returns the group for @window or the default group, if @window is %NULL or if @window does not have an explicit window group. the #GtkWindowGroup for a window or the default group a #GtkWindow, or %NULL Determines whether the window may have a resize grip. Resize grips have been removed. %TRUE if the window has a resize grip a #GtkWindow Returns whether the window has requested to have its titlebar hidden when maximized. See gtk_window_set_hide_titlebar_when_maximized (). %TRUE if the window has requested to have its titlebar hidden when maximized a #GtkWindow Gets the value set by gtk_window_set_icon() (or if you've called gtk_window_set_icon_list(), gets the first icon in the icon list). icon for window or %NULL if none a #GtkWindow Retrieves the list of icons set by gtk_window_set_icon_list(). The list is copied, but the reference count on each member won’t be incremented. copy of window’s icon list a #GtkWindow Returns the name of the themed icon for the window, see gtk_window_set_icon_name(). the icon name or %NULL if the window has no themed icon a #GtkWindow Returns the mnemonic modifier for this window. See gtk_window_set_mnemonic_modifier(). the modifier mask used to activate mnemonics on this window. a #GtkWindow Gets the value of the #GtkWindow:mnemonics-visible property. %TRUE if mnemonics are supposed to be visible in this window. a #GtkWindow Returns whether the window is modal. See gtk_window_set_modal(). %TRUE if the window is set to be modal and establishes a grab when shown a #GtkWindow Fetches the requested opacity for this window. See gtk_window_set_opacity(). Use gtk_widget_get_opacity instead. the requested opacity for this window. a #GtkWindow This function returns the position you need to pass to gtk_window_move() to keep @window in its current position. This means that the meaning of the returned value varies with window gravity. See gtk_window_move() for more details. The reliability of this function depends on the windowing system currently in use. Some windowing systems, such as Wayland, do not support a global coordinate system, and thus the position of the window will always be (0, 0). Others, like X11, do not have a reliable way to obtain the geometry of the decorations of a window if they are provided by the window manager. Additionally, on X11, window manager have been known to mismanage window gravity, which result in windows moving even if you use the coordinates of the current position as returned by this function. If you haven’t changed the window gravity, its gravity will be #GDK_GRAVITY_NORTH_WEST. This means that gtk_window_get_position() gets the position of the top-left corner of the window manager frame for the window. gtk_window_move() sets the position of this same top-left corner. If a window has gravity #GDK_GRAVITY_STATIC the window manager frame is not relevant, and thus gtk_window_get_position() will always produce accurate results. However you can’t use static gravity to do things like place a window in a corner of the screen, because static gravity ignores the window manager decorations. Ideally, this function should return appropriate values if the window has client side decorations, assuming that the windowing system supports global coordinates. In practice, saving the window position should not be left to applications, as they lack enough knowledge of the windowing system and the window manager state to effectively do so. The appropriate way to implement saving the window position is to use a platform-specific protocol, wherever that is available. a #GtkWindow return location for X coordinate of gravity-determined reference point, or %NULL return location for Y coordinate of gravity-determined reference point, or %NULL Gets the value set by gtk_window_set_resizable(). %TRUE if the user can resize the window a #GtkWindow If a window has a resize grip, this will retrieve the grip position, width and height into the specified #GdkRectangle. Resize grips have been removed. %TRUE if the resize grip’s area was retrieved a #GtkWindow a pointer to a #GdkRectangle which we should store the resize grip area Returns the role of the window. See gtk_window_set_role() for further explanation. the role of the window if set, or %NULL. The returned is owned by the widget and must not be modified or freed. a #GtkWindow Returns the #GdkScreen associated with @window. a #GdkScreen. a #GtkWindow. Obtains the current size of @window. If @window is not visible on screen, this function return the size GTK+ will suggest to the [window manager][gtk-X11-arch] for the initial window size (but this is not reliably the same as the size the window manager will actually select). See: gtk_window_set_default_size(). Depending on the windowing system and the window manager constraints, the size returned by this function may not match the size set using gtk_window_resize(); additionally, since gtk_window_resize() may be implemented as an asynchronous operation, GTK+ cannot guarantee in any way that this code: |[<!-- language="C" --> // width and height are set elsewhere gtk_window_resize (window, width, height); int new_width, new_height; gtk_window_get_size (window, &new_width, &new_height); ]| will result in `new_width` and `new_height` matching `width` and `height`, respectively. This function will return the logical size of the #GtkWindow, excluding the widgets used in client side decorations; there is, however, no guarantee that the result will be completely accurate because client side decoration may include widgets that depend on the user preferences and that may not be visibile at the time you call this function. The dimensions returned by this function are suitable for being stored across sessions; use gtk_window_set_default_size() to restore them when before showing the window. To avoid potential race conditions, you should only call this function in response to a size change notification, for instance inside a handler for the #GtkWidget::size-allocate signal, or inside a handler for the #GtkWidget::configure-event signal: |[<!-- language="C" --> static void on_size_allocate (GtkWidget *widget, GtkAllocation *allocation) { int new_width, new_height; gtk_window_get_size (GTK_WINDOW (widget), &new_width, &new_height); ... } ]| Note that, if you connect to the #GtkWidget::size-allocate signal, you should not use the dimensions of the #GtkAllocation passed to the signal handler, as the allocation may contain client side decorations added by GTK+, depending on the windowing system in use. If you are getting a window size in order to position the window on the screen, you should, instead, simply set the window’s semantic type with gtk_window_set_type_hint(), which allows the window manager to e.g. center dialogs. Also, if you set the transient parent of dialogs with gtk_window_set_transient_for() window managers will often center the dialog over its parent window. It's much preferred to let the window manager handle these cases rather than doing it yourself, because all apps will behave consistently and according to user or system preferences, if the window manager handles it. Also, the window manager can take into account the size of the window decorations and border that it may add, and of which GTK+ has no knowledge. Additionally, positioning windows in global screen coordinates may not be allowed by the windowing system. For more information, see: gtk_window_set_position(). a #GtkWindow return location for width, or %NULL return location for height, or %NULL Gets the value set by gtk_window_set_skip_pager_hint(). %TRUE if window shouldn’t be in pager a #GtkWindow Gets the value set by gtk_window_set_skip_taskbar_hint() %TRUE if window shouldn’t be in taskbar a #GtkWindow Retrieves the title of the window. See gtk_window_set_title(). the title of the window, or %NULL if none has been set explicitly. The returned string is owned by the widget and must not be modified or freed. a #GtkWindow Returns the custom titlebar that has been set with gtk_window_set_titlebar(). the custom titlebar, or %NULL a #GtkWindow Fetches the transient parent for this window. See gtk_window_set_transient_for(). the transient parent for this window, or %NULL if no transient parent has been set. a #GtkWindow Gets the type hint for this window. See gtk_window_set_type_hint(). the type hint for @window. a #GtkWindow Gets the value set by gtk_window_set_urgency_hint() %TRUE if window is urgent a #GtkWindow Gets the type of the window. See #GtkWindowType. the type of the window a #GtkWindow Returns whether @window has an explicit window group. %TRUE if @window has an explicit window group. Since 2.22 a #GtkWindow Returns whether the input focus is within this GtkWindow. For real toplevel windows, this is identical to gtk_window_is_active(), but for embedded windows, like #GtkPlug, the results will differ. %TRUE if the input focus is within this GtkWindow a #GtkWindow Asks to iconify (i.e. minimize) the specified @window. Note that you shouldn’t assume the window is definitely iconified afterward, because other entities (e.g. the user or [window manager][gtk-X11-arch]) could deiconify it again, or there may not be a window manager in which case iconification isn’t possible, etc. But normally the window will end up iconified. Just don’t write code that crashes if not. It’s permitted to call this function before showing a window, in which case the window will be iconified before it ever appears onscreen. You can track iconification via the “window-state-event” signal on #GtkWidget. a #GtkWindow Returns whether the window is part of the current active toplevel. (That is, the toplevel window receiving keystrokes.) The return value is %TRUE if the window is active toplevel itself, but also if it is, say, a #GtkPlug embedded in the active toplevel. You might use this function if you wanted to draw a widget differently in an active window from a widget in an inactive window. See gtk_window_has_toplevel_focus() %TRUE if the window part of the current active window. a #GtkWindow Retrieves the current maximized state of @window. Note that since maximization is ultimately handled by the window manager and happens asynchronously to an application request, you shouldn’t assume the return value of this function changing immediately (or at all), as an effect of calling gtk_window_maximize() or gtk_window_unmaximize(). whether the window has a maximized state. a #GtkWindow Asks to maximize @window, so that it becomes full-screen. Note that you shouldn’t assume the window is definitely maximized afterward, because other entities (e.g. the user or [window manager][gtk-X11-arch]) could unmaximize it again, and not all window managers support maximization. But normally the window will end up maximized. Just don’t write code that crashes if not. It’s permitted to call this function before showing a window, in which case the window will be maximized when it appears onscreen initially. You can track maximization via the “window-state-event” signal on #GtkWidget, or by listening to notifications on the #GtkWindow:is-maximized property. a #GtkWindow Activates the targets associated with the mnemonic. %TRUE if the activation is done. a #GtkWindow the mnemonic the modifiers Asks the [window manager][gtk-X11-arch] to move @window to the given position. Window managers are free to ignore this; most window managers ignore requests for initial window positions (instead using a user-defined placement algorithm) and honor requests after the window has already been shown. Note: the position is the position of the gravity-determined reference point for the window. The gravity determines two things: first, the location of the reference point in root window coordinates; and second, which point on the window is positioned at the reference point. By default the gravity is #GDK_GRAVITY_NORTH_WEST, so the reference point is simply the @x, @y supplied to gtk_window_move(). The top-left corner of the window decorations (aka window frame or border) will be placed at @x, @y. Therefore, to position a window at the top left of the screen, you want to use the default gravity (which is #GDK_GRAVITY_NORTH_WEST) and move the window to 0,0. To position a window at the bottom right corner of the screen, you would set #GDK_GRAVITY_SOUTH_EAST, which means that the reference point is at @x + the window width and @y + the window height, and the bottom-right corner of the window border will be placed at that reference point. So, to place a window in the bottom right corner you would first set gravity to south east, then write: `gtk_window_move (window, gdk_screen_width () - window_width, gdk_screen_height () - window_height)` (note that this example does not take multi-head scenarios into account). The [Extended Window Manager Hints Specification](http://www.freedesktop.org/Standards/wm-spec) has a nice table of gravities in the “implementation notes” section. The gtk_window_get_position() documentation may also be relevant. a #GtkWindow X coordinate to move window to Y coordinate to move window to Parses a standard X Window System geometry string - see the manual page for X (type “man X”) for details on this. gtk_window_parse_geometry() does work on all GTK+ ports including Win32 but is primarily intended for an X environment. If either a size or a position can be extracted from the geometry string, gtk_window_parse_geometry() returns %TRUE and calls gtk_window_set_default_size() and/or gtk_window_move() to resize/move the window. If gtk_window_parse_geometry() returns %TRUE, it will also set the #GDK_HINT_USER_POS and/or #GDK_HINT_USER_SIZE hints indicating to the window manager that the size/position of the window was user-specified. This causes most window managers to honor the geometry. Note that for gtk_window_parse_geometry() to work as expected, it has to be called when the window has its “final” size, i.e. after calling gtk_widget_show_all() on the contents and gtk_window_set_geometry_hints() on the window. |[<!-- language="C" --> #include <gtk/gtk.h> static void fill_with_content (GtkWidget *vbox) { // fill with content... } int main (int argc, char *argv[]) { GtkWidget *window, *vbox; GdkGeometry size_hints = { 100, 50, 0, 0, 100, 50, 10, 10, 0.0, 0.0, GDK_GRAVITY_NORTH_WEST }; gtk_init (&argc, &argv); window = gtk_window_new (GTK_WINDOW_TOPLEVEL); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); gtk_container_add (GTK_CONTAINER (window), vbox); fill_with_content (vbox); gtk_widget_show_all (vbox); gtk_window_set_geometry_hints (GTK_WINDOW (window), NULL, &size_hints, GDK_HINT_MIN_SIZE | GDK_HINT_BASE_SIZE | GDK_HINT_RESIZE_INC); if (argc > 1) { gboolean res; res = gtk_window_parse_geometry (GTK_WINDOW (window), argv[1]); if (! res) fprintf (stderr, "Failed to parse “%s”\n", argv[1]); } gtk_widget_show_all (window); gtk_main (); return 0; } ]| Geometry handling in GTK is deprecated. %TRUE if string was parsed successfully a #GtkWindow geometry string Presents a window to the user. This function should not be used as when it is called, it is too late to gather a valid timestamp to allow focus stealing prevention to work correctly. a #GtkWindow Presents a window to the user. This may mean raising the window in the stacking order, deiconifying it, moving it to the current desktop, and/or giving it the keyboard focus, possibly dependent on the user’s platform, window manager, and preferences. If @window is hidden, this function calls gtk_widget_show() as well. This function should be used when the user tries to open a window that’s already open. Say for example the preferences dialog is currently open, and the user chooses Preferences from the menu a second time; use gtk_window_present() to move the already-open dialog where the user can see it. Presents a window to the user in response to a user interaction. The timestamp should be gathered when the window was requested to be shown (when clicking a link for example), rather than once the window is ready to be shown. a #GtkWindow the timestamp of the user interaction (typically a button or key press event) which triggered this call Propagate a key press or release event to the focus widget and up the focus container chain until a widget handles @event. This is normally called by the default ::key_press_event and ::key_release_event handlers for toplevel windows, however in some cases it may be useful to call this directly when overriding the standard key handling for a toplevel window. %TRUE if a widget in the focus chain handled the event. a #GtkWindow a #GdkEventKey Reverses the effects of gtk_window_add_accel_group(). a #GtkWindow a #GtkAccelGroup Removes a mnemonic from this window. a #GtkWindow the mnemonic the widget that gets activated by the mnemonic Hides @window, then reshows it, resetting the default size and position of the window. Used by GUI builders only. GUI builders can call gtk_widget_hide(), gtk_widget_unrealize() and then gtk_widget_show() on @window themselves, if they still need this functionality. a #GtkWindow Resizes the window as if the user had done so, obeying geometry constraints. The default geometry constraint is that windows may not be smaller than their size request; to override this constraint, call gtk_widget_set_size_request() to set the window's request to a smaller value. If gtk_window_resize() is called before showing a window for the first time, it overrides any default size set with gtk_window_set_default_size(). Windows may not be resized smaller than 1 by 1 pixels. When using client side decorations, GTK+ will do its best to adjust the given size so that the resulting window size matches the requested size without the title bar, borders and shadows added for the client side decorations, but there is no guarantee that the result will be totally accurate because these widgets added for client side decorations depend on the theme and may not be realized or visible at the time gtk_window_resize() is issued. If the GtkWindow has a titlebar widget (see gtk_window_set_titlebar()), then typically, gtk_window_resize() will compensate for the height of the titlebar widget only if the height is known when the resulting GtkWindow configuration is issued. For example, if new widgets are added after the GtkWindow configuration and cause the titlebar widget to grow in height, this will result in a window content smaller that specified by gtk_window_resize() and not a larger window. a #GtkWindow width in pixels to resize the window to height in pixels to resize the window to Determines whether a resize grip is visible for the specified window. Resize grips have been removed. %TRUE if a resize grip exists and is visible a #GtkWindow Like gtk_window_resize(), but @width and @height are interpreted in terms of the base size and increment set with gtk_window_set_geometry_hints. This function does nothing. Use gtk_window_resize() and compute the geometry yourself. a #GtkWindow width in resize increments to resize the window to height in resize increments to resize the window to Windows may set a hint asking the desktop environment not to receive the input focus. This function sets this hint. a #GtkWindow %TRUE to let this window receive input focus Sets or unsets the #GtkApplication associated with the window. The application will be kept alive for at least as long as it has any windows associated with it (see g_application_hold() for a way to keep it alive without windows). Normally, the connection between the application and the window will remain until the window is destroyed, but you can explicitly remove it by setting the @application to %NULL. This is equivalent to calling gtk_application_remove_window() and/or gtk_application_add_window() on the old/new applications as relevant. a #GtkWindow a #GtkApplication, or %NULL to unset Marks @window as attached to @attach_widget. This creates a logical binding between the window and the widget it belongs to, which is used by GTK+ to propagate information such as styling or accessibility to @window as if it was a children of @attach_widget. Examples of places where specifying this relation is useful are for instance a #GtkMenu created by a #GtkComboBox, a completion popup window created by #GtkEntry or a typeahead search entry created by #GtkTreeView. Note that this function should not be confused with gtk_window_set_transient_for(), which specifies a window manager relation between two toplevels instead. Passing %NULL for @attach_widget detaches the window. a #GtkWindow a #GtkWidget, or %NULL By default, windows are decorated with a title bar, resize controls, etc. Some [window managers][gtk-X11-arch] allow GTK+ to disable these decorations, creating a borderless window. If you set the decorated property to %FALSE using this function, GTK+ will do its best to convince the window manager not to decorate the window. Depending on the system, this function may not have any effect when called on a window that is already visible, so you should call it before calling gtk_widget_show(). On Windows, this function always works, since there’s no window manager policy involved. a #GtkWindow %TRUE to decorate the window The default widget is the widget that’s activated when the user presses Enter in a dialog (for example). This function sets or unsets the default widget for a #GtkWindow. When setting (rather than unsetting) the default widget it’s generally easier to call gtk_widget_grab_default() on the widget. Before making a widget the default widget, you must call gtk_widget_set_can_default() on the widget you’d like to make the default. a #GtkWindow widget to be the default, or %NULL to unset the default widget for the toplevel Like gtk_window_set_default_size(), but @width and @height are interpreted in terms of the base size and increment set with gtk_window_set_geometry_hints. This function does nothing. If you want to set a default size, use gtk_window_set_default_size() instead. a #GtkWindow width in resize increments, or -1 to unset the default width height in resize increments, or -1 to unset the default height Sets the default size of a window. If the window’s “natural” size (its size request) is larger than the default, the default will be ignored. More generally, if the default size does not obey the geometry hints for the window (gtk_window_set_geometry_hints() can be used to set these explicitly), the default size will be clamped to the nearest permitted size. Unlike gtk_widget_set_size_request(), which sets a size request for a widget and thus would keep users from shrinking the window, this function only sets the initial size, just as if the user had resized the window themselves. Users can still shrink the window again as they normally would. Setting a default size of -1 means to use the “natural” default size (the size request of the window). For more control over a window’s initial size and how resizing works, investigate gtk_window_set_geometry_hints(). For some uses, gtk_window_resize() is a more appropriate function. gtk_window_resize() changes the current size of the window, rather than the size to be used on initial display. gtk_window_resize() always affects the window itself, not the geometry widget. The default size of a window only affects the first time a window is shown; if a window is hidden and re-shown, it will remember the size it had prior to hiding, rather than using the default size. Windows can’t actually be 0x0 in size, they must be at least 1x1, but passing 0 for @width and @height is OK, resulting in a 1x1 default size. If you use this function to reestablish a previously saved window size, note that the appropriate size to save is the one returned by gtk_window_get_size(). Using the window allocation directly will not work in all circumstances and can lead to growing or shrinking windows. a #GtkWindow width in pixels, or -1 to unset the default width height in pixels, or -1 to unset the default height By default, windows have a close button in the window frame. Some [window managers][gtk-X11-arch] allow GTK+ to disable this button. If you set the deletable property to %FALSE using this function, GTK+ will do its best to convince the window manager not to show a close button. Depending on the system, this function may not have any effect when called on a window that is already visible, so you should call it before calling gtk_widget_show(). On Windows, this function always works, since there’s no window manager policy involved. a #GtkWindow %TRUE to decorate the window as deletable If @setting is %TRUE, then destroying the transient parent of @window will also destroy @window itself. This is useful for dialogs that shouldn’t persist beyond the lifetime of the main window they're associated with, for example. a #GtkWindow whether to destroy @window with its transient parent If @focus is not the current focus widget, and is focusable, sets it as the focus widget for the window. If @focus is %NULL, unsets the focus widget for this window. To set the focus to a particular widget in the toplevel, it is usually more convenient to use gtk_widget_grab_focus() instead of this function. a #GtkWindow widget to be the new focus widget, or %NULL to unset any focus widget for the toplevel window. Windows may set a hint asking the desktop environment not to receive the input focus when the window is mapped. This function sets this hint. a #GtkWindow %TRUE to let this window receive input focus on map Sets the #GtkWindow:focus-visible property. a #GtkWindow the new value This function sets up hints about how a window can be resized by the user. You can set a minimum and maximum size; allowed resize increments (e.g. for xterm, you can only resize by the size of a character); aspect ratios; and more. See the #GdkGeometry struct. a #GtkWindow widget the geometry hints used to be applied to or %NULL. Since 3.20 this argument is ignored and GTK behaves as if %NULL was set. struct containing geometry information or %NULL mask indicating which struct fields should be paid attention to Window gravity defines the meaning of coordinates passed to gtk_window_move(). See gtk_window_move() and #GdkGravity for more details. The default window gravity is #GDK_GRAVITY_NORTH_WEST which will typically “do what you mean.” a #GtkWindow window gravity Sets whether @window has a corner resize grip. Note that the resize grip is only shown if the window is actually resizable and not maximized. Use gtk_window_resize_grip_is_visible() to find out if the resize grip is currently shown. Resize grips have been removed. a #GtkWindow %TRUE to allow a resize grip Tells GTK+ whether to drop its extra reference to the window when gtk_widget_destroy() is called. This function is only exported for the benefit of language bindings which may need to keep the window alive until their wrapper object is garbage collected. There is no justification for ever calling this function in an application. a #GtkWindow the new value If @setting is %TRUE, then @window will request that it’s titlebar should be hidden when maximized. This is useful for windows that don’t convey any information other than the application name in the titlebar, to put the available screen space to better use. If the underlying window system does not support the request, the setting will not have any effect. Note that custom titlebars set with gtk_window_set_titlebar() are not affected by this. The application is in full control of their content and visibility anyway. a #GtkWindow whether to hide the titlebar when @window is maximized Sets up the icon representing a #GtkWindow. This icon is used when the window is minimized (also known as iconified). Some window managers or desktop environments may also place it in the window frame, or display it in other contexts. On others, the icon is not used at all, so your mileage may vary. The icon should be provided in whatever size it was naturally drawn; that is, don’t scale the image before passing it to GTK+. Scaling is postponed until the last minute, when the desired final size is known, to allow best quality. If you have your icon hand-drawn in multiple sizes, use gtk_window_set_icon_list(). Then the best size will be used. This function is equivalent to calling gtk_window_set_icon_list() with a 1-element list. See also gtk_window_set_default_icon_list() to set the icon for all windows in your application in one go. a #GtkWindow icon image, or %NULL Sets the icon for @window. Warns on failure if @err is %NULL. This function is equivalent to calling gtk_window_set_icon() with a pixbuf created by loading the image from @filename. %TRUE if setting the icon succeeded. a #GtkWindow location of icon file Sets up the icon representing a #GtkWindow. The icon is used when the window is minimized (also known as iconified). Some window managers or desktop environments may also place it in the window frame, or display it in other contexts. On others, the icon is not used at all, so your mileage may vary. gtk_window_set_icon_list() allows you to pass in the same icon in several hand-drawn sizes. The list should contain the natural sizes your icon is available in; that is, don’t scale the image before passing it to GTK+. Scaling is postponed until the last minute, when the desired final size is known, to allow best quality. By passing several sizes, you may improve the final image quality of the icon, by reducing or eliminating automatic image scaling. Recommended sizes to provide: 16x16, 32x32, 48x48 at minimum, and larger images (64x64, 128x128) if you have them. See also gtk_window_set_default_icon_list() to set the icon for all windows in your application in one go. Note that transient windows (those who have been set transient for another window using gtk_window_set_transient_for()) will inherit their icon from their transient parent. So there’s no need to explicitly set the icon on transient windows. a #GtkWindow list of #GdkPixbuf Sets the icon for the window from a named themed icon. See the docs for #GtkIconTheme for more details. On some platforms, the window icon is not used at all. Note that this has nothing to do with the WM_ICON_NAME property which is mentioned in the ICCCM. a #GtkWindow the name of the themed icon Asks to keep @window above, so that it stays on top. Note that you shouldn’t assume the window is definitely above afterward, because other entities (e.g. the user or [window manager][gtk-X11-arch]) could not keep it above, and not all window managers support keeping windows above. But normally the window will end kept above. Just don’t write code that crashes if not. It’s permitted to call this function before showing a window, in which case the window will be kept above when it appears onscreen initially. You can track the above state via the “window-state-event” signal on #GtkWidget. Note that, according to the [Extended Window Manager Hints Specification](http://www.freedesktop.org/Standards/wm-spec), the above state is mainly meant for user preferences and should not be used by applications e.g. for drawing attention to their dialogs. a #GtkWindow whether to keep @window above other windows Asks to keep @window below, so that it stays in bottom. Note that you shouldn’t assume the window is definitely below afterward, because other entities (e.g. the user or [window manager][gtk-X11-arch]) could not keep it below, and not all window managers support putting windows below. But normally the window will be kept below. Just don’t write code that crashes if not. It’s permitted to call this function before showing a window, in which case the window will be kept below when it appears onscreen initially. You can track the below state via the “window-state-event” signal on #GtkWidget. Note that, according to the [Extended Window Manager Hints Specification](http://www.freedesktop.org/Standards/wm-spec), the above state is mainly meant for user preferences and should not be used by applications e.g. for drawing attention to their dialogs. a #GtkWindow whether to keep @window below other windows Sets the mnemonic modifier for this window. a #GtkWindow the modifier mask used to activate mnemonics on this window. Sets the #GtkWindow:mnemonics-visible property. a #GtkWindow the new value Sets a window modal or non-modal. Modal windows prevent interaction with other windows in the same application. To keep modal dialogs on top of main application windows, use gtk_window_set_transient_for() to make the dialog transient for the parent; most [window managers][gtk-X11-arch] will then disallow lowering the dialog below the parent. a #GtkWindow whether the window is modal Request the windowing system to make @window partially transparent, with opacity 0 being fully transparent and 1 fully opaque. (Values of the opacity parameter are clamped to the [0,1] range.) On X11 this has any effect only on X screens with a compositing manager running. See gtk_widget_is_composited(). On Windows it should work always. Note that setting a window’s opacity after the window has been shown causes it to flicker once on Windows. Use gtk_widget_set_opacity instead. a #GtkWindow desired opacity, between 0 and 1 Sets a position constraint for this window. If the old or new constraint is %GTK_WIN_POS_CENTER_ALWAYS, this will also cause the window to be repositioned to satisfy the new constraint. a #GtkWindow. a position constraint. Sets whether the user can resize a window. Windows are user resizable by default. a #GtkWindow %TRUE if the user can resize this window This function is only useful on X11, not with other GTK+ targets. In combination with the window title, the window role allows a [window manager][gtk-X11-arch] to identify "the same" window when an application is restarted. So for example you might set the “toolbox” role on your app’s toolbox window, so that when the user restarts their session, the window manager can put the toolbox back in the same place. If a window already has a unique title, you don’t need to set the role, since the WM can use the title to identify the window when restoring the session. a #GtkWindow unique identifier for the window to be used when restoring a session Sets the #GdkScreen where the @window is displayed; if the window is already mapped, it will be unmapped, and then remapped on the new screen. a #GtkWindow. a #GdkScreen. Windows may set a hint asking the desktop environment not to display the window in the pager. This function sets this hint. (A "pager" is any desktop navigation tool such as a workspace switcher that displays a thumbnail representation of the windows on the screen.) a #GtkWindow %TRUE to keep this window from appearing in the pager Windows may set a hint asking the desktop environment not to display the window in the task bar. This function sets this hint. a #GtkWindow %TRUE to keep this window from appearing in the task bar Startup notification identifiers are used by desktop environment to track application startup, to provide user feedback and other features. This function changes the corresponding property on the underlying GdkWindow. Normally, startup identifier is managed automatically and you should only use this function in special cases like transferring focus from other processes. You should use this function before calling gtk_window_present() or any equivalent function generating a window map event. This function is only useful on X11, not with other GTK+ targets. a #GtkWindow a string with startup-notification identifier Sets the title of the #GtkWindow. The title of a window will be displayed in its title bar; on the X Window System, the title bar is rendered by the [window manager][gtk-X11-arch], so exactly how the title appears to users may vary according to a user’s exact configuration. The title should help a user distinguish this window from other windows they may have open. A good title might include the application name and current document filename, for example. a #GtkWindow title of the window Sets a custom titlebar for @window. A typical widget used here is #GtkHeaderBar, as it provides various features expected of a titlebar while allowing the addition of child widgets to it. If you set a custom titlebar, GTK+ will do its best to convince the window manager not to put its own titlebar on the window. Depending on the system, this function may not work for a window that is already visible, so you set the titlebar before calling gtk_widget_show(). a #GtkWindow the widget to use as titlebar Dialog windows should be set transient for the main application window they were spawned from. This allows [window managers][gtk-X11-arch] to e.g. keep the dialog on top of the main window, or center the dialog over the main window. gtk_dialog_new_with_buttons() and other convenience functions in GTK+ will sometimes call gtk_window_set_transient_for() on your behalf. Passing %NULL for @parent unsets the current transient window. On Wayland, this function can also be used to attach a new #GTK_WINDOW_POPUP to a #GTK_WINDOW_TOPLEVEL parent already mapped on screen so that the #GTK_WINDOW_POPUP will be created as a subsurface-based window #GDK_WINDOW_SUBSURFACE which can be positioned at will relatively to the #GTK_WINDOW_TOPLEVEL surface. On Windows, this function puts the child window on top of the parent, much as the window manager would have done on X. a #GtkWindow parent window, or %NULL By setting the type hint for the window, you allow the window manager to decorate and handle the window in a way which is suitable to the function of the window in your application. This function should be called before the window becomes visible. gtk_dialog_new_with_buttons() and other convenience functions in GTK+ will sometimes call gtk_window_set_type_hint() on your behalf. a #GtkWindow the window type Windows may set a hint asking the desktop environment to draw the users attention to the window. This function sets this hint. a #GtkWindow %TRUE to mark this window as urgent Don’t use this function. It sets the X Window System “class” and “name” hints for a window. According to the ICCCM, you should always set these to the same value for all windows in an application, and GTK+ sets them to that value by default, so calling this function is sort of pointless. However, you may want to call gtk_window_set_role() on each window in your application, for the benefit of the session manager. Setting the role allows the window manager to restore window positions when loading a saved session. a #GtkWindow window name hint window class hint Asks to stick @window, which means that it will appear on all user desktops. Note that you shouldn’t assume the window is definitely stuck afterward, because other entities (e.g. the user or [window manager][gtk-X11-arch] could unstick it again, and some window managers do not support sticking windows. But normally the window will end up stuck. Just don't write code that crashes if not. It’s permitted to call this function before showing a window. You can track stickiness via the “window-state-event” signal on #GtkWidget. a #GtkWindow Asks to toggle off the fullscreen state for @window. Note that you shouldn’t assume the window is definitely not full screen afterward, because other entities (e.g. the user or [window manager][gtk-X11-arch]) could fullscreen it again, and not all window managers honor requests to unfullscreen windows. But normally the window will end up restored to its normal state. Just don’t write code that crashes if not. You can track the fullscreen state via the “window-state-event” signal on #GtkWidget. a #GtkWindow Asks to unmaximize @window. Note that you shouldn’t assume the window is definitely unmaximized afterward, because other entities (e.g. the user or [window manager][gtk-X11-arch]) could maximize it again, and not all window managers honor requests to unmaximize. But normally the window will end up unmaximized. Just don’t write code that crashes if not. You can track maximization via the “window-state-event” signal on #GtkWidget. a #GtkWindow Asks to unstick @window, which means that it will appear on only one of the user’s desktops. Note that you shouldn’t assume the window is definitely unstuck afterward, because other entities (e.g. the user or [window manager][gtk-X11-arch]) could stick it again. But normally the window will end up stuck. Just don’t write code that crashes if not. You can track stickiness via the “window-state-event” signal on #GtkWidget. a #GtkWindow Whether the window should receive the input focus. The #GtkApplication associated with the window. The application will be kept alive for at least as long as it has any windows associated with it (see g_application_hold() for a way to keep it alive without windows). Normally, the connection between the application and the window will remain until the window is destroyed, but you can explicitly remove it by setting the :application property to %NULL. The widget to which this window is attached. See gtk_window_set_attached_to(). Examples of places where specifying this relation is useful are for instance a #GtkMenu created by a #GtkComboBox, a completion popup window created by #GtkEntry or a typeahead search entry created by #GtkTreeView. Whether the window should be decorated by the window manager. Whether the window frame should have a close button. Whether the window should receive the input focus when mapped. Whether 'focus rectangles' are currently visible in this window. This property is maintained by GTK+ based on user input and should not be set by applications. The window gravity of the window. See gtk_window_move() and #GdkGravity for more details about window gravity. Whether the window has a corner resize grip. Note that the resize grip is only shown if the window is actually resizable and not maximized. Use #GtkWindow:resize-grip-visible to find out if the resize grip is currently shown. Resize grips have been removed. Whether the titlebar should be hidden during maximization. The :icon-name property specifies the name of the themed icon to use as the window icon. See #GtkIconTheme for more details. Whether mnemonics are currently visible in this window. This property is maintained by GTK+ based on user input, and should not be set by applications. Whether a corner resize grip is currently shown. Resize grips have been removed. The :startup-id is a write-only property for setting window's startup notification identifier. See gtk_window_set_startup_id() for more details. The transient parent of the window. See gtk_window_set_transient_for() for more details about transient windows. The ::activate-default signal is a [keybinding signal][GtkBindingSignal] which gets emitted when the user activates the default widget of @window. The ::activate-focus signal is a [keybinding signal][GtkBindingSignal] which gets emitted when the user activates the currently focused widget of @window. The ::enable-debugging signal is a [keybinding signal][GtkBindingSignal] which gets emitted when the user enables or disables interactive debugging. When @toggle is %TRUE, interactive debugging is toggled on or off, when it is %FALSE, the debugger will be pointed at the widget under the pointer. The default bindings for this signal are Ctrl-Shift-I and Ctrl-Shift-D. %TRUE if the key binding was handled toggle the debugger The ::keys-changed signal gets emitted when the set of accelerators or mnemonics that are associated with @window changes. This signal is emitted whenever the currently focused widget in this window changes. the newly focused widget (or %NULL for no focus) The parent class. a #GtkWindow widget to be the new focus widget, or %NULL to unset any focus widget for the toplevel window. A #GtkWindowGroup restricts the effect of grabs to windows in the same group, thereby making window groups almost behave like separate applications. A window can be a member in at most one window group at a time. Windows that have not been explicitly assigned to a group are implicitly treated like windows of the default window group. GtkWindowGroup objects are referenced by each window in the group, so once you have added all windows to a GtkWindowGroup, you can drop the initial reference to the window group with g_object_unref(). If the windows in the window group are subsequently destroyed, then they will be removed from the window group and drop their references on the window group; when all window have been removed, the window group will be freed. Creates a new #GtkWindowGroup object. Grabs added with gtk_grab_add() only affect windows within the same #GtkWindowGroup. a new #GtkWindowGroup. Adds a window to a #GtkWindowGroup. a #GtkWindowGroup the #GtkWindow to add Returns the current grab widget for @device, or %NULL if none. The grab widget, or %NULL a #GtkWindowGroup a #GdkDevice Gets the current grab widget of the given group, see gtk_grab_add(). the current grab widget of the group a #GtkWindowGroup Returns a list of the #GtkWindows that belong to @window_group. A newly-allocated list of windows inside the group. a #GtkWindowGroup Removes a window from a #GtkWindowGroup. a #GtkWindowGroup the #GtkWindow to remove Window placement can be influenced using this enumeration. Note that using #GTK_WIN_POS_CENTER_ALWAYS is almost always a bad idea. It won’t necessarily work well with all window managers or on all windowing systems. No influence is made on placement. Windows should be placed in the center of the screen. Windows should be placed at the current mouse position. Keep window centered as it changes size, etc. Center the window on its transient parent (see gtk_window_set_transient_for()). A #GtkWindow can be one of these types. Most things you’d consider a “window” should have type #GTK_WINDOW_TOPLEVEL; windows with this type are managed by the window manager and have a frame by default (call gtk_window_set_decorated() to toggle the frame). Windows with type #GTK_WINDOW_POPUP are ignored by the window manager; window manager keybindings won’t work on them, the window manager won’t decorate the window with a frame, many GTK+ features that rely on the window manager will not work (e.g. resize grips and maximization/minimization). #GTK_WINDOW_POPUP is used to implement widgets such as #GtkMenu or tooltips that you normally don’t think of as windows per se. Nearly all windows should be #GTK_WINDOW_TOPLEVEL. In particular, do not use #GTK_WINDOW_POPUP just to turn off the window borders; use gtk_window_set_decorated() for that. A regular window, such as a dialog. A special window such as a tooltip. Describes a type of line wrapping. do not wrap lines; just make the text area wider wrap text, breaking lines anywhere the cursor can appear (between characters, usually - if you want to be technical, between graphemes, see pango_get_log_attrs()) wrap text, breaking lines in between words wrap text, breaking lines in between words, or if that is not enough, also between graphemes This section contains code for working with the <link linkend="gdbus-interface-org-Gtk-MountOperationHandler.top_of_page">org.Gtk.MountOperationHandler</link> D-Bus interface in C. Abstract interface type for the D-Bus interface <link linkend="gdbus-interface-org-Gtk-MountOperationHandler.top_of_page">org.Gtk.MountOperationHandler</link>. Virtual table for the D-Bus interface <link linkend="gdbus-interface-org-Gtk-MountOperationHandler.top_of_page">org.Gtk.MountOperationHandler</link>. The parent interface. The #_GtkMountOperationHandlerProxy structure contains only private data and should only be accessed using the provided API. Class structure for #_GtkMountOperationHandlerProxy. The parent class. The #_GtkMountOperationHandlerSkeleton structure contains only private data and should only be accessed using the provided API. Class structure for #_GtkMountOperationHandlerSkeleton. The parent class. Finds the first accelerator in any #GtkAccelGroup attached to @object that matches @accel_key and @accel_mods, and activates that accelerator. %TRUE if an accelerator was activated and handled this keypress the #GObject, usually a #GtkWindow, on which to activate the accelerator accelerator keyval from a key event keyboard state mask from a key event Gets a list of all accel groups which are attached to @object. a list of all accel groups which are attached to @object a #GObject, usually a #GtkWindow Gets the modifier mask. The modifier mask determines which modifiers are considered significant for keyboard accelerators. See gtk_accelerator_set_default_mod_mask(). the default accelerator modifier mask Converts an accelerator keyval and modifier mask into a string which can be used to represent the accelerator to the user. a newly-allocated string representing the accelerator. accelerator keyval accelerator modifier mask Converts an accelerator keyval and modifier mask into a (possibly translated) string that can be displayed to a user, similarly to gtk_accelerator_get_label(), but handling keycodes. This is only useful for system-level components, applications should use gtk_accelerator_parse() instead. a newly-allocated string representing the accelerator. a #GdkDisplay or %NULL to use the default display accelerator keyval accelerator keycode accelerator modifier mask Converts an accelerator keyval and modifier mask into a string parseable by gtk_accelerator_parse(). For example, if you pass in #GDK_KEY_q and #GDK_CONTROL_MASK, this function returns “<Control>q”. If you need to display accelerators in the user interface, see gtk_accelerator_get_label(). a newly-allocated accelerator name accelerator keyval accelerator modifier mask Converts an accelerator keyval and modifier mask into a string parseable by gtk_accelerator_parse_with_keycode(), similarly to gtk_accelerator_name() but handling keycodes. This is only useful for system-level components, applications should use gtk_accelerator_parse() instead. a newly allocated accelerator name. a #GdkDisplay or %NULL to use the default display accelerator keyval accelerator keycode accelerator modifier mask Parses a string representing an accelerator. The format looks like “<Control>a” or “<Shift><Alt>F1” or “<Release>z” (the last one is for key release). The parser is fairly liberal and allows lower or upper case, and also abbreviations such as “<Ctl>” and “<Ctrl>”. Key names are parsed using gdk_keyval_from_name(). For character keys the name is not the symbol, but the lowercase name, e.g. one would use “<Ctrl>minus” instead of “<Ctrl>-”. If the parse fails, @accelerator_key and @accelerator_mods will be set to 0 (zero). string representing an accelerator return location for accelerator keyval, or %NULL return location for accelerator modifier mask, %NULL Parses a string representing an accelerator, similarly to gtk_accelerator_parse() but handles keycodes as well. This is only useful for system-level components, applications should use gtk_accelerator_parse() instead. If @accelerator_codes is given and the result stored in it is non-%NULL, the result must be freed with g_free(). If a keycode is present in the accelerator and no @accelerator_codes is given, the parse will fail. If the parse fails, @accelerator_key, @accelerator_mods and @accelerator_codes will be set to 0 (zero). string representing an accelerator return location for accelerator keyval, or %NULL return location for accelerator keycodes, or %NULL return location for accelerator modifier mask, %NULL Sets the modifiers that will be considered significant for keyboard accelerators. The default mod mask depends on the GDK backend in use, but will typically include #GDK_CONTROL_MASK | #GDK_SHIFT_MASK | #GDK_MOD1_MASK | #GDK_SUPER_MASK | #GDK_HYPER_MASK | #GDK_META_MASK. In other words, Control, Shift, Alt, Super, Hyper and Meta. Other modifiers will by default be ignored by #GtkAccelGroup. You must include at least the three modifiers Control, Shift and Alt in any value you pass to this function. The default mod mask should be changed on application startup, before using any accelerator groups. accelerator modifier mask Determines whether a given keyval and modifier mask constitute a valid keyboard accelerator. For example, the #GDK_KEY_a keyval plus #GDK_CONTROL_MASK is valid - this is a “Ctrl+a” accelerator. But, you can't, for instance, use the #GDK_KEY_Control_L keyval as an accelerator. %TRUE if the accelerator is valid a GDK keyval modifier mask Returns %TRUE if dialogs are expected to use an alternative button order on the screen @screen. See gtk_dialog_set_alternative_button_order() for more details about alternative button order. If you need to use this function, you should probably connect to the ::notify:gtk-alternative-button-order signal on the #GtkSettings object associated to @screen, in order to be notified if the button order setting changes. Deprecated Whether the alternative button order should be used a #GdkScreen, or %NULL to use the default screen Parses a signal description from @signal_desc and incorporates it into @binding_set. Signal descriptions may either bind a key combination to one or more signals: |[ bind "key" { "signalname" (param, ...) ... } ]| Or they may also unbind a key combination: |[ unbind "key" ]| Key combinations must be in a format that can be parsed by gtk_accelerator_parse(). %G_TOKEN_NONE if the signal was successfully parsed and added, the expected token otherwise a #GtkBindingSet a signal description Override or install a new key binding for @keyval with @modifiers on @binding_set. a #GtkBindingSet to add a signal to key value key modifier signal name to be bound list of #GtkBindingArg signal arguments Remove a binding previously installed via gtk_binding_entry_add_signal() on @binding_set. a #GtkBindingSet to remove an entry of key value of binding to remove key modifier of binding to remove Install a binding on @binding_set which causes key lookups to be aborted, to prevent bindings from lower priority sets to be activated. a #GtkBindingSet to skip an entry of key value of binding to skip key modifier of binding to skip This function returns the binding set named after the type name of the passed in class structure. New binding sets are created on demand by this function. the binding set corresponding to @object_class a valid #GObject class Find a binding set by its globally unique name. The @set_name can either be a name used for gtk_binding_set_new() or the type name of a class used in gtk_binding_set_by_class(). %NULL or the specified binding set unique binding set name GTK+ maintains a global list of binding sets. Each binding set has a unique name which needs to be specified upon creation. new binding set unique name of this binding set Find a key binding matching @keyval and @modifiers and activate the binding on @object. %TRUE if a binding was found and activated object to activate when binding found key value of the binding key modifier of the binding Looks up key bindings for @object to find one matching @event, and if one was found, activate it. %TRUE if a matching key binding was found a #GObject (generally must be a widget) a #GdkEventKey This function is supposed to be called in #GtkWidget::draw implementations for widgets that support multiple windows. @cr must be untransformed from invoking of the draw function. This function will return %TRUE if the contents of the given @window are supposed to be drawn and %FALSE otherwise. Note that when the drawing was not initiated by the windowing system this function will return %TRUE for all windows, so you need to draw the bottommost window first. Also, do not use “else if” statements to check which window should be drawn. %TRUE if @window should be drawn a cairo context the window to check. @window may not be an input-only window. Transforms the given cairo context @cr that from @widget-relative coordinates to @window-relative coordinates. If the @widget’s window is not an ancestor of @window, no modification will be applied. This is the inverse to the transformation GTK applies when preparing an expose event to be emitted with the #GtkWidget::draw signal. It is intended to help porting multiwindow widgets from GTK+ 2 to the rendering architecture of GTK+ 3. the cairo context to transform the widget the context is currently centered for the window to transform the context to Checks that the GTK+ library in use is compatible with the given version. Generally you would pass in the constants #GTK_MAJOR_VERSION, #GTK_MINOR_VERSION, #GTK_MICRO_VERSION as the three arguments to this function; that produces a check that the library in use is compatible with the version of GTK+ the application or module was compiled against. Compatibility is defined by two things: first the version of the running library is newer than the version @required_major.required_minor.@required_micro. Second the running library must be binary compatible with the version @required_major.required_minor.@required_micro (same major version.) This function is primarily for GTK+ modules; the module can call this function to check that it wasn’t loaded into an incompatible version of GTK+. However, such a check isn’t completely reliable, since the module may be linked against an old version of GTK+ and calling the old version of gtk_check_version(), but still get loaded into an application using a newer version of GTK+. %NULL if the GTK+ library is compatible with the given version, or a string describing the version mismatch. The returned string is owned by GTK+ and should not be modified or freed. the required major version the required minor version the required micro version Adds a GTK+ grab on @device, so all the events on @device and its associated pointer or keyboard (if any) are delivered to @widget. If the @block_others parameter is %TRUE, any other devices will be unable to interact with @widget during the grab. a #GtkWidget a #GdkDevice to grab on. %TRUE to prevent other devices to interact with @widget. Removes a device grab from the given widget. You have to pair calls to gtk_device_grab_add() and gtk_device_grab_remove(). a #GtkWidget a #GdkDevice Prevents gtk_init(), gtk_init_check(), gtk_init_with_args() and gtk_parse_args() from automatically calling `setlocale (LC_ALL, "")`. You would want to use this function if you wanted to set the locale for your program to something other than the user’s locale, or if you wanted to set different values for different locale categories. Most programs should not need to call this function. Distributes @extra_space to child @sizes by bringing smaller children up to natural size first. The remaining space will be added to the @minimum_size member of the GtkRequestedSize struct. If all sizes reach their natural size then the remaining space is returned. The remainder of @extra_space after redistributing space to @sizes. Extra space to redistribute among children after subtracting minimum sizes and any child padding from the overall allocation Number of requests to fit into the allocation An array of structs with a client pointer and a minimum/natural size in the orientation of the allocation. Cancels an ongoing drag operation on the source side. If you want to be able to cancel a drag operation in this way, you need to keep a pointer to the drag context, either from an explicit call to gtk_drag_begin_with_coordinates(), or by connecting to #GtkWidget::drag-begin. If @context does not refer to an ongoing drag operation, this function does nothing. If a drag is cancelled in this way, the @result argument of #GtkWidget::drag-failed is set to @GTK_DRAG_RESULT_ERROR. a #GdkDragContext, as e.g. returned by gtk_drag_begin_with_coordinates() Informs the drag source that the drop is finished, and that the data of the drag will no longer be required. the drag context a flag indicating whether the drop was successful a flag indicating whether the source should delete the original data. (This should be %TRUE for a move) the timestamp from the #GtkWidget::drag-drop signal Determines the source widget for a drag. if the drag is occurring within a single application, a pointer to the source widget. Otherwise, %NULL. a (destination side) drag context Sets the icon for a particular drag to the default icon. the context for a drag (This must be called with a context for the source side of a drag) Sets the icon for a given drag from the given @icon. See the documentation for gtk_drag_set_icon_name() for more details about using icons in drag and drop. the context for a drag (This must be called with a context for the source side of a drag) a #GIcon the X offset of the hotspot within the icon the Y offset of the hotspot within the icon Sets the icon for a given drag from a named themed icon. See the docs for #GtkIconTheme for more details. Note that the size of the icon depends on the icon theme (the icon is loaded at the symbolic size #GTK_ICON_SIZE_DND), thus @hot_x and @hot_y have to be used with care. the context for a drag (This must be called with a context for the source side of a drag) name of icon to use the X offset of the hotspot within the icon the Y offset of the hotspot within the icon Sets @pixbuf as the icon for a given drag. the context for a drag (This must be called with a context for the source side of a drag) the #GdkPixbuf to use as the drag icon the X offset within @widget of the hotspot the Y offset within @widget of the hotspot Sets the icon for a given drag from a stock ID. Use gtk_drag_set_icon_name() instead. the context for a drag (This must be called with a context for the source side of a drag) the ID of the stock icon to use for the drag the X offset within the icon of the hotspot the Y offset within the icon of the hotspot Sets @surface as the icon for a given drag. GTK+ retains references for the arguments, and will release them when they are no longer needed. To position the surface relative to the mouse, use cairo_surface_set_device_offset() on @surface. The mouse cursor will be positioned at the (0,0) coordinate of the surface. the context for a drag (This must be called with a context for the source side of a drag) the surface to use as icon Changes the icon for drag operation to a given widget. GTK+ will not destroy the widget, so if you don’t want it to persist, you should connect to the “drag-end” signal and destroy it yourself. the context for a drag. (This must be called with a context for the source side of a drag) a widget to use as an icon the X offset within @widget of the hotspot the Y offset within @widget of the hotspot Draws a text caret on @cr at @location. This is not a style function but merely a convenience function for drawing the standard cursor shape. Use gtk_render_insertion_cursor() instead. a #GtkWidget cairo context to draw to location where to draw the cursor (@location->width is ignored) if the cursor should be the primary cursor color. whether the cursor is left-to-right or right-to-left. Should never be #GTK_TEXT_DIR_NONE %TRUE to draw a directional arrow on the cursor. Should be %FALSE unless the cursor is split. Checks if any events are pending. This can be used to update the UI and invoke timeouts etc. while doing some time intensive computation. ## Updating the UI during a long computation |[<!-- language="C" --> // computation going on... while (gtk_events_pending ()) gtk_main_iteration (); // ...computation continued ]| %TRUE if any events are pending, %FALSE otherwise Analogical to gtk_true(), this function does nothing but always returns %FALSE. %FALSE Registers an error quark for #GtkFileChooser if necessary. The error quark used for #GtkFileChooser errors. The functions and objects described here make working with GTK+ and GIO more convenient. #GtkMountOperation is needed when mounting volumes: It is an implementation of #GMountOperation that can be used with GIO functions for mounting volumes such as g_file_mount_enclosing_volume(), g_file_mount_mountable(), g_volume_mount(), g_mount_unmount_with_operation() and others. When necessary, #GtkMountOperation shows dialogs to ask for passwords, questions or show processes blocking unmount. gtk_show_uri_on_window() is a convenient way to launch applications for URIs. Another object that is worth mentioning in this context is #GdkAppLaunchContext, which provides visual feedback when lauching applications. Returns the binary age as passed to `libtool` when building the GTK+ library the process is running against. If `libtool` means nothing to you, don't worry about it. the binary age of the GTK+ library Obtains a copy of the event currently being processed by GTK+. For example, if you are handling a #GtkButton::clicked signal, the current event will be the #GdkEventButton that triggered the ::clicked signal. a copy of the current event, or %NULL if there is no current event. The returned event must be freed with gdk_event_free(). If there is a current event and it has a device, return that device, otherwise return %NULL. a #GdkDevice, or %NULL If there is a current event and it has a state field, place that state field in @state and return %TRUE, otherwise return %FALSE. %TRUE if there was a current event and it had a state field a location to store the state of the current event If there is a current event and it has a timestamp, return that timestamp, otherwise return %GDK_CURRENT_TIME. the timestamp from the current event, or %GDK_CURRENT_TIME. Returns the GTK+ debug flags. This function is intended for GTK+ modules that want to adjust their debug output based on GTK+ debug flags. the GTK+ debug flags. Returns the #PangoLanguage for the default language currently in effect. (Note that this can change over the life of an application.) The default language is derived from the current locale. It determines, for example, whether GTK+ uses the right-to-left or left-to-right text direction. This function is equivalent to pango_language_get_default(). See that function for details. the default language as a #PangoLanguage, must not be freed If @event is %NULL or the event was not associated with any widget, returns %NULL, otherwise returns the widget that received the event originally. the widget that originally received @event, or %NULL a #GdkEvent Returns the interface age as passed to `libtool` when building the GTK+ library the process is running against. If `libtool` means nothing to you, don't worry about it. the interface age of the GTK+ library Get the direction of the current locale. This is the expected reading direction for text and UI. This function depends on the current locale being set with setlocale() and will default to setting the %GTK_TEXT_DIR_LTR direction otherwise. %GTK_TEXT_DIR_NONE will never be returned. GTK+ sets the default text direction according to the locale during gtk_init(), and you should normally use gtk_widget_get_direction() or gtk_widget_get_default_direction() to obtain the current direcion. This function is only needed rare cases when the locale is changed after GTK+ has already been initialized. In this case, you can use it to update the default text direction as follows: |[<!-- language="C" --> setlocale (LC_ALL, new_locale); direction = gtk_get_locale_direction (); gtk_widget_set_default_direction (direction); ]| the #GtkTextDirection of the current locale Returns the major version number of the GTK+ library. (e.g. in GTK+ version 3.1.5 this is 3.) This function is in the library, so it represents the GTK+ library your code is running against. Contrast with the #GTK_MAJOR_VERSION macro, which represents the major version of the GTK+ headers you have included when compiling your code. the major version number of the GTK+ library Returns the micro version number of the GTK+ library. (e.g. in GTK+ version 3.1.5 this is 5.) This function is in the library, so it represents the GTK+ library your code is are running against. Contrast with the #GTK_MICRO_VERSION macro, which represents the micro version of the GTK+ headers you have included when compiling your code. the micro version number of the GTK+ library Returns the minor version number of the GTK+ library. (e.g. in GTK+ version 3.1.5 this is 1.) This function is in the library, so it represents the GTK+ library your code is are running against. Contrast with the #GTK_MINOR_VERSION macro, which represents the minor version of the GTK+ headers you have included when compiling your code. the minor version number of the GTK+ library Returns a #GOptionGroup for the commandline arguments recognized by GTK+ and GDK. You should add this group to your #GOptionContext with g_option_context_add_group(), if you are using g_option_context_parse() to parse your commandline arguments. a #GOptionGroup for the commandline arguments recognized by GTK+ whether to open the default display when parsing the commandline arguments Queries the current grab of the default window group. The widget which currently has the grab or %NULL if no grab is active A button box should be used to provide a consistent layout of buttons throughout your application. The layout/spacing can be altered by the programmer, or if desired, by the user to alter the “feel” of a program to a small degree. gtk_button_box_get_layout() and gtk_button_box_set_layout() retrieve and alter the method used to spread the buttons in a button box across the container, respectively. The main purpose of GtkButtonBox is to make sure the children have all the same size. GtkButtonBox gives all children the same size, but it does allow 'outliers' to keep their own larger size. To exempt individual children from homogeneous sizing regardless of their 'outlier' status, you can set the non-homogeneous child property. # CSS nodes GtkButtonBox uses a single CSS node with name buttonbox. #GtkBindingSet provides a mechanism for configuring GTK+ key bindings through CSS files. This eases key binding adjustments for application developers as well as users and provides GTK+ users or administrators with high key binding configurability which requires no application or toolkit side changes. In order for bindings to work in a custom widget implementation, the widget’s #GtkWidget:can-focus and #GtkWidget:has-focus properties must both be true. For example, by calling gtk_widget_set_can_focus() in the widget’s initialisation function; and by calling gtk_widget_grab_focus() when the widget is clicked. # Installing a key binding A CSS file binding consists of a “binding-set” definition and a match statement to apply the binding set to specific widget types. Details on the matching mechanism are described under [Selectors][gtkcssprovider-selectors] in the #GtkCssProvider documentation. Inside the binding set definition, key combinations are bound to one or more specific signal emissions on the target widget. Key combinations are strings consisting of an optional #GdkModifierType name and [key names][gdk3-Keyboard-Handling] such as those defined in `gdk/gdkkeysyms.h` or returned from gdk_keyval_name(), they have to be parsable by gtk_accelerator_parse(). Specifications of signal emissions consist of a string identifying the signal name, and a list of signal specific arguments in parenthesis. For example for binding Control and the left or right cursor keys of a #GtkEntry widget to the #GtkEntry::move-cursor signal (so movement occurs in 3-character steps), the following binding can be used: |[ <!-- language="CSS" --> @binding-set MoveCursor3 { bind "<Control>Right" { "move-cursor" (visual-positions, 3, 0) }; bind "<Control>Left" { "move-cursor" (visual-positions, -3, 0) }; } entry { -gtk-key-bindings: MoveCursor3; } ]| # Unbinding existing key bindings GTK+ already defines a number of useful bindings for the widgets it provides. Because custom bindings set up in CSS files take precedence over the default bindings shipped with GTK+, overriding existing bindings as demonstrated in [Installing a key binding][gtk-bindings-install] works as expected. The same mechanism can not be used to “unbind” existing bindings, however. |[ <!-- language="CSS" --> @binding-set MoveCursor3 { bind "<Control>Right" { }; bind "<Control>Left" { }; } entry { -gtk-key-bindings: MoveCursor3; } ]| The above example will not have the desired effect of causing “<Control>Right” and “<Control>Left” key presses to be ignored by GTK+. Instead, it just causes any existing bindings from the bindings set “MoveCursor3” to be deleted, so when “<Control>Right” or “<Control>Left” are pressed, no binding for these keys is found in binding set “MoveCursor3”. GTK+ will thus continue to search for matching key bindings, and will eventually lookup and find the default GTK+ bindings for entries which implement word movement. To keep GTK+ from activating its default bindings, the “unbind” keyword can be used like this: |[ <!-- language="CSS" --> @binding-set MoveCursor3 { unbind "<Control>Right"; unbind "<Control>Left"; } entry { -gtk-key-bindings: MoveCursor3; } ]| Now, GTK+ will find a match when looking up “<Control>Right” and “<Control>Left” key presses before it resorts to its default bindings, and the match instructs it to abort (“unbind”) the search, so the key presses are not consumed by this widget. As usual, further processing of the key presses, e.g. by an entry’s parent widget, is now possible. The #GtkColorSelection is a widget that is used to select a color. It consists of a color wheel and number of sliders and entry boxes for color parameters such as hue, saturation, value, red, green, blue, and opacity. It is found on the standard color selection dialog box #GtkColorSelectionDialog. The #GtkColorSelectionDialog provides a standard dialog which allows the user to select a color much like the #GtkFileChooserDialog provides a standard dialog for file selection. Use gtk_color_selection_dialog_get_color_selection() to get the #GtkColorSelection widget contained within the dialog. Use this widget and its gtk_color_selection_get_current_color() function to gain access to the selected color. Connect a handler for this widget’s #GtkColorSelection::color-changed signal to be notified when the color changes. # GtkColorSelectionDialog as GtkBuildable # {#GtkColorSelectionDialog-BUILDER-UI} The GtkColorSelectionDialog implementation of the GtkBuildable interface exposes the embedded #GtkColorSelection as internal child with the name “color_selection”. It also exposes the buttons with the names “ok_button”, “cancel_button” and “help_button”. GTK+ has a rich set of functions for doing inter-process communication via the drag-and-drop metaphor. As well as the functions listed here, applications may need to use some facilities provided for [Selections][gtk3-Selections]. Also, the Drag and Drop API makes use of signals in the #GtkWidget class. GTK+ provides version information, primarily useful in configure checks for builds that have a configure script. Applications will not typically use the features described here. The #GtkFontSelection widget lists the available fonts, styles and sizes, allowing the user to select a font. It is used in the #GtkFontSelectionDialog widget to provide a dialog box for selecting fonts. To set the font which is initially selected, use gtk_font_selection_set_font_name(). To get the selected font use gtk_font_selection_get_font_name(). To change the text which is shown in the preview area, use gtk_font_selection_set_preview_text(). In GTK+ 3.2, #GtkFontSelection has been deprecated in favor of #GtkFontChooser. The #GtkFontSelectionDialog widget is a dialog box for selecting a font. To set the font which is initially selected, use gtk_font_selection_dialog_set_font_name(). To get the selected font use gtk_font_selection_dialog_get_font_name(). To change the text which is shown in the preview area, use gtk_font_selection_dialog_set_preview_text(). In GTK+ 3.2, #GtkFontSelectionDialog has been deprecated in favor of #GtkFontChooserDialog. # GtkFontSelectionDialog as GtkBuildable # {#GtkFontSelectionDialog-BUILDER-UI} The GtkFontSelectionDialog implementation of the GtkBuildable interface exposes the embedded #GtkFontSelection as internal child with the name “font_selection”. It also exposes the buttons with the names “ok_button”, “cancel_button” and “apply_button”. A button box should be used to provide a consistent layout of buttons throughout your application. The layout/spacing can be altered by the programmer, or if desired, by the user to alter the “feel” of a program to a small degree. A #GtkHButtonBox is created with gtk_hbutton_box_new(). Buttons are packed into a button box the same way widgets are added to any other container, using gtk_container_add(). You can also use gtk_box_pack_start() or gtk_box_pack_end(), but for button boxes both these functions work just like gtk_container_add(), ie., they pack the button in a way that depends on the current layout style and on whether the button has had gtk_button_box_set_child_secondary() called on it. The spacing between buttons can be set with gtk_box_set_spacing(). The arrangement and layout of the buttons can be changed with gtk_button_box_set_layout(). GtkHButtonBox has been deprecated, use #GtkButtonBox instead. Before using GTK+, you need to initialize it; initialization connects to the window system display, and parses some standard command line arguments. The gtk_init() macro initializes GTK+. gtk_init() exits the application if errors occur; to avoid this, use gtk_init_check(). gtk_init_check() allows you to recover from a failed GTK+ initialization - you might start up your application in text mode instead. Like all GUI toolkits, GTK+ uses an event-driven programming model. When the user is doing nothing, GTK+ sits in the “main loop” and waits for input. If the user performs some action - say, a mouse click - then the main loop “wakes up” and delivers an event to GTK+. GTK+ forwards the event to one or more widgets. When widgets receive an event, they frequently emit one or more “signals”. Signals notify your program that "something interesting happened" by invoking functions you’ve connected to the signal with g_signal_connect(). Functions connected to a signal are often termed “callbacks”. When your callbacks are invoked, you would typically take some action - for example, when an Open button is clicked you might display a #GtkFileChooserDialog. After a callback finishes, GTK+ will return to the main loop and await more user input. ## Typical main() function for a GTK+ application |[<!-- language="C" --> int main (int argc, char **argv) { GtkWidget *mainwin; // Initialize i18n support with bindtextdomain(), etc. // ... // Initialize the widget set gtk_init (&argc, &argv); // Create the main window mainwin = gtk_window_new (GTK_WINDOW_TOPLEVEL); // Set up our GUI elements // ... // Show the application window gtk_widget_show_all (mainwin); // Enter the main event loop, and wait for user interaction gtk_main (); // The user lost interest return 0; } ]| It’s OK to use the GLib main loop directly instead of gtk_main(), though it involves slightly more typing. See #GMainLoop in the GLib documentation. #GtkPageSetupUnixDialog implements a page setup dialog for platforms which don’t provide a native page setup dialog, like Unix. It can be used very much like any other GTK+ dialog, at the cost of the portability offered by the [high-level printing API][gtk3-High-level-Printing-API] Printing support was added in GTK+ 2.10. #GtkPlacesView is a stock widget that displays a list of persistent drives such as harddisk partitions and networks. #GtkPlacesView does not monitor removable devices. The places view displays drives and networks, and will automatically mount them when the user activates. Network addresses are stored even if they fail to connect. When the connection is successful, the connected network is shown at the network list. To make use of the places view, an application at least needs to connect to the #GtkPlacesView::open-location signal. This is emitted when the user selects a location to open in the view. A #GtkPrinter object represents a printer. You only need to deal directly with printers if you use the non-portable #GtkPrintUnixDialog API. A #GtkPrinter allows to get status information about the printer, such as its description, its location, the number of queued jobs, etc. Most importantly, a #GtkPrinter object can be used to create a #GtkPrintJob object, which lets you print to the printer. Printing support was added in GTK+ 2.10. A #GtkPrintJob object represents a job that is sent to a printer. You only need to deal directly with print jobs if you use the non-portable #GtkPrintUnixDialog API. Use gtk_print_job_get_surface() to obtain the cairo surface onto which the pages must be drawn. Use gtk_print_job_send() to send the finished job to the printer. If you don’t use cairo #GtkPrintJob also supports printing of manually generated postscript, via gtk_print_job_set_source_file(). GtkPrintUnixDialog implements a print dialog for platforms which don’t provide a native print dialog, like Unix. It can be used very much like any other GTK+ dialog, at the cost of the portability offered by the [high-level printing API][gtk3-High-level-Printing-API] In order to print something with #GtkPrintUnixDialog, you need to use gtk_print_unix_dialog_get_selected_printer() to obtain a #GtkPrinter object and use it to construct a #GtkPrintJob using gtk_print_job_new(). #GtkPrintUnixDialog uses the following response values: - %GTK_RESPONSE_OK: for the “Print” button - %GTK_RESPONSE_APPLY: for the “Preview” button - %GTK_RESPONSE_CANCEL: for the “Cancel” button Printing support was added in GTK+ 2.10. # GtkPrintUnixDialog as GtkBuildable The GtkPrintUnixDialog implementation of the GtkBuildable interface exposes its @notebook internal children with the name “notebook”. An example of a #GtkPrintUnixDialog UI definition fragment: |[ <object class="GtkPrintUnixDialog" id="dialog1"> <child internal-child="notebook"> <object class="GtkNotebook" id="notebook"> <child> <object class="GtkLabel" id="tabcontent"> <property name="label">Content on notebook tab</property> </object> </child> <child type="tab"> <object class="GtkLabel" id="tablabel"> <property name="label">Tab label</property> </object> <packing> <property name="tab_expand">False</property> <property name="tab_fill">False</property> </packing> </child> </object> </child> </object> ]| # CSS nodes GtkPrintUnixDialog has a single CSS node with name printdialog. GTK+ provides resource file mechanism for configuring various aspects of the operation of a GTK+ program at runtime. > In GTK+ 3.0, resource files have been deprecated and replaced by > CSS-like style sheets, which are understood by #GtkCssProvider. # Default Files # An application can cause GTK+ to parse a specific RC file by calling gtk_rc_parse(). In addition to this, certain files will be read at the end of gtk_init(). Unless modified, the files looked for will be `SYSCONFDIR/gtk-2.0/gtkrc` and `.gtkrc-3.0` in the users home directory. (`SYSCONFDIR` defaults to `/usr/local/etc`. It can be changed with the `--prefix` or `--sysconfdir` options when configuring GTK+.) The set of these “default” files can be retrieved with gtk_rc_get_default_files() and modified with gtk_rc_add_default_file() and gtk_rc_set_default_files(). Additionally, the `GTK2_RC_FILES` environment variable can be set to a #G_SEARCHPATH_SEPARATOR_S-separated list of files in order to overwrite the set of default files at runtime. # Locale Specific Files # {#locale-specific-rc} For each RC file, in addition to the file itself, GTK+ will look for a locale-specific file that will be parsed after the main file. For instance, if `LANG` is set to `ja_JP.ujis`, when loading the default file `~/.gtkrc` then GTK+ looks for `~/.gtkrc.ja_JP` and `~/.gtkrc.ja`, and parses the first of those that exists. # Pathnames and Patterns # A resource file defines a number of styles and key bindings and attaches them to particular widgets. The attachment is done by the `widget`, `widget_class`, and `class` declarations. As an example of such a statement: |[ widget "mywindow.*.GtkEntry" style "my-entry-class" ]| attaches the style `"my-entry-class"` to all widgets whose “widget path” matches the “pattern” `"mywindow.*.GtkEntry"`. That is, all #GtkEntry widgets which are part of a #GtkWindow named `"mywindow"`. The patterns here are given in the standard shell glob syntax. The `"?"` wildcard matches any character, while `"*"` matches zero or more of any character. The three types of matching are against the widget path, the “class path” and the class hierarchy. Both the widget path and the class path consist of a `"."` separated list of all the parents of the widget and the widget itself from outermost to innermost. The difference is that in the widget path, the name assigned by gtk_widget_set_name() is used if present, otherwise the class name of the widget, while for the class path, the class name is always used. Since GTK+ 2.10, `widget_class` paths can also contain <classname> substrings, which are matching the class with the given name and any derived classes. For instance, |[ widget_class "*<GtkMenuItem>.GtkLabel" style "my-style" ]| will match #GtkLabel widgets which are contained in any kind of menu item. So, if you have a #GtkEntry named `"myentry"`, inside of a horizontal box in a window named `"mywindow"`, then the widget path is: `"mywindow.GtkHBox.myentry"` while the class path is: `"GtkWindow.GtkHBox.GtkEntry"`. Matching against class is a little different. The pattern match is done against all class names in the widgets class hierarchy (not the layout hierarchy) in sequence, so the pattern: |[ class "GtkButton" style "my-style" ]| will match not just #GtkButton widgets, but also #GtkToggleButton and #GtkCheckButton widgets, since those classes derive from #GtkButton. Additionally, a priority can be specified for each pattern, and styles override other styles first by priority, then by pattern type and then by order of specification (later overrides earlier). The priorities that can be specified are (highest to lowest): - `highest` - `rc` - `theme` - `application` - `gtk` - `lowest` `rc` is the default for styles read from an RC file, `theme` is the default for styles read from theme RC files, `application` should be used for styles an application sets up, and `gtk` is used for styles that GTK+ creates internally. # Theme gtkrc Files # Theme RC files are loaded first from under the `~/.themes/`, then from the directory from gtk_rc_get_theme_dir(). The files looked at will be `gtk-3.0/gtkrc`. When the application prefers dark themes (see the #GtkSettings:gtk-application-prefer-dark-theme property for details), `gtk-3.0/gtkrc-dark` will be loaded first, and if not present `gtk-3.0/gtkrc` will be loaded. # Optimizing RC Style Matches # Everytime a widget is created and added to the layout hierarchy of a #GtkWindow ("anchored" to be exact), a list of matching RC styles out of all RC styles read in so far is composed. For this, every RC style is matched against the widgets class path, the widgets name path and widgets inheritance hierarchy. As a consequence, significant slowdown can be caused by utilization of many RC styles and by using RC style patterns that are slow or complicated to match against a given widget. The following ordered list provides a number of advices (prioritized by effectiveness) to reduce the performance overhead associated with RC style matches: 1. Move RC styles for specific applications into RC files dedicated to those applications and parse application specific RC files only from applications that are affected by them. This reduces the overall amount of RC styles that have to be considered for a match across a group of applications. 2. Merge multiple styles which use the same matching rule, for instance: |[ style "Foo" { foo_content } class "X" style "Foo" style "Bar" { bar_content } class "X" style "Bar" ]| is faster to match as: |[ style "FooBar" { foo_content bar_content } class "X" style "FooBar" ]| 3. Use of wildcards should be avoided, this can reduce the individual RC style match to a single integer comparison in most cases. 4. To avoid complex recursive matching, specification of full class names (for `class` matches) or full path names (for `widget` and `widget_class` matches) is to be preferred over shortened names containing `"*"` or `"?"`. 5. If at all necessary, wildcards should only be used at the tail or head of a pattern. This reduces the match complexity to a string comparison per RC style. 6. When using wildcards, use of `"?"` should be preferred over `"*"`. This can reduce the matching complexity from O(n^2) to O(n). For example `"Gtk*Box"` can be turned into `"Gtk?Box"` and will still match #GtkHBox and #GtkVBox. 7. The use of `"*"` wildcards should be restricted as much as possible, because matching `"A*B*C*RestString"` can result in matching complexities of O(n^2) worst case. # Toplevel Declarations # An RC file is a text file which is composed of a sequence of declarations. `“#”` characters delimit comments and the portion of a line after a `“#”` is ignored when parsing an RC file. The possible toplevel declarations are: * `binding name { ... }` Declares a binding set. * `class pattern [ style | binding ][ : priority ] name` Specifies a style or binding set for a particular branch of the inheritance hierarchy. * `include filename` Parses another file at this point. If filename is not an absolute filename, it is searched in the directories of the currently open RC files. GTK+ also tries to load a [locale-specific variant][locale-specific-rc] of the included file. * `module_path path` Sets a path (a list of directories separated by colons) that will be searched for theme engines referenced in RC files. * `pixmap_path path` Sets a path (a list of directories separated by colons) that will be searched for pixmaps referenced in RC files. * `im_module_file pathname` Sets the pathname for the IM modules file. Setting this from RC files is deprecated; you should use the environment variable `GTK_IM_MODULE_FILE` instead. * `style name [ = parent ] { ... }` Declares a style. * `widget pattern [ style | binding ][ : priority ] name` Specifies a style or binding set for a particular group of widgets by matching on the widget pathname. * `widget_class pattern [ style | binding ][ : priority ] name` Specifies a style or binding set for a particular group of widgets by matching on the class pathname. * setting = value Specifies a value for a [setting][GtkSettings]. Note that settings in RC files are overwritten by system-wide settings (which are managed by an XSettings manager on X11). # Styles # A RC style is specified by a `style` declaration in a RC file, and then bound to widgets with a `widget`, `widget_class`, or `class` declaration. All styles applying to a particular widget are composited together with `widget` declarations overriding `widget_class` declarations which, in turn, override `class` declarations. Within each type of declaration, later declarations override earlier ones. Within a `style` declaration, the possible elements are: * `bg[state] = color` Sets the color used for the background of most widgets. * `fg[state] = color` Sets the color used for the foreground of most widgets. * `base[state] = color` Sets the color used for the background of widgets displaying editable text. This color is used for the background of, among others, #GtkTextView, #GtkEntry. * `text[state] = color` Sets the color used for foreground of widgets using `base` for the background color. * `xthickness = number` Sets the xthickness, which is used for various horizontal padding values in GTK+. * `ythickness = number` Sets the ythickness, which is used for various vertical padding values in GTK+. * `bg_pixmap[state] = pixmap` Sets a background pixmap to be used in place of the `bg` color (or for #GtkText, in place of the `base` color. The special value `"<parent>"` may be used to indicate that the widget should use the same background pixmap as its parent. The special value `"<none>"` may be used to indicate no background pixmap. * `font = font` Starting with GTK+ 2.0, the “font” and “fontset” declarations are ignored; use “font_name” declarations instead. * `fontset = font` Starting with GTK+ 2.0, the “font” and “fontset” declarations are ignored; use “font_name” declarations instead. * `font_name = font` Sets the font for a widget. font must be a Pango font name, e.g. “Sans Italic 10” . For details about Pango font names, see pango_font_description_from_string(). * `stock["stock-id"] = { icon source specifications }` Defines the icon for a stock item. * `color["color-name"] = color specification` Since 2.10, this element can be used to defines symbolic colors. See below for the syntax of color specifications. * `engine "engine" { engine-specific settings }` Defines the engine to be used when drawing with this style. * `class::property = value` Sets a [style property][style-properties] for a widget class. The colors and background pixmaps are specified as a function of the state of the widget. The states are: * `NORMAL` A color used for a widget in its normal state. * `ACTIVE` A variant of the `NORMAL` color used when the widget is in the %GTK_STATE_ACTIVE state, and also for the trough of a ScrollBar, tabs of a NoteBook other than the current tab and similar areas. Frequently, this should be a darker variant of the `NORMAL` color. * `PRELIGHT` A color used for widgets in the %GTK_STATE_PRELIGHT state. This state is the used for Buttons and MenuItems that have the mouse cursor over them, and for their children. * `SELECTED` A color used to highlight data selected by the user. for instance, the selected items in a list widget, and the selection in an editable widget. * `INSENSITIVE` A color used for the background of widgets that have been set insensitive with gtk_widget_set_sensitive(). ## Color Format ## {#color-format} Colors can be specified as a string containing a color name (GTK+ knows all names from the X color database `/usr/lib/X11/rgb.txt`), in one of the hexadecimal forms `#rrrrggggbbbb`, `#rrrgggbbb`, `#rrggbb`, or `#rgb`, where `r`, `g` and `b` are hex digits, or they can be specified as a triplet `{ r, g, b}`, where `r`, `g` and `b` are either integers in the range 0-65535 or floats in the range 0.0-1.0. Since 2.10, colors can also be specified by refering to a symbolic color, as follows: `@color-name`, or by using expressions to combine colors. The following expressions are currently supported: * mix (factor, color1, color2) Computes a new color by mixing color1 and color2. The factor determines how close the new color is to color1. A factor of 1.0 gives pure color1, a factor of 0.0 gives pure color2. * shade (factor, color) Computes a lighter or darker variant of color. A factor of 1.0 leaves the color unchanged, smaller factors yield darker colors, larger factors yield lighter colors. * lighter (color) This is an abbreviation for `shade (1.3, color)`. * darker (color) This is an abbreviation for `shade (0.7, color)`. Here are some examples of color expressions: |[ mix (0.5, "red", "blue") shade (1.5, mix (0.3, "#0abbc0", { 0.3, 0.5, 0.9 })) lighter (@foreground) ]| In a `stock` definition, icon sources are specified as a 4-tuple of image filename or icon name, text direction, widget state, and size, in that order. Each icon source specifies an image filename or icon name to use with a given direction, state, and size. Filenames are specified as a string such as `"itemltr.png"`, while icon names (looked up in the current icon theme), are specified with a leading `@`, such as `@"item-ltr"`. The `*` character can be used as a wildcard, and if direction/state/size are omitted they default to `*`. So for example, the following specifies different icons to use for left-to-right and right-to-left languages: |[<!-- language="C" --> stock["my-stock-item"] = { { "itemltr.png", LTR, *, * }, { "itemrtl.png", RTL, *, * } } ]| This could be abbreviated as follows: |[<!-- language="C" --> stock["my-stock-item"] = { { "itemltr.png", LTR }, { "itemrtl.png", RTL } } ]| You can specify custom icons for specific sizes, as follows: |[<!-- language="C" --> stock["my-stock-item"] = { { "itemmenusize.png", *, *, "gtk-menu" }, { "itemtoolbarsize.png", *, *, "gtk-large-toolbar" } { "itemgeneric.png" } // implicit *, *, * as a fallback } ]| The sizes that come with GTK+ itself are `"gtk-menu"`, `"gtk-small-toolbar"`, `"gtk-large-toolbar"`, `"gtk-button"`, `"gtk-dialog"`. Applications can define other sizes. It’s also possible to use custom icons for a given state, for example: |[<!-- language="C" --> stock["my-stock-item"] = { { "itemprelight.png", *, PRELIGHT }, { "iteminsensitive.png", *, INSENSITIVE }, { "itemgeneric.png" } // implicit *, *, * as a fallback } ]| When selecting an icon source to use, GTK+ will consider text direction most important, state second, and size third. It will select the best match based on those criteria. If an attribute matches exactly (e.g. you specified `PRELIGHT` or specified the size), GTK+ won’t modify the image; if the attribute matches with a wildcard, GTK+ will scale or modify the image to match the state and size the user requested. # Key bindings # Key bindings allow the user to specify actions to be taken on particular key presses. The form of a binding set declaration is: |[ binding name { bind key { signalname (param, ...) ... } ... } ]| `key` is a string consisting of a series of modifiers followed by the name of a key. The modifiers can be: - `<alt>` - `<ctl>` - `<control>` - `<meta>` - `<hyper>` - `<super>` - `<mod1>` - `<mod2>` - `<mod3>` - `<mod4>` - `<mod5>` - `<release>` - `<shft>` - `<shift>` `<shft>` is an alias for `<shift>`, `<ctl>` is an alias for `<control>`, and `<alt>` is an alias for `<mod1>`. The action that is bound to the key is a sequence of signal names (strings) followed by parameters for each signal. The signals must be action signals. (See g_signal_new()). Each parameter can be a float, integer, string, or unquoted string representing an enumeration value. The types of the parameters specified must match the types of the parameters of the signal. Binding sets are connected to widgets in the same manner as styles, with one difference: Binding sets override other binding sets first by pattern type, then by priority and then by order of specification. The priorities that can be specified and their default values are the same as for styles. The selection mechanism provides the basis for different types of communication between processes. In particular, drag and drop and #GtkClipboard work via selections. You will very seldom or never need to use most of the functions in this section directly; #GtkClipboard provides a nicer interface to the same functionality. If an application is expected to exchange image data and work on Windows, it is highly advised to support at least "image/bmp" target for the widest possible compatibility with third-party applications. #GtkClipboard already does that by using gtk_target_list_add_image_targets() and gtk_selection_data_set_pixbuf() or gtk_selection_data_get_pixbuf(), which is one of the reasons why it is advised to use #GtkClipboard. Some of the datatypes defined this section are used in the #GtkClipboard and drag-and-drop API’s as well. The #GtkTargetEntry and #GtkTargetList objects represent lists of data types that are supported when sending or receiving data. The #GtkSelectionData object is used to store a chunk of data along with the data type and other associated information. > Since GTK+ 3.10, stock items are deprecated. You should instead set > up whatever labels and/or icons you need using normal widget API, > rather than relying on GTK+ providing ready-made combinations of these. Stock items represent commonly-used menu or toolbar items such as “Open” or “Exit”. Each stock item is identified by a stock ID; stock IDs are just strings, but macros such as #GTK_STOCK_OPEN are provided to avoid typing mistakes in the strings. Applications can register their own stock items in addition to those built-in to GTK+. Each stock ID can be associated with a #GtkStockItem, which contains the user-visible label, keyboard accelerator, and translation domain of the menu or toolbar item; and/or with an icon stored in a #GtkIconFactory. The connection between a #GtkStockItem and stock icons is purely conventional (by virtue of using the same stock ID); it’s possible to register a stock item but no icon, and vice versa. Stock icons may have a RTL variant which gets used for right-to-left locales. GTK+ supports Drag-and-Drop in tree views with a high-level and a low-level API. The low-level API consists of the GTK+ DND API, augmented by some treeview utility functions: gtk_tree_view_set_drag_dest_row(), gtk_tree_view_get_drag_dest_row(), gtk_tree_view_get_dest_row_at_pos(), gtk_tree_view_create_row_drag_icon(), gtk_tree_set_row_drag_data() and gtk_tree_get_row_drag_data(). This API leaves a lot of flexibility, but nothing is done automatically, and implementing advanced features like hover-to-open-rows or autoscrolling on top of this API is a lot of work. On the other hand, if you write to the high-level API, then all the bookkeeping of rows is done for you, as well as things like hover-to-open and auto-scroll, but your models have to implement the #GtkTreeDragSource and #GtkTreeDragDest interfaces. A button box should be used to provide a consistent layout of buttons throughout your application. The layout/spacing can be altered by the programmer, or if desired, by the user to alter the “feel” of a program to a small degree. A #GtkVButtonBox is created with gtk_vbutton_box_new(). Buttons are packed into a button box the same way widgets are added to any other container, using gtk_container_add(). You can also use gtk_box_pack_start() or gtk_box_pack_end(), but for button boxes both these functions work just like gtk_container_add(), ie., they pack the button in a way that depends on the current layout style and on whether the button has had gtk_button_box_set_child_secondary() called on it. The spacing between buttons can be set with gtk_box_set_spacing(). The arrangement and layout of the buttons can be changed with gtk_button_box_set_layout(). GtkVButtonBox has been deprecated, use #GtkButtonBox instead. Looks up the icon size associated with @name. Use #GtkIconTheme instead. the icon size (#GtkIconSize) the name to look up. Gets the canonical name of the given icon size. The returned string is statically allocated and should not be freed. Use #GtkIconTheme instead. the name of the given icon size. a #GtkIconSize. Obtains the pixel size of a semantic icon size @size: #GTK_ICON_SIZE_MENU, #GTK_ICON_SIZE_BUTTON, etc. This function isn’t normally needed, gtk_icon_theme_load_icon() is the usual way to get an icon for rendering, then just look at the size of the rendered pixbuf. The rendered pixbuf may not even correspond to the width/height returned by gtk_icon_size_lookup(), because themes are free to render the pixbuf however they like, including changing the usual size. %TRUE if @size was a valid size an icon size (#GtkIconSize) location to store icon width location to store icon height Obtains the pixel size of a semantic icon size, possibly modified by user preferences for a particular #GtkSettings. Normally @size would be #GTK_ICON_SIZE_MENU, #GTK_ICON_SIZE_BUTTON, etc. This function isn’t normally needed, gtk_widget_render_icon_pixbuf() is the usual way to get an icon for rendering, then just look at the size of the rendered pixbuf. The rendered pixbuf may not even correspond to the width/height returned by gtk_icon_size_lookup(), because themes are free to render the pixbuf however they like, including changing the usual size. Use gtk_icon_size_lookup() instead. %TRUE if @size was a valid size a #GtkSettings object, used to determine which set of user preferences to used. an icon size (#GtkIconSize) location to store icon width location to store icon height Registers a new icon size, along the same lines as #GTK_ICON_SIZE_MENU, etc. Returns the integer value for the size. Use #GtkIconTheme instead. integer value representing the size (#GtkIconSize) name of the icon size the icon width the icon height Registers @alias as another name for @target. So calling gtk_icon_size_from_name() with @alias as argument will return @target. Use #GtkIconTheme instead. an alias for @target an existing icon size (#GtkIconSize) Call this function before using any other GTK+ functions in your GUI applications. It will initialize everything needed to operate the toolkit and parses some standard command line options. Although you are expected to pass the @argc, @argv parameters from main() to this function, it is possible to pass %NULL if @argv is not available or commandline handling is not required. @argc and @argv are adjusted accordingly so your own code will never see those standard arguments. Note that there are some alternative ways to initialize GTK+: if you are calling gtk_parse_args(), gtk_init_check(), gtk_init_with_args() or g_option_context_parse() with the option group returned by gtk_get_option_group(), you don’t have to call gtk_init(). And if you are using #GtkApplication, you don't have to call any of the initialization functions either; the #GtkApplication::startup handler does it for you. This function will terminate your program if it was unable to initialize the windowing system for some reason. If you want your program to fall back to a textual interface you want to call gtk_init_check() instead. Since 2.18, GTK+ calls `signal (SIGPIPE, SIG_IGN)` during initialization, to ignore SIGPIPE signals, since these are almost never wanted in graphical applications. If you do need to handle SIGPIPE for some reason, reset the handler after gtk_init(), but notice that other libraries (e.g. libdbus or gvfs) might do similar things. Address of the `argc` parameter of your main() function (or 0 if @argv is %NULL). This will be changed if any arguments were handled. Address of the `argv` parameter of main(), or %NULL. Any options understood by GTK+ are stripped before return. This function does the same work as gtk_init() with only a single change: It does not terminate the program if the commandline arguments couldn’t be parsed or the windowing system can’t be initialized. Instead it returns %FALSE on failure. This way the application can fall back to some other means of communication with the user - for example a curses or command line interface. Note that calling any GTK function or instantiating any GTK type after this function returns %FALSE results in undefined behavior. %TRUE if the commandline arguments (if any) were valid and the windowing system has been successfully initialized, %FALSE otherwise Address of the `argc` parameter of your main() function (or 0 if @argv is %NULL). This will be changed if any arguments were handled. Address of the `argv` parameter of main(), or %NULL. Any options understood by GTK+ are stripped before return. This function does the same work as gtk_init_check(). Additionally, it allows you to add your own commandline options, and it automatically generates nicely formatted `--help` output. Note that your program will be terminated after writing out the help output. %TRUE if the commandline arguments (if any) were valid and if the windowing system has been successfully initialized, %FALSE otherwise Address of the `argc` parameter of your main() function (or 0 if @argv is %NULL). This will be changed if any arguments were handled. Address of the `argv` parameter of main(), or %NULL. Any options understood by GTK+ are stripped before return. a string which is displayed in the first line of `--help` output, after `programname [OPTION...]` a %NULL-terminated array of #GOptionEntrys describing the options of your program a translation domain to use for translating the `--help` output for the options in @entries and the @parameter_string with gettext(), or %NULL Installs a key snooper function, which will get called on all key events before delivering them normally. Key snooping should not be done. Events should be handled by widgets. a unique id for this key snooper for use with gtk_key_snooper_remove(). a #GtkKeySnoopFunc data to pass to @snooper Removes the key snooper function with the given id. Key snooping should not be done. Events should be handled by widgets. Identifies the key snooper to remove Runs the main loop until gtk_main_quit() is called. You can nest calls to gtk_main(). In that case gtk_main_quit() will make the innermost invocation of the main loop return. Processes a single GDK event. This is public only to allow filtering of events between GDK and GTK+. You will not usually need to call this function directly. While you should not call this function directly, you might want to know how exactly events are handled. So here is what this function does with the event: 1. Compress enter/leave notify events. If the event passed build an enter/leave pair together with the next event (peeked from GDK), both events are thrown away. This is to avoid a backlog of (de-)highlighting widgets crossed by the pointer. 2. Find the widget which got the event. If the widget can’t be determined the event is thrown away unless it belongs to a INCR transaction. 3. Then the event is pushed onto a stack so you can query the currently handled event with gtk_get_current_event(). 4. The event is sent to a widget. If a grab is active all events for widgets that are not in the contained in the grab widget are sent to the latter with a few exceptions: - Deletion and destruction events are still sent to the event widget for obvious reasons. - Events which directly relate to the visual representation of the event widget. - Leave events are delivered to the event widget if there was an enter event delivered to it before without the paired leave event. - Drag events are not redirected because it is unclear what the semantics of that would be. Another point of interest might be that all key events are first passed through the key snooper functions if there are any. Read the description of gtk_key_snooper_install() if you need this feature. 5. After finishing the delivery the event is popped from the event stack. An event to process (normally passed by GDK) Runs a single iteration of the mainloop. If no events are waiting to be processed GTK+ will block until the next event is noticed. If you don’t want to block look at gtk_main_iteration_do() or check if any events are pending with gtk_events_pending() first. %TRUE if gtk_main_quit() has been called for the innermost mainloop Runs a single iteration of the mainloop. If no events are available either return or block depending on the value of @blocking. %TRUE if gtk_main_quit() has been called for the innermost mainloop %TRUE if you want GTK+ to block if no events are pending Asks for the current nesting level of the main loop. the nesting level of the current invocation of the main loop Makes the innermost invocation of the main loop return when it regains control. Draws an arrow in the given rectangle on @cr using the given parameters. @arrow_type determines the direction of the arrow. Use gtk_render_arrow() instead a #GtkStyle a #cairo_t a state the type of shadow to draw the widget a style detail the type of arrow to draw %TRUE if the arrow tip should be filled x origin of the rectangle to draw the arrow in y origin of the rectangle to draw the arrow in width of the rectangle to draw the arrow in height of the rectangle to draw the arrow in Draws a box on @cr with the given parameters. Use gtk_render_frame() and gtk_render_background() instead a #GtkStyle a #cairo_t a state the type of shadow to draw the widget a style detail x origin of the box y origin of the box the width of the box the height of the box Draws a box in @cr using the given style and state and shadow type, leaving a gap in one side. Use gtk_render_frame_gap() instead a #GtkStyle a #cairo_t a state type of shadow to draw the widget a style detail x origin of the rectangle y origin of the rectangle width of the rectangle width of the rectangle side in which to leave the gap starting position of the gap width of the gap Draws a check button indicator in the given rectangle on @cr with the given parameters. Use gtk_render_check() instead a #GtkStyle a #cairo_t a state the type of shadow to draw the widget a style detail x origin of the rectangle to draw the check in y origin of the rectangle to draw the check in the width of the rectangle to draw the check in the height of the rectangle to draw the check in Draws a diamond in the given rectangle on @window using the given parameters. Use cairo instead a #GtkStyle a #cairo_t a state the type of shadow to draw the widget a style detail x origin of the rectangle to draw the diamond in y origin of the rectangle to draw the diamond in width of the rectangle to draw the diamond in height of the rectangle to draw the diamond in Draws an expander as used in #GtkTreeView. @x and @y specify the center the expander. The size of the expander is determined by the “expander-size” style property of @widget. (If widget is not specified or doesn’t have an “expander-size” property, an unspecified default size will be used, since the caller doesn't have sufficient information to position the expander, this is likely not useful.) The expander is expander_size pixels tall in the collapsed position and expander_size pixels wide in the expanded position. Use gtk_render_expander() instead a #GtkStyle a #cairo_t a state the widget a style detail the x position to draw the expander at the y position to draw the expander at the style to draw the expander in; determines whether the expander is collapsed, expanded, or in an intermediate state. Draws an extension, i.e. a notebook tab. Use gtk_render_extension() instead a #GtkStyle a #cairo_t a state type of shadow to draw the widget a style detail x origin of the extension y origin of the extension width of the extension width of the extension the side on to which the extension is attached Draws a flat box on @cr with the given parameters. Use gtk_render_frame() and gtk_render_background() instead a #GtkStyle a #cairo_t a state the type of shadow to draw the widget a style detail x origin of the box y origin of the box the width of the box the height of the box Draws a focus indicator around the given rectangle on @cr using the given style. Use gtk_render_focus() instead a #GtkStyle a #cairo_t a state the widget a style detail the x origin of the rectangle around which to draw a focus indicator the y origin of the rectangle around which to draw a focus indicator the width of the rectangle around which to draw a focus indicator the height of the rectangle around which to draw a focus indicator Draws a handle as used in #GtkHandleBox and #GtkPaned. Use gtk_render_handle() instead a #GtkStyle a #cairo_t a state type of shadow to draw the widget a style detail x origin of the handle y origin of the handle with of the handle height of the handle the orientation of the handle Draws a horizontal line from (@x1, @y) to (@x2, @y) in @cr using the given style and state. Use gtk_render_line() instead a #GtkStyle a #caio_t a state the widget a style detail the starting x coordinate the ending x coordinate the y coordinate Draws a layout on @cr using the given parameters. Use gtk_render_layout() instead a #GtkStyle a #cairo_t a state whether to use the text or foreground graphics context of @style the widget a style detail x origin y origin the layout to draw Draws a radio button indicator in the given rectangle on @cr with the given parameters. Use gtk_render_option() instead a #GtkStyle a #cairo_t a state the type of shadow to draw the widget a style detail x origin of the rectangle to draw the option in y origin of the rectangle to draw the option in the width of the rectangle to draw the option in the height of the rectangle to draw the option in Draws a resize grip in the given rectangle on @cr using the given parameters. Use gtk_render_handle() instead a #GtkStyle a #cairo_t a state the widget a style detail the edge in which to draw the resize grip the x origin of the rectangle in which to draw the resize grip the y origin of the rectangle in which to draw the resize grip the width of the rectangle in which to draw the resize grip the height of the rectangle in which to draw the resize grip Draws a shadow around the given rectangle in @cr using the given style and state and shadow type. Use gtk_render_frame() instead a #GtkStyle a #cairo_t a state type of shadow to draw the widget a style detail x origin of the rectangle y origin of the rectangle width of the rectangle width of the rectangle Draws a shadow around the given rectangle in @cr using the given style and state and shadow type, leaving a gap in one side. Use gtk_render_frame_gap() instead a #GtkStyle a #cairo_t a state type of shadow to draw the widget a style detail x origin of the rectangle y origin of the rectangle width of the rectangle width of the rectangle side in which to leave the gap starting position of the gap width of the gap Draws a slider in the given rectangle on @cr using the given style and orientation. Use gtk_render_slider() instead a #GtkStyle a #cairo_t a state a shadow the widget a style detail the x origin of the rectangle in which to draw a slider the y origin of the rectangle in which to draw a slider the width of the rectangle in which to draw a slider the height of the rectangle in which to draw a slider the orientation to be used Draws a spinner on @window using the given parameters. Use gtk_render_icon() and the #GtkStyleContext you are drawing instead a #GtkStyle a #cairo_t a state the widget (may be %NULL) a style detail (may be %NULL) the nth step the x origin of the rectangle in which to draw the spinner the y origin of the rectangle in which to draw the spinner the width of the rectangle in which to draw the spinner the height of the rectangle in which to draw the spinner Draws an option menu tab (i.e. the up and down pointing arrows) in the given rectangle on @cr using the given parameters. Use cairo instead a #GtkStyle a #cairo_t a state the type of shadow to draw the widget a style detail x origin of the rectangle to draw the tab in y origin of the rectangle to draw the tab in the width of the rectangle to draw the tab in the height of the rectangle to draw the tab in Draws a vertical line from (@x, @y1_) to (@x, @y2_) in @cr using the given style and state. Use gtk_render_line() instead a #GtkStyle a #cairo_t a state the widget a style detail the starting y coordinate the ending y coordinate the x coordinate Returns the name of the default paper size, which depends on the current locale. the name of the default paper size. The string is owned by GTK+ and should not be modified. Creates a list of known paper sizes. a newly allocated list of newly allocated #GtkPaperSize objects whether to include custom paper sizes as defined in the page setup dialog Parses command line arguments, and initializes global attributes of GTK+, but does not actually open a connection to a display. (See gdk_display_open(), gdk_get_display_arg_name()) Any arguments used by GTK+ or GDK are removed from the array and @argc and @argv are updated accordingly. There is no need to call this function explicitly if you are using gtk_init(), or gtk_init_check(). Note that many aspects of GTK+ require a display connection to function, so this way of initializing GTK+ is really only useful for specialized use cases. %TRUE if initialization succeeded, otherwise %FALSE a pointer to the number of command line arguments a pointer to the array of command line arguments Registers an error quark for #GtkPrintOperation if necessary. The error quark used for #GtkPrintOperation errors. Runs a page setup dialog, letting the user modify the values from @page_setup. If the user cancels the dialog, the returned #GtkPageSetup is identical to the passed in @page_setup, otherwise it contains the modifications done in the dialog. Note that this function may use a recursive mainloop to show the page setup dialog. See gtk_print_run_page_setup_dialog_async() if this is a problem. a new #GtkPageSetup transient parent an existing #GtkPageSetup a #GtkPrintSettings Runs a page setup dialog, letting the user modify the values from @page_setup. In contrast to gtk_print_run_page_setup_dialog(), this function returns after showing the page setup dialog on platforms that support this, and calls @done_cb from a signal handler for the ::response signal of the dialog. transient parent, or %NULL an existing #GtkPageSetup, or %NULL a #GtkPrintSettings a function to call when the user saves the modified page setup user data to pass to @done_cb Sends an event to a widget, propagating the event to parent widgets if the event remains unhandled. Events received by GTK+ from GDK normally begin in gtk_main_do_event(). Depending on the type of event, existence of modal dialogs, grabs, etc., the event may be propagated; if so, this function is used. gtk_propagate_event() calls gtk_widget_event() on each widget it decides to send the event to. So gtk_widget_event() is the lowest-level function; it simply emits the #GtkWidget::event and possibly an event-specific signal on a widget. gtk_propagate_event() is a bit higher-level, and gtk_main_do_event() is the highest level. All that said, you most likely don’t want to use any of these functions; synthesizing events is rarely needed. There are almost certainly better ways to achieve your goals. For example, use gdk_window_invalidate_rect() or gtk_widget_queue_draw() instead of making up expose events. a #GtkWidget an event Adds a file to the list of files to be parsed at the end of gtk_init(). Use #GtkStyleContext with a custom #GtkStyleProvider instead the pathname to the file. If @filename is not absolute, it is searched in the current directory. Searches for a theme engine in the GTK+ search path. This function is not useful for applications and should not be used. Use #GtkCssProvider instead. The filename, if found (must be freed with g_free()), otherwise %NULL. name of a theme engine Looks up a file in pixmap path for the specified #GtkSettings. If the file is not found, it outputs a warning message using g_warning() and returns %NULL. Use #GtkCssProvider instead. the filename. a #GtkSettings Scanner used to get line number information for the warning message, or %NULL name of the pixmap file to locate. Retrieves the current list of RC files that will be parsed at the end of gtk_init(). Use #GtkStyleContext instead A %NULL-terminated array of filenames. This memory is owned by GTK+ and must not be freed by the application. If you want to store this information, you should make a copy. Obtains the path to the IM modules file. See the documentation of the `GTK_IM_MODULE_FILE` environment variable for more details. Use #GtkCssProvider instead. a newly-allocated string containing the name of the file listing the IM modules available for loading Obtains the path in which to look for IM modules. See the documentation of the `GTK_PATH` environment variable for more details about looking up modules. This function is useful solely for utilities supplied with GTK+ and should not be used by applications under normal circumstances. Use #GtkCssProvider instead. a newly-allocated string containing the path in which to look for IM modules. Returns a directory in which GTK+ looks for theme engines. For full information about the search for theme engines, see the docs for `GTK_PATH` in [Running GTK+ Applications][gtk-running]. Use #GtkCssProvider instead. the directory. (Must be freed with g_free()) Finds all matching RC styles for a given widget, composites them together, and then creates a #GtkStyle representing the composite appearance. (GTK+ actually keeps a cache of previously created styles, so a new style may not be created.) Use #GtkStyleContext instead the resulting style. No refcount is added to the returned style, so if you want to save this style around, you should add a reference yourself. a #GtkWidget Creates up a #GtkStyle from styles defined in a RC file by providing the raw components used in matching. This function may be useful when creating pseudo-widgets that should be themed like widgets but don’t actually have corresponding GTK+ widgets. An example of this would be items inside a GNOME canvas widget. The action of gtk_rc_get_style() is similar to: |[<!-- language="C" --> gtk_widget_path (widget, NULL, &path, NULL); gtk_widget_class_path (widget, NULL, &class_path, NULL); gtk_rc_get_style_by_paths (gtk_widget_get_settings (widget), path, class_path, G_OBJECT_TYPE (widget)); ]| Use #GtkStyleContext instead A style created by matching with the supplied paths, or %NULL if nothing matching was specified and the default style should be used. The returned value is owned by GTK+ as part of an internal cache, so you must call g_object_ref() on the returned value if you want to keep a reference to it. a #GtkSettings object the widget path to use when looking up the style, or %NULL if no matching against the widget path should be done the class path to use when looking up the style, or %NULL if no matching against the class path should be done. a type that will be used along with parent types of this type when matching against class styles, or #G_TYPE_NONE Returns the standard directory in which themes should be installed. (GTK+ does not actually use this directory itself.) Use #GtkCssProvider instead. The directory (must be freed with g_free()). Parses a given resource file. Use #GtkCssProvider instead. the filename of a file to parse. If @filename is not absolute, it is searched in the current directory. Parses a color in the format expected in a RC file. Note that theme engines should use gtk_rc_parse_color_full() in order to support symbolic colors. Use #GtkCssProvider instead %G_TOKEN_NONE if parsing succeeded, otherwise the token that was expected but not found a #GScanner a pointer to a #GdkColor in which to store the result Parses a color in the format expected in a RC file. If @style is not %NULL, it will be consulted to resolve references to symbolic colors. Use #GtkCssProvider instead %G_TOKEN_NONE if parsing succeeded, otherwise the token that was expected but not found a #GScanner a #GtkRcStyle, or %NULL a pointer to a #GdkColor in which to store the result Parses a #GtkPathPriorityType variable from the format expected in a RC file. Use #GtkCssProvider instead %G_TOKEN_NONE if parsing succeeded, otherwise the token that was expected but not found. a #GScanner (must be initialized for parsing an RC file) A pointer to #GtkPathPriorityType variable in which to store the result. Parses a #GtkStateType variable from the format expected in a RC file. Use #GtkCssProvider instead %G_TOKEN_NONE if parsing succeeded, otherwise the token that was expected but not found. a #GScanner (must be initialized for parsing an RC file) A pointer to a #GtkStateType variable in which to store the result. Parses resource information directly from a string. Use #GtkCssProvider instead. a string to parse. A #GtkRcPropertyParser for use with gtk_settings_install_property_parser() or gtk_widget_class_install_style_property_parser() which parses borders in the form `"{ left, right, top, bottom }"` for integers left, right, top and bottom. %TRUE if @gstring could be parsed and @property_value has been set to the resulting #GtkBorder. a #GParamSpec the #GString to be parsed a #GValue which must hold boxed values. A #GtkRcPropertyParser for use with gtk_settings_install_property_parser() or gtk_widget_class_install_style_property_parser() which parses a color given either by its name or in the form `{ red, green, blue }` where red, green and blue are integers between 0 and 65535 or floating-point numbers between 0 and 1. %TRUE if @gstring could be parsed and @property_value has been set to the resulting #GdkColor. a #GParamSpec the #GString to be parsed a #GValue which must hold #GdkColor values. A #GtkRcPropertyParser for use with gtk_settings_install_property_parser() or gtk_widget_class_install_style_property_parser() which parses a single enumeration value. The enumeration value can be specified by its name, its nickname or its numeric value. For consistency with flags parsing, the value may be surrounded by parentheses. %TRUE if @gstring could be parsed and @property_value has been set to the resulting #GEnumValue. a #GParamSpec the #GString to be parsed a #GValue which must hold enum values. A #GtkRcPropertyParser for use with gtk_settings_install_property_parser() or gtk_widget_class_install_style_property_parser() which parses flags. Flags can be specified by their name, their nickname or numerically. Multiple flags can be specified in the form `"( flag1 | flag2 | ... )"`. %TRUE if @gstring could be parsed and @property_value has been set to the resulting flags value. a #GParamSpec the #GString to be parsed a #GValue which must hold flags values. A #GtkRcPropertyParser for use with gtk_settings_install_property_parser() or gtk_widget_class_install_style_property_parser() which parses a requisition in the form `"{ width, height }"` for integers %width and %height. %TRUE if @gstring could be parsed and @property_value has been set to the resulting #GtkRequisition. a #GParamSpec the #GString to be parsed a #GValue which must hold boxed values. If the modification time on any previously read file for the default #GtkSettings has changed, discard all style information and then reread all previously read RC files. Use #GtkCssProvider instead. %TRUE if the files were reread. If the modification time on any previously read file for the given #GtkSettings has changed, discard all style information and then reread all previously read RC files. Use #GtkCssProvider instead. %TRUE if the files were reread. a #GtkSettings load whether or not anything changed This function recomputes the styles for all widgets that use a particular #GtkSettings object. (There is one #GtkSettings object per #GdkScreen, see gtk_settings_get_for_screen()); It is useful when some global parameter has changed that affects the appearance of all widgets, because when a widget gets a new style, it will both redraw and recompute any cached information about its appearance. As an example, it is used when the default font size set by the operating system changes. Note that this function doesn’t affect widgets that have a style set explicitly on them with gtk_widget_set_style(). Use #GtkCssProvider instead. a #GtkSettings Use #GtkCssProvider instead Sets the list of files that GTK+ will read at the end of gtk_init(). Use #GtkStyleContext with a custom #GtkStyleProvider instead A %NULL-terminated list of filenames. Renders an activity indicator (such as in #GtkSpinner). The state %GTK_STATE_FLAG_CHECKED determines whether there is activity going on. a #GtkStyleContext a #cairo_t X origin of the rectangle Y origin of the rectangle rectangle width rectangle height Renders an arrow pointing to @angle. Typical arrow rendering at 0, 1⁄2 π;, π; and 3⁄2 π: ![](arrows.png) a #GtkStyleContext a #cairo_t arrow angle from 0 to 2 * %G_PI, being 0 the arrow pointing to the north X origin of the render area Y origin of the render area square side for render area Renders the background of an element. Typical background rendering, showing the effect of `background-image`, `border-width` and `border-radius`: ![](background.png) a #GtkStyleContext a #cairo_t X origin of the rectangle Y origin of the rectangle rectangle width rectangle height Returns the area that will be affected (i.e. drawn to) when calling gtk_render_background() for the given @context and rectangle. a #GtkStyleContext X origin of the rectangle Y origin of the rectangle rectangle width rectangle height return location for the clip Renders a checkmark (as in a #GtkCheckButton). The %GTK_STATE_FLAG_CHECKED state determines whether the check is on or off, and %GTK_STATE_FLAG_INCONSISTENT determines whether it should be marked as undefined. Typical checkmark rendering: ![](checks.png) a #GtkStyleContext a #cairo_t X origin of the rectangle Y origin of the rectangle rectangle width rectangle height Renders an expander (as used in #GtkTreeView and #GtkExpander) in the area defined by @x, @y, @width, @height. The state %GTK_STATE_FLAG_CHECKED determines whether the expander is collapsed or expanded. Typical expander rendering: ![](expanders.png) a #GtkStyleContext a #cairo_t X origin of the rectangle Y origin of the rectangle rectangle width rectangle height Renders a extension (as in a #GtkNotebook tab) in the rectangle defined by @x, @y, @width, @height. The side where the extension connects to is defined by @gap_side. Typical extension rendering: ![](extensions.png) a #GtkStyleContext a #cairo_t X origin of the rectangle Y origin of the rectangle rectangle width rectangle height side where the gap is Renders a focus indicator on the rectangle determined by @x, @y, @width, @height. Typical focus rendering: ![](focus.png) a #GtkStyleContext a #cairo_t X origin of the rectangle Y origin of the rectangle rectangle width rectangle height Renders a frame around the rectangle defined by @x, @y, @width, @height. Examples of frame rendering, showing the effect of `border-image`, `border-color`, `border-width`, `border-radius` and junctions: ![](frames.png) a #GtkStyleContext a #cairo_t X origin of the rectangle Y origin of the rectangle rectangle width rectangle height Renders a frame around the rectangle defined by (@x, @y, @width, @height), leaving a gap on one side. @xy0_gap and @xy1_gap will mean X coordinates for %GTK_POS_TOP and %GTK_POS_BOTTOM gap sides, and Y coordinates for %GTK_POS_LEFT and %GTK_POS_RIGHT. Typical rendering of a frame with a gap: ![](frame-gap.png) Use gtk_render_frame() instead. Themes can create gaps by omitting borders via CSS. a #GtkStyleContext a #cairo_t X origin of the rectangle Y origin of the rectangle rectangle width rectangle height side where the gap is initial coordinate (X or Y depending on @gap_side) for the gap end coordinate (X or Y depending on @gap_side) for the gap Renders a handle (as in #GtkHandleBox, #GtkPaned and #GtkWindow’s resize grip), in the rectangle determined by @x, @y, @width, @height. Handles rendered for the paned and grip classes: ![](handles.png) a #GtkStyleContext a #cairo_t X origin of the rectangle Y origin of the rectangle rectangle width rectangle height Renders the icon in @pixbuf at the specified @x and @y coordinates. This function will render the icon in @pixbuf at exactly its size, regardless of scaling factors, which may not be appropriate when drawing on displays with high pixel densities. You probably want to use gtk_render_icon_surface() instead, if you already have a Cairo surface. a #GtkStyleContext a #cairo_t a #GdkPixbuf containing the icon to draw X position for the @pixbuf Y position for the @pixbuf Renders the icon specified by @source at the given @size, returning the result in a pixbuf. Use gtk_icon_theme_load_icon() instead. a newly-created #GdkPixbuf containing the rendered icon a #GtkStyleContext the #GtkIconSource specifying the icon to render the size (#GtkIconSize) to render the icon at. A size of `(GtkIconSize) -1` means render at the size of the source and don’t scale. Renders the icon in @surface at the specified @x and @y coordinates. a #GtkStyleContext a #cairo_t a #cairo_surface_t containing the icon to draw X position for the @icon Y position for the @incon Draws a text caret on @cr at the specified index of @layout. a #GtkStyleContext a #cairo_t X origin Y origin the #PangoLayout of the text the index in the #PangoLayout the #PangoDirection of the text Renders @layout on the coordinates @x, @y a #GtkStyleContext a #cairo_t X origin Y origin the #PangoLayout to render Renders a line from (x0, y0) to (x1, y1). a #GtkStyleContext a #cairo_t X coordinate for the origin of the line Y coordinate for the origin of the line X coordinate for the end of the line Y coordinate for the end of the line Renders an option mark (as in a #GtkRadioButton), the %GTK_STATE_FLAG_CHECKED state will determine whether the option is on or off, and %GTK_STATE_FLAG_INCONSISTENT whether it should be marked as undefined. Typical option mark rendering: ![](options.png) a #GtkStyleContext a #cairo_t X origin of the rectangle Y origin of the rectangle rectangle width rectangle height Renders a slider (as in #GtkScale) in the rectangle defined by @x, @y, @width, @height. @orientation defines whether the slider is vertical or horizontal. Typical slider rendering: ![](sliders.png) a #GtkStyleContext a #cairo_t X origin of the rectangle Y origin of the rectangle rectangle width rectangle height orientation of the slider Converts a color from RGB space to HSV. Input values must be in the [0.0, 1.0] range; output values will be in the same range. Red Green Blue Return value for the hue component Return value for the saturation component Return value for the value component Appends a specified target to the list of supported targets for a given widget and selection. a #GtkWidget the selection target to add. A unsigned integer which will be passed back to the application. Prepends a table of targets to the list of supported targets for a given widget and selection. a #GtkWidget the selection a table of targets to add number of entries in @targets Remove all targets registered for the given selection for the widget. a #GtkWidget an atom representing a selection Requests the contents of a selection. When received, a “selection-received” signal will be generated. %TRUE if requested succeeded. %FALSE if we could not process request. (e.g., there was already a request in process for this widget). The widget which acts as requestor Which selection to get Form of information desired (e.g., STRING) Time of request (usually of triggering event) In emergency, you could use #GDK_CURRENT_TIME Claims ownership of a given selection for a particular widget, or, if @widget is %NULL, release ownership of the selection. %TRUE if the operation succeeded a #GtkWidget, or %NULL. an interned atom representing the selection to claim timestamp with which to claim the selection Claim ownership of a given selection for a particular widget, or, if @widget is %NULL, release ownership of the selection. TRUE if the operation succeeded the #GdkDisplay where the selection is set new selection owner (a #GtkWidget), or %NULL. an interned atom representing the selection to claim. timestamp with which to claim the selection Removes all handlers and unsets ownership of all selections for a widget. Called when widget is being destroyed. This function will not generally be called by applications. a #GtkWidget Sets the GTK+ debug flags. This is a convenience function for showing an application’s about box. The constructed dialog is associated with the parent window and reused for future invocations of this function. transient parent, or %NULL for none the name of the first property value of first property, followed by more properties, %NULL-terminated A convenience function for launching the default application to show the uri. Like gtk_show_uri_on_window(), but takes a screen as transient parent instead of a window. Note that this function is deprecated as it does not pass the necessary information for helpers to parent their dialog properly, when run from sandboxed applications for example. Use gtk_show_uri_on_window() instead. %TRUE on success, %FALSE on error screen to show the uri on or %NULL for the default screen the uri to show a timestamp to prevent focus stealing This is a convenience function for launching the default application to show the uri. The uri must be of a form understood by GIO (i.e. you need to install gvfs to get support for uri schemes such as http:// or ftp://, as only local files are handled by GIO itself). Typical examples are - `file:///home/gnome/pict.jpg` - `http://www.gnome.org` - `mailto:me@gnome.org` Ideally the timestamp is taken from the event triggering the gtk_show_uri() call. If timestamp is not known you can take %GDK_CURRENT_TIME. This is the recommended call to be used as it passes information necessary for sandbox helpers to parent their dialogs properly. %TRUE on success, %FALSE on error parent window the uri to show a timestamp to prevent focus stealing Registers each of the stock items in @items. If an item already exists with the same stock ID as one of the @items, the old item gets replaced. The stock items are copied, so GTK+ does not hold any pointer into @items and @items can be freed. Use gtk_stock_add_static() if @items is persistent and GTK+ need not copy the array. a #GtkStockItem or array of items number of #GtkStockItem in @items Same as gtk_stock_add(), but doesn’t copy @items, so @items must persist until application exit. a #GtkStockItem or array of #GtkStockItem number of items Retrieves a list of all known stock IDs added to a #GtkIconFactory or registered with gtk_stock_add(). The list must be freed with g_slist_free(), and each string in the list must be freed with g_free(). a list of known stock IDs Fills @item with the registered values for @stock_id, returning %TRUE if @stock_id was known. %TRUE if @item was initialized a stock item name stock item to initialize with values Sets a function to be used for translating the @label of a stock item. If no function is registered for a translation domain, g_dgettext() is used. The function is used for all stock items whose @translation_domain matches @domain. Note that it is possible to use strings different from the actual gettext translation domain of your application for this, as long as your #GtkTranslateFunc uses the correct domain when calling dgettext(). This can be useful, e.g. when dealing with message contexts: |[<!-- language="C" --> GtkStockItem items[] = { { MY_ITEM1, NC_("odd items", "Item 1"), 0, 0, "odd-item-domain" }, { MY_ITEM2, NC_("even items", "Item 2"), 0, 0, "even-item-domain" }, }; gchar * my_translate_func (const gchar *msgid, gpointer data) { gchar *msgctxt = data; return (gchar*)g_dpgettext2 (GETTEXT_PACKAGE, msgctxt, msgid); } ... gtk_stock_add (items, G_N_ELEMENTS (items)); gtk_stock_set_translate_func ("odd-item-domain", my_translate_func, "odd items"); gtk_stock_set_translate_func ("even-item-domain", my_translate_func, "even items"); ]| the translation domain for which @func shall be used a #GtkTranslateFunc data to pass to @func a #GDestroyNotify that is called when @data is no longer needed This function frees a target table as returned by gtk_target_table_new_from_list() a #GtkTargetEntry array the number of entries in the array This function creates an #GtkTargetEntry array that contains the same targets as the passed %list. The returned table is newly allocated and should be freed using gtk_target_table_free() when no longer needed. the new table. a #GtkTargetList return location for the number ot targets in the table Determines if any of the targets in @targets can be used to provide a #GdkPixbuf. %TRUE if @targets include a suitable target for images, otherwise %FALSE. an array of #GdkAtoms the length of @targets whether to accept only targets for which GTK+ knows how to convert a pixbuf into the format Determines if any of the targets in @targets can be used to provide rich text. %TRUE if @targets include a suitable target for rich text, otherwise %FALSE. an array of #GdkAtoms the length of @targets a #GtkTextBuffer Determines if any of the targets in @targets can be used to provide text. %TRUE if @targets include a suitable target for text, otherwise %FALSE. an array of #GdkAtoms the length of @targets Determines if any of the targets in @targets can be used to provide an uri list. %TRUE if @targets include a suitable target for uri lists, otherwise %FALSE. an array of #GdkAtoms the length of @targets Create a simple window with window title @window_title and text contents @dialog_text. The window will quit any running gtk_main()-loop when destroyed, and it will automatically be destroyed upon test function teardown. This testing infrastructure is phased out in favor of reftests. a widget pointer to the newly created GtkWindow. Title of the window to be displayed. Text inside the window to be displayed. This function wraps g_object_new() for widget types. It’ll automatically show all created non window widgets, also g_object_ref_sink() them (to keep them alive across a running test) and set them up for destruction during the next test teardown phase. This testing infrastructure is phased out in favor of reftests. a newly created widget. a valid widget type. Name of first property to set or %NULL value to set the first property to, followed by more name-value pairs, terminated by %NULL Create a window with window title @window_title, text contents @dialog_text, and a number of buttons, according to the paired argument list given as @... parameters. Each button is created with a @label and a ::clicked signal handler that incremrents the integer stored in @nump. The window will be automatically shown with gtk_widget_show_now() after creation, so when this function returns it has already been mapped, resized and positioned on screen. The window will quit any running gtk_main()-loop when destroyed, and it will automatically be destroyed upon test function teardown. This testing infrastructure is phased out in favor of reftests. a widget pointer to the newly created GtkWindow. Title of the window to be displayed. Text inside the window to be displayed. %NULL terminated list of (const char *label, int *nump) pairs. This function will search @widget and all its descendants for a GtkLabel widget with a text string matching @label_pattern. The @label_pattern may contain asterisks “*” and question marks “?” as placeholders, g_pattern_match() is used for the matching. Note that locales other than "C“ tend to alter (translate” label strings, so this function is genrally only useful in test programs with predetermined locales, see gtk_test_init() for more details. a GtkLabel widget if any is found. Valid label or container widget. Shell-glob pattern to match a label string. This function will search siblings of @base_widget and siblings of its ancestors for all widgets matching @widget_type. Of the matching widgets, the one that is geometrically closest to @base_widget will be returned. The general purpose of this function is to find the most likely “action” widget, relative to another labeling widget. Such as finding a button or text entry widget, given its corresponding label widget. a widget of type @widget_type if any is found. Valid widget, part of a widget hierarchy Type of a aearched for sibling widget This function will search the descendants of @widget for a widget of type @widget_type that has a label matching @label_pattern next to it. This is most useful for automated GUI testing, e.g. to find the “OK” button in a dialog and synthesize clicks on it. However see gtk_test_find_label(), gtk_test_find_sibling() and gtk_test_widget_click() for possible caveats involving the search of such widgets and synthesizing widget events. a valid widget if any is found or %NULL. Container widget, usually a GtkWindow. Shell-glob pattern to match a label string. Type of a aearched for label sibling widget. This function is used to initialize a GTK+ test program. It will in turn call g_test_init() and gtk_init() to properly initialize the testing framework and graphical toolkit. It’ll also set the program’s locale to “C” and prevent loading of rc files and Gtk+ modules. This is done to make tets program environments as deterministic as possible. Like gtk_init() and g_test_init(), any known arguments will be processed and stripped from @argc and @argv. Address of the `argc` parameter of the main() function. Changed if any arguments were handled. Address of the `argv` parameter of main(). Any parameters understood by g_test_init() or gtk_init() are stripped before return. currently unused Return the type ids that have been registered after calling gtk_test_register_all_types(). 0-terminated array of type ids location to store number of types Force registration of all core Gtk+ and Gdk object types. This allowes to refer to any of those object types via g_type_from_name() after calling this function. Retrive the literal adjustment value for GtkRange based widgets and spin buttons. Note that the value returned by this function is anything between the lower and upper bounds of the adjustment belonging to @widget, and is not a percentage as passed in to gtk_test_slider_set_perc(). This testing infrastructure is phased out in favor of reftests. gtk_adjustment_get_value (adjustment) for an adjustment belonging to @widget. valid widget pointer. This function will adjust the slider position of all GtkRange based widgets, such as scrollbars or scales, it’ll also adjust spin buttons. The adjustment value of these widgets is set to a value between the lower and upper limits, according to the @percentage argument. This testing infrastructure is phased out in favor of reftests. valid widget pointer. value between 0 and 100. This function will generate a @button click in the upwards or downwards spin button arrow areas, usually leading to an increase or decrease of spin button’s value. This testing infrastructure is phased out in favor of reftests. whether all actions neccessary for the button click simulation were carried out successfully. valid GtkSpinButton widget. Number of the pointer button for the event, usually 1, 2 or 3. %TRUE for upwards arrow click, %FALSE for downwards arrow click. Retrive the text string of @widget if it is a GtkLabel, GtkEditable (entry and text widgets) or GtkTextView. This testing infrastructure is phased out in favor of reftests. new 0-terminated C string, needs to be released with g_free(). valid widget pointer. Set the text string of @widget to @string if it is a GtkLabel, GtkEditable (entry and text widgets) or GtkTextView. This testing infrastructure is phased out in favor of reftests. valid widget pointer. a 0-terminated C string This function will generate a @button click (button press and button release event) in the middle of the first GdkWindow found that belongs to @widget. For windowless widgets like #GtkButton (which returns %FALSE from gtk_widget_get_has_window()), this will often be an input-only event window. For other widgets, this is usually widget->window. Certain caveats should be considered when using this function, in particular because the mouse pointer is warped to the button click location, see gdk_test_simulate_button() for details. This testing infrastructure is phased out in favor of reftests. whether all actions neccessary for the button click simulation were carried out successfully. Widget to generate a button click on. Number of the pointer button for the event, usually 1, 2 or 3. Keyboard modifiers the event is setup with. This function will generate keyboard press and release events in the middle of the first GdkWindow found that belongs to @widget. For windowless widgets like #GtkButton (which returns %FALSE from gtk_widget_get_has_window()), this will often be an input-only event window. For other widgets, this is usually widget->window. Certain caveats should be considered when using this function, in particular because the mouse pointer is warped to the key press location, see gdk_test_simulate_key() for details. whether all actions neccessary for the key event simulation were carried out successfully. Widget to generate a key press and release on. A Gdk keyboard value. Keyboard modifiers the event is setup with. Enters the main loop and waits for @widget to be “drawn”. In this context that means it waits for the frame clock of @widget to have run a full styling, layout and drawing cycle. This function is intended to be used for syncing with actions that depend on @widget relayouting or on interaction with the display server. the widget to wait for Obtains a @tree_model and @path from selection data of target type %GTK_TREE_MODEL_ROW. Normally called from a drag_data_received handler. This function can only be used if @selection_data originates from the same process that’s calling this function, because a pointer to the tree model is being passed around. If you aren’t in the same process, then you'll get memory corruption. In the #GtkTreeDragDest drag_data_received handler, you can assume that selection data of type %GTK_TREE_MODEL_ROW is in from the current process. The returned path must be freed with gtk_tree_path_free(). %TRUE if @selection_data had target type %GTK_TREE_MODEL_ROW and is otherwise valid a #GtkSelectionData a #GtkTreeModel row in @tree_model Lets a set of row reference created by gtk_tree_row_reference_new_proxy() know that the model emitted the #GtkTreeModel::row-deleted signal. a #GObject the path position that was deleted Lets a set of row reference created by gtk_tree_row_reference_new_proxy() know that the model emitted the #GtkTreeModel::row-inserted signal. a #GObject the row position that was inserted Lets a set of row reference created by gtk_tree_row_reference_new_proxy() know that the model emitted the #GtkTreeModel::rows-reordered signal. a #GObject the parent path of the reordered signal the iter pointing to the parent of the reordered the new order of rows Sets selection data of target type %GTK_TREE_MODEL_ROW. Normally used in a drag_data_get handler. %TRUE if the #GtkSelectionData had the proper target type to allow us to set a tree row some #GtkSelectionData a #GtkTreeModel a row in @tree_model All this function does it to return %TRUE. This can be useful for example if you want to inhibit the deletion of a window. Of course you should not do this as the user expects a reaction from clicking the close icon of the window... ## A persistent window |[<!-- language="C" --> #include <gtk/gtk.h> int main (int argc, char **argv) { GtkWidget *win, *but; const char *text = "Close yourself. I mean it!"; gtk_init (&argc, &argv); win = gtk_window_new (GTK_WINDOW_TOPLEVEL); g_signal_connect (win, "delete-event", G_CALLBACK (gtk_true), NULL); g_signal_connect (win, "destroy", G_CALLBACK (gtk_main_quit), NULL); but = gtk_button_new_with_label (text); g_signal_connect_swapped (but, "clicked", G_CALLBACK (gtk_object_destroy), win); gtk_container_add (GTK_CONTAINER (win), but); gtk_widget_show_all (win); gtk_main (); return 0; } ]| %TRUE Binds a callback function defined in a template to the @widget_class. This macro is a convenience wrapper around the gtk_widget_class_bind_template_callback_full() function. a #GtkWidgetClass the callback symbol Binds a child widget defined in a template to the @widget_class. This macro is a convenience wrapper around the gtk_widget_class_bind_template_child_full() function. This macro will use the offset of the @member_name inside the @TypeName instance structure. a #GtkWidgetClass the type name of this widget name of the instance member in the instance struct for @data_type Binds a child widget defined in a template to the @widget_class, and also makes it available as an internal child in GtkBuilder, under the name @member_name. This macro is a convenience wrapper around the gtk_widget_class_bind_template_child_full() function. This macro will use the offset of the @member_name inside the @TypeName instance structure. a #GtkWidgetClass the type name, in CamelCase name of the instance member in the instance struct for @data_type Binds a child widget defined in a template to the @widget_class, and also makes it available as an internal child in GtkBuilder, under the name @member_name. This macro is a convenience wrapper around the gtk_widget_class_bind_template_child_full() function. This macro will use the offset of the @member_name inside the @TypeName private data structure. a #GtkWidgetClass the type name, in CamelCase name of the instance private member on the private struct for @data_type Binds a child widget defined in a template to the @widget_class. This macro is a convenience wrapper around the gtk_widget_class_bind_template_child_full() function. This macro will use the offset of the @member_name inside the @TypeName private data structure (it uses G_PRIVATE_OFFSET(), so the private struct must be added with G_ADD_PRIVATE()). a #GtkWidgetClass the type name of this widget name of the instance private member in the private struct for @data_type gtkada-24.0.0/contrib/Pango-1.0.gir000066400000000000000000035342521446021174000165500ustar00rootroot00000000000000 A #PangoGlyph represents a single glyph in the output form of a string. The #PangoGlyphUnit type is used to store dimensions within Pango. Dimensions are stored in 1/%PANGO_SCALE of a device unit. (A device unit might be a pixel for screen display, or a point on a printer.) %PANGO_SCALE is currently 1024, and may change in the future (unlikely though), but you should not depend on its exact value. The PANGO_PIXELS() macro can be used to convert from glyph units into device units with correct rounding. The #PangoLayoutRun structure represents a single run within a #PangoLayoutLine; it is simply an alternate name for #PangoGlyphItem. See the #PangoGlyphItem docs for details on the fields. Whether the segment should be shifted to center around the baseline. Used in vertical writing directions mostly. This flag is used to mark runs that hold ellipsized text, in an ellipsized layout. This flag tells Pango to add a hyphen at the end of the run during shaping. Extracts the <firstterm>ascent</firstterm> from a #PangoRectangle representing glyph extents. The ascent is the distance from the baseline to the highest point of the character. This is positive if the glyph ascends above the baseline. a #PangoRectangle This value can be used to set the start_index member of a #PangoAttribute such that the attribute covers from the beginning of the text. A #PangoAlignment describes how to align the lines of a #PangoLayout within the available space. If the #PangoLayout is set to justify using pango_layout_set_justify(), this only has effect for partial lines. Put all available space on the right Center the line within the available space Put all available space on the left The #PangoAnalysis structure stores information about the properties of a segment of text. unused unused the font for this segment. the bidirectional level for this segment. the glyph orientation for this segment (A #PangoGravity). boolean flags for this segment (Since: 1.16). the detected script for this segment (A #PangoScript) (Since: 1.18). the detected language for this segment. extra attributes for this segment. The #PangoAttrClass structure stores the type and operations for a particular type of attribute. The functions in this structure should not be called directly. Instead, one should use the wrapper functions provided for #PangoAttribute. the type ID for this attribute The #PangoAttrColor structure is used to represent attributes that are colors. the common portion of the attribute the #PangoColor which is the value of the attribute Type of a function that can duplicate user data for an attribute. new copy of @user_data. user data to copy Type of a function filtering a list of attributes. %TRUE if the attribute should be selected for filtering, %FALSE otherwise. a Pango attribute user data passed to the function The #PangoAttrFloat structure is used to represent attributes with a float or double value. the common portion of the attribute the value of the attribute The #PangoAttrFontDesc structure is used to store an attribute that sets all aspects of the font description at once. the common portion of the attribute the font description which is the value of this attribute Create a new font description attribute. This attribute allows setting family, style, weight, variant, stretch, and size simultaneously. the newly allocated #PangoAttribute, which should be freed with pango_attribute_destroy(). the font description The #PangoAttrFontFeatures structure is used to represent OpenType font features as an attribute. the common portion of the attribute the featues, as a string in CSS syntax Create a new font features tag attribute. the newly allocated #PangoAttribute, which should be freed with pango_attribute_destroy(). a string with OpenType font features, in CSS syntax The #PangoAttrInt structure is used to represent attributes with an integer or enumeration value. the common portion of the attribute the value of the attribute The #PangoAttrIterator structure is used to represent an iterator through a #PangoAttrList. A new iterator is created with pango_attr_list_get_iterator(). Once the iterator is created, it can be advanced through the style changes in the text using pango_attr_iterator_next(). At each style change, the range of the current style segment and the attributes currently in effect can be queried. Copy a #PangoAttrIterator the newly allocated #PangoAttrIterator, which should be freed with pango_attr_iterator_destroy(). a #PangoAttrIterator. Destroy a #PangoAttrIterator and free all associated memory. a #PangoAttrIterator. Find the current attribute of a particular type at the iterator location. When multiple attributes of the same type overlap, the attribute whose range starts closest to the current location is used. the current attribute of the given type, or %NULL if no attribute of that type applies to the current location. a #PangoAttrIterator the type of attribute to find. Gets a list of all attributes at the current position of the iterator. a list of all attributes for the current range. To free this value, call pango_attribute_destroy() on each value and g_slist_free() on the list. a #PangoAttrIterator Get the font and other attributes at the current iterator position. a #PangoAttrIterator a #PangoFontDescription to fill in with the current values. The family name in this structure will be set using pango_font_description_set_family_static() using values from an attribute in the #PangoAttrList associated with the iterator, so if you plan to keep it around, you must call: <literal>pango_font_description_set_family (desc, pango_font_description_get_family (desc))</literal>. if non-%NULL, location to store language tag for item, or %NULL if none is found. if non-%NULL, location in which to store a list of non-font attributes at the the current position; only the highest priority value of each attribute will be added to this list. In order to free this value, you must call pango_attribute_destroy() on each member. Advance the iterator until the next change of style. %FALSE if the iterator is at the end of the list, otherwise %TRUE a #PangoAttrIterator Get the range of the current segment. Note that the stored return values are signed, not unsigned like the values in #PangoAttribute. To deal with this API oversight, stored return values that wouldn't fit into a signed integer are clamped to %G_MAXINT. a #PangoAttrIterator location to store the start of the range location to store the end of the range The #PangoAttrLanguage structure is used to represent attributes that are languages. the common portion of the attribute the #PangoLanguage which is the value of the attribute Create a new language tag attribute. the newly allocated #PangoAttribute, which should be freed with pango_attribute_destroy(). language tag The #PangoAttrList structure represents a list of attributes that apply to a section of text. The attributes are, in general, allowed to overlap in an arbitrary fashion, however, if the attributes are manipulated only through pango_attr_list_change(), the overlap between properties will meet stricter criteria. Since the #PangoAttrList structure is stored as a linear list, it is not suitable for storing attributes for large amounts of text. In general, you should not use a single #PangoAttrList for more than one paragraph of text. Create a new empty attribute list with a reference count of one. the newly allocated #PangoAttrList, which should be freed with pango_attr_list_unref(). Insert the given attribute into the #PangoAttrList. It will replace any attributes of the same type on that segment and be merged with any adjoining attributes that are identical. This function is slower than pango_attr_list_insert() for creating an attribute list in order (potentially much slower for large lists). However, pango_attr_list_insert() is not suitable for continually changing a set of attributes since it never removes or combines existing attributes. a #PangoAttrList the attribute to insert. Ownership of this value is assumed by the list. Copy @list and return an identical new list. the newly allocated #PangoAttrList, with a reference count of one, which should be freed with pango_attr_list_unref(). Returns %NULL if @list was %NULL. a #PangoAttrList, may be %NULL Checks whether @list and @other_list contain the same attributes and whether those attributes apply to the same ranges. Beware that this will return wrong values if any list contains duplicates. %TRUE if the lists are equal, %FALSE if they aren't. a #PangoAttrList the other #PangoAttrList Given a #PangoAttrList and callback function, removes any elements of @list for which @func returns %TRUE and inserts them into a new list. the new #PangoAttrList or %NULL if no attributes of the given types were found. a #PangoAttrList callback function; returns %TRUE if an attribute should be filtered out. Data to be passed to @func Gets a list of all attributes in @list. a list of all attributes in @list. To free this value, call pango_attribute_destroy() on each value and g_slist_free() on the list. a #PangoAttrList Create a iterator initialized to the beginning of the list. @list must not be modified until this iterator is freed. the newly allocated #PangoAttrIterator, which should be freed with pango_attr_iterator_destroy(). a #PangoAttrList Insert the given attribute into the #PangoAttrList. It will be inserted after all other attributes with a matching @start_index. a #PangoAttrList the attribute to insert. Ownership of this value is assumed by the list. Insert the given attribute into the #PangoAttrList. It will be inserted before all other attributes with a matching @start_index. a #PangoAttrList the attribute to insert. Ownership of this value is assumed by the list. Increase the reference count of the given attribute list by one. The attribute list passed in a #PangoAttrList, may be %NULL This function opens up a hole in @list, fills it in with attributes from the left, and then merges @other on top of the hole. This operation is equivalent to stretching every attribute that applies at position @pos in @list by an amount @len, and then calling pango_attr_list_change() with a copy of each attribute in @other in sequence (offset in position by @pos). This operation proves useful for, for instance, inserting a pre-edit string in the middle of an edit buffer. a #PangoAttrList another #PangoAttrList the position in @list at which to insert @other the length of the spliced segment. (Note that this must be specified since the attributes in @other may only be present at some subsection of this range) Decrease the reference count of the given attribute list by one. If the result is zero, free the attribute list and the attributes it contains. a #PangoAttrList, may be %NULL Update indices of attributes in @list for a change in the text they refer to. The change that this function applies is removing @remove bytes at position @pos and inserting @add bytes instead. Attributes that fall entirely in the (@pos, @pos + @remove) range are removed. Attributes that start or end inside the (@pos, @pos + @remove) range are shortened to reflect the removal. Attributes start and end positions are updated if they are behind @pos + @remove. a #PangoAttrList the position of the change the number of removed bytes the number of added bytes The #PangoAttrShape structure is used to represent attributes which impose shape restrictions. the common portion of the attribute the ink rectangle to restrict to the logical rectangle to restrict to user data set (see pango_attr_shape_new_with_data()) copy function for the user data destroy function for the user data Create a new shape attribute. A shape is used to impose a particular ink and logical rectangle on the result of shaping a particular glyph. This might be used, for instance, for embedding a picture or a widget inside a #PangoLayout. the newly allocated #PangoAttribute, which should be freed with pango_attribute_destroy(). ink rectangle to assign to each character logical rectangle to assign to each character Like pango_attr_shape_new(), but a user data pointer is also provided; this pointer can be accessed when later rendering the glyph. the newly allocated #PangoAttribute, which should be freed with pango_attribute_destroy(). ink rectangle to assign to each character logical rectangle to assign to each character user data pointer function to copy @data when the attribute is copied. If %NULL, @data is simply copied as a pointer. function to free @data when the attribute is freed, or %NULL The #PangoAttrSize structure is used to represent attributes which set font size. the common portion of the attribute size of font, in units of 1/%PANGO_SCALE of a point (for %PANGO_ATTR_SIZE) or of a device uni (for %PANGO_ATTR_ABSOLUTE_SIZE) whether the font size is in device units or points. This field is only present for compatibility with Pango-1.8.0 (%PANGO_ATTR_ABSOLUTE_SIZE was added in 1.8.1); and always will be %FALSE for %PANGO_ATTR_SIZE and %TRUE for %PANGO_ATTR_ABSOLUTE_SIZE. Create a new font-size attribute in fractional points. the newly allocated #PangoAttribute, which should be freed with pango_attribute_destroy(). the font size, in %PANGO_SCALEths of a point. Create a new font-size attribute in device units. the newly allocated #PangoAttribute, which should be freed with pango_attribute_destroy(). the font size, in %PANGO_SCALEths of a device unit. The #PangoAttrString structure is used to represent attributes with a string value. the common portion of the attribute the string which is the value of the attribute The #PangoAttrType distinguishes between different types of attributes. Along with the predefined values, it is possible to allocate additional values for custom attributes using pango_attr_type_register(). The predefined values are given below. The type of structure used to store the attribute is listed in parentheses after the description. does not happen language (#PangoAttrLanguage) font family name list (#PangoAttrString) font slant style (#PangoAttrInt) font weight (#PangoAttrInt) font variant (normal or small caps) (#PangoAttrInt) font stretch (#PangoAttrInt) font size in points scaled by %PANGO_SCALE (#PangoAttrInt) font description (#PangoAttrFontDesc) foreground color (#PangoAttrColor) background color (#PangoAttrColor) whether the text has an underline (#PangoAttrInt) whether the text is struck-through (#PangoAttrInt) baseline displacement (#PangoAttrInt) shape (#PangoAttrShape) font size scale factor (#PangoAttrFloat) whether fallback is enabled (#PangoAttrInt) letter spacing (#PangoAttrInt) underline color (#PangoAttrColor) strikethrough color (#PangoAttrColor) font size in pixels scaled by %PANGO_SCALE (#PangoAttrInt) base text gravity (#PangoAttrInt) gravity hint (#PangoAttrInt) OpenType font features (#PangoAttrString). Since 1.38 foreground alpha (#PangoAttrInt). Since 1.38 background alpha (#PangoAttrInt). Since 1.38 whether breaks are allowed (#PangoAttrInt). Since 1.44 how to render invisible characters (#PangoAttrInt). Since 1.44 whether to insert hyphens at intra-word line breaks (#PangoAttrInt). Since 1.44 whether the text has an overline (#PangoAttrInt). Since 1.46 overline color (#PangoAttrColor). Since 1.46 Fetches the attribute type name passed in when registering the type using pango_attr_type_register(). The returned value is an interned string (see g_intern_string() for what that means) that should not be modified or freed. the type ID name (which may be %NULL), or %NULL if @type is a built-in Pango attribute type or invalid. an attribute type ID to fetch the name for Allocate a new attribute type ID. The attribute type name can be accessed later by using pango_attr_type_get_name(). the new type ID. an identifier for the type The #PangoAttribute structure represents the common portions of all attributes. Particular types of attributes include this structure as their initial portion. The common portion of the attribute holds the range to which the value in the type-specific part of the attribute applies and should be initialized using pango_attribute_init(). By default an attribute will have an all-inclusive range of [0,%G_MAXUINT]. the class structure holding information about the type of the attribute the start index of the range (in bytes). end index of the range (in bytes). The character at this index is not included in the range. Make a copy of an attribute. the newly allocated #PangoAttribute, which should be freed with pango_attribute_destroy(). a #PangoAttribute Destroy a #PangoAttribute and free all associated memory. a #PangoAttribute. Compare two attributes for equality. This compares only the actual value of the two attributes and not the ranges that the attributes apply to. %TRUE if the two attributes have the same value. a #PangoAttribute another #PangoAttribute Initializes @attr's klass to @klass, it's start_index to %PANGO_ATTR_INDEX_FROM_TEXT_BEGINNING and end_index to %PANGO_ATTR_INDEX_TO_TEXT_END such that the attribute applies to the entire text by default. a #PangoAttribute a #PangoAttrClass The #PangoBidiType type represents the bidirectional character type of a Unicode character as specified by the <ulink url="http://www.unicode.org/reports/tr9/">Unicode bidirectional algorithm</ulink>. Use fribidi for this information Left-to-Right Left-to-Right Embedding Left-to-Right Override Right-to-Left Right-to-Left Arabic Right-to-Left Embedding Right-to-Left Override Pop Directional Format European Number European Number Separator European Number Terminator Arabic Number Common Number Separator Nonspacing Mark Boundary Neutral Paragraph Separator Segment Separator Whitespace Other Neutrals Determines the normative bidirectional character type of a character, as specified in the Unicode Character Database. A simplified version of this function is available as pango_unichar_direction(). the bidirectional character type, as used in the Unicode bidirectional algorithm. a Unicode character The #PangoColor structure is used to represent a color in an uncalibrated RGB color-space. value of red component value of green component value of blue component Creates a copy of @src, which should be freed with pango_color_free(). Primarily used by language bindings, not that useful otherwise (since colors can just be copied by assignment in C). the newly allocated #PangoColor, which should be freed with pango_color_free(), or %NULL if @src was %NULL. color to copy, may be %NULL Frees a color allocated by pango_color_copy(). an allocated #PangoColor, may be %NULL Fill in the fields of a color from a string specification. The string can either one of a large set of standard names. (Taken from the CSS <ulink url="http://dev.w3.org/csswg/css-color/#named-colors">specification</ulink>), or it can be a hexadecimal value in the form '&num;rgb' '&num;rrggbb' '&num;rrrgggbbb' or '&num;rrrrggggbbbb' where 'r', 'g' and 'b' are hex digits of the red, green, and blue components of the color, respectively. (White in the four forms is '&num;fff' '&num;ffffff' '&num;fffffffff' and '&num;ffffffffffff') %TRUE if parsing of the specifier succeeded, otherwise false. a #PangoColor structure in which to store the result, or %NULL a string specifying the new color Fill in the fields of a color from a string specification. The string can either one of a large set of standard names. (Taken from the CSS <ulink url="http://dev.w3.org/csswg/css-color/#named-colors">specification</ulink>), or it can be a hexadecimal value in the form '&num;rgb' '&num;rrggbb' '&num;rrrgggbbb' or '&num;rrrrggggbbbb' where 'r', 'g' and 'b' are hex digits of the red, green, and blue components of the color, respectively. (White in the four forms is '&num;fff' '&num;ffffff' '&num;fffffffff' and '&num;ffffffffffff') Additionally, parse strings of the form '&num;rgba', '&num;rrggbbaa', '&num;rrrrggggbbbbaaaa', if @alpha is not %NULL, and set @alpha to the value specified by the hex digits for 'a'. If no alpha component is found in @spec, @alpha is set to 0xffff (for a solid color). %TRUE if parsing of the specifier succeeded, otherwise false. a #PangoColor structure in which to store the result, or %NULL return location for alpha, or %NULL a string specifying the new color Returns a textual specification of @color in the hexadecimal form <literal>&num;rrrrggggbbbb</literal>, where <literal>r</literal>, <literal>g</literal> and <literal>b</literal> are hex digits representing the red, green, and blue components respectively. a newly-allocated text string that must be freed with g_free(). a #PangoColor The #PangoContext structure stores global information used to control the itemization process. Creates a new #PangoContext initialized to default values. This function is not particularly useful as it should always be followed by a pango_context_set_font_map() call, and the function pango_font_map_create_context() does these two steps together and hence users are recommended to use that. If you are using Pango as part of a higher-level system, that system may have it's own way of create a #PangoContext. For instance, the GTK+ toolkit has, among others, gdk_pango_context_get_for_screen(), and gtk_widget_get_pango_context(). Use those instead. the newly allocated #PangoContext, which should be freed with g_object_unref(). Forces a change in the context, which will cause any #PangoLayout using this context to re-layout. This function is only useful when implementing a new backend for Pango, something applications won't do. Backends should call this function if they have attached extra data to the context and such data is changed. a #PangoContext Retrieves the base direction for the context. See pango_context_set_base_dir(). the base direction for the context. a #PangoContext Retrieves the base gravity for the context. See pango_context_set_base_gravity(). the base gravity for the context. a #PangoContext Retrieve the default font description for the context. a pointer to the context's default font description. This value must not be modified or freed. a #PangoContext Gets the #PangoFontMap used to look up fonts for this context. the font map for the #PangoContext. This value is owned by Pango and should not be unreferenced. a #PangoContext Retrieves the gravity for the context. This is similar to pango_context_get_base_gravity(), except for when the base gravity is %PANGO_GRAVITY_AUTO for which pango_gravity_get_for_matrix() is used to return the gravity from the current context matrix. the resolved gravity for the context. a #PangoContext Retrieves the gravity hint for the context. See pango_context_set_gravity_hint() for details. the gravity hint for the context. a #PangoContext Retrieves the global language tag for the context. the global language tag. a #PangoContext Gets the transformation matrix that will be applied when rendering with this context. See pango_context_set_matrix(). the matrix, or %NULL if no matrix has been set (which is the same as the identity matrix). The returned matrix is owned by Pango and must not be modified or freed. a #PangoContext Get overall metric information for a particular font description. Since the metrics may be substantially different for different scripts, a language tag can be provided to indicate that the metrics should be retrieved that correspond to the script(s) used by that language. The #PangoFontDescription is interpreted in the same way as by pango_itemize(), and the family name may be a comma separated list of figures. If characters from multiple of these families would be used to render the string, then the returned fonts would be a composite of the metrics for the fonts loaded for the individual families. a #PangoFontMetrics object. The caller must call pango_font_metrics_unref() when finished using the object. a #PangoContext a #PangoFontDescription structure. %NULL means that the font description from the context will be used. language tag used to determine which script to get the metrics for. %NULL means that the language tag from the context will be used. If no language tag is set on the context, metrics for the default language (as determined by pango_language_get_default()) will be returned. Returns whether font rendering with this context should round glyph positions and widths. a #PangoContext Returns the current serial number of @context. The serial number is initialized to an small number larger than zero when a new context is created and is increased whenever the context is changed using any of the setter functions, or the #PangoFontMap it uses to find fonts has changed. The serial may wrap, but will never have the value 0. Since it can wrap, never compare it with "less than", always use "not equals". This can be used to automatically detect changes to a #PangoContext, and is only useful when implementing objects that need update when their #PangoContext changes, like #PangoLayout. The current serial number of @context. a #PangoContext List all families for a context. a #PangoContext location to store a pointer to an array of #PangoFontFamily *. This array should be freed with g_free(). location to store the number of elements in @descs Loads the font in one of the fontmaps in the context that is the closest match for @desc. the newly allocated #PangoFont that was loaded, or %NULL if no font matched. a #PangoContext a #PangoFontDescription describing the font to load Load a set of fonts in the context that can be used to render a font matching @desc. the newly allocated #PangoFontset loaded, or %NULL if no font matched. a #PangoContext a #PangoFontDescription describing the fonts to load a #PangoLanguage the fonts will be used for Sets the base direction for the context. The base direction is used in applying the Unicode bidirectional algorithm; if the @direction is %PANGO_DIRECTION_LTR or %PANGO_DIRECTION_RTL, then the value will be used as the paragraph direction in the Unicode bidirectional algorithm. A value of %PANGO_DIRECTION_WEAK_LTR or %PANGO_DIRECTION_WEAK_RTL is used only for paragraphs that do not contain any strong characters themselves. a #PangoContext the new base direction Sets the base gravity for the context. The base gravity is used in laying vertical text out. a #PangoContext the new base gravity Set the default font description for the context a #PangoContext the new pango font description Sets the font map to be searched when fonts are looked-up in this context. This is only for internal use by Pango backends, a #PangoContext obtained via one of the recommended methods should already have a suitable font map. a #PangoContext the #PangoFontMap to set. Sets the gravity hint for the context. The gravity hint is used in laying vertical text out, and is only relevant if gravity of the context as returned by pango_context_get_gravity() is set %PANGO_GRAVITY_EAST or %PANGO_GRAVITY_WEST. a #PangoContext the new gravity hint Sets the global language tag for the context. The default language for the locale of the running process can be found using pango_language_get_default(). a #PangoContext the new language tag. Sets the transformation matrix that will be applied when rendering with this context. Note that reported metrics are in the user space coordinates before the application of the matrix, not device-space coordinates after the application of the matrix. So, they don't scale with the matrix, though they may change slightly for different matrices, depending on how the text is fit to the pixel grid. a #PangoContext a #PangoMatrix, or %NULL to unset any existing matrix. (No matrix set is the same as setting the identity matrix.) Sets whether font rendering with this context should round glyph positions and widths to integral positions, in device units. This is useful when the renderer can't handle subpixel positioning of glyphs. The default value is to round glyph positions, to remain compatible with previous Pango behavior. a #PangoContext whether to round glyph positions The #PangoCoverage structure represents a map from Unicode characters to #PangoCoverageLevel. It is an opaque structure with no public fields. Create a new #PangoCoverage the newly allocated #PangoCoverage, initialized to %PANGO_COVERAGE_NONE with a reference count of one, which should be freed with pango_coverage_unref(). Convert data generated from pango_coverage_to_bytes() back to a #PangoCoverage This returns %NULL a newly allocated #PangoCoverage, or %NULL if the data was invalid. binary data representing a #PangoCoverage the size of @bytes in bytes Copy an existing #PangoCoverage. (This function may now be unnecessary since we refcount the structure. File a bug if you use it.) the newly allocated #PangoCoverage, with a reference count of one, which should be freed with pango_coverage_unref(). a #PangoCoverage Determine whether a particular index is covered by @coverage the coverage level of @coverage for character @index_. a #PangoCoverage the index to check Set the coverage for each index in @coverage to be the max (better) value of the current coverage for the index and the coverage for the corresponding index in @other. This function does nothing a #PangoCoverage another #PangoCoverage Increase the reference count on the #PangoCoverage by one @coverage a #PangoCoverage Modify a particular index within @coverage a #PangoCoverage the index to modify the new level for @index_ Convert a #PangoCoverage structure into a flat binary format This returns %NULL a #PangoCoverage location to store result (must be freed with g_free()) location to store size of result Decrease the reference count on the #PangoCoverage by one. If the result is zero, free the coverage and all associated memory. a #PangoCoverage Used to indicate how well a font can represent a particular Unicode character point for a particular script. Since 1.44, only %PANGO_COVERAGE_NONE and %PANGO_COVERAGE_EXACT will be returned. The character is not representable with the font. The character is represented in a way that may be comprehensible but is not the correct graphical form. For instance, a Hangul character represented as a a sequence of Jamos, or a Latin transliteration of a Cyrillic word. The character is represented as basically the correct graphical form, but with a stylistic variant inappropriate for the current script. The character is represented as the correct graphical form. Extracts the <firstterm>descent</firstterm> from a #PangoRectangle representing glyph extents. The descent is the distance from the baseline to the lowest point of the character. This is positive if the glyph descends below the baseline. a #PangoRectangle The #PangoDirection type represents a direction in the Unicode bidirectional algorithm; not every value in this enumeration makes sense for every usage of #PangoDirection; for example, the return value of pango_unichar_direction() and pango_find_base_dir() cannot be %PANGO_DIRECTION_WEAK_LTR or %PANGO_DIRECTION_WEAK_RTL, since every character is either neutral or has a strong direction; on the other hand %PANGO_DIRECTION_NEUTRAL doesn't make sense to pass to pango_itemize_with_base_dir(). The %PANGO_DIRECTION_TTB_LTR, %PANGO_DIRECTION_TTB_RTL values come from an earlier interpretation of this enumeration as the writing direction of a block of text and are no longer used; See #PangoGravity for how vertical text is handled in Pango. If you are interested in text direction, you should really use fribidi directly. PangoDirection is only retained because it is used in some public apis. A strong left-to-right direction A strong right-to-left direction Deprecated value; treated the same as %PANGO_DIRECTION_RTL. Deprecated value; treated the same as %PANGO_DIRECTION_LTR A weak left-to-right direction A weak right-to-left direction No direction specified A string constant defining the engine type for language engines. These engines derive from #PangoEngineLang. A string constant defining the engine type for shaping engines. These engines derive from #PangoEngineShape. The #PangoEllipsizeMode type describes what sort of (if any) ellipsization should be applied to a line of text. In the ellipsization process characters are removed from the text in order to make it fit to a given width and replaced with an ellipsis. No ellipsization Omit characters at the start of the text Omit characters in the middle of the text Omit characters at the end of the text #PangoEngine is the base class for all types of language and script specific engines. It has no functionality by itself. Class structure for #PangoEngine The #PangoEngineInfo structure contains information about a particular engine. It contains the following fields: a unique string ID for the engine. a string identifying the engine type. a string identifying the render type. array of scripts this engine supports. number of items in @scripts. The #PangoEngineLang class is implemented by engines that customize the rendering-system independent part of the Pango pipeline for a particular script or language. For instance, a custom #PangoEngineLang could be provided for Thai to implement the dictionary-based word boundary lookups needed for that language. Class structure for #PangoEngineLang The #PangoEngineScriptInfo structure contains information about how the shaper covers a particular script. a #PangoScript. The value %PANGO_SCRIPT_COMMON has the special meaning here of "all scripts" a semicolon separated list of languages that this engine handles for this script. This may be empty, in which case the engine is saying that it is a fallback choice for all languages for this range, but should not be used if another engine indicates that it is specific for the language for a given code point. An entry in this list of "*" indicates that this engine is specific to all languages for this range. The #PangoEngineShape class is implemented by engines that customize the rendering-system dependent part of the Pango pipeline for a particular script or language. A #PangoEngineShape implementation is then specific to both a particular rendering system or group of rendering systems and to a particular script. For instance, there is one #PangoEngineShape implementation to handle shaping Arabic for Fontconfig-based backends. Class structure for #PangoEngineShape Casts a #GObject to a #PangoFont. a #GObject. Casts a #GObject to a #PangoFontFace. a #GObject. Casts a #GObject to a #PangoFontFamily. a #GObject. Casts a #GObject to a #PangoFontMap. a #GObject. The #PangoFont structure is used to represent a font in a rendering-system-independent matter. To create an implementation of a #PangoFont, the rendering-system specific code should allocate a larger structure that contains a nested #PangoFont, fill in the <structfield>klass</structfield> member of the nested #PangoFont with a pointer to a appropriate #PangoFontClass, then call pango_font_init() on the structure. The #PangoFont structure contains one member which the implementation fills in. Frees an array of font descriptions. a pointer to an array of #PangoFontDescription, may be %NULL number of font descriptions in @descs Returns a description of the font, with font size set in points. Use pango_font_describe_with_absolute_size() if you want the font size in device units. a newly-allocated #PangoFontDescription object. a #PangoFont Computes the coverage map for a given font and language tag. a newly-allocated #PangoCoverage object. a #PangoFont the language tag Obtain the OpenType features that are provided by the font. These are passed to the rendering system, together with features that have been explicitly set via attributes. Note that this does not include OpenType features which the rendering system enables by default. a #PangoFont Array to features in the length of @features the number of used items in @features Gets the font map for which the font was created. Note that the font maintains a <firstterm>weak</firstterm> reference to the font map, so if all references to font map are dropped, the font map will be finalized even if there are fonts created with the font map that are still alive. In that case this function will return %NULL. It is the responsibility of the user to ensure that the font map is kept alive. In most uses this is not an issue as a #PangoContext holds a reference to the font map. the #PangoFontMap for the font, or %NULL if @font is %NULL. a #PangoFont, or %NULL Gets the logical and ink extents of a glyph within a font. The coordinate system for each rectangle has its origin at the base line and horizontal origin of the character with increasing coordinates extending to the right and down. The macros PANGO_ASCENT(), PANGO_DESCENT(), PANGO_LBEARING(), and PANGO_RBEARING() can be used to convert from the extents rectangle to more traditional font metrics. The units of the rectangles are in 1/PANGO_SCALE of a device unit. If @font is %NULL, this function gracefully sets some sane values in the output variables and returns. a #PangoFont the glyph index rectangle used to store the extents of the glyph as drawn or %NULL to indicate that the result is not needed. rectangle used to store the logical extents of the glyph or %NULL to indicate that the result is not needed. Gets overall metric information for a font. Since the metrics may be substantially different for different scripts, a language tag can be provided to indicate that the metrics should be retrieved that correspond to the script(s) used by that language. If @font is %NULL, this function gracefully sets some sane values in the output variables and returns. a #PangoFontMetrics object. The caller must call pango_font_metrics_unref() when finished using the object. a #PangoFont language tag used to determine which script to get the metrics for, or %NULL to indicate to get the metrics for the entire font. Returns a description of the font, with font size set in points. Use pango_font_describe_with_absolute_size() if you want the font size in device units. a newly-allocated #PangoFontDescription object. a #PangoFont Returns a description of the font, with absolute font size set (in device units). Use pango_font_describe() if you want the font size in points. a newly-allocated #PangoFontDescription object. a #PangoFont Finds the best matching shaper for a font for a particular language tag and character point. Shape engines are no longer used the best matching shaper. a #PangoFont the language tag a Unicode character. Computes the coverage map for a given font and language tag. a newly-allocated #PangoCoverage object. a #PangoFont the language tag Gets the #PangoFontFace to which @font belongs. the #PangoFontFace a #PangoFont Obtain the OpenType features that are provided by the font. These are passed to the rendering system, together with features that have been explicitly set via attributes. Note that this does not include OpenType features which the rendering system enables by default. a #PangoFont Array to features in the length of @features the number of used items in @features Gets the font map for which the font was created. Note that the font maintains a <firstterm>weak</firstterm> reference to the font map, so if all references to font map are dropped, the font map will be finalized even if there are fonts created with the font map that are still alive. In that case this function will return %NULL. It is the responsibility of the user to ensure that the font map is kept alive. In most uses this is not an issue as a #PangoContext holds a reference to the font map. the #PangoFontMap for the font, or %NULL if @font is %NULL. a #PangoFont, or %NULL Gets the logical and ink extents of a glyph within a font. The coordinate system for each rectangle has its origin at the base line and horizontal origin of the character with increasing coordinates extending to the right and down. The macros PANGO_ASCENT(), PANGO_DESCENT(), PANGO_LBEARING(), and PANGO_RBEARING() can be used to convert from the extents rectangle to more traditional font metrics. The units of the rectangles are in 1/PANGO_SCALE of a device unit. If @font is %NULL, this function gracefully sets some sane values in the output variables and returns. a #PangoFont the glyph index rectangle used to store the extents of the glyph as drawn or %NULL to indicate that the result is not needed. rectangle used to store the logical extents of the glyph or %NULL to indicate that the result is not needed. Get a hb_font_t object backing this font. Note that the objects returned by this function are cached and immutable. If you need to make changes to the hb_font_t, use hb_font_create_sub_font(). the hb_font_t object backing the font, or %NULL if the font does not have one a #PangoFont Gets overall metric information for a font. Since the metrics may be substantially different for different scripts, a language tag can be provided to indicate that the metrics should be retrieved that correspond to the script(s) used by that language. If @font is %NULL, this function gracefully sets some sane values in the output variables and returns. a #PangoFontMetrics object. The caller must call pango_font_metrics_unref() when finished using the object. a #PangoFont language tag used to determine which script to get the metrics for, or %NULL to indicate to get the metrics for the entire font. Returns whether the font provides a glyph for this character. Returns %TRUE if @font can render @wc a #PangoFont a Unicode character a newly-allocated #PangoFontDescription object. a #PangoFont a newly-allocated #PangoCoverage object. a #PangoFont the language tag a #PangoFont the glyph index rectangle used to store the extents of the glyph as drawn or %NULL to indicate that the result is not needed. rectangle used to store the logical extents of the glyph or %NULL to indicate that the result is not needed. a #PangoFontMetrics object. The caller must call pango_font_metrics_unref() when finished using the object. a #PangoFont language tag used to determine which script to get the metrics for, or %NULL to indicate to get the metrics for the entire font. the #PangoFontMap for the font, or %NULL if @font is %NULL. a #PangoFont, or %NULL a #PangoFont Array to features in the length of @features the number of used items in @features The #PangoFontDescription structure represents the description of an ideal font. These structures are used both to list what fonts are available on the system and also for specifying the characteristics of a font to load. Creates a new font description structure with all fields unset. the newly allocated #PangoFontDescription, which should be freed using pango_font_description_free(). Determines if the style attributes of @new_match are a closer match for @desc than those of @old_match are, or if @old_match is %NULL, determines if @new_match is a match at all. Approximate matching is done for weight and style; other style attributes must match exactly. Style attributes are all attributes other than family and size-related attributes. Approximate matching for style considers PANGO_STYLE_OBLIQUE and PANGO_STYLE_ITALIC as matches, but not as good a match as when the styles are equal. Note that @old_match must match @desc. %TRUE if @new_match is a better match a #PangoFontDescription a #PangoFontDescription, or %NULL a #PangoFontDescription Make a copy of a #PangoFontDescription. the newly allocated #PangoFontDescription, which should be freed with pango_font_description_free(), or %NULL if @desc was %NULL. a #PangoFontDescription, may be %NULL Like pango_font_description_copy(), but only a shallow copy is made of the family name and other allocated fields. The result can only be used until @desc is modified or freed. This is meant to be used when the copy is only needed temporarily. the newly allocated #PangoFontDescription, which should be freed with pango_font_description_free(), or %NULL if @desc was %NULL. a #PangoFontDescription, may be %NULL Compares two font descriptions for equality. Two font descriptions are considered equal if the fonts they describe are provably identical. This means that their masks do not have to match, as long as other fields are all the same. (Two font descriptions may result in identical fonts being loaded, but still compare %FALSE.) %TRUE if the two font descriptions are identical, %FALSE otherwise. a #PangoFontDescription another #PangoFontDescription Frees a font description. a #PangoFontDescription, may be %NULL Gets the family name field of a font description. See pango_font_description_set_family(). the family name field for the font description, or %NULL if not previously set. This has the same life-time as the font description itself and should not be freed. a #PangoFontDescription. Gets the gravity field of a font description. See pango_font_description_set_gravity(). the gravity field for the font description. Use pango_font_description_get_set_fields() to find out if the field was explicitly set or not. a #PangoFontDescription Determines which fields in a font description have been set. a bitmask with bits set corresponding to the fields in @desc that have been set. a #PangoFontDescription Gets the size field of a font description. See pango_font_description_set_size(). the size field for the font description in points or device units. You must call pango_font_description_get_size_is_absolute() to find out which is the case. Returns 0 if the size field has not previously been set or it has been set to 0 explicitly. Use pango_font_description_get_set_fields() to find out if the field was explicitly set or not. a #PangoFontDescription Determines whether the size of the font is in points (not absolute) or device units (absolute). See pango_font_description_set_size() and pango_font_description_set_absolute_size(). whether the size for the font description is in points or device units. Use pango_font_description_get_set_fields() to find out if the size field of the font description was explicitly set or not. a #PangoFontDescription Gets the stretch field of a font description. See pango_font_description_set_stretch(). the stretch field for the font description. Use pango_font_description_get_set_fields() to find out if the field was explicitly set or not. a #PangoFontDescription. Gets the style field of a #PangoFontDescription. See pango_font_description_set_style(). the style field for the font description. Use pango_font_description_get_set_fields() to find out if the field was explicitly set or not. a #PangoFontDescription Gets the variant field of a #PangoFontDescription. See pango_font_description_set_variant(). the variant field for the font description. Use pango_font_description_get_set_fields() to find out if the field was explicitly set or not. a #PangoFontDescription. Gets the variations field of a font description. See pango_font_description_set_variations(). the varitions field for the font description, or %NULL if not previously set. This has the same life-time as the font description itself and should not be freed. a #PangoFontDescription Gets the weight field of a font description. See pango_font_description_set_weight(). the weight field for the font description. Use pango_font_description_get_set_fields() to find out if the field was explicitly set or not. a #PangoFontDescription Computes a hash of a #PangoFontDescription structure suitable to be used, for example, as an argument to g_hash_table_new(). The hash value is independent of @desc->mask. the hash value. a #PangoFontDescription Merges the fields that are set in @desc_to_merge into the fields in @desc. If @replace_existing is %FALSE, only fields in @desc that are not already set are affected. If %TRUE, then fields that are already set will be replaced as well. If @desc_to_merge is %NULL, this function performs nothing. a #PangoFontDescription the #PangoFontDescription to merge from, or %NULL if %TRUE, replace fields in @desc with the corresponding values from @desc_to_merge, even if they are already exist. Like pango_font_description_merge(), but only a shallow copy is made of the family name and other allocated fields. @desc can only be used until @desc_to_merge is modified or freed. This is meant to be used when the merged font description is only needed temporarily. a #PangoFontDescription the #PangoFontDescription to merge from if %TRUE, replace fields in @desc with the corresponding values from @desc_to_merge, even if they are already exist. Sets the size field of a font description, in device units. This is mutually exclusive with pango_font_description_set_size() which sets the font size in points. a #PangoFontDescription the new size, in Pango units. There are %PANGO_SCALE Pango units in one device unit. For an output backend where a device unit is a pixel, a @size value of 10 * PANGO_SCALE gives a 10 pixel font. Sets the family name field of a font description. The family name represents a family of related font styles, and will resolve to a particular #PangoFontFamily. In some uses of #PangoFontDescription, it is also possible to use a comma separated list of family names for this field. a #PangoFontDescription. a string representing the family name. Like pango_font_description_set_family(), except that no copy of @family is made. The caller must make sure that the string passed in stays around until @desc has been freed or the name is set again. This function can be used if @family is a static string such as a C string literal, or if @desc is only needed temporarily. a #PangoFontDescription a string representing the family name. Sets the gravity field of a font description. The gravity field specifies how the glyphs should be rotated. If @gravity is %PANGO_GRAVITY_AUTO, this actually unsets the gravity mask on the font description. This function is seldom useful to the user. Gravity should normally be set on a #PangoContext. a #PangoFontDescription the gravity for the font description. Sets the size field of a font description in fractional points. This is mutually exclusive with pango_font_description_set_absolute_size(). a #PangoFontDescription the size of the font in points, scaled by PANGO_SCALE. (That is, a @size value of 10 * PANGO_SCALE is a 10 point font. The conversion factor between points and device units depends on system configuration and the output device. For screen display, a logical DPI of 96 is common, in which case a 10 point font corresponds to a 10 * (96 / 72) = 13.3 pixel font. Use pango_font_description_set_absolute_size() if you need a particular size in device units. Sets the stretch field of a font description. The stretch field specifies how narrow or wide the font should be. a #PangoFontDescription the stretch for the font description Sets the style field of a #PangoFontDescription. The #PangoStyle enumeration describes whether the font is slanted and the manner in which it is slanted; it can be either #PANGO_STYLE_NORMAL, #PANGO_STYLE_ITALIC, or #PANGO_STYLE_OBLIQUE. Most fonts will either have a italic style or an oblique style, but not both, and font matching in Pango will match italic specifications with oblique fonts and vice-versa if an exact match is not found. a #PangoFontDescription the style for the font description Sets the variant field of a font description. The #PangoVariant can either be %PANGO_VARIANT_NORMAL or %PANGO_VARIANT_SMALL_CAPS. a #PangoFontDescription the variant type for the font description. Sets the variations field of a font description. OpenType font variations allow to select a font instance by specifying values for a number of axes, such as width or weight. The format of the variations string is AXIS1=VALUE,AXIS2=VALUE..., with each AXIS a 4 character tag that identifies a font axis, and each VALUE a floating point number. Unknown axes are ignored, and values are clamped to their allowed range. Pango does not currently have a way to find supported axes of a font. Both harfbuzz or freetype have API for this. a #PangoFontDescription. a string representing the variations Like pango_font_description_set_variations(), except that no copy of @variations is made. The caller must make sure that the string passed in stays around until @desc has been freed or the name is set again. This function can be used if @variations is a static string such as a C string literal, or if @desc is only needed temporarily. a #PangoFontDescription a string representing the variations Sets the weight field of a font description. The weight field specifies how bold or light the font should be. In addition to the values of the #PangoWeight enumeration, other intermediate numeric values are possible. a #PangoFontDescription the weight for the font description. Creates a filename representation of a font description. The filename is identical to the result from calling pango_font_description_to_string(), but with underscores instead of characters that are untypical in filenames, and in lower case only. a new string that must be freed with g_free(). a #PangoFontDescription Creates a string representation of a font description. See pango_font_description_from_string() for a description of the format of the string representation. The family list in the string description will only have a terminating comma if the last word of the list is a valid style option. a new string that must be freed with g_free(). a #PangoFontDescription Unsets some of the fields in a #PangoFontDescription. The unset fields will get back to their default values. a #PangoFontDescription bitmask of fields in the @desc to unset. Creates a new font description from a string representation in the form "\[FAMILY-LIST] \[STYLE-OPTIONS] \[SIZE] \[VARIATIONS]", where FAMILY-LIST is a comma-separated list of families optionally terminated by a comma, STYLE_OPTIONS is a whitespace-separated list of words where each word describes one of style, variant, weight, stretch, or gravity, and SIZE is a decimal number (size in points) or optionally followed by the unit modifier "px" for absolute size. VARIATIONS is a comma-separated list of font variation specifications of the form "\@axis=value" (the = sign is optional). The following words are understood as styles: "Normal", "Roman", "Oblique", "Italic". The following words are understood as variants: "Small-Caps". The following words are understood as weights: "Thin", "Ultra-Light", "Extra-Light", "Light", "Semi-Light", "Demi-Light", "Book", "Regular", "Medium", "Semi-Bold", "Demi-Bold", "Bold", "Ultra-Bold", "Extra-Bold", "Heavy", "Black", "Ultra-Black", "Extra-Black". The following words are understood as stretch values: "Ultra-Condensed", "Extra-Condensed", "Condensed", "Semi-Condensed", "Semi-Expanded", "Expanded", "Extra-Expanded", "Ultra-Expanded". The following words are understood as gravity values: "Not-Rotated", "South", "Upside-Down", "North", "Rotated-Left", "East", "Rotated-Right", "West". Any one of the options may be absent. If FAMILY-LIST is absent, then the family_name field of the resulting font description will be initialized to %NULL. If STYLE-OPTIONS is missing, then all style options will be set to the default values. If SIZE is missing, the size in the resulting font description will be set to 0. A typical example: "Cantarell Italic Light 15 \@wght=200" a new #PangoFontDescription. string representation of a font description. The #PangoFontFace structure is used to represent a group of fonts with the same family, slant, weight, width, but varying sizes. Returns the family, style, variant, weight and stretch of a #PangoFontFace. The size field of the resulting font description will be unset. a newly-created #PangoFontDescription structure holding the description of the face. Use pango_font_description_free() to free the result. a #PangoFontFace Gets a name representing the style of this face among the different faces in the #PangoFontFamily for the face. This name is unique among all faces in the family and is suitable for displaying to users. the face name for the face. This string is owned by the face object and must not be modified or freed. a #PangoFontFace. Gets the #PangoFontFamily that @face belongs to. the #PangoFontFamily a #PangoFontFace Returns whether a #PangoFontFace is synthesized by the underlying font rendering engine from another face, perhaps by shearing, emboldening, or lightening it. whether @face is synthesized. a #PangoFontFace List the available sizes for a font. This is only applicable to bitmap fonts. For scalable fonts, stores %NULL at the location pointed to by @sizes and 0 at the location pointed to by @n_sizes. The sizes returned are in Pango units and are sorted in ascending order. a #PangoFontFace. location to store a pointer to an array of int. This array should be freed with g_free(). location to store the number of elements in @sizes Returns the family, style, variant, weight and stretch of a #PangoFontFace. The size field of the resulting font description will be unset. a newly-created #PangoFontDescription structure holding the description of the face. Use pango_font_description_free() to free the result. a #PangoFontFace Gets a name representing the style of this face among the different faces in the #PangoFontFamily for the face. This name is unique among all faces in the family and is suitable for displaying to users. the face name for the face. This string is owned by the face object and must not be modified or freed. a #PangoFontFace. Gets the #PangoFontFamily that @face belongs to. the #PangoFontFamily a #PangoFontFace Returns whether a #PangoFontFace is synthesized by the underlying font rendering engine from another face, perhaps by shearing, emboldening, or lightening it. whether @face is synthesized. a #PangoFontFace List the available sizes for a font. This is only applicable to bitmap fonts. For scalable fonts, stores %NULL at the location pointed to by @sizes and 0 at the location pointed to by @n_sizes. The sizes returned are in Pango units and are sorted in ascending order. a #PangoFontFace. location to store a pointer to an array of int. This array should be freed with g_free(). location to store the number of elements in @sizes the face name for the face. This string is owned by the face object and must not be modified or freed. a #PangoFontFace. a newly-created #PangoFontDescription structure holding the description of the face. Use pango_font_description_free() to free the result. a #PangoFontFace a #PangoFontFace. location to store a pointer to an array of int. This array should be freed with g_free(). location to store the number of elements in @sizes whether @face is synthesized. a #PangoFontFace the #PangoFontFamily a #PangoFontFace The #PangoFontFamily structure is used to represent a family of related font faces. The faces in a family share a common design, but differ in slant, weight, width and other aspects. Gets the #PangoFontFace of @family with the given name. the #PangoFontFace, or %NULL if no face with the given name exists. a #PangoFontFamily the name of a face. If the name is %NULL, the family's default face (fontconfig calls it "Regular") will be returned. Gets the name of the family. The name is unique among all fonts for the font backend and can be used in a #PangoFontDescription to specify that a face from this family is desired. the name of the family. This string is owned by the family object and must not be modified or freed. a #PangoFontFamily A monospace font is a font designed for text display where the the characters form a regular grid. For Western languages this would mean that the advance width of all characters are the same, but this categorization also includes Asian fonts which include double-width characters: characters that occupy two grid cells. g_unichar_iswide() returns a result that indicates whether a character is typically double-width in a monospace font. The best way to find out the grid-cell size is to call pango_font_metrics_get_approximate_digit_width(), since the results of pango_font_metrics_get_approximate_char_width() may be affected by double-width characters. %TRUE if the family is monospace. a #PangoFontFamily A variable font is a font which has axes that can be modified to produce different faces. %TRUE if the family is variable a #PangoFontFamily Lists the different font faces that make up @family. The faces in a family share a common design, but differ in slant, weight, width and other aspects. a #PangoFontFamily location to store an array of pointers to #PangoFontFace objects, or %NULL. This array should be freed with g_free() when it is no longer needed. location to store number of elements in @faces. Gets the #PangoFontFace of @family with the given name. the #PangoFontFace, or %NULL if no face with the given name exists. a #PangoFontFamily the name of a face. If the name is %NULL, the family's default face (fontconfig calls it "Regular") will be returned. Gets the name of the family. The name is unique among all fonts for the font backend and can be used in a #PangoFontDescription to specify that a face from this family is desired. the name of the family. This string is owned by the family object and must not be modified or freed. a #PangoFontFamily A monospace font is a font designed for text display where the the characters form a regular grid. For Western languages this would mean that the advance width of all characters are the same, but this categorization also includes Asian fonts which include double-width characters: characters that occupy two grid cells. g_unichar_iswide() returns a result that indicates whether a character is typically double-width in a monospace font. The best way to find out the grid-cell size is to call pango_font_metrics_get_approximate_digit_width(), since the results of pango_font_metrics_get_approximate_char_width() may be affected by double-width characters. %TRUE if the family is monospace. a #PangoFontFamily A variable font is a font which has axes that can be modified to produce different faces. %TRUE if the family is variable a #PangoFontFamily Lists the different font faces that make up @family. The faces in a family share a common design, but differ in slant, weight, width and other aspects. a #PangoFontFamily location to store an array of pointers to #PangoFontFace objects, or %NULL. This array should be freed with g_free() when it is no longer needed. location to store number of elements in @faces. a #PangoFontFamily location to store an array of pointers to #PangoFontFace objects, or %NULL. This array should be freed with g_free() when it is no longer needed. location to store number of elements in @faces. the name of the family. This string is owned by the family object and must not be modified or freed. a #PangoFontFamily %TRUE if the family is monospace. a #PangoFontFamily %TRUE if the family is variable a #PangoFontFamily the #PangoFontFace, or %NULL if no face with the given name exists. a #PangoFontFamily the name of a face. If the name is %NULL, the family's default face (fontconfig calls it "Regular") will be returned. The #PangoFontMap represents the set of fonts available for a particular rendering system. This is a virtual object with implementations being specific to particular rendering systems. To create an implementation of a #PangoFontMap, the rendering-system specific code should allocate a larger structure that contains a nested #PangoFontMap, fill in the <structfield>klass</structfield> member of the nested #PangoFontMap with a pointer to a appropriate #PangoFontMapClass, then call pango_font_map_init() on the structure. The #PangoFontMap structure contains one member which the implementation fills in. Forces a change in the context, which will cause any #PangoContext using this fontmap to change. This function is only useful when implementing a new backend for Pango, something applications won't do. Backends should call this function if they have attached extra data to the context and such data is changed. a #PangoFontMap Gets a font family by name. the #PangoFontFamily a #PangoFontMap a family name Returns the current serial number of @fontmap. The serial number is initialized to an small number larger than zero when a new fontmap is created and is increased whenever the fontmap is changed. It may wrap, but will never have the value 0. Since it can wrap, never compare it with "less than", always use "not equals". The fontmap can only be changed using backend-specific API, like changing fontmap resolution. This can be used to automatically detect changes to a #PangoFontMap, like in #PangoContext. The current serial number of @fontmap. a #PangoFontMap List all families for a fontmap. a #PangoFontMap location to store a pointer to an array of #PangoFontFamily *. This array should be freed with g_free(). location to store the number of elements in @families Load the font in the fontmap that is the closest match for @desc. the newly allocated #PangoFont loaded, or %NULL if no font matched. a #PangoFontMap the #PangoContext the font will be used with a #PangoFontDescription describing the font to load Load a set of fonts in the fontmap that can be used to render a font matching @desc. the newly allocated #PangoFontset loaded, or %NULL if no font matched. a #PangoFontMap the #PangoContext the font will be used with a #PangoFontDescription describing the font to load a #PangoLanguage the fonts will be used for Forces a change in the context, which will cause any #PangoContext using this fontmap to change. This function is only useful when implementing a new backend for Pango, something applications won't do. Backends should call this function if they have attached extra data to the context and such data is changed. a #PangoFontMap Creates a #PangoContext connected to @fontmap. This is equivalent to pango_context_new() followed by pango_context_set_font_map(). If you are using Pango as part of a higher-level system, that system may have it's own way of create a #PangoContext. For instance, the GTK+ toolkit has, among others, gdk_pango_context_get_for_screen(), and gtk_widget_get_pango_context(). Use those instead. the newly allocated #PangoContext, which should be freed with g_object_unref(). a #PangoFontMap Gets a font family by name. the #PangoFontFamily a #PangoFontMap a family name Returns the current serial number of @fontmap. The serial number is initialized to an small number larger than zero when a new fontmap is created and is increased whenever the fontmap is changed. It may wrap, but will never have the value 0. Since it can wrap, never compare it with "less than", always use "not equals". The fontmap can only be changed using backend-specific API, like changing fontmap resolution. This can be used to automatically detect changes to a #PangoFontMap, like in #PangoContext. The current serial number of @fontmap. a #PangoFontMap List all families for a fontmap. a #PangoFontMap location to store a pointer to an array of #PangoFontFamily *. This array should be freed with g_free(). location to store the number of elements in @families Load the font in the fontmap that is the closest match for @desc. the newly allocated #PangoFont loaded, or %NULL if no font matched. a #PangoFontMap the #PangoContext the font will be used with a #PangoFontDescription describing the font to load Load a set of fonts in the fontmap that can be used to render a font matching @desc. the newly allocated #PangoFontset loaded, or %NULL if no font matched. a #PangoFontMap the #PangoContext the font will be used with a #PangoFontDescription describing the font to load a #PangoLanguage the fonts will be used for The #PangoFontMapClass structure holds the virtual functions for a particular #PangoFontMap implementation. parent #GObjectClass. the newly allocated #PangoFont loaded, or %NULL if no font matched. a #PangoFontMap the #PangoContext the font will be used with a #PangoFontDescription describing the font to load a #PangoFontMap location to store a pointer to an array of #PangoFontFamily *. This array should be freed with g_free(). location to store the number of elements in @families the newly allocated #PangoFontset loaded, or %NULL if no font matched. a #PangoFontMap the #PangoContext the font will be used with a #PangoFontDescription describing the font to load a #PangoLanguage the fonts will be used for the type of rendering-system-dependent engines that can handle fonts of this fonts loaded with this fontmap. The current serial number of @fontmap. a #PangoFontMap a #PangoFontMap the #PangoFontFamily a #PangoFontMap a family name The bits in a #PangoFontMask correspond to fields in a #PangoFontDescription that have been set. the font family is specified. the font style is specified. the font variant is specified. the font weight is specified. the font stretch is specified. the font size is specified. the font gravity is specified (Since: 1.16.) OpenType font variations are specified (Since: 1.42) A #PangoFontMetrics structure holds the overall metric information for a font (possibly restricted to a script). The fields of this structure are private to implementations of a font backend. See the documentation of the corresponding getters for documentation of their meaning. Gets the approximate character width for a font metrics structure. This is merely a representative value useful, for example, for determining the initial size for a window. Actual characters in text will be wider and narrower than this. the character width, in Pango units. a #PangoFontMetrics structure Gets the approximate digit width for a font metrics structure. This is merely a representative value useful, for example, for determining the initial size for a window. Actual digits in text can be wider or narrower than this, though this value is generally somewhat more accurate than the result of pango_font_metrics_get_approximate_char_width() for digits. the digit width, in Pango units. a #PangoFontMetrics structure Gets the ascent from a font metrics structure. The ascent is the distance from the baseline to the logical top of a line of text. (The logical top may be above or below the top of the actual drawn ink. It is necessary to lay out the text to figure where the ink will be.) the ascent, in Pango units. a #PangoFontMetrics structure Gets the descent from a font metrics structure. The descent is the distance from the baseline to the logical bottom of a line of text. (The logical bottom may be above or below the bottom of the actual drawn ink. It is necessary to lay out the text to figure where the ink will be.) the descent, in Pango units. a #PangoFontMetrics structure Gets the line height from a font metrics structure. The line height is the distance between successive baselines in wrapped text. If the line height is not available, 0 is returned. the height, in Pango units a #PangoFontMetrics structure Gets the suggested position to draw the strikethrough. The value returned is the distance <emphasis>above</emphasis> the baseline of the top of the strikethrough. the suggested strikethrough position, in Pango units. a #PangoFontMetrics structure Gets the suggested thickness to draw for the strikethrough. the suggested strikethrough thickness, in Pango units. a #PangoFontMetrics structure Gets the suggested position to draw the underline. The value returned is the distance <emphasis>above</emphasis> the baseline of the top of the underline. Since most fonts have underline positions beneath the baseline, this value is typically negative. the suggested underline position, in Pango units. a #PangoFontMetrics structure Gets the suggested thickness to draw for the underline. the suggested underline thickness, in Pango units. a #PangoFontMetrics structure Increase the reference count of a font metrics structure by one. @metrics a #PangoFontMetrics structure, may be %NULL Decrease the reference count of a font metrics structure by one. If the result is zero, frees the structure and any associated memory. a #PangoFontMetrics structure, may be %NULL A #PangoFontset represents a set of #PangoFont to use when rendering text. It is the result of resolving a #PangoFontDescription against a particular #PangoContext. It has operations for finding the component font for a particular Unicode character, and for finding a composite set of metrics for the entire fontset. Iterates through all the fonts in a fontset, calling @func for each one. If @func returns %TRUE, that stops the iteration. a #PangoFontset Callback function data to pass to the callback function Returns the font in the fontset that contains the best glyph for the Unicode character @wc. a #PangoFont. The caller must call g_object_unref when finished with the font. a #PangoFontset a Unicode character Get overall metric information for the fonts in the fontset. a #PangoFontMetrics object. The caller must call pango_font_metrics_unref() when finished using the object. a #PangoFontset Iterates through all the fonts in a fontset, calling @func for each one. If @func returns %TRUE, that stops the iteration. a #PangoFontset Callback function data to pass to the callback function Returns the font in the fontset that contains the best glyph for the Unicode character @wc. a #PangoFont. The caller must call g_object_unref when finished with the font. a #PangoFontset a Unicode character Get overall metric information for the fonts in the fontset. a #PangoFontMetrics object. The caller must call pango_font_metrics_unref() when finished using the object. a #PangoFontset The #PangoFontsetClass structure holds the virtual functions for a particular #PangoFontset implementation. parent #GObjectClass. a #PangoFont. The caller must call g_object_unref when finished with the font. a #PangoFontset a Unicode character a #PangoFontMetrics object. The caller must call pango_font_metrics_unref() when finished using the object. a #PangoFontset a #PangoFontset Callback function data to pass to the callback function A callback function used by pango_fontset_foreach() when enumerating the fonts in a fontset. if %TRUE, stop iteration and return immediately. a #PangoFontset a font from @fontset callback data #PangoFontsetSimple is a implementation of the abstract #PangoFontset base class in terms of an array of fonts, which the creator provides when constructing the #PangoFontsetSimple. Creates a new #PangoFontsetSimple for the given language. the newly allocated #PangoFontsetSimple, which should be freed with g_object_unref(). a #PangoLanguage tag Adds a font to the fontset. a #PangoFontsetSimple. a #PangoFont. Returns the number of fonts in the fontset. the size of @fontset. a #PangoFontsetSimple. The way this unknown glyphs are rendered is backend specific. For example, a box with the hexadecimal Unicode code-point of the character written in it is what is done in the most common backends. a Unicode character The %PANGO_GLYPH_EMPTY macro represents a #PangoGlyph value that has a special meaning, which is a zero-width empty glyph. This is useful for example in shaper modules, to use as the glyph for various zero-width Unicode characters (those passing pango_is_zero_width()). The %PANGO_GLYPH_INVALID_INPUT macro represents a #PangoGlyph value that has a special meaning of invalid input. #PangoLayout produces one such glyph per invalid input UTF-8 byte and such a glyph is rendered as a crossed box. Note that this value is defined such that it has the %PANGO_GLYPH_UNKNOWN_FLAG on. The %PANGO_GLYPH_UNKNOWN_FLAG macro is a flag value that can be added to a #gunichar value of a valid Unicode character, to produce a #PangoGlyph value, representing an unknown-character glyph for the respective #gunichar. Whether a #PangoGravity represents a gravity that results in reversal of text direction. the #PangoGravity to check Whether a #PangoGravity represents vertical writing directions. the #PangoGravity to check The #PangoGlyphGeometry structure contains width and positioning information for a single glyph. the logical width to use for the the character. horizontal offset from nominal character position. vertical offset from nominal character position. The #PangoGlyphInfo structure represents a single glyph together with positioning information and visual attributes. It contains the following fields. the glyph itself. the positional information about the glyph. the visual attributes of the glyph. A #PangoGlyphItem is a pair of a #PangoItem and the glyphs resulting from shaping the text corresponding to an item. As an example of the usage of #PangoGlyphItem, the results of shaping text with #PangoLayout is a list of #PangoLayoutLine, each of which contains a list of #PangoGlyphItem. corresponding #PangoItem. corresponding #PangoGlyphString. Splits a shaped item (PangoGlyphItem) into multiple items based on an attribute list. The idea is that if you have attributes that don't affect shaping, such as color or underline, to avoid affecting shaping, you filter them out (pango_attr_list_filter()), apply the shaping process and then reapply them to the result using this function. All attributes that start or end inside a cluster are applied to that cluster; for instance, if half of a cluster is underlined and the other-half strikethrough, then the cluster will end up with both underline and strikethrough attributes. In these cases, it may happen that item->extra_attrs for some of the result items can have multiple attributes of the same type. This function takes ownership of @glyph_item; it will be reused as one of the elements in the list. a list of glyph items resulting from splitting @glyph_item. Free the elements using pango_glyph_item_free(), the list using g_slist_free(). a shaped item text that @list applies to a #PangoAttrList Make a deep copy of an existing #PangoGlyphItem structure. the newly allocated #PangoGlyphItem, which should be freed with pango_glyph_item_free(), or %NULL if @orig was %NULL. a #PangoGlyphItem, may be %NULL Frees a #PangoGlyphItem and resources to which it points. a #PangoGlyphItem, may be %NULL Given a #PangoGlyphItem and the corresponding text, determine the screen width corresponding to each character. When multiple characters compose a single cluster, the width of the entire cluster is divided equally among the characters. See also pango_glyph_string_get_logical_widths(). a #PangoGlyphItem text that @glyph_item corresponds to (glyph_item->item->offset is an offset from the start of @text) an array whose length is the number of characters in glyph_item (equal to glyph_item->item->num_chars) to be filled in with the resulting character widths. Adds spacing between the graphemes of @glyph_item to give the effect of typographic letter spacing. a #PangoGlyphItem text that @glyph_item corresponds to (glyph_item->item->offset is an offset from the start of @text) logical attributes for the item (the first logical attribute refers to the position before the first character in the item) amount of letter spacing to add in Pango units. May be negative, though too large negative values will give ugly results. Modifies @orig to cover only the text after @split_index, and returns a new item that covers the text before @split_index that used to be in @orig. You can think of @split_index as the length of the returned item. @split_index may not be 0, and it may not be greater than or equal to the length of @orig (that is, there must be at least one byte assigned to each item, you can't create a zero-length item). This function is similar in function to pango_item_split() (and uses it internally.) the newly allocated item representing text before @split_index, which should be freed with pango_glyph_item_free(). a #PangoItem text to which positions in @orig apply byte index of position to split item, relative to the start of the item A #PangoGlyphItemIter is an iterator over the clusters in a #PangoGlyphItem. The <firstterm>forward direction</firstterm> of the iterator is the logical direction of text. That is, with increasing @start_index and @start_char values. If @glyph_item is right-to-left (that is, if <literal>@glyph_item->item->analysis.level</literal> is odd), then @start_glyph decreases as the iterator moves forward. Moreover, in right-to-left cases, @start_glyph is greater than @end_glyph. An iterator should be initialized using either of pango_glyph_item_iter_init_start() and pango_glyph_item_iter_init_end(), for forward and backward iteration respectively, and walked over using any desired mixture of pango_glyph_item_iter_next_cluster() and pango_glyph_item_iter_prev_cluster(). A common idiom for doing a forward iteration over the clusters is: <programlisting> PangoGlyphItemIter cluster_iter; gboolean have_cluster; for (have_cluster = pango_glyph_item_iter_init_start (&amp;cluster_iter, glyph_item, text); have_cluster; have_cluster = pango_glyph_item_iter_next_cluster (&amp;cluster_iter)) { ... } </programlisting> Note that @text is the start of the text for layout, which is then indexed by <literal>@glyph_item->item->offset</literal> to get to the text of @glyph_item. The @start_index and @end_index values can directly index into @text. The @start_glyph, @end_glyph, @start_char, and @end_char values however are zero-based for the @glyph_item. For each cluster, the item pointed at by the start variables is included in the cluster while the one pointed at by end variables is not. None of the members of a #PangoGlyphItemIter should be modified manually. Make a shallow copy of an existing #PangoGlyphItemIter structure. the newly allocated #PangoGlyphItemIter, which should be freed with pango_glyph_item_iter_free(), or %NULL if @orig was %NULL. a #PangoGlyphItemIter, may be %NULL Frees a #PangoGlyphItemIter created by pango_glyph_item_iter_copy(). a #PangoGlyphItemIter, may be %NULL Initializes a #PangoGlyphItemIter structure to point to the last cluster in a glyph item. See #PangoGlyphItemIter for details of cluster orders. %FALSE if there are no clusters in the glyph item a #PangoGlyphItemIter the glyph item to iterate over text corresponding to the glyph item Initializes a #PangoGlyphItemIter structure to point to the first cluster in a glyph item. See #PangoGlyphItemIter for details of cluster orders. %FALSE if there are no clusters in the glyph item a #PangoGlyphItemIter the glyph item to iterate over text corresponding to the glyph item Advances the iterator to the next cluster in the glyph item. See #PangoGlyphItemIter for details of cluster orders. %TRUE if the iterator was advanced, %FALSE if we were already on the last cluster. a #PangoGlyphItemIter Moves the iterator to the preceding cluster in the glyph item. See #PangoGlyphItemIter for details of cluster orders. %TRUE if the iterator was moved, %FALSE if we were already on the first cluster. a #PangoGlyphItemIter The #PangoGlyphString structure is used to store strings of glyphs with geometry and visual attribute information. The storage for the glyph information is owned by the structure which simplifies memory management. number of the glyphs in this glyph string. array of glyph information for the glyph string. logical cluster info, indexed by the byte index within the text corresponding to the glyph string. Create a new #PangoGlyphString. the newly allocated #PangoGlyphString, which should be freed with pango_glyph_string_free(). Copy a glyph string and associated storage. the newly allocated #PangoGlyphString, which should be freed with pango_glyph_string_free(), or %NULL if @string was %NULL. a #PangoGlyphString, may be %NULL Compute the logical and ink extents of a glyph string. See the documentation for pango_font_get_glyph_extents() for details about the interpretation of the rectangles. Examples of logical (red) and ink (green) rects: ![](rects1.png) ![](rects2.png) a #PangoGlyphString a #PangoFont rectangle used to store the extents of the glyph string as drawn or %NULL to indicate that the result is not needed. rectangle used to store the logical extents of the glyph string or %NULL to indicate that the result is not needed. Computes the extents of a sub-portion of a glyph string. The extents are relative to the start of the glyph string range (the origin of their coordinate system is at the start of the range, not at the start of the entire glyph string). a #PangoGlyphString start index end index (the range is the set of bytes with indices such that start <= index < end) a #PangoFont rectangle used to store the extents of the glyph string range as drawn or %NULL to indicate that the result is not needed. rectangle used to store the logical extents of the glyph string range or %NULL to indicate that the result is not needed. Free a glyph string and associated storage. a #PangoGlyphString, may be %NULL Given a #PangoGlyphString resulting from pango_shape() and the corresponding text, determine the screen width corresponding to each character. When multiple characters compose a single cluster, the width of the entire cluster is divided equally among the characters. See also pango_glyph_item_get_logical_widths(). a #PangoGlyphString the text corresponding to the glyphs the length of @text, in bytes the embedding level of the string an array whose length is the number of characters in text (equal to g_utf8_strlen (text, length) unless text has NUL bytes) to be filled in with the resulting character widths. Computes the logical width of the glyph string as can also be computed using pango_glyph_string_extents(). However, since this only computes the width, it's much faster. This is in fact only a convenience function that computes the sum of geometry.width for each glyph in the @glyphs. the logical width of the glyph string. a #PangoGlyphString Converts from character position to x position. (X position is measured from the left edge of the run). Character positions are computed by dividing up each cluster into equal portions. the glyphs return from pango_shape() the text for the run the number of bytes (not characters) in @text. the analysis information return from pango_itemize() the byte index within @text whether we should compute the result for the beginning (%FALSE) or end (%TRUE) of the character. location to store result Resize a glyph string to the given length. a #PangoGlyphString. the new length of the string. Convert from x offset to character position. Character positions are computed by dividing up each cluster into equal portions. In scripts where positioning within a cluster is not allowed (such as Thai), the returned value may not be a valid cursor position; the caller must combine the result with the logical attributes for the text to compute the valid cursor position. the glyphs returned from pango_shape() the text for the run the number of bytes (not characters) in text. the analysis information return from pango_itemize() the x offset (in Pango units) location to store calculated byte index within @text location to store a boolean indicating whether the user clicked on the leading or trailing edge of the character. The PangoGlyphVisAttr is used to communicate information between the shaping phase and the rendering phase. More attributes may be added in the future. set for the first logical glyph in each cluster. (Clusters are stored in visual order, within the cluster, glyphs are always ordered in logical order, since visual order is meaningless; that is, in Arabic text, accent glyphs follow the glyphs for the base character.) The #PangoGravity type represents the orientation of glyphs in a segment of text. This is useful when rendering vertical text layouts. In those situations, the layout is rotated using a non-identity PangoMatrix, and then glyph orientation is controlled using #PangoGravity. Not every value in this enumeration makes sense for every usage of #PangoGravity; for example, %PANGO_GRAVITY_AUTO only can be passed to pango_context_set_base_gravity() and can only be returned by pango_context_get_base_gravity(). See also: #PangoGravityHint Glyphs stand upright (default) Glyphs are rotated 90 degrees clockwise Glyphs are upside-down Glyphs are rotated 90 degrees counter-clockwise Gravity is resolved from the context matrix Finds the gravity that best matches the rotation component in a #PangoMatrix. the gravity of @matrix, which will never be %PANGO_GRAVITY_AUTO, or %PANGO_GRAVITY_SOUTH if @matrix is %NULL a #PangoMatrix Based on the script, base gravity, and hint, returns actual gravity to use in laying out a single #PangoItem. If @base_gravity is %PANGO_GRAVITY_AUTO, it is first replaced with the preferred gravity of @script. To get the preferred gravity of a script, pass %PANGO_GRAVITY_AUTO and %PANGO_GRAVITY_HINT_STRONG in. resolved gravity suitable to use for a run of text with @script. #PangoScript to query base gravity of the paragraph orientation hint Based on the script, East Asian width, base gravity, and hint, returns actual gravity to use in laying out a single character or #PangoItem. This function is similar to pango_gravity_get_for_script() except that this function makes a distinction between narrow/half-width and wide/full-width characters also. Wide/full-width characters always stand <emphasis>upright</emphasis>, that is, they always take the base gravity, whereas narrow/full-width characters are always rotated in vertical context. If @base_gravity is %PANGO_GRAVITY_AUTO, it is first replaced with the preferred gravity of @script. resolved gravity suitable to use for a run of text with @script and @wide. #PangoScript to query %TRUE for wide characters as returned by g_unichar_iswide() base gravity of the paragraph orientation hint Converts a #PangoGravity value to its natural rotation in radians. @gravity should not be %PANGO_GRAVITY_AUTO. Note that pango_matrix_rotate() takes angle in degrees, not radians. So, to call pango_matrix_rotate() with the output of this function you should multiply it by (180. / G_PI). the rotation value corresponding to @gravity. gravity to query The #PangoGravityHint defines how horizontal scripts should behave in a vertical context. That is, English excerpt in a vertical paragraph for example. See #PangoGravity. scripts will take their natural gravity based on the base gravity and the script. This is the default. always use the base gravity set, regardless of the script. for scripts not in their natural direction (eg. Latin in East gravity), choose per-script gravity such that every script respects the line progression. This means, Latin and Arabic will take opposite gravities and both flow top-to-bottom for example. a #GObject. a #GObject. a #GObject. a #GObject. The #PangoIncludedModule structure for a statically linked module contains the functions that would otherwise be loaded from a dynamically loaded module. The #PangoItem structure stores information about a segment of text. byte offset of the start of this item in text. length of this item in bytes. number of Unicode characters in the item. analysis results for the item. Creates a new #PangoItem structure initialized to default values. the newly allocated #PangoItem, which should be freed with pango_item_free(). Add attributes to a PangoItem. The idea is that you have attributes that don't affect itemization, such as font features, so you filter them out using pango_attr_list_filter(), itemize your text, then reapply the attributes to the resulting items using this function. The @iter should be positioned before the range of the item, and will be advanced past it. This function is meant to be called in a loop over the items resulting from itemization, while passing the iter to each call. a #PangoItem a #PangoAttrIterator Copy an existing #PangoItem structure. the newly allocated #PangoItem, which should be freed with pango_item_free(), or %NULL if @item was %NULL. a #PangoItem, may be %NULL Free a #PangoItem and all associated memory. a #PangoItem, may be %NULL Modifies @orig to cover only the text after @split_index, and returns a new item that covers the text before @split_index that used to be in @orig. You can think of @split_index as the length of the returned item. @split_index may not be 0, and it may not be greater than or equal to the length of @orig (that is, there must be at least one byte assigned to each item, you can't create a zero-length item). @split_offset is the length of the first item in chars, and must be provided because the text used to generate the item isn't available, so pango_item_split() can't count the char length of the split items itself. new item representing text before @split_index, which should be freed with pango_item_free(). a #PangoItem byte index of position to split item, relative to the start of the item number of chars between start of @orig and @split_index Extracts the <firstterm>left bearing</firstterm> from a #PangoRectangle representing glyph extents. The left bearing is the distance from the horizontal origin to the farthest left point of the character. This is positive for characters drawn completely to the right of the glyph origin. a #PangoRectangle The #PangoLanguage structure is used to represent a language. #PangoLanguage pointers can be efficiently copied and compared with each other. Get a string that is representative of the characters needed to render a particular language. The sample text may be a pangram, but is not necessarily. It is chosen to be demonstrative of normal text in the language, as well as exposing font feature requirements unique to the language. It is suitable for use as sample text in a font selection dialog. If @language is %NULL, the default language as found by pango_language_get_default() is used. If Pango does not have a sample string for @language, the classic "The quick brown fox..." is returned. This can be detected by comparing the returned pointer value to that returned for (non-existent) language code "xx". That is, compare to: <informalexample><programlisting> pango_language_get_sample_string (pango_language_from_string ("xx")) </programlisting></informalexample> the sample string. This value is owned by Pango and should not be freed. a #PangoLanguage, or %NULL Determines the scripts used to to write @language. If nothing is known about the language tag @language, or if @language is %NULL, then %NULL is returned. The list of scripts returned starts with the script that the language uses most and continues to the one it uses least. The value @num_script points at will be set to the number of scripts in the returned array (or zero if %NULL is returned). Most languages use only one script for writing, but there are some that use two (Latin and Cyrillic for example), and a few use three (Japanese for example). Applications should not make any assumptions on the maximum number of scripts returned though, except that it is positive if the return value is not %NULL, and it is a small number. The pango_language_includes_script() function uses this function internally. Note: while the return value is declared as PangoScript, the returned values are from the GUnicodeScript enumeration, which may have more values. Callers need to handle unknown values. An array of #PangoScript values, with the number of entries in the array stored in @num_scripts, or %NULL if Pango does not have any information about this particular language tag (also the case if @language is %NULL). The returned array is owned by Pango and should not be modified or freed. a #PangoLanguage, or %NULL location to return number of scripts, or %NULL Determines if @script is one of the scripts used to write @language. The returned value is conservative; if nothing is known about the language tag @language, %TRUE will be returned, since, as far as Pango knows, @script might be used to write @language. This routine is used in Pango's itemization process when determining if a supplied language tag is relevant to a particular section of text. It probably is not useful for applications in most circumstances. This function uses pango_language_get_scripts() internally. %TRUE if @script is one of the scripts used to write @language or if nothing is known about @language (including the case that @language is %NULL), %FALSE otherwise. a #PangoLanguage, or %NULL a #PangoScript Checks if a language tag matches one of the elements in a list of language ranges. A language tag is considered to match a range in the list if the range is '*', the range is exactly the tag, or the range is a prefix of the tag, and the character after it in the tag is '-'. %TRUE if a match was found. a language tag (see pango_language_from_string()), %NULL is allowed and matches nothing but '*' a list of language ranges, separated by ';', ':', ',', or space characters. Each element must either be '*', or a RFC 3066 language range canonicalized as by pango_language_from_string() Gets the RFC-3066 format string representing the given language tag. a string representing the language tag. This is owned by Pango and should not be freed. a language tag. Take a RFC-3066 format language tag as a string and convert it to a #PangoLanguage pointer that can be efficiently copied (copy the pointer) and compared with other language tags (compare the pointer.) This function first canonicalizes the string by converting it to lowercase, mapping '_' to '-', and stripping all characters other than letters and '-'. Use pango_language_get_default() if you want to get the #PangoLanguage for the current locale of the process. an opaque pointer to a #PangoLanguage structure, or %NULL if @language was %NULL. The returned pointer will be valid forever after, and should not be freed. a string representing a language tag, or %NULL Returns the #PangoLanguage for the current locale of the process. Note that this can change over the life of an application. On Unix systems, this is the return value is derived from <literal>setlocale(LC_CTYPE, NULL)</literal>, and the user can affect this through the environment variables LC_ALL, LC_CTYPE or LANG (checked in that order). The locale string typically is in the form lang_COUNTRY, where lang is an ISO-639 language code, and COUNTRY is an ISO-3166 country code. For instance, sv_FI for Swedish as written in Finland or pt_BR for Portuguese as written in Brazil. On Windows, the C library does not use any such environment variables, and setting them won't affect the behavior of functions like ctime(). The user sets the locale through the Regional Options in the Control Panel. The C library (in the setlocale() function) does not use country and language codes, but country and language names spelled out in English. However, this function does check the above environment variables, and does return a Unix-style locale string based on either said environment variables or the thread's current locale. Your application should call <literal>setlocale(LC_ALL, "");</literal> for the user settings to take effect. Gtk+ does this in its initialization functions automatically (by calling gtk_set_locale()). See <literal>man setlocale</literal> for more details. the default language as a #PangoLanguage, must not be freed. Returns the list of languages that the user prefers, as specified by the PANGO_LANGUAGE or LANGUAGE environment variables, in order of preference. Note that this list does not necessarily include the language returned by pango_language_get_default(). When choosing language-specific resources, such as the sample text returned by pango_language_get_sample_string(), you should first try the default language, followed by the languages returned by this function. a %NULL-terminated array of PangoLanguage* The #PangoLayout structure represents an entire paragraph of text. It is initialized with a #PangoContext, UTF-8 string and set of attributes for that string. Once that is done, the set of formatted lines can be extracted from the object, the layout can be rendered, and conversion between logical character positions within the layout's text, and the physical position of the resulting glyphs can be made. There are also a number of parameters to adjust the formatting of a #PangoLayout, which are illustrated in <xref linkend="parameters"/>. It is possible, as well, to ignore the 2-D setup, and simply treat the results of a #PangoLayout as a list of lines. <figure id="parameters"> <title>Adjustable parameters (on the left) and font metrics (on the right) for a PangoLayout</title> <graphic fileref="layout.png" format="PNG"></graphic> </figure> The #PangoLayout structure is opaque, and has no user-visible fields. Create a new #PangoLayout object with attributes initialized to default values for a particular #PangoContext. the newly allocated #PangoLayout, with a reference count of one, which should be freed with g_object_unref(). a #PangoContext Forces recomputation of any state in the #PangoLayout that might depend on the layout's context. This function should be called if you make changes to the context subsequent to creating the layout. a #PangoLayout Does a deep copy-by-value of the @src layout. The attribute list, tab array, and text from the original layout are all copied by value. the newly allocated #PangoLayout, with a reference count of one, which should be freed with g_object_unref(). a #PangoLayout Gets the alignment for the layout: how partial lines are positioned within the horizontal space available. the alignment. a #PangoLayout Gets the attribute list for the layout, if any. a #PangoAttrList or %NULL if none was set. a #PangoLayout Gets whether to calculate the bidirectional base direction for the layout according to the contents of the layout. See pango_layout_set_auto_dir(). %TRUE if the bidirectional base direction is computed from the layout's contents, %FALSE otherwise. a #PangoLayout Gets the Y position of baseline of the first line in @layout. baseline of first line, from top of @layout. a #PangoLayout Returns the number of Unicode characters in the the text of @layout. the number of Unicode characters in the text of @layout a #PangoLayout Retrieves the #PangoContext used for this layout. the #PangoContext for the layout. This does not have an additional refcount added, so if you want to keep a copy of this around, you must reference it yourself. a #PangoLayout Given an index within a layout, determines the positions that of the strong and weak cursors if the insertion point is at that index. The position of each cursor is stored as a zero-width rectangle. The strong cursor location is the location where characters of the directionality equal to the base direction of the layout are inserted. The weak cursor location is the location where characters of the directionality opposite to the base direction of the layout are inserted. a #PangoLayout the byte index of the cursor location to store the strong cursor position (may be %NULL) location to store the weak cursor position (may be %NULL) Gets the text direction at the given character position in @layout. the text direction at @index a #PangoLayout the byte index of the char Gets the type of ellipsization being performed for @layout. See pango_layout_set_ellipsize() the current ellipsization mode for @layout. Use pango_layout_is_ellipsized() to query whether any paragraphs were actually ellipsized. a #PangoLayout Computes the logical and ink extents of @layout. Logical extents are usually what you want for positioning things. Note that both extents may have non-zero x and y. You may want to use those to offset where you render the layout. Not doing that is a very typical bug that shows up as right-to-left layouts not being correctly positioned in a layout with a set width. The extents are given in layout coordinates and in Pango units; layout coordinates begin at the top left corner of the layout. a #PangoLayout rectangle used to store the extents of the layout as drawn or %NULL to indicate that the result is not needed. rectangle used to store the logical extents of the layout or %NULL to indicate that the result is not needed. Gets the font description for the layout, if any. a pointer to the layout's font description, or %NULL if the font description from the layout's context is inherited. This value is owned by the layout and must not be modified or freed. a #PangoLayout Gets the height of layout used for ellipsization. See pango_layout_set_height() for details. the height, in Pango units if positive, or number of lines if negative. a #PangoLayout Gets the paragraph indent width in Pango units. A negative value indicates a hanging indentation. the indent in Pango units. a #PangoLayout Returns an iterator to iterate over the visual extents of the layout. the new #PangoLayoutIter that should be freed using pango_layout_iter_free(). a #PangoLayout Gets whether each complete line should be stretched to fill the entire width of the layout. the justify. a #PangoLayout Retrieves a particular line from a #PangoLayout. Use the faster pango_layout_get_line_readonly() if you do not plan to modify the contents of the line (glyphs, glyph widths, etc.). the requested #PangoLayoutLine, or %NULL if the index is out of range. This layout line can be ref'ed and retained, but will become invalid if changes are made to the #PangoLayout. a #PangoLayout the index of a line, which must be between 0 and <literal>pango_layout_get_line_count(layout) - 1</literal>, inclusive. Retrieves the count of lines for the @layout. the line count. #PangoLayout Retrieves a particular line from a #PangoLayout. This is a faster alternative to pango_layout_get_line(), but the user is not expected to modify the contents of the line (glyphs, glyph widths, etc.). the requested #PangoLayoutLine, or %NULL if the index is out of range. This layout line can be ref'ed and retained, but will become invalid if changes are made to the #PangoLayout. No changes should be made to the line. a #PangoLayout the index of a line, which must be between 0 and <literal>pango_layout_get_line_count(layout) - 1</literal>, inclusive. Gets the value that has been set with pango_layout_set_line_spacing(). a #PangoLayout Returns the lines of the @layout as a list. Use the faster pango_layout_get_lines_readonly() if you do not plan to modify the contents of the lines (glyphs, glyph widths, etc.). a #GSList containing the lines in the layout. This points to internal data of the #PangoLayout and must be used with care. It will become invalid on any change to the layout's text or properties. a #PangoLayout Returns the lines of the @layout as a list. This is a faster alternative to pango_layout_get_lines(), but the user is not expected to modify the contents of the lines (glyphs, glyph widths, etc.). a #GSList containing the lines in the layout. This points to internal data of the #PangoLayout and must be used with care. It will become invalid on any change to the layout's text or properties. No changes should be made to the lines. a #PangoLayout Retrieves an array of logical attributes for each character in the @layout. a #PangoLayout location to store a pointer to an array of logical attributes This value must be freed with g_free(). location to store the number of the attributes in the array. (The stored value will be one more than the total number of characters in the layout, since there need to be attributes corresponding to both the position before the first character and the position after the last character.) Retrieves an array of logical attributes for each character in the @layout. This is a faster alternative to pango_layout_get_log_attrs(). The returned array is part of @layout and must not be modified. Modifying the layout will invalidate the returned array. The number of attributes returned in @n_attrs will be one more than the total number of characters in the layout, since there need to be attributes corresponding to both the position before the first character and the position after the last character. an array of logical attributes a #PangoLayout location to store the number of the attributes in the array Computes the logical and ink extents of @layout in device units. This function just calls pango_layout_get_extents() followed by two pango_extents_to_pixels() calls, rounding @ink_rect and @logical_rect such that the rounded rectangles fully contain the unrounded one (that is, passes them as first argument to pango_extents_to_pixels()). a #PangoLayout rectangle used to store the extents of the layout as drawn or %NULL to indicate that the result is not needed. rectangle used to store the logical extents of the layout or %NULL to indicate that the result is not needed. Determines the logical width and height of a #PangoLayout in device units. (pango_layout_get_size() returns the width and height scaled by %PANGO_SCALE.) This is simply a convenience function around pango_layout_get_pixel_extents(). a #PangoLayout location to store the logical width, or %NULL location to store the logical height, or %NULL Returns the current serial number of @layout. The serial number is initialized to an small number larger than zero when a new layout is created and is increased whenever the layout is changed using any of the setter functions, or the #PangoContext it uses has changed. The serial may wrap, but will never have the value 0. Since it can wrap, never compare it with "less than", always use "not equals". This can be used to automatically detect changes to a #PangoLayout, and is useful for example to decide whether a layout needs redrawing. To force the serial to be increased, use pango_layout_context_changed(). The current serial number of @layout. a #PangoLayout Obtains the value set by pango_layout_set_single_paragraph_mode(). %TRUE if the layout does not break paragraphs at paragraph separator characters, %FALSE otherwise. a #PangoLayout Determines the logical width and height of a #PangoLayout in Pango units (device units scaled by %PANGO_SCALE). This is simply a convenience function around pango_layout_get_extents(). a #PangoLayout location to store the logical width, or %NULL location to store the logical height, or %NULL Gets the amount of spacing between the lines of the layout. the spacing in Pango units. a #PangoLayout Gets the current #PangoTabArray used by this layout. If no #PangoTabArray has been set, then the default tabs are in use and %NULL is returned. Default tabs are every 8 spaces. The return value should be freed with pango_tab_array_free(). a copy of the tabs for this layout, or %NULL. a #PangoLayout Gets the text in the layout. The returned text should not be freed or modified. the text in the @layout. a #PangoLayout Counts the number unknown glyphs in @layout. That is, zero if glyphs for all characters in the layout text were found, or more than zero otherwise. This function can be used to determine if there are any fonts available to render all characters in a certain string, or when used in combination with %PANGO_ATTR_FALLBACK, to check if a certain font supports all the characters in the string. The number of unknown glyphs in @layout. a #PangoLayout Gets the width to which the lines of the #PangoLayout should wrap. the width in Pango units, or -1 if no width set. a #PangoLayout Gets the wrap mode for the layout. Use pango_layout_is_wrapped() to query whether any paragraphs were actually wrapped. active wrap mode. a #PangoLayout Converts from byte @index_ within the @layout to line and X position. (X position is measured from the left edge of the line) a #PangoLayout the byte index of a grapheme within the layout. an integer indicating the edge of the grapheme to retrieve the position of. If > 0, the trailing edge of the grapheme, if 0, the leading of the grapheme. location to store resulting line index. (which will between 0 and pango_layout_get_line_count(layout) - 1), or %NULL location to store resulting position within line (%PANGO_SCALE units per device unit), or %NULL Converts from an index within a #PangoLayout to the onscreen position corresponding to the grapheme at that index, which is represented as rectangle. Note that <literal>pos->x</literal> is always the leading edge of the grapheme and <literal>pos->x + pos->width</literal> the trailing edge of the grapheme. If the directionality of the grapheme is right-to-left, then <literal>pos->width</literal> will be negative. a #PangoLayout byte index within @layout rectangle in which to store the position of the grapheme Queries whether the layout had to ellipsize any paragraphs. This returns %TRUE if the ellipsization mode for @layout is not %PANGO_ELLIPSIZE_NONE, a positive width is set on @layout, and there are paragraphs exceeding that width that have to be ellipsized. %TRUE if any paragraphs had to be ellipsized, %FALSE otherwise. a #PangoLayout Queries whether the layout had to wrap any paragraphs. This returns %TRUE if a positive width is set on @layout, ellipsization mode of @layout is set to %PANGO_ELLIPSIZE_NONE, and there are paragraphs exceeding the layout width that have to be wrapped. %TRUE if any paragraphs had to be wrapped, %FALSE otherwise. a #PangoLayout Computes a new cursor position from an old position and a count of positions to move visually. If @direction is positive, then the new strong cursor position will be one position to the right of the old cursor position. If @direction is negative, then the new strong cursor position will be one position to the left of the old cursor position. In the presence of bidirectional text, the correspondence between logical and visual order will depend on the direction of the current run, and there may be jumps when the cursor is moved off of the end of a run. Motion here is in cursor positions, not in characters, so a single call to pango_layout_move_cursor_visually() may move the cursor over multiple characters when multiple characters combine to form a single grapheme. a #PangoLayout. whether the moving cursor is the strong cursor or the weak cursor. The strong cursor is the cursor corresponding to text insertion in the base direction for the layout. the byte index of the grapheme for the old index if 0, the cursor was at the leading edge of the grapheme indicated by @old_index, if > 0, the cursor was at the trailing edge. direction to move cursor. A negative value indicates motion to the left. location to store the new cursor byte index. A value of -1 indicates that the cursor has been moved off the beginning of the layout. A value of %G_MAXINT indicates that the cursor has been moved off the end of the layout. number of characters to move forward from the location returned for @new_index to get the position where the cursor should be displayed. This allows distinguishing the position at the beginning of one line from the position at the end of the preceding line. @new_index is always on the line where the cursor should be displayed. Sets the alignment for the layout: how partial lines are positioned within the horizontal space available. a #PangoLayout the alignment Sets the text attributes for a layout object. References @attrs, so the caller can unref its reference. a #PangoLayout a #PangoAttrList, can be %NULL Sets whether to calculate the bidirectional base direction for the layout according to the contents of the layout; when this flag is on (the default), then paragraphs in @layout that begin with strong right-to-left characters (Arabic and Hebrew principally), will have right-to-left layout, paragraphs with letters from other scripts will have left-to-right layout. Paragraphs with only neutral characters get their direction from the surrounding paragraphs. When %FALSE, the choice between left-to-right and right-to-left layout is done according to the base direction of the layout's #PangoContext. (See pango_context_set_base_dir()). When the auto-computed direction of a paragraph differs from the base direction of the context, the interpretation of %PANGO_ALIGN_LEFT and %PANGO_ALIGN_RIGHT are swapped. a #PangoLayout if %TRUE, compute the bidirectional base direction from the layout's contents. Sets the type of ellipsization being performed for @layout. Depending on the ellipsization mode @ellipsize text is removed from the start, middle, or end of text so they fit within the width and height of layout set with pango_layout_set_width() and pango_layout_set_height(). If the layout contains characters such as newlines that force it to be layed out in multiple paragraphs, then whether each paragraph is ellipsized separately or the entire layout is ellipsized as a whole depends on the set height of the layout. See pango_layout_set_height() for details. a #PangoLayout the new ellipsization mode for @layout Sets the default font description for the layout. If no font description is set on the layout, the font description from the layout's context is used. a #PangoLayout the new #PangoFontDescription, or %NULL to unset the current font description Sets the height to which the #PangoLayout should be ellipsized at. There are two different behaviors, based on whether @height is positive or negative. If @height is positive, it will be the maximum height of the layout. Only lines would be shown that would fit, and if there is any text omitted, an ellipsis added. At least one line is included in each paragraph regardless of how small the height value is. A value of zero will render exactly one line for the entire layout. If @height is negative, it will be the (negative of) maximum number of lines per paragraph. That is, the total number of lines shown may well be more than this value if the layout contains multiple paragraphs of text. The default value of -1 means that first line of each paragraph is ellipsized. This behvaior may be changed in the future to act per layout instead of per paragraph. File a bug against pango at <ulink url="http://bugzilla.gnome.org/">http://bugzilla.gnome.org/</ulink> if your code relies on this behavior. Height setting only has effect if a positive width is set on @layout and ellipsization mode of @layout is not %PANGO_ELLIPSIZE_NONE. The behavior is undefined if a height other than -1 is set and ellipsization mode is set to %PANGO_ELLIPSIZE_NONE, and may change in the future. a #PangoLayout. the desired height of the layout in Pango units if positive, or desired number of lines if negative. Sets the width in Pango units to indent each paragraph. A negative value of @indent will produce a hanging indentation. That is, the first line will have the full width, and subsequent lines will be indented by the absolute value of @indent. The indent setting is ignored if layout alignment is set to %PANGO_ALIGN_CENTER. a #PangoLayout. the amount by which to indent. Sets whether each complete line should be stretched to fill the entire width of the layout. This stretching is typically done by adding whitespace, but for some scripts (such as Arabic), the justification may be done in more complex ways, like extending the characters. Note that this setting is not implemented and so is ignored in Pango older than 1.18. a #PangoLayout whether the lines in the layout should be justified. Sets a factor for line spacing. Typical values are: 0, 1, 1.5, 2. The default values is 0. If @factor is non-zero, lines are placed so that baseline2 = baseline1 + factor * height2 where height2 is the line height of the second line (as determined by the font(s)). In this case, the spacing set with pango_layout_set_spacing() is ignored. If @factor is zero, spacing is applied as before. a #PangoLayout the new line spacing factor Same as pango_layout_set_markup_with_accel(), but the markup text isn't scanned for accelerators. a #PangoLayout marked-up text length of marked-up text in bytes, or -1 if @markup is null-terminated Sets the layout text and attribute list from marked-up text (see <link linkend="PangoMarkupFormat">markup format</link>). Replaces the current text and attribute list. If @accel_marker is nonzero, the given character will mark the character following it as an accelerator. For example, @accel_marker might be an ampersand or underscore. All characters marked as an accelerator will receive a %PANGO_UNDERLINE_LOW attribute, and the first character so marked will be returned in @accel_char. Two @accel_marker characters following each other produce a single literal @accel_marker character. a #PangoLayout marked-up text (see <link linkend="PangoMarkupFormat">markup format</link>) length of marked-up text in bytes, or -1 if @markup is null-terminated marker for accelerators in the text return location for first located accelerator, or %NULL If @setting is %TRUE, do not treat newlines and similar characters as paragraph separators; instead, keep all text in a single paragraph, and display a glyph for paragraph separator characters. Used when you want to allow editing of newlines on a single text line. a #PangoLayout new setting Sets the amount of spacing in Pango unit between the lines of the layout. When placing lines with spacing, Pango arranges things so that line2.top = line1.bottom + spacing Note: Since 1.44, Pango defaults to using the line height (as determined by the font) for placing lines. The @spacing set with this function is only taken into account when the line-height factor is set to zero with pango_layout_set_line_spacing(). a #PangoLayout. the amount of spacing Sets the tabs to use for @layout, overriding the default tabs (by default, tabs are every 8 spaces). If @tabs is %NULL, the default tabs are reinstated. @tabs is copied into the layout; you must free your copy of @tabs yourself. a #PangoLayout a #PangoTabArray, or %NULL Sets the text of the layout. This function validates @text and renders invalid UTF-8 with a placeholder glyph. Note that if you have used pango_layout_set_markup() or pango_layout_set_markup_with_accel() on @layout before, you may want to call pango_layout_set_attributes() to clear the attributes set on the layout from the markup as this function does not clear attributes. a #PangoLayout the text maximum length of @text, in bytes. -1 indicates that the string is nul-terminated and the length should be calculated. The text will also be truncated on encountering a nul-termination even when @length is positive. Sets the width to which the lines of the #PangoLayout should wrap or ellipsized. The default value is -1: no width set. a #PangoLayout. the desired width in Pango units, or -1 to indicate that no wrapping or ellipsization should be performed. Sets the wrap mode; the wrap mode only has effect if a width is set on the layout with pango_layout_set_width(). To turn off wrapping, set the width to -1. a #PangoLayout the wrap mode Converts from X and Y position within a layout to the byte index to the character at that logical position. If the Y position is not inside the layout, the closest position is chosen (the position will be clamped inside the layout). If the X position is not within the layout, then the start or the end of the line is chosen as described for pango_layout_line_x_to_index(). If either the X or Y positions were not inside the layout, then the function returns %FALSE; on an exact hit, it returns %TRUE. %TRUE if the coordinates were inside text, %FALSE otherwise. a #PangoLayout the X offset (in Pango units) from the left edge of the layout. the Y offset (in Pango units) from the top edge of the layout location to store calculated byte index location to store a integer indicating where in the grapheme the user clicked. It will either be zero, or the number of characters in the grapheme. 0 represents the leading edge of the grapheme. A #PangoLayoutIter structure can be used to iterate over the visual extents of a #PangoLayout. The #PangoLayoutIter structure is opaque, and has no user-visible fields. Determines whether @iter is on the last line of the layout. %TRUE if @iter is on the last line. a #PangoLayoutIter Copies a #PangoLayoutIter. the newly allocated #PangoLayoutIter, which should be freed with pango_layout_iter_free(), or %NULL if @iter was %NULL. a #PangoLayoutIter, may be %NULL Frees an iterator that's no longer in use. a #PangoLayoutIter, may be %NULL Gets the Y position of the current line's baseline, in layout coordinates (origin at top left of the entire layout). baseline of current line. a #PangoLayoutIter Gets the extents of the current character, in layout coordinates (origin is the top left of the entire layout). Only logical extents can sensibly be obtained for characters; ink extents make sense only down to the level of clusters. a #PangoLayoutIter rectangle to fill with logical extents Gets the extents of the current cluster, in layout coordinates (origin is the top left of the entire layout). a #PangoLayoutIter rectangle to fill with ink extents, or %NULL rectangle to fill with logical extents, or %NULL Gets the current byte index. Note that iterating forward by char moves in visual order, not logical order, so indexes may not be sequential. Also, the index may be equal to the length of the text in the layout, if on the %NULL run (see pango_layout_iter_get_run()). current byte index. a #PangoLayoutIter Gets the layout associated with a #PangoLayoutIter. the layout associated with @iter. a #PangoLayoutIter Obtains the extents of the #PangoLayout being iterated over. @ink_rect or @logical_rect can be %NULL if you aren't interested in them. a #PangoLayoutIter rectangle to fill with ink extents, or %NULL rectangle to fill with logical extents, or %NULL Gets the current line. Use the faster pango_layout_iter_get_line_readonly() if you do not plan to modify the contents of the line (glyphs, glyph widths, etc.). the current line. a #PangoLayoutIter Obtains the extents of the current line. @ink_rect or @logical_rect can be %NULL if you aren't interested in them. Extents are in layout coordinates (origin is the top-left corner of the entire #PangoLayout). Thus the extents returned by this function will be the same width/height but not at the same x/y as the extents returned from pango_layout_line_get_extents(). a #PangoLayoutIter rectangle to fill with ink extents, or %NULL rectangle to fill with logical extents, or %NULL Gets the current line for read-only access. This is a faster alternative to pango_layout_iter_get_line(), but the user is not expected to modify the contents of the line (glyphs, glyph widths, etc.). the current line, that should not be modified. a #PangoLayoutIter Divides the vertical space in the #PangoLayout being iterated over between the lines in the layout, and returns the space belonging to the current line. A line's range includes the line's logical extents, plus half of the spacing above and below the line, if pango_layout_set_spacing() has been called to set layout spacing. The Y positions are in layout coordinates (origin at top left of the entire layout). Note: Since 1.44, Pango uses line heights for placing lines, and there may be gaps between the ranges returned by this function. a #PangoLayoutIter start of line, or %NULL end of line, or %NULL Gets the current run. When iterating by run, at the end of each line, there's a position with a %NULL run, so this function can return %NULL. The %NULL run at the end of each line ensures that all lines have at least one run, even lines consisting of only a newline. Use the faster pango_layout_iter_get_run_readonly() if you do not plan to modify the contents of the run (glyphs, glyph widths, etc.). the current run. a #PangoLayoutIter Gets the extents of the current run in layout coordinates (origin is the top left of the entire layout). a #PangoLayoutIter rectangle to fill with ink extents, or %NULL rectangle to fill with logical extents, or %NULL Gets the current run. When iterating by run, at the end of each line, there's a position with a %NULL run, so this function can return %NULL. The %NULL run at the end of each line ensures that all lines have at least one run, even lines consisting of only a newline. This is a faster alternative to pango_layout_iter_get_run(), but the user is not expected to modify the contents of the run (glyphs, glyph widths, etc.). the current run, that should not be modified. a #PangoLayoutIter Moves @iter forward to the next character in visual order. If @iter was already at the end of the layout, returns %FALSE. whether motion was possible. a #PangoLayoutIter Moves @iter forward to the next cluster in visual order. If @iter was already at the end of the layout, returns %FALSE. whether motion was possible. a #PangoLayoutIter Moves @iter forward to the start of the next line. If @iter is already on the last line, returns %FALSE. whether motion was possible. a #PangoLayoutIter Moves @iter forward to the next run in visual order. If @iter was already at the end of the layout, returns %FALSE. whether motion was possible. a #PangoLayoutIter The #PangoLayoutLine structure represents one of the lines resulting from laying out a paragraph via #PangoLayout. #PangoLayoutLine structures are obtained by calling pango_layout_get_line() and are only valid until the text, attributes, or settings of the parent #PangoLayout are modified. Routines for rendering PangoLayout objects are provided in code specific to each rendering system. the layout this line belongs to, might be %NULL start of line as byte index into layout->text length of line in bytes list of runs in the line, from left to right #TRUE if this is the first line of the paragraph #Resolved PangoDirection of line Computes the logical and ink extents of a layout line. See pango_font_get_glyph_extents() for details about the interpretation of the rectangles. a #PangoLayoutLine rectangle used to store the extents of the glyph string as drawn, or %NULL rectangle used to store the logical extents of the glyph string, or %NULL Computes the height of the line, ie the distance between this and the previous lines baseline. a #PangoLayoutLine return location for the line height Computes the logical and ink extents of @layout_line in device units. This function just calls pango_layout_line_get_extents() followed by two pango_extents_to_pixels() calls, rounding @ink_rect and @logical_rect such that the rounded rectangles fully contain the unrounded one (that is, passes them as first argument to pango_extents_to_pixels()). a #PangoLayoutLine rectangle used to store the extents of the glyph string as drawn, or %NULL rectangle used to store the logical extents of the glyph string, or %NULL Gets a list of visual ranges corresponding to a given logical range. This list is not necessarily minimal - there may be consecutive ranges which are adjacent. The ranges will be sorted from left to right. The ranges are with respect to the left edge of the entire layout, not with respect to the line. a #PangoLayoutLine Start byte index of the logical range. If this value is less than the start index for the line, then the first range will extend all the way to the leading edge of the layout. Otherwise it will start at the leading edge of the first character. Ending byte index of the logical range. If this value is greater than the end index for the line, then the last range will extend all the way to the trailing edge of the layout. Otherwise, it will end at the trailing edge of the last character. location to store a pointer to an array of ranges. The array will be of length <literal>2*n_ranges</literal>, with each range starting at <literal>(*ranges)[2*n]</literal> and of width <literal>(*ranges)[2*n + 1] - (*ranges)[2*n]</literal>. This array must be freed with g_free(). The coordinates are relative to the layout and are in Pango units. The number of ranges stored in @ranges. Converts an index within a line to a X position. a #PangoLayoutLine byte offset of a grapheme within the layout an integer indicating the edge of the grapheme to retrieve the position of. If > 0, the trailing edge of the grapheme, if 0, the leading of the grapheme. location to store the x_offset (in Pango unit) Increase the reference count of a #PangoLayoutLine by one. the line passed in. a #PangoLayoutLine, may be %NULL Decrease the reference count of a #PangoLayoutLine by one. If the result is zero, the line and all associated memory will be freed. a #PangoLayoutLine Converts from x offset to the byte index of the corresponding character within the text of the layout. If @x_pos is outside the line, @index_ and @trailing will point to the very first or very last position in the line. This determination is based on the resolved direction of the paragraph; for example, if the resolved direction is right-to-left, then an X position to the right of the line (after it) results in 0 being stored in @index_ and @trailing. An X position to the left of the line results in @index_ pointing to the (logical) last grapheme in the line and @trailing being set to the number of characters in that grapheme. The reverse is true for a left-to-right line. %FALSE if @x_pos was outside the line, %TRUE if inside a #PangoLayoutLine the X offset (in Pango units) from the left edge of the line. location to store calculated byte index for the grapheme in which the user clicked. location to store an integer indicating where in the grapheme the user clicked. It will either be zero, or the number of characters in the grapheme. 0 represents the leading edge of the grapheme. The #PangoLogAttr structure stores information about the attributes of a single character. if set, can break line in front of character if set, must break line in front of character if set, can break here when doing character wrapping is whitespace character if set, cursor can appear in front of character. i.e. this is a grapheme boundary, or the first character in the text. This flag implements Unicode's <ulink url="http://www.unicode.org/reports/tr29/">Grapheme Cluster Boundaries</ulink> semantics. is first character in a word is first non-word char after a word Note that in degenerate cases, you could have both @is_word_start and @is_word_end set for some character. is a sentence boundary. There are two ways to divide sentences. The first assigns all inter-sentence whitespace/control/format chars to some sentence, so all chars are in some sentence; @is_sentence_boundary denotes the boundaries there. The second way doesn't assign between-sentence spaces, etc. to any sentence, so @is_sentence_start/@is_sentence_end mark the boundaries of those sentences. is first character in a sentence is first char after a sentence. Note that in degenerate cases, you could have both @is_sentence_start and @is_sentence_end set for some character. (e.g. no space after a period, so the next sentence starts right away) if set, backspace deletes one character rather than the entire grapheme cluster. This field is only meaningful on grapheme boundaries (where @is_cursor_position is set). In some languages, the full grapheme (e.g. letter + diacritics) is considered a unit, while in others, each decomposed character in the grapheme is a unit. In the default implementation of pango_break(), this bit is set on all grapheme boundaries except those following Latin, Cyrillic or Greek base characters. is a whitespace character that can possibly be expanded for justification purposes. (Since: 1.18) is a word boundary, as defined by UAX#29. More specifically, means that this is not a position in the middle of a word. For example, both sides of a punctuation mark are considered word boundaries. This flag is particularly useful when selecting text word-by-word. This flag implements Unicode's <ulink url="http://www.unicode.org/reports/tr29/">Word Boundaries</ulink> semantics. (Since: 1.22) Do not use. Does not do anything. %NULL. a #PangoMap a #PangoScript Do not use. Does not do anything. a #PangoMap a #PangoScript location to store list of engines that exactly handle this script. location to store list of engines that approximately handle this script. A structure specifying a transformation between user-space coordinates and device coordinates. The transformation is given by <programlisting> x_device = x_user * matrix->xx + y_user * matrix->xy + matrix->x0; y_device = x_user * matrix->yx + y_user * matrix->yy + matrix->y0; </programlisting> 1st component of the transformation matrix 2nd component of the transformation matrix 3rd component of the transformation matrix 4th component of the transformation matrix x translation y translation Changes the transformation represented by @matrix to be the transformation given by first applying transformation given by @new_matrix then applying the original transformation. a #PangoMatrix a #PangoMatrix Copies a #PangoMatrix. the newly allocated #PangoMatrix, which should be freed with pango_matrix_free(), or %NULL if @matrix was %NULL. a #PangoMatrix, may be %NULL Free a #PangoMatrix created with pango_matrix_copy(). a #PangoMatrix, may be %NULL Returns the scale factor of a matrix on the height of the font. That is, the scale factor in the direction perpendicular to the vector that the X coordinate is mapped to. If the scale in the X coordinate is needed as well, use pango_matrix_get_font_scale_factors(). the scale factor of @matrix on the height of the font, or 1.0 if @matrix is %NULL. a #PangoMatrix, may be %NULL Calculates the scale factor of a matrix on the width and height of the font. That is, @xscale is the scale factor in the direction of the X coordinate, and @yscale is the scale factor in the direction perpendicular to the vector that the X coordinate is mapped to. Note that output numbers will always be non-negative. a #PangoMatrix, or %NULL output scale factor in the x direction, or %NULL output scale factor perpendicular to the x direction, or %NULL Changes the transformation represented by @matrix to be the transformation given by first rotating by @degrees degrees counter-clockwise then applying the original transformation. a #PangoMatrix degrees to rotate counter-clockwise Changes the transformation represented by @matrix to be the transformation given by first scaling by @sx in the X direction and @sy in the Y direction then applying the original transformation. a #PangoMatrix amount to scale by in X direction amount to scale by in Y direction Transforms the distance vector (@dx,@dy) by @matrix. This is similar to pango_matrix_transform_point() except that the translation components of the transformation are ignored. The calculation of the returned vector is as follows: <programlisting> dx2 = dx1 * xx + dy1 * xy; dy2 = dx1 * yx + dy1 * yy; </programlisting> Affine transformations are position invariant, so the same vector always transforms to the same vector. If (@x1,@y1) transforms to (@x2,@y2) then (@x1+@dx1,@y1+@dy1) will transform to (@x1+@dx2,@y1+@dy2) for all values of @x1 and @x2. a #PangoMatrix, or %NULL in/out X component of a distance vector in/out Y component of a distance vector First transforms the @rect using @matrix, then calculates the bounding box of the transformed rectangle. The rectangle should be in device units (pixels). This function is useful for example when you want to draw a rotated @PangoLayout to an image buffer, and want to know how large the image should be and how much you should shift the layout when rendering. For better accuracy, you should use pango_matrix_transform_rectangle() on original rectangle in Pango units and convert to pixels afterward using pango_extents_to_pixels()'s first argument. a #PangoMatrix, or %NULL in/out bounding box in device units, or %NULL Transforms the point (@x, @y) by @matrix. a #PangoMatrix, or %NULL in/out X position in/out Y position First transforms @rect using @matrix, then calculates the bounding box of the transformed rectangle. The rectangle should be in Pango units. This function is useful for example when you want to draw a rotated @PangoLayout to an image buffer, and want to know how large the image should be and how much you should shift the layout when rendering. If you have a rectangle in device units (pixels), use pango_matrix_transform_pixel_rectangle(). If you have the rectangle in Pango units and want to convert to transformed pixel bounding box, it is more accurate to transform it first (using this function) and pass the result to pango_extents_to_pixels(), first argument, for an inclusive rounded rectangle. However, there are valid reasons that you may want to convert to pixels first and then transform, for example when the transformed coordinates may overflow in Pango units (large matrix translation for example). a #PangoMatrix, or %NULL in/out bounding box in Pango units, or %NULL Changes the transformation represented by @matrix to be the transformation given by first translating by (@tx, @ty) then applying the original transformation. a #PangoMatrix amount to translate in the X direction amount to translate in the Y direction The #PangoOverline enumeration is used to specify whether text should be overlined, and if so, the type of line. no overline should be drawn Draw a single line above the ink extents of the text being underlined. Converts a dimension to device units by rounding. a dimension in Pango units. Converts a dimension to device units by ceiling. a dimension in Pango units. Converts a dimension to device units by flooring. a dimension in Pango units. Extracts the <firstterm>right bearing</firstterm> from a #PangoRectangle representing glyph extents. The right bearing is the distance from the horizontal origin to the farthest right point of the character. This is positive except for characters drawn completely to the left of the horizontal origin. a #PangoRectangle A string constant defining the render type for engines that are not rendering-system specific. The #PangoRectangle structure represents a rectangle. It is frequently used to represent the logical or ink extents of a single glyph or section of text. (See, for instance, pango_font_get_glyph_extents()) X coordinate of the left side of the rectangle. Y coordinate of the the top side of the rectangle. width of the rectangle. height of the rectangle. #PangoRenderPart defines different items to render for such purposes as setting colors. the text itself the area behind the text underlines strikethrough lines overlines #PangoRenderer is a base class for objects that are used to render Pango objects such as #PangoGlyphString and #PangoLayout. Draw a squiggly line that approximately covers the given rectangle in the style of an underline used to indicate a spelling error. (The width of the underline is rounded to an integer number of up/down segments and the resulting rectangle is centered in the original rectangle) This should be called while @renderer is already active. Use pango_renderer_activate() to activate a renderer. a #PangoRenderer X coordinate of underline, in Pango units in user coordinate system Y coordinate of underline, in Pango units in user coordinate system width of underline, in Pango units in user coordinate system height of underline, in Pango units in user coordinate system Draws a single glyph with coordinates in device space. a #PangoRenderer a #PangoFont the glyph index of a single glyph X coordinate of left edge of baseline of glyph Y coordinate of left edge of baseline of glyph Draws the glyphs in @glyph_item with the specified #PangoRenderer, embedding the text associated with the glyphs in the output if the output format supports it (PDF for example). Note that @text is the start of the text for layout, which is then indexed by <literal>@glyph_item->item->offset</literal>. If @text is %NULL, this simply calls pango_renderer_draw_glyphs(). The default implementation of this method simply falls back to pango_renderer_draw_glyphs(). a #PangoRenderer the UTF-8 text that @glyph_item refers to, or %NULL a #PangoGlyphItem X position of left edge of baseline, in user space coordinates in Pango units. Y position of left edge of baseline, in user space coordinates in Pango units. Draws the glyphs in @glyphs with the specified #PangoRenderer. a #PangoRenderer a #PangoFont a #PangoGlyphString X position of left edge of baseline, in user space coordinates in Pango units. Y position of left edge of baseline, in user space coordinates in Pango units. Draws an axis-aligned rectangle in user space coordinates with the specified #PangoRenderer. This should be called while @renderer is already active. Use pango_renderer_activate() to activate a renderer. a #PangoRenderer type of object this rectangle is part of X position at which to draw rectangle, in user space coordinates in Pango units Y position at which to draw rectangle, in user space coordinates in Pango units width of rectangle in Pango units in user space coordinates height of rectangle in Pango units in user space coordinates Draws a trapezoid with the parallel sides aligned with the X axis using the given #PangoRenderer; coordinates are in device space. a #PangoRenderer type of object this trapezoid is part of Y coordinate of top of trapezoid X coordinate of left end of top of trapezoid X coordinate of right end of top of trapezoid Y coordinate of bottom of trapezoid X coordinate of left end of bottom of trapezoid X coordinate of right end of bottom of trapezoid Informs Pango that the way that the rendering is done for @part has changed in a way that would prevent multiple pieces being joined together into one drawing call. For instance, if a subclass of #PangoRenderer was to add a stipple option for drawing underlines, it needs to call <informalexample><programlisting> pango_renderer_part_changed (render, PANGO_RENDER_PART_UNDERLINE); </programlisting></informalexample> When the stipple changes or underlines with different stipples might be joined together. Pango automatically calls this for changes to colors. (See pango_renderer_set_color()) a #PangoRenderer the part for which rendering has changed. Does initial setup before rendering operations on @renderer. pango_renderer_deactivate() should be called when done drawing. Calls such as pango_renderer_draw_layout() automatically activate the layout before drawing on it. Calls to pango_renderer_activate() and pango_renderer_deactivate() can be nested and the renderer will only be initialized and deinitialized once. a #PangoRenderer Cleans up after rendering operations on @renderer. See docs for pango_renderer_activate(). a #PangoRenderer Draw a squiggly line that approximately covers the given rectangle in the style of an underline used to indicate a spelling error. (The width of the underline is rounded to an integer number of up/down segments and the resulting rectangle is centered in the original rectangle) This should be called while @renderer is already active. Use pango_renderer_activate() to activate a renderer. a #PangoRenderer X coordinate of underline, in Pango units in user coordinate system Y coordinate of underline, in Pango units in user coordinate system width of underline, in Pango units in user coordinate system height of underline, in Pango units in user coordinate system Draws a single glyph with coordinates in device space. a #PangoRenderer a #PangoFont the glyph index of a single glyph X coordinate of left edge of baseline of glyph Y coordinate of left edge of baseline of glyph Draws the glyphs in @glyph_item with the specified #PangoRenderer, embedding the text associated with the glyphs in the output if the output format supports it (PDF for example). Note that @text is the start of the text for layout, which is then indexed by <literal>@glyph_item->item->offset</literal>. If @text is %NULL, this simply calls pango_renderer_draw_glyphs(). The default implementation of this method simply falls back to pango_renderer_draw_glyphs(). a #PangoRenderer the UTF-8 text that @glyph_item refers to, or %NULL a #PangoGlyphItem X position of left edge of baseline, in user space coordinates in Pango units. Y position of left edge of baseline, in user space coordinates in Pango units. Draws the glyphs in @glyphs with the specified #PangoRenderer. a #PangoRenderer a #PangoFont a #PangoGlyphString X position of left edge of baseline, in user space coordinates in Pango units. Y position of left edge of baseline, in user space coordinates in Pango units. Draws @layout with the specified #PangoRenderer. a #PangoRenderer a #PangoLayout X position of left edge of baseline, in user space coordinates in Pango units. Y position of left edge of baseline, in user space coordinates in Pango units. Draws @line with the specified #PangoRenderer. a #PangoRenderer a #PangoLayoutLine X position of left edge of baseline, in user space coordinates in Pango units. Y position of left edge of baseline, in user space coordinates in Pango units. Draws an axis-aligned rectangle in user space coordinates with the specified #PangoRenderer. This should be called while @renderer is already active. Use pango_renderer_activate() to activate a renderer. a #PangoRenderer type of object this rectangle is part of X position at which to draw rectangle, in user space coordinates in Pango units Y position at which to draw rectangle, in user space coordinates in Pango units width of rectangle in Pango units in user space coordinates height of rectangle in Pango units in user space coordinates Draws a trapezoid with the parallel sides aligned with the X axis using the given #PangoRenderer; coordinates are in device space. a #PangoRenderer type of object this trapezoid is part of Y coordinate of top of trapezoid X coordinate of left end of top of trapezoid X coordinate of right end of top of trapezoid Y coordinate of bottom of trapezoid X coordinate of left end of bottom of trapezoid X coordinate of right end of bottom of trapezoid Gets the current alpha for the specified part. the alpha for the specified part, or 0 if it hasn't been set and should be inherited from the environment. a #PangoRenderer the part to get the alpha for Gets the current rendering color for the specified part. the color for the specified part, or %NULL if it hasn't been set and should be inherited from the environment. a #PangoRenderer the part to get the color for Gets the layout currently being rendered using @renderer. Calling this function only makes sense from inside a subclass's methods, like in its draw_shape vfunc, for example. The returned layout should not be modified while still being rendered. the layout, or %NULL if no layout is being rendered using @renderer at this time. a #PangoRenderer Gets the layout line currently being rendered using @renderer. Calling this function only makes sense from inside a subclass's methods, like in its draw_shape vfunc, for example. The returned layout line should not be modified while still being rendered. the layout line, or %NULL if no layout line is being rendered using @renderer at this time. a #PangoRenderer Gets the transformation matrix that will be applied when rendering. See pango_renderer_set_matrix(). the matrix, or %NULL if no matrix has been set (which is the same as the identity matrix). The returned matrix is owned by Pango and must not be modified or freed. a #PangoRenderer Informs Pango that the way that the rendering is done for @part has changed in a way that would prevent multiple pieces being joined together into one drawing call. For instance, if a subclass of #PangoRenderer was to add a stipple option for drawing underlines, it needs to call <informalexample><programlisting> pango_renderer_part_changed (render, PANGO_RENDER_PART_UNDERLINE); </programlisting></informalexample> When the stipple changes or underlines with different stipples might be joined together. Pango automatically calls this for changes to colors. (See pango_renderer_set_color()) a #PangoRenderer the part for which rendering has changed. Sets the alpha for part of the rendering. Note that the alpha may only be used if a color is specified for @part as well. a #PangoRenderer the part to set the alpha for an alpha value between 1 and 65536, or 0 to unset the alpha Sets the color for part of the rendering. Also see pango_renderer_set_alpha(). a #PangoRenderer the part to change the color of the new color or %NULL to unset the current color Sets the transformation matrix that will be applied when rendering. a #PangoRenderer a #PangoMatrix, or %NULL to unset any existing matrix. (No matrix set is the same as setting the identity matrix.) the current transformation matrix for the Renderer; may be %NULL, which should be treated the same as the identity matrix. Class structure for #PangoRenderer. The following vfuncs take user space coordinates in Pango units and have default implementations: - draw_glyphs - draw_rectangle - draw_error_underline - draw_shape - draw_glyph_item The default draw_shape implementation draws nothing. The following vfuncs take device space coordinates as doubles and must be implemented: - draw_trapezoid - draw_glyph a #PangoRenderer a #PangoFont a #PangoGlyphString X position of left edge of baseline, in user space coordinates in Pango units. Y position of left edge of baseline, in user space coordinates in Pango units. a #PangoRenderer type of object this rectangle is part of X position at which to draw rectangle, in user space coordinates in Pango units Y position at which to draw rectangle, in user space coordinates in Pango units width of rectangle in Pango units in user space coordinates height of rectangle in Pango units in user space coordinates a #PangoRenderer X coordinate of underline, in Pango units in user coordinate system Y coordinate of underline, in Pango units in user coordinate system width of underline, in Pango units in user coordinate system height of underline, in Pango units in user coordinate system a #PangoRenderer type of object this trapezoid is part of Y coordinate of top of trapezoid X coordinate of left end of top of trapezoid X coordinate of right end of top of trapezoid Y coordinate of bottom of trapezoid X coordinate of left end of bottom of trapezoid X coordinate of right end of bottom of trapezoid a #PangoRenderer a #PangoFont the glyph index of a single glyph X coordinate of left edge of baseline of glyph Y coordinate of left edge of baseline of glyph a #PangoRenderer the part for which rendering has changed. a #PangoRenderer the UTF-8 text that @glyph_item refers to, or %NULL a #PangoGlyphItem X position of left edge of baseline, in user space coordinates in Pango units. Y position of left edge of baseline, in user space coordinates in Pango units. The %PANGO_SCALE macro represents the scale between dimensions used for Pango distances and device units. (The definition of device units is dependent on the output device; it will typically be pixels for a screen, and points for a printer.) %PANGO_SCALE is currently 1024, but this may be changed in the future. When setting font sizes, device units are always considered to be points (as in "12 point font"), rather than pixels. The #PangoScript enumeration identifies different writing systems. The values correspond to the names as defined in the Unicode standard. See <ulink url="http://www.unicode.org/reports/tr24/">Unicode Standard Annex #24: Script names</ulink>. Note that this enumeration is deprecated and will not be updated to include values in newer versions of the Unicode standard. Applications should use the GUnicodeScript enumeration instead, whose values are interchangeable with PangoScript. a value never returned from pango_script_for_unichar() a character used by multiple different scripts a mark glyph that takes its script from the base glyph to which it is attached Arabic Armenian Bengali Bopomofo Cherokee Coptic Cyrillic Deseret Devanagari Ethiopic Georgian Gothic Greek Gujarati Gurmukhi Han Hangul Hebrew Hiragana Kannada Katakana Khmer Lao Latin Malayalam Mongolian Myanmar Ogham Old Italic Oriya Runic Sinhala Syriac Tamil Telugu Thaana Thai Tibetan Canadian Aboriginal Yi Tagalog Hanunoo Buhid Tagbanwa Braille Cypriot Limbu Osmanya Shavian Linear B Tai Le Ugaritic New Tai Lue. Since 1.10 Buginese. Since 1.10 Glagolitic. Since 1.10 Tifinagh. Since 1.10 Syloti Nagri. Since 1.10 Old Persian. Since 1.10 Kharoshthi. Since 1.10 an unassigned code point. Since 1.14 Balinese. Since 1.14 Cuneiform. Since 1.14 Phoenician. Since 1.14 Phags-pa. Since 1.14 N'Ko. Since 1.14 Kayah Li. Since 1.20.1 Lepcha. Since 1.20.1 Rejang. Since 1.20.1 Sundanese. Since 1.20.1 Saurashtra. Since 1.20.1 Cham. Since 1.20.1 Ol Chiki. Since 1.20.1 Vai. Since 1.20.1 Carian. Since 1.20.1 Lycian. Since 1.20.1 Lydian. Since 1.20.1 Batak. Since 1.32 Brahmi. Since 1.32 Mandaic. Since 1.32 Chakma. Since: 1.32 Meroitic Cursive. Since: 1.32 Meroitic Hieroglyphs. Since: 1.32 Miao. Since: 1.32 Sharada. Since: 1.32 Sora Sompeng. Since: 1.32 Takri. Since: 1.32 Bassa. Since: 1.40 Caucasian Albanian. Since: 1.40 Duployan. Since: 1.40 Elbasan. Since: 1.40 Grantha. Since: 1.40 Kjohki. Since: 1.40 Khudawadi, Sindhi. Since: 1.40 Linear A. Since: 1.40 Mahajani. Since: 1.40 Manichaean. Since: 1.40 Mende Kikakui. Since: 1.40 Modi. Since: 1.40 Mro. Since: 1.40 Nabataean. Since: 1.40 Old North Arabian. Since: 1.40 Old Permic. Since: 1.40 Pahawh Hmong. Since: 1.40 Palmyrene. Since: 1.40 Pau Cin Hau. Since: 1.40 Psalter Pahlavi. Since: 1.40 Siddham. Since: 1.40 Tirhuta. Since: 1.40 Warang Citi. Since: 1.40 Ahom. Since: 1.40 Anatolian Hieroglyphs. Since: 1.40 Hatran. Since: 1.40 Multani. Since: 1.40 Old Hungarian. Since: 1.40 Signwriting. Since: 1.40 Looks up the script for a particular character (as defined by Unicode Standard Annex \#24). No check is made for @ch being a valid Unicode character; if you pass in invalid character, the result is undefined. Note that while the return type of this function is declared as PangoScript, as of Pango 1.18, this function simply returns the return value of g_unichar_get_script(). Callers must be prepared to handle unknown values. Use g_unichar_get_script() the #PangoScript for the character. a Unicode character Given a script, finds a language tag that is reasonably representative of that script. This will usually be the most widely spoken or used language written in that script: for instance, the sample language for %PANGO_SCRIPT_CYRILLIC is <literal>ru</literal> (Russian), the sample language for %PANGO_SCRIPT_ARABIC is <literal>ar</literal>. For some scripts, no sample language will be returned because there is no language that is sufficiently representative. The best example of this is %PANGO_SCRIPT_HAN, where various different variants of written Chinese, Japanese, and Korean all use significantly different sets of Han characters and forms of shared characters. No sample language can be provided for many historical scripts as well. As of 1.18, this function checks the environment variables PANGO_LANGUAGE and LANGUAGE (checked in that order) first. If one of them is set, it is parsed as a list of language tags separated by colons or other separators. This function will return the first language in the parsed list that Pango believes may use @script for writing. This last predicate is tested using pango_language_includes_script(). This can be used to control Pango's font selection for non-primary languages. For example, a PANGO_LANGUAGE enviroment variable set to "en:fa" makes Pango choose fonts suitable for Persian (fa) instead of Arabic (ar) when a segment of Arabic text is found in an otherwise non-Arabic text. The same trick can be used to choose a default language for %PANGO_SCRIPT_HAN when setting context language is not feasible. a #PangoLanguage that is representative of the script, or %NULL if no such language exists. a #PangoScript A #PangoScriptIter is used to iterate through a string and identify ranges in different scripts. Create a new #PangoScriptIter, used to break a string of Unicode text into runs by Unicode script. No copy is made of @text, so the caller needs to make sure it remains valid until the iterator is freed with pango_script_iter_free(). the new script iterator, initialized to point at the first range in the text, which should be freed with pango_script_iter_free(). If the string is empty, it will point at an empty range. a UTF-8 string length of @text, or -1 if @text is nul-terminated. Frees a #PangoScriptIter created with pango_script_iter_new(). a #PangoScriptIter Gets information about the range to which @iter currently points. The range is the set of locations p where *start <= p < *end. (That is, it doesn't include the character stored at *end) Note that while the type of the @script argument is declared as PangoScript, as of Pango 1.18, this function simply returns GUnicodeScript values. Callers must be prepared to handle unknown values. a #PangoScriptIter location to store start position of the range, or %NULL location to store end position of the range, or %NULL location to store script for range, or %NULL Advances a #PangoScriptIter to the next range. If @iter is already at the end, it is left unchanged and %FALSE is returned. %TRUE if @iter was successfully advanced. a #PangoScriptIter Flags influencing the shaping process. These can be passed to pango_shape_with_flags(). Default value. Round glyph positions and widths to whole device units. This option should be set if the target renderer can't do subpixel positioning of glyphs. These flags affect how Pango treats characters that are normally not visible in the output. No special treatment for invisible characters Render spaces, tabs and newlines visibly Render line breaks visibly Render default-ignorable Unicode characters visibly An enumeration specifying the width of the font relative to other designs within a family. ultra condensed width extra condensed width condensed width semi condensed width the normal width semi expanded width expanded width extra expanded width ultra expanded width An enumeration specifying the various slant styles possible for a font. the font is upright. the font is slanted, but in a roman style. the font is slanted in an italic style. A #PangoTabAlign specifies where a tab stop appears relative to the text. the tab stop appears to the left of the text. A #PangoTabArray struct contains an array of tab stops. Each tab stop has an alignment and a position. Creates an array of @initial_size tab stops. Tab stops are specified in pixel units if @positions_in_pixels is %TRUE, otherwise in Pango units. All stops are initially at position 0. the newly allocated #PangoTabArray, which should be freed with pango_tab_array_free(). Initial number of tab stops to allocate, can be 0 whether positions are in pixel units This is a convenience function that creates a #PangoTabArray and allows you to specify the alignment and position of each tab stop. You <emphasis>must</emphasis> provide an alignment and position for @size tab stops. the newly allocated #PangoTabArray, which should be freed with pango_tab_array_free(). number of tab stops in the array whether positions are in pixel units alignment of first tab stop position of first tab stop additional alignment/position pairs Copies a #PangoTabArray the newly allocated #PangoTabArray, which should be freed with pango_tab_array_free(). #PangoTabArray to copy Frees a tab array and associated resources. a #PangoTabArray Returns %TRUE if the tab positions are in pixels, %FALSE if they are in Pango units. whether positions are in pixels. a #PangoTabArray Gets the number of tab stops in @tab_array. the number of tab stops in the array. a #PangoTabArray Gets the alignment and position of a tab stop. a #PangoTabArray tab stop index location to store alignment, or %NULL location to store tab position, or %NULL If non-%NULL, @alignments and @locations are filled with allocated arrays of length pango_tab_array_get_size(). You must free the returned array. a #PangoTabArray location to store an array of tab stop alignments, or %NULL location to store an array of tab positions, or %NULL Resizes a tab array. You must subsequently initialize any tabs that were added as a result of growing the array. a #PangoTabArray new size of the array Sets the alignment and location of a tab stop. @alignment must always be #PANGO_TAB_LEFT in the current implementation. a #PangoTabArray the index of a tab stop tab alignment tab location in Pango units Rounds a dimension to whole device units, but does not convert it to device units. a dimension in Pango units. The #PangoUnderline enumeration is used to specify whether text should be underlined, and if so, the type of underlining. no underline should be drawn a single underline should be drawn a double underline should be drawn a single underline should be drawn at a position beneath the ink extents of the text being underlined. This should be used only for underlining single characters, such as for keyboard accelerators. %PANGO_UNDERLINE_SINGLE should be used for extended portions of text. a wavy underline should be drawn below. This underline is typically used to indicate an error such as a possible mispelling; in some cases a contrasting color may automatically be used. This type of underlining is available since Pango 1.4. Like @PANGO_UNDERLINE_SINGLE, but drawn continuously across multiple runs. This type of underlining is available since Pango 1.46. Like @PANGO_UNDERLINE_DOUBLE, but drawn continuously across multiple runs. This type of underlining is available since Pango 1.46. Like @PANGO_UNDERLINE_ERROR, but drawn continuously across multiple runs. This type of underlining is available since Pango 1.46. Checks that the version of Pango available at compile-time is not older than the provided version number. the major component of the version number the minor component of the version number the micro component of the version number This macro encodes the given Pango version into an integer. The numbers returned by %PANGO_VERSION and pango_version() are encoded using this macro. Two encoded version numbers can be compared as integers. the major component of the version number the minor component of the version number the micro component of the version number A macro that should be defined by the user prior to including the pango.h header. The definition should be one of the predefined Pango version macros: %PANGO_VERSION_1_2, %PANGO_VERSION_1_4,... This macro defines the earliest version of Pango that the package is required to be able to compile against. If the compiler is configured to warn about the use of deprecated functions, then using functions that were deprecated in version %PANGO_VERSION_MIN_REQUIRED or earlier will cause warnings (but using functions deprecated in later releases will not). An enumeration specifying capitalization variant of the font. A normal font. A font with the lower case characters replaced by smaller variants of the capital characters. An enumeration specifying the weight (boldness) of a font. This is a numerical value ranging from 100 to 1000, but there are some predefined values: the thin weight (= 100; Since: 1.24) the ultralight weight (= 200) the light weight (= 300) the semilight weight (= 350; Since: 1.36.7) the book weight (= 380; Since: 1.24) the default weight (= 400) the normal weight (= 500; Since: 1.24) the semibold weight (= 600) the bold weight (= 700) the ultrabold weight (= 800) the heavy weight (= 900) the ultraheavy weight (= 1000; Since: 1.24) A #PangoWrapMode describes how to wrap the lines of a #PangoLayout to the desired width. wrap lines at word boundaries. wrap lines at character boundaries. wrap lines at word boundaries, but fall back to character boundaries if there is not enough space for a full word. Create a new allow-breaks attribute. If breaks are disabled, the range will be kept in a single run, as far as possible. the newly allocated #PangoAttribute, which should be freed with pango_attribute_destroy() %TRUE if we line breaks are allowed Create a new background alpha attribute. the new allocated #PangoAttribute, which should be freed with pango_attribute_destroy(). the alpha value, between 1 and 65536 Create a new background color attribute. the newly allocated #PangoAttribute, which should be freed with pango_attribute_destroy(). the red value (ranging from 0 to 65535) the green value the blue value Create a new font fallback attribute. If fallback is disabled, characters will only be used from the closest matching font on the system. No fallback will be done to other fonts on the system that might contain the characters in the text. the newly allocated #PangoAttribute, which should be freed with pango_attribute_destroy(). %TRUE if we should fall back on other fonts for characters the active font is missing. Create a new font family attribute. the newly allocated #PangoAttribute, which should be freed with pango_attribute_destroy(). the family or comma separated list of families Create a new font description attribute. This attribute allows setting family, style, weight, variant, stretch, and size simultaneously. the newly allocated #PangoAttribute, which should be freed with pango_attribute_destroy(). the font description Create a new font features tag attribute. the newly allocated #PangoAttribute, which should be freed with pango_attribute_destroy(). a string with OpenType font features, in CSS syntax Create a new foreground alpha attribute. the new allocated #PangoAttribute, which should be freed with pango_attribute_destroy(). the alpha value, between 1 and 65536 Create a new foreground color attribute. the newly allocated #PangoAttribute, which should be freed with pango_attribute_destroy(). the red value (ranging from 0 to 65535) the green value the blue value Create a new gravity hint attribute. the newly allocated #PangoAttribute, which should be freed with pango_attribute_destroy(). the gravity hint value. Create a new gravity attribute. the newly allocated #PangoAttribute, which should be freed with pango_attribute_destroy(). the gravity value; should not be %PANGO_GRAVITY_AUTO. Create a new insert-hyphens attribute. Pango will insert hyphens when breaking lines in the middle of a word. This attribute can be used to suppress the hyphen. the newly allocated #PangoAttribute, which should be freed with pango_attribute_destroy() %TRUE if hyphens should be inserted Create a new language tag attribute. the newly allocated #PangoAttribute, which should be freed with pango_attribute_destroy(). language tag Create a new letter-spacing attribute. the newly allocated #PangoAttribute, which should be freed with pango_attribute_destroy(). amount of extra space to add between graphemes of the text, in Pango units. Create a new overline color attribute. This attribute modifies the color of overlines. If not set, overlines will use the foreground color. the newly allocated #PangoAttribute, which should be freed with pango_attribute_destroy(). the red value (ranging from 0 to 65535) the green value the blue value Create a new overline-style attribute. the newly allocated #PangoAttribute, which should be freed with pango_attribute_destroy(). the overline style Create a new baseline displacement attribute. the newly allocated #PangoAttribute, which should be freed with pango_attribute_destroy(). the amount that the text should be displaced vertically, in Pango units. Positive values displace the text upwards. Create a new font size scale attribute. The base font for the affected text will have its size multiplied by @scale_factor. the newly allocated #PangoAttribute, which should be freed with pango_attribute_destroy(). factor to scale the font Create a new shape attribute. A shape is used to impose a particular ink and logical rectangle on the result of shaping a particular glyph. This might be used, for instance, for embedding a picture or a widget inside a #PangoLayout. the newly allocated #PangoAttribute, which should be freed with pango_attribute_destroy(). ink rectangle to assign to each character logical rectangle to assign to each character Like pango_attr_shape_new(), but a user data pointer is also provided; this pointer can be accessed when later rendering the glyph. the newly allocated #PangoAttribute, which should be freed with pango_attribute_destroy(). ink rectangle to assign to each character logical rectangle to assign to each character user data pointer function to copy @data when the attribute is copied. If %NULL, @data is simply copied as a pointer. function to free @data when the attribute is freed, or %NULL Create a new attribute that influences how invisible characters are rendered. the newly allocated #PangoAttribute, which should be freed with pango_attribute_destroy(). #PangoShowFlags to apply Create a new font-size attribute in fractional points. the newly allocated #PangoAttribute, which should be freed with pango_attribute_destroy(). the font size, in %PANGO_SCALEths of a point. Create a new font-size attribute in device units. the newly allocated #PangoAttribute, which should be freed with pango_attribute_destroy(). the font size, in %PANGO_SCALEths of a device unit. Create a new font stretch attribute the newly allocated #PangoAttribute, which should be freed with pango_attribute_destroy(). the stretch Create a new strikethrough color attribute. This attribute modifies the color of strikethrough lines. If not set, strikethrough lines will use the foreground color. the newly allocated #PangoAttribute, which should be freed with pango_attribute_destroy(). the red value (ranging from 0 to 65535) the green value the blue value Create a new strike-through attribute. the newly allocated #PangoAttribute, which should be freed with pango_attribute_destroy(). %TRUE if the text should be struck-through. Create a new font slant style attribute. the newly allocated #PangoAttribute, which should be freed with pango_attribute_destroy(). the slant style Fetches the attribute type name passed in when registering the type using pango_attr_type_register(). The returned value is an interned string (see g_intern_string() for what that means) that should not be modified or freed. the type ID name (which may be %NULL), or %NULL if @type is a built-in Pango attribute type or invalid. an attribute type ID to fetch the name for Allocate a new attribute type ID. The attribute type name can be accessed later by using pango_attr_type_get_name(). the new type ID. an identifier for the type Create a new underline color attribute. This attribute modifies the color of underlines. If not set, underlines will use the foreground color. the newly allocated #PangoAttribute, which should be freed with pango_attribute_destroy(). the red value (ranging from 0 to 65535) the green value the blue value Create a new underline-style attribute. the newly allocated #PangoAttribute, which should be freed with pango_attribute_destroy(). the underline style. Create a new font variant attribute (normal or small caps) the newly allocated #PangoAttribute, which should be freed with pango_attribute_destroy(). the variant Create a new font weight attribute. the newly allocated #PangoAttribute, which should be freed with pango_attribute_destroy(). the weight Pango supports bidirectional text (like Arabic and Hebrew) automatically. Some applications however, need some help to correctly handle bidirectional text. The #PangoDirection type can be used with pango_context_set_base_dir() to instruct Pango about direction of text, though in most cases Pango detects that correctly and automatically. The rest of the facilities in this section are used internally by Pango already, and are provided to help applications that need more direct control over bidirectional setting of text. Determines the normative bidirectional character type of a character, as specified in the Unicode Character Database. A simplified version of this function is available as pango_unichar_direction(). the bidirectional character type, as used in the Unicode bidirectional algorithm. a Unicode character Determines possible line, word, and character breaks for a string of Unicode text with a single analysis. For most purposes you may want to use pango_get_log_attrs(). Use pango_default_break() and pango_tailor_break() the text to process. Must be valid UTF-8 length of @text in bytes (may be -1 if @text is nul-terminated) #PangoAnalysis structure from pango_itemize() an array to store character information in size of the array passed as @attrs The #PangoContext structure stores global information influencing Pango's operation, such as the fontmap used to look up fonts, and default values such as the default language, default gravity, or default font. It is often necessary in Pango to determine if a particular font can represent a particular character, and also how well it can represent that character. The #PangoCoverage is a data structure that is used to represent that information. This is the default break algorithm. It applies Unicode rules without language-specific tailoring, therefore the @analyis argument is unused and can be %NULL. See pango_tailor_break() for language-specific breaks. text to break. Must be valid UTF-8 length of text in bytes (may be -1 if @text is nul-terminated) a #PangoAnalysis for the @text logical attributes to fill in size of the array passed as @attrs Pango used to have a module architecture in which the language-specific and render-system-specific components are provided by loadable modules. This is no longer the case, and all the APIs related to modules and engines should not be used anymore. Converts extents from Pango units to device units, dividing by the %PANGO_SCALE factor and performing rounding. The @inclusive rectangle is converted by flooring the x/y coordinates and extending width/height, such that the final rectangle completely includes the original rectangle. The @nearest rectangle is converted by rounding the coordinates of the rectangle to the nearest device unit (pixel). The rule to which argument to use is: if you want the resulting device-space rectangle to completely contain the original rectangle, pass it in as @inclusive. If you want two touching-but-not-overlapping rectangles stay touching-but-not-overlapping after rounding to device units, pass them in as @nearest. rectangle to round to pixels inclusively, or %NULL. rectangle to round to nearest pixels, or %NULL. Searches a string the first character that has a strong direction, according to the Unicode bidirectional algorithm. The direction corresponding to the first strong character. If no such character is found, then %PANGO_DIRECTION_NEUTRAL is returned. the text to process. Must be valid UTF-8 length of @text in bytes (may be -1 if @text is nul-terminated) Do not use. Does not do anything. %NULL. the language tag for which to find the map the engine type for the map to find the render type for the map to find Locates a paragraph boundary in @text. A boundary is caused by delimiter characters, such as a newline, carriage return, carriage return-newline pair, or Unicode paragraph separator character. The index of the run of delimiters is returned in @paragraph_delimiter_index. The index of the start of the paragraph (index after all delimiters) is stored in @next_paragraph_start. If no delimiters are found, both @paragraph_delimiter_index and @next_paragraph_start are filled with the length of @text (an index one off the end). UTF-8 text length of @text in bytes, or -1 if nul-terminated return location for index of delimiter return location for start of next paragraph Creates a new font description from a string representation in the form "\[FAMILY-LIST] \[STYLE-OPTIONS] \[SIZE] \[VARIATIONS]", where FAMILY-LIST is a comma-separated list of families optionally terminated by a comma, STYLE_OPTIONS is a whitespace-separated list of words where each word describes one of style, variant, weight, stretch, or gravity, and SIZE is a decimal number (size in points) or optionally followed by the unit modifier "px" for absolute size. VARIATIONS is a comma-separated list of font variation specifications of the form "\@axis=value" (the = sign is optional). The following words are understood as styles: "Normal", "Roman", "Oblique", "Italic". The following words are understood as variants: "Small-Caps". The following words are understood as weights: "Thin", "Ultra-Light", "Extra-Light", "Light", "Semi-Light", "Demi-Light", "Book", "Regular", "Medium", "Semi-Bold", "Demi-Bold", "Bold", "Ultra-Bold", "Extra-Bold", "Heavy", "Black", "Ultra-Black", "Extra-Black". The following words are understood as stretch values: "Ultra-Condensed", "Extra-Condensed", "Condensed", "Semi-Condensed", "Semi-Expanded", "Expanded", "Extra-Expanded", "Ultra-Expanded". The following words are understood as gravity values: "Not-Rotated", "South", "Upside-Down", "North", "Rotated-Left", "East", "Rotated-Right", "West". Any one of the options may be absent. If FAMILY-LIST is absent, then the family_name field of the resulting font description will be initialized to %NULL. If STYLE-OPTIONS is missing, then all style options will be set to the default values. If SIZE is missing, the size in the resulting font description will be set to 0. A typical example: "Cantarell Italic Light 15 \@wght=200" a new #PangoFontDescription. string representation of a font description. Pango supports a flexible architecture where a particular rendering architecture can supply an implementation of fonts. The #PangoFont structure represents an abstract rendering-system-independent font. Pango provides routines to list available fonts, and to load a font matching a given description. Computes a #PangoLogAttr for each character in @text. The @log_attrs array must have one #PangoLogAttr for each position in @text; if @text contains N characters, it has N+1 positions, including the last position at the end of the text. @text should be an entire paragraph; logical attributes can't be computed without context (for example you need to see spaces on either side of a word to know the word is a word). text to process. Must be valid UTF-8 length in bytes of @text embedding level, or -1 if unknown language tag array with one #PangoLogAttr per character in @text, plus one extra, to be filled in length of @log_attrs array If @ch has the Unicode mirrored property and there is another Unicode character that typically has a glyph that is the mirror image of @ch's glyph, puts that character in the address pointed to by @mirrored_ch. Use g_unichar_get_mirror_char() instead; the docs for that function provide full details. %TRUE if @ch has a mirrored character and @mirrored_ch is filled in, %FALSE otherwise a Unicode character location to store the mirrored character pango_shape() produces a string of glyphs which can be measured or drawn to the screen. The following structures are used to store information about glyphs. Finds the gravity that best matches the rotation component in a #PangoMatrix. the gravity of @matrix, which will never be %PANGO_GRAVITY_AUTO, or %PANGO_GRAVITY_SOUTH if @matrix is %NULL a #PangoMatrix Based on the script, base gravity, and hint, returns actual gravity to use in laying out a single #PangoItem. If @base_gravity is %PANGO_GRAVITY_AUTO, it is first replaced with the preferred gravity of @script. To get the preferred gravity of a script, pass %PANGO_GRAVITY_AUTO and %PANGO_GRAVITY_HINT_STRONG in. resolved gravity suitable to use for a run of text with @script. #PangoScript to query base gravity of the paragraph orientation hint Based on the script, East Asian width, base gravity, and hint, returns actual gravity to use in laying out a single character or #PangoItem. This function is similar to pango_gravity_get_for_script() except that this function makes a distinction between narrow/half-width and wide/full-width characters also. Wide/full-width characters always stand <emphasis>upright</emphasis>, that is, they always take the base gravity, whereas narrow/full-width characters are always rotated in vertical context. If @base_gravity is %PANGO_GRAVITY_AUTO, it is first replaced with the preferred gravity of @script. resolved gravity suitable to use for a run of text with @script and @wide. #PangoScript to query %TRUE for wide characters as returned by g_unichar_iswide() base gravity of the paragraph orientation hint Converts a #PangoGravity value to its natural rotation in radians. @gravity should not be %PANGO_GRAVITY_AUTO. Note that pango_matrix_rotate() takes angle in degrees, not radians. So, to call pango_matrix_rotate() with the output of this function you should multiply it by (180. / G_PI). the rotation value corresponding to @gravity. gravity to query Checks @ch to see if it is a character that should not be normally rendered on the screen. This includes all Unicode characters with "ZERO WIDTH" in their name, as well as <firstterm>bidi</firstterm> formatting characters, and a few other ones. This is totally different from g_unichar_iszerowidth() and is at best misnamed. %TRUE if @ch is a zero-width character, %FALSE otherwise a Unicode character Breaks a piece of text into segments with consistent directional level and shaping engine. Each byte of @text will be contained in exactly one of the items in the returned list; the generated list of items will be in logical order (the start offsets of the items are ascending). @cached_iter should be an iterator over @attrs currently positioned at a range before or containing @start_index; @cached_iter will be advanced to the range covering the position just after @start_index + @length. (i.e. if itemizing in a loop, just keep passing in the same @cached_iter). a #GList of #PangoItem structures. The items should be freed using pango_item_free() probably in combination with g_list_foreach(), and the list itself using g_list_free(). a structure holding information that affects the itemization process. the text to itemize. Must be valid UTF-8 first byte in @text to process the number of bytes (not characters) to process after @start_index. This must be >= 0. the set of attributes that apply to @text. Cached attribute iterator, or %NULL Like pango_itemize(), but the base direction to use when computing bidirectional levels (see pango_context_set_base_dir ()), is specified explicitly rather than gotten from the #PangoContext. a #GList of #PangoItem structures. The items should be freed using pango_item_free() probably in combination with g_list_foreach(), and the list itself using g_list_free(). a structure holding information that affects the itemization process. base direction to use for bidirectional processing the text to itemize. first byte in @text to process the number of bytes (not characters) to process after @start_index. This must be >= 0. the set of attributes that apply to @text. Cached attribute iterator, or %NULL Take a RFC-3066 format language tag as a string and convert it to a #PangoLanguage pointer that can be efficiently copied (copy the pointer) and compared with other language tags (compare the pointer.) This function first canonicalizes the string by converting it to lowercase, mapping '_' to '-', and stripping all characters other than letters and '-'. Use pango_language_get_default() if you want to get the #PangoLanguage for the current locale of the process. an opaque pointer to a #PangoLanguage structure, or %NULL if @language was %NULL. The returned pointer will be valid forever after, and should not be freed. a string representing a language tag, or %NULL Returns the #PangoLanguage for the current locale of the process. Note that this can change over the life of an application. On Unix systems, this is the return value is derived from <literal>setlocale(LC_CTYPE, NULL)</literal>, and the user can affect this through the environment variables LC_ALL, LC_CTYPE or LANG (checked in that order). The locale string typically is in the form lang_COUNTRY, where lang is an ISO-639 language code, and COUNTRY is an ISO-3166 country code. For instance, sv_FI for Swedish as written in Finland or pt_BR for Portuguese as written in Brazil. On Windows, the C library does not use any such environment variables, and setting them won't affect the behavior of functions like ctime(). The user sets the locale through the Regional Options in the Control Panel. The C library (in the setlocale() function) does not use country and language codes, but country and language names spelled out in English. However, this function does check the above environment variables, and does return a Unix-style locale string based on either said environment variables or the thread's current locale. Your application should call <literal>setlocale(LC_ALL, "");</literal> for the user settings to take effect. Gtk+ does this in its initialization functions automatically (by calling gtk_set_locale()). See <literal>man setlocale</literal> for more details. the default language as a #PangoLanguage, must not be freed. Returns the list of languages that the user prefers, as specified by the PANGO_LANGUAGE or LANGUAGE environment variables, in order of preference. Note that this list does not necessarily include the language returned by pango_language_get_default(). When choosing language-specific resources, such as the sample text returned by pango_language_get_sample_string(), you should first try the default language, followed by the languages returned by this function. a %NULL-terminated array of PangoLanguage* While complete access to the layout capabilities of Pango is provided using the detailed interfaces for itemization and shaping, using that functionality directly involves writing a fairly large amount of code. The objects and functions in this section provide a high-level driver for formatting entire paragraphs of text at once. This includes paragraph-level functionality such as line-breaking, justification, alignment and ellipsization. This will return the bidirectional embedding levels of the input paragraph as defined by the Unicode Bidirectional Algorithm available at: http://www.unicode.org/reports/tr9/ If the input base direction is a weak direction, the direction of the characters in the text will determine the final resolved direction. a newly allocated array of embedding levels, one item per character (not byte), that should be freed using g_free. the text to itemize. the number of bytes (not characters) to process, or -1 if @text is nul-terminated and the length should be calculated. input base direction, and output resolved direction. The Pango rendering pipeline takes a string of Unicode characters and converts it into glyphs. The functions described in this section accomplish various steps of this process. ![](pipeline.png) Frequently, you want to display some text to the user with attributes applied to part of the text (for example, you might want bold or italicized words). With the base Pango interfaces, you could create a #PangoAttrList and apply it to the text; the problem is that you'd need to apply attributes to some numeric range of characters, for example "characters 12-17." This is broken from an internationalization standpoint; once the text is translated, the word you wanted to italicize could be in a different position. The solution is to include the text attributes in the string to be translated. Pango provides this feature with a small markup language. You can parse a marked-up string into the string text plus a #PangoAttrList using either of pango_parse_markup() or pango_markup_parser_new(). A simple example of a marked-up string might be: |[ <span foreground="blue" size="x-large">Blue text</span> is <i>cool</i>! ]| Pango uses #GMarkup to parse this language, which means that XML features such as numeric character entities such as `&#169;` for © can be used too. The root tag of a marked-up document is `<markup>`, but pango_parse_markup() allows you to omit this tag, so you will most likely never need to use it. The most general markup tag is `<span>`, then there are some convenience tags. ## Span attributes `<span>` has the following attributes: * `font_desc`: A font description string, such as "Sans Italic 12". See pango_font_description_from_string() for a description of the format of the string representation . Note that any other span attributes will override this description. So if you have "Sans Italic" and also a `style="normal"` attribute, you will get Sans normal, not italic. * `font_family`: A font family name * `font_size`, `size`: Font size in 1024ths of a point, or one of the absolute sizes `xx-small`, `x-small`, `small`, `medium`, `large`, `x-large`, `xx-large`, or one of the relative sizes `smaller` or `larger`. If you want to specify a absolute size, it's usually easier to take advantage of the ability to specify a partial font description using `font`; you can use `font='12.5'` rather than `size='12800'`. * `font_style`: One of `normal`, `oblique`, `italic` * `font_weight`: One of `ultralight`, `light`, `normal`, `bold`, `ultrabold`, `heavy`, or a numeric weight * `font_variant`: One of `normal` or `smallcaps` * `font_stretch`, `stretch`: One of `ultracondensed`, `extracondensed`, `condensed`, `semicondensed`, `normal`, `semiexpanded`, `expanded`, `extraexpanded`, `ultraexpanded` * `font_features`: A comma-separated list of OpenType font feature settings, in the same syntax as accepted by CSS. E.g: `font_features='dlig=1, -kern, afrc on'` * `foreground`, `fgcolor`: An RGB color specification such as `#00FF00` or a color name such as `red`. Since 1.38, an RGBA color specification such as `#00FF007F` will be interpreted as specifying both a foreground color and foreground alpha. * `background`, `bgcolor`: An RGB color specification such as `#00FF00` or a color name such as `red`. Since 1.38, an RGBA color specification such as `#00FF007F` will be interpreted as specifying both a background color and background alpha. * `alpha`, `fgalpha`: An alpha value for the foreground color, either a plain integer between 1 and 65536 or a percentage value like `50%`. * `background_alpha`, `bgalpha`: An alpha value for the background color, either a plain integer between 1 and 65536 or a percentage value like `50%`. * `underline`: One of `none`, `single`, `double`, `low`, `error`, `single-line`, `double-line` or `error-line`. * `underline_color`: The color of underlines; an RGB color specification such as `#00FF00` or a color name such as `red` * `overline`: One of `none` or `single` * `overline_color`: The color of overlines; an RGB color specification such as `#00FF00` or a color name such as `red` * `rise`: Vertical displacement, in Pango units. Can be negative for subscript, positive for superscript. * `strikethrough` `true` or `false` whether to strike through the text * `strikethrough_color`: The color of strikethrough lines; an RGB color specification such as `#00FF00` or a color name such as `red` * `fallback`: `true` or `false` whether to enable fallback. If disabled, then characters will only be used from the closest matching font on the system. No fallback will be done to other fonts on the system that might contain the characters in the text. Fallback is enabled by default. Most applications should not disable fallback. * `allow_breaks`: `true` or `false` whether to allow line breaks or not. If not allowed, the range will be kept in a single run as far as possible. Breaks are allowed by default. * `insert_hyphens`:` `true` or `false` whether to insert hyphens when breaking lines in the middle of a word. Hyphens are inserted by default. * `show`: A value determining how invisible characters are treated. Possible values are `spaces`, `line-breaks`, `ignorables` or combinations, such as `spaces|line-breaks`. * `lang`: A language code, indicating the text language * `letter_spacing`: Inter-letter spacing in 1024ths of a point. * `gravity`: One of `south`, `east`, `north`, `west`, `auto`. * `gravity_hint`: One of `natural`, `strong`, `line`. ## Convenience tags The following convenience tags are provided: * `<b>`: Bold * `<big>`: Makes font relatively larger, equivalent to `<span size="larger">` * `<i>`: Italic * `<s>`: Strikethrough * `<sub>`: Subscript * `<sup>`: Superscript * `<small>`: Makes font relatively smaller, equivalent to `<span size="smaller">` * `<tt>`: Monospace * `<u>`: Underline After feeding a pango markup parser some data with g_markup_parse_context_parse(), use this function to get the list of pango attributes and text out of the markup. This function will not free @context, use g_markup_parse_context_free() to do so. %FALSE if @error is set, otherwise %TRUE A valid parse context that was returned from pango_markup_parser_new() address of return location for a #PangoAttrList, or %NULL address of return location for text with tags stripped, or %NULL address of return location for accelerator char, or %NULL Parses marked-up text (see <link linkend="PangoMarkupFormat">markup format</link>) to create a plain-text string and an attribute list. If @accel_marker is nonzero, the given character will mark the character following it as an accelerator. For example, @accel_marker might be an ampersand or underscore. All characters marked as an accelerator will receive a %PANGO_UNDERLINE_LOW attribute, and the first character so marked will be returned in @accel_char, when calling finish(). Two @accel_marker characters following each other produce a single literal @accel_marker character. To feed markup to the parser, use g_markup_parse_context_parse() on the returned #GMarkupParseContext. When done with feeding markup to the parser, use pango_markup_parser_finish() to get the data out of it, and then use g_markup_parse_context_free() to free it. This function is designed for applications that read pango markup from streams. To simply parse a string containing pango markup, the simpler pango_parse_markup() API is recommended instead. a #GMarkupParseContext that should be destroyed with g_markup_parse_context_free(). character that precedes an accelerator, or 0 for none Do not use. Does not do anything. a #PangoIncludedModule Functions and macros in this section were used to support loading dynamic modules that add engines to Pango at run time. That is no longer the case, and these APIs should not be used anymore. The <firstterm>language engines</firstterm> are rendering-system independent engines that determine line, word, and character breaks for character strings. These engines are used in pango_break(). The <firstterm>shape engines</firstterm> are rendering-system dependent engines that convert character strings into glyph strings. These engines are used in pango_shape(). The capital-letter macros defined here can be used to check the version of Pango at compile-time, and to <firstterm>encode</firstterm> Pango versions into integers. The functions can be used to check the version of the linked Pango library at run-time. Parses an enum type and stores the result in @value. If @str does not match the nick name of any of the possible values for the enum and is not an integer, %FALSE is returned, a warning is issued if @warn is %TRUE, and a string representing the list of possible values is stored in @possible_values. The list is slash-separated, eg. "none/start/middle/end". If failed and @possible_values is not %NULL, returned string should be freed using g_free(). %TRUE if @str was successfully parsed. enum type to parse, eg. %PANGO_TYPE_ELLIPSIZE_MODE. string to parse. May be %NULL. integer to store the result in, or %NULL. if %TRUE, issue a g_warning() on bad input. place to store list of possible values on failure, or %NULL. Parses marked-up text (see <link linkend="PangoMarkupFormat">markup format</link>) to create a plain-text string and an attribute list. If @accel_marker is nonzero, the given character will mark the character following it as an accelerator. For example, @accel_marker might be an ampersand or underscore. All characters marked as an accelerator will receive a %PANGO_UNDERLINE_LOW attribute, and the first character so marked will be returned in @accel_char. Two @accel_marker characters following each other produce a single literal @accel_marker character. To parse a stream of pango markup incrementally, use pango_markup_parser_new(). If any error happens, none of the output arguments are touched except for @error. %FALSE if @error is set, otherwise %TRUE markup to parse (see <link linkend="PangoMarkupFormat">markup format</link>) length of @markup_text, or -1 if nul-terminated character that precedes an accelerator, or 0 for none address of return location for a #PangoAttrList, or %NULL address of return location for text with tags stripped, or %NULL address of return location for accelerator char, or %NULL Parses a font stretch. The allowed values are "ultra_condensed", "extra_condensed", "condensed", "semi_condensed", "normal", "semi_expanded", "expanded", "extra_expanded" and "ultra_expanded". Case variations are ignored and the '_' characters may be omitted. %TRUE if @str was successfully parsed. a string to parse. a #PangoStretch to store the result in. if %TRUE, issue a g_warning() on bad input. Parses a font style. The allowed values are "normal", "italic" and "oblique", case variations being ignored. %TRUE if @str was successfully parsed. a string to parse. a #PangoStyle to store the result in. if %TRUE, issue a g_warning() on bad input. Parses a font variant. The allowed values are "normal" and "smallcaps" or "small_caps", case variations being ignored. %TRUE if @str was successfully parsed. a string to parse. a #PangoVariant to store the result in. if %TRUE, issue a g_warning() on bad input. Parses a font weight. The allowed values are "heavy", "ultrabold", "bold", "normal", "light", "ultraleight" and integers. Case variations are ignored. %TRUE if @str was successfully parsed. a string to parse. a #PangoWeight to store the result in. if %TRUE, issue a g_warning() on bad input. Quantizes the thickness and position of a line, typically an underline or strikethrough, to whole device pixels, that is integer multiples of %PANGO_SCALE. The purpose of this function is to avoid such lines looking blurry. Care is taken to make sure @thickness is at least one pixel when this function returns, but returned @position may become zero as a result of rounding. pointer to the thickness of a line, in Pango units corresponding position Reads an entire line from a file into a buffer. Lines may be delimited with '\n', '\r', '\n\r', or '\r\n'. The delimiter is not written into the buffer. Text after a '#' character is treated as a comment and skipped. '\' can be used to escape a # character. '\' proceeding a line delimiter combines adjacent lines. A '\' proceeding any other character is ignored and written into the output buffer unmodified. 0 if the stream was already at an %EOF character, otherwise the number of lines read (this is useful for maintaining a line number counter which doesn't combine lines with '\') a stdio stream #GString buffer into which to write the result From a list of items in logical order and the associated directional levels, produce a list in visual order. The original list is unmodified. a #GList of #PangoItem structures in visual order. (Please open a bug if you use this function. It is not a particularly convenient interface, and the code is duplicated elsewhere in Pango for that reason.) a #GList of #PangoItem in logical order. Scans an integer. Leading white space is skipped. %FALSE if a parse error occurred. in/out string position an int into which to write the result Scans a string into a #GString buffer. The string may either be a sequence of non-white-space characters, or a quoted string with '"'. Instead a quoted string, '\"' represents a literal quote. Leading white space outside of quotes is skipped. %FALSE if a parse error occurred. in/out string position a #GString into which to write the result Scans a word into a #GString buffer. A word consists of [A-Za-z_] followed by zero or more [A-Za-z_0-9] Leading white space is skipped. %FALSE if a parse error occurred. in/out string position a #GString into which to write the result Looks up the script for a particular character (as defined by Unicode Standard Annex \#24). No check is made for @ch being a valid Unicode character; if you pass in invalid character, the result is undefined. Note that while the return type of this function is declared as PangoScript, as of Pango 1.18, this function simply returns the return value of g_unichar_get_script(). Callers must be prepared to handle unknown values. Use g_unichar_get_script() the #PangoScript for the character. a Unicode character Given a script, finds a language tag that is reasonably representative of that script. This will usually be the most widely spoken or used language written in that script: for instance, the sample language for %PANGO_SCRIPT_CYRILLIC is <literal>ru</literal> (Russian), the sample language for %PANGO_SCRIPT_ARABIC is <literal>ar</literal>. For some scripts, no sample language will be returned because there is no language that is sufficiently representative. The best example of this is %PANGO_SCRIPT_HAN, where various different variants of written Chinese, Japanese, and Korean all use significantly different sets of Han characters and forms of shared characters. No sample language can be provided for many historical scripts as well. As of 1.18, this function checks the environment variables PANGO_LANGUAGE and LANGUAGE (checked in that order) first. If one of them is set, it is parsed as a list of language tags separated by colons or other separators. This function will return the first language in the parsed list that Pango believes may use @script for writing. This last predicate is tested using pango_language_includes_script(). This can be used to control Pango's font selection for non-primary languages. For example, a PANGO_LANGUAGE enviroment variable set to "en:fa" makes Pango choose fonts suitable for Persian (fa) instead of Arabic (ar) when a segment of Arabic text is found in an otherwise non-Arabic text. The same trick can be used to choose a default language for %PANGO_SCRIPT_HAN when setting context language is not feasible. a #PangoLanguage that is representative of the script, or %NULL if no such language exists. a #PangoScript The functions in this section are used to identify the writing system, or <firstterm>script</firstterm> of individual characters and of ranges within a larger text string. Given a segment of text and the corresponding #PangoAnalysis structure returned from pango_itemize(), convert the characters into glyphs. You may also pass in only a substring of the item from pango_itemize(). It is recommended that you use pango_shape_full() instead, since that API allows for shaping interaction happening across text item boundaries. Note that the extra attributes in the @analyis that is returned from pango_itemize() have indices that are relative to the entire paragraph, so you need to subtract the item offset from their indices before calling pango_shape(). the text to process the length (in bytes) of @text #PangoAnalysis structure from pango_itemize() glyph string in which to store results Given a segment of text and the corresponding #PangoAnalysis structure returned from pango_itemize(), convert the characters into glyphs. You may also pass in only a substring of the item from pango_itemize(). This is similar to pango_shape(), except it also can optionally take the full paragraph text as input, which will then be used to perform certain cross-item shaping interactions. If you have access to the broader text of which @item_text is part of, provide the broader text as @paragraph_text. If @paragraph_text is %NULL, item text is used instead. Note that the extra attributes in the @analyis that is returned from pango_itemize() have indices that are relative to the entire paragraph, so you do not pass the full paragraph text as @paragraph_text, you need to subtract the item offset from their indices before calling pango_shape_full(). valid UTF-8 text to shape. the length (in bytes) of @item_text. -1 means nul-terminated text. text of the paragraph (see details). May be %NULL. the length (in bytes) of @paragraph_text. -1 means nul-terminated text. #PangoAnalysis structure from pango_itemize(). glyph string in which to store results. Given a segment of text and the corresponding #PangoAnalysis structure returned from pango_itemize(), convert the characters into glyphs. You may also pass in only a substring of the item from pango_itemize(). This is similar to pango_shape_full(), except it also takes flags that can influence the shaping process. Note that the extra attributes in the @analyis that is returned from pango_itemize() have indices that are relative to the entire paragraph, so you do not pass the full paragraph text as @paragraph_text, you need to subtract the item offset from their indices before calling pango_shape_with_flags(). valid UTF-8 text to shape the length (in bytes) of @item_text. -1 means nul-terminated text. text of the paragraph (see details). May be %NULL. the length (in bytes) of @paragraph_text. -1 means nul-terminated text. #PangoAnalysis structure from pango_itemize() glyph string in which to store results flags influencing the shaping process Skips 0 or more characters of white space. %FALSE if skipping the white space leaves the position at a '\0' character. in/out string position Splits a %G_SEARCHPATH_SEPARATOR-separated list of files, stripping white space and substituting ~/ with $HOME/. a list of strings to be freed with g_strfreev() a %G_SEARCHPATH_SEPARATOR separated list of filenames Functions in this section are used to deal with #PangoTabArray objects that can be used to set tab stop positions in a #PangoLayout. Apply language-specific tailoring to the breaks in @log_attrs, which are assumed to have been produced by pango_default_break(). If @offset is not -1, it is used to apply attributes from @analysis that are relevant to line breaking. text to process. Must be valid UTF-8 length in bytes of @text #PangoAnalysis structure from pango_itemize() for @text Byte offset of @text from the beginning of the paragraph, or -1 to ignore attributes from @analysis array with one #PangoLogAttr per character in @text, plus one extra, to be filled in length of @log_attrs array Attributed text is used in a number of places in Pango. It is used as the input to the itemization process and also when creating a #PangoLayout. The data types and functions in this section are used to represent and manipulate sets of attributes applied to a portion of text. Trims leading and trailing whitespace from a string. A newly-allocated string that must be freed with g_free() a string Determines the inherent direction of a character; either %PANGO_DIRECTION_LTR, %PANGO_DIRECTION_RTL, or %PANGO_DIRECTION_NEUTRAL. This function is useful to categorize characters into left-to-right letters, right-to-left letters, and everything else. If full Unicode bidirectional type of a character is needed, pango_bidi_type_for_unichar() can be used instead. the direction of the character. a Unicode character Converts a floating-point number to Pango units: multiplies it by %PANGO_SCALE and rounds to nearest integer. the value in Pango units. double floating-point value Converts a number in Pango units to floating-point: divides it by %PANGO_SCALE. the double value. value in Pango units The functions and utilities in this section are mostly used from Pango backends and modules, but may be useful for other purposes too. This is similar to the macro %PANGO_VERSION except that it returns the encoded version of Pango available at run-time, as opposed to the version available at compile-time. A version number can be encoded into an integer using PANGO_VERSION_ENCODE(). The encoded version of Pango library available at run time. Checks that the Pango library in use is compatible with the given version. Generally you would pass in the constants %PANGO_VERSION_MAJOR, %PANGO_VERSION_MINOR, %PANGO_VERSION_MICRO as the three arguments to this function; that produces a check that the library in use at run-time is compatible with the version of Pango the application or module was compiled against. Compatibility is defined by two things: first the version of the running library is newer than the version @required_major.required_minor.@required_micro. Second the running library must be binary compatible with the version @required_major.required_minor.@required_micro (same major version.) For compile-time version checking use PANGO_VERSION_CHECK(). %NULL if the Pango library is compatible with the given version, or a string describing the version mismatch. The returned string is owned by Pango and should not be modified or freed. the required major version. the required minor version. the required major version. This is similar to the macro %PANGO_VERSION_STRING except that it returns the version of Pango available at run-time, as opposed to the version available at compile-time. A string containing the version of Pango library available at run time. The returned string is owned by Pango and should not be modified or freed. Since 1.16, Pango is able to correctly lay vertical text out. In fact, it can set layouts of mixed vertical and non-vertical text. This section describes the types used for setting vertical text parameters. The way this is implemented is through the concept of <firstterm>gravity</firstterm>. Gravity of normal Latin text is south. A gravity value of east means that glyphs will be rotated ninety degrees counterclockwise. So, to render vertical text one needs to set the gravity and rotate the layout using the matrix machinery already in place. This has the huge advantage that most algorithms working on a #PangoLayout do not need any change as the assumption that lines run in the X direction and stack in the Y direction holds even for vertical text layouts. Applications should only need to set base gravity on #PangoContext in use, and let Pango decide the gravity assigned to each run of text. This automatically handles text with mixed scripts. A very common use is to set the context base gravity to auto using pango_context_set_base_gravity() and rotate the layout normally. Pango will make sure that Asian languages take the right form, while other scripts are rotated normally. The correct way to set gravity on a layout is to set it on the context associated with it using pango_context_set_base_gravity(). The context of a layout can be accessed using pango_layout_get_context(). The currently set base gravity of the context can be accessed using pango_context_get_base_gravity() and the <firstterm>resolved</firstterm> gravity of it using pango_context_get_gravity(). The resolved gravity is the same as the base gravity for the most part, except that if the base gravity is set to %PANGO_GRAVITY_AUTO, the resolved gravity will depend on the current matrix set on context, and is derived using pango_gravity_get_for_matrix(). The next thing an application may want to set on the context is the <firstterm>gravity hint</firstterm>. A #PangoGravityHint instructs how different scripts should react to the set base gravity. Font descriptions have a gravity property too, that can be set using pango_font_description_set_gravity() and accessed using pango_font_description_get_gravity(). However, those are rarely useful from application code and are mainly used by #PangoLayout internally. Last but not least, one can create #PangoAttribute<!---->s for gravity and gravity hint using pango_attr_gravity_new() and pango_attr_gravity_hint_new(). gtkada-24.0.0/contrib/README000066400000000000000000000001051446021174000153430ustar00rootroot00000000000000This directory contains various contributions or updates for GtkAda. gtkada-24.0.0/contrib/adaformat.py000077500000000000000000002360211446021174000170060ustar00rootroot00000000000000#!/usr/bin/env python """ Various formatting classes for Ada code """ import re import copy from collections import namedtuple # A lot of subprograms below take a "lang" parameter, which indicates how # values should be converted: # # LANG should be one of: # "ada": the value of the parameter is read from an Ada # value (as subprogram whose code is Ada) and passed to a # similar subprogram. No conversion needed. # "ada->c": all Ada values will be converted to their C equivalent, # since the target subprogram's code is written in C. # "c->ada": case of C callbacks: the value is passed from C to # an Ada subprogram in the user application. # # As an example, here is what the types for a list of strings # would look like in all languages: # # "ada" -> String_List # "c->ada" -> chars_ptr_array_access (no bounds given by C) # "ada->c" -> chars_ptr_array (bounds will be ignored anyway, # and it is simpler to pass this type). class CType(object): """Describes the types in the various cases where they can be used. A type applies either to an Ada subprogram written in Ada, or to an Ada subprogram implemented via a pragma Import. The latter case is abbreviated to a "c" subprogram below. For returned values, various pieces of information are needed: (adatype, ctype, converter, tmpvars=[]) They are used as: function ... (...) return adatype is function ... (...) return ctype; pragma Import (C, ..., "..."); Tmp : ctype; tmpvars; begin ...; -- pre-call code Tmp := ... (...); ...; -- post-call code return end; In the example above, "Tmp" is only created if there is some post-call code, otherwise we avoid the temporary variable. The variable "Tmp" is automatically added, and does not need to be specified manually in tmpvars. if converted contains the string "%(tmp)s", then we always use a temporary variable of type adatype. This is used for instance when the variable is initialized through a procedure call rather than a function call. function ... (...) return adatype is function ... (...) return ctype; pragma Import (C, ..., "...") Tmp_Result : adatype; tmpvars; begin ... -- pre-call code convert % {"var":..., "tmp":"Tmp_Result"}; -- proc call ... -- post-call code return Tmp_Result; end; The variable "Tmp_Result" is automatically added, and does not need to be specified manually in tmpvars. Converter will contain a single %s which will be replaced by the name of the temporary variable that holds the result of the call to the function. """ def __init__(self, ada, property): self.set_ada_name(ada) self.property = property self.default_record_field_value = None self.is_ptr = False self.cleanup = None # If set, a tmp variable is created to hold the result of convert # during the call, and is then free by calling this cleanup. Use # "%s" as the name of the variable. self.isArray = False # In some cases, Ada provides a special value for a parameter that # indicates that NULL should be passed to C. Such a test is only done # when allow_none is True. val_or_null is then a function in charge # of converting the value to a System.Address unless it is equal to # a specific null value. self.allow_none = False self.val_or_null = None # If True, the value returned from C must be freed by the caller self.transfer_ownership = False def set_ada_name(self, ada): self.ada = ada # Fully qualified Ada type self.param = ada # type as parameter self.cparam = ada # type for Ada subprograms binding to C def convert_from_c(self): """How to convert the value returned from C to Ada. This function returns a tuple: [0] = name of the Ada type [1] = name of the C type [2] = Conversion from C type to Ada type. The value is read from "%(var)s". It can also use "%(tmp)s" if a temporary variable is needed. [3] = List of needed temporary variables (except for the one corresponding to "%(tmp)s". [4] = Name of the C type, for "out" parameters. Often same as [1] [5] = Convert from [4] to the Ada type. Often same as [2] """ return (self.param, self.cparam, "%(var)s", [], self.cparam, "%(var)s") def convert_from_c_add_with(self, pkg, specs=False): """Add the "with" statements needed to do the conversion stated in convert_from_c(). """ pass def convert_to_c(self, pkg=None): """How to convert from Ada parameter to C parameter. If it uses %(tmp)s, we assume the converter sets the value of the temporary variable itself. It can also use %(var)s which will be substituted by the name of the parameter. Otherwise, it is used as " Tmp := ". It might be necessary to also override add_with() to add the necessary with statements. """ if self.allow_none and self.val_or_null: self.cparam = "System.Address" return "%s (%%(var)s'Address)" % self.val_or_null else: return "%(var)s" def direct_c_map(self): """Whether the parameter can be passed as is to C""" return self.convert_to_c(pkg=None) == "%(var)s" def as_property(self): """The type to use for the property""" return self.property def as_return(self, pkg=None): """See CType documentation for a description of the returned tuple""" returns = self.convert_from_c() if returns and pkg: # Avoid full dotted notation when inside the package itself return (returns[0].replace("%s." % pkg.name, ""), returns[1].replace("%s." % pkg.name, ""), returns[2], returns[3], returns[4], returns[5]) else: return returns def record_field_type(self, pkg=None): """The type to use when self is used in a record. [pkg] should be the current package, to avoid fully qualified name that reference that package. """ return self.as_c_param(pkg=pkg) def as_ada_param(self, pkg): """Converts self to a description for an Ada parameter to a subprogram. `pkg` is the package in which we insert the name. It is used to avoid qualified name when in the same package """ return self.param.replace("%s." % pkg.name, "") def as_c_param(self, pkg=None): """Returns the C type (as a parameter to a subprogram that imports a C function) """ if pkg: return self.cparam.replace("%s." % pkg.name, "") else: return self.cparam def as_call( self, name, pkg, wrapper="%s", lang="ada", mode="in", value=None, is_temporary_variable=True): """'name' represents a parameter of type 'self'. 'pkg' is the Package instance in which the call occurs. 'wrapper' is used in the call itself, and %s is replaced by the name of the variable (or the temporary variable). 'mode' is the mode for the Ada subprogram, and is automatically converted when generating a subprogram as a direct C import. :param is_temporary_variable: should be true if the corresponding variable is a variable local to the subprogram, as opposed to a parameter. In this case, we can sometimes avoid creating a second temporary variable, thus increasing efficiency. Returns an instance of VariableCall. See comments at the beginning of this package for valid LANG values """ assert lang in ("ada", "c->ada", "ada->c") assert mode in ("in", "out", "access", "not null access", "in out"), "Incorrect mode: %s" % mode if lang == "ada": return VariableCall( call=wrapper % name, precall='', postcall='', tmpvars=[]) elif lang == "ada->c": returns = self.convert_from_c() ret = returns and returns[2] additional_tmp_vars = [] if not returns else returns[3] # An "out" parameter for an enumeration requires a temporary # variable: Internal(Enum'Pos(Param)) is invalid # Unless we are already using a temporary variable. if (ret and ret != "%(var)s" and mode != "in" and not is_temporary_variable): tmp = "Tmp_%s" % name if mode in ("out", "access"): tmpvars = [Local_Var( name=tmp, type=returns[4], aliased=True)] else: tmpvars = [ Local_Var(name=tmp, type=returns[4], aliased=True, default=self.convert_to_c(pkg=pkg) % { "var": name})] if "%(tmp)s" in ret: tmp2 = "Tmp2_%s" % name tmpvars += [Local_Var(name=tmp2, type=returns[4])] postcall = "%s; %s := %s;" % ( returns[5] % {"var": tmp, "tmp": tmp2}, name, tmp2) else: postcall = "%s := %s;" % ( name, returns[5] % {"var": tmp}) call = VariableCall( call=wrapper % tmp, precall="", postcall=postcall, tmpvars=tmpvars + additional_tmp_vars) elif "%(tmp)" in self.convert_to_c(pkg=pkg): # The conversion sets the temporary variable itself tmp = "Tmp_%s" % name call = VariableCall( call=wrapper % tmp, precall=self.convert_to_c(pkg=pkg) % { "var": name, "tmp": tmp}, postcall=self.cleanup % tmp, tmpvars=[Local_Var(name=tmp, type=self.cparam)] + []) elif self.cleanup: tmp = "Tmp_%s" % name conv = self.convert_to_c(pkg=pkg) % {"var": name} # Initialize the temporary variable with a default value, in # case it is an unconstrained type (a chars_ptr_array for # instance) call = VariableCall( call=wrapper % tmp, precall='', postcall=self.cleanup % tmp, tmpvars=[Local_Var( name=tmp, type=AdaType(self.cparam), default=conv)]) else: conv = self.convert_to_c(pkg=pkg) % {"var": name} call = VariableCall( call=wrapper % conv, precall='', postcall="", tmpvars=[]) return call elif lang == "c->ada": ret = self.convert_from_c() self.convert_from_c_add_with(pkg=pkg) # Do we need a temporary variable ? # An "out" parameter for an enumeration requires a temporary # variable: Internal(Enum'Pos (Param)) is invalid ret_convert = ret and ret[2] if ret_convert and ret_convert != "%(var)s" and mode != "in": tmp = "Tmp_%s" % name tmpvars = [Local_Var(name=tmp, type=self.ada)] + ret[3] if "%(tmp)s" in ret_convert: tmp2 = "Tmp2_%s" % name tmpvars += [Local_Var(name=tmp2, type=self.cparam)] postcall = "%s; %s := %s;" % ( ret_convert % {"var": tmp, "tmp": tmp2}, name, tmp2) else: postcall = "%s := %s;" % ( name, self.convert_to_c(pkg=pkg) % {"var": tmp}) return VariableCall( call=wrapper % tmp, precall="", postcall=postcall, tmpvars=tmpvars) else: return VariableCall( call=wrapper % (ret[2] % {"var": name}), precall='', postcall='', tmpvars=ret[3]) def add_with(self, pkg=None, specs=False): """Add required withs for this type""" if pkg: pkg.add_with(package_name(self.ada)) if pkg and self.allow_none and self.val_or_null: base = self.val_or_null pkg.add_with(package_name(base), specs=specs) def copy(self): """Return a copy of self, possibly modifying some properties.""" return copy.deepcopy(self) class Enum(CType): def __init__(self, ada, property=None): base = ada[ada.rfind(".") + 1:] or ada if property is None: CType.__init__(self, ada, "Gtk.Enums.Property_%s" % base) else: CType.__init__(self, ada, property) if self.ada.lower() == "boolean": self.cparam = "Glib.Gboolean" else: # Do not convert enumerations to integers. We want to pass the # associated literal in case the enumeration in C does not start # at 0, or as holes in the series. self.cparam = self.ada def convert_from_c(self): if self.ada.lower() == "boolean": if self.ada == "Boolean": # Do not use Boolean'Val for more flexibility, in case C # returns another value than 0 and 1 (as is the case for # gtk_status_icon_position_menu on OSX for instance). conv = "%(var)s /= 0" else: conv = "%s'Val (%%(var)s)" % self.ada return (self.param, self.cparam, conv, [], # for out parameters self.cparam, conv) else: return super(Enum, self).convert_from_c() def convert_to_c(self, pkg=None): if self.ada.lower() == "boolean": return "%s'Pos (%%(var)s)" % self.ada else: return super(Enum, self).convert_to_c(pkg=pkg) def record_field_type(self, pkg=None): if pkg: return self.ada.replace("%s." % pkg.name, "") else: return self.ada @staticmethod def register_ada_decl(pkg, ctype, ada=None): """Register an enumeration type. :param pkg: is the name of the current package in which the enumeration will be defined. """ # Compute the Ada name automatically if needed. if not ada: ada = naming.type(name="", cname=ctype).ada full_name = "%s.%s" % (pkg, ada) t = Enum(full_name, "%s.Property_%s" % (pkg, ada)) naming.add_type_exception(cname=ctype, type=t) # Add the special cases for properties that GIR file use t = ctype.replace("Pango", "Pango.").replace("Gdk", "Gdk.") naming.girname_to_ctype[t] = ctype class GObject(CType): def __init__(self, ada, userecord=True, allow_none=False, classwide=False): CType.__init__(self, ada, "Glib.Properties.Property_Object") self.cparam = "System.Address" self.is_ptr = False self.classwide = classwide # Parameter should include "'Class" self.userecord = userecord # Parameter should be "access .._Record" self.allow_none = allow_none def convert_from_c(self): stub = "Stub_%s" % (base_name(self.ada), ) if self.ada == "Glib.Object.GObject": conv = "Get_User_Data (%%(var)s, %s)" % stub else: conv = "%s (Get_User_Data (%%(var)s, %s))" % (self.ada, stub) return (self.param, self.cparam, conv, [Local_Var( stub, AdaType("%s_Record" % self.ada, in_spec=False))], # for out parameters self.cparam, conv) def convert_to_c(self, pkg=None): if self.allow_none: return "Get_Object_Or_Null (GObject (%(var)s))" else: return "Get_Object (%(var)s)" def as_ada_param(self, pkg): if self.userecord: prefix = "" if self.allow_none else "not null " if self.classwide: self.param = "%saccess %s_Record'Class" % (prefix, self.ada) else: self.param = "%saccess %s_Record" % (prefix, self.ada) return super(GObject, self).as_ada_param(pkg) def copy(self): result = CType.copy(self) return result class Tagged(GObject): """Tagged types that map C objects, but do not derive from GObject""" def convert_from_c(self): return (self.param, self.cparam, "From_Object (%(var)s)", [], # for out parameters self.cparam, "From_Object (%(var)s)") def convert_to_c(self, pkg=None): return "Get_Object (%(var)s)" def as_ada_param(self, pkg): # Make sure to bind as a CType here, not as a GOBject return CType.as_ada_param(self, pkg) class UTF8(CType): def __init__(self): CType.__init__(self, "UTF8_String", "Glib.Properties.Property_String") self.cparam = "Gtkada.Types.Chars_Ptr" self.cleanup = "Free (%s);" def convert_from_c(self): conv = "Gtkada.Bindings.Value_Allowing_Null (%(var)s)" if self.transfer_ownership: conv = "Gtkada.Bindings.Value_And_Free (%(var)s)" return (self.param, self.cparam, conv, [], # for out parameters self.cparam, conv) def convert_from_c_add_with(self, pkg, specs=False): if pkg: pkg.add_with("Gtkada.Bindings", specs=specs) pkg.add_with("Gtkada.Types", specs=specs) def convert_to_c(self, pkg=None): if self.allow_none: return 'if %(var)s = "" then %(tmp)s :=' \ + ' Gtkada.Types.Null_Ptr; else'\ + ' %(tmp)s := New_String (%(var)s); end if;' else: return "New_String (%(var)s)" def add_with(self, pkg, specs=False): super(UTF8, self).add_with(pkg) if pkg: pkg.add_with("Gtkada.Types", specs=specs, might_be_unused=True) class SignalName(UTF8): """ A special kind of utf8 used for signal names """ def __init__(self): super(SignalName, self).__init__() self.set_ada_name("Glib.Signal_Name") self.cparam = "Gtkada.Types.Chars_Ptr" def convert_to_c(self, pkg=None): return "New_String (String (%(var)s))" class UTF8_List(CType): def __init__(self): CType.__init__(self, "GNAT.Strings.String_List", "") self.cparam = "Gtkada.Types.chars_ptr_array" self.cleanup = "Gtkada.Types.Free (%s);" def convert_from_c(self): # Use a temporary variable to store the result of To_String_List, # because in some cases the result will need to be freed. For instance, # when a callback from C receives a list of strings as # chars_ptr_array_access, we create a temporary String_List to call the # Ada callback, and then need to free the temporary String_List. conv = "To_String_List (%(var)s.all)" if self.transfer_ownership: conv = "To_String_List_And_Free (%(var)s)" return (self.param, "chars_ptr_array_access", conv, [], # for out parameters "chars_ptr_array_access", conv) def record_field_type(self, pkg=None): return "Gtkada.Types.char_array_access" def convert_to_c(self, pkg=None): return "From_String_List (%(var)s)" def add_with(self, pkg=None, specs=False): super(UTF8_List, self).add_with(pkg=pkg) if pkg: pkg.add_with("GNAT.Strings", specs=True) pkg.add_with("Gtkada.Bindings", specs=specs, might_be_unused=True) class Record(CType): def __init__(self, ada, property=None, val_or_null=None): """ :param val_or_null: if specified, and the null constant is passed as a parameter, then System.Null_Address is passed to C. If unspecified, any value passed by the user is given as is to C. """ if property is None: CType.__init__(self, ada, "Glib.Properties.Property_Boxed") else: CType.__init__(self, ada, property) self.val_or_null = val_or_null # Do not change self.cparam: when passing a read-only parameter to # C, GNAT will automatically pass the address of the record self.cparam = ada def convert_from_c(self): conv = "%(var)s.all" # convert C -> Ada, if self.transfer_ownership: conv = "From_Object_Free (%(var)s)" return (self.ada, "access %s" % self.ada, conv, [], # for out parameters self.ada, "%(var)s") def convert_to_c(self, pkg=None): if self.allow_none and self.val_or_null: self.cparam = "System.Address" return "%s (%%(var)s'Address)" % self.val_or_null else: return "%(var)s" @staticmethod def register_ada_record(pkg, ctype, ada=None): """Register a type. [pkg] is the name of the current package in which the enumeration will be defined. """ adaname = base_name(ada or naming.type(name="", cname=ctype).ada) full_name = "%s.%s" % (pkg, adaname) t = Record(full_name) naming.add_type_exception(cname="%s*" % ctype, type=t) naming.add_type_exception(cname=ctype, type=t) class Proxy(CType): def __init__(self, ada, property=None, val_or_null=None, from_gvalue=None, default_record_field=None): """:param val_or_null: is used when GIR indicates the parameter has allow-none=1, and is used to test whether we should pass NULL to C or a pointer to the Ada data. :param from_gvalue: is the function used to retrieve this type from a GValue, in particular when processing callbacks. The default is to retrieve a C_Proxy and Cast as appropriate. :param str default_record_field: the default value to set in record type declarations for fields of that type. No default value set if this is None. """ if property is None: CType.__init__(self, ada, "Glib.Properties.Property_Boxed") else: CType.__init__(self, ada, property) self.val_or_null = val_or_null self.default_record_field_value = default_record_field def record_field_type(self, pkg=None): if self.isArray and self.array_fixed_size is not None: return "%s (1 .. %s)" % ( self.as_c_param(pkg=pkg), self.array_fixed_size) elif self.is_ptr or self.isArray: return "access %s" % self.as_c_param(pkg=pkg) else: return self.as_c_param(pkg=pkg) class Callback(CType): def __init__(self, ada): CType.__init__(self, ada, "") self.cparam = "System.Address" def __repr__(self): return "" % self.ada def convert_from_c(self): # Never return such a callback to Ada (because in fact we are pointing # to a function in one of the bodies of GtkAda, not the actual user # callback. return None def convert_to_c(self, pkg=None): return "%(var)s'Address" class Interface(CType): def __init__(self, ada): CType.__init__(self, ada, "Glib.Properties.Property_Interface") self.cparam = ada self.is_ptr = False class List(CType): def __init__(self, ada): CType.__init__(self, ada, "Glib.Properties.Property_Object") self.__adapkg = ada[:ada.rfind(".")] self.cparam = "System.Address" self.is_ptr = False def convert_from_c(self): conv = "%s.Set_Object (%%(tmp)s, %%(var)s)" % self.__adapkg return ( # Use %(tmp)s so forces the use of temporary var. self.param, self.cparam, conv, [], # for out parameters self.cparam, conv) @staticmethod def register_ada_list(pkg, ada, ctype, single=False): """Register a list of GObject instantiated in Ada""" if single: gtype = "GSlist" name = "SList" else: gtype = "Glist" name = "List" listCname = "%s%s" % (ctype, name) # Default list name ada = ada or naming.type(cname=listCname).ada t = List("%s.%s.%s" % (pkg, ada, gtype)) naming.add_type_exception(listCname, t) def convert_to_c(self, pkg=None): return "%s.Get_Object (%%(var)s)" % self.__adapkg def add_with(self, pkg=None, specs=False): # A list comes from an instantiation (pkg.instance.glist), so we need # to skip backward two "." if pkg: p = self.ada.rfind(".") if p != -1: p = self.ada[:p].rfind(".") if p != -1: pkg.add_with(self.ada[:p], specs=True) class AdaType(CType): def __init__(self, adatype, pkg=None, in_spec=True, ctype="", convert="%(var)s"): """The 'adatype' type is represented as 'ctype' for subprograms that import C functions. The parameters of that type are converted from Ada to C by using 'convert'. 'convert' must use '%s' once to indicate where the name of the parameter should go """ CType.__init__(self, adatype, "") self.param = adatype self.cparam = ctype or adatype self.__convert = convert self.cleanup = None self.is_ptr = adatype.startswith("access ") # ??? Why do we need to call this explicitly ? if pkg: self.add_with(pkg) def convert_to_c(self, pkg=None): return self.__convert class AdaTypeArray(CType): """An array of scalar types""" def __init__(self, adatype): CType.__init__(self, adatype, "") self.param = "%s_Array" % naming.case(adatype) self.cparam = "System.Address" self.isArray = True def convert_to_c(self, pkg=None): return "%(var)s (%(var)s'First)'Address" def convert_from_c(self): # ??? This implementation is specialized for the Gtk.Clipboard pkg, # which is the only place where we use it c = ("Atom_Arrays.To_Array " + "(Atom_Arrays.Convert (%(var)s), Integer (N_Atoms))") return (self.param, # name of Ada type self.cparam, # name of C type c, # convert from C to Ada [ # list of temporary variables needed ], self.cparam, # name of C type for out parameters c) # convert from previous line to Ada type def record_field_type(self, pkg=None): if self.isArray and self.array_fixed_size is not None: return "%s (1 .. %s)" % ( self.as_ada_param(pkg=pkg), self.array_fixed_size) else: return self.as_c_param(pkg=pkg) class AdaNaming(object): def __init__(self): self.cname_to_adaname = {} # c methods to Ada subprograms self.girname_to_ctype = {} # gir names to C types self.exceptions = {} # naming exceptions self.type_exceptions = {} # C types to CType instances def add_type_exception(self, cname, type, override=False): """Declares a new type exception, unless there already existed one for that cname. """ assert(isinstance(type, CType)) if override or cname not in self.type_exceptions: self.type_exceptions[cname] = type def add_cmethod(self, cname, adaname): """Register the mapping from c method's name to Ada subprogram. This is used to replace C function names in the documentation with their Ada equivalent""" self.cname_to_adaname[cname] = adaname def add_girname(self, girname, ctype): """Maps a GIR's "name" attribute to its matching C type. This is used to resolve such names in the documentation and in properties types. """ self.girname_to_ctype[girname] = ctype def ctype_from_girname(self, girname): """Return the C type corresponding to a GIR name""" if not girname: return "" elif girname.startswith("Gdk") or girname.startswith("Gtk"): default = girname else: default = "Gtk%s" % girname return self.girname_to_ctype.get(girname, default) def adamethod_name(self, cname, warning_if_not_found=True): """Return the ada name corresponding to the C method's name""" try: return self.cname_to_adaname[cname] except KeyError: if warning_if_not_found and cname.lower().startswith("gtk_"): print("Name quoted in doc has no Ada binding: %s" % cname) self.cname_to_adaname[cname] = cname # Display warning once only return cname def case(self, name, protect=True): """Return the proper casing to use for 'name', taking keywords into account. This is for packages. """ name = self.__camel_case_to_ada(name.replace("-", "_")).title() if name.endswith("_"): name = name[:-1] if protect: return self.protect_keywords(name) else: return name def protect_keywords(self, name): return ".".join(self.exceptions.get(n, n) for n in name.split(".")) def __camel_case_to_ada(self, name): """Converts a name with CamelCase to Camel_Case""" if not name: return name result = name[0] prev = result for r in name[1:]: if prev != "_" \ and prev != "." \ and not prev.isupper() \ and r.isupper(): result += "_%s" % r else: result += r prev = r return result def __full_type_from_girname(self, girname): """Return the type description from a GIR name""" return self.type_exceptions.get( girname, # First try GIR name as is in the table (gint, ...) self.type_exceptions.get( self.ctype_from_girname(girname), # Else the C type # Else return the GIR name itself Proxy(self.__camel_case_to_ada(girname)))) def type(self, name="", cname=None, pkg=None, isArray=False, allow_access=True, allow_none=False, userecord=True, useclass=True, array_fixed_size=None, transfer_ownership=False): """Build an instance of CType for the corresponding cname. A type a described in a .gir file :param pkg: an instance of Package, to which extra with clauses will be added if needed. :param allow_none: if True, then an empty string maps to a NULL pointer in C, rather than an empty C string. For a GObject, the parameter is passed as "access" rather than "not null access". :param use_record: is only used for GObject types. :param isArray: should be true for an array of the simple type 'name'. :param allow_access: should be True if the parameter can be represented as 'access Type', rather than an explicit type, in the case of GObject descendants. :param array_fixed_size: if specified, this is the size of the array. The binding is different in this case, since we can't use a fat pointer. """ if cname is None: cname = self.girname_to_ctype.get(name, None) if (cname == "gchar**" or name == "array_of_utf8" or name == "array_of_filename"): t = UTF8_List() elif (cname in ("gint**", "int**") or name in ("array_of_gint", "array_of_guint", "array_of_gint8", "array_of_guint8", "array_of_guint16")): t = AdaTypeArray("gint") isArray = True elif name in ("array_of_Gdk.Atom", ): t = AdaTypeArray("Gdk_Atom") isArray = True elif name in ("array_of_gdouble", ): t = AdaTypeArray("gdouble") isArray = True elif name in ("array_of_gchar", ): t = AdaTypeArray("gchar") isArray = True elif cname == "void": return None elif name == "utf8" or cname == "gchar*" or cname == "char*": t = UTF8() elif name == "SignalName": t = SignalName() elif cname: # Check whether the C type, including trailing "*", maps # directly to an Ada type. # t = self.type_exceptions.get( # cname, # Proxy(self.__camel_case_to_ada(cname))) t = self.__full_type_from_girname(cname) is_ptr = False if t.ada[-1] == "*": # No, try without the trailing "*" t = self.__full_type_from_girname(cname[0:-1]) if t.ada[-1] != "*": is_ptr = True # Yes, so we had a pointer else: basename = cname[0:-1] # Remove all "*" if basename[-1] == "*": basename = basename[0:-1] t = self.__full_type_from_girname(basename) if not isinstance(t, GObject) \ and not isinstance(t, Interface): t.is_ptr = is_ptr else: t = self.__full_type_from_girname(name) t.is_ptr = cname and cname[-1] == '*' t = t.copy() t.isArray = isArray t.array_fixed_size = array_fixed_size t.classwide = useclass t.allow_none = allow_none t.userecord = userecord t.transfer_ownership = transfer_ownership # Needs to be called last, since the output might depend on all the # attributes set above t.add_with(pkg) return t naming = AdaNaming() def max_length(iter): """Return the length of the longuest element in iter""" longuest = 0 for f in iter: longuest = max(longuest, len(f)) return longuest def fill_text(text, prefix, length, firstLineLength=0): """Split TEXT on several lines (with a given max length and a prefix). """ line = "" result = [] maxLen = firstLineLength or length - len(prefix) text = text.replace("\n\n", "\n
") # Do we have a list item ? If yes, preserve the indentation if text.lstrip().startswith("* "): line += text[:text.find("*")] for w in text.split(): # for each word (this loses whitespaces) if w.startswith("
"): result.append(line) maxLen = length - len(prefix) line = w[4:] elif len(line) + len(w) + 1 > maxLen: result.append(line) maxLen = length - len(prefix) line = w elif w: line += " " + w if line != "": result.append(line) return ("\n" + prefix).join(result) def cleanup_doc(doc): """Replaces C features in the doc with appropriate Ada equivalents""" def replace_type(x): t = naming.type(x.group(1)) t.userecord = False return t.ada # get_package might have been called before we had the XML node # from the Gir file, and therefore no doc for the package. We can # now override it, unless it came from binding.xml subp = re.compile(r"([\S_]+)\(\)") doc = subp.sub(lambda x: naming.adamethod_name(x.group(1)), doc) types = re.compile(r"#([\w_]+)") doc = types.sub(replace_type, doc) params = re.compile(r"@([\w_]+)") doc = params.sub(lambda x: x.group(1).title(), doc) enums = re.compile(r"%([A-Z][\w_]+)") doc = enums.sub(lambda x: naming.adamethod_name(x.group(1)), doc) doc = doc.replace("", "*") \ .replace("", "*") \ .replace("", "'") \ .replace("", "'") \ .replace("", "'") \ .replace("", "'") \ .replace("", "") \ .replace(" ", " ") \ .replace("", "'") \ .replace("", "'") \ .replace("", "'") \ .replace("", "'") \ .replace("", "[") \ .replace("", "]") \ .replace("", "'") \ .replace("", "'") \ .replace("", "[") \ .replace("", "]") \ .replace("", "\n\n") \ .replace("", "") \ .replace("", "") \ .replace("", "") \ .replace("", "") \ .replace("", "") \ .replace("", "") \ .replace("", "") \ .replace("", "") \ .replace("", "\nNote: ") \ .replace("", "") doc = re.sub("]*>", "", doc) doc = re.sub("(.*?) :", r"\1:", doc) # Lists doc = re.sub("(\n?|\n?)?", "\n\n * ", doc) doc = doc.replace("", "") \ .replace("", "") \ .replace("", "") \ .replace("", "") \ .replace("", "\n\n") \ .replace("", "") # Definition of terms (variablelists) doc = doc.replace("", "") \ .replace("", "") \ .replace("", "") \ .replace("", "") \ .replace("", "'") \ .replace("", "'") doc = re.sub(r"]*>", "", doc) doc = re.sub(r"(.*?)", r"\n\n== \1 ==\n\n", doc) doc = re.sub(r"]*>", "", doc) doc = re.sub(r"", "", doc) doc = doc.replace("", "") \ .replace("", "") \ .replace("", "") \ .replace("", "") \ .replace("", "").replace("", "") \ .replace("", "").replace("", "") \ .replace("%", "%") \ .replace("<", "<").replace(">", ">") \ .replace("*", "*") \ .replace("", "\n\n__PRE__") doc = re.sub("(.*?)", lambda m: re.sub( "\n\n+", "\n", indent_code(m.group(1), addnewlines=False)), doc, flags=re.DOTALL or re.MULTILINE) doc = re.sub("\n\n\n+", "\n\n", doc) return doc def format_doc(doc, indent, separate_paragraphs=True, fill=True): """Transform the doc from a list of strings to a single string""" result = "" prev = "" # Make sure the doc is a list of paragraphs if not isinstance(doc, list): doc = [doc] # Cleanup the XML tags in each paragraph. This could result in # new paragraphs being created cleaned = [] for d in doc: d = cleanup_doc(d) if fill: cleaned.extend(d.split("\n\n")) else: cleaned.append(d) prefix = "\n" + indent + "--" for d in cleaned: # Separate paragraphs with an empty line, unless it is a markup # or we are at the end if separate_paragraphs: if prev != "" and not prev.lstrip().startswith("<"): result += prefix if d: if d.lstrip().startswith("__PRE__"): d = d.lstrip()[7:] result += "".join(prefix + " " + p for p in d.splitlines()) elif fill: result += prefix + " " result += fill_text(d, indent + "-- ", 79) else: result += "".join(prefix + " " + p for p in d.splitlines()) prev = d if result and separate_paragraphs and result[0] == "\n": result = result[1:] return result def box(name, indent=" "): return indent + "-" * (len(name) + 6) + "\n" \ + indent + "-- " + name + " --\n" \ + indent + "-" * (len(name) + 6) def indent_code(code, indent=3, addnewlines=True): """Return code properly indented and split on several lines. These are heuristics only, not perfect. """ body = code.strip() if not body: return "" if addnewlines: # Add newlines where needed, but preserve existing blank lines body = re.sub(r";(?!\s*\n)", ";\n", body) body = re.sub(r"(? old_parent: indent += (parent_count - old_parent) * 3 elif not old_parent: result += " " * indent if parent_count > old_parent: indent += (parent_count - old_parent) * 3 else: if parent_count > old_parent: indent += (parent_count - old_parent) * 3 result += " " * indent if old_parent > parent_count: indent -= (old_parent - parent_count) * 3 result += line + eol_comment + "\n" if (line.endswith("then") and not line.endswith("and then")) \ or line.endswith("loop") \ or (line.endswith("else") and not line.endswith("or else"))\ or line.endswith("begin") \ or line.endswith("{") \ or line.endswith("record") \ or line.endswith("is") \ or line.endswith("do") \ or line.endswith("declare"): indent += 3 # Case of generic instantiation: # package A is # new B (); if line.startswith("new"): indent -= 3 return result # The necessary setup to use a variable in a subprogram call. The returned # values map to the following Ada code: # declare # $(tmpvars) # A list of LocalVar # begin # $(precall) # Call ($(call), ...) # (postcall) # end; # and are used in case temporary variables are needed. If not, only 'call' # will have a non-null value VariableCall = namedtuple('VariableCall', ['call', 'precall', 'postcall', 'tmpvars']) class Local_Var(object): __slots__ = ["name", "type", "default", "aliased", "constant"] def __init__(self, name, type, default="", aliased=False, constant=False): self.set_type(type) self.name = name self.default = default self.aliased = aliased self.constant = constant def __repr__(self): return "" % (self.name, self.type) def set_type(self, type): if isinstance(type, str): self.type = AdaType(type) else: self.type = type def _type(self, lang, pkg): """`pkg` is the package in which we insert the variable, and is used to add necessary with statements, if any. """ if lang == "ada": return self.type.as_ada_param(pkg) elif lang == "ada->c": return self.type.as_c_param(pkg) elif lang == "c->ada": return self.type.convert_from_c()[1] def spec(self, pkg, length=0, lang="ada", show_default=True): """Format the declaration for the variable or parameter. 'length' is the minimum length that the name should occupy (for proper alignment when there are several variables. """ t = self._type(lang=lang, pkg=pkg) aliased = "" if self.aliased: aliased = "aliased " if self.default and show_default: return "%-*s : %s%s%s := %s" % ( length, self.name, "constant " if self.constant else "", aliased, t, self.default) else: return "%-*s : %s%s" % (length, self.name, aliased, t) def as_call(self, pkg, lang="ada", value=None): """Pass self (or the value) as a parameter to an Ada subprogram call, implemented in the given language. See comments at the beginning of this package for valid values of LANG. 'pkg' is the instance of Package in which the call occurs. :return: an instance of VariableCall """ n = value or self.name if isinstance(self.type, CType): return self.type.as_call( name=n, pkg=pkg, lang=lang, wrapper="%s", is_temporary_variable=True) else: return VariableCall(call=n, precall='', postcall='', tmpvars=[]) class Parameter(Local_Var): __slots__ = ["name", "type", "default", "aliased", "mode", "doc", "ada_binding", "for_function", "is_temporary_variable", "c_mode", "ownership", "is_caller_allocates"] def __init__(self, name, type, default="", doc="", mode="in", for_function=False, ada_binding=True, is_temporary_variable=False, c_mode="in", ownership="none", is_caller_allocates=False): """ 'mode' is the mode for the Ada subprogram, and is automatically converted when generating a subprogram as a direct C import. :param for_function: whether the parameter belongs to a procedure or a function. :param ada_binding: if False, the parameter will not be displayed in the profile of Ada subprograms (although, of course, it will be passed to the C subprograms) :param is_temporary_variable: True if this parameter represents a local variable. In this case, we can sometimes avoid creating other such variables, a minor optimization. :param 'c_mode' is the original mode of parameter in C :param 'ownership' means that caller should free memory if 'full' :param is_caller_allocates: True if memory for the parameter should be allocated by method caller """ assert mode in ("in", "out", "in out", "not null access", "access"), "Incorrect mode: %s" % mode super(Parameter, self).__init__(name, type, default=default) self.mode = mode self.doc = doc self.ada_binding = ada_binding self.for_function = for_function self.is_temporary_variable = is_temporary_variable self.c_mode = c_mode self.ownership = ownership self.is_caller_allocates = is_caller_allocates def _type(self, lang, pkg): mode = self.mode if lang == "ada->c" and mode != "in" and self.for_function: mode = "access" if mode in ("in out", "out") and hasattr(self.type, "userecord"): userec = self.type.userecord self.type.userecord = False t = super(Parameter, self)._type(lang=lang, pkg=pkg) self.type.userecord = userec else: t = super(Parameter, self)._type(lang=lang, pkg=pkg) if mode != "in": return "%s %s" % (mode, t) return t def as_call(self, pkg, lang="ada", value=None): """'pkg' is the package instance in which the call occurs.""" assert lang in ("ada", "c->ada", "ada->c") if not self.ada_binding: if self.default is not None: return VariableCall(call=self.default, precall='', postcall='', tmpvars=[]) else: return VariableCall(call="Parameter not bound in Ada", precall='', postcall='', tmpvars=[]) else: wrapper = "%s" n = value or self.name # We know that for a C function, an "in out" parameter is # implemented as an "access parameter", so we'll need to take a # 'Access. In the call to as_call() below, though, we still pass # the original mode ("in out") not "access", so that as_call() # knows whether we need to make a copy of the parameter or not. if lang == "ada->c" and self.mode != "in" and self.for_function: wrapper = "%s'Access" if isinstance(self.type, CType): return self.type.as_call( name=n, pkg=pkg, lang=lang, mode=self.mode, wrapper=wrapper, is_temporary_variable=self.is_temporary_variable) else: return VariableCall( call=n, precall='', postcall='', tmpvars=[]) def direct_c_map(self): """Whether the parameter can be passed as is to C""" return self.type.direct_c_map() def value(self): if not self.ada_binding: if self.default is not None: return self.default else: return "Parameter not bound in Ada" else: return self.ada_binding def base_name(qname): """Return the basename for a fully qualified name: Pkg.Name => Name """ if "." in qname: return qname[qname.rfind(".") + 1:] else: return qname def package_name(qname): """Return the package part of a fully qualified name: Pkg.Child.Name => Pkg.Child Name => "" """ if "." in qname: index = qname.rfind(".") if qname[index - 1] != '.': # ignore ".." in ranges return qname[:index] return "" max_profile_length = 79 - len(" is") class Subprogram(object): """An Ada subprogram that we are generating""" def __init__(self, name, code="", plist=[], local_vars=[], returns=None, doc=[], showdoc=True, convention=None, lang="ada", allow_none=True): """Create a new subprogram. 'plist' is a list of Parameter. 'local_vars' is a list of Local_Var. 'doc' is a string or a list of paragraphs. 'code' can be the empty string, in which case no body is output. 'lang' is the language for the types of parameters (see comment at the top of this file). 'allow_none': when this is an anonymous subprogram (and therefore used for a callback), this indicates whether the callback can be null or not). The code will be automatically pretty-printed, and the appropriate pragma Unreferenced are also added automatically. """ assert(returns is None or isinstance(returns, CType)) assert(lang in ("ada", "c->ada", "ada->c")) self.name = name self.plist = plist self.returns = returns self.local = local_vars self.showdoc = showdoc self.convention = convention # "lang" self.allow_none = allow_none self._import = None self._nested = [] # nested subprograms self._deprecated = (False, "") # True if deprecated self._manual_body = None # Written by user explicitly self.lang = lang # Language for the types of parameters if code and code[-1] != ";": self.code = code + ";" else: self.code = code if isinstance(doc, list): self.doc = doc else: self.doc = [doc] def import_c(self, cname): """Declares that 'self' is implemented as a pragma Import. This returns 'self' so that it can be chained: s = Subprogram(...).import_c('...') """ self._import = 'pragma Import (C, %s, "%s");' % (self.name, cname) return self def mark_deprecated(self, msg): """Mark the subprogram as deprecated""" self._deprecated = (True, msg) def add_nested(self, *args): """Add some nested subprograms""" for subp in args: self._nested.append(subp) return self def set_body(self, body): """Overrides the body of the subprogram (after "is")""" self._manual_body = body def profile(self, pkg, indent=" ", maxlen=max_profile_length, as_type=False, specs=False): """Compute the profile for the subprogram""" returns = self.returns and self.returns.as_return(pkg=pkg) if returns: prefix = "function" if self.lang == "ada->c": suffix = " return %s" % returns[1] elif self.lang == "c->ada": suffix = " return %s" % returns[1] else: suffix = " return %s" % returns[0] else: prefix = "procedure" suffix = "" if (not as_type) and self.name: prefix = indent + prefix + " " + base_name(self.name) elif self.allow_none: prefix = "access %s" % prefix else: prefix = "not null access %s" % prefix if self.plist: # First test: all parameters on same line plist = [p.spec(pkg=pkg, lang=self.lang) for p in self.plist] p = " (" + "; ".join(plist) + ")" # If too long, split on several lines if len(p) + len(prefix) + len(suffix) > maxlen: max = max_length([p_iter.name for p_iter in self.plist]) plist = [p_iter.spec(pkg=pkg, length=max, lang=self.lang, show_default=self.lang == "ada") for p_iter in self.plist] p = "\n " + indent + "(" \ + (";\n " + indent).join(plist) + ")" else: p = "" # Should the "return" go on a separate line ? if p and suffix and len(p.splitlines()[-1]) + len(suffix) > maxlen: return prefix + p + "\n " + indent + suffix else: return prefix + p + suffix def add_withs_for_subprogram(self, pkg, in_specs): """ Add required withs to the package (either in specs or body) """ if self.returns: r = self.returns.as_return(pkg=pkg) if self.lang == "ada->c": self.returns.add_with(pkg=pkg, specs=in_specs) elif self.lang == "c->ada": self.returns.add_with(pkg=pkg, specs=in_specs) else: pkg.add_with(package_name(r[0]), specs=in_specs) if self.plist: for p in self.plist: p.type.add_with(pkg=pkg, specs=in_specs) def formatted_doc(self, indent=" "): if self.showdoc: doc = [d for d in self.doc] if self._deprecated[0]: doc += [self._deprecated[1]] doc += [p.doc for p in self.plist] else: doc = [] return format_doc(doc, indent=indent, separate_paragraphs=False) def spec(self, pkg, indent=" ", show_doc=True, maxlen=max_profile_length, as_type=False): """Return the spec of the subprogram""" result = self.profile( pkg=pkg, indent=indent, maxlen=maxlen, as_type=as_type) + ";" if self._import: result += "\n" + indent + self._import if self._deprecated[0]: result += "\n" + indent + "pragma Obsolescent (%s);" % self.name if self.convention: result += "\n" + indent \ + "pragma Convention (%s, %s);" % (self.convention, self.name) if show_doc: doc = self.formatted_doc(indent=indent) else: doc = "" return result + doc def _find_unreferenced(self, local_vars="", indent=" "): """List the pragma Unreferenced statements that are needed for this subprogram. """ unreferenced = [] for p in self.plist: if not re.search( r'\b%s\b' % p.name, self.code + local_vars, re.IGNORECASE): unreferenced.append(p.name) if unreferenced: return indent + " pragma Unreferenced (%s);\n" % ( ", ".join(unreferenced)) else: return "" def _format_local_vars(self, pkg, indent=" "): """The list of local variable declarations""" if self.local: max = max_length([p.name for p in self.local]) result = [] seen = set() for v in self.local: if v.name not in seen: seen.add(v.name) result.append(v.spec(pkg=pkg, length=max)) return indent + " " + (";\n " + indent).join(result) + ";\n" else: return "" def body(self, pkg, indent=" "): if not self.code and not self._manual_body: return "" result = box(base_name(self.name), indent=indent) + "\n\n" profile = self.profile(pkg=pkg, indent=indent) result += profile if profile.find("\n") != -1: result += "\n" + indent + "is\n" else: result += " is\n" local = self._format_local_vars(pkg=pkg, indent=indent) auto = self._find_unreferenced(local_vars=local, indent=indent) for s in self._nested: auto += s.spec(pkg=pkg, indent=indent + " ") + "\n" auto += s.body(pkg=pkg, indent=indent + " ") auto += local auto += indent + "begin\n" auto += indent_code(self.code, indent=len(indent) + 3) if self._manual_body: result += indent + self._manual_body % {"auto": auto} else: result += auto return result + indent + "end %s;\n" % base_name(self.name) def call(self, in_pkg=None, extra_postcall="", values=dict(), lang=None): """A call to 'self'. The parameters that are passed to self are assumed to have the same name as in self's declaration. When 'self' is implemented as a pragma Import, proper conversions are done. 'in_pkg' is used to fully qualify the name of the subprogram, to avoid ambiguities. This is optional. This is an instance of Package. Returned value is a tuple: ("code", "variable_for_return", tmpvars=[]) where "code" is the code to execute for the call, including creation of temporary variables, and "variable_for_return" is either None, or the code to get the result of the subprogram. So a call is: declare tmp_vars; begin code; extra_postcall; return variable_for_return; -- Omitted for procedures end; See comments at the beginning of this package for valid LANG values. """ assert(in_pkg is not None) assert(isinstance(in_pkg, Package)) if lang: pass elif self._import: lang = "ada->c" else: lang = "ada" assert(lang in ("ada", "c->ada", "ada->c")) tmpvars = [] precall = "" params = [] postcall = extra_postcall for arg in self.plist: c = arg.as_call( pkg=in_pkg, lang=lang, # An instance of VariableCall value=values.get(arg.name.lower(), None)) params.append(c.call) tmpvars.extend(c.tmpvars) precall += c.precall postcall = c.postcall + postcall if params: call = "%s (%s)" % (self.name, ", ".join(params)) else: call = self.name returns = self.returns and self.returns.as_return(pkg=in_pkg) if returns is not None: if lang == "ada->c": self.returns.convert_from_c_add_with(pkg=in_pkg) tmpvars.extend(returns[3]) if "%(tmp)s" in returns[2]: # Result of Internal is used to create a temp. variable, # which is then returned. This variable has the same type # as the Ada type (not necessarily same as Internal) call = returns[2] % {"var": call, "tmp": "Tmp_Return"} tmpvars.append(Local_Var("Tmp_Return", returns[0])) result = ("%s%s;%s" % (precall, call, postcall), "Tmp_Return", tmpvars) elif postcall: tmpvars.append(Local_Var("Tmp_Return", returns[1])) call = "Tmp_Return := %s" % call result = ("%s%s;%s" % (precall, call, postcall), returns[2] % {"var": "Tmp_Return"}, tmpvars) else: # No need for a temporary variable result = (precall, returns[2] % {"var": call}, tmpvars) else: # "ada" or "c->ada" if postcall: # We need to use a temporary variable, since there are # cleanups to perform. This will not work if the function # returns an unconstrained array though. tmpvars.append(Local_Var("Tmp_Return", returns[0])) call = "Tmp_Return := %s" % call result = ("%s%s;%s" % (precall, call, postcall), "Tmp_Return", tmpvars) else: # No need for a temporary variable result = (precall, call, tmpvars) else: # A procedure result = ("%s%s;%s" % (precall, call, postcall), None, tmpvars) return result def call_to_string(self, call, pkg=None, lang="ada"): """CALL is the result of call() above. This function returns a string that contains the code for the subprogram. """ result = call[0] if call[1]: if lang == "c->ada": # The return value (Ada) needs to be converted back to C (this # is the returned value from a callback, for instance) result += "return %s" % ( self.returns.convert_to_c(pkg=pkg) % {"var": call[1]}, ) else: result += "return %s" % call[1] return result class Code(object): """ Some text to insert in a package. This can be either some code, or the comments for the code. In the latter case, the comment will be automatically formatted (and C names substituted as appropriate). """ def __init__(self, content, iscomment=False, fill=True): """:param:`fill` whether to reflow the text if this is a comment. :param:`add_newline` whether the block should have a leading newline """ self.content = content self.iscomment = iscomment self.fill = fill self.add_newline = True def format(self, indent=""): """Return the code that should be written into a package""" if self.iscomment: return format_doc(self.content, indent=indent, fill=self.fill) else: return indent_code( self.content, indent=len(indent), addnewlines=False) class Section(object): """A group of types and subprograms in an Ada package. There is a single section with a given name in the package """ group_getters_and_setters = False # If true, a getter will be displayed with its corresponding setter. # Only one doc will be displayed for the two, and no separation line # will be output. sort_alphabetically = False # If true, subprograms are all sorted alphabetically, otherwise the # order is alphabetical for getters, but setters appear just after the # getter. def __init__(self, pkg, name): self.pkg = pkg # The instance of Package in which the section is self.name = name self.__comment = "" self.__objects = [] # List of objects. These are tuples: # (Code or Subprogram or Package instance, # in_spec) # Whether we should sort the objects. If yes, code always comes before # subprograms. Otherwise, they are output in the order they were added self.sort_objects = ( not Section.sort_alphabetically or Section.group_getters_and_setters) def add_comment(self, comment, fill=True): """If 'fill' is true, the comment is automatically split on several lines if needed. Otherwise, the comment is assumed to be already formatted properly, minus the leading -- """ if comment == "": self.__comment += " --\n" else: self.__comment += ("".join( format_doc(comment, indent=" ", fill=fill)) + "\n") def add(self, obj, in_spec=True, add_newline=True): """Add one or more objects to the section (subprogram, code,...). :param:`add_newline` indicates whether the object should be followed by a blank line. There is never a blank line between some code and the following comment. """ iscode = False if isinstance(obj, bytes) or isinstance(obj, str): obj = Code(obj) iscode = True elif isinstance(obj, Package): obj.isnested = True obj.add_newline = add_newline if iscode: # Take care of duplicated entries. May happen in case of # subpackages in GIR files for o, s in self.__objects: if s == in_spec and isinstance(o, Code): if o.content == obj.content: return False self.__objects.append((obj, in_spec)) return True def _group_objects(self): """Returns a list of subprograms for the specs. In each nested list, the subprograms are grouped and a single documentation is output for the whole group. At the same time, this preserves the order of groups, so they appear in the order in which the first subprogram in the group appeared. """ if self.sort_objects: code = [] subprograms = [] tmp = dict() # group_name => [subprograms] gtk_new_index = 0 for obj, in_spec in self.__objects: if not in_spec: continue if isinstance(obj, Code) or isinstance(obj, str): code.append([obj]) elif isinstance(obj, Subprogram) or isinstance(obj, Package): b = base_name(obj.name) name = b.replace("Get_", "") \ .replace("Query_", "") \ .replace("Gtk_New", "") \ .replace("Gdk_New", "") \ .replace("Initialize", "") \ .replace("Set_From_", "") \ .replace("Set_", "") if b in ("Gtk_New", "Gdk_New", "G_New"): # Always create a new group for Gtk_New, since they all # have different parameters. But we still want to group # Gtk_New and Initialize. t = tmp["Gtk_New%d" % gtk_new_index] = [obj] subprograms.append(t) elif b == "Initialize": tmp["Gtk_New%d" % gtk_new_index].append(obj) gtk_new_index += 1 elif name in tmp: tmp[name].append(obj) # Also modified in result else: tmp[name] = [obj] subprograms.append(tmp[name]) else: print("Unexpected contents in package %s\n" % (type(obj), )) return code + subprograms else: return [[obj] for obj, in_spec in self.__objects if in_spec] def spec(self, pkg, indent): """Return the spec of the section""" result = "" add_newline = False for group in self._group_objects(): for obj in group: # If the previous object requested a trailing newline, and the # current object is not a comment, then add the newline now. if (add_newline and (not isinstance(obj, Code) or not obj.iscomment)): result += "\n" if isinstance(obj, Code): result += obj.format(indent=indent).strip("\n") + "\n" add_newline = obj.add_newline elif isinstance(obj, Subprogram): show_doc = ((not Section.group_getters_and_setters and not obj.name.startswith("Gtk_New")) or obj == group[-1]) result += obj.spec(pkg=pkg, show_doc=show_doc, indent=indent).strip("\n") + "\n" add_newline = (hasattr(obj, "add_newline") and obj.add_newline and show_doc) elif isinstance(obj, Package): result += obj.spec().strip("\n") + "\n" add_newline = (hasattr(obj, "add_newline") and obj.add_newline) elif isinstance(obj, str): print("Not adding unicode to package: %s\n" % ( obj.encode('UTF-8'), )) if add_newline: result += "\n" if result: if self.__comment: result = self.__comment + "\n" + result elif self.name: result = "\n" + result if self.name: result = box(self.name) + "\n" + result return result def body(self, pkg, indent): result = [] for obj, in_spec in self.__objects: if in_spec or not isinstance(obj, Code): continue result.append(obj.format(indent=indent)) # ignores obj.add_newline body_subprograms = [(obj, in_spec) for obj, in_spec in self.__objects if not isinstance(obj, Code)] body_subprograms.sort(key=lambda x: base_name(x[0].name)) # First output for the subprograms only defined in the body for obj, in_spec in body_subprograms: if not in_spec: if isinstance(obj, Subprogram): result.append(obj.spec(pkg=pkg, indent=indent)) else: result.append(obj.spec()) result.append("") # Then output all the bodiesx for obj, in_spec in body_subprograms: if isinstance(obj, Subprogram): b = obj.body(pkg=pkg, indent=indent) else: b = obj.body() + "\n" if b: result.append(b) return "\n".join(result) class Package(object): copyright_header = "" # Can be overridden by applications to change the copyright header def __init__(self, name, doc=[], isnested=False): """'doc' is a list of strings, where each string is a paragraph""" self.name = name self.doc = doc self.sections = [] # [Section] self.spec_withs = dict() # "pkg" -> use:Boolean self.body_withs = dict() # "pkg" -> use:Boolean self.private = [] # Private section self.language_version = "" # a pragma to be put just after the headers self.formal_params = "" # generic formal parameters self.isnested = isnested def __repr__(self): return "" % self.name def section(self, name): """Return an existing section (or create a new one) with the given name. """ for s in self.sections: if s.name == name: return s s = Section(self, name) self.sections.append(s) return s def add_with(self, pkg, specs=True, do_use=True, might_be_unused=False): """Add a with+use clause for pkg, where pkg can also be a list. Automatic casing is performed. If specs is True, the withs are added to the specs of the package, otherwise to the body. :param:`might_be_unused` True if the package might not be used and requires a pragma Warnings Off. """ if pkg in ("", "System"): return if type(pkg) == str: pkg = [pkg] for p in pkg: def sublist(sub, parent): """return a non-empty list if sub is not a sublist of parent""" return [elem for elem in sub if elem not in parent] l_name = self.name.lower().split(".") l_p_name = p.lower().split(".") if not sublist(l_p_name, l_name): continue # Already imported by construction p_info = ( do_use or self.spec_withs.get(p, False), # do_use might_be_unused) if specs: self.spec_withs[p] = p_info self.body_withs.pop(p, None) # Remove same with in body elif p not in self.spec_withs: self.body_withs[p] = p_info def add_private(self, code, at_end=False): if at_end: self.private.append(code) else: self.private.insert(0, code) def _output_withs(self, withs): if withs: result = [] m = max_length(withs) had_warnings_off = False # sort so that all packages for which 'might_be_unused' is True # are last in the list for w in sorted(list(withs.keys()), key=lambda w: 'zz%s' % w if withs[w][1] else w): do_use, might_be_unused = withs[w] if might_be_unused and not had_warnings_off: result.append("pragma Warnings(Off); -- might be unused") had_warnings_off = True if do_use: result.append( "with %-*s use %s;" % (m + 1, w + ";", w)) else: result.append("with %s;" % w) if had_warnings_off: result.append("pragma Warnings(On);") return "\n".join(result) + "\n" return "" def section_order(self, name): """Return a numerical order for sections""" order = {"": 0, "Callbacks": 1, "Enumeration Properties": 2, # Primitive operations first "Constructors": 3, "Methods": 4, "GtkAda additions": 5, "Inherited subprograms (from interfaces)": 6, # Then non-primitive (so that we can freeze the type, for # instance by instantiating lists) "Functions": 8, "Lists": 9, # General data independent of the type "Properties": 10, "Signals": 11, # Instantiating new generic packages freezes the types, so # should be last "Interfaces": 12, } return order.get(name, 1000) def spec(self): """Returns the spec of the package, in the file `out`""" result = [] if not self.isnested: indent = "" if Package.copyright_header: result.append(Package.copyright_header) if self.language_version: result.append(self.language_version) if self.doc: result.append(format_doc(self.doc, indent="")) result.append('') result.append('pragma Warnings (Off, "*is already use-visible*");') result.append(self._output_withs(self.spec_withs)) else: indent = " " if self.formal_params: result.append(indent + "generic") result.append(indent + " %s" % self.formal_params) result.append(indent + "package %s is\n" % self.name) self.sections.sort(key=lambda x: (self.section_order(x.name))) for s in self.sections: sec = s.spec(pkg=self, indent=indent + " ") if sec: result.append(sec.strip("\n") + "\n") if self.private: result.append(indent + "private") result.extend(self.private) result.append(indent + "end %s;" % self.name) return "\n".join(result) def body(self): """Returns the body of the package""" result = [] body = "" if self.isnested: indent = " " else: indent = "" for s in self.sections: b = s.body(pkg=self, indent=indent + " ") if b: body += "\n" + b if not body: return "" if not self.isnested: if Package.copyright_header: result.append(Package.copyright_header) if self.language_version: result.append(self.language_version) result.append("pragma Style_Checks (Off);") result.append('pragma Warnings (Off, "*is already use-visible*");') result.append(self._output_withs(self.body_withs)) result.append(indent + "package body %s is" % self.name) result.append(body) result.append(indent + "end %s;" % self.name) return "\n".join(result) gtkada-24.0.0/contrib/binding.py000066400000000000000000003466771446021174000165020ustar00rootroot00000000000000#!/usr/bin/env python2 """ Parse a .gir file for any of the gtk+ libraries (gtk+, glib,...) and generate Ada bindings. """ # Issues: # - Missing handling of nodes (see GtkArrow for instance) # - Some comments contain xref like "#GtkMisc". Not sure what to do with # those. Likewise for names of subprograms in comments. # # Backward incompatibility: # - Missing documentation for some properties. # SOLVE: we could point to the corresponding Set_* and Get_* subprograms, # or simply ignore the missing doc from xml.etree.cElementTree import parse, Element, QName, tostring, fromstring from adaformat import * import copy from binding_gtkada import GtkAda from data import enums, interfaces, binding, user_data_params from data import destroy_data_params import sys # Unfortunately, generating the slot marshallers in a separate package # does not work since we end up with circularities in a number of # cases. For now, we simply duplicate them as needed SHARED_SLOT_MARSHALLERS = False # For parsing command line options from optparse import OptionParser # Python interpreter version check: this script does not work with Python # version 3.7 or earlier! from sys import version_info version_string = '.'.join(map(str, version_info[0:3])) if version_info[0] < 3: print(('Need at least Python 3.7, got version ' + version_string)) quit(1) if version_info[0] == 3 and version_info[1] < 7: print(('Need at least Python 3.7, got version ' + version_string)) quit(1) uri = "http://www.gtk.org/introspection/core/1.0" glib_uri = "http://www.gtk.org/introspection/glib/1.0" c_uri = "http://www.gtk.org/introspection/c/1.0" cidentifier = QName(c_uri, "identifier").text cidentifier_prefix = QName(c_uri, "identifier-prefixes").text ctype_qname = QName(c_uri, "type").text ggettype = QName(glib_uri, "get-type").text gsignal = QName(glib_uri, "signal").text glib_type_struct = QName(glib_uri, "type-struct").text glib_type_name = QName(glib_uri, "type-name").text namespace = QName(uri, "namespace").text narray = QName(uri, "array").text nbitfield = QName(uri, "bitfield").text ncallback = QName(uri, "callback").text nclass = QName(uri, "class").text ndoc = QName(uri, "doc").text nenumeration = QName(uri, "enumeration").text nfield = QName(uri, "field").text nfunction = QName(uri, "function").text nimplements = QName(uri, "implements").text ninterface = QName(uri, "interface").text nmember = QName(uri, "member").text nmethod = QName(uri, "method").text nvirtualmethod = QName(uri, "virtual-method").text nparam = QName(uri, "parameter").text nparams = QName(uri, "parameters").text nrecord = QName(uri, "record").text nunion = QName(uri, "union").text nreturn = QName(uri, "return-value").text ntype = QName(uri, "type").text nvalue = QName(uri, "value").text nvarargs = QName(uri, "varargs").text nconstant = QName(uri, "constant").text ninstanceparam = QName(uri, "instance-parameter").text class GIR(object): def __init__(self, files): """Parse filename and initializes SELF""" self.packages = dict() # Ada name (lower case) -> Package instance self.ccode = "" self.classes = dict() # Maps C name to a GIRClass instance self.interfaces = dict() # Maps GIR's "name" to an interface self.ctype_interfaces = dict() # Maps GIR's c:type to an interface self.callbacks = dict() # Ada name to GIR XML node self.enums = dict() # Maps C "name" to a GIR XML node self.globals = GlobalsBinder(self) # global vars self.records = dict() # Maps C "name" to a GIR XML node # Maps C "name" to a GIR XML node for constants self.constants = dict() self.bound = set() # C names for the entities that have an Ada binding # The marshallers that have been generated when we use a slot object. # These can be shared among all packages, since the profiles of the # handlers are the same. if SHARED_SLOT_MARSHALLERS: self.slot_marshallers = set() self.slot_marshaller_pkg = self.get_package( name="Gtkada.Marshallers", ctype=None, doc="Automatically generated, used internally by GtkAda") self.slot_marshaller_section = self.slot_marshaller_pkg.section("") for filename in files: _tree = parse(filename) root = _tree.getroot() identifier_prefix = root.find(namespace).get(cidentifier_prefix) k = "%s/%s" % (namespace, ncallback) for cl in root.findall(k): ct = cl.get(ctype_qname) type = Callback(naming.case(ct)) naming.add_type_exception(cname=ct, type=type) ct = naming.type(ct).ada self.callbacks[ct] = cl k = "%s/%s" % (namespace, ninterface) for cl in root.findall(k): self.ctype_interfaces[cl.get(ctype_qname)] = \ self.interfaces[cl.get("name")] = \ self._create_class( root, cl, is_interface=True, is_gobject=False, identifier_prefix=identifier_prefix) k = "%s/%s" % (namespace, nclass) for cl in root.findall(k): if cl.get(ctype_qname) is not None: self.classes[cl.get(ctype_qname)] = self._create_class( root, cl, is_interface=False, identifier_prefix=identifier_prefix) k = "%s/%s" % (namespace, nconstant) for cl in root.findall(k): self.constants[cl.get(ctype_qname)] = cl # Some are defined with methods. They are bound the same # way in GtkAda, except that they do not derive from GObject k = "%s/%s" % (namespace, nrecord) for cl in root.findall(k): if cl.findall(nmethod): self.classes[cl.get(ctype_qname)] = self._create_class( root, cl, is_interface=False, is_gobject=False, identifier_prefix=identifier_prefix) self.records[cl.get(ctype_qname)] = cl k = "%s/%s" % (namespace, nunion) for cl in root.findall(k): if cl.findall(nmethod): self.classes[cl.get(ctype_qname)] = self._create_class( root, cl, is_interface=False, is_gobject=False, identifier_prefix=identifier_prefix) self.records[cl.get(ctype_qname)] = cl for enums in (nenumeration, nbitfield): k = "%s/%s" % (namespace, enums) for cl in root.findall(k): self.enums[cl.get(ctype_qname)] = cl self.globals.add(root) def show_unbound(self): """Display the list of entities known in the GIR files, but that have no Ada binding. """ print("Missing bindings:") count = 0 for name in sorted(gir.interfaces.keys()): if name not in self.bound: sys.stdout.write("%-28s" % (name + "(intf)", )) count += 1 if (count % 4) == 0: sys.stdout.write("\n") for name in sorted(gir.classes.keys()): if name not in self.bound: sys.stdout.write("%-28s" % name) # print ' "--%s", # Not tested yet, from Gio' % name count += 1 if (count % 4) == 0: sys.stdout.write("\n") print() def _get_class_node(self, rootNode, girname): """Find the node in the same XML document as node that matches [girname]. """ k = "{%(uri)s}namespace/{%(uri)s}class" % {"uri": uri} for cl in rootNode.findall(k): if cl.get("name") == girname: return cl return None def _create_class(self, rootNode, node, is_interface, identifier_prefix, is_gobject=True, has_toplevel_type=True): return GIRClass(self, rootNode=rootNode, node=node, is_interface=is_interface, is_gobject=is_gobject, identifier_prefix=identifier_prefix, has_toplevel_type=has_toplevel_type) def debug(self, element): """A debug form of element""" return tostring(element) def get_package(self, name, ctype, doc=""): """Return a handle to an Ada package""" if not name.lower() in self.packages: pkg = self.packages[name.lower()] = Package( name=name, doc=gtkada.get_pkg(ctype).get_doc()) else: pkg = self.packages[name.lower()] if doc: pkg.doc = ["", doc, ""] + pkg.doc return pkg def generate(self, out, cout): """Generate Ada code for all packages""" for pkg in self.packages.values(): out.write(pkg.spec().encode('UTF-8')) out.write(b"\n") out.write(pkg.body().encode('UTF-8')) out.write(b"\n") cout.write(self.ccode.encode("UTF-8")) class GlobalsBinder(object): def __init__(self, gir): self.gir = gir self.globals = dict() def add(self, node): k = "{%(uri)s}namespace/{%(uri)s}function" % {"uri": uri} all = node.findall(k) if all is not None: for c in all: id = c.get(cidentifier) self.globals[id] = c def get_function(self, id): """Return the XML node corresponding to a global function""" return self.globals[id] def _get_clean_doc(node): """ Get the child node, and replace common unicode characters by their ASCII equivalent to keep the Ada specs more readable in a terminal. """ doc = node.findtext(ndoc, "") if doc: doc = doc.replace("\u2019", "'").replace( "\u201c", '"').replace("\u201d", '"') return doc def _get_type(nodeOrType, allow_access=True, allow_none=False, transfer_ownership=False, userecord=True, pkg=None): """Return the type of the GIR XML node. nodeOrType can be one of: * a string, given the name of the C type * an instance of CType, which is returned as is. * An XML node from which the information is gathered. `allow_access' should be False if "access Type" parameters should not be allowed, and an explicit type is needed instead. `allow_none': see doc for CType. `pkg' is used to add with statements, if specified """ if isinstance(nodeOrType, CType): return nodeOrType elif isinstance(nodeOrType, str): return naming.type(name=nodeOrType, cname=nodeOrType, userecord=userecord, transfer_ownership=transfer_ownership, allow_access=allow_access, allow_none=allow_none, pkg=pkg) else: t = nodeOrType.find(ntype) if t is not None: if t.get("name") == "none": return None ctype_name = t.get(ctype_qname) if ctype_name: ctype_name = ctype_name.replace("const ", "") return naming.type(name=t.get("name"), cname=ctype_name, userecord=userecord, transfer_ownership=transfer_ownership, allow_access=allow_access, allow_none=allow_none, pkg=pkg) a = nodeOrType.find(narray) if a is not None: t = a.find(ntype) if a: type = t.get(ctype_qname) name = t.get("name") or type # Sometimes name is not set size = a.get("fixed-size", None) if type: type = "array_of_%s" % (type, ) return naming.type(name="array_of_%s" % name, cname=type, pkg=pkg, isArray=True, array_fixed_size=size, transfer_ownership=transfer_ownership, allow_none=allow_none, userecord=userecord, allow_access=allow_access) a = nodeOrType.find(nvarargs) if a is not None: # A function with multiple arguments cannot be bound # No need for an error message, we will already let the user know # that the function is not bound. return None print("Error: XML Node has unknown type: %s (%s)" % (nodeOrType, nodeOrType.attrib)) return None class SubprogramProfile(object): """A class that groups info on the parameters of a function and its return type. """ def __init__(self): self.node = None # the XML node for this profile self.gtkmethod = None self.params = None # list of parameters (None if we have varargs) self.returns = None # return value (None for a procedure) self.returns_doc = "" # documentation for returned value self.doc = "" # documentation for the subprogram # The following fields are used to handle callback parameters # and generate an Ada generic self.callback_param = [] # indexes of the callback parameter self.user_data_param = -1 # index of the "user data" parameter self.destroy_param = -1 # index of the parameter to destroy data def __repr__(self): return "" % self.node.get('name') @staticmethod def parse(node, gtkmethod, pkg=None, ignore_return=False): """Parse the parameter info and return type info from the XML GIR node, overriding with binding.xml. gtkmethod is the GtkAdaMethod that contains the overriding for the various method attributes. If pkg is specified, with statements are added as necessary. If ignore_return is True, the return type is not parsed. This is used for constructors, so that we do not end up adding extra 'with' statements in the generated package. """ profile = SubprogramProfile() profile.node = node profile.gtkmethod = gtkmethod # make sure to init the 'returns' field before the parameters, to be # able to correctly set the parameters direction ('in out' or 'out' # case) if not ignore_return: profile.returns = profile._returns(node, gtkmethod, pkg=pkg) profile.params = profile._parameters(node, gtkmethod, pkg=pkg) profile.doc = profile._getdoc(gtkmethod, node) return profile @staticmethod def setter(node, pkg=None): """Create a new SubprogramProfile for a getter""" profile = SubprogramProfile() profile.node = node profile.params = [Parameter("Value", _get_type(node, pkg))] return profile def callback_param_info(self): """If there is one or more callback parameters in this profile, return them so that we can generate the appropriate function. Returns None if there are no such parameters. """ if not self.callback_param: return None return [self.params[p] for p in self.callback_param] def callback_destroy(self): if self.destroy_param < 0: return None return self.params[self.destroy_param] def callback_user_data(self): """Returns the name of the "user_data" parameter""" if self.user_data_param == -1: return None return self.params[self.user_data_param].name def has_varargs(self): return self.params is None def direct_c_map(self): """Wether all parameters and return value can be mapped directly from C to Ada. """ for p in self.params: # If a parameter is not mapped in Ada, we need an actual body if not p.direct_c_map() or not p.ada_binding: return False return self.returns is None or self.returns.direct_c_map() def c_params(self, localvars, code): """Returns the list of parameters for an Ada function that would be a direct pragma Import. local variables or additional code will be extended as needed to handle conversions. """ assert(isinstance(localvars, list)) assert(isinstance(code, list)) result = [] for p in self.params: n = p.name is_temporary = False # Restore original mode only for arrays now # because generator is not adopted for c_mode = p.c_mod and # generates incorrect code for example for instance parameters c_mode = p.mode if p.type.isArray and p.c_mode == "out" \ and p.is_caller_allocates: # C expects an allocated array like for "in out" mode # so we will pass an address of buffer's first element # and do not expect allocation in C c_mode = "in" # Pass the array as is, without creating temporary variable as_array = p.type.isArray and p.is_caller_allocates \ and p.c_mode in ("in", "in out", "out") if self.returns is not None and p.mode != "in" and p.ada_binding \ and as_array is False: n = "Acc_%s" % p.name var = Local_Var( name=n, aliased=True, default="" if p.mode != "in out" else p.name, type=p.type) var.type.userecord = False localvars.append(var) if p.mode == "access": if p.type.allow_none: code.append( "if %s /= null then %s.all := %s; end if;" % (p.name, p.name, var.name)) else: code.append("%s.all := %s;" % (p.name, var.name)) else: is_temporary = p.mode != "out" code.append("%s := %s;" % (p.name, var.name)) # If we do not bind the parameter in the Ada profile, we will need # to substitute its default value instead. But we don't want to # systematically put the default value, which is in Ada. We would # end up with Interfaces.C.Strings.chars_ptr="" result.append(Parameter( name=n, mode=c_mode, type=p.type, for_function=self.returns is not None, default=p.default if not p.ada_binding else None, is_temporary_variable=is_temporary, ada_binding=p.ada_binding, c_mode=p.c_mode, ownership=p.ownership, is_caller_allocates=p.is_caller_allocates)) return result def set_class_wide(self): """This profile is not for a primitive operation, but for a class-wide operation. """ if isinstance(self.params[0].type, GObject): self.params[0].type.classwide = True def add_param(self, pos, param): """Add a new parameter in the list, at the given position""" self.params.insert(pos, param) if self.callback_param: self.callback_param = [p + 1 if p >= pos else p for p in self.callback_param] if self.user_data_param >= 0 and self.user_data_param >= pos: self.user_data_param += 1 if self.destroy_param >= 0 and self.destroy_param >= pos: self.destroy_param += 1 def replace_param(self, name_or_index, type): """Overrides the type of a parameter""" if name_or_index is None: return if isinstance(name_or_index, int): self.params[name_or_index].set_type(type) else: for idx, p in enumerate(self.params): if p.name.lower() == name_or_index.lower(): self.params[idx].set_type(type) return def remove_param(self, names): """Remove the parameter with the given names from the list""" assert(isinstance(names, list)) for n in names: if n is not None: n = n.lower() for p in self.params: if p.name.lower() == n: self.params.remove(p) break def find_param(self, names): """Return the first name for which there is a parameter""" for n in names: lo = n.lower() for p in self.params: if p.name.lower() == lo: return n return None def unset_default_values(self): """Remove the default values for the parameters""" for p in self.params: p.default = None def subprogram(self, name, showdoc=True, local_vars=[], code=[], convention=None, lang="ada"): """Return an instance of Subprogram with the corresponding profile. lang is one of "ada", "c->ada" or "ada->c". """ params = self.params if lang == "ada": params = [p for p in self.params if p.ada_binding] subp = Subprogram( name=name, plist=params, returns=self.returns, showdoc=showdoc, doc=self.doc, lang=lang, local_vars=local_vars, code=code) subp.convention = convention or self.gtkmethod.convention() if name != "": depr = self.node.get("deprecated") if depr is not None: subp.mark_deprecated( "\nDeprecated since %s, %s" % (self.node.get("deprecated-version"), depr)) elif self.gtkmethod and self.gtkmethod.is_obsolete(): subp.mark_deprecated("Deprecated") return subp def _getdoc(self, gtkmethod, node): doc = gtkmethod.get_doc(default=_get_clean_doc(node)) if node.get("version"): doc.append("Since: gtk+ %s" % node.get("version")) return doc def _parameters(self, c, gtkmethod, pkg): """Parse the child node of c""" if c is None: return [] params = c.find(nparams) if params is None: return [] # Check whether we'll bind to a procedure or to a function is_function = self.returns and not gtkmethod.return_as_param() result = [] for p_index, p in enumerate(params.findall(nparam)): name = p.get("name") if name == "...": name = "varargs" gtkparam = gtkmethod.get_param(name=name) adan = gtkparam.ada_name() ada_binding = adan is None or adan != "" name = adan or name # override default computed name default = gtkparam.get_default() allow_access = not default allow_none = gtkparam.allow_none(girnode=p) or default == 'null' nodeOrType = gtkparam.get_type(pkg=pkg) or p type = _get_type( nodeOrType=nodeOrType, allow_none=allow_none, userecord=default != 'null', allow_access=allow_access, pkg=pkg) if type is None: if nodeOrType.find(nvarargs) is not None: type = gtkmethod.get_param("varargs").get_type(pkg=pkg) else: type = gtkmethod.get_param(name).get_type(pkg=pkg) if type is None: return None type = _get_type(type) if not default and allow_none and isinstance(type, UTF8): default = '""' if (p.get("scope", "") in ("notified", "call", "async") or p.get("closure", "") != ""): # "async" means a callback with no closure. As a special case, # we ignore it for destroy callbacks, since they are already # handled specially. if p.get("scope") != "async" \ or type.ada != "Glib.G_Destroy_Notify_Address": self.callback_param.append(p_index) self.user_data_param = int(p.get("closure", "-1")) self.destroy_param = int(p.get("destroy", "-1")) - 1 direction = gtkparam.get_direction() or p.get("direction", "in") assert direction in ("in", "out", "inout", "access"), \ "Invalid value for direction: '%s'" % direction is_allocated = (gtkparam.get_caller_allocates() or p.get("caller-allocates", None)) == "1" ownership = (gtkparam.get_transfer_ownership() or p.get("transfer-ownership", "none")) == "full" if direction == "inout": c_mode = "in out" elif direction in ("out", "access"): c_mode = direction elif type.is_ptr: c_mode = "in out" else: c_mode = "in" if is_function and direction not in ("in", "access"): mode = "access" else: mode = c_mode doc = _get_clean_doc(p) if doc: doc = '"%s": %s' % (name, doc) result.append( Parameter(name=naming.case(name), type=type, mode=mode, default=default, ada_binding=ada_binding, doc=doc, c_mode=c_mode, ownership=ownership, is_caller_allocates=is_allocated)) return result def _returns(self, node, gtkmethod, pkg): """Parse the method's return type""" returns = gtkmethod.returned_c_type() if returns is None: ret = node.find(nreturn) if ret is None: # For a , the method's return value will be the type # of the field itself ret = node else: self.returns_doc = _get_clean_doc(ret) if self.returns_doc: self.returns_doc = "Returns %s" % self.returns_doc return _get_type( ret, allow_access=False, pkg=pkg, transfer_ownership=gtkmethod.transfer_ownership(ret)) else: return naming.type(name=None, cname=returns, pkg=pkg) class GIRClass(object): """Represents a gtk class""" def __init__(self, gir, rootNode, node, identifier_prefix, is_interface=False, is_gobject=True, has_toplevel_type=True): """If has_toplevel_type is False, no widget type is generated""" self.gir = gir self.node = node self.rootNode = rootNode self.ctype = self.node.get(ctype_qname) if not self.ctype: print("no c:type defined for %s" % (self.node.get(glib_type_name, ))) return self._private = "" self._generated = False self.identifier_prefix = identifier_prefix self.implements = dict() # Implemented interfaces self.is_gobject = is_gobject self.is_interface = is_interface self.has_toplevel_type = has_toplevel_type self.callbacks = set() # The callback functions self.pkg = None # Instance of Package(), that we are generating # List of Convert(...) functions that were implemented self.conversions = dict() self.__marshallers = set() # The generated marshallers # Search for the GtkAda binding information self.gtkpkg = gtkada.get_pkg(self.ctype) if not self.gtkpkg.bindtype: self.has_toplevel_type = False self.is_gobject = False # Is this a binding for an opaque C record (not a GObject). In this # case, we bind it as an Ada tagged type so that we can use the # convenient dot notation for primitive operations. This is only doable # if there is no public field that should be user visible in the # record. Otherwise, we'll map to a standard Ada record # (self.is_record) self.is_proxy = False self.is_boxed = (self.node.tag == nrecord and (not self.node.findall(nfield) or self.node.get("introspectable", "1") == "0")) self.is_record = self.node.tag == nrecord and not self.is_boxed if (self.is_boxed and naming.type_exceptions.get(self.ctype) is not None and isinstance(naming.type_exceptions.get(self.ctype), Proxy)): self.is_proxy = True self.is_boxed = False # Register naming exceptions for this class n = naming.case(self.ctype) into = self.gtkpkg.into() ada = self.gtkpkg.ada_name() if ada: pkg = ada elif into: into = naming.case(into) pkg = naming.protect_keywords(into.replace("_", ".", 1)) else: pkg = naming.protect_keywords(n.replace("_", ".", 1)) pkg = "%s.%s" % (pkg, n) naming.add_girname(girname=n, ctype=self.ctype) if has_toplevel_type: ctype = node.get(ctype_qname) if is_interface: t = Interface(pkg) elif is_gobject: t = GObject(pkg) elif self.is_proxy: t = Proxy(pkg) elif self.is_boxed: t = Tagged(pkg) else: t = Record(pkg) naming.add_type_exception(cname=ctype, type=t) classtype = naming.type(name=self.ctype) typename = classtype.ada self.name = package_name(typename) if ada is not None: self.name = ada self.ada_package_name = self.name if not self.has_toplevel_type: # Compute the package name ignoring the type_exceptions. For # instance, we have defined that GdkWindow is mapped to # Gdk.Gdk_Window, but the operations should go into the package # Gdk.Window.Gdk_Window. self.ada_package_name = package_name(pkg) else: typename = "" self.name = package_name(pkg) self.ada_package_name = self.name self.gtkpkg.register_types(adapkg=self.ada_package_name) # Compute information that will be used for the binding self._subst = { # for substitution in string templates "name": self.name, "typename": base_name(typename), "cname": self.ctype or ""} def _handle_function(self, section, c, ismethod=False, gtkmethod=None, showdoc=True, isinherited=False): cname = c.get(cidentifier) if gtkmethod is None: gtkmethod = self.gtkpkg.get_method(cname=cname) if gtkmethod.bind(): profile = SubprogramProfile.parse( node=c, gtkmethod=gtkmethod, pkg=self.pkg) self._handle_function_internal( section, node=c, cname=cname, gtkmethod=gtkmethod, profile=profile, showdoc=showdoc, ismethod=ismethod, isinherited=isinherited) else: naming.add_cmethod( cname, gtkmethod.ada_name() or cname) # Avoid warning later on def _func_is_direct_import(self, profile): """Whether a function with this profile should be implemented directly as a pragma Import, rather than require its own body. """ return not self.is_gobject \ and not self.is_boxed \ and profile.direct_c_map() def _add_self_param(self, adaname, node, gtkmethod, profile, inherited): """Add a Self parameter to the list of parameters in profile. The exact type of the parameter depends on several criteria. :param bool inherited: should be true if this is for a subprogram inherited from an interface (in which case we force the type of Self to be that of the child, not the interface type as described in the gir file) """ # Try to extract the type of the parameter from the instance-parameter # node. t = None if not inherited: try: ip = next(node.iter(ninstanceparam)) ipt = ip.find(ntype) if ipt is not None: ctype_name = ipt.get(ctype_qname) if ctype_name: ctype_name = ctype_name.replace('const ', '') t = naming.type(name=ipt.get('name'), cname=ctype_name, useclass=gtkmethod.is_class_wide()) except StopIteration: t = None # There was no instance-parameter node, guess the type from the # package name if t is None: t = naming.type(self._subst["cname"], cname=self._subst["cname"], useclass=gtkmethod.is_class_wide()) gtkparam = gtkmethod.get_param("self") pname = gtkparam.ada_name() or "Self" direction = gtkparam.get_direction() or "in" if direction in ("out", "access"): mode = direction elif direction == "inout": mode = "in out" else: mode = "in" profile.add_param(0, Parameter(name=pname, type=t, mode=mode)) def _handle_function_internal(self, section, node, cname, gtkmethod, profile=None, showdoc=True, adaname=None, ismethod=False, isinherited=False): """Generate a binding for a function., This returns None if no binding was made, an instance of Subprogram otherwise. `adaname' is the name of the generated Ada subprograms. By default, it is computed automatically from either binding.xml or the "name" attribute of `node'. `profile' is an instance of SubprogramProfile """ assert(profile is None or isinstance(profile, SubprogramProfile)) if profile.has_varargs() \ and gtkmethod.get_param("varargs").node is None: naming.add_cmethod(cname, cname) # Avoid warning later on. print("No binding for %s: varargs" % cname) return None is_import = self._func_is_direct_import(profile) \ and not gtkmethod.get_body() \ and not gtkmethod.return_as_param() adaname = adaname or gtkmethod.ada_name() or node.get("name").title() adaname = naming.protect_keywords(adaname) if not isinherited: naming.add_cmethod(cname, "%s.%s" % (self.pkg.name, adaname)) if ismethod: self._add_self_param( adaname, node, gtkmethod, profile, inherited=isinherited) if adaname.startswith("Gtk_New"): # Overrides the GIR file even if it reported a function or method self._handle_constructor( node, gtkmethod=gtkmethod, cname=cname, profile=profile) return local_vars = [] call = "" body = gtkmethod.get_body() if not is_import: # Prepare the Internal C function internal_call = [] internal = Subprogram( name="Internal", returns=profile.returns, lang="ada->c", plist=profile.c_params(local_vars, internal_call) ).import_c(cname) # Should we transform the return value into a parameter ? ret_as_param = gtkmethod.return_as_param() if ret_as_param is not None: profile.params.append( Parameter(name=ret_as_param, type=profile.returns, mode="out")) profile.returns = None # Is this a function that takes a callback parameter ? cb = profile.callback_param_info() if cb is not None: if ret_as_param: # ??? We would need to change _callback_support to # have additional code to set the return value. One # issue is that the profile has already been changed raise Exception("Cannot bind function with callback" + " and return value as parameter: %s" % cname) return self._callback_support(adaname, cname, profile, cb) execute = internal.call( in_pkg=self.pkg, extra_postcall="".join(internal_call)) if ret_as_param is not None: assert execute[1] is not None, \ "Must have a return value in %s => %s" % (cname, execute) call = "%s%s := %s;" % (execute[0], ret_as_param, execute[1]) else: if execute[1]: # A function, with a standard "return" call = "%sreturn %s;" % (execute[0], execute[1]) else: call = execute[0] local_vars += execute[2] subp = profile.subprogram(name=adaname, showdoc=showdoc, local_vars=local_vars, code=call) if is_import: subp.import_c(cname) else: subp.add_nested(internal) if body: subp.set_body(" " + body.strip() + "\n") section.add(subp) return subp def _callback_support(self, adaname, cname, profile, cb): """Add support for a function with a callback parameter and user data. We generate multiple bindings for such a function: * One version that doesn't take a user_data. This looks like: type My_Callback is access function (Self, other_params); procedure Gtk_Func (Self : ...; Cb : My_Callback); since My_Callback doesn't have exactly the same profile as required by gtk+, we in fact go through an intermediate function in the body, to which we pass, as user_data, a pointer to the user's callback: function Internal_Callback (same_profile_as_c, user_data) is User_Func : My_Callback := convert (user_data); begin return User_Func (...); end Internal_Callback; pragma Convention (C, Internal_Callback); * Ideally we want to generate a generic package to which users can pass their own user data type. We then need to generate the proper Destroy callback that C will call to free that user data. :profile: is an instance of SubprogramProfile. :cname: is the name of the gtk+ C function. :adaname: is the name of the corresponding Ada function. :cb: is a list of Parameter instances representing the callback parameters. """ if len(cb) > 1: print("No binding for %s: multiple callback parameters" % cname) return cb = cb[0] def call_to_c(gtk_func, values, user_data_setup='', user_data_cleanup=''): """Implement the call to the C function. If the user passes a null callback, we always want to pass null to C rather than passing our Internal_Callback'Address. :param values: a dictionary of the parameters to pass to call(). :return: the code for the Ada function's body """ values_if_null = copy.deepcopy(values) values_if_null[cb.name.lower()] = "System.Null_Address" if user_data is not None: values_if_null[user_data.lower()] = "System.Null_Address" exec1 = gtk_func.call( in_pkg=self.pkg, extra_postcall="".join(call), values=values_if_null) call1 = gtk_func.call_to_string(exec1, lang="ada->c") if not call1.endswith(";"): call1 += ";" exec2 = gtk_func.call( in_pkg=self.pkg, extra_postcall="".join(call), values=values) call2 = gtk_func.call_to_string(exec2, lang="ada->c") if not call2.endswith(";"): call2 += ";" if user_data_setup: call2 = user_data_setup + '\n' + call2 if user_data_cleanup: call2 += '\n' + user_data_cleanup return ("""if %s = null then %s else %s end if;""" % (cb.name, call1, call2), exec2[2]) cbname = cb.type.param # Compute the name of the Ada type representing the user callback cb_type_name = naming.type(name=cb.type.ada, cname=cbname).ada funcname = base_name(cb_type_name) destroy = profile.find_param(destroy_data_params) # Compute the profile of the callback (will all its arguments) gtkmethod = self.gtkpkg.get_method(cname=cname) try: cb_gir_node = self.gir.callbacks[cb.type.ada] except: raise Exception( "No GIR node for %s in callback %s" % (cb.type.ada, cname)) cbgtk = self.gtkpkg.get_method(cbname) cb_profile = SubprogramProfile.parse( cb_gir_node, gtkmethod=cbgtk, pkg=self.pkg) user_data = profile.callback_user_data() cb_user_data = cb_profile.find_param(user_data_params) if user_data is None and cb_user_data is not None: user_data = cb_user_data # Generate the access-to-subprogram type for the user callback, unless # we have already done so. This is the type that doesn't receive # user data. if cbname not in self.callbacks: self.callbacks.add(cbname) # Prevent multiple generations section = self.pkg.section("Callbacks") if cb_user_data is None: print("callback has no user data: %s" % cbname) # If the C function has no user data, we do not know how to # generate a high-level binding, since we cannot go through an # intermediate C function that transforms the parameters into # their Ada equivalent. # # Instead, we just generate a low-level C callback passing # System.Address for widgets. nouser_cb_profile = copy.deepcopy(cb_profile) subp = nouser_cb_profile.subprogram(name="", lang="ada->c") section.add( "\ntype %s is %s" % (funcname, subp.spec(pkg=self.pkg))) section.add( "\npragma Convention (C, %s);" % funcname) section.add( ("function To_Address is new Ada.Unchecked_Conversion\n" + " (%s, System.Address);\n") % (cb_type_name,), in_spec=False) else: # Generate a simpler version of the callback, without # user data, that the Ada applications can use nouser_cb_profile = copy.deepcopy(cb_profile) nouser_cb_profile.remove_param( destroy_data_params + [cb_user_data]) subp = nouser_cb_profile.subprogram(name="") section.add( "\ntype %s is %s" % (funcname, subp.spec(pkg=self.pkg))) # Generate a subprogram in the body to act as the C callback. # This subprogram is responsible for calling the user's # callback. In the call to the user's callback, we need to # convert the parameters from the C values to the # corresponding Ada values. self.pkg.add_with( "Ada.Unchecked_Conversion", do_use=False, specs=False) section.add( ("function To_%s is new Ada.Unchecked_Conversion\n" + " (System.Address, %s);\n") % (funcname, funcname), in_spec=False) section.add( ("function To_Address is new Ada.Unchecked_Conversion\n" + " (%s, System.Address);\n") % (cb_type_name,), in_spec=False) ada_func = copy.deepcopy(subp) if ada_func.plist: ada_func.name = "Func" else: ada_func.name = "Func.all" ada_func_call = ada_func.call(in_pkg=self.pkg, lang="c->ada") body_cb = cb_profile.subprogram( name="Internal_%s" % funcname, local_vars=[Local_Var( "Func", "constant %s" % funcname, "To_%s (%s)" % (funcname, cb_user_data))] + ada_func_call[2], lang="c->ada", code=ada_func.call_to_string(ada_func_call, lang="c->ada")) body_cb.convention = "C" body_cb.doc = [] section.add(body_cb, in_spec=False) # The gtk C function, will all parameters. # This will be used to generate the "Internal" nested subprogram. local_vars = [] call = [] gtk_func_profile = copy.deepcopy(profile) if cb is not None: gtk_func_profile.replace_param(cb.name, "System.Address") if cb_user_data is not None: gtk_func_profile.replace_param(destroy, "System.Address") gtk_func = gtk_func_profile.subprogram( name=naming.case("C_%s" % cname), lang="ada->c").import_c(cname) # This function is shared both by the version without user_data and by # the generic package, so we need to put it directly in the package, # not a nested subprogram. self.pkg.section("").add(gtk_func, in_spec=False) # Create a version of the function without a user data. section = self.pkg.section("Methods") nouser_profile = copy.deepcopy(profile) if user_data is None: values = {destroy: "System.Null_Address", cb.name.lower(): "To_Address (%s)" % cb.name} elif cb_user_data is None: values = {destroy: "System.Null_Address", cb.name.lower(): "Internal_%s'Address" % funcname, user_data.lower(): "To_Address (%s)" % cb.name} else: nouser_profile.remove_param(destroy_data_params + [user_data]) values = {destroy: "System.Null_Address", cb.name.lower(): "Internal_%s'Address" % funcname, user_data.lower(): "To_Address (%s)" % cb.name} c_call = call_to_c(gtk_func, values) subp = nouser_profile.subprogram( name=adaname, local_vars=c_call[1], code=c_call[0]) section.add(subp) # Now create a generic package that will provide access to # user_data. The function can no longer be a primitive operation of the # object, since it is in a nested package. # It is possible that the function doesn't accept a user data in fact # (for instance when scope="async"). In this case, no need for a # generic package. user_data2 = cb_profile.find_param(user_data_params) if user_data2 is not None: # If we have no "destroy" callback, so any memory we allocate via # User.Build would be leaked. Better not to provide a binding # in such a case. # As a special case, some functions do not need to keep the data # after their execution, so we can still bind those. if profile.callback_destroy() is None \ and '_for' not in cname \ and cname not in ('gtk_tree_view_map_expanded_rows', 'pango_attributes_filter', 'gdk_window_invalidate_maybe_recurse', 'gtk_menu_popup'): pass else: self.pkg.add_with("Glib.Object", do_use=False, specs=False) pkg2 = Package(name="%s_User_Data" % adaname) section.add(pkg2) pkg2.formal_params = """type User_Data_Type (<>) is private; with procedure Destroy (Data : in out User_Data_Type) is null;""" sect2 = pkg2.section("") sect2.add("""package Users is new Glib.Object.User_Data_Closure (User_Data_Type, Destroy);""", in_spec=False) sect2.add( ("function To_%s is new Ada.Unchecked_Conversion\n" + " (System.Address, %s);\n") % (funcname, funcname), in_spec=False) sect2.add( ("function To_Address is new Ada.Unchecked_Conversion\n" + " (%s, System.Address);\n") % (funcname,), in_spec=False) cb_profile2 = copy.deepcopy(cb_profile) cb_profile2.replace_param(user_data2, "User_Data_Type") cb2 = cb_profile2.subprogram(name="") sect2.add( "\ntype %s is %s" % (funcname, cb2.spec(pkg=pkg2))) values = {user_data2.lower(): "D.Data.all"} user_cb = cb_profile2.subprogram( name="To_%s (D.Func)" % funcname) user_cb_call = user_cb.call( in_pkg=self.pkg, lang="c->ada", extra_postcall="".join(call), values=values) internal_cb = cb_profile.subprogram( name="Internal_Cb", local_vars=[ Local_Var("D", "constant Users.Internal_Data_Access", "Users.Convert (%s)" % user_data2)] + user_cb_call[2], convention="C", lang="c->ada", code=user_cb.call_to_string(user_cb_call, lang="c->ada")) sect2.add(internal_cb, in_spec=False) values = {destroy: "Users.Free_Data'Address", cb.name.lower(): "%s'Address" % internal_cb.name, user_data.lower(): "D"} full_profile = copy.deepcopy(profile) full_profile.set_class_wide() full_profile.remove_param(destroy_data_params) full_profile.replace_param(cb.name, funcname) full_profile.replace_param(user_data, "User_Data_Type") if profile.callback_destroy() is None: c_call = call_to_c( gtk_func, values, user_data_setup= "D := Users.Build (To_Address (%s), %s);" % (cb.name, user_data), user_data_cleanup="Users.Free_Data (D);") else: c_call = call_to_c( gtk_func, values, user_data_setup= "D := Users.Build (To_Address (%s), %s);" % (cb.name, user_data)) subp2 = full_profile.subprogram( name=adaname, local_vars=c_call[1] + [Local_Var("D", "System.Address")], code=c_call[0]) sect2.add(subp2) return subp def _constructors(self): n = QName(uri, "constructor").text for c in self.node.findall(n): cname = c.get(cidentifier) gtkmethod = self.gtkpkg.get_method(cname=cname) if not gtkmethod.bind(): naming.add_cmethod( cname, gtkmethod.ada_name() or cname) # Avoid warning continue profile = SubprogramProfile.parse( node=c, gtkmethod=gtkmethod, pkg=self.pkg, ignore_return=True) if profile.has_varargs() \ and gtkmethod.get_param("varargs").node is None: naming.add_cmethod(cname, cname) # Avoid warning later on. print("No binding for %s: varargs" % cname) continue self._handle_constructor( c, gtkmethod=gtkmethod, cname=cname, profile=profile) def _handle_constructor(self, c, cname, gtkmethod, profile=None): assert(profile is None or isinstance(profile, SubprogramProfile)) section = self.pkg.section("Constructors") name = c.get("name").title() assert profile.params is not None, "No profile defined for %s" % cname format_params = ", ".join(p.name for p in profile.params) if format_params: self._subst["internal_params"] = " (%s)" % format_params format_params = ", " + format_params self._subst["params"] = format_params else: self._subst["params"] = "" self._subst["internal_params"] = "" if self.is_gobject or self.is_boxed: profile.returns = AdaType( "System.Address", pkg=self.pkg, in_spec=False) else: profile.returns = AdaType( "%(typename)s" % self._subst, pkg=self.pkg, in_spec=False) local_vars = [] code = [] internal = Subprogram( name="Internal", lang="ada->c", plist=profile.c_params(local_vars, code), returns=profile.returns).import_c(cname) call = internal.call(in_pkg=self.pkg) assert(call[1] is not None) # A function gtk_new_prefix = "Gtk_New" adaname = gtkmethod.ada_name() if not adaname: if cname.startswith("gdk_") or cname.startswith("pango_"): gtk_new_prefix = "Gdk_New" adaname = "Gdk_%s" % name # e.g. Gdk_New elif cname.startswith("g_"): gtk_new_prefix = "G_New" adaname = "G_%s" % name # e.g. G_New else: adaname = "Gtk_%s" % name # e.g. Gtk_New selfname = gtkmethod.get_param("self").ada_name() or "Self" if self.is_gobject: selftype = "%(typename)s_Record'Class" % self._subst else: selftype = "%(typename)s" % self._subst if self.is_gobject: filtered_params = [p for p in profile.params if p.ada_binding] initialize_name=adaname.replace( gtk_new_prefix, "%s.Initialize" % self.pkg.name) initialize_params = [Parameter( name=selfname, type=AdaType(selftype, pkg=self.pkg, in_spec=True), mode="not null access")] + filtered_params initialize = Subprogram( name=initialize_name, plist=initialize_params, local_vars=local_vars + call[2], doc=profile.doc + [('\n%s does nothing if the object was already' + ' created with another call to Initialize* or G_New.') % ( base_name(initialize_name), )], code="if not %s.Is_Created then %sSet_Object (%s, %s); end if" % ( selfname, call[0], selfname, call[1]), ).add_nested(internal) call = initialize.call(in_pkg=self.pkg) assert(call[1] is None) # This is a procedure naming.add_cmethod(cname, "%s.%s" % (self.pkg.name, adaname)) gtk_new = Subprogram( name=adaname, plist=[Parameter( name=selfname, type=AdaType("%(typename)s" % self._subst, pkg=self.pkg, in_spec=True), mode="out")] + filtered_params, local_vars=call[2], code=selfname + " := new %(typename)s_Record;" % self._subst + call[0], doc=profile.doc) section.add(gtk_new) section.add(initialize) # Gtk_New as a function gtk_new = Subprogram( name="%s_%s" % (self._subst["typename"], name), returns=AdaType("%(typename)s" % self._subst, pkg=self.pkg, in_spec=True), plist=filtered_params, local_vars=call[2] + [Local_Var(selfname, "constant %(typename)s" % self._subst, "new %(typename)s_Record" % self._subst)], code=call[0] + "return %s;" % selfname, doc=profile.doc) section.add(gtk_new) elif self.is_boxed: gtk_new = Subprogram( name=adaname, plist=[Parameter( name=selfname, type=AdaType("%(typename)s" % self._subst, pkg=self.pkg, in_spec=True), mode="out")] + profile.params, local_vars=local_vars + call[2], code="%s%s.Set_Object (%s)" % (call[0], selfname, call[1]), doc=profile.doc) gtk_new.add_nested(internal) section.add(gtk_new) # Now as a function gtk_new = Subprogram( name="%s_%s" % (self._subst["typename"], name), returns=AdaType("%(typename)s" % self._subst, pkg=self.pkg, in_spec=True), plist=profile.params, local_vars=local_vars + call[2] + [Local_Var(selfname, "%(typename)s" % self._subst)], code="%s%s.Set_Object (%s); return %s" % ( call[0], selfname, call[1], selfname), doc=profile.doc) gtk_new.add_nested(internal) section.add(gtk_new) else: # likely a Proxy gtk_new = Subprogram( name=adaname, plist=[Parameter( name=selfname, type=AdaType("%(typename)s" % self._subst, pkg=self.pkg, in_spec=True), mode="out")] + profile.params, local_vars=local_vars + call[2], code="%s%s := %s" % (call[0], selfname, call[1]), doc=profile.doc) gtk_new.add_nested(internal) section.add(gtk_new) # Now as a function gtk_new = Subprogram( name="%s_%s" % (self._subst["typename"], name), returns=AdaType("%(typename)s" % self._subst, pkg=self.pkg, in_spec=True), plist=profile.params, local_vars=local_vars + call[2] + [Local_Var(selfname, "%(typename)s" % self._subst)], code="%s%s := %s; return %s;" % ( call[0], selfname, call[1], selfname), doc=profile.doc) gtk_new.add_nested(internal) section.add(gtk_new) def _methods(self): all = self.node.findall(nmethod) if all is not None: section = self.pkg.section("Methods") for c in all: self._handle_function(section, c, ismethod=True) def _functions(self): all = self.node.findall(nfunction) if all is not None: section = self.pkg.section("Functions") for c in all: self._handle_function(section, c) def _virtual_methods(self): all = self.node.findall(nvirtualmethod) has_iface = False if all is not None: ifacename = base_name(self.name) info = '' for c in all: if not self.gtkpkg.bind_virtual_method( c.get('name'), default=self.is_interface): continue gtkmethod = self.gtkpkg.get_method(cname=c.get('name')) basename = gtkmethod.ada_name() or c.get('name').title() adaname = "Virtual_%s" % basename if not has_iface: has_iface = True section = self.pkg.section("Virtual Methods") info += """ procedure Set_%(basename)s (Self : %(type)s; Handler : %(adaname)s); pragma Import (C, Set_%(basename)s, "gtkada_%(ifacename)s_set_%(method)s"); """ % {"basename": basename, "type": "%s_Interface_Descr" % ifacename if self.is_interface else "Glib.Object.GObject_Class", "adaname": adaname, "ifacename": ifacename, "method": basename.lower()} c_iface = '%s%s' % ( self.identifier_prefix, self.node.get(glib_type_struct)) self.gir.ccode += """ void gtkada_%(type)s_set_%(method)s(%(iface)s* iface, void* handler) { iface->%(field)s = handler; } """ % {"type": ifacename, "method": basename.lower(), "iface": c_iface, "field": c.get('name')} profile = SubprogramProfile.parse( node=c, gtkmethod=gtkmethod, pkg=self.pkg) self._add_self_param( adaname=adaname, node=c, gtkmethod=gtkmethod, profile=profile, inherited=False) subp = profile.subprogram( name=adaname, lang="ada->c", convention="C", showdoc=True) section.add( '\ntype %s is %s' % ( adaname, subp.spec(pkg=self.pkg, as_type=True))) subp.add_withs_for_subprogram(pkg=self.pkg, in_specs=True) if has_iface: info = ('subtype %s_Interface_Descr is ' % ifacename + 'Glib.Object.Interface_Description;\n' + info + '-- See Glib.Object.Add_Interface\n') section.add(info) self.pkg.add_with('Glib.Object') def _globals(self): funcs = self.gtkpkg.get_global_functions() # List of binding.xml nodes if funcs: section = self.pkg.section("Functions") # Make sure section exists for f in funcs: c = self.gir.globals.get_function( f.cname()) # Node in gir file self._handle_function(section, c, gtkmethod=f) def _method_get_type(self): """Generate the Get_Type subprogram""" n = self.node.get(ggettype) if n is not None: section = self.pkg.section("Constructors") gtkmethod = self.gtkpkg.get_method(cname=n) if not gtkmethod.bind(): return self.pkg.add_with("Glib") get_type_name = gtkmethod.ada_name() or "Get_Type" section.add( Subprogram( name=get_type_name, doc=gtkmethod.get_doc(default=''), returns=AdaType("Glib.GType", pkg=self.pkg, in_spec=True)) .import_c(n)) if not self.gtktype.is_subtype() \ and not self.is_interface \ and self.is_gobject \ and self._subst["parent"] is not None: self.pkg.add_with("Glib.Type_Conversion_Hooks", specs=False) self._subst["get_type"] = get_type_name section.add( ("package Type_Conversion_%(typename)s is new" + " Glib.Type_Conversion_Hooks.Hook_Registrator\n" + " (%(get_type)s'Access, %(typename)s_Record);\n" + "pragma Unreferenced (Type_Conversion_%(typename)s);""") % self._subst, in_spec=False) def _get_c_type(self, node): t = node.find(ntype) if t is not None: return t.get(ctype_qname) return None def _fields(self): fields = self.node.findall(nfield) if fields: section = self.pkg.section("Fields") for f in fields: name = f.get("name") # Getter if f.get("readable", "1") != "0": cname = "gtkada_%(cname)s_get_%(name)s" % { "cname": self._subst["cname"], "name": name} gtkmethod = self.gtkpkg.get_method(cname=cname) if gtkmethod.bind(default="false"): profile = SubprogramProfile.parse( node=f, gtkmethod=gtkmethod, pkg=self.pkg) func = self._handle_function_internal( section, node=f, cname=cname, adaname="Get_%s" % name, ismethod=True, profile=profile, gtkmethod=gtkmethod) if func is not None: ctype = self._get_c_type(f) if ctype is None: continue self.gir.ccode += """ %(ctype)s %(cname)s (%(self)s* self) { return self->%(name)s; } """ % {"ctype": ctype, "cname": cname, "self": self.ctype, "name": name} # Setter if f.get("writable", "1") != "0": cname = "gtkada_%(cname)s_set_%(name)s" % { "cname": self._subst["cname"], "name": name} gtkmethod = self.gtkpkg.get_method(cname=cname) if gtkmethod.bind("false"): profile = SubprogramProfile.setter( node=f, pkg=self.pkg) func = self._handle_function_internal( section, node=f, cname=cname, adaname="Set_%s" % name, ismethod=True, gtkmethod=gtkmethod, profile=profile) if func is not None: ctype = self._get_c_type(f) if ctype is None: continue self.gir.ccode += """ void %(cname)s (%(self)s* self, %(ctype)s val) { self->%(name)s = val; } """ % {"ctype": ctype, "cname": cname, "self": self.ctype, "name": name} def _properties(self): n = QName(uri, "property") props = list(self.node.findall(n.text)) if props is not None: adaprops = [] for p in props: flags = [] if p.get("readable", "1") != "0": flags.append("read") if p.get("writable", "1") != "0": flags.append("write") # Do not provide a "pkg=self.pkg" parameter, since we do # not want to generate a with for the actual property type # (for instance a Gtk_Cell_Area), just for the actual type # (Property_Object). tp = _get_type(p) tp.userecord = False ptype = tp.as_property() if ptype: pkg = ptype[:ptype.rfind(".")] if pkg: self.pkg.add_with(pkg) else: section = self.pkg.section("Properties") section.add( (' %(name)s_Property : constant ' + 'Glib.Properties.Property_String :=\n' + ' Glib.Properties.Build ("%(cname)s");' + ' -- Unknown type: %(type)s') % { "name": naming.case(p.get("name")), "type": (p.find(ntype).get("name") if p.find(ntype) is not None else "unspecified"), "cname": p.get("name")}) self.pkg.add_with("Glib.Properties") continue adaprops.append({ "cname": p.get("name"), "name": naming.case(p.get("name")), "flags": "-".join(flags), "doc": _get_clean_doc(p), "pkg": pkg, "ptype": ptype, "type": tp.as_ada_param(self.pkg)}) if adaprops: section = self.pkg.section("Properties") section.add_comment( """The following properties are defined for this widget. See Glib.Properties for more information on properties)""") adaprops.sort(key=lambda x: x["name"]) for p in adaprops: prop_str = ' %(name)s_Property : constant %(ptype)s;' % p if not section.add(prop_str): continue # Only display the type if it isn't obvious from the actual # type of the property. if p["type"] not in ("Boolean", "UTF8_String", "Gfloat", "Glib.Gint", "Guint") \ and not p["type"].startswith("Gtk.Enums."): section.add( Code("Type: %(type)s" % p, iscomment=True)) if p["flags"] != "read-write": section.add( Code("Flags: %(flags)s" % p, iscomment=True)) if p["doc"]: section.add(Code("%s" % p["doc"], iscomment=True)) d = ' %(name)s_Property : constant %(ptype)s' % p self.pkg.add_private( d + ' :=\n %(pkg)s.Build ("%(cname)s");' % p) def _compute_marshaller_suffix(self, selftype, profile): """Computes the suffix for the connect and marshallers types based on the profile of the signal. """ return "_".join( [base_name(selftype.ada)] + [base_name(p.type.ada) for p in profile.params] + [(base_name(profile.returns.ada) if profile.returns else "Void")]) def _marshall_gvalue(self, profile): """Return the arguments to parse to an Ada callback, after extracting them from a GValue. Returns a list of local variables for the marshaller, and its body """ call_params = [] for index, p in enumerate(profile.params): if isinstance(p.type, Tagged): call_params.append( "%s.From_Object (Unchecked_To_Address (Params, %d))" % (package_name(p.type.ada), index + 1)) elif isinstance(p.type, Interface): call_params.append( "%s (Unchecked_To_Interface (Params, %d))" % (p.type.ada, index + 1)) elif isinstance(p.type, GObject): if p.type.ada != "Glib.Object.GObject": call_params.append( "%s (Unchecked_To_Object (Params, %d))" % ( p.type.ada, index + 1)) else: call_params.append( "Unchecked_To_Object (Params, %d)" % (index + 1, )) else: if p.mode != "in": call_params.append( "Unchecked_To_%s_Access (Params, %d)" % ( base_name(p.type.ada), index + 1)) else: call_params.append( "Unchecked_To_%s (Params, %d)" % ( base_name(p.type.ada), index + 1)) if call_params: call = "H (Obj, %s)" % ", ".join(call_params) else: call = "H (Obj)" if profile.returns: marsh_local = [ Local_Var("V", profile.returns, aliased=True, default=call)] marsh_body = "Set_Value (Return_Value, V'Address);" else: marsh_local = [] marsh_body = "%s;" % call marsh_body += "exception when E : others => Process_Exception (E);" return marsh_local, marsh_body def _generate_slot_marshaller(self, section, selftype, node, gtkmethod): """Generate connect+marshaller when connect takes a slot object. These procedure are independent of the specific widget, and can be shared. Returns the name for the hander type. """ if SHARED_SLOT_MARSHALLERS: pkg = gir.slot_marshaller_pkg section = gir.slot_marshaller_section existing_marshallers = gir.slot_marshallers else: pkg = self.pkg section = section existing_marshallers = self.__marshallers profile = SubprogramProfile.parse( node=node, gtkmethod=gtkmethod, pkg=pkg) callback_selftype = GObject( "Glib.Object.GObject", classwide=True, allow_none=True) name_suffix = self._compute_marshaller_suffix( callback_selftype, profile) slot_name = "Cb_%s" % name_suffix marshname = "Marsh_%s" % name_suffix callback = Subprogram( name="", plist=[Parameter(name="Self", type=callback_selftype)] + profile.params, code="null", allow_none=False, returns=profile.returns) if slot_name not in existing_marshallers: existing_marshallers.add(slot_name) slot_handler_type = "type %s is %s;" % ( slot_name, callback.profile( pkg=pkg, maxlen=69, indent=" ")) section.add(Code(slot_handler_type), in_spec=True) section.add(Code( """function Cb_To_Address is new Ada.Unchecked_Conversion (%s, System.Address); function Address_To_Cb is new Ada.Unchecked_Conversion (System.Address, %s); """ % (slot_name, slot_name)), in_spec=False) if isinstance(selftype, Interface): obj_in_body = "Glib.Types.GType_Interface (Object)" else: obj_in_body = "Object" connect_slot_body = """ Unchecked_Do_Signal_Connect (Object => %s, C_Name => C_Name, Marshaller => %s'Access, Handler => Cb_To_Address (Handler), -- Set in the closure Slot_Object => Slot, After => After)""" % (obj_in_body, marshname) marsh_local, marsh_body = self._marshall_gvalue(profile) connect_slot = Subprogram( name="Connect_Slot", plist=[Parameter("Object", selftype), Parameter("C_Name", "Glib.Signal_Name"), Parameter("Handler", slot_name), Parameter("After", "Boolean"), Parameter("Slot", GObject( "Glib.Object.GObject", allow_none=True, classwide=True), default="null") ], code=connect_slot_body) section.add(connect_slot, in_spec=False) addr_to_obj = "Glib.Object.Convert (Get_Data (Closure))" marsh = Subprogram( name=marshname, plist=[Parameter("Closure", "GClosure"), Parameter("Return_Value", "Glib.Values.GValue"), Parameter("N_Params", "Glib.Guint"), Parameter("Params", "Glib.Values.C_GValues"), Parameter("Invocation_Hint", "System.Address"), Parameter("User_Data", "System.Address")], local_vars=[ Local_Var("H", "constant %s" % slot_name, "Address_To_Cb (Get_Callback (Closure))"), Local_Var("Obj", "Glib.Object.GObject", constant=True, default=addr_to_obj) ] + marsh_local, convention="C", code=marsh_body) section.add(marsh, in_spec=False) return slot_name, callback def _generate_marshaller(self, section, selftype, node, gtkmethod): """Generate, if needed, a connect+marshaller for signals with this profile. Returns the name of the type that contains the subprogram profile """ profile = SubprogramProfile.parse( node=node, gtkmethod=gtkmethod, pkg=self.pkg if gtkmethod.bind() else None) name_suffix = self._compute_marshaller_suffix(selftype, profile) marshname = "Marsh_%s" % name_suffix name = "Cb_%s" % name_suffix callback = Subprogram( name="", plist=[Parameter(name="Self", type=selftype)] + profile.params, code="null", allow_none=False, returns=profile.returns) if gtkmethod.bind() and name not in self.__marshallers: self.__marshallers.add(name) handler_type = "type %s is %s;" % ( name, callback.profile( pkg=self.pkg, maxlen=69, indent=" ")) section.add(Code(handler_type), in_spec=True) section.add(Code( """function Cb_To_Address is new Ada.Unchecked_Conversion (%s, System.Address); function Address_To_Cb is new Ada.Unchecked_Conversion (System.Address, %s); """ % (name, name)), in_spec=False) if isinstance(selftype, Interface): obj_in_body = "Glib.Types.GType_Interface (Object)" else: obj_in_body = "Object" connect_body = """ Unchecked_Do_Signal_Connect (Object => %s, C_Name => C_Name, Marshaller => %s'Access, Handler => Cb_To_Address (Handler), -- Set in the closure After => After)""" % (obj_in_body, marshname) marsh_local, marsh_body = self._marshall_gvalue(profile) connect = Subprogram( name="Connect", plist=[Parameter("Object", selftype), Parameter("C_Name", "Glib.Signal_Name"), Parameter("Handler", name), Parameter("After", "Boolean"), ], code=connect_body) section.add(connect, in_spec=False) if isinstance(selftype, Interface): addr_to_obj = \ "%s (Unchecked_To_Interface (Params, 0))" % selftype.ada else: addr_to_obj = \ "%s (Unchecked_To_Object (Params, 0))" % selftype.ada marsh = Subprogram( name=marshname, plist=[Parameter("Closure", "GClosure"), Parameter("Return_Value", "Glib.Values.GValue"), Parameter("N_Params", "Glib.Guint"), Parameter("Params", "Glib.Values.C_GValues"), Parameter("Invocation_Hint", "System.Address"), Parameter("User_Data", "System.Address")], local_vars=[ Local_Var("H", "constant %s" % name, "Address_To_Cb (Get_Callback (Closure))"), Local_Var("Obj", selftype.ada, constant=True, default=addr_to_obj) ] + marsh_local, convention="C", code=marsh_body) section.add(marsh, in_spec=False) return name, callback, profile def _signals(self): signals = list(self.node.findall(gsignal)) if signals: adasignals = [] section = self.pkg.section("Signals") section.sort_objects = False # preserve insertion order # If at least one signal gets a On_* procedure for s in signals: if self.gtkpkg.get_method( cname="::%s" % s.get("name")).bind(): section.add( Code("use type System.Address;"), in_spec=False) self.pkg.add_with("Gtkada.Bindings", specs=False) self.pkg.add_with("Glib.Values", specs=False) self.pkg.add_with("Gtk.Arguments", specs=False) if SHARED_SLOT_MARSHALLERS: self.pkg.add_with("Gtkada.Marshallers") self.pkg.add_with( "Ada.Unchecked_Conversion", specs=False, do_use=False) break signals.sort(key=lambda x: x.get("name")) for s in signals: gtkmethod = self.gtkpkg.get_method( cname="::%s" % (s.get("name"))) bind = gtkmethod.bind() name = s.get("name") if self.is_gobject: selftype = GObject("%(typename)s" % self._subst, allow_none=True, classwide=True) on_selftype = GObject("%(typename)s" % self._subst, allow_none=False, classwide=False) elif self.is_interface: on_selftype = selftype = Interface( "%(typename)s" % self._subst) else: on_selftype = selftype = Proxy( "%(typename)s" % self._subst) # We need to parse the profile twice, so that the with # statements are set both in self.pkg and in # gtkada.marshallers handler_type_name, sub, profile = \ self._generate_marshaller( section, selftype, node=s, gtkmethod=gtkmethod) if bind: slot_handler_type_name, obj_sub = \ self._generate_slot_marshaller( section, selftype, node=s, gtkmethod=gtkmethod) section.add( Code(' Signal_%s : constant Glib.Signal_Name := "%s";' % (naming.case(name, protect=False), name)), add_newline=False) if bind: connect = Subprogram( name="On_%s" % naming.case(name, protect=False), plist=[Parameter(name="Self", type=on_selftype), Parameter( name="Call", type=Proxy(handler_type_name)), Parameter( name="After", type="Boolean", default="False")], code='Connect (Self, "%s" & ASCII.NUL, Call, After);' % name) section.add(connect, add_newline=False) self.pkg.add_with("Glib.Object") obj_connect = Subprogram( name="On_%s" % naming.case(name, protect=False), plist=[Parameter(name="Self", type=on_selftype), Parameter( name="Call", type=Proxy(slot_handler_type_name)), Parameter( name="Slot", type=GObject("Glib.Object.GObject", allow_none=False, classwide=True)), Parameter( name="After", type="Boolean", default="False")], code=('Connect_Slot (Self, "%s" & ASCII.NUL,' + ' Call, After, Slot);') % name) section.add(obj_connect) doc = _get_clean_doc(s) if doc: section.add(Code(" %s""" % doc, iscomment=True)) if not bind: sub.name = "Handler" section.add( Code( sub.profile(pkg=self.pkg, maxlen=69), fill=False, iscomment=True)) if profile.returns_doc or len(profile.params) > 1: doc = "\n Callback parameters:" + sub.formatted_doc() if profile.returns_doc: doc += "\n -- %s" % profile.returns_doc section.add(Code(doc, fill=False, iscomment=True)) def _implements(self): """Bind the interfaces that a class implements""" implements = list(self.node.findall(nimplements)) or [] for impl in implements: name = impl.get("name") # Special case, because the GIR file are inconsistent if name == "Gio.Icon": name = "Icon" # If the interface is purposefully not bound if "--%s" % name in interfaces: continue try: intf = self.gir.interfaces[name] except KeyError: intf = self.gir.interfaces[naming.girname_to_ctype[name]] type = naming.type(intf.ctype) if "." in type.ada: self.pkg.add_with(type.ada[:type.ada.rfind(".")]) self.pkg.add_with("Glib.Types") impl = dict( name=name, adatype=base_name(type.ada), impl=type.ada, interface=intf, body="", pkg="%(typename)s" % self._subst) impl["code"] = \ """package Implements_%(adatype)s is new Glib.Types.Implements (%(impl)s, %(pkg)s_Record, %(pkg)s); function "+" (Widget : access %(pkg)s_Record'Class) return %(impl)s renames Implements_%(adatype)s.To_Interface; function "-" (Interf : %(impl)s) return %(pkg)s renames Implements_%(adatype)s.To_Object; """ % impl self.implements[name] = impl # For an interface, we also define "+" to cast to itself. This is used # when writting custom bodies for the methods of the interface, so that # those bodies can be reused for the types that implement the # interface. See GtkTreeModel. if self.is_interface: self.implements[""] = { "name": self._subst["typename"], "interface": None, "code": """function "+" (W : %(typename)s) return %(typename)s; pragma Inline ("+"); """ % self._subst, "body": """function "+" (W : %(typename)s) return %(typename)s is begin return W; end "+";""" % self._subst, } if self.implements: # Duplicate the subprograms from the interfaces. This doesn't # quite work: for instance, Gtk.About_Dialog already has a # Get_Name, so we can't redefine the one inherited from Buildable. section = self.pkg.section( "Inherited subprograms (from interfaces)") for impl in sorted(self.implements.keys()): impl = self.implements[impl] if impl["name"] == "Buildable": # Do not repeat for buildable, that's rarely used section.add_comment( "Methods inherited from the Buildable interface are" + " not duplicated here since they are meant to be" + " used by tools, mostly. If you need to call them," + ' use an explicit cast through the "-" operator' + " below.") continue interf = impl["interface"] # Ignore interfaces that we haven't bound if interf is not None and not hasattr(interf, "gtkpkg"): print("%s: methods for interface %s were not bound" % ( self.name, impl["name"])) elif interf is not None: all = interf.node.findall(nmethod) for c in all: cname = c.get(cidentifier) gtkmethod = interf.gtkpkg.get_method(cname) interfmethod = self.gtkpkg.get_method(cname) if interfmethod.bind(): self._handle_function( section, c, showdoc=False, gtkmethod=gtkmethod, ismethod=True, isinherited=True) section = self.pkg.section("Interfaces") section.add_comment( "This class implements several interfaces. See Glib.Types") for impl in sorted(self.implements.keys()): impl = self.implements[impl] section.add_comment("") section.add_comment('- "%(name)s"' % impl) section.add(impl["code"]) if impl["body"]: section.add(impl["body"], in_spec=False) def add_list_binding(self, section, adaname, ctype, singleList): """Generate a list instance""" conv = "%s->Address" % ctype.ada decl = "" body = "" if conv not in self.conversions: self.conversions[conv] = True base = "function Convert (R : %s) return System.Address" % ( ctype.ada) decl += base + ';\n' body += base + " is\nbegin\n" if isinstance(ctype, Proxy): body += "return Glib.To_Address (Glib.C_Proxy (R));" else: body += "return Get_Object (R);" body += "\nend Convert;\n\n" conv = "Address->%s" % ctype.ada if conv not in self.conversions: self.conversions[conv] = True decl += "function Convert (R : System.Address) return %s;\n" % ( ctype.ada) body += "function Convert (R : System.Address) return %s is\n" % ( ctype.ada) if isinstance(ctype, Proxy): body += "begin\nreturn %s" % ctype.ada \ + "(Glib.C_Proxy'(Glib.To_Proxy (R)));" elif isinstance(ctype, Tagged): # Not a GObject ? body += "begin\nreturn From_Object(R);" else: body += "Stub : %s_Record;" % ctype.ada body += "begin\n" body += "return %s (Glib.Object.Get_User_Data (R, Stub));" % ( ctype.ada) body += "\nend Convert;" if singleList: pkg = "GSlist" generic = "Generic_SList" else: pkg = "Glist" generic = "Generic_List" self.pkg.add_with("Glib.%s" % pkg) decl += "package %s is new %s (%s);\n" % (adaname, generic, ctype.ada) section.add(decl) section.add(body, in_spec=False) def record_binding( self, section, ctype, adaname, type, override_fields, unions, private): """Create the binding for a or type. override_fields has the same format as returned by GtkAdaPackage.records() """ base = adaname or base_name(type.ada) try: node = gir.records[ctype] except KeyError: # The package doesn't contain a type (for instance GtkMain) return gir.bound.add(ctype) is_union = node.tag == nunion first_field_ctype = None fields = [] # array of (name,type,default) tuples # Check if we have forced the mapping as a C proxy ? if (naming.type_exceptions.get(ctype, None) is None or not isinstance(naming.type_exceptions[ctype], Proxy)): for field in node.findall(nfield): name = field.get("name") ftype = None type = _get_type(field) cb = field.findall(ncallback) if type: ftype = override_fields.get(name, None) if ftype is None: if not first_field_ctype: t = field.findall(ntype) assert t, "No type info for %s.%s" % (ctype, name) ctype = t[0].get(ctype_qname) if not ctype: # has no c:type attribute, # so we try to map the name to a Girname ctype = naming.girname_to_ctype[ t[0].get("name")] first_field_ctype = ctype ftype = type elif cb: # ??? JL: Should properly bind the callback here. # For now, we just use a System.Address to maintain the # record integrity ftype = override_fields.get(name, None) if ftype is None: ftype = AdaType( "System.Address", pkg=self.pkg) else: print("WARNING: Field '%s.%s' has no type" % (name, base)) print(" generated record is most certainly incorrect") if ftype is not None: if ftype.ada in ("GSList", "GList") and private: ftype = "System.Address" default_value = "System.Null_Address" else: default_value = ftype.default_record_field_value ftype = ftype.record_field_type(pkg=self.pkg) self.pkg.add_with(package_name(ftype)) fields.append((naming.case(name), ftype, default_value)) if not fields: section.add( ("\ntype %(typename)s is new Glib.C_Proxy;\n" + "function From_Object_Free (B : access %(typename)s) " + "return %(typename)s;\npragma Inline (From_Object_Free);") % {"typename": base}) section.add(""" function From_Object_Free (B : access %(typename)s) return %(typename)s is Result : constant %(typename)s := B.all; begin Glib.g_free (B.all'Address); return Result; end From_Object_Free;""" % {"typename": base}, in_spec=False) else: if private: section.add( ("\ntype %(typename)s is private;\n" + "function From_Object_Free (B : access %(typename)s)" + " return %(typename)s;\n" + "pragma Inline (From_Object_Free);") % {"typename": base}) adder = self.pkg.add_private else: adder = section.add if is_union: enums = self.get_enumeration_values(first_field_ctype) enums_dict = {ctype: adatype for ctype, adatype in enums} text = "\ntype %s (%s : %s := %s) is record\n" % ( base, fields[0][0], fields[0][1], enums[0][1]) + \ " case %s is\n" % fields[0][0] for index, f in enumerate(fields): if index != 0: when_stmt = [] if unions: for v, key in unions: # applies to field if key.lower() == f[0].lower(): when_stmt.append(enums_dict[v]) else: when_stmt = [enums[index][1]] if not when_stmt: print("ERROR: no discrimant value for field %s" % f[0]) text += "\n when %s =>\n %s : %s;\n" % ( "\n | ".join(when_stmt), f[0], f[1]) text += " end case;\nend record;\n" text += "pragma Convention (C, %s);\n" % base text += "pragma Unchecked_Union(%s);\n" % base adder("\n" + Code(text).format()) else: c = [] for f in fields: if f[2]: c.append('%s : %s := %s;' % (f[0], f[1], f[2])) else: c.append('%s : %s;' % (f[0], f[1])) c = Code('\ntype %s is record\n' % base + '\n'.join(c) + '\nend record;\npragma Convention (C, %s);\n' % base) adder(c.format()) if not private: section.add( ("\nfunction From_Object_Free (B : access %(type)s)" + " return %(type)s;\n" + "pragma Inline (From_Object_Free);") % {"type": base}) section.add(""" function From_Object_Free (B : access %(typename)s) return %(typename)s is Result : constant %(typename)s := B.all; begin Glib.g_free (B.all'Address); return Result; end From_Object_Free;""" % {"typename": base}, in_spec=False) section.add(Code(_get_clean_doc(node), iscomment=True)) def get_enumeration_values(sef, enum_ctype): """Return the list of enumeration values for the given enum, as a list of tuples (C identifier, ada identifier)""" node = gir.enums[enum_ctype] return [(m.get(cidentifier), naming.adamethod_name(m.get(cidentifier))) for m in node.findall(nmember)] def constants_binding(self, section, regexp, prefix): constants = [] r = re.compile(regexp) for name, node in gir.constants.items(): if r.match(name): name = name.replace(prefix, "").title() gir.bound.add(node.get(ctype_qname)) type = node.findall(ntype) ctype = type[0].get(ctype_qname) ftype = naming.type(name="", cname=ctype) constants.append( '%s : constant %s := "%s";' % (name, ftype.ada, node.get("value"))) constants.sort() section.add("\n".join(constants)) def enumeration_binding(self, section, ctype, type, prefix, asbitfield=False, ignore=""): """Add to the section the Ada type definition for the ctype. type is the corresponding instance of CType(). This function also handles types. :param prefix: is removed from the values to get the default Ada name, which can be overridden in data.cname_to_adaname. :param ignore: space-separated list of values that should not be bound. """ base = base_name(type.ada) node = gir.enums[ctype] current = 0 is_default_representation = True gir.bound.add(ctype) members = [] ignore = set(ignore.split()) for member in node.findall(nmember): cname = member.get(cidentifier) if cname in ignore: continue m = naming.adamethod_name(cname, warning_if_not_found=False) if m is None: continue if cname == m: # No special case ? Attempt a simple rule (remove leading # Gtk prefix, and capitalize the value) m = cname.replace(prefix, "").title() else: m = base_name(m) # For proper substitution in docs naming.add_cmethod( cname=cname, adaname="%s.%s" % (self.name, m)) value = int(member.get("value")) if value != current: is_default_representation = False current += 1 members.append((m, value)) decl = "" if node.tag == nenumeration and not asbitfield: section.add( "type %s is " % base + "(\n" + ",\n".join(m[0] for m in sorted(members, key=lambda m: m[1])) + ");\n" + "pragma Convention (C, %s);\n" % base) section.add(Code(_get_clean_doc(node), iscomment=True)) if not is_default_representation: repr = (" for %s use (\n" % base + ",\n".join(" %s => %s" % m for m in sorted(members, key=lambda m: m[1])) + ");\n") section.add(repr) elif node.tag == nbitfield or asbitfield: section.add( "\ntype %s is " % base + "mod 2 ** Integer'Size;\n" + "pragma Convention (C, %s);\n" % base) section.add(Code(_get_clean_doc(node), iscomment=True)) for m, value in members: decl += "%s : constant %s := %s;\n" % (m, base, value) section.add(decl) section.pkg.section("Enumeration Properties").add( "package %s_Properties is\n" % base + " new Generic_Internal_Discrete_Property (%s);\n" % base + "type Property_%s is new %s_Properties.Property;\n\n" % ( base, base)) self.pkg.add_with("Glib.Generic_Properties") def generate(self, gir): if self._generated: return extra = self.gtkpkg.extra() if extra: self.node.extend(extra) # The parent is unfortunately specified as a GIR name. But that creates # ambiguities when loading both Gtk and Gdk, which for instance both # define "Window". So we first look in the same file as the current # Class. parent = gir._get_class_node( self.rootNode, girname=self.gtkpkg.parent_type() or self.node.get("parent")) parent = naming.type( name=self.gtkpkg.parent_type() or self.node.get( "parent"), # GIRName cname=parent and parent.get(ctype_qname)).ada if parent and parent.rfind(".") != -1: self._subst["parent_pkg"] = package_name(parent) self._subst["parent"] = base_name(parent) else: self._subst["parent_pkg"] = None self._subst["parent"] = parent self._generated = True girdoc = _get_clean_doc(self.node) into = self.gtkpkg.into() if into: # Make sure we have already generated the other package, so that # its types go first. klass = gir.classes.get(into, None) or gir.ctype_interfaces[into] klass.generate(gir) into = klass.name # from now on, we want the Ada name # Do not integrate the documentation from the other package, it # is likely useless anyway girdoc = "" # Override the type exception. For instance, from now on we # want to use "Gtk.Box.Gtk_HBox" rather than "Gtk.HBox.Gtk_HBox" # which doesn't exist typename = "%s.%s" % (into, self._subst["typename"]) # retrieve the old type oldtype = naming.type(cname=self.ctype) newtype = None # and create the new one accordingly if isinstance(oldtype, Tagged): newtype = Tagged(typename) elif isinstance(oldtype, GObject): newtype = GObject(typename) elif isinstance(oldtype, Proxy): newtype = Proxy(typename) elif isinstance(oldtype, Record): newtype = Record(typename) else: raise Exception("Can't override %s for a package with 'into'" % oldtype) naming.add_type_exception( override=True, cname=self.ctype, type=newtype) self.pkg = gir.get_package(into or self.ada_package_name, ctype=self.ctype, doc=girdoc) if self._subst["parent_pkg"]: self.pkg.add_with("%(parent_pkg)s" % self._subst) self.gtktype = self.gtkpkg.get_type(self._subst["typename"]) section = self.pkg.section("") if self.gtkpkg.is_obsolete(): section.add("pragma Obsolescent;") if not self.has_toplevel_type: pass elif self.is_interface: self.pkg.add_with("Glib.Types") section.add( """type %(typename)s is new Glib.Types.GType_Interface; Null_%(typename)s : constant %(typename)s;""" % self._subst) self.pkg.add_private(""" Null_%(typename)s : constant %(typename)s := %(typename)s (Glib.Types.Null_Interface);""" % self._subst) elif self.gtktype.is_subtype(): section.add( """ subtype %(typename)s_Record is %(parent)s_Record; subtype %(typename)s is %(parent)s;""" % self._subst) elif self.is_proxy: section.add(""" type %(typename)s is new Glib.C_Proxy;""" % self._subst) elif self.is_boxed: # The type is not private so that we can directly instantiate # generic packages for lists of this type. section.add(""" type %(typename)s is new Glib.C_Boxed with null record; Null_%(typename)s : constant %(typename)s; function From_Object (Object : System.Address) return %(typename)s; function From_Object_Free (B : access %(typename)s'Class) return %(typename)s; pragma Inline (From_Object_Free, From_Object); """ % self._subst) # Insert constant declaration at the end of the package, to avoid # freezing issues self.pkg.add_private( ("\n Null_%(typename)s : constant %(typename)s :=" + " (Glib.C_Boxed with null record);\n") % self._subst, at_end=True) section.add(""" function From_Object_Free (B : access %(typename)s'Class) return %(typename)s is Result : constant %(typename)s := %(typename)s (B.all); begin Glib.g_free (B.all'Address); return Result; end From_Object_Free; function From_Object (Object : System.Address) return %(typename)s is S : %(typename)s; begin S.Set_Object (Object); return S; end From_Object; """ % self._subst, in_spec=False) elif self._subst["parent"] is None: # Likely a public record type (ie with visible fields). # Automatically add it to the list of records to bind. self.gtkpkg.add_record_type(self.ctype) else: section.add(""" type %(typename)s_Record is new %(parent)s_Record with null record; type %(typename)s is access all %(typename)s_Record'Class;""" % self._subst) for ctype, enum, prefix, asbitfield, ignore in \ self.gtkpkg.enumerations(): self.enumeration_binding( section, ctype, enum, prefix, asbitfield=asbitfield, ignore=ignore) for regexp, prefix in self.gtkpkg.constants(): self.constants_binding(section, regexp, prefix) for ctype, enum, adaname, fields, unions, private in \ self.gtkpkg.records(): self.record_binding( section, ctype, adaname, enum, fields, unions, private) for ada, ctype, single, sect_name in self.gtkpkg.lists(): sect = self.pkg.section(sect_name) self.add_list_binding(sect, ada, ctype, single) if extra: for p in extra: if p.tag == "with_spec": self.pkg.add_with( p.get("pkg", "Missing package name in "), do_use=p.get("use", "true").lower() == "true") elif p.tag == "with_body": self.pkg.add_with( p.get("pkg"), specs=False, do_use=p.get("use", "true").lower() == "true") elif p.tag == "type": naming.add_type_exception( cname=p.get("ctype"), type=Proxy(p.get("ada"), p.get("properties", None))) section.add(p.text) elif p.tag == "body": if p.get("before", "true").lower() == "true": # Go before the body of generated subprograms, so that # we can add type definition section.add(p.text, in_spec=False) self._constructors() self._method_get_type() self._methods() if extra: s = None for p in extra: if p.tag == "spec": if p.get("private", "False").lower() == "true": self.pkg.add_private(p.text, at_end=True) else: s = s or self.pkg.section("GtkAda additions") s.add(p.text) elif p.tag == "body" \ and p.get("before", "true").lower() != "true": s.add(p.text, in_spec=False) self._functions() self._globals() self._fields() self._virtual_methods() if not into and self.name != "Gtk.Widget": self._implements() self._properties() self._signals() # Set up and invoke our command line parser parser = OptionParser() parser.add_option( "--gir-file", help="input GTK .gir file", action="append", dest="gir_file", metavar="FILE") parser.add_option( "--xml-file", help="input GtkAda binding.xml file", dest="xml_file", metavar="FILE") parser.add_option( "--ada-output", help="Ada language output file", dest="ada_outfile", metavar="FILE") parser.add_option( "--c-output", help="C language output file", dest="c_outfile", metavar="FILE") (options, args) = parser.parse_args() # Command line argument sanity checking: make sure that all of our # inputs and outputs are specified. missing_files = [] if options.gir_file is None: missing_files.append("GIR file") if options.xml_file is None: missing_files.append("binding.xml file") if options.ada_outfile is None: missing_files.append("Ada output file") if options.c_outfile is None: missing_files.append("C output file") if missing_files: parser.error('Must specify files:\n\t' + ', '.join(missing_files)) gtkada = GtkAda(options.xml_file) gir = GIR(options.gir_file) Package.copyright_header = \ """------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ """ gir.ccode = \ """/***************************************************************************** * GtkAda - Ada95 binding for Gtk+/Gnome * * * * Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet * * Copyright (C) 2000-2022, AdaCore * * * * This library is free software; you can redistribute it and/or modify it * * under terms of the GNU General Public License as published by the Free * * Software Foundation; either version 3, or (at your option) any later * * version. This library is distributed in the hope that it will be useful, * * but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- * * TABILITY or FITNESS FOR A PARTICULAR PURPOSE. * * * * As a special exception under Section 7 of GPL version 3, you are granted * * additional permissions described in the GCC Runtime Library Exception, * * version 3.1, as published by the Free Software Foundation. * * * * You should have received a copy of the GNU General Public License and * * a copy of the GCC Runtime Library Exception along with this program; * * see the files COPYING3 and COPYING.RUNTIME respectively. If not, see * * . * * ***************************************************************************** This file is automatically generated from the .gir files */ #include """ for the_ctype in enums: node = Element( nclass, {ctype_qname: the_ctype}) root = Element(nclass) cl = gir._create_class(rootNode=root, node=node, identifier_prefix='', is_interface=False, is_gobject=False, has_toplevel_type=False) cl.generate(gir) for name in interfaces: if name.startswith("--"): gir.bound.add(name[2:]) continue gir.interfaces[name].generate(gir) gir.bound.add(name) for the_ctype in binding: if the_ctype.startswith("--"): gir.bound.add(the_ctype[2:]) continue try: e = gir.classes[the_ctype] except KeyError: cl = gtkada.get_pkg(the_ctype) if not cl: raise node = Element(nclass, {ctype_qname: the_ctype}) e = gir.classes[the_ctype] = gir._create_class( rootNode=root, node=node, is_interface=False, identifier_prefix='') e.generate(gir) gir.bound.add(the_ctype) with open(options.ada_outfile, "wb") as out: with open(options.c_outfile, "wb") as cout: gir.generate(out, cout) gir.show_unbound() gtkada-24.0.0/contrib/binding.xml000066400000000000000000013274451446021174000166430ustar00rootroot00000000000000 procedure Get_Window_At_Position (Self : not null access Gdk_Device_Record; Win_X : out Gint; Win_Y : out Gint; Window : out Gdk.Gdk_Window); -- Obtains the window underneath Device, returning the location of the -- device in Win_X and Win_Y. Returns null if the window tree under Device -- is not known to GDK (for example, belongs to another application). -- As a slave device coordinates are those of its master pointer, This -- function may not be called on devices of type -- Gdk.Device.Gdk_Device_Type_Slave, unless there is an ongoing grab on -- them, see Gdk.Device.Grab. -- Since: gtk+ 3.0 -- "win_x": return location for the X coordinate of the device location, -- relative to the window origin, or null. -- "win_y": return location for the Y coordinate of the device location, -- relative to the window origin, or null. procedure Set_Device (Event : Gdk.Event.Gdk_Event; Device : not null access Gdk_Device_Record); -- Sets the device for Event to Device. The event must -- have been allocated by GTK+, for instance, by gdk_event_copy(). procedure Set_Source_Device (Event : Gdk.Event.Gdk_Event; Device : not null access Gdk_Device_Record); -- Sets the slave device for Event to Device. -- The event must have been allocated by GTK+, -- for instance by gdk_event_copy(). procedure Set_Source_Device (Event : Gdk.Event.Gdk_Event; Device : not null access Gdk_Device_Record) is procedure Internal (Event : Gdk.Event.Gdk_Event; D : System.Address); pragma Import (C, Internal, "gdk_event_set_source_device"); begin Internal (Event, Get_Object (Device)); end Set_Source_Device; procedure Set_Device (Event : Gdk.Event.Gdk_Event; Device : not null access Gdk_Device_Record) is procedure Internal (Event : Gdk.Event.Gdk_Event; D : System.Address); pragma Import (C, Internal, "gdk_event_set_device"); begin Internal (Event, Get_Object (Device)); end Set_Device; procedure Get_Window_At_Position (Self : not null access Gdk_Device_Record; Win_X : out Gint; Win_Y : out Gint; Window : out Gdk.Gdk_Window) is function Internal (Self : System.Address; Acc_Win_X : access Gint; Acc_Win_Y : access Gint) return Gdk.Gdk_Window; pragma Import (C, Internal, "gdk_device_get_window_at_position"); Acc_Win_X : aliased Gint; Acc_Win_Y : aliased Gint; begin Window := Internal (Get_Object (Self), Acc_Win_X'Access, Acc_Win_Y'Access); Win_X := Acc_Win_X; Win_Y := Acc_Win_Y; end Get_Window_At_Position; ------------- -- Display -- ------------- -- These subprograms should really be in gdk-display.ads to match what is -- done for gtk+ itself, but that would create dependency circularities. -- Ada 2012 has support for these, but we want GtkAda to build with Ada95 -- compilers. function Get_Screen (Display : access Gdk.Display.Gdk_Display_Record'Class; Screen_Num : Glib.Gint) return Gdk_Screen; -- Returns a screen object for one of the screens of the display. function Get_Default_Screen (Display : access Gdk.Display.Gdk_Display_Record'Class) return Gdk_Screen; -- Get the default Gdk_Screen for display. procedure Get_Pointer (Display : access Gdk.Display.Gdk_Display_Record'Class; Screen : out Gdk_Screen; X : out Glib.Gint; Y : out Glib.Gint; Mask : out Gdk.Types.Gdk_Modifier_Type); -- Gets the current location of the pointer and the current modifier -- mask for a given display. -- (X, Y) are coordinates relative to the root window on the display procedure Warp_Pointer (Display : access Gdk.Display.Gdk_Display_Record'Class; Screen : access Gdk_Screen_Record; X : Glib.Gint; Y : Glib.Gint); -- Warps the pointer of display to the point x,y on the screen screen, -- unless the pointer is confined to a window by a grab, in which case it -- will be moved as far as allowed by the grab. Warping the pointer creates -- events as if the user had moved the mouse instantaneously to the -- destination. -- -- Note that the pointer should normally be under the control of the user. -- This function was added to cover some rare use cases like keyboard -- navigation support for the color picker in the GtkColorSelectionDialog. function Get_Screen (Display : access Gdk_Display_Record'Class; Screen_Num : Gint) return Gdk_Screen is function Internal (Display : System.Address; Screen_Num : Gint) return System.Address; pragma Import (C, Internal, "gdk_display_get_screen"); -- External binding: gdk_display_get_screen Stub : Gdk_Screen_Record; begin return Gdk_Screen (Get_User_Data (Internal (Get_Object (Display), Screen_Num), Stub)); end Get_Screen; function Get_Default_Screen (Display : access Gdk_Display_Record'Class) return Gdk_Screen is function Internal (Display : System.Address) return System.Address; pragma Import (C, Internal, "gdk_display_get_default_screen"); -- External binding: gdk_display_get_default_screen Stub : Gdk_Screen_Record; begin return Gdk_Screen (Get_User_Data (Internal (Get_Object (Display)), Stub)); end Get_Default_Screen; procedure Get_Pointer (Display : access Gdk_Display_Record'Class; Screen : out Gdk_Screen; X : out Gint; Y : out Gint; Mask : out Gdk_Modifier_Type) is procedure Internal (Display : System.Address; Screen : out System.Address; X : out Gint; Y : out Gint; Mask : out Gdk_Modifier_Type); pragma Import (C, Internal, "gdk_display_get_pointer"); -- External binding: gdk_display_get_pointer S : System.Address; Stub : Gdk_Screen_Record; begin Internal (Get_Object (Display), S, X, Y, Mask); Screen := Gdk_Screen (Get_User_Data (S, Stub)); end Get_Pointer; procedure Warp_Pointer (Display : access Gdk.Display.Gdk_Display_Record'Class; Screen : access Gdk_Screen_Record; X : Glib.Gint; Y : Glib.Gint) is procedure Internal (D, S : System.Address; X, Y : Gint); pragma Import (C, Internal, "gdk_display_warp_pointer"); -- External binding: gdk_display_warp_pointer begin Internal (Get_Object (Display), Get_Object (Screen), X, Y); end Warp_Pointer; function Get_Area (Context : access Gtk_Cell_Area_Context_Record) return Gtk.Cell_Area.Gtk_Cell_Area; -- Fetches the Gtk.Cell_Area.Gtk_Cell_Area this Context was created by. -- This is generally unneeded by layouting widgets; however it is important -- for the context implementation itself to fetch information about the -- area it is being used for. -- For instance at GtkCellAreaContextClass.allocate time its important to -- know details about any cell spacing that the Gtk.Cell_Area.Gtk_Cell_Area -- is configured with in order to compute a proper allocation. -- Since: gtk+ 3.0 function Get_Area (Cell_Layout : Gtk_Cell_Layout) return Gtk.Cell_Area.Gtk_Cell_Area; -- Returns the underlying Gtk.Cell_Area.Gtk_Cell_Area which might be -- Cell_Layout if called on a Gtk.Cell_Area.Gtk_Cell_Area or might be null -- if no Gtk.Cell_Area.Gtk_Cell_Area is used by Cell_Layout. -- Since: gtk+ 3.0 procedure Get_Cell_At_Position (Self : access Gtk_Cell_Area_Record; Context : access Gtk.Cell_Area_Context.Gtk_Cell_Area_Context_Record'Class; Widget : access Gtk.Widget.Gtk_Widget_Record'Class; Cell_Area : Gdk.Rectangle.Gdk_Rectangle; X : Gint; Y : Gint; Alloc_Area : out Gdk.Rectangle.Gdk_Rectangle; Renderer : out Gtk.Cell_Renderer.Gtk_Cell_Renderer); -- Gets the Gtk.Cell_Renderer.Gtk_Cell_Renderer at X and Y coordinates -- inside Area and optionally returns the full cell allocation for it -- inside Cell_Area. -- Since: gtk+ 3.0 -- "context": the Gtk.Cell_Area_Context.Gtk_Cell_Area_Context used to hold -- sizes for Area. -- "widget": the Gtk.Widget.Gtk_Widget that Area is rendering on -- "cell_area": the whole allocated area for Area in Widget for this row -- "x": the x position -- "y": the y position -- "alloc_area": where to store the inner allocated area of the returned -- cell renderer, or null. -- "renderer": the rendered that was found. -------------- -- Get_Area -- -------------- function Get_Area (Context : access Gtk_Cell_Area_Context_Record) return Gtk.Cell_Area.Gtk_Cell_Area is function Internal (Context : System.Address) return System.Address; pragma Import (C, Internal, "gtk_cell_area_context_get_area"); Stub_Gtk_Cell_Area : Gtk.Cell_Area.Gtk_Cell_Area_Record; begin return Gtk.Cell_Area.Gtk_Cell_Area (Get_User_Data (Internal (Get_Object (Context)), Stub_Gtk_Cell_Area)); end Get_Area; -------------- -- Get_Area -- -------------- function Get_Area (Cell_Layout : Gtk_Cell_Layout) return Gtk.Cell_Area.Gtk_Cell_Area is function Internal (Cell_Layout : Gtk_Cell_Layout) return System.Address; pragma Import (C, Internal, "gtk_cell_layout_get_area"); Stub_Gtk_Cell_Area : Gtk.Cell_Area.Gtk_Cell_Area_Record; begin return Gtk.Cell_Area.Gtk_Cell_Area (Get_User_Data (Internal (Cell_Layout), Stub_Gtk_Cell_Area)); end Get_Area; -------------------------- -- Get_Cell_At_Position -- -------------------------- procedure Get_Cell_At_Position (Self : access Gtk_Cell_Area_Record; Context : access Gtk.Cell_Area_Context.Gtk_Cell_Area_Context_Record'Class; Widget : access Gtk.Widget.Gtk_Widget_Record'Class; Cell_Area : Gdk.Rectangle.Gdk_Rectangle; X : Gint; Y : Gint; Alloc_Area : out Gdk.Rectangle.Gdk_Rectangle; Renderer : out Gtk.Cell_Renderer.Gtk_Cell_Renderer) is function Internal (Self : System.Address; Context : System.Address; Widget : System.Address; Cell_Area : Gdk.Rectangle.Gdk_Rectangle; X : Gint; Y : Gint; Acc_Alloc_Area : access Gdk.Rectangle.Gdk_Rectangle) return System.Address; pragma Import (C, Internal, "gtk_cell_area_get_cell_at_position"); Acc_Alloc_Area : aliased Gdk.Rectangle.Gdk_Rectangle; Stub_Gtk_Cell_Renderer : Gtk.Cell_Renderer.Gtk_Cell_Renderer_Record; Tmp_Return : System.Address; begin Tmp_Return := Internal (Get_Object (Self), Get_Object (Context), Get_Object (Widget), Cell_Area, X, Y, Acc_Alloc_Area'Access); Alloc_Area := Acc_Alloc_Area; Renderer := Gtk.Cell_Renderer.Gtk_Cell_Renderer (Get_User_Data (Tmp_Return, Stub_Gtk_Cell_Renderer)); end Get_Cell_At_Position; A Gtk_Color_Selection widget is a complex dialog that allows the user to select a color based either on its (Red, Green, Blue) or its (Hue, Saturation, Value). An additional field is provided to select the opacity of the color (this is usually called the alpha channel). See Gtk.Color_Selection_Dialog for a version of this widget that comes with its own dialog. See Gtk.Extra.Color_Combo for a different way to select colors. type Gtk_Color_Selection_Change_Palette_With_Screen_Func is access procedure (Screen : System.Address; -- Convert to Gdk_Screen with Get_User_Data Colors : Gdk.Color.Gdk_Color_Unconstrained_Array; N_Colors : Gint); pragma Convention (C, Gtk_Color_Selection_Change_Palette_With_Screen_Func); -- This function should save the new palette contents, and update the -- Gtk_Settings property "gtk-color-palette" so all Gtk_Color_Selection -- widgets will be modified, including the current one. For instance, you -- would do: -- Set_String_Property -- (Get_Default, Gtk_Color_Palette, Palette_To_String (Colors), "Foo"); function Palette_From_String (Str : String) return Gdk.Color.Gdk_Color_Array; -- Parses a color palette string. This string is a colon-separated list of -- color names readable by Gdk.Color.Parse. -- An empty array is returned if Str couldn't be parsed function Palette_To_String (Colors : Gdk.Color.Gdk_Color_Array) return String; -- Encodes a palette as a string, useful for persistent storage. package Color_Arrays is new Gtkada.C.Unbounded_Arrays (Gdk.Color.Gdk_Color, Gdk.Color.Null_Color, Natural, Gdk.Color.Gdk_Color_Array); function Palette_From_String (Str : String) return Gdk_Color_Array is use Color_Arrays; function Internal (Str : String; Colors : access Unbounded_Array_Access; N : access Gint) return Gboolean; pragma Import (C, Internal, "gtk_color_selection_palette_from_string"); N : aliased Gint; Output : aliased Unbounded_Array_Access; begin if Internal (Str & ASCII.NUL, Output'Access, N'Access) = 0 then Output := null; end if; declare Result : constant Gdk_Color_Array := To_Array (Output, Integer (N)); begin g_free (Output); return Result; end; end Palette_From_String; function Palette_To_String (Colors : Gdk_Color_Array) return String is function Internal (Colors : System.Address; N_Colors : Gint) return Gtkada.Types.Chars_Ptr; pragma Import (C, Internal, "gtk_color_selection_palette_to_string"); Str : chars_ptr; begin if Colors'Length = 0 then return ""; else Str := Internal (Colors (Colors'First)'Address, Colors'Length); declare Result : constant String := Value (Str); begin g_free (Str); return Result; end; end if; end Palette_To_String; The Gtk_Color_Selection_Dialog provides a standard dialog which allows the user to select a color much like the Gtk_File_Selection provides a standard dialog for file selection. function Get_Active_Iter (Combo_Box : not null access Gtk_Combo_Box_Record) return Gtk.Tree_Model.Gtk_Tree_Iter; -- Return the currently active iter function Get_Active_Text (Combo_Box : not null access Gtk_Combo_Box_Record) return UTF8_String; -- Return the text present in the entry if it has one, or the empty string function Get_Active_Iter (Combo_Box : not null access Gtk_Combo_Box_Record) return Gtk_Tree_Iter is function Internal (Combo_Box : System.Address; Iter : System.Address) return Gboolean; pragma Import (C, Internal, "gtk_combo_box_get_active_iter"); Iter : aliased Gtk_Tree_Iter; Tmp : constant Gboolean := Internal (Get_Object (Combo_Box), Iter'Address); begin if Tmp /= 0 then return Iter; else return Null_Iter; end if; end Get_Active_Iter; function Get_Active_Text (Combo_Box : not null access Gtk_Combo_Box_Record) return UTF8_String is begin if not Combo_Box.Get_Has_Entry then return ""; end if; return Gtk_Entry (Combo_Box.Get_Child).Get_Text; end Get_Active_Text; Create a new box. The box's child can then be set using the Gtk.Container.Add function. This widget provides a nice way for the user of your application to select fonts. It first searches on your system for the list of fonts available, and displays a set of boxes to select them based on their name, their weight, their size, etc. This widget is provided in two forms, one widget that can be embedded in any container, a Gtk_Font_Selection, whereas the other one comes directly in its own separate window (to be popped up as a dialog). Some filters can be applied to the widget, when you want the user to select only a font only among a specific subset (like bitmap or true-type fonts for instance). There are two kinds of filters: a base filter, set in your application and that the user can not change; a user filter that can be modified interactively by the user. This widget provides a dialog for selecting a font. See also Gtk.Font_Selection. This is a very convenient widget to visually group related widgets (like groups of buttons for instance), possibly with a title to explain the purpose of this group. A Gtk_Frame has only one child, so you have to put a container like for instance a Gtk_Box inside if you want the frame to surround multiple widgets. Change the underlines pattern. Pattern is a simple string made of underscore and space characters, matching the ones in the string. GtkAda will underline every letter that matches an underscore. An empty string disables the underlines. example: If the text is FooBarBaz and the Pattern is "___ ___" then both "Foo" and "Baz" will be underlined, but not "Bar". procedure Append_Page (Notebook : access Gtk_Notebook_Record; Child : access Gtk.Widget.Gtk_Widget_Record'Class); procedure Append_Page (Notebook : access Gtk_Notebook_Record; Child : access Gtk.Widget.Gtk_Widget_Record'Class; Tab_Label : access Gtk.Widget.Gtk_Widget_Record'Class); procedure Prepend_Page (Notebook : access Gtk_Notebook_Record; Child : access Gtk.Widget.Gtk_Widget_Record'Class; Tab_Label : access Gtk.Widget.Gtk_Widget_Record'Class); -- Convenience functions, same as above but discarding the return value. procedure Append_Page (Notebook : access Gtk_Notebook_Record; Child : access Gtk.Widget.Gtk_Widget_Record'Class) is Ignored : Gint; pragma Unreferenced (Ignored); begin Ignored := Append_Page (Notebook, Child, null); end Append_Page; procedure Append_Page (Notebook : access Gtk_Notebook_Record; Child : access Gtk.Widget.Gtk_Widget_Record'Class; Tab_Label : access Gtk.Widget.Gtk_Widget_Record'Class) is Ignored : Gint; pragma Unreferenced (Ignored); begin Ignored := Append_Page (Notebook, Child, Tab_Label); end Append_Page; procedure Prepend_Page (Notebook : access Gtk_Notebook_Record; Child : access Gtk.Widget.Gtk_Widget_Record'Class; Tab_Label : access Gtk.Widget.Gtk_Widget_Record'Class) is Ignored : Gint; pragma Unreferenced (Ignored); begin Ignored := Append_Page (Notebook, Child, Tab_Label); end Prepend_Page; Add a child to the top or left pane. You can not change dynamically the attributes Resize and Shrink. Instead, you have to remove the child from the container, and put it back with the new value of the attributes. You should also first call Glib.Object.Ref on the child so as to be sure it is not destroyed when you remove it, and Glib.Object.Unref it at the end. See the example in testgtk/ in the GtkAda distribution. Add the first child of the container. The child will be displayed either in the top or in the left pane, depending on the orientation of the container. This is equivalent to using the Pack1 procedure with its default parameters. Add the second child of the container. It will be displayed in the bottom or right pane, depending on the container's orientation. This is equivalent to using Pack2 with its default parameters. The children will be displayed one on top of the other The children will be displayed next to each other See the testgtk example in the GtkAda distribution to see concrete examples on how all the parameters for the boxes work. Used with Glib.Object.G_New, this creates a horizontal box Return the Num-th child of the box, or null if there is no such child function Wait_For_Targets (Clipboard : not null access Gtk_Clipboard_Record) return Gdk.Types.Gdk_Atom_Array; -- Returns a list of targets that are present on the clipboard, or an empty -- array if there aren't any targets available. -- This function waits for the data to be received using the main -- loop, so events, timeouts, etc, may be dispatched during the wait. package Atom_Arrays is new Gtkada.C.Unbounded_Arrays (Gdk.Types.Gdk_Atom, Gdk.Types.Gdk_None, Natural, Gdk.Types.Gdk_Atom_Array); ---------------------- -- Wait_For_Targets -- ---------------------- function Wait_For_Targets (Clipboard : not null access Gtk_Clipboard_Record) return Gdk.Types.Gdk_Atom_Array is use Atom_Arrays; function Internal (Clipboard : System.Address; Targets : access Unbounded_Array_Access; N_Targets : access Gint) return Gboolean; pragma Import (C, Internal, "gtk_clipboard_wait_for_targets"); Output : aliased Unbounded_Array_Access; N_Targets : aliased Gint; begin if Internal (Get_Object (Clipboard), Output'Unchecked_Access, N_Targets'Unchecked_Access) = 0 then G_Free (Output); Output := null; end if; declare Result : constant Gdk_Atom_Array := To_Array (Output, Integer (N_Targets)); begin if Output /= null then G_Free (Output); end if; return Result; end; end Wait_For_Targets; Whether the pixmap should be grayed out, as is done for insensitive widgets that do not accept user interaction function Create_Pixmap (Filename : String; Window : access Gtk.Window.Gtk_Window_Record'Class) return Gtk_Pixmap; -- Create a pixmap given a window and a filename function Create_Pixmap (Data : Gtkada.Types.Chars_Ptr_Array; Window : access Gtk.Window.Gtk_Window_Record'Class) return Gtk_Pixmap; -- Create a pixmap given a window and a buffer. Dummy_Pixmap : constant Gtkada.Types.chars_ptr_array := (New_String ("1 1 1 1"), New_String ("c None"), New_String (" ")); -- This is a dummy pixmap we use when a pixmap can't be found. function Create_Pixmap (Filename : String; Window : access Gtk.Window.Gtk_Window_Record'Class) return Gtk_Pixmap is Gdkpixmap : Gdk.Pixmap.Gdk_Pixmap; Mask : Gdk.Bitmap.Gdk_Bitmap; Pixmap : Gtk_Pixmap; use Gtk.Widget; use Gtk.Window; begin if not Realized_Is_Set (Window) then Gtk.Window.Realize (Window); end if; if Filename = "" then Gdk.Pixmap.Create_From_Xpm_D (Gdkpixmap, Get_Window (Window), Mask, Gdk.Color.Null_Color, Dummy_Pixmap); else Gdk.Pixmap.Create_From_Xpm (Gdkpixmap, Get_Window (Window), Mask, Gdk.Color.Null_Color, Filename); end if; Gtk_New (Pixmap, Gdkpixmap, Mask); return Pixmap; end Create_Pixmap; function Create_Pixmap (Data : Gtkada.Types.Chars_Ptr_Array; Window : access Gtk.Window.Gtk_Window_Record'Class) return Gtk_Pixmap is Gdkpixmap : Gdk.Pixmap.Gdk_Pixmap; Mask : Gdk.Bitmap.Gdk_Bitmap; Pixmap : Gtk_Pixmap; use Gtk.Widget; use Gtk.Window; begin if not Realized_Is_Set (Window) then Gtk.Window.Realize (Window); end if; Gdk.Pixmap.Create_From_Xpm_D (Gdkpixmap, Get_Window (Window), Mask, Gdk.Color.Null_Color, Data); Gtk_New (Pixmap, Gdkpixmap, Mask); return Pixmap; end Create_Pixmap; Modify the alignment for the widget. Xalign and Yalign are both values between 0.0 and 1.0 that specify the alignment: if Xalign is 0.0, the widget will be left aligned; if it is 0.5, the widget will be centered; if it is 1.0 the widget will be right aligned. Yalign is from top (0.0) to bottom (1.0). Both Xalign and Yalign will be constrained to the range 0.0 .. 1.0 Note that if the widget fills its allocated area, these two parameters won't have any effect. A Gtk_Layout is a widget that can have an almost infinite size, without occupying a lot of memory. Its children can be located anywhere within it, but will only appear on the screen if the visible area of the layout contains them. Just like a Gtk_Viewport, its visible area is indicated by two Gtk_Adjustment widgets, and thus a Gtk_Layout can be put as is in a Gtk_Scrolled_Window. As for Gtk_Fixed containers, the children can be located anywhere in the layout (no automatic organization is done). But, as opposed to Gtk_Fixed widgets, a Gtk_Layout does not try to resize itself to show all its children. Starting from GtkAda 2.0, you have to call Set_Size and specify the maximum size of the layout, otherwise children added with Put outside the size defined for the layout will never be visible. One way to do this is to systematically call Set_Size before calling Put, and make sure you specify a size big enough for the layout. The child will be displayed on the screen only if at least part of it intersects the visible area of the layout. The layout does not resize itself to automatically show the widget. You also need to call Set_Size, if the size you initially defined is smaller than (X, Y), or the child will never be visible even if the layout is scrolled. A Gtk_Button_Box is a special type of Gtk_Box specially tailored to contain buttons. This is only a base class for Gtk_Hbutton_Box and Gtk_Vbutton_Box which provide a way to arrange their children horizontally (resp. vertically). You can not instantiate a Gtk_Button_Box directly, and have to use one the above two instead. A Gtk_Hbutton_Box is a specific Gtk_Button_Box that organizes its children horizontally. The beginning of the box (when you add children with Gtk.Box.Pack_Start) is on the left of the box. Its end (for Gtk.Box.Pack_End) is on the right. A Gtk_Vbutton_Box is a specific Gtk_Button_Box that organizes its children vertically. The beginning of the box (when you add children with Gtk.Box.Pack_Start) is on the top of the box. Its end (for Gtk.Box.Pack_End) is on the bottom. A Gtk_Entry is a single line text editing widget. The text is automatically scrolled if it is longer than can be displayed on the screen, so that the cursor position is visible at all times. See Gtk_Text_View for a multiple-line text editing widget. subtype Gtk_GEntry is Gtk_Entry; procedure Insert_Text (Editable : access Gtk_Entry_Record; New_Text : UTF8_String; Position : in out Gint); -- Convenience subprogram, identical to Insert_Text above without -- the requirement to supply the New_Text_Length argument. procedure Insert_Text (Editable : access Gtk_Entry_Record; New_Text : UTF8_String; Position : in out Gint) is begin Insert_Text (Editable, New_Text & ASCII.NUL, New_Text'Length, Position); end Insert_Text; See Gtkada.Dialogs for a higher level dialog interface. Create a new dialog with a specific title, and specific attributes. Parent is the transient parent for the dialog (ie the one that is used for reference for the flag Destroy_With_Parent, or to compute the initial position of the dialog). procedure Set_Alternative_Button_Order_From_Array (Dialog : access Gtk_Dialog_Record; New_Order : Response_Type_Array); -- Sets an alternative button order. If the gtk-alternative-button-order -- setting is set to %TRUE, the dialog buttons are reordered according to -- the order of the response ids passed to this function. -- -- By default, GTK+ dialogs use the button order advocated by the Gnome -- Human Interface Guidelines with the affirmative button at the far right, -- and the cancel button left of it. But the builtin GTK+ dialogs and -- message dialogs' do provide an alternative button order, which is more -- suitable on some platforms, e.g. Windows. -- -- Use this function after adding all the buttons to your dialog. function Gtk_Alternative_Dialog_Button_Order (Screen : Gdk.Screen.Gdk_Screen := null) return Boolean; -- Returns True if dialogs are expected to use an alternative button order -- on the given screen (or current screen if null) . See -- Set_Alternative_Button_Order_From_Array for more details about -- alternative button order. -- -- If you need to use this function, you should probably connect to the -- ::notify:gtk-alternative-button-order signal on the Gtk_Settings object -- associated to Screen, in order to be notified if the button order -- setting changes. -- -- Returns: Whether the alternative button order should be used function Use_Header_Bar_From_Settings (Widget : access Gtk.Widget.Gtk_Widget_Record'Class := null) return Gtk_Dialog_Flags; -- Check in the gtk settings whether dialogs should display their action -- buttons in the header bar rather than in the action area at the bottom. -- Widget is used to retrieve the settings. If unspecified, the default -- settings are used. -- The value of the setting can be set in the file -- $HOME/.config/gtk-3.0/settings.ini -- with the following line: -- gtk-dialogs-use-header=0 procedure G_New_Dialog (Self : not null access Gtk_Dialog_Record'Class; Flags : Gtk_Dialog_Flags; Typ : Glib.GType := Gtk.Dialog.Get_Type); -- Equivalent of Glib.Object.G_New for a dialog. This function should be -- used when you are subclassing the dialog class (for instance to add new -- signals). The Use_Header_Bar flag can only have an impact before the -- dialog is created, so this function will take that into account as -- appropriate. Other flags (Modal and Destroy_With_Parent) are ignored. procedure G_New_Dialog (Self : not null access Gtk_Dialog_Record'Class; Flags : Gtk_Dialog_Flags; Typ : Glib.GType := Gtk.Dialog.Get_Type) is function Internal (Typ : GType; Flags : Gtk_Dialog_Flags) return System.Address; pragma Import (C, Internal, "ada_g_dialog_new"); begin if not Self.Is_Created then Set_Object (Self, Internal (Typ, Flags)); end if; end G_New_Dialog; procedure Set_Alternative_Button_Order_From_Array (Dialog : access Gtk_Dialog_Record; New_Order : Response_Type_Array) is procedure Internal (Dialog : System.Address; N_Params : Gint; New_Order : System.Address); pragma Import (C, Internal, "gtk_dialog_set_alternative_button_order_from_array"); begin Internal (Get_Object (Dialog), New_Order'Length, New_Order (New_Order'First)'Address); end Set_Alternative_Button_Order_From_Array; function Gtk_Alternative_Dialog_Button_Order (Screen : Gdk.Screen.Gdk_Screen := null) return Boolean is function Internal (Screen : System.Address) return Gboolean; pragma Import (C, Internal, "gtk_alternative_dialog_button_order"); begin return Boolean'Val (Internal (Get_Object (Screen))); end Gtk_Alternative_Dialog_Button_Order; function Use_Header_Bar_From_Settings (Widget : access Gtk.Widget.Gtk_Widget_Record'Class := null) return Gtk_Dialog_Flags is S : Gtk_Settings; begin if Widget = null then S := Gtk.Settings.Get_Default; else S := Get_Settings (Widget); end if; if Get_Property (S, Gtk_Dialogs_Use_Header_Property) then return Use_Header_Bar; else return 0; end if; end Use_Header_Bar_From_Settings; type Gtk_Dialog_Flags is mod 8; for Gtk_Dialog_Flags'Size use Gint'Size; pragma Convention (C, Gtk_Dialog_Flags); Modal : constant Gtk_Dialog_Flags := 2 ** 0; Destroy_With_Parent : constant Gtk_Dialog_Flags := 2 ** 1; Use_Header_Bar : constant Gtk_Dialog_Flags := 2 ** 2; -- Various flags that can be set for the dialog, with the following -- implications: -- - Modal : the dialog is modal, see Gtk.Window.Set_Modal -- - Destroy_With_Parent: The dialog is destroyed if its parent is -- destroyed. See Gtk.Window.Set_Destroy_With_Parent -- - Use_Header_Bar: create dialogs with actions in the header bar -- instead of action area (since 3.12) type Gtk_Response_Type is new Gint; -- Type used for Response_Id's. -- Positive values are totally user-interpreted. -- GtkAda will sometimes return Gtk_Response_None if no Response_Id is -- available. -- -- Typical usage is: -- if Gtk.Dialog.Run (Dialog) = Gtk_Response_Accept then -- blah; -- end if; Gtk_Response_None : constant Gtk_Response_Type := -1; -- GtkAda returns this if a response widget has no Response_Id, -- or if the dialog gets programmatically hidden or destroyed. Gtk_Response_Reject : constant Gtk_Response_Type := -2; Gtk_Response_Accept : constant Gtk_Response_Type := -3; -- GtkAda won't return these unless you pass them in -- as the response for an action widget. They are -- for your convenience. Gtk_Response_Delete_Event : constant Gtk_Response_Type := -4; -- If the dialog is deleted through the button in the titlebar Gtk_Response_OK : constant Gtk_Response_Type := -5; Gtk_Response_Cancel : constant Gtk_Response_Type := -6; Gtk_Response_Close : constant Gtk_Response_Type := -7; Gtk_Response_Yes : constant Gtk_Response_Type := -8; Gtk_Response_No : constant Gtk_Response_Type := -9; Gtk_Response_Apply : constant Gtk_Response_Type := -10; Gtk_Response_Help : constant Gtk_Response_Type := -11; -- These are returned from dialogs, and you can also use them -- yourself if you like. type Response_Type_Array is array (Natural range <>) of Gtk_Response_Type; See also the Double_Buffer widget provided in the GtkAda examples for an advanced example that demonstrates how to use double buffering, to avoid flickering in your drawings. The meaning of the most important fields can be explained on the following figure (imagine this is a scrollbar): [-------|=================|-------------------] lower value value + page_size upper Create a new adjustment. Value is the initial value of the adjustment. It must be in the range (Lower .. Upper) and the adjustment's value will never be outside this range. Step_Increment is the value used to make minor adjustments, such as when the user clicks on the arrows of a scrollbar. Page_Increment is used to make major adjustments, such as when the user clicks in the through on a scrollbar. Page_Size is deprecated, use the default value. Update the Adjustment value to ensure that the range between Lower and Upper is in the current page (i.e. between value and value + page_size). If the range is larger than the page size, then only the start of it will be in the current page. A "value_changed" signal will be emitted if the value is changed. function Get (Image : access Gtk_Image_Record; Size : access Gtk.Enums.Gtk_Icon_Size) return String; -- Get the stock_id for the image displayed procedure Get_Icon_Name (Image : access Gtk_Image_Record; Name : out GNAT.Strings.String_Access; Size : out Gtk.Enums.Gtk_Icon_Size); procedure Get_Icon_Name (Image : access Gtk_Image_Record; Name : out GNAT.Strings.String_Access; Size : out Gtk_Icon_Size) is procedure Internal (Image : System.Address; Name : out Gtkada.Types.Chars_Ptr; Size : out Gtk_Icon_Size); pragma Import (C, Internal, "gtk_image_get_icon_name"); Str : chars_ptr; begin Internal (Get_Object (Image), Str, Size); Name := new String'(Value (Str)); end Get_Icon_Name; function Get (Image : access Gtk_Image_Record; Size : access Gtk.Enums.Gtk_Icon_Size) return String is procedure Internal (Image : System.Address; Stock_Id : out Gtkada.Types.Chars_Ptr; Size : out Gint); pragma Import (C, Internal, "gtk_image_get_stock"); Stock : Gtkada.Types.Chars_Ptr; Sze : Gint; begin Internal (Get_Object (Image), Stock, Sze); Size.all := Gtk.Enums.Gtk_Icon_Size'Val (Sze); return Gtkada.Types.Value (Stock); end Get; type Context_Id is new Guint; type Message_Id is new Guint; Create a new table. The width allocated to the table is divided into Columns columns, which all have the same width if Homogeneous is True. If Homogeneous is False, the width will be calculated with the children contained in the table. Same behavior for the rows. Insert a new widget in the table. All the attachments are relative to the separations between columns and rows (for instance, to insert a widget spanning the first two columns in the table, you should put Left_Attach=0 and Right_Attach=2). Same behavior for the rows. Xoptions and Yoptions indicate the behavior of the child when the table is resized (whether the child can shrink or expand). See the description in Gtk.Box for more information on the possible values. Xpadding and Ypadding are the amount of space left around the child. Insert a new widget in the table, with default values. No padding is put around the child, and the options are set to Expand and Fill. This call is similar to Attach with default values and is only provided for compatibility. Set the spacing in pixels between Column and the next one. Indicate the homogeneous status of the table. If Homogeneous is True, the rows and columns of the table will all be allocated the same width or height. Create a check button. if Label is null, then no widget is associated with the button, and any widget can be added to the button (with Gtk.Container.Add). You should consider using a Gtk_Check_Button instead, since it looks nicer and provides more visual clues that the button can be toggled. Initialize a button. If Label is "", then no label is created inside the button and you will have to provide your own child through a call to Gtk.Container.Add. This is the recommended way to put a pixmap inside a toggle button. Change the state of the button. When Is_Active is True, the button is drawn as a pressed button Creates a new Gtk.Accel_Group.Gtk_Accel_Group. Remember to call Gtk.Window.Add_Accel_Group to active the group. type Gtk_Accel_Group_Activate is access function (Accel_Group : access Gtk_Accel_Group_Record'Class; Acceleratable : Glib.Object.GObject; Keyval : Gdk.Types.Gdk_Key_Type; Modifier : Gdk.Types.Gdk_Modifier_Type) return Boolean; type C_Gtk_Accel_Group_Activate is access function (Accel_Group : System.Address; Acceleratable : System.Address; Keyval : Gdk.Types.Gdk_Key_Type; Modifier : Gdk.Types.Gdk_Modifier_Type) return Boolean; pragma Convention (C, C_Gtk_Accel_Group_Activate); -- Same as Gtk_Accel_Group_Activate, but passing directly the C values. -- You must use Get_User_Data to convert to the Ada types. Creates or initializes a new radio button, belonging to Group. If Label is left as the empty string, then the button will not have any child and you are free to put any thing you want in it, including a pixmap. To initialize the group (when creating the first button), leave Group to the Null_List. You can later get the new group that is created with a call to the Get_Group subprogram below. To initialize a new group (when creating the first button), you should pass it null or a button that has not been created with Gtk_New, as in the example below. A common way to set up a group of radio group is the following: __PRE__ Group : GSlist := null; Action : Gtk_Radio_Action; while ... loop Gtk_New (Action, ...); Set_Group (Action, Group); Group := Get_Group (Action); end loop; This widget is generally put on the sides of a drawing area to help the user measure distances. It indicates the current position of the mouse cursor within the drawing area, and can be graduated in multiple units. Set or get the units used for a Gtk_Ruler. See Set_Metric Add Widget to a Fixed container at the given position. X indicates the horizontal position to place the widget at. Y is the vertical position to place the widget at. Move a child of a GtkFixed container to the given position. X indicates the horizontal position to place the widget at. Y is the vertical position to place the widget at. This package provides an interface implemented by Gtk.File_Chooser_Widget and Gtk.File_Chooser_Button, and by your own file selection widgets if you wish to expose a standard interface. Gtk_File_Chooser allows for shortcuts to various places in the filesystem. In the default implementation these are displayed in the left pane. It may be a bit confusing at first that these shortcuts come from various sources and in various flavours, so lets explain the terminology here: __PRE__ - Bookmarks are created by the user, by dragging folders from the right pane to the left pane, or by using the "Add". Bookmarks can be renamed and deleted by the user. - Shortcuts can be provided by the application or by the underlying filesystem abstraction (e.g. both the gnome-vfs and the Windows filesystems provide "Desktop" shortcuts). Shortcuts cannot be modified by the user. - Volumes are provided by the underlying filesystem abstraction. They are the "roots" of the filesystem. File Names and Encodings When the user is finished selecting files in a Gtk_File_Chooser, your program can get the selected names either as filenames or as URIs. For URIs, the normal escaping rules are applied if the URI contains non-ASCII characters. However, filenames are always returned in the character set specified by the G_FILENAME_ENCODING environment variable. Please see the Glib documentation for more details about this variable. Important: This means that while you can pass the result of Get_Filename to low-level file system primitives , you will need to convert it to UTF-8 before using it in a Gtk_Label for instance. Conversion is done through Glib.Convert.Filename_To_UTF8. You can add a custom preview widget to a file chooser and then get notification about when the preview needs to be updated. To install a preview widget, use gtk_file_chooser_set_preview_widget(). Then, connect to the GtkFileChooser::update-preview signal to get notified when you need to update the contents of the preview. Preview widgets You can add a custom preview widget to a file chooser and then get notification about when the preview needs to be updated. To install a preview widget, use Set_Preview_Widget. Then, connect to the GtkFileChooser::update-preview signal to get notified when you need to update the contents of the preview. Your callback should use Get_Preview_Filename to see what needs previewing. Once you have generated the preview for the corresponding file, you must call Set_Preview_Widget_Active with a boolean flag that indicates whether your callback could successfully generate a preview. Adding Extra Widgets You can add extra widgets to a file chooser to provide options that are not present in the default design. For example, you can add a toggle button to give the user the option to open a file in read-only mode. You can use Set_Extra_Widget to insert additional widgets in a file chooser. If you want to set more than one extra widget in the file chooser, you can a container such as a GtkVBox or a GtkTable and include your widgets in it. Then, set the container as the whole extra widget. Key bindings The following default key bindings are provided, but you can use a gtkrc file to override them if you need (see gtk-rc.ads). __PRE__ Signal name | Key binding location-popup | Control-L (empty path) | / (path of "/") | ~ (home directory) up-folder | Alt-Up or backspace down-folder | Alt-Down home-folder | Alt-Home desktop-folder | Alt-D quick-bookmark | Alt-1 through Alt-0 procedure Insert_Text (Editable : Gtk_Editable; New_Text : UTF8_String; Position : in out Gint); -- Convenience subprogram, identical to Insert_Text above without -- the requirement to supply the New_Text_Length argument. procedure Insert_Text (Editable : Gtk_Editable; New_Text : UTF8_String; Position : in out Gint) is begin Insert_Text (Editable, New_Text & ASCII.NUL, New_Text'Length, Position); end Insert_Text; procedure Internal (Menu : System.Address; X : out Gint; Y : out Gint; Push_In : out Integer; Icon : System.Address); pragma Import (C, Internal, "gtk_status_icon_position_menu"); -- Custom body because we need to initialize to 0 here (on OSX). Tmp_Push_In : aliased Integer := 0; begin Internal (Get_Object (Menu), X, Y, Tmp_Push_In, Get_Object (Icon)); Push_In := Tmp_Push_In /= 0; procedure Gtk_New (Menu_Item : out Gtk_Menu_Item; Label : UTF8_String) renames Gtk_New_With_Label; procedure Initialize (Menu_Item : access Gtk_Menu_Item_Record'Class; Label : UTF8_String) renames Initialize_With_Label; -- For backwards compatibility. Creates a new #GtkFileChooserDialog. This function is analogous to gtk_dialog_new_with_buttons(). a new #GtkFileChooserDialog Title of the dialog, or %NULL Transient parent of the dialog, or %NULL Open or save mode for the dialog In case the default screen is being used, adding a new recently used file is as simple as: __PRE__ declare Manager : constant Gtk_Recent_Manager := Get_Default; begin Add_Item (Manager, File_URI); end; While looking up a recently used file is as simple as using: __PRE__ declare Manager : constant Gtk_Recent_Manager := Get_Default; Info : Gtk_Recent_Info; Error : Glib.Error.GError; begin Lookup_Item (Info, Manager, File_URI, Error); if Error /= null then -- Use the info object Unref (Info); else Put_Line ("Could not find the file: " & Glib.Error.Get_Message (Error)); Glib.Error.Error_Free (Error); end if; end; function Add_Full (Manager : access Gtk_Recent_Manager_Record; Uri : UTF8_String; Display_Name : UTF8_String := ""; Description : UTF8_String := ""; Mime_Type : UTF8_String; App_Name : UTF8_String; App_Exec : UTF8_String; Groups : GNAT.Strings.String_List; Is_Private : Boolean) return Boolean; -- Manager : the Gtk_Recent_Manager on which to operate -- Uri : pointer to resource -- Display_Name : a UTF-8 encoded string, containing the name of the -- recently used resource to be displayed, or "". -- Description : a UTF-8 encoded string, containing a short description -- of the resource, or "". -- Mime_Type : the MIME type of the resource. -- App_Name : the name of the application that is registering this -- recently used resource. -- App_Exec : command line used to launch this resource; may contain -- the "%f" and "%u" escape characters which will be -- expanded to the resource file path and URI, respectively, -- when the command line is retrieved. -- Groups : a vector of strings containing groups names. -- Is_Private : whether this resource should be displayed only by the -- applications that have registered it or not. -- -- Adds a new resource, pointed by Uri, into the recently used -- resources list, using the metadata specified. -- -- The passed URI will be used to identify this resource inside the -- list. -- -- In order to register the new recently used resource, metadata about -- the resource must be passed as well as the URI. This metadata must -- contain the MIME type of the resource pointed by the URI; the name of -- the application that is registering the item, and a command line to be -- used when launching the item. -- -- Optionally, it is possible to specify a UTF-8 string to be used when -- viewing the item instead of the last component of the URI; a short -- description of the item; whether the item should be considered private - -- that is, should be displayed only by the applications that have -- registered it. -- -- Returns True if the new item was successfully added to the recently -- used resources list, False otherwise. function Add_Full (Manager : access Gtk_Recent_Manager_Record; Uri : UTF8_String; Display_Name : UTF8_String := ""; Description : UTF8_String := ""; Mime_Type : UTF8_String; App_Name : UTF8_String; App_Exec : UTF8_String; Groups : GNAT.Strings.String_List; Is_Private : Boolean) return Boolean is function Internal (Manager : System.Address; Uri : String; Recent_Data : System.Address) return Gboolean; pragma Import (C, Internal, "gtk_recent_manager_add_full"); type Gtk_Recent_Data_Record is record display_name : chars_ptr; description : chars_ptr; mime_type : chars_ptr; app_name : chars_ptr; app_exec : chars_ptr; groups : System.Address; is_private : Gboolean; end record; pragma Convention (C, Gtk_Recent_Data_Record); -- Internal record that matches struct _GtkRecentData in -- gtkrecentmanager.h C_Groups : aliased chars_ptr_array := From_String_List (Groups); -- Temporary variable to aid translation GRD : aliased Gtk_Recent_Data_Record; -- Data to feed in to gtk_recent_manager_add_full() Result : Gboolean; begin -- Set up. GRD.display_name := String_Or_Null (Display_Name); GRD.description := String_Or_Null (Description); GRD.mime_type := New_String (Mime_Type); GRD.app_name := New_String (App_Name); GRD.app_exec := New_String (App_Exec); GRD.is_private := Boolean'Pos (Is_Private); if C_Groups'Length > 0 then GRD.groups := C_Groups (C_Groups'First)'Address; else GRD.groups := System.Null_Address; end if; -- Invoke function. Result := Internal (Get_Object (Manager), Uri & ASCII.NUL, GRD'Address); -- Clean up, making sure to avoid double-deallocations where such -- may be possible. if GRD.display_name /= Null_Ptr then g_free (GRD.display_name); end if; if GRD.description /= Null_Ptr then g_free (GRD.description); end if; Free (GRD.mime_type); Free (GRD.app_name); Free (GRD.app_exec); for I in C_Groups'Range loop if C_Groups (I) /= Null_Ptr then Free (C_Groups (I)); end if; end loop; -- Return result. return Boolean'Val (Result); end Add_Full; subtype time_t is Long_Integer; -- Type to interface with C's time_t type. To convert this to/from -- an Ada type, look at Ada.Calendar.Conversion_Operations and be -- sure to pay special attention to the ranges each type is capable -- of representing. Only states between State_Normal and State_Insensitive are valid. procedure Internal (Widget : System.Address); pragma Import (C, Internal, "gtk_widget_destroy"); procedure Unref_Internal (Widget : System.Address); pragma Import (C, Unref_Internal, "g_object_unref"); -- External binding: g_object_unref Ptr : constant System.Address := Get_Object (Widget); use type System.Address; begin -- Keep a reference on the object, so that the Ada structure is -- never automatically deleted when the C object is. -- We can't reset the content of Widget to System.Null_Address before -- calling the C function, because we want the user's destroy -- callbacks to be called with the appropriate object. Ref (Widget); Internal (Ptr); -- We then can make sure that the object won't be referenced any -- more, (The Ada structure won't be free before the ref count goes -- down to 0, and we don't want the user to use a deleted object...). Set_Object (Widget, System.Null_Address); -- Free the reference we had. In most cases, this results in the -- object being freed. We can't use directly Unref, since the Ptr -- field for Object is Null_Address. Unref_Internal (Ptr); subtype Gtk_Allocation is Gdk.Rectangle.Gdk_Rectangle; ------------------------------------ -- Override default size handling -- ------------------------------------ type Gtk_Requisition_Access is access all Gtk_Requisition; type Gtk_Allocation_Access is access all Gtk_Allocation; pragma Convention (C, Gtk_Requisition_Access); pragma Convention (C, Gtk_Allocation_Access); function Get_Requisition (Value : Glib.Values.GValue) return Gtk_Requisition_Access; function Get_Allocation (Value : Glib.Values.GValue) return Gtk_Allocation_Access; -- Convert values received as callback parameters type Size_Allocate_Handler is access procedure (Widget : System.Address; Allocation : Gtk_Allocation); pragma Convention (C, Size_Allocate_Handler); -- Widget is the gtk+ C widget, that needs to be converted to Ada through -- a call to: -- declare -- Stub : Gtk_Widget_Record; -- or the exact type you expect -- begin -- My_Widget := Gtk_Widget (Glib.Object.Get_User_Data (Widget, Stub); -- end; procedure Set_Default_Size_Allocate_Handler (Klass : Glib.Object.GObject_Class; Handler : Size_Allocate_Handler); pragma Import (C, Set_Default_Size_Allocate_Handler, "ada_WIDGET_CLASS_override_size_allocate"); -- Override the default size_allocate handler for this class. This handler -- is automatically called in several cases (when a widget is dynamically -- resized for instance), not through a signal. Thus, if you need to -- override the default behavior provided by one of the standard -- containers, you can not simply use Gtk.Handlers.Emit_Stop_By_Name, and -- you must override the default handler. Note also that this handler -- is automatically inherited by children of this class. -- -- This function is not needed unless you are writting your own -- widgets, and should be reserved for advanced customization of the -- standard widgets. type Preferred_Size_Handler is access procedure (Widget : System.Address; Minimum_Size : out Glib.Gint; Natural_Size : out Glib.Gint); pragma Convention (C, Preferred_Size_Handler); type Preferred_Size_For_Handler is access procedure (Widget : System.Address; Ref : Glib.Gint; -- known width or height Minimum_Size : out Glib.Gint; Natural_Size : out Glib.Gint); pragma Convention (C, Preferred_Size_For_Handler); procedure Set_Default_Get_Preferred_Width_Handler (Klass : Glib.Object.GObject_Class; Handler : Preferred_Size_Handler); procedure Set_Default_Get_Preferred_Height_Handler (Klass : Glib.Object.GObject_Class; Handler : Preferred_Size_Handler); procedure Set_Default_Get_Preferred_Height_For_Width_Handler (Klass : Glib.Object.GObject_Class; Handler : Preferred_Size_For_Handler); procedure Set_Default_Get_Preferred_Width_For_Height_Handler (Klass : Glib.Object.GObject_Class; Handler : Preferred_Size_For_Handler); pragma Import (C, Set_Default_Get_Preferred_Width_Handler, "ada_WIDGET_CLASS_override_get_preferred_width"); pragma Import (C, Set_Default_Get_Preferred_Height_Handler, "ada_WIDGET_CLASS_override_get_preferred_height"); pragma Import (C, Set_Default_Get_Preferred_Height_For_Width_Handler, "ada_WIDGET_CLASS_override_get_preferred_height_for_width"); pragma Import (C, Set_Default_Get_Preferred_Width_For_Height_Handler, "ada_WIDGET_CLASS_override_get_preferred_width_for_height"); -- Override the computation of a widget's preferred sizes. -- You will only need to override this computation if you are writting -- your own container widgets. procedure Inherited_Get_Preferred_Width (Klass : Glib.Object.Ada_GObject_Class; Widget : access Gtk_Widget_Record'Class; Minimum_Size, Natural_Size : out Glib.Gint); procedure Inherited_Get_Preferred_Width_For_Height (Klass : Glib.Object.Ada_GObject_Class; Widget : access Gtk_Widget_Record'Class; Height : Glib.Gint; Minimum_Size, Natural_Size : out Glib.Gint); procedure Inherited_Get_Preferred_Height (Klass : Glib.Object.Ada_GObject_Class; Widget : access Gtk_Widget_Record'Class; Minimum_Size, Natural_Size : out Glib.Gint); procedure Inherited_Get_Preferred_Height_For_Width (Klass : Glib.Object.Ada_GObject_Class; Widget : access Gtk_Widget_Record'Class; Width : Glib.Gint; Minimum_Size, Natural_Size : out Glib.Gint); -- Call the default implementation procedure Inherited_Size_Allocate (Klass : Glib.Object.Ada_GObject_Class; Widget : access Gtk_Widget_Record'Class; Allocation : Gtk_Allocation); -- Call the inherited size_allocate. This is useful if you have overloaded it in -- your own class, but still need to call the standard implementation. type Realize_Handler is access procedure (Widget : System.Address); pragma Convention (C, Realize_Handler); procedure Set_Default_Realize_Handler (Klass : Glib.Object.GObject_Class; Handler : Realize_Handler); pragma Import (C, Set_Default_Realize_Handler, "ada_WIDGET_CLASS_override_realize"); -- Override the handler for the "realize" signal. This handler should -- create the window for the widget procedure Inherited_Realize (Klass : Glib.Object.Ada_GObject_Class; Widget : access Gtk_Widget_Record'Class); -- Call the inherited realize. --------------------------- -- Override Draw handler -- --------------------------- generic with function Draw (W : access Gtk_Widget_Record'Class; Cr : Cairo.Cairo_Context) return Boolean; function Proxy_Draw (W : System.Address; Cr : Cairo.Cairo_Context) return Gboolean; pragma Convention (C, Proxy_Draw); type Draw_Handler is access function (W : System.Address; Cr : Cairo.Cairo_Context) return Gboolean; pragma Convention (C, Draw_Handler); -- A function responsible for drawing a widget. procedure Set_Default_Draw_Handler (Klass : Glib.Object.GObject_Class; Handler : Draw_Handler); -- Override the default drawing function. This in general gives more -- control than connection to Signal_Draw, however a widget is responsible -- for drawing its children. -- Use the generic Proxy_Draw to create a suitable callback. function Inherited_Draw (Klass : Glib.Object.Ada_GObject_Class; Widget : access Gtk_Widget_Record'Class; Cr : Cairo.Cairo_Context) return Boolean; -- Call the inherited draw. This is useful if you have overloaded draw in -- your own class, but still need to draw the child widgets that do not -- have their own window (the others will already get their own "draw" -- event. -- See http://developer.gnome.org/gtk3/3.0/chap-drawing-model.html -- for an explanation of the gtk+ drawing model. function Convert is new Ada.Unchecked_Conversion (Draw_Handler, System.Address); function Proxy_Draw (W : System.Address; Cr : Cairo.Cairo_Context) return Gboolean is Stub : Gtk_Widget_Record; W2 : constant Gtk_Widget := Gtk_Widget (Get_User_Data (W, Stub)); begin return Boolean'Pos (Draw (W2, Cr)); end Proxy_Draw; function Inherited_Draw (Klass : Glib.Object.Ada_GObject_Class; Widget : access Gtk_Widget_Record'Class; Cr : Cairo.Cairo_Context) return Boolean is function Internal (Klass : Ada_GObject_Class; Widget : System.Address; Cr : Cairo.Cairo_Context) return Gboolean; pragma Import (C, Internal, "ada_inherited_WIDGET_CLASS_draw"); begin return Internal (Klass, Widget.Get_Object, Cr) /= 0; end Inherited_Draw; procedure Inherited_Get_Preferred_Width (Klass : Glib.Object.Ada_GObject_Class; Widget : access Gtk_Widget_Record'Class; Minimum_Size, Natural_Size : out Glib.Gint) is procedure Internal (Klass : Ada_GObject_Class; Widget : System.Address; Min, Nat : out Glib.Gint); pragma Import (C, Internal, "ada_inherited_WIDGET_CLASS_get_preferred_width"); begin Internal (Klass, Widget.Get_Object, Minimum_Size, Natural_Size); end Inherited_Get_Preferred_Width; procedure Inherited_Get_Preferred_Width_For_Height (Klass : Glib.Object.Ada_GObject_Class; Widget : access Gtk_Widget_Record'Class; Height : Glib.Gint; Minimum_Size, Natural_Size : out Glib.Gint) is procedure Internal (Klass : Ada_GObject_Class; Widget : System.Address; Height : Glib.Gint; Min, Nat : out Glib.Gint); pragma Import (C, Internal, "ada_inherited_WIDGET_CLASS_get_preferred_width_for_height"); begin Internal (Klass, Widget.Get_Object, Height, Minimum_Size, Natural_Size); end Inherited_Get_Preferred_Width_For_Height; procedure Inherited_Get_Preferred_Height (Klass : Glib.Object.Ada_GObject_Class; Widget : access Gtk_Widget_Record'Class; Minimum_Size, Natural_Size : out Glib.Gint) is procedure Internal (Klass : Ada_GObject_Class; Widget : System.Address; Min, Nat : out Glib.Gint); pragma Import (C, Internal, "ada_inherited_WIDGET_CLASS_get_preferred_height"); begin Internal (Klass, Widget.Get_Object, Minimum_Size, Natural_Size); end Inherited_Get_Preferred_Height; procedure Inherited_Get_Preferred_Height_For_Width (Klass : Glib.Object.Ada_GObject_Class; Widget : access Gtk_Widget_Record'Class; Width : Glib.Gint; Minimum_Size, Natural_Size : out Glib.Gint) is procedure Internal (Klass : Ada_GObject_Class; Widget : System.Address; Width : Glib.Gint; Min, Nat : out Glib.Gint); pragma Import (C, Internal, "ada_inherited_WIDGET_CLASS_get_preferred_height_for_width"); begin Internal (Klass, Widget.Get_Object, Width, Minimum_Size, Natural_Size); end Inherited_Get_Preferred_Height_For_Width; procedure Inherited_Size_Allocate (Klass : Glib.Object.Ada_GObject_Class; Widget : access Gtk_Widget_Record'Class; Allocation : Gtk_Allocation) is procedure Internal (Klass : Ada_GObject_Class; Widget : System.Address; Allocation : Gtk_Allocation); pragma Import (C, Internal, "ada_inherited_WIDGET_CLASS_size_allocate"); begin Internal (Klass, Widget.Get_Object, Allocation); end Inherited_Size_Allocate; procedure Inherited_Realize (Klass : Glib.Object.Ada_GObject_Class; Widget : access Gtk_Widget_Record'Class) is procedure Internal (Klass : Ada_GObject_Class; Widget : System.Address); pragma Import (C, Internal, "ada_inherited_WIDGET_CLASS_realize"); begin Internal (Klass, Widget.Get_Object); end Inherited_Realize; procedure Set_Default_Draw_Handler (Klass : Glib.Object.GObject_Class; Handler : Draw_Handler) is procedure Internal (K : GObject_Class; H : System.Address); pragma Import (C, Internal, "ada_WIDGET_CLASS_override_draw"); begin Internal (Klass, Convert (Handler)); end Set_Default_Draw_Handler; function Get_Allocation (Value : Glib.Values.GValue) return Gtk_Allocation_Access is pragma Warnings (Off); -- This UC is safe aliasing-wise, so kill warning function To_Allocation is new Ada.Unchecked_Conversion (System.Address, Gtk_Allocation_Access); pragma Warnings (On); begin return To_Allocation (Glib.Values.Get_Address (Value)); end Get_Allocation; function Get_Requisition (Value : Glib.Values.GValue) return Gtk_Requisition_Access is pragma Warnings (Off); -- This UC is safe aliasing-wise, so kill warning function To_Requisition is new Ada.Unchecked_Conversion (System.Address, Gtk_Requisition_Access); pragma Warnings (On); begin return To_Requisition (Glib.Values.Get_Address (Value)); end Get_Requisition; Pango_Scale : constant := 1024; -- All internal units in Pango are expressed in terms of this unit. A -- typical pango size must be divided by Pango_Scale to get the equivalent -- in pixels. function To_Pixels (Pango_Units : Gint) return Gint; -- Convert a size in pango units to pixels. This is a rounding of -- Pango_Units divided by Pango_Scale -- Enum types are bound with the following algorithm: -- + the "Pango" prefix of the type name is stripped -- + Each word of the type name is separated by '_' -- + the full enum name is kept, but capitalized. -- All enums types should be sorted by alphabetical order... function To_Pixels (Pango_Units : Gint) return Gint is begin if Pango_Units > 0 then return (Pango_Units + Pango_Scale / 2) / Pango_Scale; else return (Pango_Units - Pango_Scale / 2) / Pango_Scale; end if; end To_Pixels; function Convert (S : String) return System.Address; function Convert (S : System.Address) return String; package String_List is new Glib.Glist.Generic_List (UTF8_String); package String_SList is new Glib.GSlist.Generic_SList (UTF8_String); -- Warning: when you create this list, new memory gets allocated for -- all the strings. You should use the function Free_String_List -- instead of Glib.Glist.Free to be sure to free this memory. procedure Free_String_List (List : in out String_List.Glist); procedure Free_String_List (List : in out String_SList.GSlist); -- Free the memory occupied by all the strings in the list, as well -- as the memory occupied by the list itself. function Convert (S : String) return System.Address is function Internal is new Ada.Unchecked_Conversion (Gtkada.Types.Chars_Ptr, System.Address); begin return Internal (Gtkada.Types.New_String (S)); end Convert; function Convert_Chars_Ptr is new Ada.Unchecked_Conversion (System.Address, Gtkada.Types.Chars_Ptr); function Convert (S : System.Address) return String is begin return Gtkada.Types.Value (Convert_Chars_Ptr (S)); end Convert; procedure Free_String_List (List : in out String_List.Glist) is use type String_List.Glist; Tmp : String_List.Glist := List; Chars : Gtkada.Types.Chars_Ptr; begin while Tmp /= String_List.Null_List loop Chars := Convert_Chars_Ptr (String_List.Get_Data_Address (Tmp)); Gtkada.Types.g_free (Chars); Tmp := String_List.Next (Tmp); end loop; String_List.Free (List); List := String_List.Null_List; end Free_String_List; procedure Free_String_List (List : in out String_SList.GSlist) is use type String_SList.GSlist; Tmp : String_SList.GSlist := List; Chars : Gtkada.Types.Chars_Ptr; begin while Tmp /= String_SList.Null_List loop Chars := Convert_Chars_Ptr (String_SList.Get_Data_Address (Tmp)); Gtkada.Types.g_free (Chars); Tmp := String_SList.Next (Tmp); end loop; String_SList.Free (List); List := String_SList.Null_List; end Free_String_List; type array_of_Gdk_RGBA is array (Natural range <>) of Gdk_RGBA; Null_RGBA : constant Gdk_RGBA := (0.0, 0.0, 0.0, 0.0); Black_RGBA : constant Gdk_RGBA := (0.0, 0.0, 0.0, 1.0); White_RGBA : constant Gdk_RGBA := (1.0, 1.0, 1.0, 1.0); type Property_RGBA is new Glib.Property; procedure Set_Property (Object : access Glib.Object.GObject_Record'Class; Name : Property_RGBA; Value : Gdk_RGBA); function Get_Property (Object : access Glib.Object.GObject_Record'Class; Name : Property_RGBA) return Gdk_RGBA; function Gdk_RGBA_Or_Null (Val : System.Address) return System.Address; -- Used for the GtkAda binding itself. -- Return either a Null_Address or a pointer to Val, depending on -- whether Val is the null value for the type. -- In all cases, Val is supposed to be an access to the type mentioned in -- the name of the subprogram. -- In Ada2012, these could be replaced with expression functions instead. procedure Set_Value (Value : in out Glib.Values.GValue; Val : Gdk_RGBA); function Get_Value (Value : Glib.Values.GValue) return Gdk_RGBA; -- Conversion functions for storing a Gdk_RGBA as a GValue. function To_Address (Val : Gdk_RGBA; Addr : System.Address) return System.Address; package RGBA_Properties is new Generic_Internal_Boxed_Property (Gdk_RGBA, Gdk.RGBA.Get_Type, To_Address); procedure Set_Property (Object : access Glib.Object.GObject_Record'Class; Name : Property_RGBA; Value : Gdk_RGBA) is begin RGBA_Properties.Set_Property (Object, RGBA_Properties.Property (Name), Value); end Set_Property; function Get_Property (Object : access Glib.Object.GObject_Record'Class; Name : Property_RGBA) return Gdk_RGBA is begin return RGBA_Properties.Get_Property (Object, RGBA_Properties.Property (Name)); end Get_Property; function Gdk_RGBA_Or_Null (Val : System.Address) return System.Address is function Internal is new Gtkada.Bindings.Generic_To_Address_Or_Null (Gdk_RGBA, Null_RGBA); begin return Internal (Val); end Gdk_RGBA_Or_Null; function Get_Value (Value : Glib.Values.GValue) return Gdk_RGBA renames RGBA_Properties.Get_Value; procedure Set_Value (Value : in out Glib.Values.GValue; Val : Gdk_RGBA) renames RGBA_Properties.Set_Value; function To_Address (Val : Gdk_RGBA; Addr : System.Address) return System.Address is begin if Val = Null_RGBA then return System.Null_Address; else return Addr; end if; end To_Address; -- Common names, from PWG 5101.1-2002 PWG: Standard for Media Standardized -- Names Gtk_Paper_Name_A3 : constant String := "iso_a3"; Gtk_Paper_Name_A4 : constant String := "iso_a4"; Gtk_Paper_Name_A5 : constant String := "iso_a5"; Gtk_Paper_Name_B5 : constant String := "iso_b5"; Gtk_Paper_Name_Letter : constant String := "na_letter"; Gtk_Paper_Name_Executive : constant String := "na_executive"; Gtk_Paper_Name_Legal : constant String := "na_legal"; subtype Priority is Glib.Guint; Priority_Fallback : constant Priority := 1; -- Used when no theme is defined Priority_Theme : constant Priority := 200; -- Used for style information provided by the theme Priority_Settings : constant Priority := 400; -- Used for information provided via Gtk_Settings Priority_Application : constant Priority := 600; -- For application-specific information Priority_User : constant Priority := 800; -- Used for the style information from ~/.gtk-3.0.css function Get_Style_Context (Widget : not null access Gtk_Widget_Record'Class) return Gtk_Style_Context; -- Returns the style context associated to Widget. -- must not be freed. function Get_Style_Context (Widget : not null access Gtk_Widget_Record'Class) return Gtk_Style_Context is function Internal (Widget : System.Address) return System.Address; pragma Import (C, Internal, "gtk_widget_get_style_context"); Stub_Gtk_Style_Context : Gtk_Style_Context_Record; begin return Gtk_Style_Context (Get_User_Data (Internal (Get_Object (Widget)), Stub_Gtk_Style_Context)); end Get_Style_Context; procedure Internal (Buffer : System.Address; Iter : out Gtk.Text_Iter.Gtk_Text_Iter; Line_Number : Gint; Char_Offset : Gint); pragma Import (C, Internal, "gtk_text_buffer_get_iter_at_line_offset"); Result : Boolean; begin -- Prevent critical crashes from gtk+ if Char_Offset is invalid Internal (Get_Object (Buffer), Iter, Line_Number, 0); if not Ends_Line (Iter) then Forward_To_Line_End (Iter, Result); if Char_Offset <= Get_Line_Offset (Iter) then Internal (Get_Object (Buffer), Iter, Line_Number, Char_Offset); end if; end if; procedure Insert (Buffer : access Gtk_Text_Buffer_Record; Iter : in out Gtk.Text_Iter.Gtk_Text_Iter; Text : Gtkada.Types.Chars_Ptr); -- More efficient version of Insert, which doesn't require a string copy. procedure Insert_At_Cursor (Buffer : access Gtk_Text_Buffer_Record; Text : Gtkada.Types.Chars_Ptr; Len : Gint := -1); -- Call Buffer_Insert, using the current cursor position -- as the insertion point. -- Text: UTF-8 format C string to insert. function Get_Text (Buffer : access Gtk_Text_Buffer_Record; Start : Gtk.Text_Iter.Gtk_Text_Iter; The_End : Gtk.Text_Iter.Gtk_Text_Iter; Include_Hidden_Chars : Boolean := False) return Gtkada.Types.Chars_Ptr; -- Same as Get_Text above, but return a pointer to a C string, for -- efficiency. -- The caller is responsible for freeing (using Gtkada.Types.g_free) the -- returned pointer. function Selection_Exists (Buffer : access Gtk_Text_Buffer_Record) return Boolean; -- Return True if some text in the buffer is currently selected. procedure Insert_With_Tags (Buffer : access Gtk_Text_Buffer_Record; Iter : in out Gtk.Text_Iter.Gtk_Text_Iter; Text : UTF8_String; Tag : Gtk_Text_Tag); procedure Insert_With_Tags (Buffer : access Gtk_Text_Buffer_Record; Iter : in out Gtk.Text_Iter.Gtk_Text_Iter; Text : Gtkada.Types.Chars_Ptr; Tag : Gtk.Text_Tag.Gtk_Text_Tag); -- Same as Insert, but specifies the tag to apply to the range. function Get_Buffer (Iter : Gtk_Text_Iter) return Gtk.Text_Buffer.Gtk_Text_Buffer; -- Returns the Gtk.Text_Buffer.Gtk_Text_Buffer this iterator is associated -- with. function Get_Buffer (Mark : Gtk_Text_Mark) return Gtk.Text_Buffer.Gtk_Text_Buffer; -- Gets the buffer this mark is located inside, or null if the mark is -- deleted. function Create_Tag (Buffer : access Gtk_Text_Buffer_Record; Tag_Name : String := "") return Gtk.Text_Tag.Gtk_Text_Tag; -- Creates a tag and adds it to the tag table for Buffer. Equivalent to -- calling gtk.text_tag.gtk_new and then adding the tag to the buffer's tag -- table. The returned tag is owned by the buffer's tag table, so the ref -- count will be equal to one. -- -- If Tag_Name is NULL, the tag is anonymous, otherwise a tag called -- Tag_Name must not already exist in the tag table for this buffer. ------------ -- Insert -- ------------ procedure Insert (Buffer : access Gtk_Text_Buffer_Record; Iter : in out Gtk.Text_Iter.Gtk_Text_Iter; Text : Gtkada.Types.Chars_Ptr) is procedure Internal (Buffer : System.Address; Iter : Gtk.Text_Iter.Gtk_Text_Iter; Text : Gtkada.Types.Chars_Ptr; Len : Gint := -1); pragma Import (C, Internal, "gtk_text_buffer_insert"); begin Internal (Get_Object (Buffer), Iter, Text); end Insert; procedure Insert_At_Cursor (Buffer : access Gtk_Text_Buffer_Record; Text : Gtkada.Types.Chars_Ptr; Len : Gint := -1) is procedure Internal (Buffer : System.Address; Text : Gtkada.Types.Chars_Ptr; Len : Gint); pragma Import (C, Internal, "gtk_text_buffer_insert_at_cursor"); begin Internal (Get_Object (Buffer), Text, Len); end Insert_At_Cursor; procedure Insert_With_Tags (Buffer : access Gtk_Text_Buffer_Record; Iter : in out Gtk.Text_Iter.Gtk_Text_Iter; Text : UTF8_String; Tag : Gtk_Text_Tag) is procedure Internal (Buffer : System.Address; Iter : in out Gtk.Text_Iter.Gtk_Text_Iter; Text : UTF8_String; Len : Gint; Tag : System.Address); pragma Import (C, Internal, "ada_gtk_text_buffer_insert_with_tags"); begin Internal (Get_Object (Buffer), Iter, Text, Text'Length, Get_Object (Tag)); end Insert_With_Tags; procedure Insert_With_Tags (Buffer : access Gtk_Text_Buffer_Record; Iter : in out Gtk.Text_Iter.Gtk_Text_Iter; Text : Gtkada.Types.Chars_Ptr; Tag : Gtk.Text_Tag.Gtk_Text_Tag) is procedure Internal (Buffer : System.Address; Iter : in out Gtk.Text_Iter.Gtk_Text_Iter; Text : Gtkada.Types.Chars_Ptr; Len : Gint := -1; Tag : System.Address); pragma Import (C, Internal, "ada_gtk_text_buffer_insert_with_tags"); begin Internal (Get_Object (Buffer), Iter, Text, Tag => Get_Object (Tag)); end Insert_With_Tags; -------------- -- Get_Text -- -------------- function Get_Text (Buffer : access Gtk_Text_Buffer_Record; Start : Gtk.Text_Iter.Gtk_Text_Iter; The_End : Gtk.Text_Iter.Gtk_Text_Iter; Include_Hidden_Chars : Boolean := False) return Gtkada.Types.Chars_Ptr is function Internal (Buffer : System.Address; Start : Gtk.Text_Iter.Gtk_Text_Iter; The_End : Gtk.Text_Iter.Gtk_Text_Iter; Include_Hidden_Chars : Gboolean) return Gtkada.Types.Chars_Ptr; pragma Import (C, Internal, "gtk_text_buffer_get_text"); begin return Internal (Get_Object (Buffer), Start, The_End, Boolean'Pos (Include_Hidden_Chars)); end Get_Text; function Selection_Exists (Buffer : access Gtk_Text_Buffer_Record) return Boolean is Ignored_A, Ignored_B : Gtk_Text_Iter; Has_Selection : Boolean; begin Get_Selection_Bounds (Buffer, Ignored_A, Ignored_B, Has_Selection); return Has_Selection; end Selection_Exists; ---------------- -- Get_Buffer -- ---------------- function Get_Buffer (Iter : Gtk_Text_Iter) return Gtk.Text_Buffer.Gtk_Text_Buffer is function Internal (Iter : Gtk_Text_Iter) return System.Address; pragma Import (C, Internal, "gtk_text_iter_get_buffer"); Stub_Gtk_Text_Buffer : Gtk.Text_Buffer.Gtk_Text_Buffer_Record; begin return Gtk.Text_Buffer.Gtk_Text_Buffer (Get_User_Data (Internal (Iter), Stub_Gtk_Text_Buffer)); end Get_Buffer; ---------------- -- Get_Buffer -- ---------------- function Get_Buffer (Mark : Gtk_Text_Mark) return Gtk.Text_Buffer.Gtk_Text_Buffer is function Internal (Mark : System.Address) return System.Address; pragma Import (C, Internal, "gtk_text_mark_get_buffer"); Stub_Gtk_Text_Buffer : Gtk.Text_Buffer.Gtk_Text_Buffer_Record; begin return Gtk.Text_Buffer.Gtk_Text_Buffer (Get_User_Data (Internal (Get_Object (Mark)), Stub_Gtk_Text_Buffer)); end Get_Buffer; ---------------- -- Create_Tag -- ---------------- function Create_Tag (Buffer : access Gtk_Text_Buffer_Record; Tag_Name : String := "") return Gtk_Text_Tag is function Internal (Buffer : System.Address; Tag_Name : Gtkada.Types.Chars_Ptr) return System.Address; pragma Import (C, Internal, "ada_gtk_text_buffer_create_tag"); Stub : Gtk_Text_Tag_Record; Str : Gtkada.Types.Chars_Ptr := String_Or_Null (Tag_Name); Tag : Gtk_Text_Tag; begin Tag := Gtk_Text_Tag (Get_User_Data (Internal (Get_Object (Buffer), Str), Stub)); Free (Str); return Tag; end Create_Tag; ------------------------------- -- Converting to/from GValue -- ------------------------------- procedure Set_Text_Mark (Val : in out Glib.Values.GValue; Mark : access Gtk_Text_Mark_Record); function Get_Text_Mark (Val : Glib.Values.GValue) return Gtk_Text_Mark; -- Set the value of the given GValue to Mark. ------------------- -- Set_Text_Mark -- ------------------- procedure Set_Text_Mark (Val : in out Glib.Values.GValue; Mark : access Gtk_Text_Mark_Record) is begin Glib.Values.Set_Address (Val, Get_Object (Mark)); end Set_Text_Mark; ------------------- -- Get_Text_Mark -- ------------------- function Get_Text_Mark (Val : Glib.Values.GValue) return Gtk_Text_Mark is Stub : Gtk_Text_Mark_Record; begin return Gtk_Text_Mark (Get_User_Data_Fast (Glib.Values.Get_Address (Val), Stub)); end Get_Text_Mark; Newly created tags must be added to the tags table for the buffer you intend to use them in, as in: "Gtk.Text_Tag_Table.Add (Get_Tag_Table (Buffer), Tag)". See also Gtk.Text_Buffer.Create_Tag which is a more convenient way of creating a tag. x procedure Init; -- Initialize GtkAda's internal structures. -- This subprogram should be called before any other one in GtkAda. -- If GtkAda could not be initialized (no access to the display, etc.), the -- application exits with an error function Init_Check return Boolean; -- Initialize GtkAda's internal structures. -- Return False if there was an error (no access to the display, etc.) gnat_argc : Interfaces.C.int; pragma Import (C, gnat_argc); gnat_argv : System.Address; pragma Import (C, gnat_argv); procedure Init is procedure Internal (argc : System.Address; argv : System.Address); pragma Import (C, Internal, "gtk_init"); begin Internal (gnat_argc'Address, gnat_argv'Address); end Init; function Init_Check return Boolean is function Internal (argc : System.Address; argv : System.Address) return Gboolean; pragma Import (C, Internal, "gtk_init_check"); begin return Boolean'Val (Internal (gnat_argc'Address, gnat_argv'Address)); end Init_Check; procedure Ref (Self : Gdk.Gdk_Cursor); pragma Import (C, Ref, "g_object_ref"); procedure Unref (Self : Gdk.Gdk_Cursor); pragma Import (C, Unref, "g_object_unref"); The draw_layer virtual function is called before and after the text view is drawing its own text. Applications can override this vfunc in a subclass to draw customized content underneath or above the text. Since: 3.14 function Get_User_Data (Window : Gdk_Window) return Glib.Object.GObject; -- Return the widget to which events are reported when they happen on -- Window. This is the widget that was set through the call to -- Set_User_data. procedure Set_User_Data (Window : Gdk_Window; Widget : access Glib.Object.GObject_Record'Class); -- Sets a special field in the window. -- All the events reported by the Xserver (or the Windows server) for -- Window will be redirected to Widget through the standard signals -- "expose_event", "button_press_event", ... -- You almost always need to call this function after creating a new -- Gdk_Window yourself, or you won't be able to handle the events. procedure Ref (Window : Gdk_Window); procedure Unref (Window : Gdk_Window); pragma Import (C, Ref, "g_object_ref"); pragma Import (C, Unref, "g_object_unref"); function Get_User_Data (Window : Gdk_Window) return Glib.Object.GObject is procedure Internal (Window : Gdk_Window; Widget : System.Address); pragma Import (C, Internal, "gdk_window_get_user_data"); Data : aliased System.Address; Stub : GObject_Record; begin Internal (Window, Data'Address); return Get_User_Data (Data, Stub); end Get_User_Data; procedure Set_User_Data (Window : Gdk_Window; Widget : access Glib.Object.GObject_Record'Class) is procedure Internal (Window : Gdk_Window; Widget : System.Address); pragma Import (C, Internal, "gdk_window_set_user_data"); begin Internal (Window, Get_Object (Widget)); end Set_User_Data; procedure Enable_Model_Drag_Dest (Icon_View : access Gtk_Icon_View_Record; Targets : Gtk.Target_List.Target_Entry_Array; Actions : Gdk.Dnd.Drag_Action); -- Turns Icon_view into a drop destination for automatic DND. -- Targets is the list of targets that the drag will support. procedure Enable_Model_Drag_Source (Icon_View : access Gtk_Icon_View_Record; Start_Button_Mask : Gdk.Types.Gdk_Modifier_Type; Targets : Gtk.Target_List.Target_Entry_Array; Actions : Gdk.Dnd.Drag_Action); -- Turns Icon_view into a drag source for automatic DND. -- Start_Button_Mask is the allowed buttons to start drag. procedure Enable_Model_Drag_Dest (Icon_View : access Gtk_Icon_View_Record; Targets : Target_Entry_Array; Actions : Drag_Action) is procedure Internal (Icon_View : System.Address; Targets : System.Address; N_Targets : Gint; Actions : Drag_Action); pragma Import (C, Internal, "gtk_icon_view_enable_model_drag_dest"); begin Internal (Get_Object (Icon_View), Targets (Targets'First)'Address, Targets'Length, Actions); end Enable_Model_Drag_Dest; procedure Enable_Model_Drag_Source (Icon_View : access Gtk_Icon_View_Record; Start_Button_Mask : Gdk_Modifier_Type; Targets : Target_Entry_Array; Actions : Drag_Action) is procedure Internal (Icon_View : System.Address; Start_Button_Mask : Gdk_Modifier_Type; Targets : System.Address; N_Targets : Gint; Actions : Drag_Action); pragma Import (C, Internal, "gtk_icon_view_enable_model_drag_source"); begin Internal (Get_Object (Icon_View), Start_Button_Mask, Targets (Targets'First)'Address, Targets'Length, Actions); end Enable_Model_Drag_Source; Extract the button number from an event State of the mouse buttons and keyboard keys just prior to the event Code of the key that was pressed (and that generated the event) Hardware key code of the key that was pressed type Gdk_Event is access all Gdk_Event_Record; pragma No_Strict_Aliasing (Gdk_Event); Double_Button_Press : constant Gdk_Event_Type := Gdk_2button_Press; Triple_Button_Press : constant Gdk_Event_Type := Gdk_3button_Press; Button_Primary : constant Gint := 1; Button_Secondary : constant Gint := 3; Button_Middle : constant Gint := 2; -- The primary button is typically the left mouse button, or the -- right button in a left-handed setup. The secondary button is the -- other one. function From_Address (C : System.Address) return Gdk_Event; -- Convert a C handler to the matching Event structure. function To_Address (C : Gdk_Event) return System.Address; -- Convert an event to the underlying C handler. function Get_Event (Value : Glib.Values.GValue) return Gdk_Event; -- Convert a value into a Gdk_Event. function To_Event (Event : access Gdk_Event_Button) return Gdk_Event; function To_Event (Event : access Gdk_Event_Key) return Gdk_Event; -- Cast Event into a Gdk_Event, which can be used to call some of -- subprograms in the API. The return value is a pointer to Event, -- which should therefore remain valid as long as the pointer is in -- use. ------------------------------- -- Some constants used below -- ------------------------------- -- This constants have the '-1' since in some cases gtk itself uses -- the extrema to return some meaningful value (for instance, the result -- of Get_Area can have the values Guint16'Last to mean the whole area). Invalid_Gdouble_Value : constant Gdouble := Gdouble'Last - 1.0; Invalid_Gint_Value : constant Gint := Gint'Last - 1; Invalid_Guint_Value : constant Guint := Guint'Last - 1; Invalid_Guint32_Value : constant Guint32 := Guint32'Last - 1; Invalid_Gulong_Value : constant Gulong := Gulong'Last - 1; pragma Export (C, Invalid_Gdouble_Value, "ada_gdk_invalid_gdouble_value"); pragma Export (C, Invalid_Gint_Value, "ada_gdk_invalid_gint_value"); pragma Export (C, Invalid_Guint_Value, "ada_gdk_invalid_guint_value"); pragma Export (C, Invalid_Guint32_Value, "ada_gdk_invalid_guint32_value"); pragma Export (C, Invalid_Gulong_Value, "ada_gdk_invalid_gulong_value"); function From_Address (C : System.Address) return Gdk_Event is function Convert is new Ada.Unchecked_Conversion (Glib.C_Proxy, Gdk_Event); begin return Convert (Glib.C_Proxy'(Glib.To_Proxy (C))); end From_Address; function To_Address (C : Gdk_Event) return System.Address is function Convert is new Ada.Unchecked_Conversion (Gdk_Event, Glib.C_Proxy); begin return Glib.To_Address (Convert (C)); end To_Address; function Get_Event (Value : Glib.Values.GValue) return Gdk_Event is function Convert is new Ada.Unchecked_Conversion (Glib.C_Proxy, Gdk_Event); begin return Convert (Glib.Values.Get_Proxy (Value)); end Get_Event; function To_Event (Event : access Gdk_Event_Button) return Gdk_Event is type Gdk_Event_Button_Access is access all Gdk_Event_Button; function Convert is new Ada.Unchecked_Conversion (Gdk_Event_Button_Access, Gdk_Event); begin return Convert (Gdk_Event_Button_Access (Event)); end To_Event; function To_Event (Event : access Gdk_Event_Key) return Gdk_Event is type Gdk_Event_Key_Access is access all Gdk_Event_Key; function Convert is new Ada.Unchecked_Conversion (Gdk_Event_Key_Access, Gdk_Event); begin return Convert (Gdk_Event_Key_Access (Event)); end To_Event; --------------- -- Selection -- --------------- function Make_Atom (Num : Gulong) return Gdk.Types.Gdk_Atom; pragma Import (C, Make_Atom, "ada_make_atom"); -- Auxiliary subprogram subtype Gdk_Selection is Gdk.Types.Gdk_Atom; -- These are predefined atom values for several common selections. -- You are of course free to create new ones, but most of the time you -- should simply use Selection_Primary unless you foresee the need for -- multiple simultaneous selections. -- To access the clipboard on windows machines, you might need to create -- a new selection with Gdk.Property.Atom_Intern ("CLIPBOARD"); Selection_Primary : constant Gdk_Selection := Make_Atom (1); Selection_Secondary : constant Gdk_Selection := Make_Atom (2); procedure Selection_Data_Set (Selection : Gtk_Selection_Data; The_Type : Gdk.Types.Gdk_Atom; Format : Gint; Data : System.Address; Length : Gint); -- General form of Selection_Data_Set. -- Any data can be transmitted. Length is the number of bytes in Data. procedure Selection_Data_Set (Selection : Gtk_Selection_Data; The_Type : Gdk.Types.Gdk_Atom; Format : Gint; Data : String); -- Set the data for a selection (special case for strings) -- This function is generally called when a drag-and-drop operation -- ask the source widget for the data to be transmitted. In that case, -- a Selection_Data was already transmitted and is given as a handler -- parameter for the signal "drag_data_get". The_Type can simply be -- extracted from the Selection_Data. function Get_Targets (Selection : Gtk_Selection_Data) return Gdk.Types.Gdk_Atom_Array; -- Gets the contents of Selection_Data as an array of targets. -- This can be used to interpret the results of getting -- the standard TARGETS target that is always supplied for -- any selection. -- This is different from Get_Target, which indicate the current format -- that the selection contains. Get_Targets only applies when Get_Target -- is "TARGETS". function Get_Data_As_String (Selection : Gtk_Selection_Data) return String; -- Return the data as a string. -- This is only a convenience function, since it simply creates a string -- from the return of Get_Data. package Atom_Arrays is new Gtkada.C.Unbounded_Arrays (Gdk.Types.Gdk_Atom, Gdk.Types.Gdk_None, Natural, Gdk.Types.Gdk_Atom_Array); ------------------------ -- Selection_Data_Set -- ------------------------ procedure Selection_Data_Set (Selection : Gtk_Selection_Data; The_Type : Gdk.Types.Gdk_Atom; Format : Gint; Data : System.Address; Length : Gint) is procedure Internal (Selection : System.Address; The_Type : Gdk.Types.Gdk_Atom; Format : Gint; Data : System.Address; Length : Gint); pragma Import (C, Internal, "gtk_selection_data_set"); begin Internal (Get_Object (Selection), The_Type, Format, Data, Length); end Selection_Data_Set; procedure Selection_Data_Set (Selection : Gtk_Selection_Data; The_Type : Gdk.Types.Gdk_Atom; Format : Gint; Data : String) is begin Selection_Data_Set (Selection, The_Type, Format, Data'Address, Data'Length); end Selection_Data_Set; ----------------- -- Get_Targets -- ----------------- function Get_Targets (Selection : Gtk_Selection_Data) return Gdk.Types.Gdk_Atom_Array is use Atom_Arrays; function Internal (Selection : System.Address; Targets : access Unbounded_Array_Access; N_Atoms : access Gint) return Gboolean; pragma Import (C, Internal, "gtk_selection_data_get_targets"); Output : aliased Unbounded_Array_Access; N : aliased Gint; begin if Internal (Get_Object (Selection), Output'Unchecked_Access, N'Unchecked_Access) = 0 then Output := null; end if; declare Result : constant Gdk_Atom_Array := To_Array (Output, Integer (N)); begin G_Free (Output); return Result; end; end Get_Targets; ------------------------ -- Get_Data_As_String -- ------------------------ function Get_Data_As_String (Selection : Gtk_Selection_Data) return String is function Internal (Selection : System.Address) return Gtkada.Types.Chars_Ptr; pragma Import (C, Internal, "gtk_selection_data_get_data"); begin return Gtkada.Types.Value (Internal (Get_Object (Selection))); end Get_Data_As_String; type Target_Entry_Array is array (Natural range <>) of Gtk_Target_Entry; No_Target_Entry : Target_Entry_Array (1 .. 0); -- To be used for drop sites that accept no data. -- You will in general need to call Gtk.Dnd.Add_Text_Targets or some such Any_Target_Entry : constant Target_Entry_Array := No_Target_Entry; pragma Obsolescent (Any_Target_Entry); -- Old name for this constant, which leads to confusion. You should use -- No_Target_Entry instead. procedure Gtk_New (List : out Gtk_Target_List; Targets : Target_Entry_Array); -- Creates a new Gtk.Target_List.Gtk_Target_List from an array of -- Gtk.Target_Entry.Gtk_Target_Entry. procedure Add_Table (List : Gtk_Target_List; Targets : Target_Entry_Array); -- Prepends a table of Gtk.Target_Entry.Gtk_Target_Entry to a target list. ------------- -- Gtk_New -- ------------- procedure Gtk_New (List : out Gtk_Target_List; Targets : Target_Entry_Array) is function Internal (Targets : System.Address; Ntargets : Guint) return System.Address; pragma Import (C, Internal, "gtk_target_list_new"); begin List.Set_Object (Internal (Targets'Address, Targets'Length)); end Gtk_New; --------------- -- Add_Table -- --------------- procedure Add_Table (List : Gtk_Target_List; Targets : Target_Entry_Array) is procedure Internal (List : System.Address; Targets : System.Address; Ntargets : Guint); pragma Import (C, Internal, "gtk_target_list_add_table"); begin Internal (Get_Object (List), Targets'Address, Targets'Length); end Add_Table; function Selected_Button (In_Group : Widget_SList.GSlist) return Natural; -- Return the button number of the selected button in the group. -- Note: This function is not part of Gtk+ itself, but is provided as a -- convenient function function Selected_Button (In_Group : Widget_SList.GSlist) return Natural is use Widget_SList; J : Natural := 0; Tmp : Widget_SList.GSlist := In_Group; begin while Tmp /= Widget_SList.Null_List loop exit when Get_Active (Gtk_Radio_Menu_Item (Get_Data (Tmp))); Tmp := Next (Tmp); J := J + 1; end loop; return J; end Selected_Button; an object containing a set of pango.Font objects type Pango_Script_Array is array (Natural range <>) of Pango_Script; type script_array_bounded is array (Natural) of Pango_Script; type script_array_access is access script_array_bounded; function Internal (Self : System.Address; Size : access Gint) return script_array_access; pragma Import (C, Internal, "pango_language_get_scripts"); Scripts : script_array_access; Size : aliased Gint; begin Scripts := Internal (Self.Get_Object, Size'Access); declare Result : Pango_Script_Array (1 .. Integer (Size)); begin for R in 0 .. Integer (Size) - 1 loop Result (R + 1) := Scripts (R); end loop; return Result; end; An object that represents the set of fonts available for a particular rendering system type font_family_array_bounded is array (Natural) of System.Address; procedure Internal (Self : System.Address; Families : System.Address; Size : access Gint); pragma Import (C, Internal, "pango_font_map_list_families"); procedure g_free (s : access font_family_array_bounded); pragma Import (C, g_free, "g_free"); Families : aliased access font_family_array_bounded; Size : aliased Gint; Tmplt : Pango_Font_Family_Record; begin Internal (Self.Get_Object, Families'Address, Size'Access); declare Result : Pango_Font_Family_Array (1 .. Integer (Size)); begin for R in 0 .. Integer (Size) - 1 loop Result (R + 1) := Pango_Font_Family (Get_User_Data (Families (R), Tmplt)); end loop; g_free (Families); return Result; end; type Pango_Font_Family_Array is array (Natural range <>) of Pango_Font_Family; type font_face_array_bounded is array (Natural) of System.Address; procedure Internal (Self : System.Address; Faces : System.Address; Acc_N_Faces : access Gint); pragma Import (C, Internal, "pango_font_family_list_faces"); procedure g_free (s : access font_face_array_bounded); pragma Import (C, g_free, "g_free"); Faces : aliased access font_face_array_bounded; Size : aliased Gint; Tmplt : Pango_Font_Face_Record; begin Internal (Self.Get_Object, Faces'Address, Size'Access); declare Result : Pango_Font_Face_Array (1 .. Integer (Size)); begin for R in 0 .. Integer (Size) - 1 loop Result (R + 1) := Pango_Font_Face (Get_User_Data (Faces (R), Tmplt)); end loop; g_free (Faces); return Result; end; type Pango_Font_Face_Array is array (Natural range <>) of Pango_Font_Face; type gint_array_bounded is array (Natural) of Gint; procedure Internal (Self : System.Address; Sizes : System.Address; Acc_N_Sizes : access Gint); pragma Import (C, Internal, "pango_font_face_list_sizes"); procedure g_free (s : access gint_array_bounded); pragma Import (C, g_free, "g_free"); Sizes : aliased access gint_array_bounded; Size : aliased Gint; begin Internal (Self.Get_Object, Sizes'Address, Size'Access); declare Result : Gint_Array (1 .. Integer (Size)); begin for R in 0 .. Integer (Size) - 1 loop Result (R + 1) := Sizes (R); end loop; g_free (Sizes); return Result; end; function Get_Text (Layout : access Pango_Layout_Record) return Gtkada.Types.Chars_Ptr; -- Same a Get_Text, but return directly the C string, which is more -- efficient. The returned value should not be freed or modified. function Get_Text (Layout : access Pango_Layout_Record) return Gtkada.Types.Chars_Ptr is function Internal (Layout : System.Address) return Gtkada.Types.Chars_Ptr; pragma Import (C, Internal, "pango_layout_get_text"); begin return Internal (Get_Object (Layout)); end Get_Text; type Action_Callback is access procedure (Action : System.Address; User_Data : System.Address); pragma Convention (C, Action_Callback); -- Profile of callbacks when an action is activated. You must convert -- Action to a Gtk_Action through: -- Act : constant Gtk_Action := Convert (Action); type Action_Entry is record Name : Gtkada.Types.Chars_Ptr; Stock_Id : Gtkada.Types.Chars_Ptr; Label : Gtkada.Types.Chars_Ptr; Accelerator : Gtkada.Types.Chars_Ptr; Tooltip : Gtkada.Types.Chars_Ptr; Callback : Action_Callback; end record; pragma Convention (C, Action_Entry); type Radio_Action_Entry is record Name : Gtkada.Types.Chars_Ptr; Stock_Id : Gtkada.Types.Chars_Ptr; Label : Gtkada.Types.Chars_Ptr; Accelerator : Gtkada.Types.Chars_Ptr; Tooltip : Gtkada.Types.Chars_Ptr; Value : Glib.Gint; end record; pragma Convention (C, Radio_Action_Entry); type Toggle_Action_Entry is record Name : Gtkada.Types.Chars_Ptr; Stock_Id : Gtkada.Types.Chars_Ptr; Label : Gtkada.Types.Chars_Ptr; Accelerator : Gtkada.Types.Chars_Ptr; Tooltip : Gtkada.Types.Chars_Ptr; Callback : Action_Callback; Is_Active : Glib.Gboolean; end record; pragma Convention (C, Toggle_Action_Entry); -- An opaque structure describing an action entry type Action_Entry_Array is array (Natural range <>) of Action_Entry; type Radio_Action_Entry_Array is array (Natural range <>) of Radio_Action_Entry; type Toggle_Action_Entry_Array is array (Natural range <>) of Toggle_Action_Entry; type Radio_Action_Callback is access procedure (Group : access Gtk.Action.Gtk_Action_Record'Class; Current : access Gtk.Action.Gtk_Action_Record'Class; User_Data : System.Address); -- Called when an element of the Gtk_Radio_Action group is selected function Create (Name : String; Label : String := ""; Stock_Id : String := ""; Accelerator : String := ""; Tooltip : String := ""; Callback : Action_Callback := null) return Action_Entry; -- Create a new Action_Entry. The returned value must be freed by the -- caller. function Create (Name : String; Label : String := ""; Stock_Id : String := ""; Accelerator : String := ""; Tooltip : String := ""; Callback : Action_Callback := null; Is_Active : Boolean := True) return Toggle_Action_Entry; -- Create a new Action_Entry. The returned value must be freed by the -- caller. Is_Active is the initial state of the button. function Create (Name : String; Label : String; Stock_Id : String := ""; Accelerator : String := ""; Tooltip : String := ""; Value : Glib.Gint) return Radio_Action_Entry; -- Create a new Radio_Action_Entry. Value is the value set on the radio -- action (see Gtk.Radio_Action.Get_Current_Value) procedure Free (Action : in out Action_Entry); procedure Free (Actions : in out Action_Entry_Array); procedure Free (Action : in out Radio_Action_Entry); procedure Free (Actions : in out Radio_Action_Entry_Array); procedure Free (Action : in out Toggle_Action_Entry); procedure Free (Actions : in out Toggle_Action_Entry_Array); -- Free Action and Actions procedure Add_Actions (Action_Group : access Gtk_Action_Group_Record; Entries : Action_Entry_Array; User_Data : System.Address := System.Null_Address; Destroy : Glib.G_Destroy_Notify_Address := null); -- This is a convenience function to create a number of actions and add -- them to the action group. -- Destroy is called when User_Data is no longer needed. -- -- The "activate" signals of the actions are connected to the callbacks in -- Entries, and their accel paths are set to -- <Actions>/group-name/action-name. procedure Add_Radio_Actions (Action_Group : access Gtk_Action_Group_Record; Entries : Radio_Action_Entry_Array; Value : Glib.Gint; On_Change : Radio_Action_Callback; User_Data : System.Address := System.Null_Address; Destroy : Glib.G_Destroy_Notify_Address := null); -- This is a convenience routine to create a group of radio actions and -- add them to the action group. -- -- The "changed" signal of the first radio action is connected to the -- On_Change callback and the accel paths of the actions are set to -- <Actions>/group-name/action-name -- -- Value is the value of the action to activate initially, or -1 if no -- action should be activated. -- Destroy is called when User_Data is no longer necessary. procedure Add_Toggle_Actions (Action_Group : access Gtk_Action_Group_Record; Entries : Toggle_Action_Entry_Array; User_Data : System.Address := System.Null_Address; Destroy : Glib.G_Destroy_Notify_Address := null); -- This is a convenience function to create a number of toggle actions and -- add them to the action group. -- The "activate" signals of the actions are connected to the callbacks and -- their accel paths are set to <Actions>/group-name/action-name. -- Destroy is called when User_Data is no longer necessary. procedure Local_Radio_Action_Callback (Group, Current, User_Data : System.Address); pragma Convention (C, Local_Radio_Action_Callback); -- Local proxy for Radio_Action_Callback procedure Local_Radio_Action_Destroy (Data : in out System.Address); pragma Convention (C, Local_Radio_Action_Destroy); -- Local proxy for the Destroy notify for Radio_Action type Local_Radio_Action_User_Data is record Callback : Radio_Action_Callback; User_Data : System.Address; Destroy : G_Destroy_Notify_Address; end record; type Local_Radio_Action_User_Data_Access is access Local_Radio_Action_User_Data; function Convert is new Ada.Unchecked_Conversion (System.Address, Local_Radio_Action_User_Data_Access); function Convert is new Ada.Unchecked_Conversion (Local_Radio_Action_User_Data_Access, System.Address); procedure Unchecked_Free is new Ada.Unchecked_Deallocation (Local_Radio_Action_User_Data, Local_Radio_Action_User_Data_Access); procedure Local_Radio_Action_Callback (Group, Current, User_Data : System.Address) is Data : constant Local_Radio_Action_User_Data_Access := Convert (User_Data); Stub : Gtk_Action_Record; G : constant Gtk_Action := Gtk_Action (Get_User_Data (Group, Stub)); C : constant Gtk_Action := Gtk_Action (Get_User_Data (Current, Stub)); begin Data.Callback (G, C, Data.User_Data); end Local_Radio_Action_Callback; procedure Local_Radio_Action_Destroy (Data : in out System.Address) is D : Local_Radio_Action_User_Data_Access := Convert (Data); begin D.Destroy (D.User_Data); Unchecked_Free (D); end Local_Radio_Action_Destroy; function Create (Name : String; Label : String := ""; Stock_Id : String := ""; Accelerator : String := ""; Tooltip : String := ""; Callback : Action_Callback := null) return Action_Entry is begin return (Name => String_Or_Null (Name), Label => String_Or_Null (Label), Stock_Id => String_Or_Null (Stock_Id), Accelerator => String_Or_Null (Accelerator), Tooltip => String_Or_Null (Tooltip), Callback => Callback); end Create; function Create (Name : String; Label : String := ""; Stock_Id : String := ""; Accelerator : String := ""; Tooltip : String := ""; Callback : Action_Callback := null; Is_Active : Boolean := True) return Toggle_Action_Entry is begin return (Name => String_Or_Null (Name), Label => String_Or_Null (Label), Stock_Id => String_Or_Null (Stock_Id), Accelerator => String_Or_Null (Accelerator), Tooltip => String_Or_Null (Tooltip), Callback => Callback, Is_Active => Boolean'Pos (Is_Active)); end Create; function Create (Name : String; Label : String; Stock_Id : String := ""; Accelerator : String := ""; Tooltip : String := ""; Value : Glib.Gint) return Radio_Action_Entry is begin return (Name => String_Or_Null (Name), Label => String_Or_Null (Label), Stock_Id => String_Or_Null (Stock_Id), Accelerator => String_Or_Null (Accelerator), Tooltip => String_Or_Null (Tooltip), Value => Value); end Create; procedure Free (Action : in out Action_Entry) is begin g_free (Action.Name); g_free (Action.Label); g_free (Action.Stock_Id); g_free (Action.Accelerator); g_free (Action.Tooltip); end Free; procedure Free (Actions : in out Action_Entry_Array) is begin for A in Actions'Range loop Free (Actions (A)); end loop; end Free; procedure Free (Action : in out Radio_Action_Entry) is begin g_free (Action.Name); g_free (Action.Label); g_free (Action.Stock_Id); g_free (Action.Accelerator); g_free (Action.Tooltip); end Free; procedure Free (Actions : in out Radio_Action_Entry_Array) is begin for A in Actions'Range loop Free (Actions (A)); end loop; end Free; procedure Free (Action : in out Toggle_Action_Entry) is begin g_free (Action.Name); g_free (Action.Label); g_free (Action.Stock_Id); g_free (Action.Accelerator); g_free (Action.Tooltip); end Free; procedure Free (Actions : in out Toggle_Action_Entry_Array) is begin for A in Actions'Range loop Free (Actions (A)); end loop; end Free; procedure Add_Actions (Action_Group : access Gtk_Action_Group_Record; Entries : Action_Entry_Array; User_Data : System.Address := System.Null_Address; Destroy : Glib.G_Destroy_Notify_Address := null) is procedure Internal (Action_Group : System.Address; Entries : System.Address; N_Entries : Guint; User_Data : System.Address; Destroy : G_Destroy_Notify_Address); pragma Import (C, Internal, "gtk_action_group_add_actions_full"); begin Internal (Get_Object (Action_Group), Entries (Entries'First)'Address, Entries'Length, User_Data, Destroy); end Add_Actions; procedure Add_Radio_Actions (Action_Group : access Gtk_Action_Group_Record; Entries : Radio_Action_Entry_Array; Value : Glib.Gint; On_Change : Radio_Action_Callback; User_Data : System.Address := System.Null_Address; Destroy : Glib.G_Destroy_Notify_Address := null) is procedure Internal (Action_Group : System.Address; Entries : System.Address; N_Entries : Guint; Value : Gint; On_Change : System.Address; User_Data : System.Address; Destroy : System.Address); pragma Import (C, Internal, "gtk_action_group_add_radio_actions_full"); Data : constant Local_Radio_Action_User_Data_Access := new Local_Radio_Action_User_Data' (Callback => On_Change, User_Data => User_Data, Destroy => Destroy); begin Internal (Get_Object (Action_Group), Entries (Entries'First)'Address, Entries'Length, Value, Local_Radio_Action_Callback'Address, Convert (Data), Local_Radio_Action_Destroy'Address); end Add_Radio_Actions; procedure Add_Toggle_Actions (Action_Group : access Gtk_Action_Group_Record; Entries : Toggle_Action_Entry_Array; User_Data : System.Address := System.Null_Address; Destroy : G_Destroy_Notify_Address := null) is procedure Internal (Action_Group : System.Address; Entries : System.Address; N_Entries : Guint; User_Data : System.Address; Destroy : G_Destroy_Notify_Address); pragma Import (C, Internal, "gtk_action_group_add_toggle_actions_full"); begin Internal (Get_Object (Action_Group), Entries (Entries'First)'Address, Entries'Length, User_Data, Destroy); end Add_Toggle_Actions; procedure Internal (Settings : System.Address; Page_Ranges : System.Address; Num_Ranges : Gint); pragma Import (C, Internal, "gtk_print_settings_set_page_ranges"); begin Internal (Get_Object (Self), Page_Ranges (Page_Ranges'First)'Address, Page_Ranges'Length); type Internal_Page_Range_Array is array (Natural) of Gtk_Page_Range_Record; pragma Convention (C, Internal_Page_Range_Array); type Internal_Page_Range_Array_Access is access Internal_Page_Range_Array; pragma Convention (C, Internal_Page_Range_Array_Access); procedure Free (Item : in out Internal_Page_Range_Array_Access); pragma Import (C, Free, "g_free"); function Internal (Settings : System.Address; Num_Ranges : access Gint) return Internal_Page_Range_Array_Access; pragma Import (C, Internal, "gtk_print_settings_get_page_ranges"); Len : aliased Gint; Result : Internal_Page_Range_Array_Access; begin Result := Internal (Get_Object (Self), Len'Access); declare Ranges : constant Gtk_Page_Range_Array := Gtk_Page_Range_Array (Result (0 .. Natural (Len))); begin Free (Result); return Ranges; end; type Gtk_Page_Range_Record is record Range_Start : Gint; Range_End : Gint; end record; pragma Convention (C, Gtk_Page_Range_Record); type Gtk_Page_Range_Array is array (Integer range <>) of Gtk_Page_Range_Record; pragma Convention (C, Gtk_Page_Range_Array); -- Page range specification(s). An icon set represents a single icon in various sizes and widget states. It can provide a Gdk_Pixbuf for a given size and state on request, and automatically caches some of the rendered Gdk_Pixbuf objects. Normally you would use Gtk.Widget.Render_Icon instead of using icon sets directly. The one case where you'd use an icon set is to create application-specific icon sets to place in an icon factory. function Lookup_Icon_Set (Style : access Gtk.Style_Context.Gtk_Style_Context_Record'Class; Stock_Id : String) return Gtk_Icon_Set; -- Retrieve an icon set by its name. The icon might exist in various sizes, -- that can be manipulated through the result set function Lookup_Icon_Set (Style : access Gtk.Style_Context.Gtk_Style_Context_Record'Class; Stock_Id : String) return Gtk_Icon_Set is function Internal (Style : System.Address; Stock_Id : String) return System.Address; pragma Import (C, Internal, "gtk_style_context_lookup_icon_set"); begin return From_Object (Internal (Get_Object (Style), Stock_Id & ASCII.NUL)); end Lookup_Icon_Set; type gint_array_bounded is array (Natural) of Gint; procedure Internal (Self : System.Address; Sizes : System.Address; Acc_N_Sizes : access Gint); pragma Import (C, Internal, "gtk_icon_set_get_sizes"); procedure g_free (s : access gint_array_bounded); pragma Import (C, g_free, "g_free"); Sizes : aliased access gint_array_bounded; Size : aliased Gint; begin Internal (Self.Get_Object, Sizes'Address, Size'Access); declare Result : Gint_Array (1 .. Integer (Size)); begin for R in 0 .. Integer (Size) - 1 loop Result (R + 1) := Sizes (R); end loop; g_free (Sizes); return Result; end; An icon source contains a Gdk_Pixbuf (or image filename) that serves as the base image for one or more of the icons in an icon set, along with a specification for which icons in the icon set will be based on that pixbuf or image file. An icon set contains a set of icons that represent "the same" logical concept in different states, different global text directions, and different sizes. So for example a web browser's "Back to Previous Page" icon might point in a different direction in Hebrew and in English; it might look different when insensitive; and it might change size depending on toolbar mode (small/large icons). So a single icon set would contain all those variants of the icon. An icon set contains a list of icon sources from which it can derive specific icon variants in the set. In the simplest case, an icon set contains one source pixbuf from which it derives all variants. If you want to use a different base pixbuf for different icon variants, you create multiple icon sources, mark which variants they'll be used to create, and add them to the icon set with Add_Source (see below). By default, the icon source has all parameters wildcarded. That is, the icon source will be used as the base icon for any desired text direction, widget state, or icon size. function Get_Icon_Factory (Self : Gtk.Style_Provider.Gtk_Style_Provider; Path : Gtk.Widget.Gtk_Widget_Path) return Gtk_Icon_Factory; -- Returns the Gtk.Icon_Factory.Gtk_Icon_Factory defined to be in use for -- Path, or null if none is defined. -- Since: gtk+ 3.0 function Get_Icon_Factory (Self : Gtk_Style_Provider; Path : Gtk.Widget.Gtk_Widget_Path) return Gtk.Icon_Factory.Gtk_Icon_Factory is function Internal (Self : Gtk_Style_Provider; Path : Gtk.Widget.Gtk_Widget_Path) return System.Address; pragma Import (C, Internal, "gtk_style_provider_get_icon_factory"); Stub_Gtk_Icon_Factory : Gtk.Icon_Factory.Gtk_Icon_Factory_Record; begin return Gtk.Icon_Factory.Gtk_Icon_Factory (Get_User_Data (Internal (Self, Path), Stub_Gtk_Icon_Factory)); end Get_Icon_Factory; procedure Internal (Icon_Theme : System.Address; Path : out chars_ptr_array_access; N_Elements : out Gint); pragma Import (C, Internal, "gtk_icon_theme_get_search_path"); P : chars_ptr_array_access; N : Gint; begin Internal (Get_Object (Icon_Theme), P, N); declare Result : constant GNAT.Strings.String_List := To_String_List (P.all, N); begin Free (P.all); return Result; end; use Gint_Arrays; function Internal (Icon_Theme : System.Address; Icon_Name : String) return Unbounded_Array_Access; pragma Import (C, Internal, "gtk_icon_theme_get_icon_sizes"); Res : constant Unbounded_Array_Access := Internal (Get_Object (Icon_Theme), Icon_Name & ASCII.NUL); Result : constant Gint_Array := To_Gint_Array_Zero_Terminated (Res); begin G_Free (Res); return Result; use Points_Arrays; function Internal (Icon_Info : System.Address; Result : access Unbounded_Array_Access; N_Points : access Gint) return Gboolean; pragma Import (C, Internal, "gtk_icon_info_get_attach_points"); R : aliased Unbounded_Array_Access; N : aliased Gint; begin if Internal (Icon_Info.Get_Object, R'Unchecked_Access, N'Unchecked_Access) = 0 then R := null; end if; declare Result : constant Gdk_Points_Array := To_Array (R, Integer (N)); begin G_Free (R); return Result; end; package Points_Arrays is new Gtkada.C.Unbounded_Arrays (Gdk.Types.Gdk_Point, (0, 0), Positive, Gdk.Types.Gdk_Points_Array); procedure Set_Property_Value (Settings : not null access Gtk_Settings_Record; Name : String; Value : GValue; Origin : String); function Get_Settings (Widget : not null access Gtk_Widget_Record'Class) return Gtk_Settings; -- Get the settings object holding the settings used for this widget. -- -- Note that this function can only be called when the widget is -- attached to a toplevel, since the settings object is specific to a -- particular Gdk.Screen.Gdk_Screen. function Get_Settings (Widget : not null access Gtk_Widget_Record'Class) return Gtk_Settings is function Internal (W : System.Address) return System.Address; pragma Import (C, Internal, "gtk_widget_get_settings"); Stub : Gtk_Settings_Record; begin return Gtk_Settings (Get_User_Data (Internal (Get_Object (Widget)), Stub)); end Get_Settings; procedure Set_Property_Value (Settings : not null access Gtk_Settings_Record; Name : String; Value : GValue; Origin : String) is type Property_Value is record Origin : Gtkada.Types.Chars_Ptr; Value : GValue; end record; pragma Convention (C, Property_Value); procedure Internal (Settings : System.Address; Name : String; Svalue : System.Address); pragma Import (C, Internal, "gtk_settings_set_property_value"); Val : aliased Property_Value := (Origin => New_String (Origin), Value => Value); begin Internal (Get_Object (Settings), Name & ASCII.NUL, Val'Address); g_free (Val.Origin); end Set_Property_Value; type Gtk_Stock_Item_Array is array (Natural range <>) of Gtk_Stock_Item; procedure Gtk_New (Item : out Gtk_Stock_Item; Stock_Id : String; Label : UTF8_String; Modifier : Gdk.Types.Gdk_Modifier_Type; Keyval : Gdk.Types.Gdk_Key_Type; Translation_Domain : String); -- Create a new stock item. procedure Free (Item : in out Gtk_Stock_Item); -- Free memory allocated in Item. procedure Add (Item : Gtk_Stock_Item); -- Register Item. -- If an item already exists with the same stock ID as one of the items, -- the old item gets replaced. The stock item is copied, so GtkAda does -- not hold any pointer into item and item can be freed. Use -- Add_Static if item is persistent and GtkAda need not copy the array. procedure Gtk_New (Item : out Gtk_Stock_Item; Stock_Id : String; Label : UTF8_String; Modifier : Gdk.Types.Gdk_Modifier_Type; Keyval : Gdk.Types.Gdk_Key_Type; Translation_Domain : String) is begin Item.Stock_Id := Gtkada.Types.New_String (Stock_Id); Item.Label := Gtkada.Types.New_String (Label); Item.Modifier := Modifier; Item.Keyval := Guint (Keyval); Item.Translation_Domain := Gtkada.Types.New_String (Translation_Domain); end Gtk_New; procedure Free (Item : in out Gtk_Stock_Item) is begin Gtkada.Types.g_free (Item.Stock_Id); Gtkada.Types.g_free (Item.Label); Gtkada.Types.g_free (Item.Translation_Domain); end Free; --------- -- Add -- --------- procedure Add (Item : Gtk_Stock_Item) is procedure Internal (Item : Gtk_Stock_Item; N_Items : Guint := 1); pragma Import (C, Internal, "gtk_stock_add"); begin Internal (Item); end Add; Null_Text_Iter : constant Gtk_Text_Iter; Null_Text_Iter : constant Gtk_Text_Iter := (System.Null_Address, System.Null_Address, 0, 0, 0, 0, 0, 0, System.Null_Address, System.Null_Address, 0, 0, 0, System.Null_Address); procedure Copy (Source : Gtk_Text_Iter; Dest : out Gtk_Text_Iter); pragma Inline (Copy); -- Create a copy of Source. function Get_Char (Iter : Gtk_Text_Iter) return Character; -- Return the character immediately following Iter. If Iter is at the -- end of the buffer, then return ASCII.NUL. -- Note that this function assumes that the text is encoded in ASCII -- format. If this is not the case, use the Get_Char function that -- returns a Gunichar instead. function Iter_Or_Null (Iter : System.Address) return System.Address; -- Internal function for GtkAda ------------------------------- -- Converting to/from GValue -- ------------------------------- procedure Set_Text_Iter (Val : in out Glib.Values.GValue; Iter : Gtk_Text_Iter); pragma Import (C, Set_Text_Iter, "g_value_set_pointer"); -- Set the value of the given GValue to Iter. -- Note that Iter is stored by reference, which means no copy of Iter -- is made. Iter should remain allocated as long as Val is being used. procedure Get_Text_Iter (Val : Glib.Values.GValue; Iter : out Gtk_Text_Iter); -- Extract the iterator from the given GValue. -- Note that the iterator returned is a copy of the iterator referenced -- by the give GValue. Modifying the iterator returned does not modify -- the iterator referenced by the GValue. function Get_Slice (Start : Gtk_Text_Iter; The_End : Gtk_Text_Iter) return Gtkada.Types.Chars_Ptr; -- Same as Get_Slice above, but returns the raw C string. -- The caller is responsible for freeing the string returned, -- using Gtkada.Types.g_free. type Gtk_Text_Iter_Access is access Gtk_Text_Iter; function Convert is new Ada.Unchecked_Conversion (System.Address, Gtk_Text_Iter_Access); use type System.Address; ------------------ -- Iter_Or_Null -- ------------------ function Iter_Or_Null (Iter : System.Address) return System.Address is begin if Convert (Iter).all = Null_Text_Iter then-- null iter return System.Null_Address; else return Iter; end if; end Iter_Or_Null; ---------- -- Copy -- ---------- procedure Copy (Source : Gtk_Text_Iter; Dest : out Gtk_Text_Iter) is begin Dest := Source; end Copy; -------------- -- Get_Char -- -------------- function Get_Char (Iter : Gtk_Text_Iter) return Character is Result : constant Gunichar := Get_Char (Iter); Eight_LSB_Mask : constant := 2#1111_1111#; begin -- This function relies on the Get_Char function provided by gtk+, -- which returns a gunichar value. Only the 8 least significant bits -- are then kept to deduce the associated character. return Character'Val (Result and Eight_LSB_Mask); end Get_Char; ------------------- -- Get_Text_Iter -- ------------------- package Iter_Access_Address_Conversions is new System.Address_To_Access_Conversions (Gtk_Text_Iter); procedure Get_Text_Iter (Val : Glib.Values.GValue; Iter : out Gtk_Text_Iter) is begin Copy (Source => Iter_Access_Address_Conversions.To_Pointer (Glib.Values.Get_Address (Val)).all, Dest => Iter); end Get_Text_Iter; --------------- -- Get_Slice -- --------------- function Get_Slice (Start : Gtk_Text_Iter; The_End : Gtk_Text_Iter) return Gtkada.Types.Chars_Ptr is function Internal (Start : Gtk_Text_Iter; The_End : Gtk_Text_Iter) return Gtkada.Types.Chars_Ptr; pragma Import (C, Internal, "gtk_text_iter_get_slice"); begin return Internal (Start, The_End); end Get_Slice; type font_family_array_bounded is array (Natural) of System.Address; procedure Internal (Self : System.Address; Families : System.Address; Size : access Gint); pragma Import (C, Internal, "pango_context_list_families"); procedure g_free (s : access font_family_array_bounded); pragma Import (C, g_free, "g_free"); Families : aliased access font_family_array_bounded; Size : aliased Gint; Tmplt : Pango_Font_Family_Record; begin Internal (Get_Object (Self), Families'Address, Size'Access); declare Result : Pango_Font_Family_Array (1 .. Integer (Size)); begin for R in 0 .. Integer (Size) - 1 loop Result (R + 1) := Pango_Font_Family (Get_User_Data (Families (R), Tmplt)); end loop; g_free (Families); return Result; end; function To_Font_Description (Family_Name : String := ""; Style : Pango.Enums.Style := Pango.Enums.Pango_Style_Normal; Variant : Pango.Enums.Variant := Pango.Enums.Pango_Variant_Normal; Weight : Pango.Enums.Weight := Pango.Enums.Pango_Weight_Normal; Stretch : Pango.Enums.Stretch := Pango.Enums.Pango_Stretch_Normal; Size : Gint := 0) return Pango_Font_Description; -- Create a new font decription from the given parameters. function Get_Style_As_String (Self : Pango_Font_Description) return String; -- Return the font's style as a string (e.g: 'Oblique'). function Get_Weight_As_String (Self : Pango_Font_Description) return String; -- Return the font's style as a string (e.g: 'Oblique'). function To_Address (F : Pango_Font_Description; Add : System.Address) return System.Address; package Desc_Properties is new Generic_Internal_Boxed_Property (Pango_Font_Description, Get_Type, To_Address); type Property_Font_Description is new Desc_Properties.Property; procedure Free (Desc : in out Pango_Font_Description); -- Deallocate the given font description. subtype String7 is String (1 .. 7); Style_Map : constant array (Enums.Style) of String7 := (Enums.Pango_Style_Normal => " ", Enums.Pango_Style_Oblique => "Oblique", Enums.Pango_Style_Italic => "Italic "); subtype String10 is String (1 .. 10); Variant_Map : constant array (Enums.Variant) of String10 := (Enums.Pango_Variant_Normal => " ", Enums.Pango_Variant_Small_Caps => "Small-Caps"); subtype String15 is String (1 .. 15); Stretch_Map : constant array (Enums.Stretch) of String15 := (Enums.Pango_Stretch_Ultra_Condensed => "Ultra-Condensed", Enums.Pango_Stretch_Extra_Condensed => "Extra-Condensed", Enums.Pango_Stretch_Condensed => "Condensed ", Enums.Pango_Stretch_Semi_Condensed => "Semi-Condensed ", Enums.Pango_Stretch_Normal => " ", Enums.Pango_Stretch_Semi_Expanded => "Semi-Expanded ", Enums.Pango_Stretch_Expanded => "Expanded ", Enums.Pango_Stretch_Extra_Expanded => "Extra-Expanded ", Enums.Pango_Stretch_Ultra_Expanded => "Ultra-Expanded "); -- Some of the values are not directly supported by pango. -- ??? See fonts.c in pango Weight_Map : constant array (Enums.Weight) of String10 := (Enums.Pango_Weight_Ultralight => "Light ", Enums.Pango_Weight_Thin => "Thin ", Enums.Pango_Weight_Light => "Light ", Enums.Pango_Weight_Normal => " ", Enums.Pango_Weight_Book => "Book ", Enums.Pango_Weight_Medium => "Medium ", Enums.Pango_Weight_Semibold => "Semi-Bold ", Enums.Pango_Weight_Bold => "Bold ", Enums.Pango_Weight_Semilight => "Semi-Light", Enums.Pango_Weight_Ultrabold => "Bold ", Enums.Pango_Weight_Ultraheavy => "Ultraheavy", Enums.Pango_Weight_Heavy => "Heavy "); function To_Font_Description (Family_Name : String := ""; Style : Enums.Style := Enums.Pango_Style_Normal; Variant : Enums.Variant := Enums.Pango_Variant_Normal; Weight : Enums.Weight := Enums.Pango_Weight_Normal; Stretch : Enums.Stretch := Enums.Pango_Stretch_Normal; Size : Gint := 0) return Pango_Font_Description is begin return From_String (Family_Name & " " & Style_Map (Style) & " " & Variant_Map (Variant) & Weight_Map (Weight) & " " & Stretch_Map (Stretch) & Gint'Image (Size)); end To_Font_Description; function Get_Style_As_String (Self : Pango_Font_Description) return String is Style : constant Pango.Enums.Style := Get_Style (Self); begin if Style = Pango.Enums.Pango_Style_Normal then return "Normal"; else return Style_Map (Style); end if; end Get_Style_As_String; function Get_Weight_As_String (Self : Pango_Font_Description) return String is Weight : constant Pango.Enums.Weight := Get_Weight (Self); begin if Weight = Pango.Enums.Pango_Weight_Normal then return "Normal"; else return Weight_Map (Weight); end if; end Get_Weight_As_String; function To_Address (F : Pango_Font_Description; Add : System.Address) return System.Address is pragma Unreferenced (Add); begin return F.all'Address; end To_Address; ---------- -- Free -- ---------- procedure Free (Desc : in out Pango_Font_Description) is procedure Internal (Desc : Pango_Font_Description); pragma Import (C, Internal, "pango_font_description_free"); begin Internal (Desc); Desc := null; end Free; procedure Gtk_New (Tree_View : out Gtk_Tree_View; Model : access Gtk.Tree_Model.Gtk_Root_Tree_Model_Record'Class); -- A convenience function so that one can directly pass a model, without -- converting to a Gtk_Tree_Model via the "+" operator. procedure Gtk_New (Tree_View : out Gtk_Tree_View; Model : access Gtk.Tree_Model.Gtk_Root_Tree_Model_Record'Class) is begin Gtk_New (Tree_View, To_Interface (Model)); end Gtk_New; Default_Sort_Column_Id : constant Gint := -1; Unsorted_Sort_Column_Id : constant Gint := -2; -- Two special values for the sort column function Internal (Tree_Model : Gtk_Tree_Model; Iter : System.Address; Path : System.Address) return Gint; pragma Import (C, Internal, "gtk_tree_model_get_iter"); Iter : aliased Gtk_Tree_Iter; begin if Internal (+Tree_Model, Iter'Address, Get_Object (Path)) /= 0 then return Iter; else return Null_Iter; end if; function Internal (Tree_Model : Gtk_Tree_Model; Iter : System.Address; Str : String) return Gint; pragma Import (C, Internal, "gtk_tree_model_get_iter_from_string"); Iter : aliased Gtk_Tree_Iter; begin if Internal (+Tree_Model, Iter'Address, Path_String & ASCII.NUL) /= 0 then return Iter; else return Null_Iter; end if; function Internal (Tree_Model : Gtk_Tree_Model; Iter : System.Address) return Gint; pragma Import (C, Internal, "gtk_tree_model_get_iter_first"); Iter : aliased Gtk_Tree_Iter; begin if Internal (+Tree_Model, Iter'Address) /= 0 then return Iter; else return Null_Iter; end if; function Internal (Tree_Model : Gtk_Tree_Model; Iter : System.Address) return Gint; pragma Import (C, Internal, "gtk_tree_model_iter_next"); Local_Iter : aliased Gtk_Tree_Iter := Iter; begin if Internal (+Tree_Model, Local_Iter'Address) = 0 then Iter := Null_Iter; else Iter := Local_Iter; end if; function Internal (Tree_Model : Gtk_Tree_Model; Iter : System.Address) return Gint; pragma Import (C, Internal, "gtk_tree_model_iter_previous"); Local_Iter : aliased Gtk_Tree_Iter := Iter; begin if Internal (+Tree_Model, Local_Iter'Address) = 0 then Iter := Null_Iter; else Iter := Local_Iter; end if; function Internal (Tree_Model : Gtk_Tree_Model; Iter : System.Address; Parent : System.Address) return Gint; pragma Import (C, Internal, "gtk_tree_model_iter_children"); It : aliased Gtk_Tree_Iter; begin if Internal (+Tree_Model, It'Address, Iter_Or_Null (Parent'Address)) /= 0 then return It; else return Null_Iter; end if; function Internal (Tree_Model : Gtk_Tree_Model; Iter : System.Address) return Gint; pragma Import (C, Internal, "gtk_tree_model_iter_n_children"); begin return Internal (+Tree_Model, Iter_Or_Null (Iter'Address)); function Internal (Tree_Model : Gtk_Tree_Model; Iter, Parent : System.Address; N : Gint) return Gint; pragma Import (C, Internal, "gtk_tree_model_iter_nth_child"); Iter : aliased Gtk_Tree_Iter; begin if Internal (+Tree_Model, Iter'Address, Iter_Or_Null (Parent'Address), N) /= 0 then return Iter; else return Null_Iter; end if; function Internal (Tree_Model : Gtk_Tree_Model; Iter : System.Address; Child : Gtk_Tree_Iter) return Gint; pragma Import (C, Internal, "gtk_tree_model_iter_parent"); Iter : aliased Gtk_Tree_Iter; begin if Internal (+Tree_Model, Iter'Address, Child) /= 0 then return Iter; else return Null_Iter; end if; type Gtk_Root_Tree_Model_Record is new Glib.Object.GObject_Record with null record; type Gtk_Root_Tree_Model is access all Gtk_Root_Tree_Model_Record'Class; -- A common base type for all objects that implement GtkTreeModel. This -- is used to conveniently provide a number of primitive operations. function Get_Int (Tree_Model : access Gtk_Root_Tree_Model_Record; Iter : Gtk_Tree_Iter; Column : Gint) return Gint; function Get_Ulong (Tree_Model : access Gtk_Root_Tree_Model_Record; Iter : Gtk_Tree_Iter; Column : Gint) return Gulong; function Get_Boolean (Tree_Model : access Gtk_Root_Tree_Model_Record; Iter : Gtk_Tree_Iter; Column : Gint) return Boolean; function Get_Object (Tree_Model : access Gtk_Root_Tree_Model_Record; Iter : Gtk_Tree_Iter; Column : Gint) return Glib.Object.GObject; function Get_C_Proxy (Tree_Model : access Gtk_Root_Tree_Model_Record; Iter : Gtk_Tree_Iter; Column : Gint) return Glib.C_Proxy; function Get_String (Tree_Model : access Gtk_Root_Tree_Model_Record; Iter : Gtk_Tree_Iter; Column : Gint) return UTF8_String; function Get_Address (Tree_Model : access Gtk_Root_Tree_Model_Record; Iter : Gtk_Tree_Iter; Column : Gint) return System.Address; -- Get the value of one cell of the model function Get_Int (Tree_Model : Gtk_Tree_Model; Iter : Gtk_Tree_Iter; Column : Gint) return Gint; function Get_Ulong (Tree_Model : Gtk_Tree_Model; Iter : Gtk_Tree_Iter; Column : Gint) return Gulong; function Get_Boolean (Tree_Model : Gtk_Tree_Model; Iter : Gtk_Tree_Iter; Column : Gint) return Boolean; function Get_Object (Tree_Model : Gtk_Tree_Model; Iter : Gtk_Tree_Iter; Column : Gint) return Glib.Object.GObject; function Get_C_Proxy (Tree_Model : Gtk_Tree_Model; Iter : Gtk_Tree_Iter; Column : Gint) return Glib.C_Proxy; function Get_String (Tree_Model : Gtk_Tree_Model; Iter : Gtk_Tree_Iter; Column : Gint) return UTF8_String; function Get_Address (Tree_Model : Gtk_Tree_Model; Iter : Gtk_Tree_Iter; Column : Gint) return System.Address; package Implements_Gtk_Tree_Model is new Glib.Types.Implements (Gtk_Tree_Model, Gtk_Root_Tree_Model_Record, Gtk_Root_Tree_Model); function To_Interface (Widget : access Gtk_Root_Tree_Model_Record'Class) return Gtk_Tree_Model renames Implements_Gtk_Tree_Model.To_Interface; function "-" (Interf : Gtk_Tree_Model) return Gtk_Root_Tree_Model renames Implements_Gtk_Tree_Model.To_Object; -- Convert from the gtk+ interface to an actual object. The return type -- depends on the exact model, and will likely be an instance of -- Gtk_Tree_Store'Class or Gtk_List_Store'Class depending on how you -- created it. function Get_Int (Tree_Model : access Gtk_Root_Tree_Model_Record; Iter : Gtk_Tree_Iter; Column : Gint) return Gint is begin return Get_Int (To_Interface (Tree_Model), Iter, Column); end Get_Int; function Get_Int (Tree_Model : Gtk_Tree_Model; Iter : Gtk_Tree_Iter; Column : Gint) return Gint is procedure Internal (Tree_Model : Gtk_Tree_Model; Iter : Gtk_Tree_Iter; Column : Gint; Value : out Gint); pragma Import (C, Internal, "ada_gtk_tree_model_get"); A : Gint; begin if Iter = Null_Iter then raise Program_Error with "Get_Int with null_iter"; end if; Internal (Tree_Model, Iter, Column, A); return A; end Get_Int; function Get_Ulong (Tree_Model : access Gtk_Root_Tree_Model_Record; Iter : Gtk_Tree_Iter; Column : Gint) return Gulong is begin return Get_Ulong (To_Interface (Tree_Model), Iter, Column); end Get_Ulong; function Get_Ulong (Tree_Model : Gtk_Tree_Model; Iter : Gtk_Tree_Iter; Column : Gint) return Gulong is procedure Internal (Tree_Model : Gtk_Tree_Model; Iter : Gtk_Tree_Iter; Column : Gint; Value : out Gulong); pragma Import (C, Internal, "ada_gtk_tree_model_get"); A : Gulong; begin if Iter = Null_Iter then raise Program_Error with "Get_Ulong with null_iter"; end if; Internal (Tree_Model, Iter, Column, A); return A; end Get_Ulong; function Get_Boolean (Tree_Model : access Gtk_Root_Tree_Model_Record; Iter : Gtk_Tree_Iter; Column : Gint) return Boolean is begin return Get_Boolean (To_Interface (Tree_Model), Iter, Column); end Get_Boolean; function Get_Boolean (Tree_Model : Gtk_Tree_Model; Iter : Gtk_Tree_Iter; Column : Gint) return Boolean is begin return Get_Int (Tree_Model, Iter, Column) /= 0; end Get_Boolean; function Get_Object (Tree_Model : access Gtk_Root_Tree_Model_Record; Iter : Gtk_Tree_Iter; Column : Gint) return Glib.Object.GObject is begin return Get_Object (To_Interface (Tree_Model), Iter, Column); end Get_Object; function Get_Object (Tree_Model : Gtk_Tree_Model; Iter : Gtk_Tree_Iter; Column : Gint) return Glib.Object.GObject is Stub : Glib.Object.GObject_Record; begin return Get_User_Data (Get_Address (Tree_Model, Iter, Column), Stub); end Get_Object; function Get_C_Proxy (Tree_Model : access Gtk_Root_Tree_Model_Record; Iter : Gtk_Tree_Iter; Column : Gint) return Glib.C_Proxy is begin return Get_C_Proxy (To_Interface (Tree_Model), Iter, Column); end Get_C_Proxy; function Get_C_Proxy (Tree_Model : Gtk_Tree_Model; Iter : Gtk_Tree_Iter; Column : Gint) return Glib.C_Proxy is procedure Internal (Tree_Model : Gtk_Tree_Model; Iter : Gtk_Tree_Iter; Column : Gint; Value : out Glib.C_Proxy); pragma Import (C, Internal, "ada_gtk_tree_model_get"); A : Glib.C_Proxy; begin if Iter = Null_Iter then raise Program_Error with "Get_C_Proxy with null_iter"; end if; Internal (Tree_Model, Iter, Column, A); return A; end Get_C_Proxy; function Get_String (Tree_Model : access Gtk_Root_Tree_Model_Record; Iter : Gtk_Tree_Iter; Column : Gint) return UTF8_String is begin return Get_String (To_Interface (Tree_Model), Iter, Column); end Get_String; function Get_String (Tree_Model : Gtk_Tree_Model; Iter : Gtk_Tree_Iter; Column : Gint) return UTF8_String is procedure Internal (Tree_Model : Gtk_Tree_Model; Iter : Gtk_Tree_Iter; Column : Gint; Value : out Gtkada.Types.Chars_Ptr); pragma Import (C, Internal, "ada_gtk_tree_model_get"); A : Gtkada.Types.Chars_Ptr; begin if Iter = Null_Iter then raise Program_Error with "Get_String with null_iter"; end if; Internal (Tree_Model, Iter, Column, A); if A = Gtkada.Types.Null_Ptr then return ""; else declare S : constant String := Gtkada.Types.Value (A); procedure C_Free (S : Gtkada.Types.Chars_Ptr); pragma Import (C, C_Free, "free"); begin -- Since A was allocated by gtk+ via malloc(), and not via -- System.Memory, we should not be using Gtkada.Types.g_free -- which goes through System.Memory. So we call free() directly -- instead. C_Free (A); return S; end; end if; end Get_String; function Get_Address (Tree_Model : access Gtk_Root_Tree_Model_Record; Iter : Gtk_Tree_Iter; Column : Gint) return System.Address is begin return Get_Address (To_Interface (Tree_Model), Iter, Column); end Get_Address; function Get_Address (Tree_Model : Gtk_Tree_Model; Iter : Gtk_Tree_Iter; Column : Gint) return System.Address is procedure Internal (Tree_Model : Gtk_Tree_Model; Iter : Gtk_Tree_Iter; Column : Gint; Value : out System.Address); pragma Import (C, Internal, "ada_gtk_tree_model_get"); A : System.Address; begin if Iter = Null_Iter then raise Program_Error with "Get_Address with null_iter"; end if; Internal (Tree_Model, Iter, Column, A); return A; end Get_Address; Null_Iter : constant Gtk_Tree_Iter; function "=" (Left : Gtk_Tree_Iter; Right : Gtk_Tree_Iter) return Boolean; procedure Set_Tree_Iter (Val : in out Glib.Values.GValue; Iter : Gtk_Tree_Iter); pragma Import (C, Set_Tree_Iter, "g_value_set_pointer"); -- Set the value of the given GValue to Iter. -- Note that Iter is stored by reference, which means no copy of Iter -- is made. Iter should remain allocated as long as Val is being used. procedure Get_Tree_Iter (Val : Glib.Values.GValue; Iter : out Gtk_Tree_Iter); -- Extract the iterator from the given GValue. -- Note that the iterator returned is a copy of the iterator referenced -- by the give GValue. Modifying the iterator returned does not modify -- the iterator referenced by the GValue. function Get_Tree_Iter (Val : Glib.Values.GValue) return Gtk_Tree_Iter; -- Extract the iterator from the given GValue. function To_Address (Iter : Gtk_Tree_Iter) return System.Address; pragma Convention (C, To_Address); -- Return address of the specified iterator. -- Note: To_Address needs a pass-by-reference semantic to work properly -- On some ABIs (e.g. IA64), Gtk_Tree_Iter is passed by copy, since it's -- a "small enough" record. function Iter_Or_Null (Iter : System.Address) return System.Address; -- Internal function for GtkAda Null_Iter : constant Gtk_Tree_Iter := (0, System.Null_Address, System.Null_Address, System.Null_Address); function "=" (Left : Gtk_Tree_Iter; Right : Gtk_Tree_Iter) return Boolean is use type System.Address; begin if Left.Stamp = Right.Stamp then if Left.Stamp = 0 then -- Stamp = 0 means the iterator is null iterator, we need not to -- compare other fields in this case. return True; else return Left.User_Data = Right.User_Data and then Left.User_Data2 = Right.User_Data2 and then Left.User_Data3 = Right.User_Data3; end if; else return False; end if; end "="; type Gtk_Tree_Iter_Access is access Gtk_Tree_Iter; function Convert is new Ada.Unchecked_Conversion (System.Address, Gtk_Tree_Iter_Access); use type System.Address; function Iter_Or_Null (Iter : System.Address) return System.Address is begin if Convert (Iter).Stamp = 0 then -- null iter return System.Null_Address; else return Iter; end if; end Iter_Or_Null; procedure Get_Tree_Iter (Val : Glib.Values.GValue; Iter : out Gtk_Tree_Iter) is begin Iter := Convert (Glib.Values.Get_Address (Val)).all; end Get_Tree_Iter; function Get_Tree_Iter (Val : Glib.Values.GValue) return Gtk_Tree_Iter is Result : Gtk_Tree_Iter; begin Get_Tree_Iter (Val, Result); return Result; end Get_Tree_Iter; function To_Address (Iter : Gtk_Tree_Iter) return System.Address is begin return Iter'Address; end To_Address; Depth : constant Integer := Integer (Get_Depth (Path)); subtype Result_Array is Gint_Array (0 .. Depth - 1); type Result_Array_Access is access all Result_Array; pragma Convention (C, Result_Array_Access); function Internal (Path : System.Address) return Result_Array_Access; pragma Import (C, Internal, "gtk_tree_path_get_indices"); -- Do not free the result of gtk_tree_path_get_indices since this is -- not a copy, but the currently used data. Result : constant Result_Array_Access := Internal (Get_Object (Path)); begin if Result = null then return (0 .. -1 => 0); else return Result.all; end if; function Get_Tree_Path (Val : Glib.Values.GValue) return Gtk_Tree_Path; -- Extract the path from the given GValue. function Get_Tree_Path (Val : Glib.Values.GValue) return Gtk_Tree_Path is begin return From_Object (Glib.Values.Get_Address (Val)); end Get_Tree_Path; function Internal (Selection : System.Address; Model : access Gtk_Tree_Model; Iter : access Gtk_Tree_Iter) return Gboolean; pragma Import (C, Internal, "gtk_tree_selection_get_selected"); M : aliased Gtk_Tree_Model := Null_Gtk_Tree_Model; It : aliased Gtk_Tree_Iter; begin if Internal (Get_Object (Selection), M'Access, It'Access) = 0 then Iter := Null_Iter; else Iter := It; end if; Model := M; procedure Get_Selected_Rows (Selection : access Gtk_Tree_Selection_Record; Model : out Gtk.Tree_Model.Gtk_Tree_Model; Path_List : out Gtk.Tree_Model.Gtk_Tree_Path_List.Glist); -- Creates a list of path of all selected rows. Additionally, if you are -- planning on modifying the model after calling this function, you may -- want to convert the returned list into a list of Gtk_Tree_Row_Reference. -- -- You must free the resulting list by calling Path_Free on each item, and -- then freeing the list itself. procedure Get_Selected_Rows (Selection : access Gtk_Tree_Selection_Record; Model : out Gtk_Tree_Model; Path_List : out Gtk_Tree_Path_List.Glist) is use type System.Address; function Internal (Selection : System.Address; Model : access Gtk_Tree_Model) return System.Address; pragma Import (C, Internal, "gtk_tree_selection_get_selected_rows"); M : aliased Gtk_Tree_Model; Selected : System.Address; -- list of paths begin Selected := Internal (Get_Object (Selection), M'Access); Model := M; if Selected = System.Null_Address then Path_List := Gtk_Tree_Path_List.Null_List; else Gtk_Tree_Path_List.Set_Object (Path_List, Selected); end if; end Get_Selected_Rows; %(auto)s Iter := Gtk.Tree_Model.Null_Iter; procedure Set (Tree_Store : access Gtk_List_Store_Record; Iter : Gtk.Tree_Model.Gtk_Tree_Iter; Column : Gint; Value : UTF8_String); procedure Set (Tree_Store : access Gtk_List_Store_Record; Iter : Gtk.Tree_Model.Gtk_Tree_Iter; Column : Gint; Value : Boolean); procedure Set (Tree_Store : access Gtk_List_Store_Record; Iter : Gtk.Tree_Model.Gtk_Tree_Iter; Column : Gint; Value : Gint); procedure Set (Tree_Store : access Gtk_List_Store_Record; Iter : Gtk.Tree_Model.Gtk_Tree_Iter; Column : Gint; Value : Gdk.Pixbuf.Gdk_Pixbuf); procedure Set (Self : not null access Gtk_List_Store_Record; Iter : Gtk.Tree_Model.Gtk_Tree_Iter; Columns : Glib.Gint_Array; Values : Glib.Values.GValue_Array); pragma Precondition (Columns'Length = Values'Length); -- A variant of Set which takes the columns and valus as two arrays. -- This is more efficient when changing multiple values than calling -- one of the Set procedures above multiple times. procedure Set (Self : not null access Gtk_List_Store_Record; Iter : Gtk.Tree_Model.Gtk_Tree_Iter; Values : Glib.Values.GValue_Array); -- A variant of the above that is used to set all the columns. procedure Set (Tree_Store : access Gtk_List_Store_Record; Iter : Gtk.Tree_Model.Gtk_Tree_Iter; Column : Gint; Value : UTF8_String) is procedure Internal (Tree_Store : System.Address; Iter : Gtk.Tree_Model.Gtk_Tree_Iter; Column : Gint; Value : UTF8_String); pragma Import (C, Internal, "ada_gtk_list_store_set_ptr"); begin Internal (Get_Object (Tree_Store), Iter, Column, Value & ASCII.NUL); end Set; procedure Set (Tree_Store : access Gtk_List_Store_Record; Iter : Gtk.Tree_Model.Gtk_Tree_Iter; Column : Gint; Value : Gint) is procedure Internal (Tree_Store : System.Address; Iter : Gtk.Tree_Model.Gtk_Tree_Iter; Column : Gint; Value : Gint); pragma Import (C, Internal, "ada_gtk_list_store_set_int"); begin Internal (Get_Object (Tree_Store), Iter, Column, Value); end Set; procedure Set (Tree_Store : access Gtk_List_Store_Record; Iter : Gtk.Tree_Model.Gtk_Tree_Iter; Column : Gint; Value : Boolean) is procedure Internal (Tree_Store : System.Address; Iter : Gtk.Tree_Model.Gtk_Tree_Iter; Column : Gint; Value : Gboolean); pragma Import (C, Internal, "ada_gtk_list_store_set_int"); begin Internal (Get_Object (Tree_Store), Iter, Column, Boolean'Pos (Value)); end Set; procedure Set (Tree_Store : access Gtk_List_Store_Record; Iter : Gtk.Tree_Model.Gtk_Tree_Iter; Column : Gint; Value : Gdk.Pixbuf.Gdk_Pixbuf) is procedure Internal (Tree_Store : System.Address; Iter : Gtk.Tree_Model.Gtk_Tree_Iter; Column : Gint; Value : System.Address); pragma Import (C, Internal, "ada_gtk_list_store_set_ptr"); begin Internal (Get_Object (Tree_Store), Iter, Column, Get_Object (Value)); end Set; procedure Set (Self : not null access Gtk_List_Store_Record; Iter : Gtk.Tree_Model.Gtk_Tree_Iter; Columns : Glib.Gint_Array; Values : Glib.Values.GValue_Array) is procedure Internal (Self : System.Address; Iter : Gtk.Tree_Model.Gtk_Tree_Iter; Columns : System.Address; Values : System.Address; N_Values : Gint); pragma Import (C, Internal, "gtk_list_store_set_valuesv"); begin if Columns'Length = Values'Length then Internal (Get_Object (Self), Iter, Columns (Columns'First)'Address, Values (Values'First)'Address, Values'Length); end if; end Set; procedure Set (Self : not null access Gtk_List_Store_Record; Iter : Gtk.Tree_Model.Gtk_Tree_Iter; Values : Glib.Values.GValue_Array) is Columns : Gint_Array (Integer (Values'First) .. Integer (Values'Last)); begin for C in Columns'Range loop Columns (C) := Gint (C); end loop; Set (Self, Iter, Columns, Values); end Set; generic type Data_Type is private; package Generic_Set is type Data_Type_Access is access all Data_Type; procedure Set (Tree_Store : access Gtk_Tree_Store_Record'Class; Iter : Gtk.Tree_Model.Gtk_Tree_Iter; Column : Gint; Value : Data_Type_Access); -- Generic procedure used to store access objects in the model. -- For GObject and all of its descendents (including all widgets), -- you should use the Set procedure below that takes a GObject as -- parameter. -- -- Please see the example at the end for more information on how to -- create your own Set procedures adapted to your model. Also consider -- using Set_Value for complex cases function Get (Tree_Store : access Gtk_Tree_Store_Record'Class; Iter : Gtk.Tree_Model.Gtk_Tree_Iter; Column : Gint) return Data_Type_Access; -- Generic procedure used to get access objects back from the model. -- For GObject and all of its descendents (including all widgets), -- you should use the Get_Object function defined in Gtk-Tree_Model -- that returns a GObject. end Generic_Set; procedure Set (Tree_Store : access Gtk_Tree_Store_Record; Iter : Gtk.Tree_Model.Gtk_Tree_Iter; Column : Gint; Value : UTF8_String); procedure Set (Tree_Store : access Gtk_Tree_Store_Record; Iter : Gtk.Tree_Model.Gtk_Tree_Iter; Column : Gint; Value : Boolean); procedure Set_Ulong (Tree_Store : access Gtk_Tree_Store_Record; Iter : Gtk.Tree_Model.Gtk_Tree_Iter; Column : Gint; Value : Gulong); procedure Set (Tree_Store : access Gtk_Tree_Store_Record; Iter : Gtk.Tree_Model.Gtk_Tree_Iter; Column : Gint; Value : Gint); procedure Set (Tree_Store : access Gtk_Tree_Store_Record; Iter : Gtk.Tree_Model.Gtk_Tree_Iter; Column : Gint; Value : Glib.C_Proxy); procedure Set (Tree_Store : access Gtk_Tree_Store_Record; Iter : Gtk.Tree_Model.Gtk_Tree_Iter; Column : Gint; Address : System.Address); procedure Set (Tree_Store : access Gtk_Tree_Store_Record; Iter : Gtk.Tree_Model.Gtk_Tree_Iter; Column : Gint; Value : Glib.Object.GObject); procedure Set (Self : not null access Gtk_Tree_Store_Record; Iter : Gtk.Tree_Model.Gtk_Tree_Iter; Columns : Glib.Gint_Array; Values : Glib.Values.GValue_Array); pragma Precondition (Columns'Length = Values'Length); -- A variant of Set which takes the columns and valus as two arrays. -- This is more efficient when changing multiple values than calling -- one of the Set procedures above multiple times. procedure Set (Self : not null access Gtk_Tree_Store_Record; Iter : Gtk.Tree_Model.Gtk_Tree_Iter; Values : Glib.Values.GValue_Array); -- A variant of the above that is used to set all the columns. function Freeze_Sort (Tree : access Gtk.Tree_Store.Gtk_Tree_Store_Record'Class) return Gint; -- Freeze the sorting in the tree view, and returns the current -- sort_column_id, which should be used when thawing. (See Thaw_Sort) procedure Thaw_Sort (Tree : access Gtk.Tree_Store.Gtk_Tree_Store_Record'Class; Column_Id : Gint); -- Thaw a frozen tree_view. Column_Id should be the value returned by -- the corresponding call to Freeze_Sort. function Freeze_Sort (Tree : access Gtk.Tree_Store.Gtk_Tree_Store_Record'Class) return Gint is function Internal (Tree : System.Address) return Gint; pragma Import (C, Internal, "ada_gtk_tree_view_freeze_sort"); begin return Internal (Get_Object (Tree)); end Freeze_Sort; procedure Thaw_Sort (Tree : access Gtk.Tree_Store.Gtk_Tree_Store_Record'Class; Column_Id : Gint) is procedure Internal (Tree : System.Address; Id : Gint); pragma Import (C, Internal, "ada_gtk_tree_view_thaw_sort"); begin Internal (Get_Object (Tree), Column_Id); end Thaw_Sort; package body Generic_Set is pragma Warnings (Off); -- Disable warnings on strict aliasing, since there's no aliasing -- issue here. function To_Address is new Ada.Unchecked_Conversion (Data_Type_Access, System.Address); function To_Access is new Ada.Unchecked_Conversion (System.Address, Data_Type_Access); pragma Warnings (On); procedure Set (Tree_Store : access Gtk_Tree_Store_Record'Class; Iter : Gtk.Tree_Model.Gtk_Tree_Iter; Column : Gint; Value : Data_Type_Access) is begin Set (Tree_Store, Iter, Column, To_Address (Value)); end Set; function Get (Tree_Store : access Gtk_Tree_Store_Record'Class; Iter : Gtk.Tree_Model.Gtk_Tree_Iter; Column : Gint) return Data_Type_Access is begin return To_Access (Get_Address (+Tree_Store, Iter, Column)); end Get; end Generic_Set; procedure Set (Tree_Store : access Gtk_Tree_Store_Record; Iter : Gtk.Tree_Model.Gtk_Tree_Iter; Column : Gint; Address : System.Address) is procedure Internal (Tree_Store : System.Address; Iter : Gtk.Tree_Model.Gtk_Tree_Iter; Column : Gint; Value : System.Address); pragma Import (C, Internal, "ada_gtk_tree_store_set_ptr"); begin Internal (Get_Object (Tree_Store), Iter, Column, Address); end Set; procedure Set (Tree_Store : access Gtk_Tree_Store_Record; Iter : Gtk.Tree_Model.Gtk_Tree_Iter; Column : Gint; Value : UTF8_String) is procedure Internal (Tree_Store : System.Address; Iter : Gtk.Tree_Model.Gtk_Tree_Iter; Column : Gint; Value : UTF8_String); pragma Import (C, Internal, "ada_gtk_tree_store_set_ptr"); begin Internal (Get_Object (Tree_Store), Iter, Column, Value & ASCII.NUL); end Set; procedure Set (Tree_Store : access Gtk_Tree_Store_Record; Iter : Gtk.Tree_Model.Gtk_Tree_Iter; Column : Gint; Value : Gint) is procedure Internal (Tree_Store : System.Address; Iter : Gtk.Tree_Model.Gtk_Tree_Iter; Column : Gint; Value : Gint); pragma Import (C, Internal, "ada_gtk_tree_store_set_int"); begin Internal (Get_Object (Tree_Store), Iter, Column, Value); end Set; procedure Set_Ulong (Tree_Store : access Gtk_Tree_Store_Record; Iter : Gtk.Tree_Model.Gtk_Tree_Iter; Column : Gint; Value : Gulong) is procedure Internal (Tree_Store : System.Address; Iter : Gtk.Tree_Model.Gtk_Tree_Iter; Column : Gint; Value : Gulong); pragma Import (C, Internal, "ada_gtk_tree_store_set_ulong"); begin Internal (Get_Object (Tree_Store), Iter, Column, Value); end Set_Ulong; procedure Set (Tree_Store : access Gtk_Tree_Store_Record; Iter : Gtk.Tree_Model.Gtk_Tree_Iter; Column : Gint; Value : Boolean) is procedure Internal (Tree_Store : System.Address; Iter : Gtk.Tree_Model.Gtk_Tree_Iter; Column : Gint; Value : Gboolean); pragma Import (C, Internal, "ada_gtk_tree_store_set_int"); begin Internal (Get_Object (Tree_Store), Iter, Column, Boolean'Pos (Value)); end Set; procedure Set (Tree_Store : access Gtk_Tree_Store_Record; Iter : Gtk.Tree_Model.Gtk_Tree_Iter; Column : Gint; Value : Glib.C_Proxy) is procedure Internal (Tree_Store : System.Address; Iter : Gtk.Tree_Model.Gtk_Tree_Iter; Column : Gint; Value : Glib.C_Proxy); pragma Import (C, Internal, "ada_gtk_tree_store_set_ptr"); begin Internal (Get_Object (Tree_Store), Iter, Column, Value); end Set; procedure Set (Tree_Store : access Gtk_Tree_Store_Record; Iter : Gtk.Tree_Model.Gtk_Tree_Iter; Column : Gint; Value : Glib.Object.GObject) is procedure Internal (Tree_Store : System.Address; Iter : Gtk.Tree_Model.Gtk_Tree_Iter; Column : Gint; Value : System.Address); pragma Import (C, Internal, "ada_gtk_tree_store_set_ptr"); begin if Value = null then Internal (Get_Object (Tree_Store), Iter, Column, System.Null_Address); else Internal (Get_Object (Tree_Store), Iter, Column, Get_Object (Value)); end if; end Set; procedure Set (Self : not null access Gtk_Tree_Store_Record; Iter : Gtk.Tree_Model.Gtk_Tree_Iter; Columns : Glib.Gint_Array; Values : Glib.Values.GValue_Array) is procedure Internal (Self : System.Address; Iter : Gtk.Tree_Model.Gtk_Tree_Iter; Columns : System.Address; Values : System.Address; N_Values : Gint); pragma Import (C, Internal, "gtk_tree_store_set_valuesv"); begin if Columns'Length = Values'Length then Internal (Get_Object (Self), Iter, Columns (Columns'First)'Address, Values (Values'First)'Address, Values'Length); end if; end Set; procedure Set (Self : not null access Gtk_Tree_Store_Record; Iter : Gtk.Tree_Model.Gtk_Tree_Iter; Values : Glib.Values.GValue_Array) is Columns : Gint_Array (Integer (Values'First) .. Integer (Values'Last)); begin for C in Columns'Range loop Columns (C) := Gint (C); end loop; Set (Self, Iter, Columns, Values); end Set; Gvariant_Type_Boolean : constant Gvariant_Type; -- value is 0 or 1 Gvariant_Type_Byte : constant Gvariant_Type; -- from 0 to 255 Gvariant_Type_Int16 : constant Gvariant_Type; -- from -32768..32767 Gvariant_Type_Uint16 : constant Gvariant_Type; -- from 0 to 65535 Gvariant_Type_Int32 : constant Gvariant_Type; Gvariant_Type_Uint32 : constant Gvariant_Type; Gvariant_Type_Int64 : constant Gvariant_Type; Gvariant_Type_Uint64 : constant Gvariant_Type; Gvariant_Type_Double : constant Gvariant_Type; Gvariant_Type_String : constant Gvariant_Type; pragma Import (C, Gvariant_Type_Boolean, "ada_gvariant_type_boolean"); pragma Import (C, Gvariant_Type_Byte, "ada_gvariant_type_byte"); pragma Import (C, Gvariant_Type_Int16, "ada_gvariant_type_int16"); pragma Import (C, Gvariant_Type_Uint16, "ada_gvariant_type_uint16"); pragma Import (C, Gvariant_Type_Int32, "ada_gvariant_type_int32"); pragma Import (C, Gvariant_Type_Uint32, "ada_gvariant_type_uint32"); pragma Import (C, Gvariant_Type_Int64, "ada_gvariant_type_int64"); pragma Import (C, Gvariant_Type_Uint64, "ada_gvariant_type_uint64"); pragma Import (C, Gvariant_Type_Double, "ada_gvariant_type_double"); pragma Import (C, Gvariant_Type_String, "ada_gvariant_type_string"); function Register (Self : not null access Gapplication_Record; Cancellable : access Glib.Cancellable.Gcancellable_Record'Class) return Boolean; -- Attempts registration of the application. -- This is the point at which the application discovers if it is the -- primary instance or merely acting as a remote for an already-existing -- primary instance. This is implemented by attempting to acquire the -- application identifier as a unique bus name on the session bus using -- GDBus. -- If there is no application ID or if -- Glib.Application.G_Application_Non_Unique was given, then this process -- will always become the primary instance. -- Due to the internal architecture of GDBus, method calls can be -- dispatched at any time (even if a main loop is not running). For this -- reason, you must ensure that any object paths that you wish to register -- are registered before calling this function. -- If the application has already been registered then True is returned -- with no work performed. -- The Glib.Application.Gapplication::startup signal is emitted if -- registration succeeds and Application is the primary instance (including -- the non-unique case). -- In the event of an error (such as Cancellable being cancelled, or a -- failure to connect to the session bus), False is returned and Error is -- set appropriately. -- Note: the return value of this function is not an indicator that this -- instance is or is not the primary instance of the application. See -- Glib.Application.Get_Is_Remote for that. -- Since: gtk+ 2.28 -- "cancellable": a Glib.Cancellable.Gcancellable, or null -------------- -- Register -- -------------- function Register (Self : not null access Gapplication_Record; Cancellable : access Glib.Cancellable.Gcancellable_Record'Class) return Boolean is function Internal (Self : System.Address; Cancellable : System.Address; Error : System.Address) return Glib.Gboolean; pragma Import (C, Internal, "g_application_register"); begin return Internal (Get_Object (Self), Get_Object_Or_Null (GObject (Cancellable)), System.Null_Address) /= 0; end Register; function Run (Self : not null access Gapplication_Record) return Gint; -- Same as above, but automatically sets argc argv from actual values. gnat_argc : Interfaces.C.int; pragma Import (C, gnat_argc); gnat_argv : System.Address; pragma Import (C, gnat_argv); function Run (Self : not null access Gapplication_Record) return Gint is function Internal (Self : System.Address; Argc : Gint; Argv : System.Address) return Gint; pragma Import (C, Internal, "g_application_run"); begin return Internal (Self.Get_Object, Gint (gnat_argc), gnat_argv); end Run; type GOption_Entry_Array is array (Natural range <>) of GOption_Entry; Null_GOption_Entry : constant GOption_Entry; type Parse_Filter is access function (Param : String) return Boolean; -- Returns True if the parameter is to be passed from Command_Line to -- Goption_Context procedure Parse (Self : Goption_Context; Command_Line : not null access Glib.Application.Gapplication_Command_Line_Record'Class; Filter : Parse_Filter := null; Success : out Boolean; Error : out Glib.Error.GError); -- Parses the arguments given via Command_Line, removing from the arguments -- list all parsed switches. procedure Parse (Self : Goption_Context; Argv : access chars_ptr_array_access; -- Null-terminated Success : out Boolean; Error : out Glib.Error.GError); -- This version is suitable for use from Glib.Application.Local_Command_Line Null_GOption_Entry : constant GOption_Entry := (Gtkada.Types.Null_Ptr, Gchar(ASCII.NUL), 0, G_Option_Arg_None, System.Null_Address, Gtkada.Types.Null_Ptr, Gtkada.Types.Null_Ptr); ----------- -- Parse -- ----------- procedure Parse (Self : Goption_Context; Command_Line : not null access Glib.Application.Gapplication_Command_Line_Record'Class; Filter : Parse_Filter := null; Success : out Boolean; Error : out Glib.Error.GError) is function Get_Args (Self : System.Address; Argc : access Glib.Gint) return chars_ptr_array_access; pragma Import (C, Get_Args, "g_application_command_line_get_arguments"); function Internal (Self : System.Address; Argc : access Glib.Gint; Argv : System.Address; Error : System.Address) return Glib.Gboolean; pragma Import (C, Internal, "g_option_context_parse"); pragma Warnings (Off, "possible aliasing problem for*"); function Convert is new Ada.Unchecked_Conversion (System.Address, chars_ptr_array_access); pragma Warnings (On, "possible aliasing problem for*"); Argc : aliased Glib.Gint; Argv : chars_ptr_array_access; Err : Glib.Error.GError; Ret : Glib.Gboolean; begin Argv := Get_Args (Command_Line.Get_Object, Argc'Access); if Filter = null then Ret := Internal (Get_Object (Self), Argc'Access, Argv'Address, Err'Address); else declare Args : aliased Gtkada.Types.Chars_Ptr_Array := To_Chars_Ptr (Argv); Idx : aliased Glib.Gint := 1; begin -- Copy command name argument Args (0) := Argv (0); Idx := 1; for J in 1 .. Argc - 1 loop if Filter (Gtkada.Types.Value (Argv (Interfaces.C.size_t (J)))) then Args (Interfaces.C.size_t (Idx)) := Argv (Interfaces.C.size_t (J)); Idx := Idx + 1; end if; end loop; Argv := Convert (Args'Address); Ret := Internal (Get_Object (Self), Idx'Access, Argv'Address, Err'Address); end; end if; Error := Err; Success := Ret /= 0; end Parse; ----------- -- Parse -- ----------- procedure Parse (Self : Goption_Context; Argv : access chars_ptr_array_access; -- Null-terminated Success : out Boolean; Error : out Glib.Error.GError) is use Interfaces.C; function Internal (Self : System.Address; Argc : access Glib.Gint; Argv : access chars_ptr_array_access; Error : System.Address) return Glib.Gboolean; pragma Import (C, Internal, "g_option_context_parse"); Err : Glib.Error.GError; Ret : Glib.Gboolean; Argc : aliased Glib.Gint := 0; begin while Argv.all (size_t (Argc)) /= Gtkada.Types.Null_Ptr loop Argc := Argc + 1; end loop; Ret := Internal (Get_Object (Self), Argc'Access, Argv, Err'Address); Argv.all (size_t (Argc)) := Gtkada.Types.Null_Ptr; Error := Err; Success := Ret /= 0; end Parse; type GAction_Entry_Array is array (Natural range <>) of GAction_Entry; type Activate_Callback is access procedure (Action : access Glib.Simple_Action.Gsimple_Action; Parameter : Glib.Variant.Gvariant; Data : System.Address); pragma Convention (C, Activate_Callback); type Change_State_Callback is access procedure (Action : access Glib.Simple_Action.Gsimple_Action; Parameter : Glib.Variant.Gvariant; Data : System.Address); pragma Convention (C, Change_State_Callback); function Build (Name : String; Activate : Activate_Callback := null; Parameter_Type : String := ""; State : String := ""; Change_State : Change_State_Callback := null) return GAction_Entry; -- Return a newly allocation action entry. -- This will be freed by the the action_map when needed. -- -- Name is the name of the action. -- Activate is the callback to connect to the "activate" signal of -- the action. -- Parameter_Type is the type of the parameter that must be passed -- to the activate function for this action, given as a single -- Gvariant (or the empty string for no parameter). -- State is the initial state of this action, given in Gvariant -- text format. The state is parsed with no extra type information -- so type tags must be added to the string if they are necessary. -- Change_State is the callback for the "change-state" signal. function Convert is new Ada.Unchecked_Conversion (Activate_Callback, System.Address); function Convert is new Ada.Unchecked_Conversion (Change_State_Callback, System.Address); function Build (Name : String; Activate : Activate_Callback := null; Parameter_Type : String := ""; State : String := ""; Change_State : Change_State_Callback := null) return GAction_Entry is P, S : chars_ptr := null_ptr; begin if Parameter_Type /= "" then P := New_String (Parameter_Type); end if; if State /= "" then S := New_String (State); end if; return GAction_Entry' (Name => New_String (Name), Activate => Convert (Activate), Parameter_Type => P, State => S, Change_State => Convert (Change_State), Padding => <>); end Build; type Giochannel is access all GIO_Channel_Record; pragma No_Strict_Aliasing (Giochannel); function Shutdown (Self : Giochannel; Flush : Glib.Gboolean; Error : access Glib.Error.GError) return GIOStatus; pragma Import (C, Shutdown, "g_io_channel_shutdown"); -- Close an IO channel. Any pending data to be written will be flushed if -- Flush is True. The channel will not be freed until the last reference is -- dropped using Glib.IOChannel.Unref. -- "flush": if True, flush pending function Flush (Self : Giochannel; Error : access Glib.Error.GError) return GIOStatus; pragma Import (C, Flush, "g_io_channel_flush"); -- Flushes the write buffer for the GIOChannel. function Set_Encoding (Self : Giochannel; Encoding : UTF8_String := ""; Error : access Glib.Error.GError) return GIOStatus; -- Sets the encoding for the input/output of the channel. The internal -- encoding is always UTF-8. The default encoding for the external file is -- UTF-8. -- The encoding null is safe to use with binary data. -- The encoding can only be set if one of the following conditions is -- true: -- - The channel was just created, and has not been written to or read -- from yet. -- - The channel is write-only. -- - The channel is a file, and the file pointer was just repositioned by -- a call to Glib.IOChannel.Seek_Position. (This flushes all the internal -- buffers.) -- - The current encoding is null or UTF-8. -- - One of the (new API) read functions has just returned -- Glib.IOChannel.G_Io_Status_Eof (or, in the case of -- g_io_channel_read_to_end, Glib.IOChannel.G_Io_Status_Normal). -- - One of the functions Glib.IOChannel.Read_Chars or -- Glib.IOChannel.Read_Unichar has returned -- Glib.IOChannel.G_Io_Status_Again or Glib.IOChannel.G_Io_Status_Error. -- This may be useful in the case of G_CONVERT_ERROR_ILLEGAL_SEQUENCE. -- Returning one of these statuses from g_io_channel_read_line, -- Glib.IOChannel.Read_Line_String, or g_io_channel_read_to_end does not -- guarantee that the encoding can be changed. -- Channels which do not meet one of the above conditions cannot call -- Glib.IOChannel.Seek_Position with an offset of -- Glib.IOChannel.G_Seek_Cur, and, if they are "seekable", cannot call -- Glib.IOChannel.Write_Chars after calling one of the API "read" -- functions. -- "encoding": the encoding type function Set_Flags (Self : Giochannel; Flags : GIOFlags; Error : access Glib.Error.GError) return GIOStatus; pragma Import (C, Set_Flags, "g_io_channel_set_flags"); -- Sets the (writeable) flags in Channel to (Flags and -- Glib.IOChannel.G_Io_Flag_Set_Mask). -- "flags": the flags to set on the IO channel function Read_Chars (Self : Giochannel; Buf : out Ada.Streams.Stream_Element_Array; Bytes_Read : access Gsize; Error : access Glib.Error.GError) return GIOStatus; -- Replacement for g_io_channel_read with the new API. -- "buf": a buffer to read data into -- "count": is sent as Buf'Length. -- "bytes_read": The number of bytes read. This may be zero even on -- success if count less than 6 and the channel's encoding is non-null. -- This indicates that the next UTF-8 character is too wide for -- the buffer. function Write_Chars (Self : Giochannel; Buf : Ada.Streams.Stream_Element_Array; Bytes_Written : access Gsize; Error : access Glib.Error.GError) return GIOStatus; -- Replacement for g_io_channel_write with the new API. -- On seekable channels with encodings other than null or UTF-8, generic -- mixing of reading and writing is not allowed. A call to -- g_io_channel_write_chars () may only be made on a channel from which -- data has been read in the cases described in the documentation for -- g_io_channel_set_encoding (). -- "buf": a buffer to write data from -- "count": is sent as Buf'Length. -- "bytes_written": The number of bytes written. This can be nonzero even -- if the return value is not Glib.IOChannel.G_Io_Status_Normal. If the -- return value is Glib.IOChannel.G_Io_Status_Normal and the channel is -- blocking, this will always be equal to Count if Count >= 0. function Read_Line_String (Self : Giochannel; Buffer : Glib.String.Gstring; Terminator_Pos : in out Gsize; Error : access Glib.Error.GError) return GIOStatus; pragma Import (C, Read_Line_String, "g_io_channel_read_line_string"); -- Reads a line from a Glib.IOChannel.Giochannel, using a -- Glib.String.Gstring as a buffer. -- "buffer": a Glib.String.Gstring into which the line will be written. If -- Buffer already contains data, the old data will be overwritten. -- "terminator_pos": location to store position of line terminator, or -- null function Read_Unichar (Self : Giochannel; Thechar : access Gunichar; Error : access Glib.Error.GError) return GIOStatus; pragma Import (C, Read_Unichar, "g_io_channel_read_unichar"); -- Reads a Unicode character from Channel. This function cannot be called -- on a channel with null encoding. -- "thechar": a location to return a character function Write_Unichar (Self : Giochannel; Thechar : Gunichar; Error : access Glib.Error.GError) return GIOStatus; pragma Import (C, Write_Unichar, "g_io_channel_write_unichar"); -- Writes a Unicode character to Channel. This function cannot be called -- on a channel with null encoding. -- "thechar": a character generic type User_Data is limited private; function Generic_Add_Watch (Channel : Giochannel; Condition : GIOCondition; Callback : access function (Source : Giochannel; Condition : GIOCondition; Data : access User_Data) return Glib.Gboolean; Data : access User_Data) return Glib.Main.G_Source_Id; pragma Import (C, Generic_Add_Watch, "g_io_add_watch"); -- Adds the Glib.IOChannel.Giochannel into the default main loop context -- with the default priority. -- "channel": a Glib.IOChannel.Giochannel -- "condition": the condition to watch for -- "callback": the function to call when the condition is satisfied ------------------ -- Set_Encoding -- ------------------ function Set_Encoding (Self : Giochannel; Encoding : UTF8_String := ""; Error : access Glib.Error.GError) return GIOStatus is function Internal (Self : Giochannel; Encoding : Gtkada.Types.Chars_Ptr; Error : access Glib.Error.GError) return GIOStatus; pragma Import (C, Internal, "g_io_channel_set_encoding"); Tmp_Encoding : Gtkada.Types.Chars_Ptr; Tmp_Return : GIOStatus; begin if Encoding = "" then Tmp_Encoding := Gtkada.Types.Null_Ptr; else Tmp_Encoding := New_String (Encoding); end if; Tmp_Return := Internal (Self, Tmp_Encoding, Error); Free (Tmp_Encoding); return Tmp_Return; end Set_Encoding; ---------------- -- Read_Chars -- ---------------- function Read_Chars (Self : Giochannel; Buf : out Ada.Streams.Stream_Element_Array; Bytes_Read : access Gsize; Error : access Glib.Error.GError) return GIOStatus is function Internal (Self : Giochannel; Buf : System.Address; Count : Gsize; Acc_Bytes_Read : access Gsize; Error : access Glib.Error.GError) return GIOStatus; pragma Import (C, Internal, "g_io_channel_read_chars"); Acc_Bytes_Read : aliased Gsize; Tmp_Return : GIOStatus; begin Tmp_Return := Internal (Self, Buf'Address, Buf'Length, Acc_Bytes_Read'Access, Error); if Bytes_Read /= null then Bytes_Read.all := Acc_Bytes_Read; end if; return Tmp_Return; end Read_Chars; ----------------- -- Write_Chars -- ----------------- function Write_Chars (Self : Giochannel; Buf : Ada.Streams.Stream_Element_Array; Bytes_Written : access Gsize; Error : access Glib.Error.GError) return GIOStatus is function Internal (Self : Giochannel; Buf : System.Address; Count : Gssize; Acc_Bytes_Written : access Gsize; Error : access Glib.Error.GError) return GIOStatus; pragma Import (C, Internal, "g_io_channel_write_chars"); Acc_Bytes_Written : aliased Gsize; Tmp_Return : GIOStatus; begin Tmp_Return := Internal (Self, Buf'Address, Buf'Length, Acc_Bytes_Written'Access, Error); Bytes_Written.all := Acc_Bytes_Written; return Tmp_Return; end Write_Chars; type GPid is new Interfaces.C.ptrdiff_t; generic type User_Data is limited private; function Generic_Spawn_Async (Working_Directory : Gtkada.Types.Chars_Ptr := Gtkada.Types.Null_Ptr; Argv : access Gtkada.Types.Chars_Ptr_Array; Envp : access Gtkada.Types.Chars_Ptr_Array; Flags : GSpawn_Flags; Child_Setup : access procedure (Data : access User_Data); Data : access User_Data; Child_Pid : access GPid; Error : access Glib.Error.GError) return Glib.Gboolean; pragma Import (C, Generic_Spawn_Async, "gnat_spawn_async"); -- See Glib.Spawn.Spawn_Async_With_Pipes for a full description; this -- function simply calls the Glib.Spawn.Spawn_Async_With_Pipes without any -- pipes. -- You should call Glib.Spawn.Spawn_Close_Pid on the returned child -- process reference when you don't need it any more. -- If you are writing a GTK+ application, and the program you are spawning -- is a graphical application, too, then you may want to use -- gdk_spawn_on_screen instead to ensure that the spawned program opens its -- windows on the right screen. -- Note that the returned Child_Pid on Windows is a handle to the child -- process and not its identifier. Process handles and process identifiers -- are different concepts on Windows. -- "working_directory": child's current working directory, or null to -- inherit parent's -- "argv": child's argument vector -- "envp": child's environment, or null to inherit parent's -- "flags": flags from Glib.Spawn.GSpawn_Flags -- "child_setup": function to run in the child just before exec -- "child_pid": return location for child process reference, or null generic type User_Data is limited private; function Generic_Spawn_Async_With_Pipes (Working_Directory : Gtkada.Types.Chars_Ptr := Gtkada.Types.Null_Ptr; Argv : access Gtkada.Types.Chars_Ptr_Array; Envp : access Gtkada.Types.Chars_Ptr_Array; Flags : GSpawn_Flags; Child_Setup : access procedure (Data : access User_Data); Data : access User_Data; Child_Pid : access GPid; Standard_Input : access Glib.Gint; Standard_Output : access Glib.Gint; Standard_Error : access Glib.Gint; Error : access Glib.Error.GError) return Glib.Gboolean; pragma Import (C, Generic_Spawn_Async_With_Pipes, "gnat_spawn_async_with_pipes"); -- Executes a child program asynchronously (your program will not block -- waiting for the child to exit). The child program is specified by the -- only argument that must be provided, Argv. Argv should be a -- null-terminated array of strings, to be passed as the argument vector -- for the child. The first string in Argv is of course the name of the -- program to execute. By default, the name of the program must be a full -- path. If Flags contains the Glib.Spawn.G_Spawn_Search_Path flag, the -- `PATH` environment variable is used to search for the executable. If -- Flags contains the Glib.Spawn.G_Spawn_Search_Path_From_Envp flag, the -- `PATH` variable from Envp is used to search for the executable. If both -- the Glib.Spawn.G_Spawn_Search_Path and -- Glib.Spawn.G_Spawn_Search_Path_From_Envp flags are set, the `PATH` -- variable from Envp takes precedence over the environment variable. -- If the program name is not a full path and -- Glib.Spawn.G_Spawn_Search_Path flag is not used, then the program will -- be run from the current directory (or Working_Directory, if specified); -- this might be unexpected or even dangerous in some cases when the -- current directory is world-writable. -- On Windows, note that all the string or string vector arguments to this -- function and the other g_spawn* functions are in UTF-8, the GLib file -- name encoding. Unicode characters that are not part of the system -- codepage passed in these arguments will be correctly available in the -- spawned program only if it uses wide character API to retrieve its -- command line. For C programs built with Microsoft's tools it is enough -- to make the program have a wmain instead of main. wmain has a wide -- character argument vector as parameter. -- At least currently, mingw doesn't support wmain, so if you use mingw to -- develop the spawned program, it will have to call the undocumented -- function __wgetmainargs to get the wide character argument vector and -- environment. See gspawn-win32-helper.c in the GLib sources or init.c in -- the mingw runtime sources for a prototype for that function. -- Alternatively, you can retrieve the Win32 system level wide character -- command line passed to the spawned program using the GetCommandLineW -- function. -- On Windows the low-level child process creation API CreateProcess -- doesn't use argument vectors, but a command line. The C runtime -- library's spawn* family of functions (which -- Glib.Spawn.Spawn_Async_With_Pipes eventually calls) paste the argument -- vector elements together into a command line, and the C runtime startup -- code does a corresponding reconstruction of an argument vector from the -- command line, to be passed to main. Complications arise when you have -- argument vector elements that contain spaces of double quotes. The -- spawn* functions don't do any quoting or escaping, but on the other hand -- the startup code does do unquoting and unescaping in order to enable -- receiving arguments with embedded spaces or double quotes. To work -- around this asymmetry, Glib.Spawn.Spawn_Async_With_Pipes will do quoting -- and escaping on argument vector elements that need it before calling the -- C runtime spawn function. -- The returned Child_Pid on Windows is a handle to the child process, not -- its identifier. Process handles and process identifiers are different -- concepts on Windows. -- Envp is a null-terminated array of strings, where each string has the -- form `KEY=VALUE`. This will become the child's environment. If Envp is -- null, the child inherits its parent's environment. -- Flags should be the bitwise OR of any flags you want to affect the -- function's behaviour. The Glib.Spawn.G_Spawn_Do_Not_Reap_Child means -- that the child will not automatically be reaped; you must use a child -- watch to be notified about the death of the child process. Eventually -- you must call Glib.Spawn.Spawn_Close_Pid on the Child_Pid, in order to -- free resources which may be associated with the child process. (On Unix, -- using a child watch is equivalent to calling waitpid or handling the -- SIGCHLD signal manually. On Windows, calling Glib.Spawn.Spawn_Close_Pid -- is equivalent to calling CloseHandle on the process handle returned in -- Child_Pid). See g_child_watch_add. -- Glib.Spawn.G_Spawn_Leave_Descriptors_Open means that the parent's open -- file descriptors will be inherited by the child; otherwise all -- descriptors except stdin/stdout/stderr will be closed before calling -- exec in the child. Glib.Spawn.G_Spawn_Search_Path means that Argv[0] -- need not be an absolute path, it will be looked for in the `PATH` -- environment variable. Glib.Spawn.G_Spawn_Search_Path_From_Envp means -- need not be an absolute path, it will be looked for in the `PATH` -- variable from Envp. If both Glib.Spawn.G_Spawn_Search_Path and -- Glib.Spawn.G_Spawn_Search_Path_From_Envp are used, the value from Envp -- takes precedence over the environment. -- Glib.Spawn.G_Spawn_Stdout_To_Dev_Null means that the child's standard -- output will be discarded, instead of going to the same location as the -- parent's standard output. If you use this flag, Standard_Output must be -- null. Glib.Spawn.G_Spawn_Stderr_To_Dev_Null means that the child's -- standard error will be discarded, instead of going to the same location -- as the parent's standard error. If you use this flag, Standard_Error -- must be null. Glib.Spawn.G_Spawn_Child_Inherits_Stdin means that the -- child will inherit the parent's standard input (by default, the child's -- standard input is attached to /dev/null). If you use this flag, -- Standard_Input must be null. Glib.Spawn.G_Spawn_File_And_Argv_Zero means -- that the first element of Argv is the file to execute, while the -- remaining elements are the actual argument vector to pass to the file. -- Normally Glib.Spawn.Spawn_Async_With_Pipes uses Argv[0] as the file to -- execute, and passes all of Argv to the child. -- Child_Setup and User_Data are a function and user data. On POSIX -- platforms, the function is called in the child after GLib has performed -- all the setup it plans to perform (including creating pipes, closing -- file descriptors, etc.) but before calling exec. That is, Child_Setup is -- called just before calling exec in the child. Obviously actions taken in -- this function will only affect the child, not the parent. -- On Windows, there is no separate fork and exec functionality. Child -- processes are created and run with a single API call, CreateProcess. -- There is no sensible thing Child_Setup could be used for on Windows so -- it is ignored and not called. -- If non-null, Child_Pid will on Unix be filled with the child's process -- ID. You can use the process ID to send signals to the child, or to use -- g_child_watch_add (or waitpid) if you specified the -- Glib.Spawn.G_Spawn_Do_Not_Reap_Child flag. On Windows, Child_Pid will be -- filled with a handle to the child process only if you specified the -- Glib.Spawn.G_Spawn_Do_Not_Reap_Child flag. You can then access the child -- process using the Win32 API, for example wait for its termination with -- the WaitFor* functions, or examine its exit code with -- GetExitCodeProcess. You should close the handle with CloseHandle or -- Glib.Spawn.Spawn_Close_Pid when you no longer need it. -- If non-null, the Standard_Input, Standard_Output, Standard_Error -- locations will be filled with file descriptors for writing to the -- child's standard input or reading from its standard output or standard -- error. The caller of Glib.Spawn.Spawn_Async_With_Pipes must close these -- file descriptors when they are no longer in use. If these parameters are -- null, the corresponding pipe won't be created. -- If Standard_Input is NULL, the child's standard input is attached to -- /dev/null unless Glib.Spawn.G_Spawn_Child_Inherits_Stdin is set. -- If Standard_Error is NULL, the child's standard error goes to the same -- location as the parent's standard error unless -- Glib.Spawn.G_Spawn_Stderr_To_Dev_Null is set. -- If Standard_Output is NULL, the child's standard output goes to the -- same location as the parent's standard output unless -- Glib.Spawn.G_Spawn_Stdout_To_Dev_Null is set. -- Error can be null to ignore errors, or non-null to report errors. If an -- error is set, the function returns False. Errors are reported even if -- they occur in the child (for example if the executable in Argv[0] is not -- found). Typically the `message` field of returned errors should be -- displayed to users. Possible errors are those from the G_SPAWN_ERROR -- domain. -- If an error occurs, Child_Pid, Standard_Input, Standard_Output, and -- Standard_Error will not be filled with valid values. -- If Child_Pid is not null and an error does not occur then the returned -- process reference must be closed using Glib.Spawn.Spawn_Close_Pid. -- If you are writing a GTK+ application, and the program you are spawning -- is a graphical application, too, then you may want to use -- gdk_spawn_on_screen_with_pipes instead to ensure that the spawned -- program opens its windows on the right screen. -- "working_directory": child's current working directory, or null to -- inherit parent's, in the GLib file name encoding -- "argv": child's argument vector, in the GLib file name encoding -- "envp": child's environment, or null to inherit parent's, in the GLib -- file name encoding -- "flags": flags from Glib.Spawn.GSpawn_Flags -- "child_setup": function to run in the child just before exec -- "child_pid": return location for child process ID, or null -- "standard_input": return location for file descriptor to write to -- child's stdin, or null -- "standard_output": return location for file descriptor to read child's -- stdout, or null -- "standard_error": return location for file descriptor to read child's -- stderr, or null generic type User_Data is limited private; function Generic_Spawn_Async_With_Fds (Working_Directory : Gtkada.Types.Chars_Ptr := Gtkada.Types.Null_Ptr; Argv : access Gtkada.Types.Chars_Ptr_Array; Envp : access Gtkada.Types.Chars_Ptr_Array; Flags : GSpawn_Flags; Child_Setup : access procedure (Data : access User_Data); Data : access User_Data; Child_Pid : access GPid; Stdin_Fd : Glib.Gint; Stdout_Fd : Glib.Gint; Stderr_Fd : Glib.Gint; Error : access Glib.Error.GError) return Glib.Gboolean; pragma Import (C, Generic_Spawn_Async_With_Fds, "gnat_spawn_async_with_fds"); -- Identical to g_spawn_async_with_pipes() but instead of creating pipes -- for the stdin/stdout/stderr, you can pass existing file descriptors -- into this function through the stdin_fd , stdout_fd and -- stderr_fd parameters. The following flags also have their behaviour -- slightly tweaked as a result: G_SPAWN_STDOUT_TO_DEV_NULL means that -- the child's standard output will be discarded, instead of going to the -- same location as the parent's standard output. If you use this flag, -- standard_output must be -1. G_SPAWN_STDERR_TO_DEV_NULL means that the -- child's standard error will be discarded, instead of going to the same -- location as the parent's standard error. If you use this flag, -- standard_error must be -1. G_SPAWN_CHILD_INHERITS_STDIN means that the -- child will inherit the parent's standard input (by default, the child's -- standard input is attached to /dev/null). If you use this flag, -- standard_input must be -1. -- It is valid to pass the same fd in multiple parameters (e.g. you can -- pass a single fd for both stdout and stderr). -- Parameters -- "working_directory" child's current working directory, or NULL to -- inherit parent's, in the GLib file name encoding. -- "argv" child's argument vector, in the GLib file name encoding. -- "envp" child's environment, or NULL to inherit parent's, in the GLib -- file name encoding. -- "flags" flags from GSpawnFlags -- "child_setup" function to run in the child just before exec(). -- "user_data" user data for child_setup -- "child_pid" return location for child process ID, or NULL. -- "stdin_fd" file descriptor to use for child's stdin, or -1 -- "stdout_fd" file descriptor to use for child's stdout, or -1 -- "stderr_fd" file descriptor to use for child's stderr, or -1 -- "error" return location for error -- Returns -- TRUE on success, FALSE if an error was set -- Since: 2.58 generic type User_Data is limited private; function Generic_Spawn_Sync (Working_Directory : Gtkada.Types.Chars_Ptr := Gtkada.Types.Null_Ptr; Argv : access Gtkada.Types.Chars_Ptr_Array; Envp : access Gtkada.Types.Chars_Ptr_Array; Flags : GSpawn_Flags; Child_Setup : access procedure (Data : access User_Data); Data : access User_Data; Child_Pid : access GPid; Standard_Output : access Gtkada.Types.Chars_Ptr_Array; Standard_Error : access Gtkada.Types.Chars_Ptr_Array; Exit_Status : access Glib.Gint; Error : access Glib.Error.GError) return Glib.Gboolean; pragma Import (C, Generic_Spawn_Sync, "gnat_spawn_sync"); -- Executes a child synchronously (waits for the child to exit before -- returning). All output from the child is stored in Standard_Output and -- Standard_Error, if those parameters are non-null. Note that you must set -- the Glib.Spawn.G_Spawn_Stdout_To_Dev_Null and -- Glib.Spawn.G_Spawn_Stderr_To_Dev_Null flags when passing null for -- Standard_Output and Standard_Error. -- If Exit_Status is non-null, the platform-specific exit status of the -- child is stored there; see the documentation of -- Glib.Spawn.Spawn_Check_Exit_Status for how to use and interpret this. -- Note that it is invalid to pass Glib.Spawn.G_Spawn_Do_Not_Reap_Child in -- Flags. -- If an error occurs, no data is returned in Standard_Output, -- Standard_Error, or Exit_Status. -- This function calls Glib.Spawn.Spawn_Async_With_Pipes internally; see -- that function for full details on the other parameters and details on -- how these functions work on Windows. -- "working_directory": child's current working directory, or null to -- inherit parent's -- "argv": child's argument vector -- "envp": child's environment, or null to inherit parent's -- "flags": flags from Glib.Spawn.GSpawn_Flags -- "child_setup": function to run in the child just before exec -- "standard_output": return location for child output, or null -- "standard_error": return location for child error messages, or null -- "exit_status": return location for child exit status, as returned by -- waitpid, or null generic type User_Data is limited private; function Generic_Spawn_Command_Line_Sync (Command_Line : Gtkada.Types.Chars_Ptr; Standard_Output : access Gtkada.Types.Chars_Ptr_Array; Standard_Error : access Gtkada.Types.Chars_Ptr_Array; Exit_Status : access Glib.Gint; Error : access Glib.Error.GError) return Glib.Gboolean; pragma Import (C, Generic_Spawn_Command_Line_Sync, "gnat_spawn_command_line_sync"); -- A simple version of g_spawn_sync() with little-used parameters removed, -- taking a command line instead of an argument vector. See g_spawn_sync() -- for full details. command_line will be parsed by g_shell_parse_argv(). -- Unlike g_spawn_sync(), the G_SPAWN_SEARCH_PATH flag is enabled. -- Note that G_SPAWN_SEARCH_PATH can have security implications, so -- consider using g_spawn_sync() directly if appropriate. Possible errors -- are those from g_spawn_sync() and those from g_shell_parse_argv(). -- If exit_status is non-NULL, the platform-specific exit status of the -- child is stored there; see the documentation of -- g_spawn_check_exit_status() for how to use and interpret this. -- On Windows, please note the implications of g_shell_parse_argv() -- parsing command_line . Parsing is done according to Unix shell rules, -- not Windows command interpreter rules. Space is a separator, -- and backslashes are special. Thus you cannot simply pass a -- command_line containing canonical Windows paths, like -- "c:\program files\app\app.exe", as the backslashes will be eaten, -- and the space will act as a separator. You need to enclose such paths -- with single quotes, like "'c:\program files\app\app.exe' -- 'e:\folder\argument.txt'". -- Parameters -- "command_line" a command line. -- "standard_output" return location for child output. -- "standard_error" return location for child errors. -- "exit_status" return location for child exit status, as returned -- by waitpid(). -- "error" return location for errors -- Returns -- TRUE on success, FALSE if an error was set function Spawn_Command_Line_Async (Command_Line : Gtkada.Types.Chars_Ptr; Error : access Glib.Error.GError) return Boolean; -- A simple version of Glib.Spawn.Spawn_Async that parses a command line -- with g_shell_parse_argv and passes it to Glib.Spawn.Spawn_Async. Runs a -- command line in the background. Unlike Glib.Spawn.Spawn_Async, the -- Glib.Spawn.G_Spawn_Search_Path flag is enabled, other flags are not. -- Note that Glib.Spawn.G_Spawn_Search_Path can have security implications, -- so consider using Glib.Spawn.Spawn_Async directly if appropriate. -- Possible errors are those from g_shell_parse_argv and -- Glib.Spawn.Spawn_Async. -- The same concerns on Windows apply as for g_spawn_command_line_sync. -- "command_line": a command line function Spawn_Check_Exit_Status (Exit_Status : Glib.Gint; Error : access Glib.Error.GError) return Boolean; -- Set Error if Exit_Status indicates the child exited abnormally (e.g. -- with a nonzero exit code, or via a fatal signal). -- The Glib.Spawn.Spawn_Sync and g_child_watch_add family of APIs return -- an exit status for subprocesses encoded in a platform-specific way. On -- Unix, this is guaranteed to be in the same format waitpid returns, and -- on Windows it is guaranteed to be the result of GetExitCodeProcess. -- Prior to the introduction of this function in GLib 2.34, interpreting -- Exit_Status required use of platform-specific APIs, which is problematic -- for software using GLib as a cross-platform layer. -- Additionally, many programs simply want to determine whether or not the -- child exited successfully, and either propagate a Gerror.Gerror or print -- a message to standard error. In that common case, this function can be -- used. Note that the error message in Error will contain human-readable -- information about the exit status. -- The Domain and Code of Error have special semantics in the case where -- the process has an "exit code", as opposed to being killed by a signal. -- On Unix, this happens if WIFEXITED would be true of Exit_Status. On -- Windows, it is always the case. -- The special semantics are that the actual exit code will be the code -- set in Error, and the domain will be G_SPAWN_EXIT_ERROR. This allows you -- to differentiate between different exit codes. -- If the process was terminated by some means other than an exit status, -- the domain will be G_SPAWN_ERROR, and the code will be -- Glib.Spawn.G_Spawn_Error_Failed. -- This function just offers convenience; you can of course also check the -- available platform via a macro such as G_OS_UNIX, and use WIFEXITED and -- WEXITSTATUS on Exit_Status directly. Do not attempt to scan or parse the -- error message string; it may be translated and/or change in future -- versions of GLib. -- Since: gtk+ 2.34 -- "exit_status": An exit code as returned from Glib.Spawn.Spawn_Sync ------------------------------ -- Spawn_Command_Line_Async -- ------------------------------ function Spawn_Command_Line_Async (Command_Line : Gtkada.Types.Chars_Ptr; Error : access Glib.Error.GError) return Boolean is function Internal (Command_Line : Gtkada.Types.Chars_Ptr; Error : access Glib.Error.GError) return Glib.Gboolean; pragma Import (C, Internal, "gnat_spawn_command_line_async"); begin return Internal (Command_Line, Error) /= 0; end Spawn_Command_Line_Async; ----------------------------- -- Spawn_Check_Exit_Status -- ----------------------------- function Spawn_Check_Exit_Status (Exit_Status : Glib.Gint; Error : access Glib.Error.GError) return Boolean is function Internal (Exit_Status : Glib.Gint; Error : access Glib.Error.GError) return Glib.Gboolean; pragma Import (C, Internal, "g_spawn_check_exit_status"); begin return Internal (Exit_Status, Error) /= 0; end Spawn_Check_Exit_Status; function Get_Home_Dir return UTF8_String; -- Gets the current user's home directory. As with most UNIX tools, this -- function will return the value of the HOME environment variable if it -- is set to an existing absolute path name, falling back to the passwd -- file in the case that it is unset. If the path given in HOME is -- non-absolute, does not exist, or is not a directory, the result is -- undefined. Before version 2.36 this function would ignore the HOME -- environment variable, taking the value from the passwd database -- instead. This was changed to increase the compatibility of GLib with -- other programs (and the XDG basedir specification) and to increase -- testability of programs based on GLib (by making it easier to run them -- from test frameworks). If your program has a strong requirement for -- either the new or the old behaviour (and if you don't wish to increase -- your GLib dependency to ensure that the new behaviour is in effect) -- then you should either directly check the HOME environment variable -- yourself or unset it before calling any functions in GLib. -- -- Returns: -- the current user's home directory. ------------------ -- Get_Home_Dir -- ------------------ function Get_Home_Dir return UTF8_String is function Internal return Gtkada.Types.Chars_Ptr; pragma Import (C, Internal, "glib_get_home_dir"); Tmp : constant Gtkada.Types.Chars_Ptr := Internal; Result : constant String := Gtkada.Types.Value (Tmp); begin Gtkada.Types.g_free (Tmp); return Result; end Get_Home_Dir; function Get_Device_Manager (Self : not null access Gdk.Display.Gdk_Display_Record'Class) return Gdk.Device_Manager.Gdk_Device_Manager; -- Returns the Gdk.Device_Manager.Gdk_Device_Manager associated to -- Display. -- Since: gtk+ 3.0 function Get_Device_Manager (Self : not null access Gdk.Display.Gdk_Display_Record'Class) return Gdk.Device_Manager.Gdk_Device_Manager is function Internal (Self : System.Address) return System.Address; pragma Import (C, Internal, "gdk_display_get_device_manager"); Stub_Gdk_Device_Manager : Gdk.Device_Manager.Gdk_Device_Manager_Record; begin return Gdk.Device_Manager.Gdk_Device_Manager (Get_User_Data (Internal (Get_Object (Self)), Stub_Gdk_Device_Manager)); end Get_Device_Manager; procedure Store_Clipboard (Display : not null access Gdk_Display_Record; Clipboard_Window : Gdk.Gdk_Window; Time : Guint32; Targets : Gdk.Types.Gdk_Atom_Array); -- Issues a request to the clipboard manager to store the clipboard data. -- On X11, this is a special program that works according to the -- freedesktop clipboard specification, available at <ulink -- url="http://www.freedesktop.org/Standards/clipboard-manager-spec"> -- http://www.freedesktop.org/Standards/clipboard-manager-spec</ulink>>. -- Since: gtk+ 2.6 -- "clipboard_window": a Gdk.Gdk_Window belonging to the clipboard owner -- "time_": a timestamp -- "targets": an array of targets that should be saved, or null if all -- available targets should be saved. -- "n_targets": length of the Targets array procedure Get_Window_At_Pointer (Display : access Gdk_Display_Record; Win_X : out Glib.Gint; Win_Y : out Glib.Gint; Win : out Gdk.Gdk_Window); -- Obtains the window underneath the mouse pointer, returning the location -- of that window in Win_X, Win_Y. Returns nullif the window -- under the mouse pointer is not known to GDK (for example, belongs to -- another application). -- (Win_X, Win_Y) are relative to the origin of the window under the -- pointer. -- -- Obsolescent: use Gdk.Device.Get_Window_At_Position instead. procedure Store_Clipboard (Display : not null access Gdk_Display_Record; Clipboard_Window : Gdk_Window; Time : Guint32; Targets : Gdk.Types.Gdk_Atom_Array) is procedure Internal (Display : System.Address; Clipboard_Window : Gdk_Window; Time : Guint32; Targets : System.Address; N_Targets : Gint); pragma Import (C, Internal, "gdk_display_store_clipboard"); begin Internal (Get_Object (Display), Clipboard_Window, Time, Targets (Targets'First)'Address, Targets'Length); end Store_Clipboard; procedure Get_Window_At_Pointer (Display : access Gdk_Display_Record; Win_X : out Gint; Win_Y : out Gint; Win : out Gdk_Window) is function Internal (Display : System.Address; Win_X : access Gint; Win_Y : access Gint) return Gdk_Window; pragma Import (C, Internal, "gdk_display_get_window_at_pointer"); X, Y : aliased Gint; begin Win := Internal (Get_Object (Display), X'Access, Y'Access); Win_X := X; Win_Y := Y; end Get_Window_At_Pointer; GtkAda Gesture events are meant to replace low-level handling in most cases. For instance, you should move away from direct use of "button_press" event, and instead use a Gtk.Gesture.Multi_Press gesture. They give you more control (on the area for which a double click is valid for instance), work with touchpad in addition to mouse events, and you can have multiple gestures associated with the same widget, and that won't compete with each other. For instance, having drag-and-drop on a widget which also manipulates low-level "button_press" events is hard to get rid, since the latter callback will often consume the events needed by gtk+ to detect that a drag operation is about to take place. Gestures are objects in their full rights, and therefore needs to be Unref-ed to free memory. GtkAda provides a convenient function for this, so that the typical workflow is: Gesture : Gtk_Gesture_Multi_Press; Gtk_New (Gesture, Widget); Gesture.Watch (Widget); -- Destroy Gesture when Widget is destroyed Gesture.On_Pressed (On_Pressed'Access, Slot => Widget); Without the call to Watch, Gesture would be kept in memory for ever, ready to be attached to some other widget. procedure Set_State (Self : not null access Gtk_Gesture_Record'Class; State : Gtk.Enums.Gtk_Event_Sequence_State := Event_Sequence_Denied); pragma Inline (Set_State); -- Same as the function Set_State, but ignore the return value. -- This is in general call in a gesture callback to stop monitoring the -- current sequence of events. For instance, when you have a multipress -- gesture, you could call Set_State when the number of clicks is greater -- than 2 and you will never be interested in triple clicks or more. procedure Watch (Self : not null access Gtk_Gesture_Record'Class; Object : not null access GObject_Record'Class); -- Automatically unref Self when Widget is destroyed. -- This is a convenience function, since attaching a gesture to a widget -- does not automatically free the gesture when the widget is destroyed -- (presumably so that you can reuse the gesture and its settings for -- another widget). procedure Set_State (Self : not null access Gtk_Gesture_Record'Class; State : Gtk.Enums.Gtk_Event_Sequence_State := Event_Sequence_Denied) is Dummy : Boolean; begin Dummy := Set_State (Self, State); end Set_State; procedure On_Widget_Destroyed (Gesture, Object : System.Address); pragma Convention (C, On_Widget_Destroyed); procedure On_Widget_Destroyed (Gesture, Object : System.Address) is pragma Unreferenced (Object); procedure Internal (Object : System.Address); pragma Import (C, Internal, "g_object_unref"); begin Internal (Gesture); end On_Widget_Destroyed; procedure Watch (Self : not null access Gtk_Gesture_Record'Class; Object : not null access GObject_Record'Class) is begin Weak_Ref (Object, Notify => On_Widget_Destroyed'Access, Data => Get_Object (Self)); end Watch; gtkada-24.0.0/contrib/binding_gtkada.py000066400000000000000000000602141446021174000177710ustar00rootroot00000000000000""" See annotations documentation at: https://live.gnome.org/GObjectIntrospection/Annotations Parses the file binding.xml, which is used to override some aspects of the automatically generated code. The syntax of that file is as follows: obsolescent="..." bindtype="..." into="..." ada="..." parent="..." > group="..." testgtk="..." see="..." > package-level documentation name="..." subtype="True" /> type="..." ctype="..." direction="..." /> id='...' bind=True /> id="..." ada="..." bind="true" obsolescent=".." transfer-ownership='none' return_as_param="..." return="..." classwide="False" > ... name="..." ada="..." type="..." ctype="..." default="..." direction=".." allow-none="0" /> ... /> prefix="..." /> prefix="GTK_" asbitfield="false" ignore="value1 value2..." /> private="False" > ctype="..."/> section="..." ctype="..."/> ... ... ... ctype="..." ada="..." > code """ from xml.etree.cElementTree import parse, SubElement from adaformat import AdaType, GObject, List, naming, Enum, Record class GtkAda(object): def __init__(self, filename): self._tree = parse(filename) self.root = self._tree.getroot() self.packages = dict() for node in self.root: if node.tag == "package": self.packages[node.get("id")] = GtkAdaPackage(node) def get_pkg(self, pkg): """Return the GtkAdaPackage for a given package""" return self.packages.get(pkg, GtkAdaPackage(None)) class GtkAdaPackage(object): """A node in the binding.xml file""" def __init__(self, node): self.node = node self.doc = [] if node: self.bindtype = node.get("bindtype", "t").lower() != "false" else: self.bindtype = True def __repr__(self): return "" % ( self.node.get("id") if self.node else "") def register_types(self, adapkg): """If we are going to generate some enumerations in the package, we need to register them now, so that all places where the enumeration is referenced have the proper full name. adapkg is the name of the Ada package. """ if self.node: for enum in self.node.findall("enum"): Enum.register_ada_decl(pkg=adapkg, ctype=enum.get("ctype"), ada=enum.get("ada", None)) for rec in self.node.findall("record"): Record.register_ada_record( pkg=adapkg, ctype=rec.get("ctype"), ada=rec.get("ada", None)) for rec in self.node.findall("list"): List.register_ada_list( pkg=adapkg, ctype=rec.get("ctype"), ada=rec.get("ada", None)) for rec in self.node.findall("slist"): List.register_ada_list( pkg=adapkg, ctype=rec.get("ctype"), ada=rec.get("ada", None), single=True) def parent_type(self): """Override the parent type for the main widget type in this package""" if self.node: return self.node.get("parent", None) return None def enumerations(self): """List of all enumeration types that need to be declared in the package. The result is a list of tuples. """ result = [] if self.node: for enum in self.node.findall("enum"): result.append((enum.get("ctype"), naming.type(name="", cname=enum.get("ctype")), enum.get("prefix", "GTK_"), enum.get( "asbitfield", "false").lower() == "true", enum.get("ignore", "") )) return result def constants(self): """Return the list of constants that should be bound as part of this package. """ if self.node is not None: return [(c.get("prefix_regexp", ""), c.get("prefix", "")) for c in self.node.findall("constant")] return [] def lists(self): """Return the list of list instantiations we need to add to the package. Returns a list of tuples: [(adaname, CType for element, true for a single-linked list, section), ...] """ result = [] if self.node: for l_inst in self.node.findall("list"): result.append((l_inst.get("ada"), naming.type(name="", cname=l_inst.get("ctype")), False, l_inst.get("section", ""))) for s_l in self.node.findall("slist"): result.append((s_l.get("ada"), naming.type(name="", cname=s_l.get("ctype")), True, s_l.get("section", ""))) return result def add_record_type(self, ctype): """Add explicit record to bind, unless it is already mentioned explictly in the nodes. """ if self.node: for rec in self.node.findall("record"): if rec.get("ctype") == ctype: return SubElement(self.node, "record", {"ctype": ctype}) def records(self): """Returns the list of record types, as a list of tuples: [ (ctype name, corresponding CType, ada name, [fields], [union], [private=False]) ...] Where fields is a dict for each field whose type is overridden: { name: CType, ... } and union is a list of tuples (value, field) associating a field of a with the corresponding value of the discriminant. The returned list includes records added via add_record_type """ result = [] if self.node: for rec in self.node.findall("record"): override_fields = {} for field in rec.findall("field"): override_fields[field.get("name")] = \ naming.type(name="", cname=field.get("ctype")) unions = [] for field in rec.findall("union"): unions.append((field.get("value"), field.get("field"))) result.append((rec.get("ctype"), naming.type(name="", cname=rec.get("ctype")), rec.get("ada"), override_fields, unions, rec.get("private", "false").lower() == "true")) return result def get_doc(self): """Return the overridden doc for for the package, as a list of string. Each string is a paragraph """ if self.node is None: return [] docnode = self.node.find("doc") if docnode is None: return [] doc = [] txt = docnode.text or "" if txt: doc = ["", txt, ""] n = docnode.get("screenshot") if n is not None: doc.append("%s" % n) n = docnode.get("group") if n is not None: doc.append("%s" % n) n = docnode.get("testgtk") if n is not None: doc.append("%s" % n) n = docnode.get("see") if n is not None: doc.append("%s" % n) return doc def get_method(self, cname): if self.node is not None: for f in self.node.findall("method"): if f.get("id") == cname: return GtkAdaMethod(f, self) for f in self.node.findall("virtual-method"): if f.get("id") == cname: return GtkAdaMethod(f, self) for cb in self.node.findall("callback"): if cb.get("id") == cname: return GtkAdaMethod(cb, self) return GtkAdaMethod(None, self) def get_type(self, name): if self.node is not None: name = name.lower() for f in self.node.findall("type"): if f.get("name").lower() == name: return GtkAdaType(f) return GtkAdaType(None) def into(self): if self.node is not None: return self.node.get("into", None) return None def ada_name(self): if self.node is not None: return self.node.get("ada", None) return None def is_obsolete(self): if self.node is not None: return self.node.get("obsolescent", "False").lower() == "true" return False def extra(self): if self.node is not None: extra = self.node.find("extra") if extra is not None: return list(extra) return None def get_default_param_node(self, name): if name and self.node is not None: name = name.lower() for p in self.node.findall("parameter"): if p.get("name") == name: return p return None def get_global_functions(self): """Return the list of global functions that should be bound as part of this package. """ if self.node is not None: return [GtkAdaMethod(c, self) for c in self.node.findall("function") if c.get("bind", "true").lower() != "false"] return [] def bind_virtual_method(self, name, default): """ Whether to bind the given virtual method """ if not hasattr(self, 'virtual_methods'): self.virtual_methods = {'*': default} if self.node is not None: for c in self.node.findall("virtual-method"): self.virtual_methods[c.get('id')] = ( c.get("bind", "true").lower() == "true") v = self.virtual_methods.get(name, None) if v is None: v = self.virtual_methods['*'] return v class GtkAdaMethod(object): def __init__(self, node, pkg): self.node = node self.pkg = pkg def cname(self): """Return the name of the C function""" return self.node.get("id") def get_param(self, name): default = self.pkg.get_default_param_node(name) if self.node is not None: name = name.lower() for p in self.node.findall("parameter"): if p.get("name").lower() == name: return GtkAdaParameter(p, default=default) return GtkAdaParameter(None, default=default) def is_class_wide(self): return self.node is not None \ and self.node.get("classwide", "False").lower() != "false" def bind(self, default="true"): """Whether to bind""" if self.node is not None: return self.node.get("bind", default).lower() != "false" return default != "false" def ada_name(self): if self.node is not None: return self.node.get("ada", None) return None def returned_c_type(self): if self.node is not None: return self.node.get("return", None) return None def is_obsolete(self): if self.node is not None: return self.node.get("obsolescent", "False").lower() == "true" return False def convention(self): if self.node is not None: return self.node.get("convention", None) return None def return_as_param(self): if self.node is not None: return self.node.get("return_as_param", None) return None def transfer_ownership(self, return_girnode): """Whether the value returned by this method needs to be free by the caller. return_girnode is the XML node from the gir file for the return value of the method. """ default = return_girnode.get('transfer-ownership', 'none') if self.node is not None: return self.node.get('transfer-ownership', default) != 'none' else: return default != 'none' def get_body(self): if self.node is not None: return self.node.findtext("body") return None def get_doc(self, default): """Return the doc, as a list of lines""" if self.node is not None: d = self.node.find("doc") if d is not None: txt = d.text doc = [] for paragraph in txt.split("\n\n"): for p in paragraph.split("\\n\n"): doc.append(p) doc.append("") if d.get("extend", "false").lower() == "true": return [default, ""] + doc return doc return [default] class GtkAdaParameter(object): def __init__(self, node, default): self.node = node self.default = default def get_default(self): if self.node is not None: return self.node.get("default", None) return None def get_direction(self): if self.node is not None: return self.node.get("direction", None) if self.default is not None: return self.default.get("direction", None) return None def get_caller_allocates(self): value = None if self.node is not None: value = self.node.get("caller-allocates", None) if self.default is not None: value = self.default.get("caller-allocates", None) return value def get_transfer_ownership(self): value = None if self.node is not None: value = self.node.get("transfer-ownership", None) if self.default is not None: value = self.default.get("transfer-ownership", None) return value def ada_name(self): name = None if self.node is not None: name = self.node.get("ada", None) if name is None and self.default is not None: name = self.default.get("ada", None) return name def get_type(self, pkg): """pkg is used to set the with statements. This returned the locally overridden type, or the one from the default node for this parameter, or None if the type isn't overridden. """ if self.node is not None: t = self.node.get("type", None) if t: if t == "Glib.Object.GObject": return GObject(t, userecord=False) return AdaType(t, pkg=pkg) # An instance of CType t = self.node.get("ctype", None) if t: return t # An XML node if self.default is not None: t = self.default.get("type", None) if t: return AdaType(t, pkg=pkg) return None def allow_none(self, girnode): default = girnode.get('allow-none', '0') if self.node is not None: return self.node.get('allow-none', default) == '1' else: return default == '1' class GtkAdaType(object): def __init__(self, node): self.node = node def is_subtype(self): if self.node is not None: return self.node.get("subtype", "false").lower() == "true" return False gtkada-24.0.0/contrib/contrib.gpr000066400000000000000000000003061446021174000166400ustar00rootroot00000000000000project Contrib is for Source_Dirs use ("."); for Languages use ("Python", "Xml", "Gir"); package Naming is for Implementation_Suffix ("Gir") use ".gir"; end Naming; end Contrib; gtkada-24.0.0/contrib/data.py000066400000000000000000001016721446021174000157610ustar00rootroot00000000000000"""This package contains data which must be edited by hand when adding new bindings. """ from adaformat import naming, Enum, Proxy, Record, GObject, List, Callback # General packages that don't depend on others and must be processed first enums = ("GtkEnums", "PangoEnums", ) # List of interfaces to bind. These are processed before the widgets themselves # These are GIR names interfaces = ( "Actionable", "Activatable", # "AppChooser", "--Atk.ImplementorIface", "Buildable", "CellEditable", "CellLayout", "ColorChooser", "Editable", "FileChooser", "FontChooser", "Icon", "Orientable", "PrintOperationPreview", "RecentChooser", "Scrollable", "StyleProvider", "ToolShell", "TreeDragDest", "TreeDragSource", "TreeSortable", "TreeModel", "Action", "ActionGroup", "ActionMap", "ListModel", "--AppInfo", # Not tested yet, from Gio "--AsyncInitable", # Not tested yet, from Gio "--AsyncResult", # Not tested yet, from Gio "--Converter", # Not tested yet, from Gio "--DBusInterface", # Not tested yet, from Gio "--DBusObject", # Not tested yet, from Gio "--DBusObjectManager", # Not tested yet, from Gio "--DesktopAppInfoLookup", # Not tested yet, from Gio "--Drive", # Not tested yet, from Gio "--File", # Not tested yet, from Gio "--FileDescriptorBased", # Not tested yet, from Gio "--Initable", # Not tested yet, from Gio "--LoadableIcon", # Not tested yet, from Gio "--Mount", # Not tested yet, from Gio "--NetworkMonitor", # Not tested yet, from Gio "--PollableInputStream", # Not tested yet, from Gio "--PollableOutputStream", # Not tested yet, from Gio "--Proxy", # Not tested yet, from Gio "--ProxyResolver", # Not tested yet, from Gio "--RemoteActionGroup", # Not tested yet, from Gio "--Seekable", # Not tested yet, from Gio "--SocketConnectable", # Not tested yet, from Gio "--TlsBackend", # Not tested yet, from Gio "--TlsClientConnection", # Not tested yet, from Gio "--TlsFileDatabase", # Not tested yet, from Gio "--TlsServerConnection", # Not tested yet, from Gio "--Volume", # Not tested yet, from Gio ) # List of widgets to bind. # Contains C type names. # Start the name with -- for objects we do not want to bind binding = ("--GdkAtom", # No binding necessary, too low-level "GdkCursor", "GdkDevice", "GdkDeviceManager", "GdkDeviceTool", "GdkDisplay", "GdkDragContext", "GdkDrawingContext", "GdkEvent", "GdkFrameClock", "GdkFrameTimings", "GdkGLContext", "GdkRGBA", "GdkMonitor", "GdkScreen", "GdkSeat", "GdkWindow", "GApplication", "GApplicationCommandLine", "--GBytes", # Function returning arrays "--GBufferedInputStream", # Not tested yet, from Gio "--GBufferedOutputStream", # Not tested yet, from Gio "GCancellable", "--GCharsetConverter", # Not tested yet, from Gio "--GConverterInputStream", # Not tested yet, from Gio "--GConverterOutputStream", # Not tested yet, from Gio "--GCredentials", # Not tested yet, from Giov "--GDBusActionGroup", # Not tested yet, from Gio "--GDBusAnnotationInfo", # Not tested yet, from Gio "--GDBusArgInfo", # Not tested yet, from Gio "--GDBusAuthObserver", # Not tested yet, from Gio "--GDBusConnection", # Not tested yet, from Gio "--GDBusInterfaceInfo", # Not tested yet, from Gio "--GDBusInterfaceSkeleton", # Not tested yet, from Gio "--GDBusMenuModel", # Not tested yet, from Gio "--GDBusMessage", # Not tested yet, from Gio "--GDBusMethodInfo", # Not tested yet, from Gio "--GDBusMethodInvocation", # Not tested yet, from Gio "--GDBusNodeInfo", # Not tested yet, from Gio "--GDBusObjectManagerClient", # Not tested yet, from Gio "--GDBusObjectManagerServer", # Not tested yet, from Gio "--GDBusObjectProxy", # Not tested yet, from Gio "--GDBusObjectSkeleton", # Not tested yet, from Gio "--GDBusPropertyInfo", # Not tested yet, from Gio "--GDBusProxy", # Not tested yet, from Gio "--GDBusServer", # Not tested yet, from Gio "--GDBusSignalInfo", # Not tested yet, from Gio "--GDataInputStream", # Not tested yet, from Gio "--GDataOutputStream", # Not tested yet, from Gio "--GDesktopAppInfo", # Not tested yet, from Gio "--GEmblem", # Not tested yet, from Gio "--GEmblemedIcon", # Not tested yet, from Gio "--GFileAttributeInfoList", # Not tested yet, from Gio "--GFileAttributeMatcher", # Not tested yet, from Gio "--GFileEnumerator", # Not tested yet, from Gio "--GFileIOStream", # Not tested yet, from Gio "--GFileIcon", # Not tested yet, from Gio "--GFileInfo", # Not tested yet, from Gio "--GFileInputStream", # Not tested yet, from Gio "--GFileMonitor", # Not tested yet, from Gio "--GFileOutputStream", # Not tested yet, from Gio "--GFilenameCompleter", # Not tested yet, from Gio "--GFilterInputStream", # Not tested yet, from Gio "--GFilterOutputStream", # Not tested yet, from Gio "--GIOExtension", # Not tested yet, from Gio "--GIOExtensionPoint", # Not tested yet, from Gio "GIOChannel", "--GIOModule", # Not tested yet, from Gio "--GIOModuleScope", # Not tested yet, from Gio "--GIOSchedulerJob", # Not tested yet, from Gio "--GIOStream", # Not tested yet, from Gio "--GInetAddress", # Not tested yet, from Gio "--GInetAddressMask", # Not tested yet, from Gio "--GInetSocketAddress", # Not tested yet, from Gio "--GInputStream", # Not tested yet, from Gio "--GMemoryInputStream", # Not tested yet, from Gio "--GMemoryOutputStream", # Not tested yet, from Gio "GMenuModel", # Not tested yet, from Gio "GMenu", # Not tested yet, from Gio "GMenuAttributeIter", # Not tested yet, from Gio "GMenuItem", # Not tested yet, from Gio "GMenuLinkIter", # Not tested yet, from Gio "--GMountOperation", # Not tested yet, from Gio "--GNativeVolumeMonitor", # Not tested yet, from Gio "--GNetworkAddress", # Not tested yet, from Gio "--GNetworkService", # Not tested yet, from Gio "GNotification", "--GOutputStream", # Not tested yet, from Gio "GOptionContext", "GPoll", "Spawn", "Utils", "--GParamSpec", # Bound manually "--GParamSpecBoolean", # Bound manually "--GParamSpecBoxed", # Bound manually "--GParamSpecChar", # Bound manually "--GParamSpecDouble", # Bound manually "--GParamSpecEnum", # Bound manually "--GParamSpecFlags", # Bound manually "--GParamSpecFloat", # Bound manually "--GParamSpecGType", # Bound manually "--GParamSpecInt", # Bound manually "--GParamSpecInt64", # Bound manually "--GParamSpecLong", # Bound manually "--GParamSpecObject", # Bound manually "--GParamSpecOverride", # Bound manually "--GParamSpecParam", # Bound manually "--GParamSpecPointer", # Bound manually "--GParamSpecPool", # Bound manually "--GParamSpecString", # Bound manually "--GParamSpecUChar", # Bound manually "--GParamSpecUInt", # Bound manually "--GParamSpecUInt64", # Bound manually "--GParamSpecULong", # Bound manually "--GParamSpecUnichar", # Bound manually "--GParamSpecValueArray", # Bound manually "--GParamSpecVariant", # Bound manually "--GPermission", # Not tested yet, from Gio "--GProxyAddress", # Not tested yet, from Gio "--GProxyAddressEnumerator", # Not tested yet, from Gio "--GResolver", # Not tested yet, from Gio "--GResource", # Not tested yet, from Gio "--GSettings", # Not tested yet, from Gio "--GSettingsSchema", # Not tested yet, from Gio "--GSettingsSchemaSource", # Not tested yet, from Gio "GSimpleAction", "GSimpleActionGroup", "--GSimpleAsyncResult", # Not tested yet, from Gio "--GSimplePermission", # Not tested yet, from Gio "--GSocket", # Not tested yet, from Gio "--GSocketAddress", # Not tested yet, from Gio "--GSocketAddressEnumerator", # Not tested yet, from Gio "--GSocketClient", # Not tested yet, from Gio "--GSocketConnection", # Not tested yet, from Gio "--GSocketControlMessage", # Not tested yet, from Gio "--GSocketListener", # Not tested yet, from Gio "--GSocketService", # Not tested yet, from Gio "--GSource", # Manually bound in Glib.Main "--GSrvTarget", # Not tested yet, from Gio "--GStaticResource", # Not tested yet, from Gio "GString", "--GTcpConnection", # Not tested yet, from Gio "--GTcpWrapperConnection", # Not tested yet, from Gio "--GThemedIcon", # Not tested yet, from Gio "--GThreadedSocketService", # Not tested yet, from Gio "--GTlsCertificate", # Not tested yet, from Gio "--GTlsConnection", # Not tested yet, from Gio "--GTlsDatabase", # Not tested yet, from Gio "--GTlsInteraction", # Not tested yet, from Gio "--GTlsPassword", # Not tested yet, from Gio "--GUnixConnection", # Not tested yet, from Gio "--GUnixCredentialsMessage", # Not tested yet, from Gio "--GUnixFDList", # Not tested yet, from Gio "--GUnixFDMessage", # Not tested yet, from Gio "--GUnixInputStream", # Not tested yet, from Gio "--GUnixMountMonitor", # Not tested yet, from Gio "--GUnixMountPoint", # Not tested yet, from Gio "--GUnixOutputStream", # Not tested yet, from Gio "--GUnixSocketAddress", # Not tested yet, from Gio "GVariant", "GVariantIter", "GVariantType", "--GVfs", # Not tested yet, from Gio "--GVolumeMonitor", # Not tested yet, from Gio "--GZlibCompressor", # Not tested yet, from Gio "--GZlibDecompressor", # Not tested yet, from Gio "--PangoAttrIterator", "PangoAttrList", "PangoAttribute", "--PangoColor", "PangoContext", "PangoCoverage", "PangoFont", "PangoFontDescription", "PangoFontFace", "PangoFontFamily", "PangoFontMap", "PangoFontMetrics", "PangoFontset", "--PangoGlyphItem", "--PangoGlyphItemIter", "--PangoGlyphString", "--PangoItem", "--PangoRenderer", "--PangoScriptIter", "PangoLanguage", "PangoLayout", "PangoLayoutIter", "PangoLayoutLine", "PangoMatrix", "PangoTabArray", "GtkAboutDialog", "GtkAccelGroup", "GtkAccelLabel", "GtkAccelMap", "--GtkAccessible", # Needs ATK "GtkAction", "GtkActionGroup", "GtkActionBar", "GtkAdjustment", "GtkAlignment", "--GtkAppChooserButton", # Needs GFile "--GtkAppChooserDialog", # Needs GFile "--GtkAppChooserWidget", # Needs GFile "GtkApplication", "GtkApplicationWindow", "GtkArrow", "--GtkArrowAccessible", # We do not support atk "GtkAspectFrame", "GtkAssistant", "GtkBin", "GtkBindingEntry", "GtkBindingSet", "GtkBorder", "GtkBox", "--GtkBooleanCellAccessible", # We do not support atk "GtkBuilder", "GtkButton", "--GtkButtonAccessible", # We do not support atk "GtkButtonBox", "GtkCalendar", "--GtkCellAccessible", # We do not support atk "GtkCellArea", "GtkCellAreaBox", "--GtkCellAreaClass", "GtkCellAreaContext", "GtkCellRenderer", "GtkCellRendererAccel", "--GtkCellRendererClass", # Useless in Ada "GtkCellRendererCombo", "GtkCellRendererPixbuf", "GtkCellRendererProgress", "GtkCellRendererSpin", "GtkCellRendererSpinner", "GtkCellRendererText", "GtkCellRendererToggle", "GtkCellView", "GtkCheckButton", "GtkCheckMenuItem", "--GtkCheckMenuItemAccessible", # We do not support atk "GtkClipboard", "GtkColorButton", "GtkColorChooserDialog", "GtkColorChooserWidget", "GtkColorSelection", "GtkColorSelectionDialog", "GtkComboBox", "--GtkComboBoxAccessible", # We do not support atk "GtkComboBoxText", "GtkContainer", "--GtkContainerAccessible", # We do not support atk "--GtkContainerCellAccessible", # We do not support atk "--GtkContainerClass", "GtkCssProvider", "GtkCssSection", "GtkDialog", "GtkDrawingArea", "GtkEntry", "--GtkEntryAccessible", # We do not support atk "GtkEntryBuffer", "GtkEntryCompletion", "--GtkEntryIconAccessible", # We do not support atk "GtkEventBox", "GtkEventController", "GtkExpander", "--GtkExpanderAccessible", # We do not support atk "GtkFileChooserButton", "GtkFileChooserDialog", "GtkFileChooserWidget", "GtkFileFilter", "GtkFixed", "GtkFlowBox", "--GtkFlowBoxAccessible", # We do not support atk "GtkFlowBoxChild", "--GtkFlowBoxChildAccessible", # We do not support atk "GtkFontButton", "GtkFontChooserDialog", "GtkFontChooserWidget", "GtkFontSelection", "GtkFontSelectionDialog", "GtkFrame", "--GtkFrameAccessible", # We do not support atk "GtkGesture", "GtkGestureDrag", "GtkGestureLongPress", "GtkGestureMultiPress", "GtkGesturePan", "GtkGestureRotate", "GtkGestureSingle", "GtkGestureSwipe", "GtkGestureZoom", "GtkGradient", "GtkGLArea", "GtkGrid", "GtkHandleBox", "GtkHBox", "GtkHButtonBox", "GtkHeaderBar", "GtkHPaned", "GtkHScale", "GtkHScrollbar", "GtkHSeparator", "GtkHSV", "GtkIconFactory", "GtkIconInfo", "GtkIconSet", "GtkIconSource", "GtkIconTheme", "GtkIconView", "--GtkIconViewAccessible", # We do not support atk "GtkIMContext", "GtkIMContextSimple", "GtkIMMulticontext", "GtkImage", "--GtkImageAccessible", # We do not support atk "--GtkImageCellAccessible", # We do not support atk "GtkImageMenuItem", "GtkInfoBar", "GtkInvisible", "GtkLabel", "--GtkLabelAccessible", # We do not support atk "GtkLayout", "GtkLevelBar", "--GtkLevelBarAccessible", # We do not support atk "GtkLinkButton", "--GtkLinkButtonAccessible", # We do not support atk "GtkListBox", "--GtkListBoxAccessible", # We do not support atk "GtkListBoxRow", "--GtkListBoxRowAccessible", # We do not support atk "GtkListStore", "--GtkLockButton", # requires GPermission "--GtkLockButtonAccessible", # We do not support atk "GtkMain", "GtkMisc", "GtkMenu", "--GtkMenuAccessible", # We do not support atk "GtkMenuBar", "GtkMenuButton", "--GtkMenuButtonAccessible", # We do not support atk "GtkMenuItem", "--GtkMenuItemAccessible", # We do not support atk "GtkMenuShell", "--GtkMenuShellAccessible", # We do not support atk "GtkMenuToolButton", "GtkMessageDialog", "--GtkMountOperation", # Requires a lot of GIO "GtkNotebook", "--GtkNotebookAccessible", # We do not support atk "--GtkNotebookPageAccessible", # We do not support atk "--GtkNumerableIcon", # Requires a lot of GIO "GtkOffscreenWindow", "GtkOverlay", "GtkPaned", "--GtkPanedAccessible", # We do not support atk "GtkPageSetup", "GtkPaperSize", "--GtkPlacesSidebar", # Requires GFile "GtkPopover", "--GtkPopoverAccessible", # We do not support atk "GtkPrintContext", "GtkPrintOperation", "GtkPrintSettings", "--GtkPlug", # X11-specific, no binding "GtkProgressBar", "--GtkProgressBarAccessible", # We do not support atk "GtkRadioAction", "GtkRadioButton", "--GtkRadioButtonAccessible", # We do not support atk "GtkRadioMenuItem", "--GtkRadioMenuItemAccessible", # We do not support atk "GtkRadioToolButton", "GtkRange", "--GtkRangeAccessible", # We do not support atk "--GtkRcStyle", # manual binding for these deprecated routines "GtkRecentAction", "GtkRecentChooserDialog", "GtkRecentChooserMenu", "GtkRecentChooserWidget", "GtkRecentFilter", "GtkRecentInfo", "GtkRecentManager", "--GtkRendererCellAccessible", # We do not support atk "GtkRevealer", "GtkScale", "--GtkScaleAccessible", # We do not support atk "GtkScaleButton", "--GtkScaleButtonAccessible", # We do not support atk "GtkSearchBar", "GtkSearchEntry", "GtkSelectionData", "GtkSeparator", "GtkSeparatorMenuItem", "GtkSeparatorToolItem", "GtkShortcutsWindow", "GtkSizeGroup", "GtkScrollbar", "GtkScrolledWindow", "--GtkScrolledWindowAccessible", # We do not support atk "GtkSettings", "--GtkSocket", # X11-specific, no binding "GtkSpinner", "--GtkSpinnerAccessible", # We do not support atk "GtkSpinButton", "--GtkSpinButtonAccessible", # We do not support atk "GtkStack", "GtkStackSwitcher", "GtkStatusbar", "--GtkStatusbarAccessible", # We do not support atk "GtkStatusIcon", "GtkStockItem", "GtkStyle", "GtkStyleContext", "GtkStyleProperties", "GtkSwitch", "--GtkSwitchAccessible", # We do not support atk "GtkSymbolicColor", "GtkTable", "GtkTargetEntry", "GtkTargetList", "GtkTearoffMenuItem", "GtkTextAttributes", "GtkTextBuffer", "--GtkTextCellAccessible", # We do not support atk "GtkTextChildAnchor", "GtkTextIter", "GtkTextMark", "GtkTextTag", "GtkTextTagTable", "GtkTextView", "--GtkTextViewAccessible", # We do not support atk "GtkThemingEngine", "GtkTreeIter", "GtkTreeModelFilter", "GtkTreeModelSort", "GtkTreePath", "GtkTreeRowReference", "GtkTreeSelection", "GtkTreeStore", "GtkTreeView", "--GtkTreeViewAccessible", # We do not support atk "GtkTreeViewColumn", "GtkToggleAction", "GtkToggleButton", "--GtkToggleButtonAccessible", # We do not support atk "GtkToggleToolButton", "GtkToolButton", "GtkToolbar", "GtkToolItem", "GtkToolItemGroup", "GtkTooltip", "GtkToolPalette", "--GtkToplevelAccessible", # We do not support atk "GtkUIManager", "GtkVBox", "GtkVButtonBox", "GtkVPaned", "GtkVScale", "GtkVScrollbar", "GtkVSeparator", "GtkViewport", "GtkVolumeButton", "GtkWidget", "--GtkWidgetAccessible", # We do not support atk "GtkWidgetClass", "GtkWindow", "--GtkWindowAccessible", # We do not support atk "GtkWindowGroup", ) # Handling of functions with user data. The names below are the likely names # for callback functions that accept user_data. The GIR file doesn't point to # these specific parameters. user_data_params = ["Data", "Func_Data", "User_Data", "D", "Search_Data"] destroy_data_params = ["destroy", "func_notify", "notify"] # Maps c methods to Ada subprograms or enumeration (for docs). # All methods that are generated automatically will be added # as they are processed. naming.cname_to_adaname = { "gtk_show_uri": "gtk_show_uri()", "gtk_icon_factory_add_default": "Gtk.Icon_Factory.Add_Default", "gtk_icon_factory_add": "Gtk.Icon_Factory.Add", "gdk_pixbuf_new_from_data": "Gdk.Pixbuf.Gdk_New_From_Data", "gdk_pixbuf_new_from_file": "Gdk.Pixbuf.Gdk_New_From_File", "gdk_pixbuf_new_from_xpm_data": "Gdk.Pixbuf.Gdk_New_From_Xpm_Data", "gdk_pixbuf_animation_new_from_file": "Gdk.Pixbuf.Gdk_New_From_File", "gdk_pixbuf_new": "Gdk.Pixbuf.Gdk_New", "gdk_pixbuf_new_subpixbuf": "Gdk.Pixbuf.Gdk_New_Subpixbuf", "gtk_drag_finish": "Gtk.Dnd.Finish", "TRUE": "True", "FALSE": "False", "NULL": "null", "GDK_2BUTTON_PRESS": "Gdk_2button_Press", "GDK_3BUTTON_PRESS": "Gdk_3button_Press", "GDK_EVENT_LAST": None, # ??? Doesn't exist "gtk_activatable_get_action": "Gtk.Activatable.Get_Action", } # Maps GIR's "name" to a "c:type". This isn't needed for the classes # themselves, since this is automatically read from the GIR file. # Mostly used for properties. The values must correspond to entries in # self.type_exceptions. naming.girname_to_ctype = { "GdkPixbuf.Pixbuf": "GdkPixbuf", "Pango.EllipsizeMode": "PangoEllipsizeMode", "Pango.FontDescription": "PangoFontDescription*", "Pango.AttrList": "PangoAttrList", "Gio.Action": "Action", "Gio.ActionGroup": "ActionGroup", "Gio.ActionMap": "ActionMap", "Gio.Application": "GApplication", "Gio.ApplicationCommandLine": "GApplicationCommandLine", "ApplicationCommandLine": "GApplicationCommandLine", "Gio.Icon": "GIcon*", "GLib.Variant": "GVariant", "Gdk.Event": "GdkEvent*", "Gdk.EventButton": "GdkEventButton*", "Gdk.EventMotion": "GdkEventMotion*", "Gdk.EventProximity": "GdkEventProximity*", "Gdk.EventAny": "GdkEventAny*", "Gdk.EventConfigure": "GdkEventConfigure*", "Gdk.EventExpose": "GdkEventExpose*", "Gdk.EventKey": "GdkEventKey*", "Gdk.EventCrossing": "GdkEventCrossing*", "Gdk.EventScroll": "GdkEventScroll*", "Gdk.EventSequence": "GdkEventSequence*", "Gdk.EventWindowState": "GdkEventWindowState*", "Gdk.EventVisibility": "GdkEventVisibility*", "Gdk.EventSelection": "GdkEventSelection*", "Gdk.EventFocus": "GdkEventFocus*", "Gdk.EventProperty": "GdkEventProperty*", "Gdk.EventGrabBroken": "GdkEventGrabBroken*", "Gdk.EventOwnerChange": "GdkEventOwnerChange*", "Gdk.Pixmap": "GdkPixmap*", "Gdk.Image": "GdkImage*", "Gdk.GLContext": "GdkGLContext*", "Gdk.DragContext": "GdkDragContext", "GdkPixbuf.PixbufAnimation": "GdkPixbufAnimation*", "Gdk.Bitmap": "GdkBitmap*", "Gdk.Color": "GdkColor*", "Gdk.Screen": "GdkScreen", "Gdk.RGBA": "GdkRGBA", "GObject.Object": "GObject*", "GObject.Closure": "GClosure*", "cairo.Surface": "cairo_surface_t*", "cairo.Context": "cairo_t*", "cairo.RectangleInt": "cairo_rectangle_int_t*", "ModifierType": "GdkModifierType", "PropertyState": "GdkPropertyState", "TreePath": "GtkTreePath*", "TreeModel": "GtkTreeModel*", "GObject.InitiallyUnowned": "GObject*", # An alias "GObject.ParamSpec": "GParamSpec", "Giochannel": "GIOChannel*", } # Naming exceptions. In particular maps Ada keywords. naming.exceptions = { "Entry": "GEntry", "Type": "The_Type", "Range": "GRange", "Delay": "The_Delay", "Select": "Gtk_Select", "End": "The_End", "Return": "Do_Return", "Function": "Func", "Digits": "The_Digits", "Reverse": "Gtk_Reverse", "Raise": "Gdk_Raise", "Use": "GUse", "Uri": "URI", "In": "Gtk_In", "Gtk_Imcontext": "Gtk_IM_Context", "Gtk_Imcontext_Simple": "Gtk_IM_Context_Simple", "Gtk_Immulticontext": "Gtk_IM_Multi_Context", "Gtk_Uimanager": "Gtk_UI_Manager", "Gicon": "G_Icon", "Gtk_Glarea": "Gtk_GLArea", "Gdk_Glcontext": "Gdk_GLContext", } # Maps C types to type descriptions. # All standard widgets will be added automatically. Only special # namings are needed here naming.type_exceptions = { "gboolean": Enum("Boolean", "Glib.Properties.Property_Boolean"), "gdouble": Proxy("Gdouble", "Glib.Properties.Property_Double"), "double": Proxy("Gdouble", "Glib.Properties.Property_Double"), "gshort": Proxy("Gshort", "Glib.Properties.Property_Int"), "gushort": Proxy("Gushort", "Glib.Properties.Property_Uint"), "int": Proxy("Glib.Gint", "Glib.Properties.Property_Int"), "gint": Proxy("Glib.Gint", "Glib.Properties.Property_Int", default_record_field="0"), "gint8": Proxy("Gint8", "Glib.Properties.Property_Int"), "gint16": Proxy("Gint16", "Glib.Properties.Property_Int"), "gint32": Proxy("Gint32", "Glib.Properties.Property_Int"), "gint64": Proxy("Gint64", "Glib.Properties.Property_Int"), "guint": Proxy("Guint", "Glib.Properties.Property_Uint"), "guint8": Proxy("Guint8", "Glib.Properties.Property_Uint"), "guint16": Proxy("Guint16", "Glib.Properties.Property_Uint"), "guint32": Proxy("Guint32", "Glib.Properties.Property_Uint"), "guint64": Proxy("Guint64", "Glib.Properties.Property_Uint"), "gfloat": Proxy("Gfloat", "Glib.Properties.Property_Float"), "glong": Proxy("Glong", "Glib.Properties.Property_Long"), "gulong": Proxy("Gulong"), "gsize": Proxy("Gsize"), "gssize": Proxy("Gssize"), "gunichar": Proxy("Gunichar"), "gchar": Proxy("Gchar"), "guchar": Proxy("Guchar"), "GAppInfo": Proxy("Glib.GApp_Info"), # These should not be necessary, but if we don't put them the gnerated # binding is wrong (for instance we end up passing Gdk_Event_Record as # parameters to functions, or Gdk_RGBA directly to C) "GdkRGBA": Record("Gdk.RGBA.Gdk_RGBA", # impose casing "Gdk.RGBA.Property_RGBA"), "GdkRGBA*": Proxy("Gdk.RGBA.Gdk_RGBA", "Gdk.RGBA.Property_RGBA", "Gdk.RGBA.Gdk_RGBA_Or_Null"), "GdkEvent*": Proxy("Gdk.Event.Gdk_Event", ""), "GIOChannel*": Proxy("Glib.IOChannel.Giochannel", ""), "cairo_t*": Proxy("Cairo.Cairo_Context"), "cairo_format_t": Proxy("Cairo.Cairo_Format"), "cairo_rectangle_int_t*": Proxy("Cairo.Region.Cairo_Rectangle_Int"), "cairo_content_t": Proxy("Cairo.Cairo_Content"), "cairo_pattern_t*": Proxy("Cairo.Cairo_Pattern"), "cairo_surface_t*": Proxy("Cairo.Cairo_Surface"), "cairo_region_t*": Proxy("Cairo.Region.Cairo_Region"), "cairo_font_options_t": Proxy("Cairo.Cairo_Font_Options"), "GtkWidgetClass": Proxy("Glib.Object.GObject_Class"), "GtkWidgetClass*": Proxy("Glib.Object.GObject_Class"), # Force mapping to a Proxy. This is also hard-coded in GITClass.__init__ "PangoFontDescription": Proxy("Pango.Font.Pango_Font_Description", "Pango.Font.Property_Font_Description"), "PangoFontDescription*": Proxy("Pango.Font.Pango_Font_Description", "Pango.Font.Property_Font_Description"), "GtkTreeIter*": Record("Gtk.Tree_Model.Gtk_Tree_Iter", val_or_null="Iter_Or_Null"), "GtkTextIter*": Record("Gtk.Text_Iter.Gtk_Text_Iter", val_or_null="Iter_Or_Null"), "PangoAttribute": Proxy("Pango.Attributes.Pango_Attribute"), "PangoAttribute*": Proxy("Pango.Attributes.Pango_Attribute"), "GError*": Proxy("Glib.Error.GError"), "GObject*": GObject("Glib.Object.GObject"), "GClosure*": Proxy("System.Address", ""), "GInitiallyUnowned": GObject("Glib.Object.GInitiallyUnowned"), "GIcon*": Proxy("Glib.G_Icon.G_Icon"), "GValue": Proxy("Glib.Values.GValue", ""), "GdkAtom": Proxy("Gdk.Types.Gdk_Atom"), "GVariantType": Proxy("Glib.Variant.Gvariant_Type"), "GVariantType*": Proxy("Glib.Variant.Gvariant_Type"), "GVariantIter": Proxy("Glib.Variant.Gvariant_Iter"), # Proper generation of lists "GdkEventSequence": Proxy("Gdk.Event.Gdk_Event_Sequence"), # Specific to this binding generator (referenced from binding.xml) "VisualList": List("Gdk.Visual.Gdk_Visual_List.Glist"), "ObjectList": List("Glib.Object.Object_Simple_List.Glist"), "ObjectSList": List("Glib.Object.Object_List.GSlist"), "StringList": List("Gtk.Enums.String_List.Glist"), "StringSList": List("Gtk.Enums.String_SList.GSlist"), "TreePathList": List("Gtk.Tree_Model.Gtk_Tree_Path_List.Glist"), "TextTagList": List("Gtk.Text_Tag.Text_Tag_List.GSlist"), "DeviceList": List("Gdk.Device.Device_List.Glist"), "gpointer": Proxy("System.Address", "", default_record_field="System.Null_Address"), "GDestroyNotify": Proxy("Glib.G_Destroy_Notify_Address"), "GQuark": Proxy("Glib.GQuark"), "GObject": Proxy("Glib.Object.GObject"), "GParamSpec": Proxy("Glib.Param_Spec"), "GClosure": Proxy("GClosure"), "GConnectFlags": Proxy("Glib.G_Connect_Flags"), "GSource": Proxy("Glib.Main.G_Source"), "WidgetPath*": Proxy("Gtk.Widget.Widget_Path"), # ??? Shouldn't we use a naming exception instead ? "GtkStatusbar": GObject("Gtk.Status_Bar.Gtk_Status_Bar"), "GtkRcStyle": GObject("Gtk.Rc.Gtk_Rc_Style"), "GtkTreeViewRowSeparatorFunc": Callback("Gtk.Tree_View.Gtk_Tree_View_Row_Separator_Func"), "GKeyFile*": Proxy("Glib.Key_File.G_Key_File"), "GdkColor*": Proxy("Gdk.Color.Gdk_Color", "Gdk.Color.Property_Gdk_Color", "Gdk.Color.Gdk_Color_Or_Null"), "GdkDragContext": GObject("Gdk.Drag_Contexts.Drag_Context"), "GdkFont": Proxy("Gdk.Font.Gdk_Font"), "GdkVisual*": Proxy("Gdk.Visual.Gdk_Visual"), "GdkPixmap*": Proxy("Gdk.Pixmap.Gdk_Pixmap"), "GdkBitmap*": Proxy("Gdk.Bitmap.Gdk_Bitmap"), "GdkImage*": Proxy("Gdk.Image.Gdk_Image"), "GdkPixbuf": GObject("Gdk.Pixbuf.Gdk_Pixbuf"), "GdkPixbufAnimation*": Proxy("Gdk.Pixbuf.Gdk_Pixbuf_Animation"), "GdkRectangle*": Proxy("Gdk.Rectangle.Gdk_Rectangle"), # in gdkevents.h "GdkRectangle": Proxy("Gdk.Rectangle.Gdk_Rectangle"), # ??? The above should not be needed, we should infer it from the Gir. # we need it to generate the "Stub" object in Gdk.Device.Get_Position "Gdk.ModifierType": Proxy("Gdk.Types.Gdk_Modifier_Type"), "GdkModifierType": Proxy("Gdk.Types.Gdk_Modifier_Type"), "GdkKeyType": Proxy("Gdk.Types.Gdk_Key_Type"), "GdkWindowAttr*": Proxy("Gdk.Gdk_Window_Attr"), # Override type: we do not want to show they derive from GObject "GdkCursor": Proxy("Gdk.Gdk_Cursor"), "GdkCursor*": Proxy("Gdk.Gdk_Cursor"), "GdkWindow": Proxy("Gdk.Gdk_Window"), "GdkWindow*": Proxy("Gdk.Gdk_Window"), } gtkada-24.0.0/docs/000077500000000000000000000000001446021174000137575ustar00rootroot00000000000000gtkada-24.0.0/docs/Makefile000066400000000000000000000003171446021174000154200ustar00rootroot00000000000000 all:: ${MAKE} -C gtkada_rm ${MAKE} -C gtkada_ug html latexpdf clean:: ${MAKE} -C gtkada_rm clean ${MAKE} -C gtkada_ug clean distclean:: ${MAKE} -C gtkada_rm distclean ${MAKE} -C gtkada_ug distclean gtkada-24.0.0/docs/gtkada_rm/000077500000000000000000000000001446021174000157105ustar00rootroot00000000000000gtkada-24.0.0/docs/gtkada_rm/.cvsignore000066400000000000000000000000551446021174000177100ustar00rootroot00000000000000Makefile gtkada_rm *.html *.info* *.txt *.ps gtkada-24.0.0/docs/gtkada_rm/Makefile000066400000000000000000000004471446021174000173550ustar00rootroot00000000000000 MKDIR = mkdir -p gtkada_rm: docgen docgen_clean docgen: $(MKDIR) gtkada_rm $(MKDIR) doc_obj gnatdoc -Pgtkada_documentation.gpr --enable-build docgen_clean: $(RM) -rf doc_obj/* clean: docgen_clean $(RM) generated.texi generated_menu.texi $(RM) -rf gtkada_rm/ distclean: clean force: gtkada-24.0.0/docs/gtkada_rm/checkbutton.eps000066400000000000000000001017131446021174000207350ustar00rootroot00000000000000%!PS-Adobe-2.0 EPSF-2.0 %%Title: /home/briot/gtk/GtkAda/t/checkbutton.eps %%Creator: XV Version 3.10a Rev: 12/29/94 (PNG patch 1.2) - by John Bradley %%BoundingBox: 268 362 344 430 %%Pages: 1 %%DocumentFonts: %%EndComments %%EndProlog %%Page: 1 1 % remember original state /origstate save def % build a temporary dictionary 20 dict begin % define string to hold a scanline's worth of data /pix 228 string def % define space for color conversions /grays 76 string def % space for gray scale line /npixls 0 def /rgbindx 0 def % lower left corner 268 362 translate % size of image (on paper, in 1/72inch coords) 76.03200 67.96800 scale % define 'colorimage' if it isn't defined % ('colortogray' and 'mergeprocs' come from xwd2ps % via xgrab) /colorimage where % do we know about 'colorimage'? { pop } % yes: pop off the 'dict' returned { % no: define one /colortogray { % define an RGB->I function /rgbdata exch store % call input 'rgbdata' rgbdata length 3 idiv /npixls exch store /rgbindx 0 store 0 1 npixls 1 sub { grays exch rgbdata rgbindx get 20 mul % Red rgbdata rgbindx 1 add get 32 mul % Green rgbdata rgbindx 2 add get 12 mul % Blue add add 64 idiv % I = .5G + .31R + .18B put /rgbindx rgbindx 3 add store } for grays 0 npixls getinterval } bind def % Utility procedure for colorimage operator. % This procedure takes two procedures off the % stack and merges them into a single procedure. /mergeprocs { % def dup length 3 -1 roll dup length dup 5 1 roll 3 -1 roll add array cvx dup 3 -1 roll 0 exch putinterval dup 4 2 roll putinterval } bind def /colorimage { % def pop pop % remove 'false 3' operands {colortogray} mergeprocs image } bind def } ifelse % end of 'false' case 76 68 8 % dimensions of data [76 0 0 -68 0 68] % mapping matrix {currentfile pix readhexstring pop} false 3 colorimage d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 000000d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0000000d0d4d0d0d4d0000000d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 000000d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0f8fcf8f8fcf8f8fcf8 f8fcf8f8fcf8f8fcf8f8fcf8f8fcf8f8fcf8000000d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 000000d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0000000d0d4d0d0d4d0000000d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0000000000000 000000d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0f8fcf8d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0000000d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 000000d0d4d0000000000000d0d4d0d0d4d0d0d4d0000000d0d4d0d0d4d0d0d4d0000000 d0d4d0000000000000000000000000000000000000d0d4d0d0d4d0000000000000000000 d0d4d0d0d4d0d0d4d0000000d0d4d0000000000000d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 000000d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0f8fcf8d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0909490000000d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 000000000000d0d4d0d0d4d0000000d0d4d0d0d4d0000000d0d4d0d0d4d0d0d4d0000000 d0d4d0d0d4d0000000d0d4d0d0d4d0000000d0d4d0d0d4d0000000d0d4d0d0d4d0d0d4d0 000000d0d4d0d0d4d0000000000000d0d4d0d0d4d0000000d0d4d0d0d4d0d0d4d0d0d4d0 000000d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0f8fcf8d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0909490000000d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 000000d0d4d0d0d4d0d0d4d0000000d0d4d0d0d4d0000000d0d4d0d0d4d0d0d4d0000000 d0d4d0d0d4d0000000d0d4d0d0d4d0000000d0d4d0d0d4d0000000d0d4d0d0d4d0d0d4d0 000000d0d4d0d0d4d0000000d0d4d0d0d4d0d0d4d0000000d0d4d0d0d4d0d0d4d0d0d4d0 000000d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0f8fcf8d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0909490000000d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 000000d0d4d0d0d4d0d0d4d0000000d0d4d0d0d4d0000000d0d4d0d0d4d0d0d4d0000000 d0d4d0d0d4d0000000d0d4d0d0d4d0000000d0d4d0d0d4d0000000d0d4d0d0d4d0d0d4d0 000000d0d4d0d0d4d0000000d0d4d0d0d4d0d0d4d0000000d0d4d0d0d4d0d0d4d0d0d4d0 000000d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0f8fcf8d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0909490000000d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 000000d0d4d0d0d4d0d0d4d0000000d0d4d0d0d4d0000000d0d4d0d0d4d0d0d4d0000000 d0d4d0d0d4d0000000d0d4d0d0d4d0000000d0d4d0d0d4d0000000d0d4d0d0d4d0d0d4d0 000000d0d4d0d0d4d0000000d0d4d0d0d4d0d0d4d0000000d0d4d0d0d4d0d0d4d0d0d4d0 000000d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0f8fcf8d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0909490000000d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 000000000000d0d4d0d0d4d0000000d0d4d0d0d4d0000000d0d4d0d0d4d0000000000000 d0d4d0d0d4d0000000d0d4d0d0d4d0000000d0d4d0d0d4d0000000d0d4d0d0d4d0d0d4d0 000000d0d4d0d0d4d0000000d0d4d0d0d4d0d0d4d0000000d0d4d0d0d4d0d0d4d0d0d4d0 000000d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0f8fcf8d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0909490000000d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 000000d0d4d0000000000000d0d4d0d0d4d0d0d4d0d0d4d0000000000000d0d4d0000000 d0d4d0d0d4d0000000000000d0d4d0000000000000d0d4d0d0d4d0000000000000000000 d0d4d0d0d4d0d0d4d0000000d0d4d0d0d4d0d0d4d0000000d0d4d0d0d4d0d0d4d0d0d4d0 000000d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0f8fcf8d0d4d0909490 909490909490909490909490909490909490000000d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0000000000000000000 000000000000000000000000000000000000000000d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0000000000000000000000000000000000000 000000000000000000000000000000000000000000000000000000000000000000000000 000000000000000000000000000000000000000000000000000000000000000000000000 000000000000000000000000000000000000000000000000000000000000000000000000 000000000000000000000000000000000000000000000000000000000000000000000000 000000000000000000000000000000000000000000000000000000000000000000d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0000000d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0000000d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0000000d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0000000d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0000000d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0000000d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0000000d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0000000d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0000000d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0000000d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0000000d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0000000d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0000000d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 000000d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0000000d0d4d0d0d4d0000000d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0000000 000000000000d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0000000d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0000000d0d4d0d0d4d0888888888888888888 888888888888888888888888888888888888888888d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 000000d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0000000d0d4d0d0d4d0000000d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0000000d0d4d0 d0d4d0d0d4d0000000d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0000000d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0000000d0d4d0d0d4d0888888000000000000 000000000000000000000000000000000000f8fcf8d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 000000d0d4d0000000000000d0d4d0d0d4d0d0d4d0000000d0d4d0d0d4d0d0d4d0000000 d0d4d0000000000000000000000000000000000000d0d4d0d0d4d0000000000000000000 d0d4d0d0d4d0d0d4d0000000d0d4d0000000000000d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0000000d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0000000d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0000000d0d4d0d0d4d0888888000000c0c0c0 c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0f8fcf8d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 000000000000d0d4d0d0d4d0000000d0d4d0d0d4d0000000d0d4d0d0d4d0d0d4d0000000 d0d4d0d0d4d0000000d0d4d0d0d4d0000000d0d4d0d0d4d0000000d0d4d0d0d4d0d0d4d0 000000d0d4d0d0d4d0000000000000d0d4d0d0d4d0000000d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0000000d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0000000d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0000000d0d4d0d0d4d0888888000000c0c0c0 c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0f8fcf8d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 000000d0d4d0d0d4d0d0d4d0000000d0d4d0d0d4d0000000d0d4d0d0d4d0d0d4d0000000 d0d4d0d0d4d0000000d0d4d0d0d4d0000000d0d4d0d0d4d0000000d0d4d0d0d4d0d0d4d0 000000d0d4d0d0d4d0000000d0d4d0d0d4d0d0d4d0000000d0d4d0d0d4d0d0d4d0d0d4d0 000000d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0000000d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0000000d0d4d0d0d4d0888888000000c0c0c0 c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0f8fcf8d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 000000d0d4d0d0d4d0d0d4d0000000d0d4d0d0d4d0000000d0d4d0d0d4d0d0d4d0000000 d0d4d0d0d4d0000000d0d4d0d0d4d0000000d0d4d0d0d4d0000000d0d4d0d0d4d0d0d4d0 000000d0d4d0d0d4d0000000d0d4d0d0d4d0d0d4d0000000d0d4d0d0d4d0d0d4d0000000 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0000000d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0000000d0d4d0d0d4d0888888000000c0c0c0 c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0f8fcf8d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 000000d0d4d0d0d4d0d0d4d0000000d0d4d0d0d4d0000000d0d4d0d0d4d0d0d4d0000000 d0d4d0d0d4d0000000d0d4d0d0d4d0000000d0d4d0d0d4d0000000d0d4d0d0d4d0d0d4d0 000000d0d4d0d0d4d0000000d0d4d0d0d4d0d0d4d0000000d0d4d0d0d4d0000000d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0000000d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0000000d0d4d0d0d4d0888888000000c0c0c0 c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0f8fcf8d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 000000000000d0d4d0d0d4d0000000d0d4d0d0d4d0000000d0d4d0d0d4d0000000000000 d0d4d0d0d4d0000000d0d4d0d0d4d0000000d0d4d0d0d4d0000000d0d4d0d0d4d0d0d4d0 000000d0d4d0d0d4d0000000d0d4d0d0d4d0d0d4d0000000d0d4d0d0d4d0000000d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0000000d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0000000d0d4d0d0d4d0888888000000c0c0c0 c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0f8fcf8d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 000000d0d4d0000000000000d0d4d0d0d4d0d0d4d0d0d4d0000000000000d0d4d0000000 d0d4d0d0d4d0000000000000d0d4d0000000000000d0d4d0d0d4d0000000000000000000 d0d4d0d0d4d0d0d4d0000000d0d4d0d0d4d0d0d4d0000000d0d4d0d0d4d0000000000000 000000000000000000d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0000000d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0000000d0d4d0d0d4d0888888000000c0c0c0 c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0f8fcf8d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0000000d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0000000d0d4d0d0d4d0888888f8fcf8f8fcf8 f8fcf8f8fcf8f8fcf8f8fcf8f8fcf8f8fcf8f8fcf8d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0000000d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0000000d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0000000d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0000000d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0000000d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0000000d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0000000d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0000000d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0000000d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0000000d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0000000d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0000000000000000000000000000000000000 000000000000000000000000000000000000000000000000000000000000000000000000 000000000000000000000000000000000000000000000000000000000000000000000000 000000000000000000000000000000000000000000000000000000000000000000000000 000000000000000000000000000000000000000000000000000000000000000000000000 000000000000000000000000000000000000000000000000000000000000000000d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0 showpage % stop using temporary dictionary end % restore original state origstate restore %%Trailer gtkada-24.0.0/docs/gtkada_rm/checkbutton.jpg000066400000000000000000000037611446021174000207320ustar00rootroot00000000000000JFIFXCREATOR: XV Version 3.10a Rev: 12/29/94 (PNG patch 1.2) Quality = 75, Smoothing = 0 C    $.' ",#(7),01444'9=82<.342C  2!!22222222222222222222222222222222222222222222222222DL" }!1AQa"q2#BR$3br %&'()*456789:CDEFGHIJSTUVWXYZcdefghijstuvwxyz w!1AQaq"2B #3Rbr $4%&'()*56789:CDEFGHIJSTUVWXYZcdefghijstuvwxyz ?*(qhԐn>!yu XN-nż~=sA+ZV.l˵*M 6N(uhUiY-)@*rz X]}Ho#cs< $"rݷ [i9:+"hӤ/~5g_%)eS'j22ySHk I6IU^g9QEx0* ``:xA۶;Lf_&!A&!5+8Ϣ˥G5`V6y`u;iEr7z&}5쫦Ŀ`0ۤ~pҲ2w1})yV ʑ=ˢWJۂsutP#:&q v Ƴ.O =%VZd` {b6VQE実jW0[73E<Hfc?VWi51VYN2A L|1CTcxu- "3Tvwpj6[F#r8<z1G&>HӺ#I@"=Yh$D}H(3 Ǥt_Uc=#j4uc$&ܨ!s;cj4lV9\) ˁ A;qʎAvҢԖ[as[ىf9'ut(((((gtkada-24.0.0/docs/gtkada_rm/checkbutton.pdf000066400000000000000000000112101446021174000207070ustar00rootroot00000000000000%PDF-1.2 1 0 obj << /CreationDate (D:20040115155810) /Producer (@\(#\)ImageMagick 5.4.7 07/01/02 Q:16 http://www.imagemagick.org) >> endobj 2 0 obj << /Type /Catalog /Pages 3 0 R >> endobj 3 0 obj << /Type /Pages /Kids [ 4 0 R ] /Count 1 >> endobj 4 0 obj << /Type /Page /Parent 3 0 R /Resources << /Font << /F0 8 0 R >> /XObject << /Im0 9 0 R >> /ProcSet 7 0 R >> /MediaBox [0 0 612 792] /CropBox [268 362 344 430] /Contents 5 0 R /Thumb 12 0 R >> endobj 5 0 obj << /Length 6 0 R >> stream q 76 0 0 68 268 362 cm /Im0 Do Q endstream endobj 6 0 obj 33 endobj 7 0 obj [ /PDF /Text /ImageC ] endobj 8 0 obj << /Type /Font /Subtype /Type1 /Name /F0 /BaseFont /Helvetica /Encoding /MacRomanEncoding >> endobj 9 0 obj << /Type /XObject /Subtype /Image /Name /Im0 /Filter [ /DCTDecode ] /Width 76 /Height 68 /ColorSpace 11 0 R /BitsPerComponent 8 /Length 10 0 R >> stream JFIFHHXCREATOR: XV Version 3.10a Rev: 12/29/94 (PNG patch 1.2) Quality = 75, Smoothing = 0 C    $.' ",#(7),01444'9=82<.342C  2!!22222222222222222222222222222222222222222222222222DL"6 !"1AV5QTu2CaRq ?J]r5$7TeJyu XN-oao Ӂ]dpy|[!y2f AqNn;  *6o-pUiY-)@ފ_[.,zRCyHi%a/'.?۳)n$&~[L=x՝|,#Nܞ+dloiR&%fD{i'Kt'!TX/JP*FC-!aCe:n#latI+nrfX 21 `xm:O'6fJ{8ܟ[Z">2Iw‚RǑiZbR軼ڽ6rvt6Oa܁8Ǽx毽QDX~*hZe: ozc6qh&yǦ=|t_5<>:/Ag ;F8>E`?:[]Ay KEH9FR?* qxO8ǼxU>\>grTf@8+O%â .Y`^FNeWQDX~*A>+Yfu;W({t1lWsU)le&l*N{+}]gp,.⸋6N*.+xPE];&v{[ոC1.O$ `">i/=PfsG]ͅ?E%ԆRA='+gG{vEwYm1C3\)JCv7|O42௥^}is>VۦV i^*A!Va˱'K{LxŬic33V> stream JFIFHHXCREATOR: XV Version 3.10a Rev: 12/29/94 (PNG patch 1.2) Quality = 75, Smoothing = 0 C    $.' ",#(7),01444'9=82<.342C  2!!22222222222222222222222222222222222222222222222222DL"6 !"1AV5QTu2CaRq ?J]r5$7TeJyu XN-oao Ӂ]dpy|[!y2f AqNn;  *6o-pUiY-)@ފ_[.,zRCyHi%a/'.?۳)n$&~[L=x՝|,#Nܞ+dloiR&%fD{i'Kt'!TX/JP*FC-!aCe:n#latI+nrfX 21 `xm:O'6fJ{8ܟ[Z">2Iw‚RǑiZbR軼ڽ6rvt6Oa܁8Ǽx毽QDX~*hZe: ozc6qh&yǦ=|t_5<>:/Ag ;F8>E`?:[]Ay KEH9FR?* qxO8ǼxU>\>grTf@8+O%â .Y`^FNeWQDX~*A>+Yfu;W({t1lWsU)le&l*N{+}]gp,.⸋6N*.+xPE];&v{[ոC1.O$ `">i/=PfsG]ͅ?E%ԆRA='+gG{vEwYm1C3\)JCv7|O42௥^}is>VۦV i^*A!Va˱'K{LxŬic33V> startxref 4346 %%EOF gtkada-24.0.0/docs/gtkada_rm/childtree.png000066400000000000000000000002641446021174000203630ustar00rootroot00000000000000PNG  IHDRVΎWbKGD pHYs  tIME 39AIDAT8c` 3H1..ba44bfMR /i0R)Mg )IENDB`gtkada-24.0.0/docs/gtkada_rm/childtree2.png000066400000000000000000000002271446021174000204440ustar00rootroot00000000000000PNG  IHDRVΎWbKGD pHYs  tIME 5hzy$IDAT8c`ʀ$(2BA,Ԋ2 pGPuIENDB`gtkada-24.0.0/docs/gtkada_rm/childtree3.png000066400000000000000000000002701446021174000204430ustar00rootroot00000000000000PNG  IHDRVΎWbKGD pHYs  tIME 2 xdEIDAT8c` 3H1..ba44bfMR /i0R)Iɑ#( YIENDB`gtkada-24.0.0/docs/gtkada_rm/childtree4.png000066400000000000000000000002461446021174000204470ustar00rootroot00000000000000PNG  IHDRVΎWbKGD pHYs  tIME 5'Z3IDAT8c` 3H1..ba44bfS+Gp3J nIENDB`gtkada-24.0.0/docs/gtkada_rm/color-button.png000066400000000000000000000037551446021174000210570ustar00rootroot00000000000000PNG  IHDR[L[sBIT|dIDATxKhkgأhR@"^"*RPx#iՂԅZ8nZ6;n BCh""ƒ;M/̷\&miҼ^̼K? """""""HKnQRC{=v&DtjG& 9z~j$\Z0GG@Ds ?Hx3"*P>6Ơi~JM?vꙁ@T@m$?&0`@T`j6 ҜQq[0OZERe6?@Tʡ6RF$`H_"*v "1|:;;]eP_~ف]eP~flxx8% p H` "159:%$Œ%K]ۛ0]q 0*\ H` "1 H` "1 H` "1 H`|;p80wS`!|=`oQq H` "15Ư"1 `fip H` "1 H` "1tڊunFOOEI{?EQ`2Λ)  Պ455Y=vޝTgl[.Љ(ŋq=|Ov;E} 2N'N't:qڵ͛rח_eI__wޔ $IBkk+͛7x)^z3gΤO6s~?>|/_Bim6L7nh4m^ʺ~ܿϞ=æMpika۷oŒr(x9QQQłcǎ{`0;o`hh޽Æ p,~e[oeee޲2ʌ˗cٲe}v~?L&Fc̝ ɄFx<B!H^D猏W[ Hۍ[n0n޼6fvcdd@.\@cciB!sD 2 ܹjnc…x5.^d,s< b۾|[N$Iƍڵ 555hhhǏ 8""" % (pict, pict) self.pictureslist[entity_name] = [entity_href, img] return """

Screenshot

%s
""" % (img) def on_exit (self, docgen): if len (self.pictureslist) == 0: return # first print the right-side box containing the group index content="" content += """
""" content += """
""" content += """
""" content += """

Index

""" content += """
    """ n = 0 for pict in sorted(self.pictureslist.keys()): content += """
  • %s
    • """ % (n, pict) n += 1 content += """
""" content += """
""" content += """
Widget Screenshots
""" n = 0 for pict in sorted(self.pictureslist.keys()): content += """

%s

%s
""" % (n, pict, self.pictureslist[pict][0], self.pictureslist[pict][1]) n += 1 content += """
""" docgen.generate_index_file ("Widget Screenshots", "screenshots.html", content); class ExampleTagHandler (GPS.DocgenTagHandler): """Handling for tags""" def __init__ (self): GPS.DocgenTagHandler.__init__ ( self, "example", on_match = self.on_match) def on_match (self, docgen, attrs, value, entity_name, entity_href): return """
%s
""" % value def on_gps_start (hook): # Disable launching of browser on exit GPS.Preference ("Doc-Spawn-Browser").set(False) GPS.Docgen.register_tag_handler (ScreenshotTagHandler ()) GPS.Docgen.register_tag_handler (ExampleTagHandler ()) GPS.Docgen.register_css (GPS.File ("gtkada.css")) GPS.Docgen.register_main_index (GPS.File ("gtkada_rm/groups.html")) GPS.Project.root().generate_doc (True) GPS.Timeout (500, wait_doc) def wait_doc(timeout): txt = GPS.Console("Messages").get_text() if txt.find("Documentation generated") == -1: return True else: # Log the output in log.txt f=open("log.txt", "w") f.write(GPS.Console ("Messages").get_text()) f.close() GPS.exit() GPS.Hook ("gps_started").add (on_gps_start) gtkada-24.0.0/docs/gtkada_rm/entities.png000066400000000000000000000002261446021174000202420ustar00rootroot00000000000000PNG  IHDR bKGD pHYs  tIME! >XN#IDAT8c`0"#ЬQpԅuk ?IENDB`gtkada-24.0.0/docs/gtkada_rm/file-button.png000066400000000000000000000174321446021174000206550ustar00rootroot00000000000000PNG  IHDR!sBIT|dIDATxw|u4 QBh"H=1H)zGDP#wrg=) "4Q*JhAHɆ3?vSl$f>c;3;;3B!B!*o(~yBKJ j@ !jY,ކy|9L3YB[? u~JuNJx=!6DmERPd@30J]x_tN$Ю6~7o=!6S0!BhZtkA@ n0˟WuB:_<ǃO,y FYÏjvHO?޽{>{#.3FHZnM&M1[,u]Zxģ8s۵k#͹XŻH8pgg,FcIBX^ҦPUUni'a}] mF.II̸wfR ccR^ܺf+m#~=観=ߺq%6[g;/p1nS*F8tf:(Ac Cp@HP>3GNl k82p:^j|-aھRol|`w"]B]b4J^KX|$ zl 0fgnJPS9}7񖒿307#%g{>@k?qBϟn2`x'g37&~|/vM`ye4o_$jr>SfX_]#wa ʌ7Y+t2'?bML :$Oq_?b&qe '-oE841ZFڮn){۹sgz ^xq vd.nw\ ttPUN3Fܱj ƹ,QAurzdEݨN<&W=|t:p;*/6t8uw-K4Z15;Q~La'O|hxYz5Š xT/YoMshb??0-܊=g=Ib߭曯yxTP$."[,e1*K{ k7%Rѵ8[h5}h2ݧ5{.tqkɑt(XZܿ䵱h?࢞rxwlGfuJc:@N:ڱaӘKDU tVFU+wF>J^X8zKə AwleQu(kCP^={d^_\!~@'3Yz<Z:T9Fo ֏;6_S*prߞ{ODSˤ_$ RB:& IcB:& IcB:& IcB:& IcB:& IcB:& IcBX=xO{kjQBnӮV[cе{rM-Jq[Nv, (=r@B$1 !tL@B$1 !tL@B$б_KAxPU".CшɬGs5t\`޽d=[HDd$[I-.RTx<222K0Lu],qq\M;Ưd2ظC aӯ?M5ːbEV,flD||DHpSJ&D|vc2fP ʢ~n^㵋TJq1*S%th2TU-usݘfv;AA2*x9w.Lhh3;{,]VBGS'e0( gϞvt9q8 а0BufطKʌml޼vnÎy]cOcւ^&55;~OǎIMM%;[dC X/+ޭ/ۯJa` <<鷜_KumoȾe* g{ r%D>zaM+pʜov0E, ק1q8n_~F?B^٤u9Iީsh>|΀A$2ވ4.p!v]kɅ3V+Fb޿w* .jOPh0/ H8N_bqBd3ܴQ5YoٖX#ztjs[j?Rza7ruLSECۘ?KX=>ΉW>xi_|/M|d27:X^cCFLD1q4k>Š Pf̘7h4WoӉ!״lKF)dRh/DUTۀ+8 'K'>2qm͑Uo;]AsTrny//}H5e<`_ςiԦn2p ½w}pLи1X @՘q}d͜r=p\+2/7Э[NNBB"-$$$dBFYkرu9vN*~u \5z!>Ю̴T' znclF<߻)Nzے|^2?t#Z8cPU7uydSqÎáSAsAA-bԩŇK/1qDBCC몘m}czۍho>D}I; ?@HH(У[/#=FPPS@ٮh9-ËLcKoLSPmʠ~R }TV1]>C}CAnK`@U P ։=9-[ԩrp\Lz˖-pTiyZ=U-9t1{EgBCðr:lB^^n4:Q@QC*>{*mCǐ{sY潢K<= OJjӤ۟h5JX$g?uAUU$QY^7UѴr?LMـ:*Odd$VbذtTU%66իWWW@ᙬ̋] t8X}k N,~éNƙ&#AV,V  ŌdQp9؝NNvH.~9:YhtL~޹2egg3|čx%e9[o.baDFU>&~߁< R4ǐQ;0 |x-V3f CX./R!1i_/wYdT+W((˛(OST8JM \nڵ] ׯ]ߣmUzT/lY6̪NOlϾ4F|~ gȲEwHS`0"33.eeeTM&u-K4C PU|}; ZEU ĕW6}q'6[N4na~,tqkɑt(XZܿ䵱h?࢞rxwlGfuJc:@N:ڱaӘKDU tV;ť(o02֫ʩ¢Gd NR_-g==q$%!rM{ʽf?ə AٶB@e~ eʛx_ke8O A@!1npA1u^ɒSa- 1_ ̽jMTue&]=in~ؚIJU #qP0{D-UWoΉʒ+m#A]U.@UŴygO0b,y{eUԕ=8 hkoИ >G [iè8TFCn;Ǫwߙt;m \!y"1ܣ5r:N={SϞ% z+jE9peU\oc۹̺6H΀MpTUiE{ ]^`u=.'! ÍZn<hTmE] ЪRT9Fo~m@:ܷķ'>Rx&Z_ RB:& IcB:& IcB:& IcB:& IcB:& IcB:& IcBh{?ӁU(~e׹|PApkDz@T˅B~*ƟP@ ofJ„&o- T*?J7~7 [Uv^j߉w@qiR)iJ0mҍ jB WtII tS9oƯN:w@Co5B\ IDATxw|UfS B zQD*X QAG{{y ]H u}HaRn$9̝; B!B!B!B!W{B!:ϟOrZQS&BQv-b8ɔ"? \QMk^Z!,9='aK>z"(3.-{7qIY[!$f4sXt"#BuK>z 8]~B.VAutf7RřBUiU!;AQ[j ZT]!wSHJd_-:4ħdpy|Dr+ oU޴YcSL%=vSN婧:πP6B!w%es:%ݛ{0֮|K?Ьc/*W )x//G !7rMeCgcpN9^#aÆ}Zv֊!.#'Cq,1'ְԩ_A> ٙۓ(|N:+QC; ~o0"!9޴}Y1OY,4OK,ެc/voZN1rx-6 sԔ=f)dWUzb޼yϩS2}KnB}XָnpO4H(Yxˎ5m`|+9_NEPwҘ, YB>vY/,Rh*ɖZ EWOKd{u>V޵s{v-! x:@QCcЮ];:ugOu^BʙʮNnߓ>!ц[D{Y̩TFTT(1͚$2M9}{ұ*DףuHSjGT %6,Biތ&U!`U|}"_K騪 h_Vhai'b 128 s0PZZ6"Lr2!]w>s`ƽ:wOzȉ~&Xhwu-Gt?Cι,Pp4Dp;+>]1 Mb֬ DOF^U._LM)hMM-E_fީTJbμ@W -=_L_Ob5"%sVɖi&I'8R'T- uzk>T,bK̙GP soGA7:/'7oOV#T-!ʍ-~Wwcܫ  ָWnf,!' Ltyy/D=Z;ke\,ۆg-KQ֘dۉl^T6vH"*s }Hj&ɣBpא.v+!=։{,`FA*octU _?J$Ru5p="~vN&gi @Vg&Y= y;;`&֡Sl6LKrõG4M\եPoܫsUL,<&3v;0ޒ8WQxi!l=Z %Y{+KQV8 p: '(Hrllٖ%Bcˮ &:D0έy&6u{27ēcZT laa(+ϯhuj]gƦDⵦ{o/.meUJ4+*9n Qhg:ouMt<ppGct'Zzd9{>̾y )({CI^nu!9O @tɂ0O +Xh,*\-wirG&p$`O+x!2ݎ:+5u7OV5hפݘs^RWz5Lay1Yc:whŒk8nrs5ʿ:=Zz=#l(DWFXҋ iΪ5C. o'TSj %ĽtN쎭}7'qjpYGѣR p hv*S61:h)p{ҩ8vXZ=$O[cc?ڹ}r*VhpܳW`%DyQV&_}!mx B˜O`0 xT%1}֬K[yx|;8fЪzZB)hPCKefx:Qܬ3>؞Wm;=ɝMq)^:t5mӪww\qNңىsAGw[e6;K1 'ni QQԏNcE TYoX~Pn=jW @ Eܳ0R& 5jnF=*M !Uhּ!Zn^wpkԨ9Μijai_FSgkT(:1D9SaB>tXuSA| B==Z'2hղEA/V-0e=&VŔE{΁#!zKnWjBqD =K*7jBм1ZB@xẔZnW auZ.=jӦ`"2<~*"1 +Sr\9L\;e Vn4iUvgSݽ>0K|L(QVddy`&H oբA.F= "CBK+3+@zo <=`6윳ߥx6g*r`t0}K]#86!DyCa=!_̶Q%"At^N2mn9ԣў]x^!6B!$d\tM.j!BQX,;/o]:S)xMq|Weeeq<;v_DFFҪU4kVDppx,;v 9)ıTyԭ[(6g>/o]:S)bBxO-NB)6m-[Ѷu4W)ٸqUV%::~AA||<7mgԭWrq8:`X].a\6gE?lr]eT/,) |h9vnBm !  k:j n5-0ضu C JJ&MXXjիW4%iVJ+wE@ٟO<vIe&hݲVK+z)!ZIH/Q"99lbժUd_6g_nK@?˟b) qAB.u0B#>e&hehn׺ͭV+iB.m3˛\ (?uzS,5.(;|zR Tϲ*޲&6T/ŕ%x>7?(z ;J8EJJ &X,LhHU*UF4_[*<B!h)''OҸqSk62 ̬ 233H8?{FT\ŗ!D!%{:]rJ25$95ӉR 412M4M# JPp5פQ&ٻvҤ~zB!spx$#/r8.rbJLÎRӡ}G"#زm3M4|TMf9Ir>_{k^+K0^$#?Y2t'РA#SS8x 5M>MRB!D-㑔ʽT&#GʝS)T{J)\~?m;BzF:* ^M>)E^XN-:z2~/ȖeSe:֯ζŃ(i ,1#:R{C2 c@@BZOۅ6BΒ@YGQ40\^f<L:0hOOŴu9X^{u8U2U_Eoeߔ;IN`P*2?ȎPy}MF=PDܻT^f>:U:dWj\8Gv7x4_(--V\q+ʠ޺3\3N~a=cfm3ئBP:<9woG~=م53+qx.c>̨+rQhC=/*? ,ۆ$kժU^*UJ 7mt v]7SR+`&N(xo*#W?c~ֈ^^Q;)|Q*KFŽL2Yg<W]O:Ƭ5㦌;L6LXuW {Gb]6֕}tZ`n{joll/$Y`$^`݆<>eRMH?Ðs*d?3.YcR&wg_)#xsFwڪsTFHn9s0k,}%Y侱οl"5kThټy{DKǧ?‚qY\DBlū)3Mb!aw/2o̍>mzŪ_Qo|^%]&̕LqԟF6WdpȤ9IJGLcZӻ8.*JU Xbn iv]꠪PCYc#WnPؓ!p/#qFren*;RI-Ks|s,Q=;Fxy4Cb⨧x;AH+hg4US +X‰`wvJIEpx;ʃorU09n7O: % ~З%no%РBUǛcqRyTkX,\ֽ|vZt4@Z ;9 (Lk&Dy{˸bm Ae28rH[{~^Q4` ڝ`bmؕC)LC 홖Qö/4>O~&_+c߹PN{|64Qʁnf*L ;J9s_msv *wié]Uu8 T&`m-v*7vm=c??̠5& j7K;~?>9FAƊ{8?ۚ`oW98 e䵛3Y6QoͿ-fQt;ui{;\g{t`s2p}Ѳ:Ffь};ouG](Nw|7i3ݻ3hu$%%y],(h(dyw/((̫Yly%YIs r(oЬio8e nRL[ WxYxjyfe,lLh~6Թ9i$֮pQ<3q)3:W"ee+3/LÚ2f@xϸi#<:?˛ZN:vkM`pE,i4F?yȖ>6gο΁DFH5KaWVތ!ހB^._82{dҏo0rmɂvf%7jj+Iyj fԞuiXl쏦_{7Ͼ hg嬟s?.C_:Ե;괼k~}4X􅍬]MӘ9s&?<+W2x^cvvfE|#GgQ ~  6-Γ9o;86Tc*etHpx,!.յчpm{[ zԡV+Ѻ^}i91^䁶g{,5.NaB:}`3Cov7OX˞h+5ܕ |t7/ _fj{Ǘ9} 1uca(u.^dq4?Yڠg{=7nO놡Z;\[+LbU/{;Jqwu)vjSV<ο^Zg1<sV=>`iJ_Xjn҈<̾:ϤVԞDEY h2B8t=nW:ySq|f\"<3:o{%c(T1Zs]c4-˥54C=U(ɪN =絟kgL,\tct3ӆa {ˋ(ԾEKRҒf/硂S%|z2񣞅V2pC3u9euCBb =_Sx IDAT?_+K >Bܻ Gh'X^<`e:́9mZ%ax;}:^Cfg͙bbY8^m1P*[}^]k\BygO>P?\hyan%+Cl6<.s œy]\m/?lU^OX\k\B(:0rϘ{ zpz .!,ߔywh͛5孷=^yҼYr:zJOy?˟bqq !,M*47/5-7^S~"}W+a6ۻ}{)ayoKt]GtXD׈ں\` =NffWafr&VE?/or]:S)WM>It]jTv@+=>e*a^TO&**cILeu֥Qƥm&DIV>JS QAc z&K&WPg?R;|zסffr>aX M7~YmWT/ŕ%VB!IB!|D-!BDK!G$B!IB!|D-!BDK!G$B!IB!|D-!Bwgv Ái:!B] Z *uJUYYY

IߤG'ٔǭzW;>XB!*s=Z&L>??KB!hُÄA5=dФ9s8a .AQlY;x^\ٻWwikIfΓY;;Gz'G,%C+adFAכcWxKJB!)DKS-ǑqcE빫ygIK= ̷ OS֥G!hHKM-cG1@V+l '=ZUNO< !B%$ZP !B'BJ!BxaX,R[$ZHukpKB!.СCQ&ٜ'+uRv)=[B!D`w/o6[tXZҤYsXgN}$[B!X,TfuCߠ!Y^IJ4 7nBuB!4qd$Z%fٰRB!&B!IB!|D-!BDK!G$B!IB!|D-!BDK!G$B!IB!|D-!Bw./ 2п>MIHH8rY*:t^z^!J/}=*Z gw܉Yk^X,iBp:+tN:Śի F͚#۽BViϽgneBؒ%ҥ+40 41MLl6[5MzjԯW%Kq]cZlBQz|y<&ZJ)_/D9N:v#vڲU+g^!JO^DK"((0{r^;`!DGKJ)#jTbyi;oʲng{c_VQգkжCۂu]uv>ﲊ&vJ)dsϰB`x6B^6 L\;qSJYrbhb,;E*U|s x]>3n6KO` |:ěso(DO@efD>XIhW;R%svʒ1I9|'LS_ƺe񯃨3{@^yæ+?bsH\(UۗUDtQdX nbOZfo%Ont#e03]7'wŪ lϞ[I׫լ֑߳|Ճ4O𳛓Z֋o!Ӧ &OTi^iӘ~ w~'[sùlG{ym`A`iQþFŬSQԭטj B"}H:ڍ>eDɴ1[m[Vc%Z<{oqt6t LFojRYf;IKp>t= U4E#D_3*#Fr 4oj_Z-0:?_zF-gR$ף$g52,0tH>\'_9=懃wsInN:^ᗤBɓ&aʔxũL4ɓJh) 빝72hI/O[2n<SV1 ?pSg#k}FN}۶3m34[7 P$.s_䳔%.?>6X |t:`p(͞bct$;N ,p`hA!'7'ӆl|}Av|s/(yD'ޣף1 ݟdFP8RjXR蟛ݜt$h QT~Oִ_f 9997*uh8l0ȫ~ien>ql>*|jRn]r1'R[K*WLF8zlqߟ -KRt8s<IF|קn[1aMI{{5'5VOg#7ӂf48o3'hVoM0ne(IA޿J9qM"w|8 ܃ӑɞOݟdftLMô۱v Sa:lO: 5ac+3f3acϸ/k]P'X9;+)*݁T(#oy;BNeMwڰ #W'J8Ӝn=,+m'JtûK@oM͑"Z]GȀL}zzg W~U cWݽ`#c|P=M~|še*<>mOuw0wWf}Z.G$#$\+;)Q(H[bѓI -'?T'^ OQj3puS͛J.I`nL-npԎ&ۿI׈u,ٟCoL*n'}uw5\ݫ#yC^/r[*{¨b w~y/}|zh^7PE;**T멬}<J%ъQ<'N2!*=Ǚ{4~*rNLS^%<,zP6/DCY8;74$csorvc2f+vs!W%-81Yyi˫!wi?2piP~Gzby]:&*V>_ϽT9lB_ %u(v/D%Ph !B$ZBxlB? 6&KƿZY |h}l_-_DK!D>%Z7:WE q>R[$ZB!w o =B!\j5q[Ν:ueN:^\kK)Dk ԗ{M.DY# B*D`姅 }>g.Ώ ~ _~).3o{>e;bFppge췵gmZ6uƥB(Dk;A?Ϟ}ywu}{3bNc{uvڵi Ş/֓#A'C~~z5߾@E/ʙ;ðX0N>M ޡjpzOTB67ZmAUrKBQ.&);F zmG O쳝M U1BReVr߹{nq8 DclVe2r+ -CWo}vh(쩊jǒsm"]ò fo9g zҪ؈]𮓩bK4wVp~tLJGs /(oO$z\ё>⾡}H;+岜4^֩O_B&tߘi|bE?{2 is;=+DŽ(.PLO֫GM٣%t"'N瞧Wϫ[6|Yy5lX4j׾{&xȲZQjW㝱MO6mGZz 50z9y( 򓐴 }l-XܟQ/3^*6X%+br+))A<7aϾz(R r(wO6 ;i KD 2 sD%즎 fe8IO<c#)."ܣ:~T(-[}hhҼW 0Md>pS4ɩH55۝ KH`Ydzɕ]ǎEIIőX35 y4]w cnlR'2pLW HJ bb8=5?lc~ӱ.6mEO9q.N.nBe;qg-O2228邻.K3eAv?{w_epss݃JV:)ACKBPi."dĒn9!cJ )Z"E fCZu?3 f Bb$JAH/,^Rq,+& +#-A! dNMʓh(FA1 TƘLc?!&ޥs j{3Br$ВMΌgԘ#RtGדΓώIڸ”ZoR5\q=ҥJ3r{"A!7H4g+28||bHlz {|qa 'įZ |ʨ^bS32"o73lXojͣcI)|zK.JAih%Z%bK1?7n+{e޼yh4R )$HD\Bć$p,(Cy曋h`1ت@X<1jlzʓ{M9c T@;4\ޙ67)YL[VCɴi%?͡KEd[8l!Bv2 ܺiyy0p;YR SMAYZ.jF"[PB0zh/^N#r/̑I x^B7 q_];_A%;w6Y~fzpɾj HRRrCұC &#*ԙv>0wX)LAx#e{eooKppp$"2ukjG ziqg#YxވVJB_=}H^%ݓٙ QuRfqJZSh6ϓs7AY,q򼖡\ 0bY:~zU;{F=#dآ)?l)j9h]Y>p{W2b,h0L>r$#%qFS˓O|$Z>}MHײArŕ108Q^SAw8YP2rП YׇkXS f.C?k7Nbu zC9>b!\/W_7v$gCK;S50~8 ʢiE y6PnKa#Sї{Z⮄KtfdxŘIrVմs*l\F-[, ö[}?-" dV;\N~K IZ8܅/;VkEXM"2+'qYXipPZNX~]pqqY,-dn0_,}w"Ϫ5~d6 xh!{\dx6-M?r,M򵟈U>R߭_ȜnFxygqxW7#ѱUh2t0Lx>Ebb`G-̞3D.hٰ"gJ BGSI$FDbS{(}/+'.s .D)^+8;A7p97 h|j#W>o%m,`[U8 q`LU -R|zUxu@~Umkt kE@@O4k7CqV 5+ӤoE-z<));wf:2 /^'W|`M*i6φ28kޙYPk/֍ˎhw+G6qhdDcIF_i0Ɖ 02X9ՙl)0rM5,DhϢ-(M@D枏o۵7v$J.% ; :a-ۿVeJyr>ϰa#Yt1}zéqpwP\Z5rQΩS(Jk *c^ JE-`ApeQ#B XO I'@RzdMV~gi *@![hSj˃(Rtتvcٻ}87cFqk2ptPd,bmך(x%I\ B[#KUz\BϳtGˆb-DFcXآ,ʺMqS">?[uB68g0qW'%HU]~/Ã8,jΫ{{ wsoQ\Ć;"d:U!1ET.p|L.](XEүoOjժdftnQ9x?t[JIsy"=~Kw`?AFő9.X_$;E{tUVʲ6*d8FH> 1źS-Kk@=^V (YKV1s6tB^9"APU|uwbeD͔"K;<I2?0Ǘ]©f%5֛J\-qT'5]S`"_XĠF>\!.$ SRץKgm* '0?_]OYtENl[zW(b.E$ϋ?Lf3WVc]o,_Pצ?2P^cD_e}t8Natmʞj-~LEt+e;Dnqzrζ֎gNԘjDQ(r_M=UҎ##YCcVSl4p.=&g $_"#RR^QIZJŲj !g~R8JMooE~IPk8Ëg!($v*CjH E=pŏCę3?=(J _DXPllw,Ո{*"p,Z bvٰzSyyװ)V8$G5tEsd#*̩}L9v}մuq=hhϭRncgUcPa_3wufGb͡&Ym"#frϫо|o:eJ,Qó2;[*SJQ_"j@|p^Pj|>{/¸\[)'_~;S\K"Z= dAУ%o(7]bwpbyz UBxg ]giV-2 Cٿ4e,(vN]&><{W#(9/8'%saj5! )Ó6%yw|ԟΦsq(z=y 7e4Т7'&2Nl#yjOfV<Mx~;, Z8Fw:ƈ f{ K^5 [qKBfnlS}X#ۏFSǔVK*{EZ=_^=^2 [ŀ̬뜽 y ϔ#߬j-%'U{-!1!3WԮs О*SvsjJnCxɲى1 O}\QA Z_ZL^G';e)-MƯ P'e~`Ą7}|[Hw'dU)B[rDuaնqfĿQM(*G;¹rj d+ш**қA\9>W\*U`ᚗ' {2!;`سPA  .lߚX3&-AAUw,+L`Ll N|4;R^5A^hլ]/;GS&sZ捣˕-LJz ?1u?HrH굫 ;~I)|zKD?1upKqV] B3 ܺ(xyйK ֨Q1ͩ& ,-9-Њe޹« N^7; ܥcMFTAqc ̾}s .fճY*T2b#ͥh02~IX,h4gY"5G7*Ƌ*G3exS{l9c Tnf8P p`y72=VebhN $ c@{?|o 6@C}Y_,OM;/OMKwȮ Bۿ$7ebAQYfÄgY@w:;d;ZDh74Q a[ݹ=c?Ǐwύ#Z+9*]XH7W{EtjyҼ} ȶ3+p~9ER''AOsZS?6߼ՉެOSc?lrT|wlI/\[-xl%ВYQ'j<)&V2w"E%EQ mk*Pm1wa nvbȫfU<[LaFpOv]7[/OVtO[VR!nu":j >o9oϝ)̎=-qWڥNgVEb˨ew%}vGeUd! ĸ<_,bhbΰ`4IbKxcρX]F1hZF>9U۵|WL;B!Vd Ou@&r֦2=NkGW592U/Þ-E-xYM="ReG`ѨI¦KftekZmp1DD 𡨧BZ;пt4 NjhЛȠS=m>U SEyg˝i_5!I@`4&Bsxj|VUK!܎c͉i@ӎ/VCYi[EAcţ$v3'.s .D)^+8Ka-ڀR*PuiÒmkt kE@@PAY.󜽒6wl*S)j2^>{s{֛_"4~B߯R,ajNj 2r$вֳzozƍk2[O hSm S4h{}r«"Şg/H4:.6(N/爔s('Y(WُµKxaXbS(;yC rUNtfb.E܁KGL`)*T `"hlD?s$ENb2 oeg`w'Gi.\-zE_z:vۇ; x:`" Hmc|Lƥ+(jw)1ҭ3ͫ:~:Æΰ+BrR _R o& yWLnztի/e*U ¿EZm_bI*y=pɓ!ݽx45C:ftDA; ܥcMFTAqS ̾}a@.4VAhqCF`$VmO>M̐.R;NK]"Xj;M IDAT!j$)ɈŒq_F{eoC%y{bh8/ݠL̾YPk[B|D޿K7+>%8ۡ<(ڟsQTL4 ~M/ޏzM B%XE^ Q)-W()W0C נ3$#ŜU˸O\pl @N>jDv'oxئձ1S|s0waE;0g>ͼ[X/SZhP)ͫ}Ə SsS)W㡳u *ف{#^ [~fz"EQ mk\RK~'Q_&1LۨqG0V;6n透r =LRHijEm,8L!"_cc8[{`|lmg k/-ޚ9YY6;os-f=ԩO )T |q Ǻ/ZtrrU> {DZ|1(EM߯/bMNoOY!C .^o^(B&S~~;b ݎ{k]+o|XO2HҙhӢ)&@RNFnB@7n#=*E"b0~F `vmhݼ1'HGSXGϷd:`vxd~,Xd5jl Q SJk7*[`S.%TqD);BEcl7`OpfUMI~XcCGpG*&,?JF19~h[|i5[t`ts%#ze/8x_3-[8.JkyKjըE~ƅxx  lz:i EӁJůԔߎ+cvq!`$xPиUb~ 7QfGe瞖+alҁi'j3淕Zg&FsId/}%N|Sj~ dV[gNy۬jۙg3]")Lmcέ۬i=/FJII8X>:Fሮ 2좮*S*uuZ P4QU#cƘcD48z1,It8flݍ_^ۮжǼ˶uMp~gFi(Lƒ3"zݯ'YCZ8yWY2a`kkϙIJy•={'.se~ U NīQ u4֜E8A ?R)4vO64roUSh}VU_"b )}^t3i.@6cA_į!&u+bn]o bͮ4cɝxtZqfzw g 5Y),Ӊmfq,(*.c60ohjw~=Ӎ  d!1=1ggpON  ąr Z6JAo dLG+['OɅ AZ ^ʰa3w—bA&-A&&[@I=]:fFyol ol,[HJJ ˋhc2A^qK-0Pagd2o\h ]=2 ;` Z[[{ 䧦IXn dFѐqGNdh4g]XtT+tpη k.d-qq {/`8@=0f ZIcɖ/ 6v5GpJ y,;$ V`!~n +2:V> dDFFf8ֿ_\\ptt@e$EQPdK$QݪW6+&Hgx5Ͱ:OXn佱V3y}c{ ΂ˍ]rGĸ*,XVn y`0`Z"՟Kg^*/iy{ m׾Ŧh3?m~-rdmqbN6}6w(s0~z 837h`/Ǔs'-p+92z qy7r7r]߅5kߡ_P-:C-g8w ĝL;Jqt$ JI諽Ǣ ɸKCEIQS~Rf'w Cy Yk&hZ,(Gۚ |r:E]u 4+Bti>> xuW-9[,f3dN ԑ,9^(hZdYκ{ *=~Zn?ghA1\gu,9۔uQ=,Q?b @h )BHȍW^J"鞆BE>t~A|rpp?= #P4815uthZ!)̎=-qWڥNfo+"M,& [F$,炐Jm-$f8h&jzݱW?c8~fCo=(&mC˚'j| &g-IBocCR,iS% `KQT*N̦gߡynaڜ--A 3ڃw_?pl]oӼB{Zí# cHs!7."F|Yq iؐB6/N Fy!>'G-NOP$_ >޾t:,,ؐ?_A*Dl| am Hڕ\9Jf"enClݏU pwOÕ[VIУV3>>w?3q)\8^Ri u4֜EzG2i!(cQxCS›(iΓIS8kdbhɢǧ'^%As\K.E܁KGL$ΦNThы3GR$4!/>,1Z7iR@?3ean\,]ғs#R]I&_1=^:)F!7dadT 6>j "<|(VvvC))DE$$sYnHdTFgqփ'=ꥏ'Y9)=.kO蹢%oKӯl9MS18ىwpo?Τd,$f!]G`:8W'c ivǗ6iJ_ǁVI:-QCZ$zb͡AO!b#6p5[jl}t?o݄͞,e{t. @{x]|QM5j`.FV*0daAW--u~n^.T*jj UhTy0KiK@r$cF=̷WѾb?͜&}s+6|^&5|qdQgJq|.2ːGJAF!GR$J^mt[[U̱Ѧ˻X)ߔu^!wdKaZłZFeEFEb IfdBѴI3t=ew=}'̸T~]pqqY,*} ϲN7w;xk)C{qsWη^8 OJIlZ<>>lkV/]dNOp# H(h,[[!az|TQ^m.Yr:+&Ey{9+VE YR\]\~7Ѵ\J2she^?Ӡ|Đn/yqOdmCuiظ!ujrǔ/Hjթ^*+b 9$99єa ؋>|?_|;w|DqmZ4yj:Tͱ{8mDy)p<ҵ 0"îoөK:Ս%{4y(@Zvŀ>÷Z0!˲qhvץ:όDHU7MFCҎ~P̈́8qsقʡ4U9z> FnIű%G(bJ$AvA"6UYrKZH, rI@Z8زX,X$ I2c43}m/@I Ύc=r_%rMD={ Ǣ4=aWu󱟰ϓvz|=_LLKթ (G"0qg멟b3!{[YlںmkPK ss6azVNA=#,Se uel޺vg/|_Am͓$hqɗqXaՉe e1&:xv-sXY*k=Pd,]8RhYF$3f Yy(H gδ lGM0$hذ m?~ШMYGZg5]QS2z/,bPn#Xd=t IDATBz{1sJ]J.Y}rOa~x/կJ Gy3E^!qz.J)5zz|yZӇ&)%>I!)̎=-qWڥNgq 3{pG4#.gtrX̢Ἷ70 aޣ:jfļ5En8}^ұh|[+'X.%tl,\\;λS+ z7r'm[~.!e U۷qȷe4_!+=ECݶ3$a!pk_! }I8rDn,i̽؜/ػ]BAȟ3Z?FmgqTUjd2j6LMK#N}hN2u#gz9Eɹ~$Gg9{-z M~ٝc-iR;{z!gd]6OsO+ẖh햏S)Bqxh0 $Ibyϫ$+RوI'>>9zv/L!>0&d Iɘ,;^'l_? .Zf^X |@ ZȡE'%gĪH8QLԄCEcմS|3j& K ~⣖g]՗v7eo2Nr:εbH~ێhGYj(*(*Ȳ$IXVÉ޾!%)7]6ƍYڻ#޸( ,*ac4W^qb]*z<՜ܚa^`uנ >ٽAxL`O~n/6ۛco(#Y!Rĕ))ۋUI=U7Y'_o֗4a|5ӽ"gN=.~Ĕ=ٰ-9fEt1sA:unܸU;Ym̊-ٲ=dEFmVrr^^e+zv/y#iRG]G??S9$t 4@M䲡jPFaԭ]6oEŠrZԪUU]ۼB>ev\\\Yߨ,ŋ'9+gvׯ_ Yj6Q_nN|tWuF2/1rV>ц5{2[}g輅dk,F",1a 3KXSeF.EJP]s{%ZNbޛȤsf)n?g͔p|u %_K O=܋-ŭxG9ۊtVArxuDeA@Fu?ْeY$+f9K_Nry{1lm^_vED^YQ8ck?Ж这WWI!ru*11=)ش)uqy+ҮOWa7{m},c2:o_Gy ߠ5azJ¥;xvݱ`7c:Ixbq.u@zc*CڍhXK£K**"*~?%gђX5Yt fA3z)c7~$EX֍ϴ}w@qFT4=Ŝjq;`qov}w)ŭpa&%B<+y2> FXSIKӘMUYV޾E[){貗#<1&=rFםޫ&UU3չ:|kܐGbӻ5.m=/ݙss{iAG\Xg*pyiktlA-B6ٿ6帽҆19 !zЍ|Pn{l$LJW 3]&5\a %_-EEɜ<ْ x8-[byHRI>Iz|+2nf[k}mt;|2tђ7J0kbKGٍÞ4:-I,tٱ :@_3Qk2~#<*ƽ/R5VBǮ"#or7=vln:LK=.}p'Irl].ō4ZMF<~tAO3]ܝ HcJd U&VRC㷯LqKҮkӶˆ}׸Unnn\}װ(0TeH5J99Ȳd6PT%Lm#ZYY;Kt4Xn\c?".)0罙J$@:cod]2Oo~_ruȐ LofB4.BU0t?t`^ ]AkrGw'4\Nupv$/4JH:HW譵{׾h SqC?ry*Z>?0qb*t*.c!BQ"Rl?ލͩ kOq,]BAȟ3Z?FѶSvGUUV N&.nԴ4R>z'Jvú1[joۏ,G, GktCGZwnf(I H)$)O߶7Ff ,gUZ5q7^%7]DKkwyʽi{̈́)_Iuwsc[v1!,{3Gk|a,c6G)l1 5ߜCd BXNΦ[ŜMۇiX˗joVԢ?qJtēiR0`Z՚NM>dnh܏u*obN8бtj􆢱^h0\8tx?wk`m{!3$Ĺ)ɶsI4vZFjA"7%ȱ/P_*s7Fy` qjF )pcmMfUaTЂω?oaa8!1PQv1՚:C@N^Qkv3ޒ2p N@l -'Dڒ^KRg#& vX=bv'\tfՇ03@eNP :RX4w>Y2UaĢޞqfTՙRjTU\9i'1q-R TzU[.}C[1iTdLo_Tl6mwiKA7܊; @bb"gd̎ҥC ==A%2Wqimiz1f?qr 9%Ávwhp)ہIk;Lш%4ag@v?.Q]|>}a [AYhr12"mW7\]m.h5Z$c pt$ZmZU+9h4Ӿ+ =U5s)/frX1Sy߮hrD1WŔ//`;re%c hOdYF$$Ɋb ^GF1l];I1H׷3wcVHgF`MBVũ\jՠ/gV.0]kQ*z {zZ'/|=hP}p1y\ĚHM'Jg+w.'bؗJ~Ci*;Bӹ-E$Zj"ɜ<ْ x8-[$al""[Ѣ鋼z#AMƱfDeoU轪Q9o&3Tu3eU&!zq2q΋f ?6P:nsf)\%k46A٣K5>>ib<Ã'^{O̷v IRCk|z # xL:C] /LFNqSwV<[Jx@ǟȟANJA,8%OuߴyW/:MȳιWI3W5ݸ~ȌcGx猖"CQn6և}d 2Z//ɏhw2 2>+uGFKJWǬ-q~\N4:-I,tYý3iB ܀8wjy_\‰qt=J:[I n#F3hdHi|2^h:IxGAF'zM 7Dz![EcnK5 lќFc)O8 =yTHPywMY7 lXiȒ-96{RѠ(YeHvSXr%+W~61CQq=Axl*I$z27?OS5 J<쪖̱zHIhH$+69zϩ=|C4 X|wi5Z FA7`29ꆻ{! Ϸ0E)U4eBʡ^ 1t yo_VIŽq]oZقATpzT\CߘRaeqzB$ꏦps[9c Ix DX31:KI ]%43T4wrvF\޾@/3w-/ۯQ~ te ?KwiZQ{ciPu&Τt|hR0}I8rDn,yQ((2:9db\@Da4uމ]nDyG9a 9:V psJ3eLɜK!W{v/8Qkj$\9c IDATRZLK@܉ΟSZT6DqܐrWe΋Kq#[I F`u5Gl:ރ%6&`U|06'8Z?T-5qZ|?31M8iUoיԣ4Nmw^I5Zg :օhN"gyh3;ޢOqSxwѸeӗ Y,ߠOc \mReߙ`17} 799)8SiB&ecތm:Q#j\s"11cBB}Ud8?VAՒnNc{pYJa4*ER9342\odԹ$uA:HW譵{n#XsIݝxpM:KfQ jQtujǐ5Y<E fb6-ђ[~1u=M Cﯷͼ }'$bvo`bBh1P,yo,%ڷ9=}Ɓ23>(3)| JdC+R.MR:}6i20)W|iDGQ> ƒW}?p6[H1ibj z=-<{i@x㑋yu ҽr=}Y3~SWb݋T3u}ƩƯ].'Zf+V W7zt߂JExyy#2qKťtvz8&OT afBc9Na1h\j9AKaqL`޴SнfB/Ѐަ ^ߧYF#n_⭯?%R2HGbi*ުm=qMT)r ⣌~O50p@*Al9Y&*ϼIzT]^Loα)vg2MOpǙz)d6qw~i<^" ;idدe9ߺX|7bX(^!ʠ*NF'4ۘ;r-b\pK n݊+] ͒iުͽZ*W`4~Á}{OkE[[rޗ_pСs :tsuK={_- Y$QO%ݜΥKؾc-"[RAAp|($4>1 V܆c281m;iggdYFբ( (* 2$aZJ /6'zzt3 <6mÍ7,{wG<=qwwCQ$YFUUTEah^ }/C{ u[4Wk{R4˧:z,sf;IW 䛿0w",WMo7b蔱6fŖl"#ɶd+55o_ⲕg=;nW$z<7wP4dbކ3ږIॎ}25L\.#mkl\ )ƤQ4EFu<%%_Ѭ1lp0Kb&3ޏF*EX֍ϴ}w@qƐٌ) J'r3(%RN/Ŋz )aExV:e|Z2sD4.%*Sf>jr>4)Tս<}SƎ,\:eWs Gq\=9SiSsPOQ^L PӴT0mT!_$GwR,[wM_!{jF:m7q+-g@MRr-L|l(bPiCAYsDeA@Fu?ْeY$+f9Kj/]an~'uXk G/օ2Hto<ԡgZxJliGctGŠ/LcXtcmt;|2tNwۼ[>p?gzT/^kMR~ep)l-:-I,tٱ  5#ٰ1yQ9:ZGįefӈ~t=/c9<|Y=Yy'#d̚H֝Ʒ+NJ-HQ)$t &C1k6}a} |n [pD{H\SkV#J$ 7Ȋ(%Y3Zr-ɊjAQDj?x|T'dsi%2,qpgvǺeM%]?.Mc*k7Va}RVod}X;Kt4Xn$ ϝƽx@ЊhJ7T/y\JySGnјƩ8JϨTzh W]ŷNejDr8:SPJNӷU A뎟ędž3P=t8.kHHF+/ѬY ڼ\E$YBky||s4._g̬%KN55A^WTXɓ-ɺ ӲuZ,[[GFKJ(-qe7nR{dim@X}gjdVF5&y8Um )f9YMzб zKZZJGwd9Qcwv=ljP V\D$.|=On ffY2wosqLUU4v꘲dڟFGp̓uʹ Vi;ề4Y$@Ax߯Tz?Z~no\/XҶSUYP݆wdmcSn a2]"#hޛUbqqikWjDG% =do[y9vp9[z`]ɨ> aޣ:jfD;_K2\7oomǬ/jw:HW$oLT-L$PRHH3SmSmo͍͒?24kY:ϪjLIoT q!(or4j0 ;l.:3Cv(81ƅoΡ;p+(ң)B. j R+*vZÊA4i!!XE:^ǗC!y*D^23;mp$ZJO{AȉK޴SнfB/Ѐv\닭R8c_"#xesFVrL-Og;ظε"ቖ ɅC|')W1ooF7BsS^mSi #yo\PҿafxsIxkFK$Q~W1[cHW#7ZH)'kh2 V xNyK w1(yjM6.h6n5ܸ|6hw=A-,Á?j|i7_y-vmӁF*f.fKqM;(kȹu3Ͻ)+5%kwd,um\o#'gS^Qkv3ޒ2sxOWk:x^g[g2hw`sy= hi5 zw?oAb^-ʡE.u6b l7#rjQDFWaqLi%򈊛0bH oO83L|5*.hpƴ޸Ǔ*-HG4*UC`X/*.EJfݽV3mi霝]"?5`b@ TȀNt=W!8fnlrw 113g\fG!xzzFHvn`Ȏ+bYZrjdjEgl&`0ޟF#hunkOhh(O_XqO3[-_AWD\>v-z9< c DedE_t#.n8ڞ]\jH CAȇDMv|j%UX??ڷ{AAp'Znnw# #F PUAAD%0u':}* T`7 F BA 8ӧ0GSSr D%bs9Șr/7^1zyM`S¡_v8xAȕ dfRR2&T!&^nbF4YưXlܸ ^S TrhUN}G/hZszֻGoCJt:|||$]bI1xurzd Sx?˽M~ٝcCglyMT|#:wEL&Or_u1Rx&5?nѸR>xF@MoagW-AG3ep=| |h1fkcpbB;+ : ¿Ԧ{qFe7n($˨(lիW"};:aX8n=rdj5 U+qgtt9^s)Op[>Y3a&wa_|z-KwH/?֝:ROnZ9:0w}/JY2hG@̼ͩډoW4WȂWg}ޫbpv>=w)cr sƎٖWz^}]ŋ?s1;: 7H+ٗЀ&ZH?[D(7XԊ5f[Yuˇ"A%W0H:1`G^fÄ\II\>7l!'T't-^˻k4&Pf5u_gփ9"B՟)g +OwX+>F))s,MF_0ΩHGJ&IqM3bK`wt*SPP+?IUUbcO?>uT3<0wLc)vES72L$:;xًxL<'1|+._w}עϱ%:oCpv$}""") 3ȕ;SR/sg)Je۟7U3z=G=I탋Y·8c2孒h"fuIXgĚHfo+|itUr  O̍ܐ$k+5Tswr#)Vp7C-k\ųZY:Tjd !"7ϊ$K>6Ӝzowg\WFY z-ꭃ8ϻ*Le+t :e2SvM])!yF0ط $;C_ !gh=WKKKyUqSvڇGahar*n)n Kxo Me.BS>,؊?w`Q[՛of; v#9& _H$7z Ir^bc'ig Nw1..ul !{N7HG_W+U-. HS^}eN`6[HMM#z6mw;=6nϹzvaESf-jժA_ԭ\`aIR "B~$,RY=o!'uO揯 s#Ar{6.Z̘7%zGds; w(q WrMiPu&Τt|hR l^=W$_7Ҧ~mWJW04}7#[ڗ#'HT+܋iUp%}bW_eW R Mgq^.K,"a3hꣲp#eۄk_ ,u->aoiP:^B`puFV4xӕ\4cq8U{-ln M:QTkyPAȟWH Hi?N!9 S`J)G߸"|}-}یN図TiڝS^bE  9'{tz4؊ +fɋ쭪.>|9j:n/gz W c9Na1h\}vнfB/Ѐ/h(`v'\tfՇ03@GAt%3s3GXΪtϨ꒧HA@$ZO+C@v9XDimE-'` IDAT f7^ѽ)+ݽ.+kwd@qinfvo7aWX.7cZ^^^]A$_-q_#&SA Ǻ*44Wq5/&SAw9<C T#mCQlϨHV)ci_ub2uA( f<+*fBL. 83޶3;ΝVqeiǜ[a7ɜ5;IKLXGXp!}%((4֮]ˈ(L]O\ƳbGl;fJMy-]?LkϞ;]]?30ݎ?_ -Xxwk̏_f> CO&A1w?RL {>>>'x)|N6D$eLks_q/8v#bj'ϫ#<}uｓN/vE QnK.ʫ"554~,+VZcѣ-))y:$D:_ſ~?uU̟yO3!*3'=~<"'׫O?gi,KouӮMf> MKiP4#Nb^L/1nѷ|l_֌'4f["FFhIx*j֡<}%꺷zS0`@F΢Eu饼 >fuOaCTP"͗Ov%r'3BxF`lXds/2xs3=ˤksrٗ&^Nޭ)Pv VA | h%Jؘۙ֝ǥ&u 'ϫF.O_NUUfSNeY7f%NE+M^'3Bx;\awm]; `-\y^JE 'µ3 *V,<7۹xZe>\c?%ׯyUHUO_/|y]d͡w -#_7yjKPU|>{3z(*=\ݓ#/[siy<"D2HNœ{ ڕNH`9iIf׬<` .t@@J!pAbhԹI$hCX&~>KstK)%ĝwgW{ )}^5=]O_BshrN>̢Fʸq7wjo2u0 g7dƜUBTJWxe9&ʕk}?w/x].{Irӭ:iK &MB}WgzT?so_HHC( l tS(xƺ:'S0F`H) !<ɠ1k{;Њь֦3׾GƣdϷMJ@WRz)`,/w ?5}^5ɱcxV\o3K 39 c[7Yh)d _C!/gjx!Vaa q ֟Y j ׿ڹ22vn%^ʟK5}^5G-׃9zC.YlS>V IȄ۹ ~t{OBBTPC/:DGɜm;qo`L7<7S ~+QhޢZz49u>r_&SB_{֟'CUzJj73.3&%9RqwUp5;..[6T{UU [4oޢ^!j~=ޜ _ i|9;BE-ZEv<BQzS!I%B!h !Bx$ZB!"B!xt'Áա UUXxyyk{}h2t]ȟNx(f/=VRNN驩?AVf9/(7it9'}h2.ǏcΝvu$UU cǎ4oZ#z$r:dgfr:uBXx8V$ڽp:KEb_*{! ]IHH` t9[mp\>7WD448{$r9;~.] 0tn':/hFdTwnP^b_*{! Cپm+EV]jҦ]{4uk'HeYYYan\MBBBD-c'g'BQiJ]Btt i\.|j<]5L@4 YaQ5 }${! 0va֭]Um}dV+aXCݛ -*Db/܅([}ǟo!i8$B!Dle"*Eb/BԺ޳Ӊ(l6:tPUB!yȣVAGt:С9999r似V[BQ9i>H5>ƧAwWNW}0U'BRG AjQeWݬG8(iu3U/j>=k?k~~벥z G2=BfoXD 9\v=-Fȱ2oT{bbbaиY 1-sߺI;kT牵xCLLa4Z57A))) 6aÆNw7V嚕Nx"9>WVsf9U?ʪۊ>W"\50{8A>Ͱօ: !DQ^H}o X-7 ;-  `wLsKYeZΫ8n)g֛?qۛ=ks2.ZjrvSRR>|8 6%KԩܩIIQ0tmQ \f^tzq ''/oGWkr9g+tTCG mKMlf>~N2pDZV&Yj ] r8k+ ,ڞ8︺\F Tށw^o]Qel%L__~:̢YŕX^&!qZzn׽BI/ӦM+NUbjG-tzn7n ^v&yO n1Mfڏ ;kӞ it6 t;MϝT&Y,fPϗwi4\:x7 S\\ʆh:HibSTGv7i`.n0LL##ӉK7'HeDz"MҸmTJ,'59B1BOq]C_̕Ik Y$Yw[4\ ~:-t;=Áhu\?y!| g.'Ȱ˥ڷ1XZNMңH-YE(<we,t?B9QhEb_YL pȑ3Zl6[t$%7'C/o:'69i#> g LG*I9w7g{VJ< VpJgߐT(=L=L?OwH6=7p7mCn>mvM[N£Tv?^hApˉNZB:x7OՄl~'7G/gfZy]7lD~dCp57?uxqLa!{&UKmE]3 Ѭ墵o*&=8Wo߹bt̙ԩSO:4 3grm{vO)xOu'AJOpp0 |wu]G6Mt]GUUE0b#<% խԡ?O!0O=2߯M EۛuXJBQGNa|dժUڮBQ1ҢuN1>z Q:B/u!>ƧAh !N[[W4^!qn1>KU%'; QsO#^!*CUUNO%#j׾cQ?a5g$ZOvv瘸H[NN6Q6{(O2E!88$"""j: ^rra5lyFtfܿ,K:deerp~w%կBP5N;aoǟ<=,ջA|I6[G :bjHf#I||9o/YYPib /ľzU$BQѸqbccپuizBXI=GuitY\ tB/^BTje64iEQڬX}p[-Bb/iIچF;B!OՇ-[ѪU OGS̽7T !u֭[6l`ذau*Le̪/}'SYxJҡ+zGLOZŬ6Q΋pWy5 ${VLÒl^H}o zYۚO-w6vN/m,yq`t'XIQTa?X",Rֵm˖-1'|t|IF-[yD+Y|jɫ\JFgY FFjprLv۷ اg'Հ8rQv8WЫwz]:>[Ň?MAC`˸8*~|"<ʷ\IA#:W>#'`ɛ7Ǡs IKʲVJK9v]v_ӟKo;;x}l k'=c/f\o,ͨ(c#. fX^]IUp>xp.>Xe&Lќ8O@}sqeg }zmW Pg]th[&ǩt~3l'ʀYxKOBW3yrwT2\ܲn\(aoq>2k>wmB {y>oaH|:jZ;,Eb|:OſqG\LӼǣXv aI G)|U!󈃑go^:ʽʿYb4!Gpu\:gβ>W1IY=yc/>¿c%onk?_kxX|]cnfI43zmfvrT|y`նD6i_~Jce>ņ %c<5}4IDATBO}'NdT<5_U0 ۍG f(̓ձpU.6[{tͻz AyIP9n'Thf'Ktrt6~C^Eĕfy$w/89~?'B\-LjK:F%֝uv  8ˉ'ۅCmh~4n^ S ,{7oy@B&#__p`tsgGE }zx\(szNSmX5W߫w3 L(.wؙrJ$C`@kzs-cx!OgBTP#.aD[oW)B!Ҟ2+OzGW9zɫ`k~Gއ(@QB-M͡w3#~-<[(/ C/3y,y#^g)|,8Aɯ~SQTv2MJVQΎY.  yke/z6IG1wTrÎmaN;tLӅai.;N ~SD;N|#Xֆ"M܊V~Ȳ'.,9n=SN>tGn~ysG Lw~vpȃBQ_8bJҡ _)=NtpǹٙUZ"C`Vj)b .$mO8=;nr:(pc#-YA'l|s칎> z#m&܀k6|q 1]O 7@_l40 {0y9$O^>|w(<}^1w`ǎص*|џze$i;YsȞ0mڈݞwKFXhh]x} d{˂ۉ~dN`OagrJF!_G2}+n0Ͻ_MHm;):~gϯbwEYdխƌüy󊬛7ocƌ9jgR= yh>waڬx"5rM [M<\:<۽%s](\l.IS~'<}dҠ8mdÕ= ))>f.__}v;Mt\9|Tqnt2G6]m틡_1,죘f郺}Q"C^@b7nghNfhݜ6\y$57| <z=}C\}1޸qC~[|E3迼vnCaDY*gyX j_^t WUGҳݮsg#bSD|qaKoz !z)FMVV&L`޼yK,X]/S{|cۤ$'xw,+;◽/?}l~p/cNg V!{нǥdd<۹Q… ҥKǛ;}jC*Uǎ2xs;c\ '.:˰''%pMLJ_x\4<ެbSm4 !Vڵs,X:?Ν;י`$ZPNʽ*4M̒z !XY׶αlܰR_T2h !չmչ$Z :Bk$Z iQ!(K}IJvv6*q !hbZ"11ZeF^#%j@E!88D""J~S!8%'%Vcɖ$Z itܙ ~%4TBq~1MSiufr%j@4Mq&Ʋ}60#B!DmQU:O+VcZiٺ MFvB!'(fǷʔD4 _?ڮBqޓGӄB!-jҷ}×_/SwJYM$BQVfwE57ÙX} $u(%n>tL^]wv/ύ7^Mddx9MWUk$BQk2cUWҹS3"Z4<3', #37C71,>hׁal~ ,~~0Oމ gϞwؙofztUaCsIb!B*3ML` ci2ЈܻUSP-0c\[nԒ.][{4&M=/~( 6W>G ͐xfH KI >I\~EN,e誂w7c,()K<|$Bv-=+ E=1F4'/ ;F'$``y(6o.r?`~;lV*^G{J92u7aY+S, TvS.9KG1w]|CxFE wGY$S!Kfq+n=cc2/u8=T^6İ;k8Sӊ*y-^o mIG30/l$fK:| !6P3.pd?GZ-vջk &ThgcWU( Ytʟh)%ίdJ s7_((9mJ~`g.ao%Ğnj/9OìYr?xq;8:Ӂt&ˉi/T]ֹ,B [ pOuhK( nHUgcx׶|CYtkCt stĎm(-J<8'}?5BQgf ޝSbZ0-%,*?Ct]7>8s4v#G ű8Yڝח0tǗ,|r>>]xlX/.iVkWF H M Q>He./!Μϣ IBTYE[Y7ƿMNL 2< = $[60:Sy'!D9zr0L03s!|e"gxz':=4op.X)׾k:1aX7[6n߃bEt3/2 IJJ:*mV/\.7n=PN,U \'ab :t:@Vv ZؐH%ϋS.|yO?cgׇȐH4 .'Ӊbzyašt2q"qi(ȏ '\٢eRt3-\!BybP<*5YRS!|e[śIENDB`gtkada-24.0.0/docs/gtkada_rm/font-button.png000066400000000000000000000057651446021174000207120ustar00rootroot00000000000000PNG  IHDR[L[sBIT|d IDATxln :Fʀj[+Ř ILj1%lJTc(!a$ƈq*(c6cs~umw?Zmɥ]{ϫ!B!B2|%lHӗ:0?x=\#V;_K2Մa>477ǨF!d[p!,`x>b!z 6x_` f >4y k@_fw`2 W Bį~?tN$_#aC|9"%<7D?Hfl^F`Bx' IcWTTTLu "  8qT &駟?Lu bZZZB$1 1N:5%1B$1 !tL Jryf|r^z%TU &HLjjQUUU9~8v,Ym-ܼyrrrrXx1twwGzjVXkx(,,<Ο??הּkrYzO)--l6cp:|Gږ@222HKKa{ŋOTVVF,/oG^W"VVVx8w;vm-uuuyOYY/?#?3inn櫯j ]}n7<ʕ+rpHDd2g1w\'*0o}}}|>TU%)) 6P]]͍7hjj͛7ǴFlPRRBFFk֬!!!cǎAUU[laÆ 5~z--[n?ʕ+r辄q`ѢE*]vi_yz! (**tƴFO58qB0Nmph`t@'p>0u=)=!tL@nb$1 !tL@KoCn3-(d $F I>9!tL@B$1 !tL@… #&Պz lڴiL5XVm-K.nn'4NMnw1 FE_̙3^oOOϐw`2hoo_r CX3mGz1d2HII&шr{nz{{4pSO=E  //<?>/`h4bX(..?dжm6۰۩Gl{#bO`x_8}4gϞe޽i?Ѩw֭c{Gmm-W&![t:yfDlIP~~>AaakwQQQdbk.jkk#>;!㕕jeҥ;w}E_b?":r >s?+mZioo'hF8d^Jrrv`Ν|'Zpb?":t,yao}ͤa4X-iiilܸ3gӣקCzjHL1Š+x7顭7iii~mmm---=zEQ0;߿kRTTă>8v91oڈG쏈-D8$!nK@B$1 !tL@B$1 !tL@B$1 !tL@B$1 !tL@"~Lˇ@bBW/&i@ 0kqv H !&N%n <G >Kp!CrEK%v @Q@%D@x ! ^?8߇+(t2~ Aah C7D@zbz c0B'r 0PW<'`D@6`?5 ߀\C te ?؀ z o[ !Ѕ?aSpF{-¯J@MQxjeIENDB`gtkada-24.0.0/docs/gtkada_rm/font.eps000066400000000000000000000434211446021174000173730ustar00rootroot00000000000000%!PS-Adobe-2.0 EPSF-2.0 %%Title: font.eps %%Creator: fig2dev Version 3.2 Patchlevel 1 %%CreationDate: Wed Mar 22 11:21:10 2000 %%For: briot@lyon.act-europe.fr (Emmanuel Briot) %%Orientation: Portrait %%BoundingBox: 0 0 271 230 %%Pages: 0 %%BeginSetup %%EndSetup %%Magnification: 1.0000 %%EndComments /MyAppDict 100 dict dup begin def /$F2psDict 200 dict def $F2psDict begin $F2psDict /mtrx matrix put /col-1 {0 setgray} bind def /col0 {0.000 0.000 0.000 srgb} bind def /col1 {0.000 0.000 1.000 srgb} bind def /col2 {0.000 1.000 0.000 srgb} bind def /col3 {0.000 1.000 1.000 srgb} bind def /col4 {1.000 0.000 0.000 srgb} bind def /col5 {1.000 0.000 1.000 srgb} bind def /col6 {1.000 1.000 0.000 srgb} bind def /col7 {1.000 1.000 1.000 srgb} bind def /col8 {0.000 0.000 0.560 srgb} bind def /col9 {0.000 0.000 0.690 srgb} bind def /col10 {0.000 0.000 0.820 srgb} bind def /col11 {0.530 0.810 1.000 srgb} bind def /col12 {0.000 0.560 0.000 srgb} bind def /col13 {0.000 0.690 0.000 srgb} bind def /col14 {0.000 0.820 0.000 srgb} bind def /col15 {0.000 0.560 0.560 srgb} bind def /col16 {0.000 0.690 0.690 srgb} bind def /col17 {0.000 0.820 0.820 srgb} bind def /col18 {0.560 0.000 0.000 srgb} bind def /col19 {0.690 0.000 0.000 srgb} bind def /col20 {0.820 0.000 0.000 srgb} bind def /col21 {0.560 0.000 0.560 srgb} bind def /col22 {0.690 0.000 0.690 srgb} bind def /col23 {0.820 0.000 0.820 srgb} bind def /col24 {0.500 0.190 0.000 srgb} bind def /col25 {0.630 0.250 0.000 srgb} bind def /col26 {0.750 0.380 0.000 srgb} bind def /col27 {1.000 0.500 0.500 srgb} bind def /col28 {1.000 0.630 0.630 srgb} bind def /col29 {1.000 0.750 0.750 srgb} bind def /col30 {1.000 0.880 0.880 srgb} bind def /col31 {1.000 0.840 0.000 srgb} bind def end save -215.0 353.0 translate 1 -1 scale .9 .9 scale % to make patterns same scale as in xfig % This junk string is used by the show operators /PATsstr 1 string def /PATawidthshow { % cx cy cchar rx ry string % Loop over each character in the string { % cx cy cchar rx ry char % Show the character dup % cx cy cchar rx ry char char PATsstr dup 0 4 -1 roll put % cx cy cchar rx ry char (char) false charpath % cx cy cchar rx ry char /clip load PATdraw % Move past the character (charpath modified the % current point) currentpoint % cx cy cchar rx ry char x y newpath moveto % cx cy cchar rx ry char % Reposition by cx,cy if the character in the string is cchar 3 index eq { % cx cy cchar rx ry 4 index 4 index rmoveto } if % Reposition all characters by rx ry 2 copy rmoveto % cx cy cchar rx ry } forall pop pop pop pop pop % - currentpoint newpath moveto } bind def /PATcg { 7 dict dup begin /lw currentlinewidth def /lc currentlinecap def /lj currentlinejoin def /ml currentmiterlimit def /ds [ currentdash ] def /cc [ currentrgbcolor ] def /cm matrix currentmatrix def end } bind def % PATdraw - calculates the boundaries of the object and % fills it with the current pattern /PATdraw { % proc save exch PATpcalc % proc nw nh px py 5 -1 roll exec % nw nh px py newpath PATfill % - restore } bind def % PATfill - performs the tiling for the shape /PATfill { % nw nh px py PATfill - PATDict /CurrentPattern get dup begin setfont % Set the coordinate system to Pattern Space PatternGState PATsg % Set the color for uncolored pattezns PaintType 2 eq { PATDict /PColor get PATsc } if % Create the string for showing 3 index string % nw nh px py str % Loop for each of the pattern sources 0 1 Multi 1 sub { % nw nh px py str source % Move to the starting location 3 index 3 index % nw nh px py str source px py moveto % nw nh px py str source % For multiple sources, set the appropriate color Multi 1 ne { dup PC exch get PATsc } if % Set the appropriate string for the source 0 1 7 index 1 sub { 2 index exch 2 index put } for pop % Loop over the number of vertical cells 3 index % nw nh px py str nh { % nw nh px py str currentpoint % nw nh px py str cx cy 2 index show % nw nh px py str cx cy YStep add moveto % nw nh px py str } repeat % nw nh px py str } for 5 { pop } repeat end } bind def % PATkshow - kshow with the current pattezn /PATkshow { % proc string exch bind % string proc 1 index 0 get % string proc char % Loop over all but the last character in the string 0 1 4 index length 2 sub { % string proc char idx % Find the n+1th character in the string 3 index exch 1 add get % string proe char char+1 exch 2 copy % strinq proc char+1 char char+1 char % Now show the nth character PATsstr dup 0 4 -1 roll put % string proc chr+1 chr chr+1 (chr) false charpath % string proc char+1 char char+1 /clip load PATdraw % Move past the character (charpath modified the current point) currentpoint newpath moveto % Execute the user proc (should consume char and char+1) mark 3 1 roll % string proc char+1 mark char char+1 4 index exec % string proc char+1 mark... cleartomark % string proc char+1 } for % Now display the last character PATsstr dup 0 4 -1 roll put % string proc (char+1) false charpath % string proc /clip load PATdraw neewath pop pop % - } bind def % PATmp - the makepattern equivalent /PATmp { % patdict patmtx PATmp patinstance exch dup length 7 add % We will add 6 new entries plus 1 FID dict copy % Create a new dictionary begin % Matrix to install when painting the pattern TilingType PATtcalc /PatternGState PATcg def PatternGState /cm 3 -1 roll put % Check for multi pattern sources (Level 1 fast color patterns) currentdict /Multi known not { /Multi 1 def } if % Font dictionary definitions /FontType 3 def % Create a dummy encoding vector /Encoding 256 array def 3 string 0 1 255 { Encoding exch dup 3 index cvs cvn put } for pop /FontMatrix matrix def /FontBBox BBox def /BuildChar { mark 3 1 roll % mark dict char exch begin Multi 1 ne {PaintData exch get}{pop} ifelse % mark [paintdata] PaintType 2 eq Multi 1 ne or { XStep 0 FontBBox aload pop setcachedevice } { XStep 0 setcharwidth } ifelse currentdict % mark [paintdata] dict /PaintProc load % mark [paintdata] dict paintproc end gsave false PATredef exec true PATredef grestore cleartomark % - } bind def currentdict end % newdict /foo exch % /foo newlict definefont % newfont } bind def % PATpcalc - calculates the starting point and width/height % of the tile fill for the shape /PATpcalc { % - PATpcalc nw nh px py PATDict /CurrentPattern get begin gsave % Set up the coordinate system to Pattern Space % and lock down pattern PatternGState /cm get setmatrix BBox aload pop pop pop translate % Determine the bounding box of the shape pathbbox % llx lly urx ury grestore % Determine (nw, nh) the # of cells to paint width and height PatHeight div ceiling % llx lly urx qh 4 1 roll % qh llx lly urx PatWidth div ceiling % qh llx lly qw 4 1 roll % qw qh llx lly PatHeight div floor % qw qh llx ph 4 1 roll % ph qw qh llx PatWidth div floor % ph qw qh pw 4 1 roll % pw ph qw qh 2 index sub cvi abs % pw ph qs qh-ph exch 3 index sub cvi abs exch % pw ph nw=qw-pw nh=qh-ph % Determine the starting point of the pattern fill %(px, py) 4 2 roll % nw nh pw ph PatHeight mul % nw nh pw py exch % nw nh py pw PatWidth mul exch % nw nh px py end } bind def % Save the original routines so that we can use them later on /oldfill /fill load def /oldeofill /eofill load def /oldstroke /stroke load def /oldshow /show load def /oldashow /ashow load def /oldwidthshow /widthshow load def /oldawidthshow /awidthshow load def /oldkshow /kshow load def % These defs are necessary so that subsequent procs don't bind in % the originals /fill { oldfill } bind def /eofill { oldeofill } bind def /stroke { oldstroke } bind def /show { oldshow } bind def /ashow { oldashow } bind def /widthshow { oldwidthshow } bind def /awidthshow { oldawidthshow } bind def /kshow { oldkshow } bind def /PATredef { MyAppDict begin { /fill { /clip load PATdraw newpath } bind def /eofill { /eoclip load PATdraw newpath } bind def /stroke { PATstroke } bind def /show { 0 0 null 0 0 6 -1 roll PATawidthshow } bind def /ashow { 0 0 null 6 3 roll PATawidthshow } bind def /widthshow { 0 0 3 -1 roll PATawidthshow } bind def /awidthshow { PATawidthshow } bind def /kshow { PATkshow } bind def } { /fill { oldfill } bind def /eofill { oldeofill } bind def /stroke { oldstroke } bind def /show { oldshow } bind def /ashow { oldashow } bind def /widthshow { oldwidthshow } bind def /awidthshow { oldawidthshow } bind def /kshow { oldkshow } bind def } ifelse end } bind def false PATredef % Conditionally define setcmykcolor if not available /setcmykcolor where { pop } { /setcmykcolor { 1 sub 4 1 roll 3 { 3 index add neg dup 0 lt { pop 0 } if 3 1 roll } repeat setrgbcolor - pop } bind def } ifelse /PATsc { % colorarray aload length % c1 ... cn length dup 1 eq { pop setgray } { 3 eq { setrgbcolor } { setcmykcolor } ifelse } ifelse } bind def /PATsg { % dict begin lw setlinewidth lc setlinecap lj setlinejoin ml setmiterlimit ds aload pop setdash cc aload pop setrgbcolor cm setmatrix end } bind def /PATDict 3 dict def /PATsp { true PATredef PATDict begin /CurrentPattern exch def % If it's an uncolored pattern, save the color CurrentPattern /PaintType get 2 eq { /PColor exch def } if /CColor [ currentrgbcolor ] def end } bind def % PATstroke - stroke with the current pattern /PATstroke { countdictstack save mark { currentpoint strokepath moveto PATpcalc % proc nw nh px py clip newpath PATfill } stopped { (*** PATstroke Warning: Path is too complex, stroking with gray) = cleartomark restore countdictstack exch sub dup 0 gt { { end } repeat } { pop } ifelse gsave 0.5 setgray oldstroke grestore } { pop restore pop } ifelse newpath } bind def /PATtcalc { % modmtx tilingtype PATtcalc tilematrix % Note: tiling types 2 and 3 are not supported gsave exch concat % tilingtype matrix currentmatrix exch % cmtx tilingtype % Tiling type 1 and 3: constant spacing 2 ne { % Distort the pattern so that it occupies % an integral number of device pixels dup 4 get exch dup 5 get exch % tx ty cmtx XStep 0 dtransform round exch round exch % tx ty cmtx dx.x dx.y XStep div exch XStep div exch % tx ty cmtx a b 0 YStep dtransform round exch round exch % tx ty cmtx a b dy.x dy.y YStep div exch YStep div exch % tx ty cmtx a b c d 7 -3 roll astore % { a b c d tx ty } } if grestore } bind def /PATusp { false PATredef PATDict begin CColor PATsc end } bind def % this is the pattern fill program from the Second edition Reference Manual % with changes to call the above pattern fill % left30 11 dict begin /PaintType 1 def /PatternType 1 def /TilingType 1 def /BBox [0 0 1 1] def /XStep 1 def /YStep 1 def /PatWidth 1 def /PatHeight 1 def /Multi 2 def /PaintData [ { clippath } bind { 32 16 true [ 32 0 0 -16 0 16 ] {} imagemask } bind ] def /PaintProc { pop exec fill } def currentdict end /P1 exch def 1.1111 1.1111 scale %restore scale /cp {closepath} bind def /ef {eofill} bind def /gr {grestore} bind def /gs {gsave} bind def /sa {save} bind def /rs {restore} bind def /l {lineto} bind def /m {moveto} bind def /rm {rmoveto} bind def /n {newpath} bind def /s {stroke} bind def /sh {show} bind def /slc {setlinecap} bind def /slj {setlinejoin} bind def /slw {setlinewidth} bind def /srgb {setrgbcolor} bind def /rot {rotate} bind def /sc {scale} bind def /sd {setdash} bind def /ff {findfont} bind def /sf {setfont} bind def /scf {scalefont} bind def /sw {stringwidth} bind def /tr {translate} bind def /tnt {dup dup currentrgbcolor 4 -2 roll dup 1 exch sub 3 -1 roll mul add 4 -2 roll dup 1 exch sub 3 -1 roll mul add 4 -2 roll dup 1 exch sub 3 -1 roll mul add srgb} bind def /shd {dup dup currentrgbcolor 4 -2 roll mul 4 -2 roll mul 4 -2 roll mul srgb} bind def /$F2psBegin {$F2psDict begin /$F2psEnteredState save def} def /$F2psEnd {$F2psEnteredState restore end} def %%EndProlog $F2psBegin 10 setmiterlimit n -1000 6867 m -1000 -1000 l 9095 -1000 l 9095 6867 l cp clip 0.06000 0.06000 sc % Polyline 7.500 slw n 4756 3976 m 4756 2529 l 4901 2529 l 4901 3107 l 5046 3107 l 5046 2529 l 5190 2529 l 5190 3976 l 5046 3976 l 5046 3397 l 4901 3397 l 4901 3976 l cp gs col0 s gr % Polyline [60] 0 sd n 3600 3976 m 8083 3976 l cp gs col0 s gr [] 0 sd % Polyline [60] 0 sd n 4034 2529 m 4756 2529 l cp gs col0 s gr [] 0 sd % Polyline [60] 0 sd n 4756 3976 m 4756 5277 l cp gs col0 s gr [] 0 sd % Polyline [60] 0 sd n 5190 3976 m 5190 5566 l cp gs col0 s gr [] 0 sd % Polyline [60] 0 sd n 4179 3976 m 4179 5855 l cp gs col0 s gr [] 0 sd % Polyline n 4179 3976 m 4323 3976 l 4323 4119 l 4179 4119 l cp gs /PC [[0.00 0.00 0.00] [0.00 0.00 0.00]] def 15.00 15.00 sc P1 [16 0 0 -8 278.60 265.07] PATmp PATsp ef gr PATusp gs col0 s gr % Polyline gs clippath 4092 4901 m 4034 5132 l 3976 4901 l 3976 5147 l 4092 5147 l cp 3976 2760 m 4034 2529 l 4092 2760 l 4092 2514 l 3976 2514 l cp clip n 4034 2529 m 4034 5132 l gs col0 s gr gr % arrowhead n 3976 2760 m 4034 2529 l 4092 2760 l col0 s % arrowhead n 4092 4901 m 4034 5132 l 3976 4901 l col0 s % Polyline gs clippath 4525 5219 m 4756 5277 l 4525 5335 l 4771 5335 l 4771 5219 l cp clip n 4179 5277 m 4756 5277 l gs col0 s gr gr % arrowhead n 4525 5219 m 4756 5277 l 4525 5335 l col0 s % Polyline gs clippath 4959 5508 m 5190 5566 l 4959 5624 l 5205 5624 l 5205 5508 l cp clip n 4179 5566 m 5190 5566 l gs col0 s gr gr % arrowhead n 4959 5508 m 5190 5566 l 4959 5624 l col0 s % Polyline [60] 0 sd n 6203 4698 m 5769 4698 l cp gs col0 s gr [] 0 sd % Polyline [60] 0 sd n 7070 3976 m 7070 5855 l cp gs col0 s gr [] 0 sd % Polyline n 5769 3976 m 5914 3976 l 5914 4119 l 5769 4119 l cp gs /PC [[0.00 0.00 0.00] [0.00 0.00 0.00]] def 15.00 15.00 sc P1 [16 0 0 -8 384.60 265.07] PATmp PATsp ef gr PATusp gs col0 s gr % Polyline gs clippath 5827 4467 m 5769 4698 l 5711 4467 l 5711 4713 l 5827 4713 l cp 5711 3628 m 5769 3397 l 5827 3628 l 5827 3382 l 5711 3382 l cp clip n 5769 3397 m 5769 4698 l gs col0 s gr gr % arrowhead n 5711 3628 m 5769 3397 l 5827 3628 l col0 s % arrowhead n 5827 4467 m 5769 4698 l 5711 4467 l col0 s % Polyline gs clippath 5972 5219 m 6203 5277 l 5972 5335 l 6218 5335 l 6218 5219 l cp clip n 5769 5277 m 6203 5277 l gs col0 s gr gr % arrowhead n 5972 5219 m 6203 5277 l 5972 5335 l col0 s % Polyline gs clippath 6839 5797 m 7070 5855 l 6839 5913 l 7085 5913 l 7085 5797 l cp clip n 5769 5855 m 7070 5855 l gs col0 s gr gr % arrowhead n 6839 5797 m 7070 5855 l 6839 5913 l col0 s % Polyline gs clippath 6551 5508 m 6782 5566 l 6551 5624 l 6797 5624 l 6797 5508 l cp clip n 5769 5566 m 6782 5566 l gs col0 s gr gr % arrowhead n 6551 5508 m 6782 5566 l 6551 5624 l col0 s % Polyline [60] 0 sd n 6782 4698 m 6782 5566 l gs col0 s gr [] 0 sd % Polyline [60] 0 sd n 6203 4698 m 6203 5277 l gs col0 s gr [] 0 sd % Polyline [60] 0 sd n 5769 4698 m 5769 5855 l cp gs col0 s gr [] 0 sd % Polyline gs clippath 5538 5797 m 5769 5855 l 5538 5913 l 5784 5913 l 5784 5797 l cp clip n 4179 5855 m 5769 5855 l gs col0 s gr gr % arrowhead n 5538 5797 m 5769 5855 l 5538 5913 l col0 s % Polyline n 4756 2529 m 4901 2529 l 4901 3107 l 5046 3107 l 5046 2529 l 5190 2529 l 5190 3976 l 5046 3976 l 5046 3397 l 4901 3397 l 4901 3976 l 4756 3976 l cp gs 0.50 setgray ef gr gs col0 s gr % Polyline [60] 0 sd n 5769 3397 m 6203 3397 l cp gs col0 s gr [] 0 sd % Polyline n 6348 3541 m 6637 3541 l 6637 3831 l 6348 3831 l cp gs col0 s gr % Polyline 0.000 slw n 6203 3397 m 6782 3397 l 6782 3541 l 6203 3541 l cp gs 0.50 setgray ef gr % Polyline n 6782 3541 m 6782 3976 l 6637 3976 l 6637 3541 l cp gs 0.50 setgray ef gr % Polyline n 6203 3541 m 6348 3541 l 6348 3976 l 6203 3976 l cp gs 0.50 setgray ef gr % Polyline n 6348 3831 m 6637 3831 l 6637 3976 l 6348 3976 l cp gs 0.50 setgray ef gr % Polyline n 6637 3976 m 6637 4553 l 6348 4553 l 6348 4409 l 6203 4409 l 6203 4698 l 6782 4698 l 6782 3976 l cp gs 0.50 setgray ef gr % Polyline 7.500 slw n 6203 3397 m 6782 3397 l 6782 4698 l 6203 4698 l 6203 4409 l 6348 4409 l 6348 4553 l 6637 4553 l 6637 3976 l 6203 3976 l 6203 3397 l cp gs col0 s gr % Polyline n 6348 3541 m 6637 3541 l 6637 3831 l 6348 3831 l 6348 3541 l cp gs col0 s gr % Polyline [60 30 15 30] 0 sd gs clippath 4381 3600 m 4323 3831 l 4265 3600 l 4265 3846 l 4381 3846 l cp clip n 4323 2239 m 4323 3831 l gs col0 s gr gr [] 0 sd % arrowhead n 4381 3600 m 4323 3831 l 4265 3600 l col0 s /Times-Roman ff 225.00 scf sf 4034 3541 m gs 1 -1 sc 90.0 rot (ascent) col0 sh gr /Times-Roman ff 225.00 scf sf 4034 4843 m gs 1 -1 sc 90.0 rot (descent) col0 sh gr /Times-Roman ff 225.00 scf sf 5769 3831 m gs 1 -1 sc 90.0 rot (ascent) col0 sh gr /Times-Roman ff 225.00 scf sf 5769 4698 m gs 1 -1 sc 90.0 rot (descent) col0 sh gr /Times-Roman ff 225.00 scf sf 4323 5132 m gs 1 -1 sc (lbearing) col0 sh gr /Times-Roman ff 225.00 scf sf 4323 5566 m gs 1 -1 sc (rbearing) col0 sh gr /Times-Roman ff 225.00 scf sf 4323 5855 m gs 1 -1 sc (width) col0 sh gr /Times-Roman ff 225.00 scf sf 5914 5132 m gs 1 -1 sc (lbearing) col0 sh gr /Times-Roman ff 225.00 scf sf 5914 5566 m gs 1 -1 sc (rbearing) col0 sh gr /Times-Roman ff 225.00 scf sf 5914 5855 m gs 1 -1 sc (width) col0 sh gr /Times-Roman ff 225.00 scf sf 7215 3976 m gs 1 -1 sc (baseline) col0 sh gr /Times-Roman ff 225.00 scf sf 4179 2239 m gs 1 -1 sc (origin \(x, y\)) col0 sh gr $F2psEnd rs end gtkada-24.0.0/docs/gtkada_rm/font.jpg000066400000000000000000000345771446021174000174000ustar00rootroot00000000000000JFIFPPC    $.' ",#(7),01444'9=82<.342C  2!!22222222222222222222222222222222222222222222222222 S" }!1AQa"q2#BR$3br %&'()*456789:CDEFGHIJSTUVWXYZcdefghijstuvwxyz w!1AQaq"2B #3Rbr $4%&'()*56789:CDEFGHIJSTUVWXYZcdefghijstuvwxyz ?( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( +~ +DRneA3V" 1x #ZVJC I$ p"rN^S=2Ezgޝ ?gONcoϵ޷xsGVծ>c2]w0Q‚O$yޤ&+kw(×FAm(Ua (0]YfcMV{=*zRڣY$ $$:vxn.%"BI#TP2I'5êx^zQ[A' pdKxLd\ZI1ln#e y[vx )HDH3ʰO%y?Mm~k[VSI.6mqV@#ƥZRqD-ʹ3vTVVVV$X47M=֧w$ _)}v+36 fQuPQ7VEJ$E `*J(8![kxC!H"$gb,Ė>{pysw;D,HQQ2HQc&mu5KI 0-n̉JG˖? 孍mJŋ3IUT`(((((((((((((((((W|E|)XMC3>IŹb K7a]xEbg<%7)6@%T0?wC4T;_--gFy~`KZH@!H$V^GD`1F@n#  ).S?;oJ~0i* (?;oJ?>.~ס϶+76e"O/9j _PU xė*t=FEIêӽv5֯O<5`_yZ襠(n.%"BI#TP2I'5H冟qoZK=ۤvIs\+L4a puur9/-KnG* >ʻ fl=h9hg?oEh9k~ &]χ4םm-v:͸9m۸DB͏ Q OXf((/гcg?Y +g&V{qqaf٣̭pb=1v ( ( ( ( ( ( ( ( (9ZkW7ۈ *Z\)Ku%T]NØ5.u(,^3,+; %?&7FHsCan}&NA{BdyLa\FY2:PP,zԮ_PW_l]APvN*ƪǫ7_(_\jP_O&cmB"?ri9m('b _PU`%_Zۊz!]ݗE^|7_s,?B/* pOͼW@Aoп^?/P|'^a_@?O {¿mo^@Q@Q@Q@Q@Q@Q@Q@Q@Q@sPXۺ+*FA^wcV¶ggp-d-#H! N1^Pa̍e`7D+[֚k܄#2ϗ]>P+Ɨi$WVbr=vQE`_q^^? J ѷ|7_s,ܐ,/9`t;J##z;޹{9@@WgzE o7TpAVآ@O ׿+ Wm(xkybI ,72:$?@l{JPլss jrDe*PrXUt܃ovw|:m_I%@oo3V.8VUq+(}O⦁i\^$q$FY`@HeȬ ݋@5\y^::憀C*G;6'Xgn ^kMWT-Uh.L VlJO?(`|K߅5eshr!2,÷qQ+Š(((%r-AtqI23 Pv* 0Yљb"LX}w rA$v* 0Yљb"LX}w rA;Pv* 0Yљb"LX}w rA8v6$7](*lL 2~N?0zV^]4X;n;|{3Iۮ~3lwcs9蚏)i:M/WˋzNǖ < ޙ-Bmu yvȥҀ>A&:39LDWIBn၎H9A&:39LDWIBn၎H9rÎA&:39LDWIBn၎H9#xWsioZog$U9 sꕏmuZ_+OTďKf6᮷:^$k9H*KFgq[׆C L50$'*H nas]Ey*ckxD1RUٕ B7;Wz|oc?70w 9 o? zqnj,/o}O 0 yUqR;_K1]&U ۇ,>w 9 5MW&q-gz|ȧOLpqx'qi=x![V-O+Y$+o+I6  |m%&Ԟ[(J4afٙ y#{(_+_md,_fM*Cc\$@8Q`lo.5եFq E0LO1Q@mXCҟ/։4#z?9bA!&YMm/GfR =aN1Ou'( 8|Ta.3EtT+nI6䃞0u,R;8x'$8–b8^:U(((((\p.f\Ee w 6?xxgy[Z[<˔O.?*[Z啦%g5An\>F6iD`" ;!R|Al/jW0إ1q(U(g8mtŦ`dwz8=>dSǧkbMW&q-gz|ȧOLQEmuZ_+OTďKfǶ-N/K*bG%F́سzQ@ekRY𮑪\,k=7,` N2}MjV_) ƳCq"P΁$'Q@|) vKxF\CZkHIbi*YV _Y|>eMo[o[fpQy8E̲ncm̭( ( ( B{LH_HWgzE  ׿+ Wm(Y|= lPxgAނẙxlV>}qiz$ޠ6Oؠ((((((((/BTдY5tH.+LL䓉 񥶳ygXIov0,j}G.+Y`r' ؀`w $o-5_C#w@9"==3[\Zj 6Gw<3Ak_9S>.Fn6dśր6(+/ZυtRcYlc(g@ qkR5MWH.50Bt @'>5(+mtmWCO|QE#4_:vy$/eE?DL)|Y1ھxΓŢj: bťZT Kmp3(ag{ i*o}8WWB/mbCM-lss2%RGg {WWrB$xdw*Hd O6z }_7_/i+C;޹{9Qv[»b"8`h>/^[נW'^a_@ }fU0I;Amz Y2)5XŦ`dwz8=>dSǧkb ( ( ( ( ( ( ( (ÐsƱ'\i><ۯ,&XDHUDU#A18$ho-5_C#w@9"==3[\Zj 6Gw<3Ak_9S>.Fn6dśր6(+/ZυtRcYlc(g@ qkR5MWH.50Bt @'>5(+oi s3O|gHƍNVs Z7 i/VF1 ~0i* (~0i*O:|u|:e/YZ[ rA[>YpjSKCKeȷF-#ά8"\q¬?fK?Vk3Xz5R~U ?)?^EqEqs̰tbVͭpqҲJkG\c az%M2Fc>R1MW&q-gz|ȧOLc7M h;Z O((((((((k:<^u=ݘg 5k76#Tմx&2ݵ`1J`P+|$N[y_-<4` YAY|= lPxgAނẙxlV>}qiz$ޠ6Oؠ wG+ VI"3Ap1Bʆs#kBO>_An' VU?w99AvwZ4BW%J$0hqѴaI'<@p~]fO6{و(WrqGbYr; ^IWSm:-&̆UdBH*0\WUW7Rk-iii4ks6cG`<8PQ\Tn#$];xO0;2GݤrXm j^6ּ^Evjqgik8FKo4u,{=B5MWH.50Bt @'>+/ZυtRcYlc(g@ qhR(i<־ żC7Ekg9i$`m \+)c $'#V["2{ԍ4R2wfq =2xSҡ${A{ŕ]50 P V;SێҋF$(g }׀jS_j:弫K շ9*m-]0:jS_j:弫K շ9*m-]0:\Zj 6Gw<3Ak%\Zj 6Gw<3Akݨ43MFϰ[O&{QC~l$> [xkF0#f-bB'UkO iw}֣ZEKk# dT"\*'ğj9?St)m3IA 1ZHQ$qq  > cͪEYv}ݬ0G <=1Qæh]$дk5"fG&^0122 cx/xķ suGa:orJmbےfwO cU$mNeE (p$I ͐ Ggtݳ~e76}3#9jKk:7]XYIm=F0ve~ApQ@ekRY𮑪\,k=7,` N2}MjV_) ƳCq"P΁$'Q@ay| ydx˗Hث#ynV'!HgLx䍊0 Asޝko?Q4{>׶ĻaFZυ]$`QC~lZVcn bMV>dH1:\Xt:3[zﴵ. ߴ"L_͡ZU͎KhZ#^č!WGߌrzд{OJ;ۢفghQ@g_6hֶ4d[9qI$S6૏Dmg{\?b:C5^SӾF8'$: {AӍ\{ԓbHye8ؓĺ :\:ޚ|ϲ+A<+=yYio;pL"irYy<?5mRu7ikFS+p̌|dn m{E武o9Ti a9cz3L54+QԬqX xcoԊI^M1 IYtĒ4@`/!;mN]F{kEyr\H쏸͸0S$r6 g=#Pt}#?Z67 7n뵽 GxAѮTwWI8#>Ƹ}~Zծ .I&fr>y! #s&]Kdy|Fخ N ;{U ah]ekRY𮑪\,k=7,` N2}Mpz'_X}Z>X4k R~_<<Fi2_MX˪CQFr)QG'O( Z7 i/VF1 ܬ?O5|Cqo,rdaA9 I-7CԄm֭enL{WTO1f`,>^x9CЙ/H?SӵK/YIG5]`zg !YA-,6 Ds$7H  0JwGձߴ'uy3sz>x7RN5{Ɠ"f;haYj=?Jŵ7Pf1Y|ٛ;/}qiz$ޠ6Oج}fU0I;Amz Y2)5 h؟_whVI ­*pv\<0GR =;˛8no!Ix G#=jHg"7x_d F vwvW/-J-I/&B*m|K) m7S 6"&̎9V+[Lǐ@PH~gblZkk&'qeg^F@\z]QEQEV'!HgLx䍊0 A}BZc_DZn8s3~ .xis=;J yNTTIڀ:(w* O2Frhk#x^@]-O-J_:N:=,[+{,ZU1-$Ċ }C\tɼA&"^]jĕf2CoɌP[ic3eU 1{n%y5kBE|n.?=ķr*؎%6|ή DŽ5?wyWZ}>7;F$k:ڦi}xZ<-IH+b!($ qUE81RQ@^k{9%Tɂ!.27' Jc[omƫj[u&hL"s` Ŧ`dwz8=>dSǧkbIm}y6Z]\okr@Mpw*0zv<QEQEQEQEQEQEQEQEQEORtfmM>p+*#>  k9A<B?  k9A<B?  k9A<B?  k9A<B?  k9A<B?  k<xSKVAaqqEsx?M4 4?CAEsx?M4 4?CAEsx?M4 4?CAEsx?M4 4?CAErvr5|9=絎$nFr6# c³/XF~q!`2y!$ (>xSZvA $eABy@WYEQEQEQEQEQEQEgtkada-24.0.0/docs/gtkada_rm/font.pdf000066400000000000000000000373621446021174000173640ustar00rootroot00000000000000%PDF-1.2 1 0 obj << /CreationDate (D:20040115155816) /Producer (@\(#\)ImageMagick 5.4.7 07/01/02 Q:16 http://www.imagemagick.org) >> endobj 2 0 obj << /Type /Catalog /Pages 3 0 R >> endobj 3 0 obj << /Type /Pages /Kids [ 4 0 R ] /Count 1 >> endobj 4 0 obj << /Type /Page /Parent 3 0 R /Resources << /Font << /F0 8 0 R >> /XObject << /Im0 9 0 R >> /ProcSet 7 0 R >> /MediaBox [0 0 612 792] /CropBox [136 252 475 540] /Contents 5 0 R /Thumb 12 0 R >> endobj 5 0 obj << /Length 6 0 R >> stream q 339 0 0 288 136 252 cm /Im0 Do Q endstream endobj 6 0 obj 35 endobj 7 0 obj [ /PDF /Text /ImageC ] endobj 8 0 obj << /Type /Font /Subtype /Type1 /Name /F0 /BaseFont /Helvetica /Encoding /MacRomanEncoding >> endobj 9 0 obj << /Type /XObject /Subtype /Image /Name /Im0 /Filter [ /DCTDecode ] /Width 339 /Height 288 /ColorSpace 11 0 R /BitsPerComponent 8 /Length 10 0 R >> stream JFIFHHC    $.' ",#(7),01444'9=82<.342  SI !"1QAu#267VtBUa$5Rq%3S4Tb?)JR)JR)JR)JR)JR)JR)JR)JR)JR)JR)JR)J={gCbٻv61^v9h~uЄޣ8H$@U*ȐX}a$ I9}2c!jB#<@@#^T}%B  P)JR)JR)JR)JRƻM1KD1T˨-8 ϪSWnԌZ5MS"փqMn9 &@jR8 tF _{~rsN̜ɸI3]imC t%j$NӝAwHõG RPKnp;N1,5ﲙ6!ަÝ-K@ ,3) Y:tdiGx!dK(qHc!$t9'vxoEtf19}- 54m[Z[IRI2z QZoBMDᡕ%olcjRMboM\nJ۬\]QB1m2HU0ANcf3 [>z$8Bm}jJR)JR)JR)JR)RoS>*qf{rS60@%8*H%GkZ|mvD{n屷v)!iRTcjAI bж~KʹJk\QhJ`(wG5<ʎwmIC!IZH#Q;q\(m .81ʔIQ}u3 %ɖ"FED%#> $$`eJ8ʉ>8pw9{ka1Z!A(G+*=Ϯ,! [TTT<<`)JR)JR)JR)JR"\5Кb-$Hl%i~PJR)JR)JR)JR)JR+ S>mSz%qW*)R^@ H[#IRBv=_vg 6LTwB2 -'OPRHFGH#WݱڃVU˲?#Rz~zNvsRM6tj\Ymiˎ uCxz_3,ZE XHuAZQ6I+Bl~{髃}-iKa[$)h d3UJR)JR)JR)JRqkXT֢8.tie L y*Ennk f\ IR< JR}U^? eEY?L={{WzP+pj}v {Z R)JR)JR)JR+pn[}HZ[.qBG# Ϫm|)K$CT P ZSn86#;P !@*O)<UJ~T_őS7~r `ПWkQ 5)JR)JR)JR)JRyTŗZ yM돶K,%%Di*^q*)\ʋ*~{@WrM{*/&)JR)JR)JR)JV7TLlhF+tn@m=f°3vfՒSbފ vjC 61F-K:0\22$.yy$TRVrT+AwQEO?Ot>/⚮_]B}^eE$ւ)JR)JR)JR)J{C܉/9W?JImմ\!2rTTPzBDU=+Cqz ` o^ऐJL6K4D[(-'xy(TRVp T+AwQEfd8\Ӭ{nZҒBA(]KPrHh-+?q JJTꯥv {Z R)JR)JR)JR+m5ayȑ'!7RCmڊJ`m(I6,5Ly }r^Q}}b~ʆ @zULn|&uJet[ywqYH8N? eEY+hO5쨿R$3;uXi%n8 $xsYt0$GDuˎ7%HJZR )+ʇ8^8})JR)JR)JR)Ynm$ ԤvE[J\BX ޲ڔ!i @k~԰",co%2Rn.,nRJVARoS>*qf{rS60@%8*H%Gj)\ʋ+>[ʘG]I!*>#T/ZcQiiOfb֛_BkX8pV4'T_Mh)Jn%iVumg| Ŷ9S( ج'l~{Zv_ l~{Z^= _[$rLv7uYNթi-)^>A"+٨>_Sx5~fZ0fYP^ࢄ15)JR)JR+;"_ˇL > RTZ+SI)IVVWkg&{W%ٸ<* 19"\5Кb-$Hl%i~PJWﲢ,~鿽+=(}_5\^ʋI)_u]QLf\;k^-UC-F J-;  ZH>V$EBIyj*.‹./' QAx+AwQEfx6[ p bvHZj52Zm(HIt!DƭU.${V訚tuu0JTV8i}%+Rn~l6{r%8ѐ"X@8Cn%@oMj*$ BWC#TBX%JH"BL]C{BԬ?TBxۂhνf.7ZǺJ}7VXBUJ'P )j_IsJL9ҷLK.6U+ $aj!A#$S)JRsS5qLfId3$3ϟ ]RvgR>HBUrNp$n.t;xe$Sju!*9P'p۸`cx7T:YԲ):nvm01<`ÃQZޒd\- k)3ܓ'.OǺvIii9汔-[ cXHBUrNp$񃈹i+幷bkڤ8K UycT/F} ŭGODqN6ږRJ[g?3[iAHOCnABus![F8xoi`UDmFtukْkA\opm7B,YGڝHJT;I6䃞0M!ou,mN%[*w rA&ꐇC:QE6RÕw 9 ޭ~=j /ZN p%))'m<Qm6oZr˝΄ԆE4 =Jy h7T:YԲ):nvm01<`/׻®ru;q[,'ĵs ~oi`Om,t-}}amW2S!o0 H'ѻ7w l3B^J\G%DSۀs;n.t;xe$Sju!*9P'p۸`cxpMZw/u<8`n.t;xe$Sju!*9P'p۸`cxϵuVD4j| MZtR㛝V7(Jݣu-vMMnCj"6u)dNs# uJyjRQ-KݪnZɵX ,H;SZW Ӻ73ԖD`:R e><1>>ckr mɲgJű`,ʊ]pz7Rǿ]0-,fONХ$Յ'֒yquHCŝK("S Vʇi;s (I{̽$g{2ZB8JGcDž{)JRga}e;Ӆj'?uOMF>ʈO&NGm>e,<- q%Gy8WzRƓY\tOJGzF^$W#f@+έR#M\kMB[̄̇!!K@Q$dJdr:ˁ EF8RH)?G}%^_|f4mm7Ggv2N8ssJC ]#6Zm.3BlzNvdJI2Jb=l_=u}=t x"%lnT;#>9!'/,ժR)JR)Y]i2#W6ܗZ. ,wʒT?G'uM5j$8MFq 2]T:l;v7delK,9S@üJ>X>_[xK+:Q!֮shf,upc'¶6DKܩewF}`sBO^YT)JR)JRM?!˄kQ;BT2)[H A +B(rs}+fizٷ:|XR< P%(m(O5M`e67*z|`XwǗj)JNera=(q{ܒ6^T:JT5pz省79 l?22K`-D qj)P5ڂDw\e歲ۍHPiDG j)Rk)oiPqS}*c 'zϏ)Jl>{[J`LvAI˙W>;PfEM`e67*z|`XwǗj)JR)JR$轶*']Z:8F+ԡ5XLNB;0Ke T[R[n@ IFߊ&ȉt2Û=l0Ϭ|;I5j¾Z.N6 )n8}bB*l(yHP)φF9!'/,ժ ͟»?m[0kZJIqȁdPDF.v8W5-եYQS8oiSjl$sJ7N_!7ГrUK 4@,Dy TAJ@PN ݎ9|"cI0[fT{َ €p {;5 &XSovNZHeA'%ChLZ^5q퓟ȉ+nD1[oQ)M H;ԍ5pz省79 l?22K`-D qj)P5ڂDw\e歲ۍHPiDG jsmfԇזa쒜jĆdtÝ%+xV*EUV^fdf2RDw\ZlJG?Ujx%ޢr-L.BVAH@-4!( /JnLKf648d {[J`LvAI˙W>;PfEM`e67*z|`XwǗj)JR)JRy)քnJI) @n>u66DKܩewF}`sBO^YUf,":ݜ)hhkjTp H'״yWJ$[\lRJ#I0l9>vѫ}/c2 PHK'obm[,[z,Yr#2\[## ř;Dm0^;_R:6|ΦG{o9Ǫu%&N zTNG~ZZW]HԳOpmN#M\kMB[̄̇!!K@Q$dJT ft6ylj)RQ YݿKn.vɒ;# 6IR#vVY:֙e̲dH;m]5I;\6|g"!_KBSxz(nDil5 SI%D2JH>fvZ`w^t'0;x}uԞ"ߜkƈ%P-k pڛy s'%})C[ H^ܵzq}fvˋΥ h칕s1k[.Xscrށχy Q H6U_llܠ^-ŤǾ꫃d1o@IS8ݸ #9q:QLW6>,D-䔤li`rV96zgK#M \HNpv@$R*F=w֛ %BBI85^bmA";2V mR(4#A5|^} z\-wQ{ Q@`Q q8fu.m}(X.[I)HQV<nslʏ#P]o./jCVQXNH\_pu-0f&;E e̫(q3^&ȉt2Û=l0Ϭ|;I5j)JR)JR6DKܩewF}`sBO^YUMǻ~A*Zn(Uq20ʓ1q]GbfչJ ^pOu\>Uv[Ə63ײ3o<)d  1Q/m\Ln0HAUі ~Q-zp~ĊpZ-J6Cxݻo#b^FwKb>Kպ HZ[) ($dqFq#M\kMB[̄̇!!K@Q$dJT ft6ylj)RQ YG-8w$2* :j楧T#vȡRX J mD2p|g{~~v<|xIbDն3Ӿ;JBpPI†GT3)B4(t8DVХBIU>%s bTg3!X$(ppAWq~}Զ2|w88zx"%lnT;#>9!'/,ժR)JR)JVsSfXyLz3=⒑!*nc/BVZ8%,V8R-ue6u"`Owm?.y]Э~ۣ-=qT9J)9<dx5*}غPH댼նBq (ync/B;}tM`g^7vGָ[4Nu0K\?"kM5/Zp&-im"?imhcHHJ{hPÏtJa>FI$E yXZչ ;f~V}ѶW=:[v+p)ťiKn&l'Gc9lZ q0R$B =,=YKm."Ŗ w+1TBJIR]P*XN?I!Yam0cǂm-J@$ANBUtx96hrҧGp6Zl'p QodDXa͍ʞ_zg>$嚵JR)JR)Jx"%lnT;#>9!'/,ժW$L l9&6޻(pe;9NG#>4f|I$f[ImnNSύmˮ>mje{JT Ba^Gjp}D]z+9DiW ء.s1R]h:xIRS  Ҕ@oCj q[n6!AA9$ ;\#K 8GrhF'wA2< )օ- JH x nu !uΘ2U)=T`!YNrO{ǎXGaa6$ 8z)QodDXa͍ʞ_zg>$嚵JR)JR)Jx"%lnT;#>9!'/,) maJAJ\l$72vŨ5-,$[__RL$uk]Q ';:SaKڜ[[{NGX_;*mAijVQFvw\\bL!ISIhBaĀD=>}K{P9Aj$V Ӎ)(ߔbvY֭E7J?!Nӏ%*Gb FߝҵT3G's&LuxrJ$ JzC\v,^0C=@$7c8N)pΞ)JR)JRZmטsk XZ[]HV gS"i?w3>X&)cs?OC쥏->"i?w3>X&)cs?OC쥏->"i?w3>X&)cs?Y퉣EJ_j o_u;H@][s2bIА( gտC쥏->"i?w3>X&)cs?OC쥏->"i?w3>X&)cs?^I#N"Gפlm譴r3GSǍIřĸZv g6]x-+H4H2NJ黢.[i*$)(B % @V)JR)JR)JR)JR)JR)JR)J endstream endobj 10 0 obj 12904 endobj 11 0 obj /DeviceGray endobj 12 0 obj << /Filter [ /DCTDecode ] /Width 106 /Height 90 /ColorSpace 11 0 R /BitsPerComponent 8 /Length 13 0 R >> stream JFIFHHC    $.' ",#(7),01444'9=82<.342 ZjA !1AQa"4q2BCr#$Rb%356cs?+s#Qv\ ]K͔+PPw\[ӭA=sҽ)JR)]Vej $Sxn= |zW+e]3SQFryv)?^ SRN—A^|*֔)JRSxRd(7'QIQ[~8Hn4'NJ1[fݡ'*sɮa})JRI}LDgX==ՈOkp緱_ouI)J\Zsd u,y֎0`idZ>YێuT8޳%uG[2$9G*X/륹(iQtj@'~u :*.q}*JRWu)ٖ'4TYs`\?,Ilv=*:g'FSVBs!?4Tu۬Vz*-2T-}v}jRʕ.$%; *!H?OPc/slI[q:*\;̘*cZ9@Tk}o{ ҷⳤc88@Um!R_eӃ N֋eoAn3uRTN@s^6!¶0 WuwܕGNC\alLrܕ-!H C$u=JRY$3th!%.2GNkE f*J(d[SRMy̟9-g9& U$-⵷!рe'yx2]n: #$ojj[n#'QJ2p2mˌhV.N6|E[Ҕ)JR)JR endstream endobj 13 0 obj 1712 endobj xref 0 16 0000000000 65535 f 0000000010 00000 n 0000000141 00000 n 0000000190 00000 n 0000000249 00000 n 0000000457 00000 n 0000000544 00000 n 0000000562 00000 n 0000000600 00000 n 0000000708 00000 n 0000013793 00000 n 0000013815 00000 n 0000013843 00000 n 0000015694 00000 n 0000000000 00000 n 0000000000 00000 n trailer << /Size 16 /Info 1 0 R /Root 2 0 R >> startxref 15715 %%EOF gtkada-24.0.0/docs/gtkada_rm/gallery.png000066400000000000000000000015131446021174000200550ustar00rootroot00000000000000PNG  IHDR bKGD pHYs  IDAT8ՓObg{0PX4v%rgwn:r4eٸcc S"hA(PA xNڙ7vVٝ{C{ja.>aaaAv[٬_\\|]9<<$PJaOi2 dERlmmQ._+fh`@&accit]'Ji'''rvvF>J\4{~&&&Ì &KboopggGhZR]0kkkc6 `&"ReVVV4?@P`n(JLW_ϑNFjR&191 1<P؎P,c<3\Шau (D'֪PDAk-V,RD"!t_˲,듇eA{躎8]ަT*;~i:@$ KQ(n5qW3>cYl\_cY6V۷R*iwڌDF2at:~=hh@0gvy9o|˙fgg'^>FLrTk5^L2$xx<񿉿M% MmIENDB`gtkada-24.0.0/docs/gtkada_rm/generate_doc.pl000077500000000000000000000760001446021174000206720ustar00rootroot00000000000000#! /usr/bin/env perl ## This script generates the GtkAda documentation from the sources ## All the .ads in the src/ subdirectory are searched for relevant ## tags, and the documentation is automatically generated. ## The tags are looked for anywhere in the file. ## ## SETUP NOTES: ## This script should be run from the $prefix/doc/gtkada_ug ## directory in the GtkAda package. ## ## The following tags are known: ## ## ... ## This is the description for a package. It can span multiple ## lines, and contain any kind of text ## It no such tag is found, no documentation is generated for ## the package. ## Multiple such tags are concatenated. ## Lists are automatically replaced by @itemize items (a list ## is a set of paragraphs that start with '-'; the list ends ## at the first empty-line not followed by a paragraph that ## starts with '-'). ## ## ... ## Version number of gtk+ that was used to generate this file. ## ex/ 1.2.6 ## The package should be fully synchronized with the c header ## when this tag is used. ## If not such tag is found, the package is assumed to be more ## or less synchronized with gtk+1.2. Some functions might not ## have an Ada binding. ## ## ... ## Specifies the name of a file that shows a screenshot of the ## widget. The name should not include any extension (it will ## be ".eps" for the latex version of the documentation and ## ".jpg" for the html version. ## This tag won't be shown in the info file. ## The pixmap should be in the directory where you are compiling ## the documentation. ## ## ... ## Gives an example of use of the widget. The keywords and comments ## are automatically highlighted. Unless the example is short, we ## recommended using to include its code from an external ## compilable source file. ## ## ... ## Includes an external source file. The file is included inline, thus ## any enclosing tag is taken into account, as in ## file ## Note that comment starts are added at the beginning of each line. ## You can use relative pathnames (relative to the directory of the file ## containing this file). ## Both tags (opening and closing) should be on the same line. ## ## ## - "signal_name" ## signal description ## - "signal_name" .... ## ## This tag describes all the new signals defined by a widget. ## ## ... ## Indicates a section which should not be included in the documentation. ## All the subprograms inside the section will not be documented. The lines ## on which these tags are are completly deleted. ## ## The functions and procedures are automatically associated with ## the comments that follow them, and that stops at the first blank ## line. ## No documentation is generated for the following special subprograms: ## Initialize, Generate ## $src_dir = "../../src/"; # name of the source directory for GtkAda $output_file_name = "generated.texi"; $menu_file_name = "generated_menu.texi"; $with_html = 0; ## Whether we should output HTML support code $makeinfo_for_html = 0; ## Set to 1 if we use makeinfo to generate the HTML, to 0 if we use texi2html if ($ARGV[0] eq "-usemakeinfo") { $makeinfo_for_html = 1; $with_html = 1; shift @ARGV; } elsif ($ARG[0] eq "-usetexi2html") { $makeinfo_for_html = 0; $with_html = 1; shift @ARGV; } @source_files = @ARGV; local (@Ada_keywords) = ('abort', 'abs', 'accept', 'access', 'all', 'and', 'array', 'at', 'begin', 'body', 'case', 'constant', 'declare', 'delay', 'delta', 'digits', 'do', 'else', 'elsif', 'end', 'entry', 'exception', 'exit', 'for', 'function', 'generic', 'goto', 'if', 'in', 'is', 'limited', 'loop', 'mod', 'new', 'not', 'null', 'of', 'or', 'others', 'out', 'package', 'pragma', 'private', 'procedure', 'raise', 'range', 'record', 'rem', 'renames', 'return', 'reverse', 'select', 'separate', 'subtype', 'task', 'terminate', 'then', 'type', 'until', 'use', 'when', 'while', 'with', 'xor'); local (@Ada95_keywords) = ('abstract', 'aliased', 'protected', 'requeue', 'tagged'); local ($keywords_reg) = join ("|", @Ada95_keywords, @Ada_keywords); %package_from_type = ("Gtk_Plot" => "Gtk.Extra.Plot", "Gtk_Check_Item" => "Gtk.Extra.Check_Item", "Gtk_Plot_Layout" => "Gtk.Extra.Plot_Layout", "Gtk_Plot_Canvas" => "Gtk.Extra.Plot_Canvas", "Gtk_Plot_3D" => "Gtk.Extra.Plot_3D", "Gtk_Plot_Bar" => "Gtk.Extra.Plot_Bar", "Gtk_Plot_Box" => "Gtk.Extra.Plot_Box", "Gtk_Plot_Data" => "Gtk.Extra.Plot_Data", "Gtk_Plot_Polar" => "Gtk.Extra.Plot_Polar", "Gtk_Plot_Surface" => "Gtk.Extra.Plot_Surface", "Gtk_Combo_Box" => "Gtk.Extra.Combo_Box", "Gtk_Sheet" => "Gtk.Extra.Sheet", "Gtk_Color_Combo" => "Gtk.Extra.Color_Combo", "Gtk_Border_Combo" => "Gtk.Extra.Border_Combo", "Gtk_Font_Combo" => "Gtk.Extra.Font_Combo", "Gtk_IEntry" => "Gtk.Extra.Item_Entry", "Gtk_Item_Entry" => "Gtk.Extra.Item_Entry", "Gtk_Entry" => "Gtk.GEntry", "Gtk_Plot_Canvas_Child" => "Gtk.Extra.Plot_Canvas", "Gtk_Range" => "Gtk.Grange", "Gtk_Hbox" => "Gtk.Box", "Gtk_Vbox" => "Gtk.Box", "Gtk_Hpaned" => "Gtk.Paned", "Gtk_Vpaned" => "Gtk.Paned", "Gtk_Hruler" => "Gtk.Ruler", "Gtk_Vruler" => "Gtk.Ruler", "Gtk_Hscale" => "Gtk.Scale", "Gtk_Vscale" => "Gtk.Scale", "Gtk_Hscrollbar" => "Gtk.Scrollbar", "Gtk_Vscrollbar" => "Gtk.Scrollbar", "Gtk_Hseparator" => "Gtk.Separator", "Gtk_Vseparator" => "Gtk.Separator"); ## Contains the parent of each widget %parent = (); ## The output file (stored here so that we can sort the output) ## It is indexed on the package name %output = (); ## List of packages defined in GtkAda my (%packages) = (); ## Name of the package that is currently being proposed. $package_name=""; ## Colors used $chapter_bg="#FFF0D0"; $chapter_fg="#000000"; $section_bg="#FFD0D0"; $section_fg="#000000"; $subsection_bg="#FFF0D0"; $subprog_bg="#D6E8FF"; $hierarchy_bg="#FFF0D0"; $tab1_width="7%"; $tab2_width="30%"; $tab3_width="63%"; $tab23_width="93%"; # $tab2_width + $tab3_witdh # Prepares the menu foreach $source_file (@source_files) { open (FILE, $source_file); @content = ; close (FILE); # Only generate documentation if we have a tag if (grep (/\/, @content)) { @content = &delete_ignore(&expand_include (@content)); print "Generating doc for $source_file\n"; # Get the package name $package_name = &get_package_name (@content); my ($cfile) = &get_c_file ($package_name); # Underscores are incorrectly written in the table of contents # because of the font that is used in there. We thus use another # font just for them... local ($pack) = $package_name; $packages{$package_name} = ""; $pack =~ s/_/\@code{_}/g; &output ("\@page\n", "\@node Package_$package_name\n", "\@chapter Package $pack\n", "\@cindex $package_name\n"); &output ("\n\@noindent\n"); my ($description) = &clean_comment_marks (&get_tag_value ("description", @content), 0); $description =~ s/^\s*//; $description = &process_list ($description); # Add support for tags in the description $description =~ s/^\s+<(small)?example>/\@\2example\n/gm; $description =~ s/^\s+<\/(small)?example>/\@end \2example\n/gm; # Protect special characters $description =~ s/([{}@])/@\1/g; &output ("$description\n"); if (&get_tag_value ("screenshot", @content)) { if (-f &get_tag_value ("screenshot") . ".eps") { &output ("\@iftex\n\@image{", &get_tag_value ("screenshot", @content), ",}\n\@end iftex\n\n"); } } my (%signals) = &find_signals ($cfile . ".h", @content); my (@hierarchy) = &find_hierarchy (@content); my (@subprogs) = &get_subprograms (@content); my (%types) = &get_types (@content); ## Widget hierarchy if (@hierarchy) { my ($hierarchy, $hierarchy_short) = ("", ""); $hierarchy = sprintf ("\@b{%-30s (\@pxref{Package_%s})\n", "GObject}", "Glib.Object"); $hierarchy .= sprintf ("\@b{%-30s (\@pxref{Package_%s})\n", "Gtk_Object}", "Gtk.Object"); $hierarchy_short = sprintf ("%-30s (Package %s)\n", "Gtk_Object", "Gtk.Object"); for ($level = 1; $level < @hierarchy; $level ++) { $hierarchy .= " " x ($level * 3) . sprintf ("\\___ \@b{%-" . (25 - $level * 3) . "s (\@pxref{Package_%s})\n", $hierarchy[$level] . "}", &package_from_type ($hierarchy[$level])); my ($line) = " " x ($level * 3) . sprintf ("\\___ %-" . (25 - $level * 3) . "s (Package %s)\n", $hierarchy[$level], &package_from_type ($hierarchy[$level])); if (length ($line) > 75) { my ($length) = " " x ($level * 3); $line =~ s/\(/\n$length \(/; } $hierarchy_short .= $line; } §ion_output ("Widget Hierarchy"); &html_output ("
"); &output ("\n\@ifnottex\n"); &output ("\@smallexample\n$hierarchy\n\@end smallexample\n"); &output ("\@end ifnottex\n"); if ($with_html) { &output ("\@ifnothtml\n\@iftex\n\@smallexample\n$hierarchy_short\n", "\@end smallexample\n\@end iftex\n\@end ifnothtml\n"); } else { &output ("\@iftex\n\@smallexample\n$hierarchy_short\n", "\@end smallexample\n\@end iftex\n"); } &html_output ("
"); } else { $parent{$package_name} = "<>"; } ## List of signals if (keys %signals) { §ion_output ("Signals"); &output ("\@itemize \@bullet\n\n"); foreach $signal (sort keys %signals) { &output ("\@item \"\@b{$signal}\"\n\n"); my ($handler, $comment) = ($signals{$signal} =~ /^([^)]+\)[^;]*;)(.*)$/s); $handler = &highlight_keywords ($handler); if ($with_html) { &html_output ("
"); &output ("$handler"); &html_output ("
"); } else { &output ("\@smallexample\n"); &output ("$handler"); &output ("\n\@end smallexample\n"); } &output ("$comment\n"); } &output ("\@end itemize\n\n"); } ## List of types (sorted) if (%types) { §ion_output ("Types"); &html_output (""); foreach $type (sort keys %types) { if ($with_html) { &html_output (""); } else { &output ("\@smallexample\n\@exdent ", $types{$type}[0], "\n\@end smallexample\n"); &output ("\@noindent\n", $types{$type}[1], "\@*\n"); } } &html_output ("
"); &output ($types{$type}[0]); &html_output ("
"); &output ($types{$type}[1]); &html_output ("
"); } ## List of subprograms (sorted) if (@subprogs) { my ($has_itemize) = 0; §ion_output ("Subprograms"); &html_output (""); foreach $subprog (@subprogs) { my ($name, $return, $comment, @params) = ($$subprog[1], $$subprog[0], $$subprog[2], @{$$subprog[3]}); if ($return eq "--") { if ($has_itemize == 1) { $has_itemize = 0; } &html_output (""); $comment =~ s/^\s*//; if ($comment ne "") { # Protect special characters $comment = &process_list (&clean_comment_marks ($comment, 1)); $comment =~ s/([{}@])/@\1/g; &html_output (""); } next; } if ($has_itemize == 0) { $has_itemize = 1; } my ($profile) = ""; if ($return eq "" && scalar (@params) == 0) { $name .= ";"; } $profile = sprintf ("%-35s", ($return eq "") ? "\@b{procedure} $name" : "\@b{function} $name"); if (scalar (@params) > 0) { $profile .= "\n ("; for ($i=0; $i<=$#params; $i++) { $profile .= " " x 3 if ($i != 0); my ($type) = $params[$i][2]; my ($default) = ""; if ($params[$i][2] =~ /:=/ && length ($params[$i][2]) > 30) { $type =~ s/\s*:=.*//; $default = $params[$i][2]; $default =~ s/.*:=/:=/; } $profile .= sprintf ("%-18s : \@b{%-6s} %s", $params[$i][0], $params[$i][1], $type); if ($default ne '') { $profile .= "\n" . (' ' x 23) . $default; } $profile .= (($i == $#params) ? ")" : ";\n"); } } if ($return eq "") { $profile .= ";" if (scalar (@params) != 0); } else { $profile .= "\n" . " " x 3 if (scalar (@params) > 0); $profile .= "\@b{return} $return;"; } $comment =~ s/^\s*//; $comment = &process_list (&clean_comment_marks ($comment, 1)); if ($with_html) { &output ("\@ifnothtml\n\@smallexample\n$profile\n", "\@end smallexample\n\@end ifnothtml\n"); } else { &output ("\@smallexample\n$profile\n", "\@end smallexample\n"); } &html_output ("", ""); } &html_output ("
"); if ($name !~ /^\s*$/) { &output ("\@subsection $name\n\n"); } &html_output ("

"); &output ($comment, "\n\n"); &html_output ("
$profile
"); &output ("$comment\n"); &html_output ("
"); } ## Examples if any if (&get_tag_value ("example", @content)) { §ion_output ("Example"); &output ("\n\@example\n", &highlight_keywords (&clean_comment_marks (&get_tag_value ("example", @content), 0)), "\n\@end example\n"); } } else { # No tag # print "no description tag for $source_file\n"; } } ## Creates empty nodes for the packages that are referenced but not ## already created. # $parent{"Gtk_Object"} = ""; $parent{"GObject"} = ""; foreach $package_name (keys %parent) { $package_name = &package_from_type ($package_name); unless (defined $output{$package_name}) { &output ("\@node Package_$package_name\n", "\@chapter Package $package_name\n\n", "\@cindex $package_name\n"); } } ## Outputs the files ## Requires the global variables $output and $package_name foreach (keys %parent) { $packages{&package_from_type ($_)} = ""; } open (MENU, ">$menu_file_name"); print MENU "\@menu\n"; print MENU "* Package_", join ("::\n* Package_", sort keys %packages), "::\n"; print MENU "* Index::\n"; print MENU "\@end menu\n"; close MENU; open (OUT, ">$output_file_name"); foreach $package_name (sort { if ($a =~ /Glib/ && $b =~ /Glib/) { return $a cmp $b; } elsif ($a =~ /Glib/) { return -1; } elsif ($b =~ /Glib/) { return 1; } else { if ($a =~ /GtkAda/i && $b =~ /GtkAda/i) { return $a cmp $b; } elsif ($a =~ /GtkAda/i) { return -1; } elsif ($b =~ /GtkAda/i) { return 1; } else { return $a cmp $b; } }} keys %output) { print OUT join ("", @{$output{$package_name}}), "\n"; } close OUT; # Outputs some lines sub output () { push (@{$output{$package_name}}, @_); } # Outputs the block, only for html sub html_output () { if ($with_html) { if ($makeinfo_for_html) { &output ("\@ifhtml\n\@html\n", @_, "\n\@end html\n\@end ifhtml\n"); } else { &output ("\@ifhtml\n", @_, "\n\@end ifhtml\n"); } } } # Outputs the block, only for tex sub tex_output () { &output ("\n\@tex\n", @_, "\n\@end tex\n"); } # Print some output with special colors # $1 = name of the current package # $2 = name of the current section (doesn't include the name of the package) sub section_output () { my ($section) = shift; &html_output ("
$section
"); if ($with_html) { &output ("\@ifnothtml\n\@section $section\n\@end ifnothtml\n"); } else { &output ("\@section $section\n"); } } # Returns the name of the widget defined in the package whose contents is # @1. # The htable %parent is initialized, as a side effect sub find_type_in_package () { my ($type) = shift; ## if "", returns the main type. Otherwise, returns ## that type specifically my (@content) = @_; my ($line, $origin, $p); # If $type is unspecified, return the main type if ($type eq "") { $type = "[^ \t]+"; } # Ignore everything except for the private part (but see exception below) while (@content && $line !~ /^private/) { $line = shift @content; # Special Case: subtype declarations in the public part. if ($line =~ /subtype/) { # get the rest of the line while (@content && $line !~ /;/) { $line .= shift @content; } # Extract hierarchy information from a "recognized" declaration if ($line =~ /subtype ($type)_Record\s+is\s+([^;\s]+)/) { $origin = $1; unless ($parent{$origin}) { $p = $2; $p =~ s/_Record//; $p =~ s/.*\.([^.]+)/$1/; } } } } # Find the name of the type in the package @content while (@content && ! defined $p) { # read the current line, and make sure we get the end of the current # declaration $line = shift @content; while (@content && $line !~ /;/) { $line .= shift @content; } if ($line =~ /type ($type)_Record\s+is\s+new\s/) { $origin = $1; # Do not keep the package name $origin =~ s/.*\.([^.]+)/$1/; unless ($parent{$origin}) { if ($line =~ /is\s+new\s+([^\s]+)/) { if ($1 eq "") { $line = shift @content; $line =~ /\s+([^\s]+)/; } $p = $1; } else { $line = shift @content; $line =~ /((is)?\s+new)? ([^\s]+)/; $p = $3; } $p =~ s/_Record//; $p =~ s/.*\.([^.]+)/$1/; } } } if ($p ne "") { $parent{$origin} = $p; } return $origin; } # Expands a given ... and replace it with the content of # the file # Parameter: array of strings to check and possibly expand # Returns the new array where tags have been expanded. sub expand_include () { my (@content) = @_; my (@strings); my ($line); foreach $line (@content) { if ($line =~ /(.*)\(.*)\<\/include\>(.*)/) { push (@strings, $1); my ($file, $rest) = ($2, $3); if (open (INCLUDE_FILE, "$src_dir/$file")) { push (@strings, "\n-- " . join ("-- ", ) . "\n" . $rest); close (INCLUDE_FILE); } } else { push (@strings, $line); } } return @strings; } # Return the list of types defined in the Ada file $1. # This function does not return the type defined in the private part of the # package. # It returns a hash-table: # return ::= (type_name => (string_to_display, comment), ...) sub get_types () { my (@content) = @_; my (%types) = (); my ($current) = ""; my ($description); while (($line = shift @content)) { # Skip the private part if ($line =~ /^\s*private/) { return %types; } if ($line =~ /^\s*((sub)?type)\s*(\S+)\s+(.)/) { $current = $3; # print "======$current====\n"; $description = "$1 $current is "; # Be sure that we have on the same line the "is" and the following # character or word (open parenthesis or new). if ($line =~ /\sis\s*$/ || $line !~ /\sis/) { $line .= shift @content; } # Likewise for an access type, which could be an access to # subprogram if ($line =~ /access\s*$/) { $line .= shift @content; } $line =~ s/^\s+/ /g; # For an access to function type if ($line =~ s/access\s+(function|procedure)/access $1/) { my ($is_function) = ($1 eq "function"); $line =~ s/\(/\n \(/; $line =~ /(access (.|\n)*)/; $description .= $1; my ($length) = " "; # If there is a non-empty argument list, include it. if ($line =~ /\(/) { while ($line !~ /\)/) { $line = shift @content; $line =~ s/^\s+/ /; $description .= $length . $line; } } # Add the 'return' line if ($is_function && $line !~ /\Wreturn\W/) { $line = shift @content; $line =~ s/^\s+/ /; $description .= " $line"; } } # Else for a record type elsif ($line =~ /\Wrecord\W/) { $description .= "record\n"; while ($line !~ /record;/) { $line = shift @content; chop $line; $line =~ s/^\s+//; if ($line =~ s/^\s*--\s*//) { $description .= " -- $line\n"; } else { $description .= " $line\n"; } } } # Else if we have an enumeration type, get all the possible values # and the associated comments elsif ($line =~ s/^.*\sis\s+\(\s*(.*)//) { # There can be multiple values on the same line, separated # by commas. my ($length) = ' ' x (length ($description) - 0); $description .= "\n ($1\n"; $length = " "; while ($description !~ /\)/) { $line = shift @content; # If we have a comment if ($line =~ /^\s*--\s*(.*)$/) { $description .= $length . " -- $1\n"; } # Else we have one or more possible values else { $line =~ s/\s+/ /g; $description .= "$length$line\n"; } } } # Else for a simple type, skip to the end of its definition else { $line =~ /\sis\s+(.*)$/; $description .= $1; while ($line !~ /;/) { $line = shift @content; $line =~ s/\s+/ /g; $description .= $line; } } # print $description; $line = shift @content; # If we have a comment associated with the type, read it. my ($comment) = ""; if ($line =~ /^\s*--/) { while ($line !~ /^\s*$/) { $line =~ s/^\s*--\s*/ /; $comment .= $line; $line = shift @content; } } else { unshift (@content, $line); } # print "\n===>\n$comment\n==============\n"; # print $description, "\n"; # print &highlight_keywords ($description), "\n"; # Do not keep the widgets themselves if ($current !~ /_Record/ && $description !~ /access all .*_Record/) { $types{$current} = [&highlight_keywords ($description), $comment]; } } } return %types; } # Returns the list of signals defined in the C file $1. # The Ada file is defined in $2 # If the Ada file has a "" tag, then this is used instead # ( signal_name => profile, signal_name => profile) sub find_signals () { my ($cfile) = shift; my (@content) = @_; my (%signals); my ($ada_signals) = &get_tag_value ("signals", @content); # If the tag is found in the Ada file, use it if ($ada_signals ne "") { my ($signal, $descr); my (@lines) = split (/\n/, $ada_signals); my ($in_handler) = 0; foreach $line (@lines) { $line =~ s/^\s*--\s*//; if ($line =~ /- \"([^\"]+)\"/) { $signals{$signal} = $descr if ($signal ne ""); $signal = $1; $descr = ""; $in_handler = 1; } elsif ($line =~ /^\s*$/) { if ($in_handler == 1) { $in_handler = 0; $descr .= ""; } $descr .= "\n"; } else { $descr .= $line . "\n"; } } $signals{$signal} = $descr if ($signal ne ""); } return %signals; } # Returns the type hierarchy of the main type defined in the file whose # content is @1 sub find_hierarchy () { my (@content) = @_; my ($origin) = &find_type_in_package ("", @content); if ($origin =~ /^Gtk/) { return &find_hierarchy_array ($origin); } else { return (); } } sub find_hierarchy_array () { my ($type) = shift; if ($type =~ /Gtk_Object/ || $type =~ /GObject/i) { return ($type); }; unless ($parent{$type}) { my ($filename) = &file_from_package (&package_from_type($type)); if (-f $src_dir . "/gtk-" . $filename) { open (FILE, $src_dir . "/gtk-" . $filename); } elsif (-f $src_dir . "/gtk-extra-" . $filename) { open (FILE, $src_dir . "/gtk-extra-" . $filename); } else { die "file not found for type $type ($filename)\n"; } my ($origin) = &find_type_in_package ($type, ); close (FILE); return (&find_hierarchy_array ($parent{$type}), $type); } return (&find_hierarchy_array ($parent{$type}), $type); } # Returns the name of the file that contains a given package sub file_from_package () { my ($package) = shift; $package =~ s/G[dt]k\.//; $package =~ s/\./-/g; $package =~ tr/A-Z/a-z/; return $package . ".ads"; } # Returns the name of the Ada package that contains the type $1 sub package_from_type () { my ($string) = shift; if (defined $package_from_type{$string}) { return $package_from_type{$string}; } else { $string =~ s/(G[td]k)_/$1./; return $string; } } # Prepare the string $1 for output (highlight keywords and comments) sub highlight_keywords () { my ($string) = shift; # Protect texi special characters $string =~ s/([{}])/\@$1/g; # Highlight keywords and commands $string =~ s/--([^\n]*)/-\@:-\@i{$1}/g; $string =~ s/\b($keywords_reg)\b/\@b{$1}/g; # Do not highlight keywords in comments ! while (($string =~ s/\@i(.*)\@b{([^\}]+)}(.*)/\@i$1$2$3/g)){}; return $string; } # Returns the name of the C file corresponding to the Ada package $1 sub get_c_file () { my ($file) = shift; $file =~ tr/A-Z/a-z/; $file =~ s/[_.]//g; return $file; } # Delete all the sections that should be ignored in the documentation sub delete_ignore () { my (@content) = @_; my (@output) = (); my ($ignore)=0; foreach $line (@content) { if ($line =~ /\/) { $ignore=1; } push (@output, $line) if (! $ignore); if ($line =~ /\<\/doc_ignore\>/) { $ignore=0; } } return @output; } # Returns the package name from the file whose content is $1 sub get_package_name () { my (@content) = @_; ($_) = grep (/^package /, @content); $_ =~ /^package\s*([^\s]+)/; return $1; } # Eliminates the comment marks in the string (i.e suppress the -- at # the beginning of each line in $1) # When there is an empty line, replaces it with @* # And the first line is ended with @* if $2 is 1 sub clean_comment_marks() { my ($string) = shift; my ($first_line) = shift; # get rid of comments $string =~ s/^[ \t]*-- ?//; $string =~ s/\n[ \t]*-- ?/\n/g; # If needed, separate the first line from the rest (if there is more # than one line) if ($first_line) { if ($string =~ /\n.*\n/) { $string =~ s/\n/\@*\n/; } } return $string; } # Processes the lists, and replaces them with some @itemize instructions. # A list is recognized when at least one line starts with '-' as the first # non-white character, and ends after the next empty line. sub process_list() { my ($value) = shift; my (@lines) = split (/\n/, $value); my ($output); my ($in_list) = 0; my ($terminate_list) = 0; foreach $line (@lines) { if ($line =~ /^\s*-\s/) { $output .= "\@itemize \@bullet\n" if (! $in_list); $in_list = 1; $terminate_list = 0; $line =~ s/^\s*-/\@item /; } elsif ($in_list && $line =~ /^\s*$/) { $terminate_list = 1; } elsif ($terminate_list) { $output .= "\@end itemize\n"; $terminate_list = 0; $in_list = 0; } $output .= $line . "\n"; } $output .= "\@end itemize\n" if ($in_list); return $output; } # Returns the value of the tag $1, in the file whose content is $2 # All the matching tags found in the documentation are concatenated, # with a blank line added between them. sub get_tag_value () { my ($tag) = shift; my (@content) = @_; my ($value) = ""; my ($line, $add); while (@content) { $line = shift @content; if ($line =~ /\<$tag\>/) { if ($value ne "") { $value .= "\n"; } $line =~ /\<$tag\>(.*)/; $value .= $1; while ($line !~ /<\/$tag\>/) { $line = shift @content; $value .= $line; } $value =~ s/\<\/$tag\>.*//; } } return $value; } # Returns a list of all the subprograms defined in the file whose # content is $1. # The format of the list is the following: # ( (subprogram_return_type, # "" for a procedure "--" for a separator # subprogram_name, # comments # (param1_name, # param1_access, # "in", "in out", "access", "" # param1_type) # (param2_name, # param2_access, # param2_type), # ... # ) # (subprogram_return_type, .... # sub get_subprograms () { my (@content) = @_; my ($line); my (@result) = (); my ($saw_package_start) = 0; my ($last_was_section) = 0; while (@content) { $line = shift @content; if ($line =~ /^package /) { $saw_package_start = 1; next; } if ($saw_package_start && $line =~ /^\s*------*/) { # Delete the previous section if it was empty if ($last_was_section != 0) { pop (@result); } $line = shift @content; $line =~ /-- (.*) --/; my ($comments) = ""; my ($section) = $1; $line = shift @content; while ($content [0] =~ /^\s*--/) { $comments .= shift @content; } push (@result, ['--', $section, "$comments", ()]); $last_was_section = 1; # Else if we have a subprogram or operator definition } elsif ($line =~ /^\s*(procedure|function)\s+([\w\"+\-*\/&]+)\s*(.*)/) { my ($type) = $1; my ($name) = $2; my ($params) = $3; # If the line was over multiple lines if ($params !~ /;/) { $params .= shift @content; } # Get the whole parameter list if ($params =~ /\(/) { while ($params !~ /\)/) { $params .= shift @content; } } $params =~ s/\s+/ /g; my ($dummy, $profile, $return) = ($params =~ /^\s*(\(\s*([^\)]+)\))?(.*)/); # If we expect a return type, make sure we have it if ($type eq "function") { while ($return !~ /;/) { $return .= shift @content; } } my ($ret_type) = ($return =~ /return\s+([^\s;]+)/); # Memorizes the comments (if we have any) my ($comments) = ""; $line = shift @content; if ($line !~ /^\s*--/) { unshift @content, $line; } while ($line =~ /^\s*--/) { $comments .= $line; $line = shift @content; } # Parses the profile my (@param_list) = (); while ($profile !~ /^ *$/) { my ($all, $tname, $taccess, $ttype) = ($profile =~ /(\s*([\w\s,]+)\s*:\s*(in out|in|out|access)?\s*([^;]+);?)/); push (@param_list, [$tname, $taccess, $ttype]); $all =~ s/([()])/\\\1/g; $profile =~ s/$all//; } # Ignore the special subprogram "Generate" and "Initialize" if ($name ne "Generate" && $name !~ /^Initialize/) { push (@result, [ $ret_type, $name, $comments, \@param_list]); $last_was_section = 0; } } } if ($last_was_section == 1) { pop @result; } return @result; } gtkada-24.0.0/docs/gtkada_rm/generate_html_doc.pl000077500000000000000000001160631446021174000217220ustar00rootroot00000000000000#! /usr/bin/env perl use warnings; use strict; ## This script generates the GtkAda documentation from the sources ## All the .ads in the src/ subdirectory are searched for relevant ## tags, and the documentation is automatically generated. ## The tags are looked for anywhere in the file. ## ## SETUP NOTES: ## This script should be run from the $prefix/doc/gtkada_ug ## directory in the GtkAda package. ## ## The following tags are known: ## ## ... ## This is the description for a package. It can span multiple ## lines, and contain any kind of text ## It no such tag is found, no documentation is generated for ## the package. ## Multiple such tags are concatenated. ## Lists are automatically replaced by @itemize items (a list ## is a set of paragraphs that start with '-'; the list ends ## at the first empty-line not followed by a paragraph that ## starts with '-'). ## ## ... ## Version number of gtk+ that was used to generate this file. ## ex/ 1.2.6 ## The package should be fully synchronized with the c header ## when this tag is used. ## If not such tag is found, the package is assumed to be more ## or less synchronized with gtk+1.2. Some functions might not ## have an Ada binding. ## ## ... ## Specifies the name of a file that shows a screenshot of the ## widget. The name should not include any extension (it will ## be ".eps" for the latex version of the documentation and ## ".jpg" for the html version. ## This tag won't be shown in the info file. ## The pixmap should be in the directory where you are compiling ## the documentation. ## ## ... ## Gives an example of use of the widget. The keywords and comments ## are automatically highlighted. Unless the example is short, we ## recommended using to include its code from an external ## compilable source file. ## ## ... ## Includes an external source file. The file is included inline, thus ## any enclosing tag is taken into account, as in ## file ## Note that comment starts are added at the beginning of each line. ## You can use relative pathnames (relative to the directory of the file ## containing this include). ## This is only supported within ## ## ## - "signal_name" ## signal description ## - "signal_name" .... ## ## This tag describes all the new signals defined by a widget. ## ## ## -- Name: name ## -- Type: type ## -- Descr: descr ## ## Describes the properties of the widget ## ## ## Same syntax as , documents properties for children ## ## ## Same syntax as , documents style properties ## ## file.adb ## Specifies the name of the source file in testgtk that contains example ## for the widget ## ## ... ## Indicates the group in which the package should be listed in the ## general index. ## ## ... ## The name of a package that the user should also visit for more information ## on this widget. You can have several such links if there are more than one ## package. ## ## ... ## Indicates a section which should not be included in the documentation. ## All the subprograms inside the section will not be documented. The lines ## on which these tags are are completly deleted. ## ## The functions and procedures are automatically associated with ## the comments that follow them, and that stops at the first blank ## line. ## No documentation is generated for the following special subprograms: ## Generate ## # The list of files to parse our @source_files = @ARGV; # The special keywords to highlight in profiles and examples our @Ada_keywords = ('abort', 'abs', 'accept', 'access', 'all', 'and', 'array', 'at', 'begin', 'body', 'case', 'constant', 'declare', 'delay', 'delta', 'digits', 'do', 'else', 'elsif', 'end', 'entry', 'exception', 'exit', 'for', 'function', 'generic', 'goto', 'if', 'in', 'is', 'limited', 'loop', 'mod', 'new', 'not', 'null', 'of', 'or', 'others', 'out', 'package', 'pragma', 'private', 'procedure', 'raise', 'range', 'record', 'rem', 'renames', 'return', 'reverse', 'select', 'separate', 'subtype', 'task', 'terminate', 'then', 'type', 'until', 'use', 'when', 'while', 'with', 'xor'); our @Ada95_keywords = ('abstract', 'aliased', 'protected', 'requeue', 'tagged'); our $keywords = join ("|", @Ada95_keywords, @Ada_keywords); ## List of special sections in the Ada files our @xml_sections = ("description", "example", "screenshot", "c_version", "see", "signals", "properties", "child_properties", "style_properties", "testgtk", "group"); ## Will contain, for each widget, the name of its parent type. The parent ## doesn't contain a package name. our %parents; ## Will contain the name of packages for each widget. Indexed on widget name ## The second variable contains the name of html file for each widget. our %packages; our %files_from_widget; our %files_from_package; ## List of all known entities. Key is the entity name, prefixed by package, ## contents is ## [$file, $a_name] ("a_name" is the name of the HTML anchor our (%entities); ## Will contain info about each of the source files (subprograms,...). Indexed ## on file name. our %files; ## The groups for the index. Key is the group name, contents is an array of ## package our %groups; ## The list of types that implements an interface. Index is the interface name (short), ## value is the list of types that implement it our %implemented; ## The list of screenshots. Index is package name, value is image name our %screenshots; ##################### ## Name of the HTML output file (suitable for links) for an Ada file ##################### sub html_from_ada() { my ($file) = shift; $file =~ s/^.*\/([^\/]+).ads/$1.html/; return $file; } ##################### ## Parse an Ada file, and extra each of the relevant special sections ##################### our $subprogram_re = '\n[ \t]*(?:(?:procedure|function)\s+(\w+|".")\s*(?:\([^)]+\))?[^;]*?;)'; our $empty_comment_re = '(?:[ \t]+--\n)'; our $non_empty_comment_re = '(?:[ \t]+--[^\n]+\n)'; our $non_empty_comment_block_re = '(' . $non_empty_comment_re . '*)'; our $comment_block_re = '((?:[ \t]*--[^\n]*\n)*)'; our $section_and_comment_re = "\n[ \t]+--[ \t]+([^\n]+?)[ \t]+--\n[ \t]+--+\n" . $non_empty_comment_block_re; our $subprogram_and_comment_re = "((?:$subprogram_re)+)\n" . $comment_block_re; our $widget_re = '\n\s*type\s+(\w+)\s+is\s+(?:abstract\s+)?(?:tagged\s+private|new\s+([\w\.]+)\s+with)'; our $type_re = '\s*(type\s+(\w+)\sis\s+((?:access\s*(?:function|procedure)\s*\([^)]+\))?[^;]*);)\n' . $comment_block_re; our $interface_re = 'is\s+new\s+(?:Glib\.Types\.)?Implements\s*\(([\w\.]+),\s*([\w\.]+)'; sub extract_sections() { my ($file) = shift; my ($html_file); my ($tags) = join ("|", @xml_sections); my (%tags, @subprograms, $package, @widgets); my ($section, $section_pushed, @sections, %types, @interfaces); my ($count) = 1; open (FILE, $file) || die "File not found: $file"; my ($contents) = join ("", ); close (FILE); # Find package name ($package) = ($contents =~ /^package ([\w\.]+) is/m); return if (!defined $package); $html_file = &html_from_ada($file); # Remove sections that must be ignored $contents =~ s/.*?<\/doc_ignore>/\n/gs; # Find all special tags while ($contents =~ /<($tags)>(.*?)<\/\1>/osg) { my ($tag, $value) = ($1, $2); if (defined $tags{$tag}) { $tags{$tag} .= "\n$value"; } else { $tags{$tag} = $value; } } # No ? => No automatic doc should be generated if (!defined $tags{'description'}) { return; } $files_from_package{$package} = $html_file; $entities{$package} = [$html_file, ""]; # Store for the index if (defined $tags{'group'}) { push (@{$groups{$tags{'group'}}}, $package); } else { push (@{$groups{"Miscellaneous"}}, $package); } # Store the screenshot if (defined $tags{'screenshot'}) { my ($screenshot) = $tags{'screenshot'}; $screenshot .= ".jpg" if (-f "$screenshot.jpg"); $screenshot .= ".png" if (-f "$screenshot.png"); $screenshots{$package} = $screenshot; $tags{'screenshot'} = $screenshot; } # Remove private part, after finding special tags. Ignore private part # for local packages $contents =~ s/\nprivate\s.*//s; # Remove these special tags so that they get ignored when looking for # subprograms (think of examples and/or signal descriptions). In fact, this # might not be needed since these other subprograms will be inside comments # and will therefore not match $subprogram_re. #$contents =~ s/<($tags)>.*?<\/\1>//osg; # Find widget names while ($contents =~ /$widget_re/og) { my ($widget, $parent) = ($1, $2); if (defined $parent) { $parent =~ s/^.*?\.(\w+)$/$1/; $parents{$widget} = $parent; } else { $parents{$widget} = ""; } push (@widgets, $widget); $packages{$widget} = $package; $entities{"$package.$widget"} = [$html_file, ""]; $files_from_widget{$widget} = $html_file; } # Find types while ($contents =~ /$type_re/og) { my ($definition, $name, $parent, $comment) = ($1, $2, $3, $4); $entities{"$package.$name"} = [$html_file, ""]; if ($name eq "GType_Interface") { $parents{$name} = ""; $files_from_widget{$name} = $html_file; } elsif ($parent =~ /GType_Interface/) { $parents{$name} = "GType_Interface"; $files_from_widget{$name} = $html_file; } $types{$name} = [$definition, $comment]; } # Find interfaces while ($contents =~ /$interface_re/og) { my ($interface, $object) = ($1, $2); push (@interfaces, $interface); $interface =~ s/^.*?\.([^.]+)$/$1/; push (@{$implemented{$interface}}, $object); } # Find subprograms $section = "General"; push (@sections, [$section, ""]); $section_pushed = 0; while ($contents =~ /(?:$subprogram_and_comment_re)|(?:$section_and_comment_re)/og) { if (defined $1) { my ($description, $comment) = ($1, $3); push (@subprograms, [$section, $description, $comment]); $section_pushed = 0; ## Store the subprograms in the list of entities while ($description =~ /($subprogram_re)/og) { my ($sname) = ($2); $entities {"$package.$sname"} = [$html_file, "${sname}_${count}_"]; $count ++; } } else { pop (@sections) if ($section_pushed); ## No contents => ignore $section = $4; push (@sections, [$section, $5]); $section_pushed = 1; } } pop (@sections) if ($section_pushed); ## No contents => ignore $files{$file} = [$package, \%tags, \@subprograms, \@widgets, \@sections, \%types, \@interfaces]; } ##################### ## Return a processed version of the comment ##################### sub process_comment() { my ($comment) = shift; my ($package) = shift; my ($params) = shift; my (%params) = (); %params = %{$params} if (defined $params); $comment =~ s/^\s*--( )?//gm; # Empty line => Force a new paragraph $comment =~ s/\n\n/\n

\n/g; # Highlight URLs $comment =~ s,(http://\S+),$1<\/a>,g; # Highlight internal cross-refs. This is done by detecting words starting # with an upper case that reference a known package or widget type $comment =~ s/([A-Z](?:\.?\w+)*)/ my ($name) = $1; my ($file, $anchor); if (defined $params{$name}) { "$name<\/tt>"; } else { if (defined $entities{$name}) { ($file, $anchor) = @{$entities{$name}}; } elsif (defined $entities{"${name}_Record"}) { ($file, $anchor) = @{$entities{"${name}_Record"}}; } elsif (defined $entities{"$package.${name}_Record"}) { ($file, $anchor) = @{$entities{"$package.${name}_Record"}}; } elsif (defined $entities{"$package.$name"}) { ($file, $anchor) = @{$entities{"$package.$name"}}; } if (defined $file) { if ($anchor ne "") { "$name<\/a>"; } else { "$name<\/a>"; } } else { $name; } } /xeg; ## Highlight cross-refs to specific file names (only starting with g ## so that we do not add xref to files in testgtk, since no html is ## generated for these) $comment =~ s/\b(g[\w.-]+)(\.ad[bs])/$1$2<\/a>/g; return $comment; } ##################### ## Display the profile of a subprogram, including xref ##################### sub process_profile() { my ($profile) = shift; # Unindent as much as possible $profile =~ s/^[ \t]*\n//mg; my ($spaces) = ($profile =~ /^(\s*)/); $profile =~ s/^$spaces//gm; # Remove empty lines $profile =~ s/\s*$//; # Create xref for types $profile =~ s/(:\s*(?:access|in|out)?\s*)([\w.]+)((?:'Class)?(\s*:=\s*\w+)?[;)])/ if (defined $entities{$2}) { "$1$2<\/a>$3"; } else { "$1$2$3"; } /xeg; $profile =~ s/(return\s+|is\s+new\s+)([\w.]+)/ if (defined $entities{$2}) { "$1$2<\/a>"; } else { "$1$2"; } /xeg; return &highlight_syntax ($profile); } sub highlight_syntax() { my ($profile) = shift; # Highlight comments $profile =~ s/^([ \t]*--.*)/$1<\/i>/mg; # Highlight subprogram name (for subprograms section, not examples) $profile =~ s/^(procedure|function)\s+(\w+|".")/$1 $2<\/span>/gi; # Highlight keywords, not in comments $profile =~ s/\b($keywords)\b/$1<\/b>/og; while (($profile =~ s/(.*)(\w+)<\/b>/$1$2/g)){}; return $profile; } ###################### ## Parse the signals section ###################### our $non_empty_non_signal_comment_re = '(?:[ \t]+-- [^-][^\n]*\n)'; our $non_empty_comment_non_signal_block_re = '(' . $non_empty_non_signal_comment_re . '*)'; our $signal_re = '--[ \t]+-[ \t]*"(\w+)"\n' # Signal name . '[ \t]+--[ \t]+((?:procedure|function) Handler[\s-]+\([^)]+\)[\s-]*' . '(?:return [\w.]+)?;)\n' . $empty_comment_re . '?' # Optional blank line between profile and comment . $non_empty_comment_non_signal_block_re; # comment sub parse_signals() { my ($section) = shift; my (%signals); while ($section =~ /$signal_re/goi) { my ($name, $profile, $comment) = ($1, $2, $3); $profile =~ s/^\s+--//mg if (defined $profile); $signals{$name} = [$profile, $comment]; } return %signals; } ###################### ## Parse the properties section ###################### our $properties_re = '--[ \t]+(?:- )?Name:[ \t]*(.+)\n' . '[ \t]+--[ \t]+(?:- )?Type:[ \t]*(.+)\n' . '(?:[ \t]+--[ \t]+(?:- )?Flags:[ \t]*(.+\n))?' . '(?:[ \t]+--[ \t]+(?:- )?Descr:[ \t]*(.+\n(?:--[ \t]{4,})*))?' . '(?:[ \t]+--[ \t]+(?:- )?See also:[ \t]*(.+)\n)?'; sub parse_properties() { my ($section) = shift; my (%properties); while ($section =~ /$properties_re/goi) { my ($name, $type, $descr, $see) = ($1, $2, $4, $5); $properties{$name} = [$type, $descr, $see]; } return %properties; } ###################### ## Generate a HTML header in the given FILE ###################### sub generate_header() { my ($title) = shift; local (*FILE) = shift; # Headers print FILE "\n"; print FILE '', "\n"; print FILE "\n"; print FILE " GtkAda: $title\n"; print FILE " \n"; print FILE " \n"; print FILE "\n"; # Page title print OUTPUT "

\n"; print OUTPUT " Toc"; print OUTPUT " Gallery\n"; print OUTPUT " Index\n"; print OUTPUT " Tree\n"; print OUTPUT " \n$title\n"; print OUTPUT "
\n\n"; } ###################### ## Generate HTML for a package ###################### sub generate_html() { my ($filename) = shift; my ($output) = &html_from_ada ($filename); my ($package) = $files{$filename}[0]; my (%tags) = %{$files{$filename}[1]}; my (@subprograms) = @{$files{$filename}[2]}; my (@widgets) = @{$files{$filename}[3]}; my (@sections) = @{$files{$filename}[4]}; my (%types) = %{$files{$filename}[5]}; my (@interfaces) = @{$files{$filename}[6]}; my ($w, $current); my ($parent_package, $parent_file); my ($count) = 1; my ($has_types) = scalar (keys %types) > 0; # Start generating the output $w = $widgets[0]; if (defined $w && defined $parents{$w}) { $parent_package = $packages{$parents{$w}}; $parent_file = $files_from_widget{$parents{$w}}; } open (OUTPUT, ">gtkada_rm/$output"); &generate_header ("$package", *OUTPUT); ## Left side print OUTPUT "
\n"; ## Screenshot if (defined $tags{"screenshot"}) { my ($screenshot) = $tags{"screenshot"}; print OUTPUT "
\n"; print OUTPUT "

Screenshot

\n"; print OUTPUT " No screeshot\n"; print OUTPUT "
\n\n"; } ## Class hierarchy if (defined $widgets[0]) { print OUTPUT "
\n"; print OUTPUT "

Hierarchy

\n"; &generate_tree_for_widgets (\@widgets, 0, *OUTPUT); print OUTPUT "
\n\n"; } ## Interfaces if ($#interfaces >= 0) { print OUTPUT "
\n"; print OUTPUT "

Interfaces

\n"; print OUTPUT "
    \n"; foreach (@interfaces) { my ($name) = $_; my ($short) = $name; $short =~ s/^.*?\.([^.]+)$/$1/; my ($f) = $files_from_widget{$short}; if (defined $f) { print OUTPUT "
  • $name
    • \n"; } } print OUTPUT "
\n"; print OUTPUT "
\n\n"; } ## Implemented by my ($has_interface) = 0; foreach (keys %types) { my ($def) = $types{$_}->[0]; if ($def =~ /GType_Interface/ && $_ ne "GType_Interface") { $has_interface = $_; } } if ($has_interface) { print OUTPUT "
\n"; print OUTPUT "

Implemented by

\n"; print OUTPUT "
    \n"; foreach (@{$implemented{$has_interface}}) { print OUTPUT "
  • $_
    • \n"; } print OUTPUT "
\n"; print OUTPUT "
\n\n"; } ## Navigation print OUTPUT " \n\n"; ## See also if (defined $tags{"see"}) { print OUTPUT "
\n"; print OUTPUT "

See Also

\n"; print OUTPUT "
    \n"; foreach $w (split ("\n", $tags{'see'})) { my ($file) = $files_from_package{$w}; if (defined $file) { print OUTPUT "
  • $w
    • \n"; } } print OUTPUT "
\n"; print OUTPUT "
\n\n"; } ## Finish left side print OUTPUT "
\n\n"; ## Documentation print OUTPUT "
\n"; ## Notebook print OUTPUT "
    \n"; print OUTPUT "
  • Entities
    • \n"; print OUTPUT "
  • Signals
    • \n" if (defined $tags{"signals"}); print OUTPUT "
  • Properties
    • \n" if (defined $tags{"properties"} || defined $tags{"style_properties"} || defined $tags{"child_properties"}); print OUTPUT "
  • Examples
    • \n" if (defined $tags{"example"}); print OUTPUT "
  • Testgtk
    • \n" if (defined $tags{"testgtk"}); print OUTPUT "
\n\n"; ## First notebook page print OUTPUT "
\n"; ## Description of package if (defined $tags{'description'}) { print OUTPUT " \n"; print OUTPUT "
\n"; print OUTPUT "

Description

\n"; print OUTPUT &process_comment ($tags{'description'}, $package); print OUTPUT "
\n\n"; } ## Page1 => Types if ($has_types) { print OUTPUT " \n"; print OUTPUT "
\n"; print OUTPUT "

Types

\n"; print OUTPUT "
    \n"; foreach (sort keys %types) { my ($name, $def, $comment) = ($_, $types{$_}->[0], $types{$_}->[1]); $def =~ s/) is ..." $def =~ s/>/>/g; print OUTPUT "
  • \n"; print OUTPUT "
    ", &process_profile($def), "
    \n"; print OUTPUT "
    ", &process_comment($comment, $package), "
    • \n"; } print OUTPUT "
\n"; print OUTPUT "
\n\n"; } ## Page1 => Subprograms print OUTPUT " \n"; print OUTPUT " \n"; print OUTPUT "
\n"; print OUTPUT "

Subprograms

\n"; print OUTPUT "
    \n"; my (%names); my ($current_section) = "General"; $count = 1; foreach $w (@subprograms) { my ($section, $description, $comment) = ($w->[0], $w->[1], $w->[2]); if ($section ne $current_section) { $current_section = $section; $section =~ s/[ \t]/_/g; print OUTPUT " \n"; print OUTPUT "

    $current_section

    \n"; foreach (@sections) { my ($name, $comment) = ($_->[0], $_->[1]); if ($name eq $current_section) { print OUTPUT "
    ", &process_comment ($comment, $package), "
    \n\n"; } } } print OUTPUT "
  • "; my (%params) = (); while ($description =~ /($subprogram_re)/og) { my ($sname, $sprofile) = ($2, $1); # Output profile for each subprograms in the group print OUTPUT "\n"; print OUTPUT "
    ", &process_profile ($sprofile), "
    \n"; # Save the name for the index $names{"${sname}_${count}_"} = $sname; $count++; } # Highlight parameters while ($description =~ /[(;]\s*(?:--)?\s*(\w+)\s*:/og) { my ($pname) = $1; $params{$pname}++; } # Output the common comment for all subprograms in the group print OUTPUT "
    ", &process_comment ($comment, $package, \%params), "
    • \n"; } print OUTPUT "
\n"; print OUTPUT "
\n\n"; ## End of first notebook page print OUTPUT "
\n"; ## Second notebook page (signals) if (defined $tags{'signals'}) { print OUTPUT "
\n"; print OUTPUT " \n"; print OUTPUT "
\n"; print OUTPUT "

Signals

\n"; my (%signals) = &parse_signals ($tags{'signals'}); print OUTPUT "
    \n"; foreach (sort keys %signals) { my ($name, $profile, $comment) = ($_, $signals{$_}->[0], $signals{$_}->[1]); print OUTPUT "
  • $name
    \n"; print OUTPUT "
    ", &process_profile ($profile), "
    \n"; print OUTPUT "
    ", &process_comment ($comment, $package), "
    • \n"; } print OUTPUT "
\n"; print OUTPUT "
\n"; print OUTPUT "
\n\n"; } ## Third notebook page (properties) my ($proptype); my (%properties_sections) = ('properties' => 'Properties', 'child_properties' => 'Child Properties', 'style_properties' => 'Style Properties'); print OUTPUT "
\n"; foreach $proptype (('properties', 'child_properties', 'style_properties')) { if (defined $tags{$proptype}) { print OUTPUT " \n"; print OUTPUT "
\n"; print OUTPUT "

$properties_sections{$proptype}

\n"; my (%props) = &parse_properties ($tags{$proptype}); print OUTPUT "
    \n"; foreach (sort keys %props) { my ($name, $type, $descr, $see) = ($_, $props{$_}->[0], $props{$_}->[1], $props{$_}->[2], $props{$_}->[3]); print OUTPUT "
  • $name
    \n"; print OUTPUT "
    $type
    \n"; print OUTPUT "
    ", (defined $descr ? &process_comment ($descr, $package) : ""), (defined $see ? "
    See: " . &process_comment ($see, $package) : ""), "
    • \n"; } print OUTPUT "
\n"; print OUTPUT "
\n"; } } print OUTPUT "
\n\n"; ## Fourth page (example) if (defined $tags{'example'}) { print OUTPUT "
\n"; print OUTPUT " \n"; print OUTPUT "
"; print OUTPUT "

Example

"; my ($example) = $tags{'example'}; if (($example =~ /(.*)<\/include>/)) { my ($base, $dirname) = ($1, $filename); $dirname =~ s,/[^/]+$,/,; open (EXAMPLE, "$dirname$base") || print "Cannot open $dirname$base\n"; $example = join ("", ); close (EXAMPLE); } $example =~ s/^\s*--//mg; print OUTPUT &highlight_syntax ($example); print OUTPUT "
\n"; print OUTPUT "
\n\n"; } ## Fifth page (testgtk) if (defined $tags{'testgtk'}) { print OUTPUT "
\n"; print OUTPUT " \n"; print OUTPUT "
"; print OUTPUT "

Testgtk source code

"; print OUTPUT "
This code is part of testgtk, a demo application", " packaged with GtkAda. Testgtk demonstrates the various", " widgets of GtkAda
"; open (TESTGTK, "../../testgtk/$tags{'testgtk'}") || print "Cannot open file testgtk file $tags{'testgtk'}\n"; print OUTPUT &highlight_syntax (join ("", )); close (TESTGTK); print OUTPUT "
\n"; print OUTPUT "
\n\n"; } ## Finish documentation print OUTPUT "
\n\n"; ## Start right side print OUTPUT "
\n"; print OUTPUT "
\n"; print OUTPUT "

Alphabetical Index

\n"; print OUTPUT "
    \n"; foreach $w (sort keys %names) { print OUTPUT "
  • $names{$w}
    • \n"; } print OUTPUT "
\n"; print OUTPUT "
\n"; print OUTPUT "
\n\n"; print OUTPUT <switchPage('page1'); adjust_height() EOF ; close (OUTPUT); } ####################### ## Generate the general index ####################### sub generate_index() { my ($entity, $short); my ($first); my (%short_entities); open (OUTPUT, ">gtkada_rm/entities.html"); &generate_header ("Index", *OUTPUT); print OUTPUT "
\n"; print OUTPUT "

Index

\n"; print OUTPUT "\n"; print OUTPUT " \n"; for ($first = ord ('a'); $first <= ord ('z'); $first++) { print OUTPUT " \n" if (($first - ord ('a')) % 3 == 0); print OUTPUT " \n"; print OUTPUT " \n" if (($first - ord ('a')) % 3 == 2); } print OUTPUT "
operators
", uc (chr ($first)), "
\n"; print OUTPUT "
\n"; foreach $entity (keys %entities) { my ($short) = $entity; $short =~ s/^.*\.([^\.]+)$/$1/; $short_entities{$short} = $entity; } $first = ""; foreach $short (sort { lc($a) cmp lc($b) } keys %short_entities) { my ($entity) = $short_entities{$short}; my ($html_file, $anchor) = @{$entities{$entity}}; my ($package) = $entity; my ($new_first) = lc (substr ($short, 0, 1)); $new_first = "operators" if ($new_first eq '"'); if ($new_first ne $first) { print OUTPUT "
\n" if ($first ne ""); $first = $new_first; print OUTPUT "
\n"; print OUTPUT " \n"; print OUTPUT "

$first

\n"; print OUTPUT "
    \n"; } $package =~ s/\.([^\.]+)$//; if ($anchor ne "") { print OUTPUT "
  • $short ($package)
    • \n"; } else { print OUTPUT "
  • $short ($package)
    • \n"; } } print OUTPUT "
\n"; print OUTPUT "
\n"; print OUTPUT ""; close (OUTPUT); } ####################### ## Generate the table of contents ####################### sub generate_table_of_contents() { my ($group, $pkg); open (OUTPUT, ">gtkada_rm/index.html"); &generate_header ("Reference Manual", *OUTPUT); foreach $group (sort keys %groups) { print OUTPUT "
\n"; print OUTPUT "

$group

\n"; print OUTPUT "
    \n"; foreach $pkg (sort @{$groups{$group}}) { print OUTPUT "
  • $pkg
    • \n"; } print OUTPUT "
\n"; print OUTPUT "
\n"; } print OUTPUT ""; close (OUTPUT); } ####################### ## Generates the gallery ####################### sub generate_gallery() { my ($screenshot, $pkg); open (OUTPUT, ">gtkada_rm/gallery.html"); &generate_header ("Widgets Gallery", *OUTPUT); print OUTPUT "
\n"; foreach $pkg (sort keys %screenshots) { $screenshot = $screenshots{$pkg}; print OUTPUT "
\n"; print OUTPUT " ", "No image", "\n"; print OUTPUT "
\n"; } print OUTPUT "
\n"; print OUTPUT ""; close (OUTPUT); } ####################### ## Generates the widget tree ####################### sub print_children() { my ($level) = shift; my ($widget) = shift; my ($children) = shift; my (%children) = %$children; local (*OUTPUT) = shift; my ($has_next_child) = shift; my (@has_next_child) = @$has_next_child; ## One entry for each level my ($do_xref) = shift; my (%do_xref) = %$do_xref; ## Whether we want xref for those widgets my ($count); print OUTPUT "
  • "; for ($count = 0; $count < $level - 1; $count++) { if ($has_next_child[$count]) { print OUTPUT " "; } else { print OUTPUT " "; } } if ($has_next_child[$level - 1]) { print OUTPUT "\_"; } else { print OUTPUT "\_"; } if (defined $children{$widget}) { print OUTPUT "[-]"; } #if (defined $screenshots{$packages{$widget}}) { # print OUTPUT " SCREENSHOT "; #} if (defined $do_xref{$widget} && $do_xref{$widget} == 0) { print OUTPUT "$widget
    • "; } else { my ($tmp) = $files_from_widget{$widget}; if (defined $tmp) { print OUTPUT "$widget"; } } if (defined $children{$widget}) { print OUTPUT "
      \n"; my (@immediate) = @{$children{$widget}}; while (@immediate) { $_ = shift @immediate; push (@has_next_child, $#immediate >= 0); &print_children ($level + 1, $_, \%children, *OUTPUT, \@has_next_child, \%do_xref); pop (@has_next_child); } print OUTPUT "
    \n"; } } ############################## ## Generate a widget tree for a given set of widgets ## If $xref_widgets_from_list is 1, then these widgets will also have hyper ## links, otherwise they don't ############################## sub generate_tree_for_widgets() { my ($widget_list) = shift; my ($xref_widgets_from_list) = shift; local (*OUTPUT) = shift; my (@widget_list) = @$widget_list; my (%do_xref) = (); print OUTPUT "
      \n"; ## Make sure the parents of each widget is in the list. This is wasted ## time when generating the whole inheritance tree, but doesn't really ## matter, that's fast enough my (%list); foreach (@widget_list) { $list{$_} ++; $do_xref{$_} = 0 if (!$xref_widgets_from_list); my ($w) = $parents{$_}; while (defined $w && $w ne "") { $list{$w}++; $w = $parents{$w}; } } my (%children); my (@root); my (@has_next_child); foreach (keys %list) { push (@root, $_) if (!defined $parents{$_} || $parents{$_} eq ""); push (@{$children{$parents{$_}}}, $_) if (defined $parents{$_}); } ## There could be several roots to the inheritance tree @root = sort @root; while (@root) { $_ = shift (@root); @has_next_child = ($#root >= 0); &print_children (1, $_, \%children, *OUTPUT, \@has_next_child, \%do_xref); } print OUTPUT "
    \n"; } ################################ ## Generate the full inheritance tree ################################ sub generate_tree() { open (OUTPUT, ">gtkada_rm/tree.html"); &generate_header ("Widgets Tree", *OUTPUT); print OUTPUT "
    \n"; print OUTPUT "\n"; print OUTPUT "\n"; print OUTPUT "
    \n"; print OUTPUT "
    \n"; my (@list) = keys %parents; &generate_tree_for_widgets (\@list, 1, *OUTPUT); print OUTPUT "
    \n"; print OUTPUT "\n"; close (OUTPUT); } ####################### ## Main ####################### ## Parse all source files, to get info on type hierarchy our ($source); foreach $source (@source_files) { &extract_sections ($source); } ## Then generate HTML for each source file foreach $source (sort keys %files) { &generate_html ($source); } ## Generate general files &generate_table_of_contents(); &generate_index(); &generate_gallery(); &generate_tree(); gtkada-24.0.0/docs/gtkada_rm/gtk-accel_label.png000066400000000000000000000043221446021174000214100ustar00rootroot00000000000000PNG  IHDR[L[sBIT|dIDATx{|99K$3sYVyu#P um-*m=ZX=hzft^(Z6n589Iq}Or ,[,"e߂߇,+b )H)=y굅~>QDJZ1B"AAnHP_<_U}Y^|3@W6r?pO 8"W,߅m0!.DʵhkpG/~)*+|;oAnX+"@` )D 1@` )D 1@` )D 1@` )D 1@` )D 1@` )D (_^.cfJ!}̿S:FInoǍ#ӟ-ZѦuK:]~ݪ/w7?W#AE+ZjIBϑ~DP _-^BCٖ=)-^rˤLcM{rm?e?g?#h#;/&!3a"q 'ul]*z:peÙZiܮ՘6 H=mqeCKHoP!_ʼ~6`y}#~ [Gd>^]˓NQ:>s|B|73 $;_+9MsۧoXϰ֮3vl6 ?]8?_I^CI|B)h-1WW/7p JMpRKwdOoߵ8:Z"+7!|2XALH.;\tTQ ^nI4s+9crT>_;/1nqs;mQ8/S+[]#j>Xl\δÊLm;=v搔GkZk<yJ`}L7;ys??orݤe5a*g7ލl /ۤ3ͅ+'zh,[UfwOb#u̝06gSR1۱|VᮚHclzGzsٕthkeV}OٛNjF[pFe]Y? a*WD< hԅ]bF\MEM:oׂ%H`S2S'x徝W3rH3#"SL b0"SL b0"SL b0"SL b0"SL b0"SL b0"SL b0"7L Yo+`E+s pSH<TbA@R_g 'l^2xɋvo lrg_ w8x)@+Y{;߁oF "e!_[DE7AfBK="e+,߆;"e;O 7ౄɂoͳNDʦMF;" %t;4 UU)..BUpJZۋ^#Hp8(x|Li(B$iv-7㶶/侊ǻoPUp8,ˈr Rqo(jF&][JQQO;ϜĢ,|5.% MB,'g5|1Ȋ}\#&L `ٸ f5_yMEł$IFȲ @~a)0pgex$I2X,&q$!$"IRڕ-ʲ+go]5/_W\w" !Ju)I(6 W]} 5($Ih{@ii 3(1XDQ}jJ%AТ$#K//aٚ1Wp7q͵7u8.[-aYE*+zEY  F EQ4`bdgg,B}>Y1v8Le< 8am@Ee%^t ?(4WS$nko`m߸c7EQ4i'7EE6FO^=q3%-[o/ol2RYb]ko|1(8ㅛ&I2` 6r3KENqq%%fDQ?o6>MӈD"dggSZZBNNefWTXiR\\V(n7ƍἩg3Ilٺh5krɧrSo}qc0sHpGUU8c+̱uVb!??Ғ*VnN+ɂ7r4 `ZDeLcz/++Yʉ'MÏ>feWbZS.P:4m| n@ȏin&ښU+N$Q__'擅 )(}DYY 0lذH$BΝ+YﾃJvv6Vrj񧟙t)Or޳g=/ ?AZi{2f\1ڵk{xkkDQ?b"{ʈDxӭ?x,j5С o2}aȰYr9@yoͥb⭫DV KYHmM-Gu /Y \wMQO?M8<ȃnemlld-w4{g6H$}d{޽G~ …˯rLQEQ8x=<8`[oUUYvw"P̼jr0Vnߘ СCX0M>K_>ŠA)..“SD|>jk8Sٴi3V^y! dYtR֩;kV@QTUe=q8X>$ FQa!%x뫨FQS`xn:v >ŰaC8xOV+Gstԑ9_#//p8g/KNfrK%XqRԡihhয়)S|tX; vg4|KB!1~Bsm۲`0|>V+,cX0h*o" aX[qAcc 8 P PTľl_qN'-`i_=oàù3'w." Q]]͛r˭wpݵ3q8WOQY&pɧԱ.ݺ#6SR\TH(B=+hll3z( yY2ez{bwcYMngEQ4>{| t9 TUwߞgMNx٧E]wFuu57nO6M:-`(ƩM;oe„C''łRYh4JnnŢEC&MXU㓏?Sǎ,\Y.q~o]aAH@~x9uƿ^zguaGedg{EQq,0۶Gexir?~֭EQ_lݼAP.zeH'nG4+@SUxa=]RTDm]$v  Q4NDe^~>{QWW`*JM]=&MO>QUC;kǍ%;kf1WQʪj|_p1+8S jL> ~'|h744'f dgqP<]Aq8 C 3\>jΚr:u5!6nX7v7PUF/S/,fI>6!a)HF7Mnϣ=}FMӸYHn 28_Kg9*ݻu%7zCāO]]=%yPz@8^oj% 'dh"ѯ__:|=GBU5TUÏ>)SMa;$VJͦ͛<$qk]CsaTVV񐟟O4qs0eIt TWDb>&6|;E)(+{< sOjk8ÉFgʔo0y}ԑ\{U /e~? pYgR^Q֭[7ptҬRڱ{3_g dA4fхfCTg4qf.>ߖb. :#Ge3fhhT7mEҥs3Gj~F;-[x8sT~{N' ^/{&( Y']F,kVZjgQr=J, 2#ѫg@ں:z2kZg`gq6Сq8\3*2k}ʷn4cQ񾒂 }LΝx<u6̿uZD XVx؂ pEEI4vuu5vQͱ6ߚ5k9cXVK@%rtf[# & R^^ż`n܂t}/Ȫk͖}{O>[hr6o  m z|䉧ş6VZ~HiBbLQd )((s/h8| _Pd%j:vdY!+`=Mӧ7cq~ 4IxQ<Գt֍|n.d __-z.4frssڥ zU?ff䚊[Ęf֥K<~pc-beȲnOl4]*)@~}8aC""}aU#"O< L< ֬Y3>isYrtڕΝ;s-sS>~R?w}{ӅrStO>Caa!TUUkd q͵vga٘7mb>}zcX>Kl6͆( 0۶nQVV{h̳~+<,.N@ 1=7" t:e撓Cd4aCi999J(&aР۱lw%Zf_!ǰaR*,{IJ V(h8]z$b_&`=wK4,+"cZ{ pC0zߑfWS"˲ŽmQ;#4M%&d3&HG%; EQB\zٕTVTt:X~=gq:]x)FIkiQIg w#n:A^CCh5gÏZT3g}eJ|K½}" 6kSx2m"~Q1ak6$*f$9miqx2YؙϪ)^4SWҶb큯]$+7hX(^8&S1; Bv; zLs ^oC욐vkmbOQlbr& SZEv/D4zZ|iѨLχ5C4 *7+kL]bsfek+XNeiIB\Gmj2Wxa jsqM||+OiZ&S*i|*BtoƷ ƑBInx$ >F2 ĖNx0u)t9TvԖ3koz[Rweevƶ#܎^Yv6Ye%)nFY~[ڳ}Mo{n__o[ld\KI_C!V^M>ڽ7=z`G-[X,wɬ]PHNK9rZeH*z3ڻ}||v5E۲!UҖjOӫlڼ1|3F p#{~{yM!??}#IEEXo/U,CEjkdg{xn,V uu 6?ۗ;kWƻfG--ET(+K)տ_?rIn~^9yzRwN!ٸqǞ@nN?K.IcV\ɓOO?%{n̟;Fǟp2jj6;=ztc7v) keeN=xR}TckyCUU5?EQ{]DrrW j Ѓѱ EQX0o6\{6 S]SCUEˮ;gqe^{~(E) ?]{ۚgw22v|cKl͎Nwj|ZV|1m=^>da©;19h:.,uעC0og~*[n ϟʫn&SVVFuuY+|Ю6im;ۗ;kW*"ݱwM{X-EaӦl޲P(ˢEu /^$)K4&DF#ȲBVV$fT7m,n__4T]oH}`-p),,䉧' "gWE>Ҕhѹs'V;vE"mDEV+^p.W̸qgq gkjkY|ݾ _{Bf:`k_ ÔWнg?z{qw{Dx{} :~1s5{｟C7н{w}a^y֣/b9S8hgS&B]OokI;ۗH([e&u6ᤥtN2O91Pd#RHz(dgc٨*nT6Ov6hF~T^ PW_oϝ3QB{yyy]U+˷޿?c vw_{//ow·e,m~m)]WU‹ AA.AM  X gQY;@-^Ug~{л;tAIm־SvU 5ӣMʞO?iM ִVR9 V|Z H$ESJ(ۜn ݪ 822[)&@ܰaK^]kh{͎(2?|*D. ~W@Ҁj;p|a~N:,eX,Lg A)*Ւ8 g hlk\SҞif@ 2Ɍ?H:|]-I@IDATSۗ*xgX9z6kg{ЛL( WMhFgEgu¹l||>sߎ_rWcxp: }i\.q9(5Wn't:3(fXeA;/l6l6kbmgmo|ml2ACxgM&X,4tnNC Fn(O=l.;WPBAAAʍOd6'T<Eawʺs/$et:).LaqG ;RPԑ2EQ>4)t a؞vgtmp8̛b|Rڱ.3p ~306k\- <ta^YIDΝ),K^\.H$š5P%M),4'Rŷ-'6vsgŞQFdwX,3IaN3׀>nj#G˖[ \?o!|7D":St0¸'yy9e*99٦%SNkgp=x ;1S7^<ǐ=FPX܉ǜ@0L|k;Ui{AÁ@\{rGcY~Rsp3 &!+ [mcӆ֚kٰX,($Y\NB0Nɓ;eI'†uc{.(,3cj1W.MWAZ<Ž\[:so޳gw.?&;pR[]w˓O=È{|r 5ӳ@JeP(L޽xZ,iO~?&.l6^~9:|>#S@ƫEx<(^7VUoc#o24rF7'e4l|GqD۷j1vVaÆO?P]yӇo|=G7WM7נ x9d8=m' JbekeV( Wθ=/by\z4 >YE.eԨzNk;?S@]M/Lt{f+99rWc0; TU%''_x[7X,zj:uno,C, f1x <\-7]Ï<տ*9^aÆy B]]=SQYoײaF^xi<`S w͞{ ㇟~{g18j>!"I~a;v". 73 !:AVpD ކ 6]Yn~zGqq ۇs^yu|>9Y6oXM]}=? {{4WMh4J ɧaptA+۝mĘq[2rTWטX<_׬aAX$I$??5kbX 6؃' GMӰHes{u7UUYn=bٲTW0SnO"(v|k.Q9JE&^/v.{jIg"(^o#ĝiF2Ց! cZԩo0ɁB^/%%|,0/ZȈ}G<}D2ILgט0(`H$W\ĉGϫDe6lH4*ӻw/~_ #,s{]FcL' ~-RPT2X0gkhO1CI(--In1D"< 25Mwםѧ`Kz5TU_xWPRRB8#c>9o=f$}w .v F 9*S__ϝw"֭?V2SN=VmvOCP¢N:ΜAyy9v,Gؾ(t o}5.N~Jyy9}6?o(UI Hl, $nL|>) ۼa Ej ˖.C5myRN&+DEle׀g?ʷm75^wLǚU+PUQ CX,.à#hrb,7KtqV%3?fp8>ذq#&$*^oc(u 4~[QW nG)SyW i(6-[" I 3uwѝn˼ol444`X(.." _qCגD)q]2Ѵ(hjbh\&4F&2︛+7 ,˼\x%מhJyy9|=  F؛QYY؃@ @>Fs<9@k"hlD"8t4Jǎe2h@45VmZy*^wX,s6 *hQ1 YYnTUAU5;֬]˺5ӹk/~_t(/sm^M%=6Ȅ#D<6ٵ?Ch*/"p.c-rQoȲf3}(R__O8A$w2 brb@C!|;M4/\fG!" lM5 f;RPP$ ۱N'QTTHm]vH4ʦM?nzJ/T__ϸs/6֌}>tG__adY& Zb< "/F_#>,~p:] *2s!MdY)g˯@]]7&y\ݽޜ=W̉+Ir* XJM6f.5UDALOĀA{p٥ pigq'K.6}|$A`֬5j^o˵:&ED#jj먩mޱ($aZ9c893 X,^ $6)NVeULHnO(q7pg[#?x:eB!c٣.jj޻9xa|'~y̛?,֮[G׮]xRȨpӸqC8f?8BmsyS+z}l^N~}ǓSHuF|^yuyfX:v,ccvgѽ[WumۙtqL=n:4Mc(prǝbMsnӣGw+XƍC(i2wdg5ES|' $MV0[$"$w9< ɱH!+$;P\w5|O >`0Ţlt<zZy핗%c6Ӻbmw4/F 77L4BյD}z#3d</<Bk/"U1M$qyf5~oENgZ9sX|q-zƊD",[O~/?}G8s9ضe=*N|k׭c=|ُaƏ7@ YS`ú5,^)L8{S;gVQyx9ࠃQ;}`Z+[AՃ\BTEt|UUܹԢ{&UU&‘GKm]Gu|p8=b~cqey 6o¼9o0|QD"̝ 67HX_f^KvN6M=X6 g0sf=^0hTA$BAa6 9Lz rr[*T9_[!Pp\|>_Bl6bS4\Zfrrxܦ TYYAcoB43cdee[$_ UjMsJҤtڻ}_ʖ4Tڢ$JX@@{J6<9|n ߎoGt&^3r__!4y7/0oO|B3kWS4-omr_2kmq߇][m<¶fgߎk븴G q7F|–gD7RCZc{spw_]پH$B đ͑ݙCN^E XFΣq䱼kTVVoA )5R[\P(L hV|WGKs vl9p[|;/=}Gg-lڰmkֽzM6idVibf4jkذq#5]ªU=V2^EmΆ̍蚦Q[[HEe֭'kA~|j$9[c]D"A֯_ODz2sӴLfѧOo8adn^G(?VDV hb|~?M8}ӫWzɿ^~,FD{%zЯo?^y5-WG:)?vlm9m&ma g3u9tl6+pD?!E{dYf~5 E~\r4 >'C`„C8sT̟nOaEt:yCb_1L ?=MKwWF|mVSg| Vog?:d07| r'蛍4e{AQon7f~p]9L ?mK-kv֒y탦559x:X$(HHRIQdh4Ha ة#۶n#;&vc mO ƣ%3(]cki[ R_0<ٴi3Pr{! ?7qcyGkx'Va{ ߤo>ӧO0+~6qҥ[oƍCAa>2/ ^oYjAњ;vl-վJ"Ֆ .H LCDwΒo$;Gwu;[oQb%Λz u \L:xF؛_x;EIIx+7LeU/y6H$Bblv[,W/meٛxZ|;-J;mtT}qRG}M'4=T3>P*Vh4jhE1gQU YxtQ@d| 0z<4M#l些1ߋ M .Zݧ 0lִ>SBmߒ%yq_|Jm\iђO(v"ݡ|;O0]EREQwE*|m;ֈ6_no|l[S22g;meR 21[3ŕSλ ~ȥӯ`ڕlEJKX,d 8}Y;'؂+b!Su7Q PdA(hlx+T,ލf2|;.EG^MmSaAȌ__P V킭wA@2?tמN@Q d kC͂zқ@269NViLÀq\j@vSdU8&r˚%N7ycx3-(ԘPxM37p>@2; 6 >!CsXbLYb&hv`@2 xkS7G d ;Im2[2QcK *~:/4IENDB`gtkada-24.0.0/docs/gtkada_rm/gtk-arrow.png000066400000000000000000000246361446021174000203460ustar00rootroot00000000000000PNG  IHDR6S+bKGDC pHYs  tIME02@ IDATxw|TU߷L4BHBPPTem(յ+e\U{6tu`RDPbW@h !$$v{e2!u_ܙs9ss9y0",:HC`ӆ[~K0 exQdg& fbÉfZǟ`g܀3f-^$IB$FAt@ κ=tr  ?qAC,[M(+˙cJZfQa"LbKEl0~h᪪v:>X!e}2`<QU7 oWx -3JM9^@Xhg6.I}Oal7 o'.$ 'sx!v4Nkd<&ZˇtY[x\*KsaDX[[x{[JJ)%ۭq1y(iz ;ޞHܟ$ѐl?CF"EAQU"rhn'lW8( ᰲ_5,-x[U<UE `QǰjէK%aЩs)YYYH_;G*O2c*><ͭ`mg)Ut~<~?lvQ#F Ռ3ӧt:d!,*6w4 HqI,WUEQV]ױlDq84 1VUUMT2et-^qEQeUU[&Ɩ(%Z-0:6lȞٳNFf؈x=~Qo̙ӻazZZƌ='^JXQ5 ]׹Z^/ L3V.agtp=j$a0},ᴾ@w~37xJA`LzO>b5 -lxtCh[ tl#;+ M8uY<7V~ EUٻw))~ҕ 6w.6|>&d\=}&N3h5/2:A)ۇS'3yͷ4]1 wn,xοvڅa' x5xyXA5M#S0F:SO9^_cv- ôq~^7p /yӉngirpy'z=].N;dfμ뮿aÆ[ogKՑE^=$//YCuMMv[Z73๹b4-Z_NŽsx6iA.ݻ|6oLUN@Qb o-xp8L8/ְeŗ}Z>p95|| Mfyם#PMۭ7cۑ$Frs$f@mm-vEMӸ# !%%̘~5,G80!Jj??"i$rB!1M~?n,axL56=E@ 8f;EU TUEE<?IдH3S^nv4ݴ~N( .*y0hآ&`+ LƖ.\HK{[>{awA%UQ^,G{*ck2[x2**+Ӫ[i?6,gCmO )6RoPOoop oxbZ{=} BQfGt~X8D$QֵY$p8֭TX*ۢ9]{0;wҧwooe@Acc@i%5eXDD~3aнGw2^T5ZY)))@U#i{\U-//Gem &滘2Om1of&vU( wl ?;w1jw9j0MM Q9Lz5Îr*}I>X+\͌ap]Ll=.ZI'7Wƴ]px#g5k636A0d[8j:tｅ(8N9dnkn?l0c 'E)--ngɗ_~ź>V#p}92;ReHBqp3+Rַ/`` D߾}awN<79444} ԓO/07Eb !MM~}4nK/ݬ3S^<~=wksk@$uzs;q͌oz wWywYOVoᘣG1I r8Ј!## ?èF0̝"saP[[˯9q 'wJ[PйDg3t]gS1 Jå )).F64૫f[ 71b{VL7.R^}m>ݺuK9jlo&Y8(ddxl*|>YY4nn?0Uٸ+n:}<999((tAUUAk/rco]vѻw˾]tYe΅b⾝c=E:9ٜyu={\9?t~& I MMx=;7B]7,COT {Yt;|b^TV&76$)+PسN^M]]`ñϰ*FS544A3,sɓ~0f^{=Y9fV 7n,<8.rأ*g\T?D Lڕ`„өE$r;t ;;+*m&5 λqo/7@ o#4EVA1=Ј& S'TUeʔI,YP3e9"*`b\ɋtUU f$If#HM9Mi81 Ε7^-%-|{u){:{`"KU$a#&\n]Mm 6ͷ4Z=^t555lܰ5߻Gqzy9LrR4Iǟdʕعs'^rWa S&E58X]]MMMy( 24M6s/c3ٹs[ӽg? ;-{Nv6nd׮ ,x$v=˾22ٶu#ws?b2Lr%'0M[z33g'q(²,sg\z;bI>b'>c!nL8}<_~&St]7r9mrIlذ/~}2v̱8NdIn.οp"Ïo~s"9QUr1=N4ܼ\>Y\ àsBN8~.!CvsQÉr̦b΢fc'!I9߯g''Oe޼g]y72m:}χl1v6 gN=;UWMp `bJaAyX ;jwQ[[K\sN;N23SxLh0h.9kޔ2sFff'#9_J-N쿰p޹瘾vU4\smIK*撓Z_me~p*qjdW4JJJRjdg<o]Cz@VYx{{<:׉'n DJVXA1nӑ8kSf̜&hpαMe 3D3wD:irR}>Bl۶ѵ{vC^8l3@gqiOrseE1'RWr;S3tUf;voQnj\;tC7`$yD>yť=Mh5>-$@+G'[2f];$44m;" '; {p8Bae ";; gBL232hhl!\i`\eNn$xVX(  ˖[1f fh MŮ=#KfF&`Y\A(T.'6\\N'}~`ҥI! Ӊn磰S4{Nn'^[#I5269uRr)(H~~>YYwA4"0h(zk>ф͡ѫݺ%/'|,VPXԕ=_d2AXftotҍ>QGͷP[[ʕ-TDNn'3jQAFF^^#:pgQR\>=z#7z >s 8N<]>n=7p{h" IDATD"dIbi1dpIJMXd)50i:tflnPm۶_$ sCez],unhq~pݷƖ*ڃu]>(?]JzҹK7nt"K2۾g7x (--/ao}}tEQ4y*իVF\|e|:>Xb-\81*&EEE_MUv|:DsPńB! @=WOIFFs{Cש޳˖Op8Rn$/B?\jjj٢E^/s׬%;; I1mqNǃgv}];P{yl~@h[3V<*EI9~!.[oN:-Eb*aM йJEe={ ̺z3@Hrssǟ)ܥ ˗̋/>SNsωLӆd vM;Վ;ۣU&6nĀb;{0hlֵOn,SbudffO{w~]҇V%exZ6Ac''Ą^ j4g*-$Dk|UƖLV7 Basy'((,vE ܂hhl:ܴбK4Eae]lߏ//rxɧ8Sѽ;sPΜ@0thvUS:BjKiM 6F⒏9deYfh_Aдh^ӺǼdÇ׹l%f?%PRRI׉+>&MnWLH8?8m-_EB 66qm<F{ >_]zZv#fdef hllBQtݵz[9[[( Fd\ݵѭk)2>{&I$IͮD΢o|TEzټN^^.lrѽy8.x w KS?M_̳sq8l6T5^J0f0 ܼ\>x%MkIQNgTkZsb㺮S[[˴iW2꘱17l۶'C8& QHCC#>ŋccg s8.4NOj(,z&^61?xỈfCQuJ8[@.]$H$bnj4+auk>tїvGL:]ѥ'ee}y7y,[2v-iܢM&ˬ\~{Qڭ7>@ӯRX Y[oUD"(JCCkVokov'_fx<:vc„)֛\NͺMz%E(*NQlcӆ~wrrx_|-(<#>U.qնafߑpXM}^SBkhEYtHɀc ]YdE테gEccEY[$W[@0IS")cb*]qCN`j50Q?7YdE푱1%'']rs,Ȣh0v["cLǭ,fE7ƖmFd%&",j'm$fIlYdQ{R;^IENDB`gtkada-24.0.0/docs/gtkada_rm/gtk-box.png000066400000000000000000000536151446021174000200030ustar00rootroot00000000000000PNG  IHDRTV-n bKGDC pHYs  tIME2'\M() IDATxwUU]{{23Cf9 DV׈V渮ְkΊPr ;wWGwTtOcu9sCWwWTZFh-e4e })]APUA^{yv]Rkn uyfB5 \UՌ@'%n߁7D?2߈L&hϼg VLPP^X,I }k6-j $@ A JErٽ{vm8WR]]M4mTbWUBV+^]w܊b&(˲~Ʉ(I $\:s#⍌D[x>SU5ύ2.H\C*$!˲{Ib XB⴯:EAzפ# ($ wV7p]}N K^lXH$+TgĹy2яY7ܬ vv^RGUUL&,4޸~nR&-ɲLih%fRuFy7Y˯ATTTEsbĈw՗p8XvLMM-EmyԱcJXLQ&j]@VV6P0fgz:402T8j*K@@ P`r= 5&MHo{ "f?;o*2\N^/TVVa6QUVڽN'ee{D"},f3yb6 jɎ;Eh43n7>׃lfϞ2}EfK0dTU%//UUٵk7& UUcOYqشysb!!//Q4QUUE H_#H7, [n?nO˜{_|LЉ nqD (a'''9&Sw~X,Fqqhb`xLEQAw}>`(fA Ѻu ;D⿷lXV***(,,d˖-v7Hl>:>, YVʢ@ d ?P8EJo$ݾz ПwZRUP8e]dn1v$ χ^C $77yAm/!MPQQ,uQO8aΝIO'ɲªU).*CG`ZQ"wu;@͚#;ۋd6T_;mΠؾcV5#B\1}& ap:XVn7plbZQT@^^.{$avUoR׽u_PdJ_sV'u]!& %lo&$Ʉ,﫪0h8vg6={ Eݕ͙g,O>EmYj K{ppʩgRI,Nʡ+Ws/ik޸Z֮[Gmm- i, P^^~fAU u]5;^}v;'N=<=TT#J=AQ)tÍ?b`9jؤ{K駝Wǜ[n$''9s`M:~/+ %& ((ҪU!+WbБIil(|brrISp 7!,IUD=j g.WG2h|9ٺCubk{"΀6lHCp8fuęf݄ lbI |('4Kn &UU4RUU-qc$l\utN; C,˄BaX5;P{+55Ȳ(DQDєz&ظA+Dl6+~^J$a5y̙sƍju\̼v{/g~*YYYH(f{I~8=8eeeiVߤ,Dx🏰v (/6mNZA9֬ZN(7#ٴa5*7_cǎ6EQt(ZߟXTոsD*+*L$W6 #+2\_g(n’ jns2J` 8e\Kڔ rٴuQMDe|M-\;8+JSm R%}hڼmN hT8Lf.$m9E~AA~~q]UUէʳt &CMҙN'mȊd[1&ˢYj5X,84j)"+TTT0jH(ncݺt.-1cx7hݺ!SN>{{wVf==jAiժy'M`ĺt"Iv:uU-7߈`"ПI5{5!rc?ƽ*B,G'''e.dWrɧ$IdeeSt撗֙ctY,f,3V!2 g#ʫaAwX,rssy8aqu ٌכ͚5kMǼy!^jbvG1 GKZ 3q:>sz-snoנ )$ ]HFDQ$?/ucٰlݫk4` I6;vRUU,+8N^OFGQK!E'+.K2q`„p4nz|H^x~Bra:f?MZWI5ka1TTT( Փ[o Ʉfcͺ9TڔhF[N4%#eO>;vǧ7(=Pʪ$pH$css[n$xWz=vء0Xs$3f!йs)?7$GˈFTUV&O?/߯!''6mоcWz@‘n:A~?{GUW_C~^UUDѴݪUaKr0~ᐾf(蒜9c25Oͣciw:thG0"(2=4WϸvN+()כ͝wIщIufn(+K4CM#5#UUz^D $7#5)$ҤKXuqXڝ.]JFb1E敗犫f4ҵKgz!i5uk~ihC1[ KuMNR\\Į]o1^7*+E.))ab\mTUU p547'@.lJQ_|?;n(D"rq:A***EM(& 0ʲj%/7*=&SUU PTݻ¦dY&77Ύ;iӦ57Ǚ vN^4gTw v=I-$( [f۶m4 I(((@Q*++Zzynn.{AUUq:B!vڃ,Q6|>?՘L&zޅ}D&N;+.*SUPTwжml٪o, B$-BAA>h2~V+yyD"QݫD$ Aeez=!0qbP[Sg |7L%6%6mzػ7it:RUUnN}$)'RUUE8rRXԎ˖m)j& RxmZeVڶm֭5ϣJn*0ƿJG u.A@$GUU\.^*N'zXYˏk UUU%LH= 6}\ۤ ŵi'[j("jCdZN"fI$$™me3-I&AzH"d3+RSș߆' ~-m}3%Ԇn. ]xA)w\IS|ƃLk Q#i*=o=t-V X8;]6nsHiЮ&XO~M^ t:2VNo܆́֫*HѠ,Wﵰ^fK|m͝o&57&"D"Q=QLt!_:rDR ?l 5J`ZpN$Y I(.*" IhӮ3o  5{ڔSoOejW:D/EER-&W&P(S߯Won2I IߥfTgRZ_->_WZJ#32U|BQ\.EmMcpc-%>_m4Lc* #\A6gJ Nsc9М!5ojK>~2x vLuM +][oY*K:d%UBWm@\Z5l|6~7nRpG}_zSOK Qg(:|6^=anV8|4#Gr] JЋh|R9ߧuiyg*c>&l~#6{̼g傿(ӯo\Ng٨t6}1!BT2 L!IBEIjCb-bF~`]gyA~Թe(x`( !J 'D"f\}%/,7p>p/_NAA>zetq\2r\.'~'GȳϽȳWعscW](Ӯ|kO.,(`ok'U]Op8™g)'%~E|g@<6_M>oSeVV~8j1\|th^n.]fIq湄|ݞ2>|s$~7cDi]&2gu>ǟ|3f2j*f\( ~{oŭsnogrIxᅗ8rD{)V~OsN9LʒܧX  /Lha/^|.6#M䣏?ppmwqأ837~@ Q7A7bQGsEmUjOs三y_Yl6QWvIaaAڊ/ 0+mz.Ct:D,Z-W_s&) nNy=CFa69bD`䡇? IDAT2aұt˜zfM*65!ul63m?$#ˑG Gx˖ܳЩ;O=(| @ii'\̘qUM v((ִCP U9pMK.GكZ-''';#!psϝG0D (4qFd!ݞVF'f,&+/(+K}YW:ԃ>>‚ 0/,^J17 %%Ŭ[g_xQL&:w7nnh4gNMM-?$wyT0g_謱:pfت뙮[K1yۇ>}zW xy{# 1%}۝v|} vs‰ Æ?7<\Y}$?.]j‹aZyb9b<t摇ΝԹK]NxX,jjkB72l$ FMm {3>M6S26z/vVUUU :RogRTԊ`0PYYc&3qQ<Ï0X^}yFyy\{,xA;$A!h =41t{ί+~䚫M|t7#NW]1MsRngl޲X,n_b¤8ӨpАMUS'\Yy[=+Ut;rr1GGG7l1cp:DQ$77gćMvv6mڴfCjBBrgsyN;l~ѓ&бc{\ 4EVݻ'}x|zp)St4v5[/ 7]t\ʠp::r$6o2+ݻ<s}\_$)8o,yx.2Sxa h׮><߷ <5_rxgxz&pYxz6SO=bN?4֭_?gPV;J8XxX,f>.+~ŴiӚ]?/ӥ_Sa)S~zҙ  >=˻\.***8?/Uq{X)Qf"blV]eCFq駲/ԹA"дЦη!nS>c|H؇$IҳTbDKx@Пl/"RF40ճ!~ժKZnVU5-bzW]]C]9al6DQc&酽vݩZ7S!ڽPͪT>` 9gI֭X,i( UUUxs y1,ճ1ZUӵk>sf3^_.K1-i%I\ZO?fI!_2rpŠA)((w*@Mn+5;P!tzVc__b>O^ 6dHgf>}z`ax:dpRidJ `݉0B~|>l6+{VУGẁXa#Æ 咋/%jG2t9ՎՆ/fa&,KRjlr6t9:!{DZ5nڐM)S8F&;I7`(^Ν;0kuOiÑD2rb:%;ү__֬]ɽpꤪ77i\ p bX'܇c&ijClhUܖCgqѣ,{Y?#8Nb~kjjx٧5z,}bٲ;~}$grIxlFaBvol2jԡ7J9~)99,L.S}oSlniJh":EFUϳl(6Mk٬=mЩKw:w5kY|@/?h4KFW=ҴuWzhىt4U UX5V i^9-F-&9!v`]̨$IzB8Kc z(kZGPS#UUҭyZb~p`tz՚~g^}Iof#& uҁEV$$nDQєsgɇ%z)J2h]5x/63M5O?~W?nu`lSWUfY7CȰQZS-Ƙs9Q(n14m5h2}*r_z}|(J܆o#N,f3Ff6µX,HjJ#Q1Loh7EA20ZhJƜ9 M6ҮI=1Pw~5$7dlhb]j赿ptRVk0@.S}@n#~5Jcu_:n, 2~^- rasx=XnDAvϥK6 vz=8rq涢SL& ۰v:|>6nd͚D~yR?ү6z#|>_|13;;".dz:hiWk#'gLgWH2|z0Wkizj֭goSV?/[ζX6oق`_RAXlݶ f֭zLEQ%K_+W՝~' !2( "Kw/I$Ė-[j׬߰A/P]]7_WaXu)d2ɧc1"555,Z-~}RTj,bOc#AͷF0b6P*;4_/eӆմk׆_|šUٶe={裏q8|d)Kns-VO?/cѢoN*δ{lcݚXE_GQybNF#} FY%梪*N;ﺗp89G[.^+%qA` |b{T}^6o‚_l^MH~?hggebT ݬil p0pP(\' =;;J&L?[n‹1{T$٫?} WBCuF3{Ν K3*?Q^^+ΓO͋o#x^3ƛʫewP[c 6w /1`p,^/WϘZ\=c&vU0xH6lȦ͛뵞F(Cp$\UU͈vaL=Ljjji;*B4Ib1<71=ٸqH$3qřf,$)Rڥ'_|163dءTVV7Yև#3@Y GSV#Ga~?aАqֹfQDZ 99\3:v ?p5:lWfx3OAlJ>ٰa%KcۓjhCl8|.&\>btrkݻu寬X'LL}ټq wm6<3 (,:\//SOa*dYfԓXڝo.9Ĕ)G?D$]v"%Ȳf`3|x!."986nĂ_՗mg~*KЃq |姴jU)gO>ǥ%h4Ɗ_~}vL|,.<=+2rt֙`B8aϮTWW0~Xƍ=2N?\kxhۦM=AH@v׋h 0,s2yL.]:s̙{鬮g RZ)+* [Q*++9rDȉ{wPQQL4b׮]L=, /,KJRh=^iÆM ~ne(+/_租~";;۶_b~/= łftpؘHeV`BfS2X)SAIpp5#>/˗}vv6Y}zr%UR:kc{L܃n$.iv-mvDAo 'qIt55b1|;{n t{]߾}6tw Dhk(t8F̾d9nRxܔp:ض}^cƍ{֊U+5&SOC0b!ؼy3EEEz>6xȴw6*+DgxeGumG*mӈPf&EDQw8.>M/MMMޖjd y)//gi*r{%'qwj-Is B,^'4SN HisѹQ[G~Lun^y91W7HÇ _ĸ#ٷŽȵ?Yz5Ϯ]X5jbw؏(ڽQ_'# ݺl:f\2z=p-qϽ`Y1Ltt*AeUcF} fN2X顾7n#Z9na AgV֭[SU+qp$ ǝuNhnؔ yedqc}W2+WU( ZC /8$ifM$.Չ"&фk. lVJ;u";';1b28tОUWsqpٴdV '/0 yfIbeR[c붭y\|aoMo8Ow^Y\nA ??_~YIҎ_-}h4ơdaFy 7   C C(N tՍp- ={tjEObC {h38[!I|>}B\ytM8pfD~]>b>h4"&4CɆVZm ͆fuI1EHw^Zm8Jiy;nw^L<%`6Ύ u302Бt În?\B0[nFqiw;v|o9e>FNCx7qF?PTT*)|#fw>O}V[ X Պb7K8K$ZEP8L4l6c̼.!p_/d=Y !!:}|*fB& !L&ÑOJgu:Na o@UԌkкivcc  bKZ\z҃p88YAd9)Ѳ\Q:lZtUZpcDWczF\$bZ:A]D*\EQZ,Xz\7[b>%I^*!kV|fsRWY#CӮMeMJ0^IDATzϮiaSMmJfHLA8IGcTA1|~_Wp]Z L-Iu82o~8$ud2A*i}=h)GMUzBYn㧟!TDVKڂ,J=([w%L]5Ոۜ7G!\CS?o Tf`X2Vm{56/})?ܦJR Ѱtbuc7zVC!0ݡc~Ɯ}ZZwYYY=u2ޡt**kOe:ś WEZ[bUlZ?L=q:~1vˎm[vRbdm;ְmvdYޯuӾ!Tj'K٬7f %HWx:jِ?pQUBf+R ,ͪ{Un(*f"hq_mC]iANUX47]Bm7$N')e IokH5NwFQLi/~KFq{K]~Ca7M]78P:S hrR))8ߘ1 7ݵM=x~opSa6as竽 jq v tnZp8(vZ '~8D"vlV`~e @f1L.P9 6nzd2aXe>KeG~K<^p9ip{nJT{.eH=n:fZ^QSOKOF:O=u8Yv7={4"?'KFxNGFL((xhӮ3 =vx?z emw&. ?StvվuF0d7г:tJ=Щ+:tMR:vg]$tE˰C;3 1<5dOdЮC<Ooc zx9w[d|Tt=m#ٔt39L7ucoݺ#Òż8#ȲL^^,œAzF94sss"u,Ɍ7ӵ>g܀z=ܾI/Vy.z11tޛJ2q՟QLxHؗuK=m͘ l6#IRř͠#8l8Zconq6=z`Q;P7U%/YkYZaҺm'-Z-W6f,%m:s׮DlQҩ;wPQ9aT =>3dkci^T /TPy*,υ -U.Ђ  R "P.VyA^39q93I&zY|9:笽:k]ӧ\㞾t܍=zӪM;DQ/6cZpwgCaa^Jʽ>nH-'O'9)t6%N[=)Mٴi V~N}^&SyIv^tܕfE5 {JS AvwYw[ABWz$Ҥ&.R䭡|m6:g);MBB<'>̢ghf4KOr_ϣ`?ֿE~~>Ͽv=IJJᨨsԻ|Kw71(,*l|pL|Zltz{~H~}4eee۷cW]&8i2 ϨÉUv{p,]t`$~,N\F5N'Mgqs?9v,raȰz;vC`3A)Bz ܬ(T٬(Y (;zcnW^9ws;qq6_/||CfΚ^@V)SgpX2F]? _Hl޲^z^|gsݻfr JKK.N>bṥy <1 ֬}aq櫓x1g'9|G9^/ؿ6o$%5F?Gҭ[v+B='..Ǝfʴ'8r eeTV:4!ڷoAۓ?aO{ gѶ}'˥{nl߶Ynw0o/))) z))_[|׶|ˀG'=̥oIyIl]{Xmn]I&= xHOoJYy)B,>6W~濩 }r|Cgחg1 ,Y r(_AsTTTO̙j S~?L@BBǎ2r0\.7EEEՓ/_9=@ [ѣt_XȽg'5&v;n[sX,fJ֭)ɩ+_U8NnkFII KII9B TϬy+`(YEvvظis,ƖN!\..] hĄZ5@p8*hugzN|*++Le `*h66nIMex~bbd[RSx2 SۋVg:?un5ysC㉏#JqqqD>35y IIz%''cf,Hee%ZRRRr*=®]6t/ Z^^r[ʸq`ӕ322Z &QmAe6A2~跌9F\>C\-BzV,ݺveݘLrsK2>'Oo=HbUpScxC-Y͙$KK ??{f ; ;Y XmZrmo6z}:tKhO+W|bukC Vm,IU:D훸6_QMi<O?c̘<6yyytؑS'sILHcK!TW%~q־'O}Q_b0}ϘI?~f L<AwhќG" 4 4 5k`Z8ŧ̝( *+Mw}-lJDtd'eܩOOey|vm۶aoW˛ߎ Wf%,{nŒA1&$1B9{G&ÆLv/tؑ=w0m|sݻwegHMIas3wvVamڴm cƎ`;HJJZ(Bx?p,N}v .aXt7k"߲}fƎO=;yIbS? 3O Yt=XUwMJm舤d2Lp5Fl*IMZ~{|Pw\.kHė/`殻ZU1rh,ׅZ$954^mHRzjsTbHPM=_lSCyoI+K9;8q3>;_sWwfE(JБkv11tT'Bҷz?BjW~S?p8x,^DVV&eWd/2BϕaۃMW% DNꆃ LGZF( Y-\~):Ct ۅoeo͔Cc  w?B-Ox*_'F]O߯$y7!y^ =zH-]t_Z>h-k1]ňl"$Pju w̢ CQk _wqPoJю%d;8ҹ ҲU# hgX N%OY-7l}+G6EQ+/h8Keee:+G.euC/~u0S|QFyW!&&Gqqq!#|75R>s:j!uzDK#HV_2(? ~er:Xc]WU5Z?GEllQBK;7O@#eƔK$[D\MEeF뻫KՖ8bipiRTF$E|mVVX񣇔"Jhh 7560kLهj&A''GU\:((PkAi]c k2HOOWƘ-{Zn,94_5U6|%IL,jR`7Cd2_' +7X~S+Pp(Yj 2dQ HZ* 2 Ru&k~*KEJ 2H֑~-3 2Rt_ѝELFX,rCdAU)TQQT- S> 2 Zw)jIQeO4AdPT]PEi kAdPxCFmyAdP- ;[7IENDB`gtkada-24.0.0/docs/gtkada_rm/gtk-button.png000066400000000000000000000036761446021174000205300ustar00rootroot00000000000000PNG  IHDR[L[sBIT|duIDATx[lgn6;ni )RJ\D)@ !$RTE^ Rڋ*-$QmjRRnBc;G{fvbfkg4y~ҧfw~} """"""" [O-"eQ9]- Dd5z8eU9I5\k[ r1i>mH55_1<=^u "a Q×KEV"k QӏÎ7D+[ R?GK|Wԯ&n"Qf "t=A"u!~lq@~-$j|-`+"N a Sd@$"0H)D2L a Sd@$"0HWDA1;$ea6NNJs)P}pqFΝu9ضMӒ%[.r|KYP$\ fo/I:V8N}N:_{qX3uQ$\}-St^Sr&ynZ| >PE+WuֺVX׺R CI\.GMM+ %1)+sN+rGFaA3===vxq';8~8)kW%t "y=c, ;>YJ?Nӿ \:{iL?y~y£1=ԗ=(ݻغ_qquCb7ذapߧܓɱ^}?Sxg 7[?0~ Z$H8qq(aއmwwƂj]̂ M(.*>73~$ZHD~} C/rF+Z4KZp80L(BeeOR40 XVT$Ib1s2v;Y+xQU͆(fBBB-49*++iiفRĿJ%VEsVgl܌lf#|ʔs  үW "5 ]yWv^obI9U7 IRP&hlt贺>ِ=!z9c!kϛdvvl l6˗_ qvUŘjg(Aa`06Y۩4U; ޭ@p!5ql6^WʃlZBڿ&Oa,\ Y5=N3}L93L> _gԷ8|14y*On6ܽ{6͘Yo;wO-_(mڴfa;ؾc'[l`00;0?z:{FG$Wp1ڶaMZ*}vrΞOSVvK0V`szywf3a i]pDӑ9?v|ïMĨ'))YFzJZ-$$ēL9v8+xd720vΜ`=de/Çے͛r7xYr5Gk6]͸&2vN'gϥg , Y!п_ڵk?/4]\.W7N)RRY!꒤AVdZL1Çn . $$c8x;ݛ11tMO7P^~M6Ӯ][BCCMf`+/218N>¶m۩suDHn]9rKSH={de66nLaQfϥ~\}U3l6>s@TT$|x)ŇzRrrQ^^N޽pSoJ\{mSTTLu( }L۶W>lf[FXWTTRTT_^z\u$k^aCnEEחkS*j}n}<4uΙ3{HUA9w^^.QQtIe,gNմ֪J/➑#~no9E?F&.fag&}cGtdmWVZ;rn˅"OHNdVC7i!UUUvi\yMvg*NvC(}xB2 thN\:-!㛊KmBC‚Y洢N ! BH@ $~~ z-fnw.% 8W/Ct^XX|d2RR9bZۢ3f}ѿ__z ^wA۶07 k+W *,h^BD;̼ycO?J׮iDEE2r0\.=zd_СBO{Lii)iidd\AMjVq9J!Gj_^BFFw4 Z#99e3foIҠjPU/FAAWz]E *_֭IOHwRe"6%~ b[mF#;vwE(Ӗʢ w!*Na,B%% AT$vkТ8qf%1'"k'! BHkW9|x 2-jeU,^.o3Ѯpuϩt:ygڻnJBr<+=n >p>72x<f;UU֥^b!%%k7g>r9;vCl<صk7[leuv<^6ڵTUYY^/(ݻ//EQ*ocu|ض}6R0q2ȼ7w:綾WaLp}o4c? 4VPa{>-~g LH`4$M~dT_Oqax`a#}Ӧ#KQH6Z,3j_0vӽ{]j qܼ|Z ǃ$I 8޽zxR 1 D7x㍷sj+dTTT` +{]:כ>,h,SVv&ےU0t:4-X̾uJ zoeİ<zp=INNjk ёخO=M v7ɾVIP] ͅ.1Ԅ"A됽a8Cя3o_M*sϣ@ ZO>.Laۂ lVܮB٬U -RmZ'c V.N.gٲl (mcO(a劕(AjUoE C,q1H#_NqmW IDATx}yxU޳CHBB ʒa@PpQg>P}qFegA\A@|יyGDqC[’齪Gw՝:Dϓ;յܺ˹wC 0YR(Y8WBHwXJR;Gֳb˟!&Wzһ*f&>nZmG^Fm7 =ƈV)QqZ{R_wQ*jmlZRsFF& Js> ," ߕ:B<;z޳9F7RD#sϻ%k0z޵{35A`X¹k\O $@!ě@xPښYby!k"GX q5Bf,@՘91Ԟ8*.h"€ C,f1y%qE ٨*66TlimR@Q upгT:GpPЭtɓ<\ T ZR]^_׋ɷ ft'`z5cP]fA$t&ћ ZmboDhZZ;F5%ncЋx[Z[a0x h2 {\ S`X`ۑf$ ~GaB22@`Թnw  að(.={!?+l6;p!46/~1_~5hz,6f~4BlRS8|x`(,(qصc <r `0#]?hP%XőC{Eشinq$cĜJ+JeZUz:ji$F`Jm=jdv쵴T=]2!C<;mohmmEys=Xe+V k5[(] s_arB`ZL}~, qp:aYE! bHy˲E˹tL2~I  F Y)iaSM&~ZBx>ǧގr̈cR'#mxCzߕT,w ¶nԛsfV^wF4>oZH`佌H$rw1Zx1:m+wV?v˯Z펱,+͕xǎa@4V+,obPn*rr6bFsSa!J X,L>6d;,?-X-{sp\f,aLf,8dL8@0Y²,:-UC4)ƂjQWj0?>sG /\B# "+z4+9BA}ޕ: (Q< ף[dqOt Iyu EQUv!WVpxzyzAƓ5z\B|>T'9Q>^5Om0 |>/B䣣4Nĺ^ij\e)*W\u-Z@b  Ja/p|a$${MӸЯ_,^2!pe`=`_eYp'ujPP(ٰF xp0G/EQ8vضǏWaY1e* , 8.̲,^={w\4;)4E#KW47nw`kQ9x+<'?ðR}ƉZp(ƃgϞMQ.Z@>a.֨ǠO ݭށh4 xǃo5ԄsZ$P(^ů/  0+@4>,\WdegcA(@ Uﮈ"6u4b6~Uv!j;ϣX9?6۶۪z}sp1wIbZꠞtBG꽷%8uL,}UxtO,c.cB8NLt; Vz4Ea|˝ZQ jA&%)}*|>bjD 04h(_6Ν[ދ;N~zn2hYV_< pϽ B,+|*&gApX5nt^f ͅ+#3 F>46FVVd>Nڂzre!##3|ODl0Q _}a}%2_~Ewrz~uIa( Bɹ@?2D~8x`?"dT_e9z,}s|r"T}-rsxr塾V4@3 z_l#q~{Q^Fjre9 m[7cӦoqcc{XE0Dss֬GV+222@n%dUMH1ex>^s\p8Ţ 7O&8zJ{|^&?%*X#L@cahj:L,k(¶q`ed$+unT9.t(_S̈́[K^tj*nGrWt2PWWo"0x{vhijBNn.V-P2HBQعc)˕Q9h(V"t~?,o-yǎẁbRK3JMb Qp[9WbEY>ZBl`i,ELbh8Vdg砥 (ʥp:]zqq0 U?`=9j%8آFf)V?6 ^3;yv7Պ@ E9L $j*d$/2-p8}hZ#xp:5^NY0p8'EQy,kj6E(tE| DVM»DU ҟm@H~?l6T/XV]%(մ 72MʝE `0"8N@ `%K^0aX\3%=PW{ <ǡG ҟTstMC8͖h !Yyhl)vx~j萙bAy()XqbB@t%x|s湀v!zQB G 2!VXeT_9WWmYV4IƢ)t/-8>ZdԞou:sb7R_zZ޹ZFZ22F՞ji\tOO=u/3.9ԑ 2t$/C f^3/C\HF66;"h=a`d6ZyYɹC+uYv&M}ԭ.J+Uz`J}MŎdh%2Mx_&ʠ&:mX-yAkjZ=VsSYk3`ДdB0Q$-8y{V Ŋ[62sdpp`}Dy*L@A[67ƶ3 EСC( /2a)e1j(/hZУ 'nEZ *s$w8U_ KOJ꿞yLou66ԃZQ\\P.] 9֤VApLưld?ҽVfdJ{˲8{,]g$v۟OFUUvd4inݺuxW0|pmH9Wj6Bru4s"IaCwOc9:CUJc0Q4} ǤZMɇ v Vɠsl+KrxMw&==zJZ_"VtYpeekʠUyMdY0L+l{r/y[jz/jF J֗J+ǡ3 &Y K:!tA=&^.CI&+%],.M.Ao/ݐAͺs^p&| x<U~^>SiOV Jb;\-MazYRez^)X b3cDi mϱ dӟ 'ĉ1i$vmq9&%,>|L2Eݵ j93v+ju׎Sa$*ϢEpc͚5y^WK6Avᮻŋ k2A|Qvџ*<\.@@Q~ؼy&@4A?n-?!fkWƽuF W! K/ʕ+`ŴiӢ2x^ 2Çq뭷k5v gΜŋqeAL:=q]2DvR#&׮^ZrzZS>ȑ#Ϫz92M{>kN?io&AYYF0&̙3xzq>  $ o gɓ'5Ϳd>|8̩ - A*! aժUki& 6 3gɤ2+Qj 0Xp!֮]3gbҤI䓨Nd<>}Ԥ2XV̜9oQSSI&aҤI1-(ؿ?l6l٢.x OwA]]y21 233˗/˲9IbYl݋&v;jjj嗨UIDAT_bҥA`zgӭbO/Y!^{ ۷oǖ-[zjdff㽤1y^f&hq֭[@ ݎO?wy'Ν*l߾=ae18,kя1鮻Vi#bdXoԋW#W#Bܨ`5&Z+vL6AIeMAe02AͲl.4n=\-ވ6(A2aۚ\+lj(Pp~G!e0 &!EҞc*&2йܔdV MtVZf*73bAEZJd;&nw`0-@2t1I$%<n Iv^y<b3 4y:A=wۍVnem> BhmmUzu1IP(t.FiK n7n7ڢ̟ZcGN8 J6(GEEz ⱬk~ibԨQ.v+H^|rylڴ CEqq1>s+PJ^^)rCY9 ѽ{wdgg#77/BPʂ'`QQQ~ia޼yzZLGrJؕldgge|={6pWFWرc6k2Nt;w.Ν5&d[B.bpcJF 0~x\wuqr7/8?DM2+O>Qd&(\r%8rH;şgL>]3~` ƍn342|>L:---;%\ݻʐ4`k^h'^ɒ VZ.Vt]w$ Xźu0q(,8{,ƏYf){!Cii),Y-܂+ѧ 2|gmwҥK1elذARS >èz444`ذa( ϐ `۱|r<3b(@SSJJJ$o`ZnuAdgSEItbyyyXv- 1ydC+~5 {x'ybۣ =Bƍgy#G4k&jeG^n7M ,0Onn6 "//OU bx/1xLKIAYbaX}2.҂!C,/b~<Ø4iTWW7om[n=zݺuk"ݻv6 _|+P%EpJc!7oFcc#ك`ذa={6XŚ5k$7TrxΜ9Ӊ[b̘1ӟzqM7aڵ{9J.Tn[l˲8p˅1eʔvjFN1 m8rQTT?ׯ֯_<+R$vڅĉزe Fa0vXE+TReF xBkٵD q1u>b:ekxxim}G>J%!i!nIFo}:&%l2#;rL2:qSsL"'ʠA|RaePk/=d[I5eexj,V=rIl+NO;o"&\e舕耏2\w0 &!!.CRAٳ%/+VH8~8qٳ'-}EQ4hT~Xj%KD2Lde {EQ:t}D /$Wɓ'G]qƏ{`0?r`N[XA ~>Dq䣏>"ׯ~@B-=y@8#˖-#3f QKvv՞U} dݺudٲe$ i^kObC>Y|9ޘPcv"/R '>J~1bD\1ɂ [[[ѣG, .\{7*\!C8Yb\.AŋqwTWG:tbܹxqNqL BXf 233riӦ8&?}>^D,DrLƦOds[V\ ÁaÆE%(]TAqرvq̘1Qpw#222p W^hhhVL2(5Xr%mA`PG}Tbi9u4Ȫ8A1 /]tY={,h7nЭ[7?9,KJ gSSTSNZJV^/"N>y;ٳ`Y6 .An# 8Yxt:ѳgOܹSUKA,&LY0vXB!塢~-N:Gn_\ ࡇ‚ 0gs'|+V+Hi^7oСCѳgOvm|gΜ"Z1Iᘔ4+ _**KmlfQkH_| XdIB @CCCZ ~#*? EQhnn˲Ȓee[0k,\ұ x^$CO@AMM 'm׿֭ '$^qn7!ҥ V^ ''Ӭ nQqr;---ͼ{( lؿ$See( oGa ?(BII ƏK&dAee%J̟?>5?Y(TUUa߾}xGQQQ!%[ݻ7v|wK9dieeeի*++1|p>|8l6V^/! +233QTT{k׮p\B=0 leuH):m-ػgGZ *IO.&n-F!(F 籩GX r:1R˼&܊Z 8tHE"> ;-CENċ.Y3l#F?ě)ix @4)6Rs}0 Ĕ ts&p j{"4MG 1KN$jlXHK񬴉@3ȥ*Ȫ{{lWAVM.e0 &26 &2`rL.X*7% U455B;o!Ѷo0e$ 6ԀʰKￕTtA=.}(OXJ24!?$6o@QqN2BA VP՘*+Az.쫻*@Qڊ CvB`YKJ!C!V bUUqSiePj k 9Vo@P\E% =~: wE|2 kkmHc\P<^<ٺRqEK!iF} 4mUA\t+Y2R5] Z,X i#&My q H4[lٵ `4àbC[M妶2R2߻ >] ѣ.FN$.Brރ^mU@AAawX6jʠ:ɩ6UVdrSzdr3hhi F75)HN*7zi]ZȈ0#"V5`]GSˠ.1I1V2(2警2Ď2葸L.e0 & FI[fD]vБXFu? @UhsDכX3@*|m& +*~]DoȢsǮ8)H}/~7 H@ִI[8]+"}@"61)DlL bc Sؘ@"61)DlL bc Sؘ@"61=% tk1M0@ |s[INxLAwN=@ s;ZYI|cc#.(`e2LtC{zߋi[fë5=qٽ=> &k|oqBF7Z>c/I:3OǼvKHp8e{^ΝKmm-#G$' qG^>៬uI3mO0ytz)8D2/f/{\P8e̻yl. 1{lòe?%ݧ ou#co& gтBv' g?j:HyT “REOpLտQ䇚عlgDw>CN~RDm?䟯^e5|¢9Lkb|X<vɌ|EE7l<|uŌL? uf}RJBG!##u:[kːN뇌o>Pɒ9`p/S?_#u Xs({&)я'k 59XX?js]n6D+(@`ǽћX=K*.~?߮`_~^vE,4~t,3a׀)RQQIػw/;w#//[orI AiEpEK}vd3ϟIU0o8p uشgH˼[u6/}DտWLz۶dFgTzm9鑜0@ ۷Yfz)))PVV֭1N$;c|u E0:4vpUTWWQ]]ū[wpDN^o\g0p6UԂ~:ַ{3&!HB˩''' 6lX ~hj<δ;\1g͜OW-Es3ˡWEkބsgI5]DT$^_1gic6RC3?ڱC,d"TRӺH5*,,`ҥuţondK大;65o.vxJʮSvQsx>ˍR܉S8X}-7k;n63?|ѧ<'\@8psf'rWʏn2g)Lpcdh9[_xrUf" 1JfѴDX<'jjk~CCwھx"V=It`@Ƹ!Rt2eʔN~K j9 nt͝tNzadegwk@$NOL|ck@Sؘ@"61)DlL bc Sؘ@"61)DlL bc Sؘ@"61)DlL bc Sؘ@"61He&hOt{pZ/."\~ D[0B@$0qL E3p0HD7b%pv&"UGB@0 TH$D"H$D"H$D"H$D"HjCcl["H$IFT$@^"@9SD"H$&W,=XVaG5͗JK$D"Lbȳʅ.W$@paoMh~YC["H$IWXK7j/4f1~V.3nAKga2P*ERQr96ԱD"HN2Jm㪐0 4؉r.9`ʅ[T+{F aF5.!]'u'~扪H$D"ix =QŽV3+蚑άVXF~#HJW F na).\B9#s0=Sz 3gaHa!9Ksٽ;#vt,)tԞ .'Eۛn]\8)ώ8(N͉ pSNIv%Z*Z{UWu*RZѵ} 1jhu:I$MŎV3t$Rג/ }ٺnF :껝MϮgQ9|xH[?xzVy+"t֒4 MSTEQB`˅\{D x.dKvW_3gġL~ ]j\6w捧[TM׺~=pv?'nL]z9;Kk޽U qqj)9zD2JrL{?ݒ/}''sg/F[w~:ke^I!~gҪW/U"9P+~J=6o9 /{7;* NEHPa"jE3iMUXn4-+Dr痽#Kf##z1 lplg{VbSص-=  (&V(7Ѽ9=u%zQ,]YpqrY[Iދ?_2?yH/dbF\h{]*sNqYE؄Fl`[A [@MH{C˶q8GѤuFdsՋCt~%9i]p x*qӿHs|:[^1~=BQΑٙkCO5rep^[{$(=6oyzc|"X/TUel2c2ih(tCDYA%4=`XfK57c)nNa-i@ɑ7vƘU {vDki=y$y} ?B3cŠ0N?pF'EGZguќmK!ˬ:B}[\srp}\h+xxu*j̥Io܎U0DA<m(cz2hVU\3;䉞D }w kR3Py(8'#;^>Bڹa$ ǏGϴy˫6o98[ձqKApz$?}bQ*X-,fVL&cp:Cj[ݚq.djɠIJz, tBzZ fUq$CϹ|ai׷8ZIƅ#9mG::?S1xEƵ$.V;g^֕!шn՛{.?2--\1,˱sod2{[؁ޫ?3zvp M(NUgH?0O_˧%; "3rz~,ɴˈbϯ53ܟ)i#YR@VΓD!惒Z}Nc21='mm.[RO:~^yC iTu~;rŀ41tc7Q-$<ᷢ@B|3 me`#MH,Yd* c5@!fa7LvI%YlSJr.dĈ4.vH~)P4b[BH8FtrJO\qhohYKpVH&2GN9ķYl~=@.M[woN8m{ ?ꪅVdnU! q,nIH۫h`vXfyHxɴRŸzE;lqFI9&aqI$@`Kr˭\tE?W5s:O5@} F"l*ʧ<]ys2g0ڸ?[ d{~s\y4Eۓ$l'_=u6QP &8B'Bێ3n"q(@˨[dށ ly2 Fw=xS7s՜@zo}[ǡ*hi8P""F:[ޛOR|g}_v;.ݑŠ&@1ŇR ,w[>O 5iOOWi'Eq8/a1/'=1WA5D6U Pp?@F>ߍ]Ǚ؂(@>}QCKML}gBD:A[Mw3c[_7wߩ哯nD0ΒM >£I` .[w>i6%[TMH=#isfh\5y8&W#rh{RXB|zxwULPϮS9IZ}(/b݃~5g Zesu-c:]Խx*UY>{4V5#c_d[YNԚߐ.ZlPחk6}`zƚgs8}+Q\_MǡES=̫:q3QZo>/uWRWYXf8yuD3y3eD!}c1b`uzpnekxs/(jM2:S8t^5l˭Ɯš7eqNY"^Gwq_Vȥeopj0"ة/ey FGY&NURʝ\RvbI.HC7x7i38m"yD%Dw>;mo\dڲ<6wdOr9?2rd,&ώhS/BTqL= <ܳr E%3uŝLmY,2v iu,.U|זo{ό*y{Rէ)ڞ~;O|; P"J?QOh4DPMi ;tamv!G^2C;Y{WMyu18@>X1_Y3>nFW_瞍_Ÿ'FiUہle<2Z G%@4TIa]NgP` ,*"4GmlWLT _q/.#ѦgR糸Āw4IImt^FdBTUNOK9k͟OzZW3i CS=),*p8</E>_?oqQETq|z;H5ڒbd`4'H!V$k%аbр{vS;NCǡPSfaSb`T\ FW`^R wI:qeπ&|6maZzKG1HoIaڵa׊V u8d#A7.a u$1>*32ՕrJ6Qb@{ ht^ (Lb-J:߿ii闡"'D^s w3)WKj^]"."Z9~Qry&**Rg NA&Ip%Ee5%UWPxu fIc$(\$쨪JV9r0m#pB%!eڼy2) 9I%xKO1QZ,B " sL V40PFEaz+jAFRl7"pPnRˇج($0)*<ŅPD9q;6Qf}ӥkDRba!|g$&&ҹKW4M w071vE^pF cǎqC翰ѴOL_A癢Dg!hA@0t5 ԢE`+~{i(]#5e߅$DZX9.:z+D-j`Y/K0Q4 tC`nap\F 帔ua,jq; ܪa{^5I$/O*}btyN]Xu\vVQf5!=YZ$C !t.Wк@E"=|?ּ7$DRr;o'5QQzͥMQ@X ^K{ :ʊ.*Ѝ9VH OS h4p 3R^Ʋ$BBf>Uh$j8v3GR7 ;(͛wUR3=~<~J#ma Nz#j1u;Ez6=8g ܱ+e!*wS^:%7JiE+еD2ir%D/@Jgؿ+_Ӵ㖄'rfI L Th4m.Wt$.5ʹH~A6[Ӌ{oh|2n!g)bv>ط"9 a`sԩ=NeU /vCS&-,޶ȿ'%zj(.z8h4 aIgzaTfxW'Bn^,T@qpLZ@Hˏڷˡ:ǎeE8kq7+UtQMf^˰Q9n|O92n( ?~q#@a}E r,Zs'@кQ sn^}ҿ__K+Zuƞ5~?YΟ-McȑUvzKS&+,vͽM`hh?JfbBk(wU R{DǶĥdrET(fJZ=!trZFJe,s>[5Vs}L!_#{\ >yA֧Ҹd՚$xWsJ1\y\{< k6KA@W{ a h6! ڶT>ӦM&\t'oi k ##)WgȌsnnn;EV^իe4Ak^!Nԝm{-(4~r="47ӊ|#@Oy]78r(iB..>1UIb *B/)_݊+W+呛bcajqZz?Ҝ~{3^{.vWپirյO]^a;׌_^v:3=fxԖq]wr"gՒhz!$ء^auWQzĘ)>0žGK6x]RsL^blچx>)9&سg7 5]sX3Onyƛվ;܄2kmI 'ײtB !>ya6݂KW+ V4镁z%e ɑGIkӦD3(2,K6w~-7ΝwbĢ[3{ΐ rtL,āɝA8ѡ3fο?g+`~ϫ(fNWw$ɤ(X @ yܩ)|8M/v`ICLi ̝47x W&[GfL\:y3i`T]JO|F%ݵk[`ށ ly2 Fw=^{̍g--smܰx% Jq[wZh{MNX`ѕ*?al^* 5 Z@]-0<.)-lڴ=[ġh{x1RK8\+u@9q]|^!cr=S;u|>&] Qf9d;t:xޘԛH2mvWORdlZÝ!isv6۝Ss>3{r{fJ)q5A!,{Z]>G$hW3/1Ŵ]OCKML3V 9>}kGVaIcj?l%^IS&%,w'+*Boz߉a&RŏoC8G,(,d6Ѣyyίu"EL_)^|H"X ^+6FR߄vG,BZ73).) 뽟, %= R3~?o "zsh{.+!C6|8/Q^+,op4N댿f2&?1g"H($ܧ෌8_swF|{b;!O 2.y?]ࡣ5l8{=ȣ=1tƔ.eE#z}[- Q=m ނ^hF͟7HK e}UoN={i>(;LB+M˘us(v- _MwwbuSZzKG{HoEc[+zDz 3\M01B- Iqq8G,)-cΝ5'TCiMR}gKYjwapg:%V%#'D^1?,.\6^6~([A*=B `K])<}y'س7|OWRzҢr< BUUZj͑#7BS][*(( yH' !}deRy@rWyUTRPf1iXݒczE+w^-m:|3hN [p% ( L^V{k=U @mv M JDl}fcݹDf֣= "LvЌ+9WD<[A5` _:FuBQ=19)ahq'з_pW/=B4:vꌪ_k./wIHk"B !КO(Rp==Uݥr|J >w1s SDa}9.+܏V}OA*4$a}[*A e r_Hk_`,Epoi5 kE"{JtmSx:9ΗVUёMq 5'-뷰LCx!BW:?G^ED$t?4WV& CU'qe/ v {{L֭&܏V3o2ՖD! a~n:ѣGsԩ?j!".9}h K1S&RDC ܩ[\A7>^GTa`Yp!̞͢ ;}ˆV^-3xȅ r!{'>=63:SXt2"Fvm>^|S,,,dcꁛ4 "p|wP u)l_d﻽zWpYgG357$piFbDyz^2*oyvNx '.h`k\2>q Zi+//pg m3xUtq}Y2\Luo3H sʔscgUw]n$~zU S&h{aob$GpTVun f 6 һ+y %bO9GGI'7BNL7rF?ȭ%#x쵽O7T]YlSL!)11uH8^0ǢbmξN%*55ř/cm׺;p0CgOmr>ȼd{&h6nXJu$ 1|E8nudΥ;7҆0plb]\k iҢq'Ņ}80]!ڑwaln?+(פi<=}\U ^؅@ Ņ RZzP,ç'0 _ ky]kع; )3Q ]PR%>%U%,Y.:bbbb>u鷍RaO^ŽS?Gǖai}Lsv贫\ݛ8q1gBD:4p٘K;ם:_uL);n0s6N.|u#1e횊#=}cZ\㚂='ƎUzwFiJBT$иjpL>GF=)^Xb 7/ BٺUlX8.jz]B}V.}|Lk0AjY X]:LcE IDATkV/ @wvj~¶kypU9Kن}Wsw';4*¹rjQ9gY~wSS⩟^.I:{"&ʉ<1XX.Zl Z) 7^ߞ1OMڞ~\{Qcv"QɣnioC= h{ac*(Wm Rl8^l 5ڭX'$;x _/wKjhn? FBy^])+G;+xƶl=AE4=Q-ԅͣT3y3eG!}c1 +Щ5"0x-`ga۰?G?k"՚"=Kbti&/>Ք<=. bVz<ŕǍeopj֟l\_ochdkqKEkEn!g kV:]/<VOxo;L~׃- qquje[֨GbfUKmv]OzM]gm\t3W~Ӟ=]s|O3>m&c򻛿Mb2SZ`1#/HSx;ނpҧy3nݘrѥXe8>^BC3=gAVV>{plb e5l^A`϶Ow+|'ӽ[dLg6˚嵊KmSvJt^I DŠh =-gY<7>iiUd8H;?UX0 -PWaUC^X}{T/;~Υ]嫏^+Z, T=Eo6z apucuvҵ勵iCT0-=%Kg8/-~wf;O{]Acph8uck/ɿ_}ӧzn Tw sɡe̖F뙆ijD#_BJRi{O؄U`}WUs&! A@AAQZZ-ZjݻժUm]ںDPDeo;9?nƽ7wy>q޳nuBߖfr_QШn"VܱГaCYl=`RX4K ͎Z-|ka6rMߟx{))) {̔4AŨ׷=@tu#zȞ>~GUU uKJ}:jkk4Wgg$,XlԂ5p=HX=Xȷk0td߫KP1L#.ߺm;O<|4sަa}W-,zfc3xwf1 cfMӤ%KCtى^H7f`f$_a[ oclkVY&2\^G~Y84%15NFaw!"}u=f1zl967xOG^^Əﭷ #{S>;1!C$F H`D#BYi0tC7uCnCzkocx;膁a~1ܱ3`o>FȲG7x䑿ysΪg^HC>Qv !D_`QX Fv/Zcfr4_F[h+8^`{38qB;>L-s:DDX]5vBW%,X4j+BZxL0+}c_.)ik~W3=N. sӮHvv6qߔ&j͌BySa_;OB~p1MX! _Y nzuVn{hön_0Ly}a|רBd`a5L|'&P J}KA̎ P]uV6Mſ,F  :0ʦ_˝놿mrn:γ]*tu]0Sz.B'JX.3 5&8X, ⿘q-1YyPG79hDl˷\?zqh&(ჅB=U‚Ev{.B7P) miпg{KJ1CLչ3|g4%D`ElsY[n3aSj 7ZPfNn\A!d ѽ>:$YJCpmзm0ڮXoӈ_SI3$DH:bk]"5,^%>P\?=XDSK+B!"IXoA3r$,}.+!e#a?fcѕC +ϩnZ(?l>ul!,KWWYԄ ݀e뽣AB/h|bt}S6蜏P F5F9.GϜ9v=TjnޠA>B ŦC7\-6[/_nC?gٶKhGfnr{EdP(sj:nVrr{ʔnt7XE:B' 0Ni/^l4H%|t-t /!a۹(}(!ڱN諡ͻ5kt=T7loEl}, BIj,@  t]fی_E`9l #ùcGW;O#ul梡/ɉ}n|B/{Z ݯM}T_Fcߝ\y-/8ѯ{=PPX1G}|7zx|Da}6ex++ζm[H K5л,zT6UY{V2A­د 6!F˺ k'vy ;POݍ`1NEOu]zi_EVTäŧ~[y~3sZ{\gK3HAv$H_-A䉲b^4bD}3].:9K/RRR>Z/'x3Sm#d !FB"X3UN},z['EEX/^.=vu+FZ\.=fW; WtrN?Lv{||y)sWb=e3:W Myn:}{6̚5cٯSo)ÊGw<~Gp/ȇw:3fgqˋ|>vBw jwi5 뭸MU[\ KZ{(ٝgxI4CUcmY~g}6/yRSSq\|>"  idzt1?WªgGPcJ\ /;jk^p\ۺ:Nz"^Xb4oQ;7DՒ+wӦ#7N4ZlrO^v"sa'9=r06|$G{ O!+HOԟK`13`d*|h,w?hh9j(Cp!"ncY7m~Bxd|{3un6ΟYx~x,`ߝd5W3泇ׯ~[)yװo9b*׳9_pp9'>y'ofQz(G?Ø| {7ÏUkQɧ/ pϭl%}i3SOTWm{n>վ7w>n7|Y(Wf=,>!ؤX=8O9 ߲pOà̀/no.\{u!txҮ/`~ty|PY>_e [mÅmz"JocP+_"CScnwdO=o\4Lu(V~mo=\CdF~e_{6f!ӱidKv{]y<;ooPp덝3U\kF܇f/,':}$_M<`\{Oî7eX]}*+n'H`mw(XsHjw%U’5 L#Ʋn1:”c 9s@jEC0a8*'cbeʱͼ؃qr̴8y( 3[^[BI綕hfBvgy+Oݥcu9GLRrݥS 6H^Y/ˑ)vx 63c.w+ad6e%' ia]ju wz-dj ;fn}( ʙ5#}Pk\ǕÿUC_;wXf^{ C3\,oF}vU>rpn|k->]mIf fF7eĸ#T̠P ⢡TVr8*+1bv*o0ϫZv}E'n3xri|(ܑE>D ?>^luͣeZrssxQai^\ʶ ']0']}2گe_t sG!j݇S氫8>NZj..x/z`S6x-̙Yб}cXO^QCk_E`?mWE.`Ӧw؎;_fe}wu 0VSIl`!CSh~9sZw~[ (Ǖ?e8ymTL%r|3yZ{FIRcQآUci6VȱFc$- KtoR6ao6f fײ~9UUUZBTETMfFkjj}} F@17(=_O^7Y//ev Tμs1iԑw4,uxaC2y(s矔2h+8wu1ZH-%e0=Lo:o6xǟgO퍧u=uQ&nrf͚L?:s_F[t2nK , Y?>O̰qހp/sױ?j!x*v f5P\|[#qC:mI~` .wpAiK\e)Z])"]}wlV6u=eMU=qeL7 0viiJyd!i׿LMi~n\ECWE2Y]u%~=4'TDe&1zoM@P߶oL <S8%hR m5| WK(ؑCWF2*˘0gzқ_Ki3  "5줦?jEL;bƌEKl?S%T9O/gŲzh*D,*X\e;`[ IDAT -6VY9;$&MlaչV͹yHS1z0cS9v(cY:-ɮJ؎uz:k+|D`0>nUqI5RX8[Pp8{֭[C0 #ѧ" v9y.n ,… u6g4vU6H<$#t9\Mƀ ;c ]HB*a<%/Fz b,uXFG[6ϘCvv6F_ٻIu~\o~>D\NgOI#I,ʛ[m yKǵ0!7ZVt$̠M!A0~Hr *GS9ʱ Ɏû;`" yV&v|5v<4&M((,䨣lDG.X<]z-Åm-t^92U|ݹ+k(hh/QӱȁdPn*=TDQ<ڏ&}?@ lעΨQ7~j5Uav$T^tB.̅K2cd78,U*_ /0moE#Qʄ9TeTHA^{lxk+E~!7@h9NRe/Dt"'7}Ύ5@{{'RƮQomF#MjTH `&AKqA:P92Q9LK^v:OVN|V j. !8L !Ğ#)MǴpR 6jE*Noo.u4(4iDxiT̢rd&#a"_9ίQ76,FM: !H`pƈVXʶ&5ڊHQ.ȹVeOhmQ#F&ҩNt*GfR1"̴}B[YC+li ZE>9g/{k&Wo3b >\Vo^evAbhly˜aiT Oa4*G3,d]:oUkarR[!qԑ<[!>,4u6\bY *L-sڊ& b7%%g%Ų~kG`mYhyz/BLs>IZ Eˀ+̞bbb:EFË$uVƝ\(hb=}B`pٴ^Ϊ*-pfs ŋ׷m ]CC'oG]mokͮ&T ږٟ`~>mZIr1hߵ ޏnE }͂ޱB!:%Ft8p4|'(_~-rt]'-X?v:@ j4Z.g:s`L =]E' ^Epuƻع TL$m>fڊP_Lʣeބ^Bџ`a౹Ymw<{ حkp?K2"N۱MPap<6MfBg9PcBTh΅Ovϼ q=op}E¹\.f'5Dԋw2z!DӧF:i6Xx|a_Ȱ%mةQyҥm$):BY5E3H(_:~hQ!Dh}Ƣݟv07tf]*Bu`#/>s6mDN t13}hA"{4繍n)mޑ#Pwk,va6&ECE*KEA'}+t12[B>,fD À;Ux1%/_IyEU~tG},M/셙gW#, Y?:ߕonȤE~[SSH *DD.lMOC/K$,ʇinj"P<9e龮I =8Kݙ"亚F> _BÂQS\FQfYNSTt_DuRS:u  hM^~UB!qN> %킛Ng'eR%TRo@ b\szU !G 3grgp萠 _-0ln3 S^DJ-) ey{3V4(*;p!B!m i_57ĩ{Ocټ<}zJk)ڂ{γC!,Κ_/mD! JLXF38|BGک+,;Գ3Q6PVvâ`gJGM!H{|8in"sç>rl.:/VL,Q>vCB@ehΦdBD/]xk=fڇhXۿ&4yP6g|̷˱1߆3;ٙڗC /uDZ/J!7`n޺=gP_>rIYp@O?JCɳ#yRGְM!n.Fn)"z*X.yz"cce^s| ^onZ߷QL0Wi]j'pm? τ Pa~xB!vS N:ɔ~5/D·'@PXoЀS݌anzެ^K+M-4/blS\X(y:n(O5Em0(nSY :#t3/dkck:@QA5v(n:U\5 ZwsJ &5",W… URk`[*"A$XZv˯4olNoؠ;kԮݏ|b BE}-r}þ]B!Tn>|y6cRc*PkkUN CJȏBTZP =#Hf_'2{K6\Z{AQ&L]Wt@[NG`*|ÅpO\$!#"< a3 \cG~A!pѝf"<(\h/ǻ)TctHӿˌB!D_ " gZ|=ht7l&d*4[owBD4%:iZܳ]Q!}(Y,p/[Zn!Cawk-b WnmYd๷ Z<';B$XjSl/k l5,D;BfXij`фVB*{0 dy~ ,ᶿ42zg N!mH#/kPmBHenณ 'XyT>φ~HVqrN քBt8Q`7fWʛy^"RWKwR;jQ:駴z5_Fx!D% 28NWXX𲝅/ع!x|,.pDB Mc\d:ޅB$XQFUx֬+>+'Zmmb}dvqx B!IE#*u>`uTjk8TZk*Wjn0aM7Z]O`kM+0,If^VPP!q "i64Jg(=ѧ"BD$d !"n$X!"n$X!"n$X!"n$X!"n$X!"n$X!"nz}y)C;5`唔bZ{XB%ףۉ:tR]SH"[Iau*ZfSRZi=r6n ֲhư;BuR+5B||9Ҳ=~.#GAZO((( 5-G)}tIIQ_4MjkkV\KgEEv{BH}a$aZ1 ; !D_&M!ϓ/z!HRc!B`!Bѧ[M!.oWdBs9#vB o9ʫ,]Z6mį;qc}zB'IҮ-Ͽ,6l@]]=M-^,B!I藮XVl 6jNb%%ŞB>Kbcp84;C͸#{d*$BDkʔ),6mLÁ!7'@YiiOS!, p8kv>H>dJVf&w~g"FBnAEx<׫Q-v&?nB~~!*'j0tp!`r9{ąb%BiEss3}jw:x~%~iOV!`!d-[*Bڐᠵz%S'2}HB8>Oklܸ+W9d[kZiu8hݲ}3cIMM }""<}\/|[oIlk44`-TMi,j)ּԴh8RSʙ$X-D UU* M뇡(݅ ! O4Ao躭 !7 RUFv!H" ORlcUMnn !#!CNaD4&TVOپ}a4f,al߾E}Frl6[_B$X464p3X2@_'MDVaV+e#F2dhG;c*f%55ǎ!{^vxoR4M#-==ѧ!BB!DHB!DHB!DHB!DHB!DHB!DHB!DHB!DHB!DHB!DHB!D$"dB躎=z=(f5ck\4򷎙(d۰$Au !vef[jkj}:}d @yy9%%Xְf>^=;k$\@Us1e,-t*$$X!D ]ש⫥K9k6%eh3n7֭eG 4a%!~]44K8~D< MtїyuTU %Be:PJˆ'tcЬ> HMKn`a9p^>Ӿ/ncj_G̜{NI#4MjkkV\Sӊv\0MkV!nw7qD4#IBa4&Պa;f!_}nMP,"x^oQ7x[PTcx~W.cma̶Cϙ3L~,T-\< ފUkaC#֔4ҳF~jޞXIw2׿N:mI$n?gbG7<&44{ɷ^ED,"W㣏r0K 17l)(*lM K*2ppKoKz:eѻ,ntp` 콆a&CdTB`Dzg8eijKZTUATŪbh\-}EĽJꒋi޲[O'ֻ|Z~sQ4.[7q{LZ]nTEI3&B!臻 )g*@Q@QAUA@(BmPܼ ;%CsUcabKxE8=+m0cnP ouI,"N oo1on>Gc@ raRx!}jJFa.p5|U̦tƌę'}]u?]̐)ozGf*8m߱l 0ҡъjd|@uYWv(GL=8ֶ>paY|}AX!DT1~ )ioZ,RCoH;}XY{- N|~ǕfL4 B'5Kfhn4X/OV6ozOԒWiپ46fpU_#/;O:>"/Ka7qG.ձ37F˨8˿z-߷Nd`Q q<kK s77-+O+{jH MݪaڭdQUߌm~ XA_sڼ@[^ϵ?;S^HB8'YF0L ۩?p< O|b_EWUa`t4˺K_3 q Gv g?Ct5 IDATO^ۯ!URÛܱ25ߕLܶH6~z99"[םOʼsOB+xo9d&lnc=6U`׼\,v24? v,XFᬻT? gNYyLYD>B'-7c4 itLft9itk9嘃pceL@QUkD05uc躉iESq=X:kVT| fT;tޔ !qx^?{hzz  ɼ_Bɸ_ԝ3;B jѣp0y:;;N4|'^d>]#[b˿@:ˉ `q𘠷CFo]5կ1Mߺ tbtL,IU!ŪbU; w52`ןw=oܮI~B?gMZl{_c !4i)Sp`Zމtcbf"oc>ϚU O=BMPL~1l?zn} OٿZNzr'd҇Ypbܗ~ MwOLXp ?>Nû-58;~ Y:* 8/ͻZwxhuxt|O[ Ee@z*Ͼ N,oֈ8,<.XՊI3Lxɜqyyr2 !#/I{X׀1$ x<&>,cpصSܻXG!o/`M7Q:mZ5]n*&Tx)kZ8tYXƠnjӯb}]_i;vsq0.'?ƕr12cȳ6:ta*GLLcx;yv#r3{Ɍ-gZfO,EUZ4 ͭmWbp~c|=ɭWcGG]EE!)^Ve'O_3/4IHBG>x0#Gc[oߌi֯Su\۶}?jta(p46u9%m,\MRoyxlnqk9{_⼀zӜ*5w={!sa\֕0}( ~wAWLep^&X~u9?k8n|5n첵m]}6' Nl{~O&B!Bp Y)X2l9mn̛ (WG׷ngQ{g{4͊15v0ǮN=ŤgG~krv˹ + } !;`H9QWc32?PQ0TEQo@JAlZMZD~yJcՅa3+40{-G]7~'UEAU.v=Nod%B!B)]o˶aʕH'e`])c>T 57jg]4jz MÓG;X#0xiB!DHB!DHB!DHB!DHB!DHB!DHB!DHB!DHB!DHB!DHB!DHB!DHB!DHB!DHB!DHB!DHB!DHB!DHB!DHB!DX=e:!B$?3|`a\rozԄB״Nնd#dmY>3ڞ !"yxCh,PM!ƛHZ6>;{̅BtLohb,|C !"VEB!أt'ÉO?pB a  !"wt0;qzQcP3TА`!B7wTH`^nBE&B!=` :`n AB xN!CXϢcо+ !i3p͎uϚoK;IENDB`gtkada-24.0.0/docs/gtkada_rm/gtk-combo.png000066400000000000000000000053231446021174000203030ustar00rootroot00000000000000PNG  IHDR[L[sBIT|d IDATx_lSi]if12,Y:/494a 1F ʕ" \x1oPQdq1[`۲Dtkw~]vl`kw^9=ϧz@DDDDDDD|"̑}?xElÉ$RB><GnydtttGsx-H?aH[H 5> |*~`X["s"BE?0l#ϛ l k!Ÿh C k!Pc-h@dNsF:# +P4BvFfx]"0)D,L ba  SX@"0)D,L ba  SXX$ӧg{ bA  n%Ml޼y P[[1^|ń=*f{ bA>o>gX@"0%}\|m۶Kzz:.gyzLӜLӤ00 Fff&\ti7 ]r~8a䐴`&C}}=nҥKn޼igϞz?~igj2K6^{5oNuu5k֬!==Cee%G2-[믿N?iFͿk6l@ff&455QWWǺu`ƍ1ߌ| WfѢEl߾=ҧiqnjn)//ʕ+ NgGGn'ND:&;;L È|6}SPP@SSiRRRB0$//<>:> w|LӤ4|r)))SI@SS7/ҸÛ۶mF.\޽{c^{I;Ynq9zzzgΝ1;w˗/_ooGMẻIOO^R0xoAYY;wI?UVrp:8NJJJb9OO?M={%Kx8v@^yIIgΜ/))񖧢 ?2lʕV\IOO`0\t,Xݎ|sfff200>ẖ ͛ Maa!/¤}HVUUΆ x'y~HYxH?}ɉy\YYe```0Hii<Ջ8~֮]{?04#}׮]cٲeiڵ@at:ٺu+?}}}q7oa`&<\z50Cnn.+V`Ŋ17<0 xM6p8x/Bx<_7rii&֯_Ϛ5kwމ,1Md̟?իW?PWW99Qis!>s)**⭷ƍq tiSzn]vCtR>477STTڵk4F*K06ZNl޼Y Vwe˖-)QM؟ [MHuI ԩS RVV6S;t?"%kp88r=% 0~lOCvD,L ba!5~3*?,_JN9@DfI)D,L ba  SX@"0)D,L ba  SX@"0)D,L ba  SX@"qZ dB"?08҆FZ'Y@¨Yɋ3 /hDDy tA[rf."f>B!@0 x.ɋ`PGo r$ɮ,,"1LFh B_A8{'/">7hs 8pIv@.@q*|:@$Ǵ@8+;|]1D$9Oj1BnHr>o와+fvdIENDB`gtkada-24.0.0/docs/gtkada_rm/gtk-combo_box.png000066400000000000000000000050301446021174000211460ustar00rootroot00000000000000PNG  IHDR[L[sBIT|d IDATx}p].H.! "$Q+*RQv*cCqX;:c3ʃVhR5"k $$w{?.$ ov O~܂g[ˉ=S3?6ɰRbnjVpP)[2B >o="r+"VfR])g" >$?`k Ċ3ތzP"bLT"Xg "ş8E"9mD1ċ(Dr0bMta:)D\L b S@".q1)D\L b S@@ibYe8Ή,'`^fjDMk.B`3 à(`ڴiLX///C9 A,vsŕX1 כa4fx^O}f A- or篢bReS|y>^}e^0IIArP( =5nB!LPrfi`6^W'\|<Ǭöm @`>1:8jAjkkؼy3F:Ò82,r;GEL9Otm{3vsjpK󋩮)SƪH[[mmmj&E Lr|\{Uqsh:4466oW\̮ьP(Dmm-555455DMM BEtFG޿_' @ܥ48#ˮwM ÌY†M[Js< a=?wyl;_Cs7ߺv9n[x~TL'}֏9˹~jݼ Cי9s&`o,|y=Xzj2O~cw{+((`ʕ=g:: ۩6n,^| e7og e| qд(up8]xGq0ÝD"tok9`G"pe;o`Mnf2ngׅBA֬YMGuYf5PRQ`'_.3}v+v%aޭ2--OlbsrI!h}qˇ̼>{GV>_*.{<_}ח]>}0uuu,] 41MKQWWG8>$t M'g^޶A͔2lN۫'0HOpH?}_z ׿%$@ MX`!8<& = R]= 8|T y|"H3dŗ̡}^ B,:6m@II {p͂O^e?G#֖cvo>R@q16z= ѱj*_SC&v1h m tꔴO6@A{{{SK(x8-}ٶ}! Ax<JYYYjeԨR@(z^]W_Y8| ZZ>^c=$˙go6pHN|a0R tdƞ5hԉ4x y ^$@x^ F;*".q1)D\L b S@".q1)D\L b S@".q1)D\L b S.'Ez8u;\'"f[ F#cQ ?ÃO!Vq 9 d`KNbw2^gj"2h=N,: 3? ep"28$Vɳ -P]aa@`+x38xIA8esV wyN@d&O Cr} @ uV`{Rl!V܉7z&"CS;YTOEdhJ]F@IENDB`gtkada-24.0.0/docs/gtkada_rm/gtk-combo_box_entry.png000066400000000000000000000054401446021174000223740ustar00rootroot00000000000000PNG  IHDR[L[sBIT|d IDATxyp&%H $@(*HQ! ԪEF URS{xMVQk)TE"(b=阄@(G Aɝ=MBf|_39|?{}y@!B!ft7=c!qi@EMb Ӧ5B  `]~B\ӯ9h#!D^fǯbыT@^VZ߷O 8%Ѿ]o%@;h_d@^-{_xP$@[h U $01 !LL@$01 !LL@$01 !LL@$01Üat:x$wPUkDQQQJPFW_Pu4n;]&*Jtt4I$%'-p88q{>Y?CbPT9O!s/vTWS\q/sNeYD~ruQUEdf͔PYy)~{.ߟ:ÎjnUUEhz EU  !-4o|Bhl`t4;0 YW{ob+:u ްm5#Y]ZQÆMvv6SL㾼m}deejީp^W|{C ̘#ou |5X2-\e ["/g׮M2utsi߮ѓسgSwۏ>s~yO[=@Oӂ PVZڥFg;o܈̻صc> Q+/bsh\2nڊ5d7ٗssԸr Ƴ\\2Vܱ`O?_z%:;⪭FRd>x ˏ-`t~(|/XKg"b 3Ƭj>o幥Kh8]ϯϫKriέ߈mi&7bgB:/EvanPR\jZYi e%?Cov' * V9s[>8x8Q?߄͢pÁ_+fNᝓ|pk<+n _'A?G9)#oET>~^`0JrBV*#mAn*kۋR^hEpX&[F#̉ 18@FP=(mC/*r]MʆU2׊mٱ(+些>&SÀO&F]ǿiNb#wTV!m1[GbU-g~pۛH9^9e&"'joyfMcx!2nǹz60f]L=I@yIJFdd$ J44ܳOrՃ$%'kvv2u6tbx[DvlC)^OmMm. $P5v~1G˾~N{Gqw CEܳ H" 1X,r"P6l@` ȉaV<+fس=""#IH@u~Xv{P؏P->Į 8UY)! zL( `N464u݌،q={t8zχ! ) :L[!LL@$01 !LL@$01 !LL@$01 !LL@$01 !LL@$01 !LL@V]@,"x5vmNosn:@ `DQ!4oi 2;=9ѯ"Ma\z6@-@C/p]@D;/0hF/~Q;߁+(hG~À^K$` aηAKv`;5Z  ѹ&ﱯ腯"at6?܀G ^ܾ[WLB_sy :z,0&# .LIENDB`gtkada-24.0.0/docs/gtkada_rm/gtk-dialog.png000066400000000000000000000140151446021174000204410ustar00rootroot00000000000000PNG  IHDR\bKGDC pHYs  tIME(%nIDATxyXTe߀aDT,0-R2\ 3Ps m725E1}$ 7LKwL߲ &RsCuOQa;2 k99r9ΝSArãIsUq-1x{ylRs"c&-R BtNT@RY)*+< WH!yNT ѣO<_}r"`:Eiի"wSw[K*;M6$O?-R aC^J*R+'iiiܺuˬǬY&GEw)P=,8J֭[Wt:nݺY@͚5)<*b ԭ[הh#K)Qr;f=nFHHH^zGE)E)sg8vyQ]\r%.\ёLڶmK݋Ms)֭[+bPmh؊K^ʀKFa޽4nܘƍݻwҒH$H)R hӦ 7f8Vtt4 JjٷoCӵkW:uT.RjZ=ʘ1c(Aff&x{{LeNٰaC|||8x ...8::Ʉ P^ ޾};:~ooG3gjܼykkk<==yW 99} 6dtss3WWW:vȑ# ߣ" _O?TcuС\G!&&ׯ3s<;Zfԩtܙ8~mSNEV^* 8(4 D:t@ӦM"qqq.@Yp!k.PEQظq#aaaW7tvvCh"gffGʙ3g C׳|={ZjEhh(*oeìhas‚'r1prrbĉ@R%V_ 㯿ɉ,lll0K]FnAVVVoҤ ơd a޽̘13f_e~4h@\\\CRX~u___]FtttE!<<'''V\5/2ݺu#<<BBBDJeddƝ;wprrΝ;1e,--BҲeKIIIAO?ѤIb'%-A@C#?R;v,M6- D+W2zhjRe1FQÖ-[8uoF޽;VVV׭x,s5PaxQś233Y`qQg„ ,YxEaʔ).ׯ_g8::2|p^Jxx8ZiӦ\ ԩS/"((w}=q׎9- ===)ԫWHAXX:ub̘14hЀX6mTh4qttΝ;4W^h}Yz*)?>cǎaiiIPPjfڴiy+u[ZͨQV :(h4lذ1cƠVKU{ Ӣʟ? :`O^WTTd~W Mn:^~e"""5j ))@>^72>GΝ2eJo}hذ1]6mt.]2vm 6m۶1k,>3ju \Z5"ZZZұcGFiݺ5~~~&Es733`x뭷 |)))cxݻFC\\:8۷M~ZG||<#ak-P#FWY$jLªUhѢXmh\J… ߿?&L`ƍۗH;vsN,--U:t`ҥ4lذ 4=k, ޞ}2d DEExbO(x{{'~tNi<+<%bð(Ǖ+WѣG"7.\ٳt:222ptt[nTEΎ{ 4nܸ\ο[7x4i. \yN)tR} ,TOߣT?~ޓjHf 'rjx? 6(Tul`ge^{{'fsV6Fos4i߿_,_={/ UFG/899>c:EQHOOhC/Yf;Njj*u%ǍI,+6l p GRQF 1y?#zSL2zS sCBiՌիzu'7<-[[ו 6~s2ʠ( ƿqTwpgԨիW9p?JdjX/©_={tƆ?O/QQ뉏VZj;/ve8r"{;v4k֔k"d ( {-[i_A1r47ٷݻw`X~ÝukWQ1"hlORӘN/4MQ=C}L41e+X5k1!plh*wK$11KSn]nܸQe`\ GGGc1SARRe ۸ɸmOťf64ijt3ʱ1QQ`eeSȓjeZIJG`kkKjj*Ch|$sğլim-{acc͉?ur),--iΧy&MQ=zݙ?pqqիܿ]@ڵ yz=gq ֽ{pvv.sRTٓtdK|)w GD֖o,r{xۛ˗g.5 ;ZU+0\Ǝ~tpp %SQRRS,TfNfRIS\ySSS W4ܜ5¿@mzUkP,,hԨT*6dUr b)~-8':~;))\|y\tۺudddw}ڿ@~>}Qڵ9G;r܊'T*&MQۉ'Œ1M^xrQx:ujK,Klmm|!kD+=xl–۹y3~%fwL6Fm٥KΟKFFcM,t$ 49ĥfMmɶ;U!sg2wv6曨U <7Fivxf{ -V&)cF(zׅ|]4`hDvhΞ>Qᵾ}l$,[j5o踎$y=)) F 4p'ge7ΝJs޴y[攂P1[Je2!ovx'tΜ=ˡCֵ zgEQx_҈`pi8vt=v4y 7^/taiH) K,6ynkj)AASE~T*Njt"PQ,|qEڿr" = R R H)H)" eɷD*&!R '%Eyf&)AA** jokÃd)@"p YElx1Rf,/2;gG=` 2)e)r|@%a׬s" _!]5DlۜE OJ6-3DܲsD^)RfMY%;s#DJA0,!v'S\IENDB`gtkada-24.0.0/docs/gtkada_rm/gtk-expander.png000066400000000000000000000107501446021174000210120ustar00rootroot00000000000000PNG  IHDRZӳ8DbKGDC pHYs  tIME ; PuIDATxwxTպ=I#!PzMM "yJQ @^E%;B, *(5T=,!}̜ @!><5+뷿֞~ "PcL$ Z4e d/w |DfJMF &bQ')]L w^a3:vec UU-e# NE` -pU➽شi3իU'< #GY&P`]&"sΧАڴFpl޲o}ǂyAi(:iMBS*)@Q/]To1qc`tEQ_//pܿ)..חF;x ݢgΜeر\kгGw]ἴ],[CPXXw&2aC@@S"I`` 'O f={2Bš+kgdШQCZzooo.]Ď4ƎȻL剘ιx=z&zڷۛ~de,]V̽]ԫWQt:3Ijnբ"  DUUPM"Xb)cM$%%Ν;JLL 3;$63vVX&2,Tpѻ?jzώ!=6oB^=,7 3ׇɌOY|c^LY,^ϣQ"6J𱀢('atbbb:u*111|m#.XUU^ʾXœIZOOO~Jϩ^=} @2z3l[ĕxyyNAՖN.3m3g%(:ϏG k"|C-[8,4UU`-ϼѮ][BCB((,L~wj׮UͷQ֭ iMyi(( $F69!X&Wh( lќԝis]:4iO%ō]ְݏFP^=x=WFR_s@ < PkB 8gz/ i&AMA'NDp A'NDp A'"8ADpvJGn3?@,[qpu骶Y>7NБ#GIl{#++^O`6mLΝ٣~~~NѠQsj׮EZw/UU%!z@Ւ~GTwyExB+--ͩ:<== oCc4fL}=28\(CI*_``9jT+]oonڵ`p=w[QUUF#i̜5n?>=~-Z4 UgaL֭@P̟S!ۘ(hZ"#&2J͢K{ᩡ TWa37mfU0 }C.9̹>Sm`mr 'NA CLjauȪ2i6"wyٳlzET(gWzM@m%W )dժōr(˗ѫ7tz#zom㭷ǻ\'w⯪*;+ϣQ] NNN׬u[{<ԝi+Gs:7 u7׭[Wf͚WN,]hwfO}HIޛ6 "% FW$+:?uCÇT["r[zm9Mܴ4`ڻ@ٲyTDr?_Ѩ:,{Aˍ|F8AxX ؕyy]~nl_|Et^G!;RwML>Gx^5顎Wm+8EQiGJg/8t0RZvZl߾Czz\-;]u.w\nyh֑/=IpU͹CBwܝ999\xu$gsџ9sֲ`0+B" h[ISs& #[57 7ӛVdz4&y@,XˣIENDB`gtkada-24.0.0/docs/gtkada_rm/gtk-fixed.png000066400000000000000000000110011446021174000202710ustar00rootroot00000000000000PNG  IHDR bKGDC pHYs  tIME6;IDATxyTSg@ZE;uk]Z\VEq:ӱ.Ԫ.WU׺vD[R+;Z 9BB7!眜`M|O@p0\d7Nck2RH`T*n[DTRQ`܌W10V;K5aP7KXT "gF^d(l KFY-Fv_#B*jo lKŅ؅ LNfؔDD< "10AD "b`aCJEio KW/`Z,]]"cZH_jF H)kw&}vC F7)%f3O qzUUU)^;{\0vd~|mswkv,O_ĎuCu _n[ADx8֮Y !?tpo8{nQQjH)/ZڃڶEM^>DQQ1.y^6\J5k9YgZmKH???v5G&`4?BBB\>B_F-@XX`RbG;k>]] ?wA\\wؾ PQQ)fb]xt[ B`Nv?m`׶15VGbVLzlڼ GyHRZZqcǸ +Ql?p0?ք(J}eCV]XssfBׄBk< `GG~J$$B``G~}o{=n RJ8k:{9[n۶b۶oٲ ^\ 88sKO ߓAkѢvP*JT*\v'= 3kl++JU6g3|Yq䛁QXTǠV\P(雤°rkj/B &7s#_BR!44'˥MRaxՄCmVV=|30f ǃדAR`2].7 hѢETֶZnm CRLF8 hxz2(;or :zڷk 6cаX¨ޞ q䛁VGBNARJ=à<MRaضضYQRRRǑoFtNRҥ-IQ?d0MxMĄQMRaضhsha0¸N:r=D>q9eHlٺ RfN9 *.;&N̽bĨD $ /4_'{nvF }dFtLHq-fXjʋ5?mѣӰhe?/tqwIZ-== ᭑{8gOȻT++|UF!iX$%}QA9@<ZBvTU%ݶZr  ?Bvx/MN6f5)X|P ^+H$&ƾ}.OvarDLNѠ; :%㰰Ɡ/-T*ڏ0tpo8{nQQjkvEhX(QVV\ܺXxaϏJ&&9}ݖ-[`K>ORbs6Ggp5¢"@ll7K3d2Ja!vً+ذ=v$ݺu#<֭[A@@/G֑c؛1BCBrcкu+Kn@<1o]YaPsBR!44Wڢ5?g9W<~op}tx?ٌKqlڴ ^80뫯+s!00ni?X_mZaP`6P(<>vkܳP*8u* %00 WS'DðEJjuEÍUܭ'F!((FݛU{!PC{Rֲ]7!(DA̘9BC<ѯW!I?H)QQQHPp:z},cTZ7o*_>9R"+(RgρJ;w^ Bj5ѝ:AJK.{\{2^RuM&3X)%FZGcC}noRb7:thOBLz~ЩS8I{__d8\ rlٺ RfN;8rzz;yyjHM0PiXMmDᷛAYy96 h4O0X Iؔh_+B). k]4P]x[=&V^9B!3EBr:'nK~4]bqO4~(nyrbiE {#X= V( wH+ݴyݼ0P}(dQOPR;7~:W^ ZsnQAcRZ4_wm1%aTjlAcb2.~4Fw|(wm^u<,VND>Vt%h|=/C!ػ❷M%ckf`w*)ou9A `XZ+:NNF(jf(RlYB)ٝĢ9Xʷsr m_D2pTw)Cxxkeqr!>r7e[v59:VMiTU.iĘjlp-+o"J/oQ=&Nfw|B86YݧN ˈm ?ANl[Lȍ1y#K u30uh(z Ze-ʓkqh6_iZ*T3ZI>R@QzC~mG2Vɱd_Pcz&q(F'q[ Ržԋ26⓰\۰eQ19/h̍F 'aRtTHpUU1w\<ↅĘJãjm(_47b;*Zz4t}֎ǐ/mg5~2v;{drY.$fcÀ]  EIdqiN&dL ⑖5]Njɽ0wY-&U`0ITb!Ew3kZ\\z:F, FNQ5~ IP] =n\H={ I GM#_7KqMG Qsٺ!1]'5η]ϮttFcV/LzlBJb 1 i2fj=jHk>W_޺lʹ5VɈ>Km x7}2-[jTY+oiZxo;$ _ox5Yl<|ړ!W5c[w1oe]<:\ K4ՅU{Mj\3=P۾ mkLun˄p@:TUE[WN1IO.ҷP/qz &?ڏ~ddhŨkP9q0%ćKW3ؚ概usnj$\9s4 hC6}OȈ)4 ZllgΒXhʡ2T@Η,ے( k7a2B;=wiy)PVn `~]YhK6[n ɍ26h4dfeb6y44:VJe_=<(,!4-򌁎GǼ5̙;Jx(g3x<&A؇iط+l]lS4bk0Ym9w󖱾a-6ƃGeUW"OdNMUp(^Zj4(*OEjSw% mxպΫӖ^ 5o2js_\*6 UEk*JO -Y j𱵰|:\`% j뎘@ib߷bC'-dQ2%-^\%ߒk&oJk`6ech5u:TTTEW%*VՕN_u) hРѨn04U14si4yZh) t҅,!j'krŸ(Pת7rsх=j5*VՀNbVץW֏OQT|婨Xүs1L>>&ކxklFUh%IQ4W@"Y#Fijv;X5kʭ[6GojX|C/?Ҕ8\BUռ%(&NCӡ,:*Vd?&$V+T,%]!Z2T/n>+cHV& V_Bb9j_#UTxUvEMĢ())1'͛д\ƅSdk+Ij:+#jr< pTZ_B d|x}F?fYP%+7r˷y|_?S2\4܎)Iu=Kr\\u(ZZ+:܍|T'-ѩ463H7s$}.']V{{Z@Yr}%. f6ՠij5hn%%%~5ؿw?fo"N)إ zW7rQa\gbn|R.eޒ(\,k㽻V17.z\Bݳ+Nm (ٜ;l=m7 o«|L-"$PQϻ[\|pa۫MW*I-K.6t<ёغOBzbbOvO4oϲjm=avDIS|@?b/# KwB!F.&]F=.լ;Z[ĢȽ}-뉧%Z_W[EVTPbE*zVBA!+;t=[`vYq qb8|6 AV(d#=.諩0P3.Z>OÆr 9Cɥ縖Q?OPL$] UZxh\HLBUOM{a̷/7[y\4VR\b|:fUwukV.uW9WoO[K F*VNpPjgƓ!"q s:hI2iUH3lIe VF-snOtwd"J\YG:!=đh$@fNDXy#,V]7ҁT %gI8Ā|D˿֙gϝՂlc!D W,!|Ћ ($]8gq?F,ʗ +Ŀq[*U(1rJ:' g,V,S:: ;:Ŷb~HW$#>ս8f kƆ~2]DHظ'bKM0de<*$%$!R[tIQ#u/,cOddAKde|C{xJBB!' M1ĊRd@n왐7B!n_c֗"_-_ &)1 $B_.^dKWQB!d! H@B!d! H@B!d! H@B!d! H@B!d! H@B!d! H@B!d! H@B!d! H@B!d! H@B!d! {@6NjySYֿUnj<7ROcʨB8ΡE BXtjߖaScQrW{@8;5Thş;*2+ )הiB8%8g QLʿNz)-)~3~搀\Ֆ̑ٝ63j]fR.L~ :;PZI̵;ˑJ]?{Y3G_2ֿ#a؎] zXMbQ54hݙz; OƵtD=ot]'{ihGӧ`MJ&>室:%3|y䯼)'9o'g}_N-j3=uy\5۫5zL<?+yI J3݌ߙlW޵&-1z>9m0{~P?oFQSڪJaZCd ,kUT3Pū6]Fҵo$b#Dνy&f} jMg{WݾӿCtFlⱍ0*^4N!i\>xӄǐ[P$<y(=OԐWɬPQ@kw_˚"\'>!)1+T2e8_GWE;Fs!ץ؋s@*${V-dU]_fPz?(}y.5EeYza[[v˞({}y.5K-S B!WB' Y!pB' Y!pB'P?{ZK!n[>x~C||?jVL˖xu^2LX,扁ʓVEo0zrȭ3#v+-_|۷54:utX-VcU!=-׮cv\FjԬy?ھE\5o`QLμ3xv >YQA[}bPs>J,4m#okdQ󼶘l߶^|-o_jPF V &L\dž+T@eьQ,9і{p$_z l|qveU?f_@bV5Z;m#3 T&L [_R&߲ʬYo!ĥػ4-ZK6p<zci<wUU9|1Cݺ]dG ֯_C>a&\hKzZtBPmaQrHU*&$6!Cx<9(߾#Xp-Quiuw(ŽDQ?;v0q/_Iywh/Uf߿KPqUӕ2أ oQUCD`.^U%Nݿ63ecxs l8-/wy i74v[K;)JPK].-5QqY\9Nggi5VǷ{T~ɡ +ي|?~<Mxs,֮YÑ#G2"SKK *=o:auսɹWh#&vSѾ_S:kpXW{zmy@SZjr]۷ѹ>c1g#haZW{TfTYOYw+#--07hH6….J|i)gu6l^-%~LȺcupNBOݨ<x3{{xqk<4fKȨXQ}ފ;u3b3gS@GCooh:Q&Ch@A o c_c[~ ] ,,YfQR%TUۋ~X¶mʤ2_jd$%*t۫_d݌Vtq*уW#}٢zr\ɌLJ } bQܼnI2MQƪUA~jiAf3F>(~k\b&N4πly%s\S" +7AC~ P_oʗG}'OIE:+{rG|"opԧOg"<< n2P13xBy5/&Un<nUNk#G IgQU2#SAUot5ߏBe3אIwtqBI| Y-Ƣywv.8EzB4?kI$I|(I+ɖ E53'& d*+.8l:Syo..֌C XL##TG)DrWgN/R '\楯nMK]|>s5o`QLμ3xv >9w`MYch('&ӼB ܤ)Zco( )18Q@.,ad 0PY4cKea%W[3~]YUOYPmUM5Zw&- G&#.g{=&).h3y:LLjktz1_YcviQ(opa{|=+2/ZL~e209Aqڀ|әݓ?`~xsf`l4ebA̱t  {z:t{D8uyg8aICVylGP̈́5nB 'q@ʉ|vh^z ԓX2 (\>sӐxhv1ʜ7*19EQ!i& x<ܬl'jb$̗ 0Idl8_ƻ+.\NX>Z-+ӲCޑ BWX4Z a#Q}ϯ\̎J`t:TEAUUTTkر};.F#5j,Ӻ*,(팅x%kQkyB",5k֬E4hVjjbXdggIff&jUR'05kV9Bndc!V.x`Ln5{a1u\s,+~%U\M6.Yօ؋J7>kxo*...tlNd!ȅ ͦb͊aΤYaaaXooo%t.}e-a|.ѷ{/ҡ k ް郢(Gunkk:P6tUҢg6GyUU!D0Տ٢.*9SdOiӒgWD!q| !(Y K36K`;r ȅ<6^*fbɱ,d܃#jS,:z/!bkfW2=&).h3y:LLjt:MEHIiSS.zGB?]͢ t~(;m@>xExx:{~oάT3hֲ!K^f"sCO Ly1tfjď S\͑*1--et8eXZql8@hh(W/vQ l')g3`@f'Տ$C 6j`Yl}.p6 :nzYJ{5!Xt-‡S{MWxttu-}0YKw3ͯFu=шN rsU8M@6x`z5Cg…yث5h;h.K'&-4%OGWT~!ZXch('&Ӽ)oh%>=v8p!rvYݾ q7cviQ(oPz xzzT-C>IFJٹ~!pr~FM ޷3c{ې[!,4T )z:oQn\Q|"=f-S!4Uc9yoTcrOebA̱t <!͜" +Ҽqи_ xÿx>;];俴cͺPJU{DN. a5yk`O~^@g牪2Qg]BwU6OG HNGw+ڟcݾ2~ᭈY|%tz\Zk9Pa!DIZQ:`3e8>QWl&A={z]s 3Kď dT wB,]X=c]˰70Pj8ś.k! H@BP<߳ \ }Ӽ%n!:c*W$ !pAfҲ0n+kׯa\p(Ra,¡>^5u+H[VFɘpWjX>dPBfԑ\(-p2^WjV)տIJ6F{1mƒ^UY,h(8'z 3CUTl(TPņؔ*s2>[4]G̡g0""zڹ#^k WhmCUP!DzЋ7}лۧe[I˲e%5BJ 3KR4i;Qٚy~7,_ut[IqtՄB8@pRTk_gR*]֪-ɻoFΤese0{L${S\f&Pt>9,1%Dz0ڒqYO=kt+@}p&-3s&,2 u!(oW.6e!$ăӿߝt펋jݴiYQN mxd[chס#©eĚyJ&؎ k܄N⚳m̋ɟK0?9F^Ol9?Ƹgx[˄x8BΦME{t2+@Ne |Zpp9[=NwoFe3c73ݘ&vNR|ɀ0`͞_wp<uѹԦzn:t7.cNN !$$vm3~)nł|z%`b¿Vݼ]bfqHNBFU*&$6!Cx<9(BgHGCD-֠,T =-4ݍMC{B8 G 6mʙ9;vrbY[fagӭ2gWٺLw/})ZvNSZU+wʇT~ɡ +ʍ`߻.ĒrvY (gx. 3MJCxOO*We0ch7oELΝѺf !)!b4OJ 7jx3{{xqk<2|PB \Ǭ%x4$Ƽ8j 2}0`Lv{ɲQ[:9A3yg8aIS8\^_1 k) Y(-Ƞ;UX[<ʝVn_0fs83qWY0x`.+ eNXZGZƘ+NtFV}qLc`|<] y8jwijiƭ!?-`,ĭp,Uz<QQ (4,BþB,JQ8Sd)! !nbbϱn_V,RX]:VZK].-O_g>GT\VEk4ZPyjG.G^f',$ b,u+b]"I Y%!!!LY>:zU;ɭFsf*()~^oW\ }#5}Ukfs>FNԷAD+yG.Ln5{a1u_8~(*f+b8E B%s1T1k {s V |+oۋ7[S] 3TgžyJ5o:!DaB~:q@MJ搀<##v+-)z3ecNJM]e][R!Ľ-r ڌmvsH@V$ !q;v˺Bfԑ\%]%.k! 5Wo'UEoБt5L !n85dޕm<4IVFKFHk>;ݹ{G9E@Yx!ADǦqJG'oR]ɌLJ } bQUܼ*bL*ܜ]/PJ1|? ΅N )wvgӦWuG̜f=9vH6~8;RbLXU*Z Z *3EjUxt}[ 'cSz,; Q_g^$]֎᐀l.ҳ8t*Cv1c[p4&m]<xvDK,k;,+*U!-=wNJ4WAɼj]!)+ dZGDh]]OU FOq(J*ըeРG)CQj/JPMj_ʞD]Lё Q+}BqגQ֎99sCX:-W`&K3/eThm۪ jN)Y<ҽ6ؾY!ntY;Sd=αgW3xۤ| yrԍ?y'QMB4Y!Ľg+nV6OW=6UEUl*A[ӝ%"I@BQnk>ݩ{Bhwz.4{9NWv֪t,$ !(7_<_h qKl>s%yЫl$]wu.Գ^䝵iy- s--qWYfHvN BܭE*M7M[7wj 4<[5ˤ^5o[ebi<9 ͏?=d!nQZ5F 7@!7©BZ~ktwk{EUAqU.o+ M{cI* 9/MYIRPU7o_Ӥ%vӶi! !(7PWalg/~9mYٜ& Y2mBn ;=vg;^>[ãw.g[]W|$1b"=4+Sdk M pӣ*7yg0A%GWO!D)9o⾜:V䓅'RdYbV5y];mY1MqA@drg4 泃Gky`6?+6&dz͎*r;Kڟ| RRh7~>S0ٕU|{gьQ,9і{p$_z MB!JR8 \g_:#=6X!fIyWo~MF~]rنGнE[Z=։v:="^Fǩj?M{$϶Liaa,01C S.\.k^j'b6˲Fo lX:}P tE%ޜYg#x."$9+ًyv  >mrzϜɤUy^#W10r>&L M7g/' GcUfx^Zvu>%|4^cC=-ߚ_yvrf?y4=~$#E#Y!Jt.KU iPRmB"j1Z?Γs)}\d{T?4@d}-&3e2ceL?f9"чcX]}ٕ/E0ZtBPO.dCs z Βs!#&hă_r(Jx.Y X<15*Pw|TPv+:ڄe{|w˥e{f#*. 8paPӧ+Rlb,u+b]%!r/qrV$9Zm?2"FĎ bnx^0Lké1hLۭݎEdj뚄%Gj2;VT`fQtoC:nӀtq7pHwBMZs NzXۍ;K{Σ?kz`.r-a%kܴo_yVqB!'xN;7u ®g+<+LtY !ʊS B!wBo.k!DY, ]B"]B!ʔ{T%t%c;O{}|d!9}:<߬@Z9lPe6nބ|u-A5,B8ǫ&ni[d֌+$)7`,¡uŮ{OW54cʟd!N_7p|y1չ& Y2]ˆEh玌zKN|?-f6l)fNݎR aR/=fW: !Mv~Y=l5rlۖri =ⴝ!lEq~Dfcrcaр:͛ѰqcuG> MAѶb"3Yh mֆG>e=0{G}&u*,jݯ]>X)J6gȾCceTlMk1_{sd;C↼r:=p5fkͮUH>@;$G9jQyVyMWcZ3Qe؉|W&y= M"r\6t -!"FޝxcZI:Yx gg`<`.RLr'uF{zKZ3?&f۝( 1Wy{wb*w4{&/`GxQhrտSkviڣ BjIup?(ѣyڶ.mw5#q7aÌ?O ^VӦ@o+>nB;!Zv.C_IZv*INѯn7ZO}yqwoZ|-_{St?ǟ_dt҅r.Q/mOj`H^UX"jd&ۯ;VB!9t&uN-P=8m) ,{4>\S#1l+A<}[fЀpB!ĭ1F v.C_IZv*INѯn7+5oVʲJܱe3۫H6֜߷nf)4\=$E!e}~Hu@]K;صAu)޹!G{zЮ7uMlgQ| /YZvwgyBq3 Bm0IӧE T+N[ %=Ȣ'oiױ<*>ħ>.<:Я w'@pr, xAJƿCB!re@çuxK{W _^r[%u]B!D0DBq@B! @Y!0 d!$B@B3f|=-yZ6z[ q#-;Ԡv-Y6hݼ5|I;}Ϟsu5Sw[X/зtUy3D I=bWBjz[r֝>@&zy,_4-_tvG|-r߿(H'x3͋?6*R7-,[vϭ@&iijkL;+C&bA|*'Ĺ(< S_pGϭ@Ba8Ns?bOSyE}ވh+]]|cA]/LVmԩ#[4e8_?ě4#;֧Uo)N[>7(&zt.oEZH~dլ\Ri8{Ck:oᴝCl|}\t)˼֬Y qΞ9f2nu!@_ERv]_{unz;w; Ċ[QY2 K<6n:wjvޝ:_QC6?28ӯc.<"q/Xn;ux_ÃbӦ..2<=1v=$)1 [)ZlIG7(Zl `WVoDiɞG2bMoNzŧs]iތӮSDnjuiw>;B`* qҶ̬1E/t{ٳyzhAX?SLvuՄeU޿vpYBB S\n{@6E丬|lq{ۿާh!D;x:Du@,V zIϞ=Yii< ߬^*sfϦQF̙3 0mTT0o+!n(TV`>LhT^h4w-dt;!د$-;eWOTJ7C+eY%8&/UX42{,5lHn]  !n(TRB)Zwh_vO 4|حHѢ4lԈ+:(DUU *Dƍ(R-O' m};ue`KNB]ֹ)ޥ1?[/ȎxFVckp*yū:?fXh,!]{q<:! C7 +ΤҲmg- xT+%;] Hc跣c C?>#'*RBY!DEC N~o<.FGxBS'p|f}m bӧL T(ˢ.`MB(@B!3.!^!,BBaB!H ! ,BeKMni *f777WWpQ '%%qavHN+!e2 ^T!63O-iמ"Es.8NN8)L%l.Sfۉ؉ZBJZ_ΐϹ< iiΝ%88w-BdQTiΞ=cZtBL&a1I* ! ,BBaB!H ! ,BBaB!H !p^]c~JTi-q[%VM{ǶoN%k^8Gl@bh6rGˏIb2KRJ-=[ι]k4YRaaTR.}p՟nXxjm̃=Gg3OIn˲=#4]2aaP=7}!GٶbJcNb\<iZ6JM_#s,syw#{NzOXH禱ME̦yƦ[`{^ۥ9b +Ǘ# _R 8> b?)n5ee0`KT(-.]?;?L/m$2}֟N"ĜBϦ5klͩ\xȕsG9+J7߀yHu ɼs韥t:frwyW硔؟p:D ȫ3\s,RLi&tFFՠVk֒/_[ZT?FxD<3{COm_fˇCpW;oK.ۅ~O>ϓKqђ3d)_u{:fV.t#Ʋxd'2|huעw/m*=Ⱥ哳|B= epj%/|V$֥sor 1箹?oۆ J햌.[}xq@jT,CRlЊ'RѹY-Jv.\?v]^,a+Тˣ,52cX#kXb4yag}gҩi~4Ƭ55wp 4lXIאaVfY~.]:2%K0轍~Oxv:ceM]2lV y*K_[ nL>U1=Y{ s\%e tfb} J!NI;t1#1`c[iM ҹ3  v,~Sb@֝,~ QگtUoNȪɋWgmZ61uK:*A6ܳ/]U;bXx6*q=i0e+cŌ0Nc_R|1#k#O&PmB2ԚA\݁l4 ]=/pぬkz5Sק-Y֛޿xcuV"i)t~5[Q}>V@'1Lňl_G ӵgx1fe(sr&k\w#)_>k;p^W:9ۑuӭ{e-Đ|xږ ȫmǘv 5# 5%udխ8W]l8Rat_sS84~ٖedg >JOS8\.ǧma(iȊ%{pZ*n6?7<@P^8ܧ|Lw@Ow*A/(d9^fe OMR^Ge]1b1w`?!'vrPցY֧ V9{8qfjĪQ< moVfn9?ݾgo ! dT|FʱL2o[0`!?CKr)D;rT.G^<;C*d3;7s4 :Q:ԛ(۵_tߑُ,: `T(1`kT2s\DA5{]^?. jD&;h`4(myXfҾ 7IOzt0xr2~l>zNDHT(~cu|vm'.oiK!~=˷GfJn1д] 8SFٞ !XH̑Y f~& O@-6#nn`<µ|gFӯ}&*VKJ\Bb,7^ I`XU ׻?n~G1?~1Kw?WcfErFvodng̟(IDATÏ2U1q<04u|`_osbn>ATрRY_ޮl?(fxk#r_|6z_=z?5_cŬX83ѱ/Sƽ^fokQqħTLug؂ `֋p.!,9}.w:dp{sq1:*wǬf+^<Ϸpn攚of |3vOlE/L;>j' ʏK{t|Is4bc|ۧO5 Mb27L n#y/iݸ6=tzKfN⢥_wb9Rۯ8~eaE~sJv7!BtYŊf= 1X Q>[018,-a՚1saQܞ^dU'#2eF I ϿƩ|" \] !kOB!=NY!0 d!$B@B! @Y!0 d!$BpI L&=O!_N)s; m8 因* 4]dpwu$ytɟA /druvG-L&J ;e#.!n-ӤV9ܬ_JIXw(R.yFs:k.Z>КR]];bl ,f~پP<^n8uqII _0`[WO@OfIAQXX4f |E  0{yQWFrQ"9}"r'i Hu*Q2Z73iN'ER!wKjRP f٢b2ϳ%'D熒t-hS~۝~O-ry@Z7]CԱ;tRlvTEq̋s$ԩy8EPPTPUPM`2+WXMo1+:a{ߘ|ɩJzj:84pjx=ov2 d!i=ay$mxM_uu>؈GVq{¶maÈ>/] KSy/s)_ P^{(JN1zZ~[QN aSmT /,~R5^|L.6lJ6ZW#x| אf/ك'8OlIkq cVuR3`~wjXyݿ\-EOJ|=ڱBgA[hE#аqcjRi=?|A7TD1rZ*)FqCg)»+0Z--MHfzu-'!९i3 ۽uuw=#05yAp|?NW@B? -) ]#c?`*UIo|V$쇦藧|<-Dm #Fdl?>ĥm3n Iaw3`G;jysdөҿDa_Ju~[= 1ٮ,%96cbbR, Mq`ٌ'wyMkRJ sl3f& ,&*n=PM~oQl1=ñǚe?F>3~v~fz31M9qqRQnTGquDgzK-sN ?)-PzX8csrr{(grb6bMVhժ|9++uUY}:7ÎcEUQԴt: 6˩84SGGGlRI;p7_iɫJvPL-a'}^_#A]BB9Î h?^N=mt(*3X=sbm vnq#!6R3W!_T[}2dʵoCn;({F:+ݖݖʗ@aeNB~aD,{؉۳KΛ<7*f4Ա95N$6сY([-jk]AM{ҹxJaO?9Wm5ĊO}~ ߥQvs FZB<@k&QvӡZ̥+8qޏtEh%;:XOd6/YL_NMCL ~ob2a7󷯢cE:o-EH\AG]ǢV}{Pq mAÙa7oG%*B|͟wkFLrբb`vDꡘM`V,M fL*$88z_w73TTG+~\Û/^MPgb+|_X@ BY.$o["x- y(RI=Ѣ΃=ǹ ` (vMQHO".>B͛eۿٳ"o~7U==4_yXX Wm7U'·Toq362홶hbhX/M&> [J4Z"[,>J&d[[ׄ#dYٿ`"|֧IS|ܱxLtwR@Es"P`zqy,u߱?*k`{!Imc?֪+<|5Vr-\W',sr`e)7zf̠l?⌏EQ@Suy|. pLUx>t?㛥z~YgfX/|v[*:zךEQPU5*g/亟8@B乛Գrv:~^AJg|UGՄfqhMfMJJ}4 ÁtЭAIB}|6+YUI:ɤb20̘i!,勛7nb]ž`2`l( 8s1?(.Ő|0E;X|0p88vvG*dhNJ\t MPUɄlb`1-XZԇ[%,{BJJFDhgDZ43Hr&kzxpMjT'TsDrrJӇ q#nhn!hN'jBQ@523gJ>n"JݝbEL*nnn\=(c>qsH%14Gx"ߏ  ",,…CZLg YQV+7-Zөt8pjN6LTdxjFW]Bw , ŋxl6IJJ"%%Tl(nn㍧'V55MPi^jb:Q"꠮, +wB83\/ JYTU%11AFކGQeԭ;~M I !(EppsNJ"00(PV@:O E vw=jP@Bd}㗟[>!!i} t]'2 BBaB!H ! ,BBaB!H ! ,BBaB!H ! ,BBaB!H ! ,BBaB!H !`mS' B!Laʲ<@{BqHR[dOЕV^7oB!@'- >)Z]im'-SHV3-Oͯ !w,M"-ZB֮eșXB!r Id¾@N%{۸΀0!Biz9OS̩d[ ;I י30cBA\6]B0vp%u^S6!,B(G)(\9s/ V!7yՔ9מXjB!rwF Zy9~B!];s]}=׋d8IENDB`gtkada-24.0.0/docs/gtkada_rm/gtk-frame.png000066400000000000000000000040611446021174000202740ustar00rootroot00000000000000PNG  IHDR!sBIT|dIDATx[\ol6Ilҍ4q&Rڄ*hEנ-QA[T'/T(XjUӖhͥJ3;sƇn64n037gΞ$I$Idƹ>p.K*c qH[$ZʵJ+e:6FI6w.@_-#Ο7x9?԰1$M 3|})0@4uͤ:%]_eiQvO`2ԕ/Qvγ ijhïҔU;mjd 4uuRpJ 3R`@ Os/xтo,!Dkfoo}xHBfѶsw>_} [ /oy}?;3Z_~w/*滛yg(Ml%h.`d9ܿjPn%WMۓ-iڳ=^XFp/2P,bБ:Mwqs%YJ#ϒ"o8<i\M ^۷|`M&h#`kޖɴ 4J#a~ƣ\>'vY ǞOg{W8Ub0\p=k6}S6:2-}|O_ڛ&P:8_`ڴifls5-{7 ):}/d>z=y?-/ow]pm斏gv$?σ=H(I{z_P( 칚9\G6A[[[3Z \.S,-RDTjJj (f 3R`@ H)0 f 4uUXF>TmKj@(֖Rʌ@7S;5i-~.]N3ov!IVrIBuvOS @ꀗ/xIA߸P-_% i* o0^T=Sq;G; 38ʵ;ԇ}mi+5,7_Nu<@ʣ 43J]?mdm&?iRu2V:e˒&#F xZ *IENDB`gtkada-24.0.0/docs/gtkada_rm/gtk-gamma.png000066400000000000000000000411701446021174000202660ustar00rootroot00000000000000PNG  IHDR6vBqbKGDC pHYs  tIME63"9P IDATx}y$EYצ齛fYdQFqaq}SDܘ(D\y\feieiznzw-xDfݪ'2A˽Uq|; @huiL 7dB0 H{Qڟku՝?^w ՞Kw=IPk1ztEuI/z nQ!u\vEYiÖt4k_ $=@ӂ}^}{I2씇`Zk-r"h8*CQmIw34m3lTlrF(=iN0 2/?2S[3aհ5\{5&1i cpNE>cpP֜qdsy (FJdi0D !ω# Csp֘D@5! {' !]#Jk#";]Bsrq-`^䝕ZP8?{<ExnV=9R5&`p\?t?>K>` p8p5&!Js9O*nOdLkt?q ˇ 8hoXTT*LF0 Ex#@Cxf pgƸPabr Y(vb۞|'8[7+}-d"[Ӻ_fue \cߧ˸l I~&~q0jDVIdctIj Bѱf,2,Us\TD6 T*<7 G8dyWƟ]'ϝϣ6]LNN{|?v{ܱh߽p.2ſiF4&,:ãz]eLcBo% i1S9s:@%}ͫs;L5=$#FgU^n# #c`##`NJq9] !P,\ z52 eL?^{t>6׿^~6> (*xIK!4BFN@)F/46HU%5Vj(Ɵ⁘BW[b%Q6 0={U@{?b Cba8>pܱ'@:HcGR>eG^A叫7Ƙ Awﭽ*Z0fb1~Xx{0AP5f]nr)@{U;n1%MhdbSdU]iC5)ƄuB- q؄Q<`ؙ$o :6C%8!\<Q䬊4[k@ԂgC2$-"J4&sfc<(;]35A)YKP2RMYMY<];yT}һ$%B ["a@?,y)`SS@qd@mU^i,S=J'`0q ;Ӂ#)wڛEbl&dnZ2N CMUC ;)<.3y&o&_t^kye{ifD5:X;",GپÀT "<$!خ(]5F#`ңd.S5LPa!^laq<hoC>1l*.BS&a5 d6q}31 MtnȡBZJƏ 7BEsW$onhQC@BL}CC`Œ4F}}8M(A{ T Q]n5J~1)I'#`4` ! :$ߪy}xl*,bM4&2 Tׅ9:,O}6 ѱ~ Q)$f⒔UBfyxc9tFR&R`wtw!7$G8l={.;hvY?' zz3?s5B0ަb9cxf|疯"΀<8#p|&y`U1u SSmJ Q=JF*S.T˦d~U)S`tj<8J@y1g2݃#_4XFGQY`lz<-?@"z1$L%xMIӎO^{]uo˱Ƀf3lngh/S*EM$؂pµ|_= U}V%)0a3D6Ԏ|B8J|QGH!qt:4`C ٳJ?z{%6Nf' L^2&@58Gۻ H /ۼ^w+p pZWje 's[a !0 WbjrNdrL&݃Zm+M1FbRePM;UMTF0Bmѕ:jѽ)aS@xcҐ4~WHrfK>gHu`kIBk. lV,ؖg@z&DU1*`XJ-ܹc+R4am1P.Mb%X~]VvB:S"R\nJ5f2T"dT%1kS&%*k&#Z* <!}J$QU`tdq S`STl$,b|jPCڛdTΦєʀJ a%:0W^}Aහ&k{5& u9'lB p \1< C8;!J?)DOO 7 Ѓ2ء5 ѨPi>%*ۿ/;(4Ij' c TKȣBa RK[J˒Ba A-6*0_͎ 0~hEpS@xXFF!J૟p]`x_,4fT?% fqj ) N:|߇U("UpëvbٵB@:F_ĽKL' EkL"5aH3̪،IG@!RnſM`BG҉AkԲWݻLBQ[$l]{\8 R ]߂@S|iǤj:c+ M? !\JJ\4NS|T{Ľ1(FQwg̜Jq5q+8;OMSWrlb dxwm+O7mYo7(U!VmM(6%s7eM p͚%U6UFoev^jlx~;fSUMkFmġe1֚Km&*y%TM6ӽv2*uze "Usڤ";tؾ=.-T^Ȩ 0Uqqz<ol3`1ReMFM1 TL&1*s[֛oD&gB T*%ݏtM_LFX홊 &'$g4DQHYd @c+(&J𢨙uAil4c<3fmo[C8&aJ0cjEW5E`՗O}bT6 O*G9)iw*G ɕוot|P!&+Tvo]{$yR?VH;^&Q@jaٴaI^j멼A[qQl(&Oձsuvudѿ{dRt- iJS&/M`MU]TR@3vq>bȤ!oH]z05 $H<Uk @kf(ύB1i}3PM{:'V&ugSV{}8/~~*Zb 7c35SDo2DoQq5j@IL,X+XCǨ8 `O<;(E`nf15HKzoP< [2S 7/4_<렑fp9ܥjQxӔJTZ8 C bq[/C>6J%~͖eo6 M(;SR=f3P6 O>G푙HGp' ʣ[F!fDж$ŠR JX۪'h& FUӯPr9u΅j,)ϹT*cjj*~֞!kVc؊łTyoH{Q<=T4b+=X0`rRvM -?$P0>_pS83OK,cR b JX$y(@)fin3@62%gP^7eDUY|$p]tLΎ x\=݃l1Ż&Lg*[ȠQ씏gNgR'/ÿZ l6in+2f3@)Yc*x|TJ3xAԞuTa=fLzIy4&o qԭ3Ɛ{~;s۵)oV 11::r% fCa7Z}J? 12qolN[H#w>FV 9::Ri(VRI8pzQ;'q b7IwئyCPxi:]89FO8O|a y|/AuDGTjɥ3t$gnpR"ne0W"с́z{!dD?_#ƙΆ$cN|ba_{1 OɨEQSZKuJB`0~y̿ymy c:;ViF.ڍ;"m1̹Ć'dho7]] l~ uQ9GU) ^C=PRȒR5JL5 R&)T)UӍRBn`WDŽGkNBCJ#Q6^ny)5y 8S({>~ _r1\S˗'q 15-cAMg i) V5 n W\6 *'`(20·̖g]WhdAn63J* @3QAۆ**|ΤqG鸑T6 uDi%F:INǒ0g2x0GǺ8wvB8u8g9x;% [߀ 3'*7M@NsGSS`cWd ]'vT6Gyx/3kH R)@V 0 4Qt7ƉcLĩlt%CdTsSC`.LDn\#47U7i%͉f*}|ka.A_ @v T֯b_W~Sd,m"eu!yGx[Zlq;O16`H)ۦ"5uâl:Uخ#5S1QyW .vdٽ1l(pk3ìjgp_& Exٲʕd`|hSguϳPFFhv<UBLGo L^Mɔm[?n[:G n4L\ٶۜDhT*#za=6SGtzNyBR }+Ce?>.w\YC07H6ZbESHi&kG5J읍 ѤƤqxJpRǔ Qm:6h,68S21naOAXwQuShk %;Bu hO\ϘlJ20dں}ؘ 3ぎH"FaTaTޞ~=`vQ}GPiն7#{>^ %_Pu&I[Rִ)lU57ab֍H@0Kaڵ䁍b,%TF8QD'`w/qTݳGJM@L^[m#da2n*lƤgt P̞u2%`lUc(.YDeΫQ)`lBW 05n0#!Ĺ$Ο'e׮ <:&3^-g.\ dI éHᮙvrk+,oKQvt2WZtF}(I^)=l S4J\.uj%GcMTQ16ݎI)ݨjHw_ydR8 `/T%LG2& ߰ u2ϳ)_2{*C3!9C94дv(cFcz}6JF漍G& f`r6şqs1sE?!s"d:Pپσ 3aXC~lIו4 Tp7Be3) TS16Ic/w*" VLj }㳰CK~rk׭Dž\|וXv:0Q:siLlR8Hb BIؖbWJULtwt@nІ nu?D P?*n3&TFiwl=;JT:e,oqvI6)q)':6<݈y & Ϯ(y*3BT*`"硼9m\5g]wĦ$#;-eTaE_[϶bCӧ`=T,׶u#TE>^ G5E {7Ӥ4&aٲXf->`br 6}^)XO$a{#ض%L{P*]`\Ru!%*`l<,OyPꁨB#لm6Ɠ8CaJ4l:uݿ۷ز'fC}{*5Pe߷G+"]$ !ё({wvhlN ⥳ EQ*RiX(+bD',JpR/>cJXh J`!Ncú5Xp ʕrxCcJKC.֍ EiwpIb=p\`\˄^%NZZc y1؂Ptc5P(ɤ-WsMuIL;\As =LL ?SSR-~-ƛA5%nR āk466jSq ⬶e/ &^32tlz2gvtTQPg@YGE(&&&&"Tj&8|?6 T{d[,6ccIm.}ZLsn]J'NS}/X& zRYs']1dmkFU!Pރq rT 1/"Lʴ+(ru966޷͵[P.\ zs~ Ĥ,JGMSS 5VSneKePxMZ&/2WLFWwgOD7=12=_Ow/::"h2ԾM")eav:86o\/y!i+Ϧ:k\erM_N׍6JStijR6j,t%.U RkdcjE F0m؄:P%y*Gl5v6(KXtǦe,\I 5[J=}&W[QP)~4 WyfЛJoi8U&$)D*N@@U8v0Q;T+ օ5\!a[8xugd@Ò a(Aw^̛2})w"kLlBHP8TAS֕ҽL1QHĔ6~6tRXjj\b+JI1ޫ*LUanӢxD p!R.o?v 9R#"V!^z,2'&$ )L226 Sl'(,zSD%Rq3fHtTmOL]EcUck4m:S<.Q )gS4 }CijZXpE^nI)+fdEcȎA)ezQʵɄ9Q  ݔaTʴHuۆi.P?bhSSFДU4DL8bC^UDTO[%Flj ܹղ=@CY6Hcƣ>M(p S\aצYjĩ5,XL}66Jtz/%dz&LvSU$L.4/:mpzkڍ0CM_p8XҴQ&l6< ]@YIJaQUdcUA [)e,IWiƊqi6%ǡa/Ǹ1Tr(IEIPfLᮎeB[0~ٛ+tz\M>J_]d}Wy%:Nj¨2dDRMISwIOMJ? U4KG|BJ6\SK2{13ݳ׭ SGKM p] `]( 0RYour&">\MZt.kbeBPl˸(4qEKM)}XPPu=gz2ifuzcozd:s1ghwٸzXnW]dƤab;Lli"מ7DTO*rosSj:+J4n|Fxo|ޔ&\zze:Օ%Mgh gك n%OUGT*UZ=S4(DK"P&M M*/) CJDi4QE h4bdRUjkG&G::Tk*|uަIoܴ3%Yd>Qv?)QմMlkIn)ezb &5U;ߦ :hP=gS[>íTShMzu5@-=l|MZ63jS8PҸZfrEW^5 (uF̶ÕI&hoownaW.=ۏ\r)FbrrWy@Bp&bX͝s>cAPk_k+Ǒ4B a]_u%8@k:0 1g :pp.sy؅YbM^.j讗L&CcbдylڭM$h*]\f!VSuu1022 OW=884EKҥKJ!B @d2iaΜAtvve::ڑf֖ |}38n!׃ @ood>[{abܹ} ^.׋_ ===3gt:Ѹ _Q GK~7A&|Ss@Ygk!"ɰ ui&AQ_g TFK4rSJI] )!#>{=Xy:8t\`Ϯmx_}sqؾ}0:5ˑoǝ-[V7_7xϕ+οm8 9Gn܄G|G/-9 ]xQ(<->m}`Fsw{ =s=}u8|Rw[qaS CG/u1E.Cxx#ӟ1[w_;~}_w1|mxUصk^sqٛ߄UBg %AOO^xMXB-_⍸5kqŕǓ|DE_?#cx#J7x[ެ`Ct(Be)}tmK1tXHCcFJM%L'*cz&,Lef )6W4fz:-k82 .UH\ Q,(gq+/¹_ѵp\Wa(SOF ?\]]~|#Ǚg>u>sQ,GՕ4~p]g< ^!ŋ µ^@Ra%|100Pqo_M7`޼lV;OM@;5TzA&>ɣ55Q]ud3M͏ _5puҥR)|3?8p0'T?|8p/ԑ24ҩT v'T*7\:|7}'pR ccog<ݿ/ǟ.&LJwIi `dd~xՅg>}:q57on{_ .Fp\_Uc?66 '>q /Zw?~SVUj&mJ?6^Y(զkjC>F!Sz4Stp0`PKTUDRU[P'@>[7^|? Ş]۰knd2{+y^'駝 Nb ]O|˪Lc=GYgQ,aP]܋O:@Wg'ҙ4aӘ;0翀r_a߾3RSOg^dV*^磭 \/~{{n V=/mh9p_'PHx/fG@$ ?J3s  :zH8ҳ36 ~`H?QY6H)D 1@` )D 1@` )D 1@` )D 1@` Uw:8D̤x,"ZUEuuuRPڹø[.Iٶ\=n\zY>l*6aovx$[ gRoV^E}CC qRw *6ÆɌ{e#!7t0Y'̘xhb?2=44 .uW#FiV;q]7T )omnI#b9s[c.[g {޲q=7k?ǻ_MR`Ir |ęCqv ;|޳:L|r0|jq<|N ^z>b%~7"a@(v|Ŝycr&l_GG;yt}i[K*m[Wvy=Ӟ/lr P  Ѿ &tֶr@Ʃ>Q%?>Si ;]72~ޒ3DΘ@9H!R=Ϸ~h/^dG9a' f7"8U^gW?3<+R5I u 0pT>؀SO?3wa1+RR Xus]~J/հbOlqK6Ck Wr(MOϬxz@(z1ED*VEj3|mۥFAUlXESS3Vꮈ!vEssKb*/ضuFR4m_.7MKSsX\HW~ơTHQضMcSN#ϥ]* u5j4]ܪ/<ㄪ ѐLLǦ"SL b0"SL b0"SL b0"SL b0"SL b0"SL b0Hxr.s=(0]b; '\z 6ZXE)o:ȆA0|$$s~=O|k?:Ɏz ~'OUE켈L/( NwEB,E~de@oz$=X1.bEe&A L> S) (D]2Ђ5LG B;[  x'E;,x>)O@sriHy NBS3qvIENDB`gtkada-24.0.0/docs/gtkada_rm/gtk-handle_box.png000066400000000000000000000350121446021174000213050ustar00rootroot00000000000000PNG  IHDR6]ubKGDC pHYs  tIME7 IDATxw\uߧLۙ%e7}HB^R!H^"zgCUD%HG) !M~Li,]?$IBUQWt Vq:v6V`҅ldespx8 ygO#qG$fEH o 4<v**y7 ,\0d*#NswD"ʧ> zxɧill_+ 5kpfҔL: װbk dmvEf'fbV63if)pK2IMs᭷qO~ibp0O= OWWW ( F6Cu~?"D;x'mrg_?}YgK,O~M>ܽnM"RAd2)TU'˦~_GYXdȵK}F[-jp<#%;X+|Adͣ=Ν; kJ<@UUR,Cٲu+ SIZZY54TPH!LeSLAQjc]]'x/7XSO= tYSS38# LMUUDI]:eyHhχkfewrѕV*Bpx8Fӟ/rM~$KRi~o-^}5֮[G(,ѓxqM7d``p8L?_rxͬZ? hF"dѢ47kBSSdYEǷoČ3˖=7o\ÏpNOd``P(i̙3%̳bɒ,\8EaY\U_磧iʌiYn+^{kql ct5cvnWt ; =)ma yi+<‹\yeAEEI )Vr!'!Ҍ47ѱnr1G (½/X!L} /8D"A |> ⋾}$fLN<@E$I"JqcyjWL&!iKi0֯}rgnth;ci9}p0TUUIӦAEQhFcc#LC BN*&$|R*a|>LF!dA@ejFH&CTLPP(,KF*"J~| -06+#<34T*M /(2D"$I٨XףkZ!FugeMUUJ(Suk};9m~^.c{$p80z8<GYm8QU^Z tyH zoN18\vMcݨ8l<;KUt06QIt`u4Mj<0KEʽFRsn'LDpx8<e v3iR3׭Ɖw+  ˱ #nUIwi>=õV:0]4MPYUj]`YjCsUIiN v8]pqflf@΃-3ioJ_o7=em[?R-Xu L38Lf)Mpt:EsL]K)ˊZdIUԩ3Q8b~e߮1qX2a' ׃k)/؟-Q+:E&޻dn#0xzTڵpx8<{R$I̜=]שm`U;nbSDHtJU鵝a`hhcwᘨ8ruUQؼ]}>Zf˱kB-ؘ98* XMԻpLdeIlVEdؾ];wN& v;d$IB$dY.T|/z4[i.MlQUN+cml(2e4avu%сA ɐ(Pt=Z/e3&Nf#st;cAjW.y8< k6A6ن$v:o7E%ǁVTTPS/jTC}9+w.TN)-D1YsJ&Vٰ: B!<-C_SZf[o' jR ,b.IɎgV}Γc0\{bf6y`y* ۷nd"*&5It梮c``K.{~*#",qw}-x_(=A**Ipi=+lU*xpoC=ʕܬl{ʳփpx8&26a.7Ee}-ߓ\':U(6=Q+<cth5&Ҷ}Ka=~ie(qT횜Im=u8pRbgS&pq<2#*u* s,![߳Y)fSnfv'[]p1Qp \Q)S U0y46`{T.:vڑTݪ|U|1pflfhކ5+")/~OVA,.7\F'hޟZSfAN]=,ylkWʳcIjH]EJ˃+w7s1p tUD%vwA0/;Ah0UuCMˠ( 0rUx=ȣKCRDQd` Jܹ̞3i|>_(b:n( D% FDfuY4mʺp9vI(L6kggv4=UEDQ$ HSScR\f$Ǒ$==;n; LҩdeW2|_GYTts!:f-&fSic4pHD&~9MM<555\w՜qis( R~A2#աi` n I">`T*nTBiF*& 2|KRHU|جJXMj@۝vky8<cG?bV ҋ zz۹׳%̟?e( HZdY&JG:& W&2 Hj~?D~R@EQ6YikkG$4M3Q4%Ib֬R)M|ؑhe8Xdt#{zVc=‘ vOKK3&51m4;."b-(伝w?'t*x(<‹TF"(bD /˩ep0F]m-\v%aBxH$?y g۶(,ItvvO(>,u_·kf8Zve)IlwMcD`c4qlN:oٳg1k֬60^W#IDATK.C8栃d˖/Ceekf2BW\eZQ:V&}bgTj*u\o::4`0ģ=֭D[W;M њ=:5[p[uӍ֬ʧ}6+pz |oG~.?G}$?r0׼rN=cZ|444׿>5W ]Xv-(KbۓN-],@Ǥ 8((YJRG<`Vg~ӼB#?WÝe>Jcc#ڵ 8|Dd*+#_ ƍ|l߱oZb>/$IC! K/S[[[oo6۶`uʕo…C1Fq>\KlV <vSpnNĵ; 8rW.|O}=ڇ(+enf~_  y_O L> kB!6lDMM-5$qDhk@E7o/-_N0y8wX!+y78ChGYS$Սb`\;Sj])-Ew-tvvC=3N;;~sRO?~:5sLkiAQ! $IDTK& >LOo9~Oyb|D"N>#_!0 $%S{Eoێi466RWWG]]-55,^!(ɤY`>}}D44uVfΘS). a :ȑGA|lm" 0ma5{5T+׵*YfX3CpeB]$ fͻwߟ8SBe2^x%~_/P(4D" 8?;~BCC#Dp87 |#u,~k/ޏ LXh?jkj'?aH:^Q7\)*ލ8i+f=c_(ev1V^CFQ5n֭%k_! *gu6l?~͛^i2DJg2>L&GN8 ?;；~\k??{M'#tzs_ܟƦ >rTp[qkKWkFupx8|&$I{ $3grSN'd`[n38g,[mgҤFN?_d]MHavo%/_MTaITjHҲX h·՚9u^_)晞[dY K=JV(fNGNU[C(UYہkE $IiBP{ikdI@/јM.k}ʸ78e7 hG+VY/ChBERɜ/"Ȳ뮻>~G<# aYFKCC3feICCCICI 鵴a# y1pflV+N7VYveI,HU6oXCE>|~?Kp)d8]!%/g! ѵs+[nMی- Yg|삡w;;X^WlUԍxgb5] v@$I2m6mli [@ D"$h].Ba:w4d2IE?H0mƖH |T A-ؾ{'[XZW5cӝlv^"gPl[R2g HDWWe m̤)$qjosji9/u,,]圗LE׵!vњ;SXZWÎRf3L] Cdio݈$9{L:dE|tJ<6P@]7d3ݯߙ!Ҳ5f)"f I*jQ<8x|Xјa1>q826+CN 2N:f9 v 5uLي$ٱ$`wVK$3[QUݥ24:;f׮Nɤ%#2{Vp:-|zooޔmc_χUEX]Wõ*|+NޓR$vc#UD{ItuveӻH(d+LUI]}#mME2u!uulٸd29$@s,̇´ s1qmcS95`bJN@cd̞wVAm]Ug20Џ(؁,gs\3;n G17yE*DI"-Dm\;UWWH&GIwקD  FI$s!EQDU5OF]]-J@ad@p_N^I+ש 38y"cA.:[7 I2ٴMfΞK&iltz: #z.̣e*ñ8?<|x,1g~*g"$( (穧'Yg}h4}uҩۙ7j{ /^^Cgg'U???pӦ++K/n&55򕫮GA@"Dp971Vt| 1ppp7c!;;HcY&'N#IY都TVV$q}45M)03-fX:=$O<O=yQ֮]G& I89SEe߻黼ƛ466pݿ/tvvRQQ`,=:;x'6e}T*͍7~"0]]\w7EgjQ2Pi8ƺ+$hgwk1q8zEݖqS eku?(ȲiyZ[f_6[Ou&B t`W@ p7{ $ٱc бs'Gu5$ɂqEEE}:hkk'iӧyJ֭)S L3 M[@  -}9Ny;XZWl]cr]希CDMQdpBa Cgμپ-gSze-X@?-g > ֭h_ %3!1cC FwQf/.%< `z!nS6 Ē,cG[!M}9Nye]y8G͎8=@=k5 ܹ>Iͅs$Y&LCY߄Õl۲ d% D 1eyFwձs.сQ?ޑ656Lhm͖-#I䪗G>mj&Ƭ3Y+tuuc:~t:Mww7x9gJ {瓉Fҝn薮}9N8v<GY66W]N*SY>Y@?յ,@z{:> CG5 ۷nd<%^%JC$^gfb^xS"~w [Oww7w̙3IL<}jj fǎ6N?dY~?L>T*3?E4>3FBAR4KˑGAFdz>a]y8UҁqW+NmjfgD4{8,}nݷY@6]$`.q;TT<]mCT?LlűlsssŗrQG' rf֬tww󉏟ɓO,?=|rѱ-]ʅo~{+Vodݺ w 5b-"0~k(=p=֕c|(y`yY"ʭYvr6 ZbwkhbשDTDIBUZͦg08%#aPUUEUU%pt+**p>,6n3Ns>Òŋ梨T*/ϸOǞ5k8#ԧbJz{pawa\/qi X ۫ߡ:+Az9kEpNk1~p Њk=*ho1(v UD4̤ggA CK vAY^P?Gq(ضm;L/bYۿi\q|_G$b8}}}DQ|>UU$A>Or٥I&ۇ5Ȑ?'8`t:M?hMڹk<8 }%j>Du_8\36;uϮͼnS%3i{{{k A_MQ4T6?3eؼi=~ې|~bxN%xkj~?(Z#[ܲ]$xI#J2f jOt FOOa ">Yjz8O~fw\↜,px8<o[ExG_HΙe 4-@cyGc%<0Ey#<kM-U0U4Gz4,yL#<MtwrS4,@ֹ16 r/{<ȣh2J%b%昙SA;Xy#<kXTR%{GuK]KbGE͔?A:FᐁIENDB`gtkada-24.0.0/docs/gtkada_rm/gtk-image.png000066400000000000000000000054361446021174000202730ustar00rootroot00000000000000PNG  IHDR[L[sBIT|d IDATx}l4'NO m@cMEa'i mImLHR B1 m 1*FAcek)-kPڦ!mqO$N5~gO~>ߝA!B!N^~e!2-\EM1J1 ҙ[ Qq| |*ӆ?c!ۅ:ҳqT H8Dq{xu*҄;v',"Jѽ> /8jBs}9. ("=(gDPLJ6#])=g1mOX7@a 3Rto}Iݞ\>5^|:̷_/UVPIqi:/@L( E4@:dϨ.PQ|F^4=P<_Mbϰu׋+|eOt׺ to\MxT.Pi<#ԖQZ窱930N*LGPMď6`D( G,_Z H@qiihNX~WYz~q}3+׵ب횮㪚i.pQ\QA/Ok֐ꔢkj23sv z z(.t1|~=F+f)- ۵tOa ).g>?yZ/*+\_b3r4 WЉBX+%D^ӅF`*3Rtoy1v%tM'G7Si!XZD7HuՊq ?>vTm듇'RiX%p?+^8=d(^F|bB ` KuhE^^y>i6slfAwS 9$bv!0.c D_]hhc7֙~)P WK c%>k>V4M#//>G"'Q PU3p8-mB)s20zqRـR$M躎}R&`B8& I`S'T^m(& ɗ69n[?q'Ɨ+hwh}q`H?c4:>']ލ7+O㡺SL }ΛRyU|7)g{8ӖHc 3?_B7$O9=4$I$IRRVR3R 0 H3R 0 H3R 0 H3R 0 H3R 0 H3R 0 BϞ=#>r_x,@ 0QȹsLNN;(jw=&S,(|'Or <-ǫ3u5x9333-377<^͛צO>ŋ,..rƍm=maRbddT*ɓ'-]|}ϥKx>|ѣGCww7SSS<|x;b:v(Ν;yt:MRaiie䍼\.Ǐx-.\ PtZT*m;v2ׯ\xYΜ9C&˗LLLW(8zhy?ܿ#G4"G]T*Q,\.7GFFd2T*޽[nQ*3@ pi_Η/_cov KEQ( r18|0W^err Ο?кԩS qʕkoߦq9{, M]~ >Il6 & @ f)`@ f)`@ f)`@ f)`@ f)`@ f)`@ f)`@ fsEmV]D6SՊ PrmU*S{MԹܓn$EL CttȌ:030 "ʌ(JF7_n:اsc类n}]ӽwz7<*z^Mvxqi)z/ ~6ylgf}hdK4CWV079 [#o̲ {F}dɻhdAesEfE/ ̇Ѽ}Vt oM2.#*h.m8.0c}SM^P"M~;]4QZd }_&a"Ɣ]G hk hmycmƈE>K͛܄mrYEʅ]-ٜspEZv`.lʔ[~i ~Y@ S\a%O 'yk<e3>d$=CMZl0Bv,dȕϚZT*%zx̵ ]sӣQ6–Q7om"%"Z%sqz96Ȋ3[YgƉzle.L12 zY @<ӳښ-Ei0M3KzW  Z,C:FVNf10KO&<:2Ƴx&a Y"HEueQ-'E ( ',EIGEُ2k,K)&dbT+J$MP,e1b->4h,j91u-˦e, i²,h4wR)g7cxZJ% KpmZ2Wg2G ԗm\1̒DFy3/,&-)(1+'ԃB\5Qc"!,0,0/DvELy<޺x1Y7#:TUm SV1yyЇ?>:;;aj^{ҩ'l6Kg8Wbt੧ Ź^tÏj2Je'EV/sò"Ӯ[|<YQ,155x 1&&&002|Wǽ =TW"lגܰa=2\+_A:F^ɸֲԳtQT2\S;fE!LXVdVN~+,/(0w*YD ؕedMlgvxhx\L襊"pֲ,qww+W'ַSUUɤq9gbii ~u;>Y1t:G}sss'?}#HWK%wd`63 \ZË:Ǽh|K_=~#Ɵ^z\Na H"=׳&U@QQC5b1XX,N[نl'vN( * @d{X +ߑe <V"ǁ#KaV j񄹨Hemw?\QETEAVCgg'>ng24WFm#iOxO; 6nf`Ǎ}ʌ5ömz_q?> ˴'b6`v"wò<K ~kFy(n vJds2)>[XwI2_ U ,ZbY_;$=&L&4E~/Q@U忿zWŦ2;͢s7D%0UXMaP<%BIb˲ёÍ7۷w ιS5@U5 c0t|KheOMhFԲ. ^/Ev.iU/P.nl-H^övÁr\KNn^,24be6lǡ{ٶռKUr}LB-(Иqe4=4G}9tMkݶ[KKB4XysPU;c;d-ۖϡ{p ;OۖFvacApmdžmˡ0#+6b[of˶˗7]}BGO1c:$ٿukoƎmO!#Hq4.FXV\2aқƽ^A\%mLsg.zZqg(_v˲Q*r 0 }, H&bh/Ba FiOQmF._Th4al6;FjRpJ%帛vit:M!A̡4MeYf-26.0,{AT׬ץ*x\~l+!^ҺiT*!F;18bH({'bcGAQqzSrt:\X,"!u DtQǓyd -UUǁrdp4L ӓ;|זJ%zj _ JKIn'jp҉'T.Q\ CVUiHgq{*Hػw~~tw#ȳKq~ñIgҘݻ07EOѲm8s122L+ՉwXD2i(4 +'.zŨU]UJee&am߻ƍ![j\gN?LMOV!ػg;>e!•070 O*R7K$pnG8zza[y&̱ǾQ*@gh]0Mbæ#q߽_28\RT*Uk6b x晭ض hd2)CUQP*QGT2%dsY,3bavt+ j\w.aҵuk׮M?Zy۶Lw3nH-X,=]}C}﫪 C8{lGWW1)MC^^W-[o~ٳ sܽT>pv|^#J᷿ .ؾI$ /Cba}⸓19;vB.ؾ@4ef,,,`t C\2*:6lX%>ZCFd2iȱX ;wrSضmtwwcٲ>1&q*`:7A\D"իWyP ;wy}&pef:t3sn%KUU lٴ D"Ǟ={QUCHUu_CX֭ۡj*lKF* ̆Ar9t;ń vٙ0-2![*Jk_a`Ӧ ؽ{Jr C866mڄZD"wxpWJU9ܼilۖ UӰu6b4E`Dqju\HSBYWUL`jj%LAxlWm`Za%s ]Ǻuk=ݺ /:@TA̓!2-<3h48昣=*p ذhض<6=~/?dTKؾc'ru\TiLjtdB+ ݈ŠkZ+nИl(A2@oBcBL&Cdv FW|d20'I*0X8^RbcxK/l ժcko$YכRM&Bvc" c6UW)m 9G\8@2Զxk6<>E~pkdJ #56*ݠ*q;۶;ޞ,H`L.d& y/2!*ϲ\( o܀ Z4,DF22݇<I7yʮ^jnBX&#*(Qq8{3jR*9͉%AL&-uq)XSk3(dKX<FoJvaA 蟧t:dl|NUg>7+'2M&DF(Y(sJ%C/x򼴴D?c2,(b}MK/lt]xcVk4Fae!dR )*_PظJBiXXX'؀Z []طoFpGb}}=pAuju)u z@DWѱNy'L&0H ugHpwiHyZUUye0w*(}}}]a簧gAλ>i$Y,#uO|p 7fPR1r=^iB1rE;:ђ@V4QT| *l6C ir>%-Ryk pl$alǎ0Bo>;wbXԖ~z2=oaffWp/RUa: 4}kWw˲ŠLe˖Ζj:ٌWjMӠ:nȿp+yع":2K/Ǟ[s.dAz.aYo/|[MF<ܷX,a H:|!"J\Za5ظ۷3 sطo?E߶mtw}?q'Nc~vwD* _A4\OēO6fgBJ%Rt;n׭E,O9ʯA 033TV-RM6"ߕmNߠ\uZǼX4M,Vg> /<U'>L ò4Ha`ii o7 L@T]Ӱ7\x>?ݳb"/ MTU{+P*|GBՉBa "kj66m܈~7eʥO$8EAwW ,tZg\. 8LR|BϨ 9d-"=ll޼Eٶ#8bf\.ի86pr83<Ɲ&QFX+۶ZfUé^u즛Ó`h6bOn@k9Za˖-8`[&}OAq<S4(.sMeY&jbY Lj6zh8:::{9ុ455 b3"`nn~.*Guz{x1 ⎅uz{9igIvuuB׍&9򹐼CS~[ggg[}%q蚎%8n؞n>>Ѳ2IzUU]4 SSӡ#KM0? É䋆5 ̤B=8/FC8dCm~163 6uDD/ 㱂 CN0MN0.<%˰u Z2l't2g;OP&a@9 DY,NH̛WrmXW*ܰsq (my]r#Ԍ+Ҭȓ " šDQa,s9&3eAbǁh+vJ˴6Op˔w#zN^2Qagx2J/K>HABx80wW(QP1-yE< llǁ&t֯_E.ae0>0- WfuҰCF5ibhhBM111' Lx&Q'LNN lCC݄<}6]ױqzLO¼֬Yl0 LNNRDY]ʕ+߽BzՋC/Wiaffxb-nRIf RH1J022I_u,)ŽA4[ ]vUway\ON|>lG/.~V02$eU;lGR)fh4088.G:هAdr=Exp׿lG/::yлl|/<W)У=LGz3pѵ +FP.WZ0Vժzv:::2>}^\'|q90ZX1M[BG2:?lGŀ4M,_ޏ.~'ryw ػzwC(J *ҩ~kag>| RlƮ]t{0!%XَZ\ZKl3#k00_O"˹Zb^r+17ȰaOf/5h{O}]]Tig"wL4M*aV0MG&׃#EGG;Q|-z Mv};`eb_`S% 4B8/($ѫy2:,*asß?cK@~~5 D)ҞD6Q'*D_琛4'j%\Б{ "ȒhrE @Z%|;:_Y / bRu,,,#Gu{:1!BUDx>z \rۑn~XDVaĸ"˗ⷽMR*``N7x1G`Dja\*=]L&ɩ)/k \Qu,.Kށb4DZHM38 kVvY.scBB:{{;U+W`ii@Չ /8+FFZ,QF3<_^LLL0bPU璉D`1j5$qT5K%!u mo<,ەn > <K2N>$yyk:}i,8ibf(i"сc~~ZktD>8k5l'$ v&هwtVZHQqgns7&tӶ}pn(% )X\\ jRN&R8lE*|rWKk6qkY5R _Ň-.KXXX kJ&s)~pQdպ%*X|v],ze\tttIt٠P*UUKm[-ȼ5HR49{ZF ye ;2!E侢 Loz,xB )ɰnTtl6)e5k:JْeYXXX BI9? ( (Ȱe` ^,W*gI8݇`n~`A J(̝1a.b` àR"耊` wo4teH>*Kjޅajx*! 2,"w2I!exU 2,[;tLaa0lۡn~"rB!I%)&"'Yq;aL'av}9<*&PvaEm+v ~Y.*j$<gV,0 MVش*!m;^&u>6SJ`0MZߌiʑcmb.Jm?-?v2.V>69񱉬u>ާ&?*<>(p"vLIJw9a$g%c+Kb׀Yվ5ѱ9-|l3={BU^4Mĺk] :Wp Ր u S>Q$,tCB?`ʕ-85BQ ;Ku@,Vppವ6 Y39th9h4044W*US)M,IC0V\kL8Źy >ֆ >_Ϯx܍8p6?v V^ťxwRVZ41808JŇu *Wwzq@9V+a`Ӧ 0K7=f q `=^^5cӦ (`iETr"'Oja愓;aēx; G8Nt g9FVC<ժ+ I%TGq'wݽwchd z a``9V]Qs{qgcժ4Mz^i$y$ӝ}1Q) 208C10 dfggQ}7Oju  AgruH;Crx89۶ى~Ht{ѹ xˎᴂ|hX ?|Bwwt#Yy$Ry$RyرR&knGb˖šu12j'ib,ְw~3&[*|قKVi2a <ضM'=NRq87[}HWWcjjf^LSf2"Rt1yd33B믻r@5Ԫ|K_gt:ѽ8;qdAl4NqXr%;l//`Zt:{ׅ#(:c)b1<ػoRujbѫ{ǐL$ T۲q晧T*HlRgy/-r]~P/zQh i"_Kez?\QҲl)w_X)uz gu&*JK;X [n]oëT2Nz-uxCPXZmiphHH4M ǿtd[4H$_Ac\Jguf;ϛGӴɤ˲h@\SOAXq1jd<gK8X/{1ܾ 'Dww} lSqjz63nZ@QzB98GҸ{W\q8;JYL|mH$-׳kkL֠9vDlz.T*Ʌ\iUC<Ƴ$ .u;ɠXӏw㭤Fp x2RTEU0dXpqlӘ &j2NZzs;Ƀ-gcH7lRHq4ae]FUV,U)Rd>.1~W 0 6`7D>GWg' 0794bDx3(\p K"B4L`r}JҬ"gfF, Tkԭ3D+(+0)F??MՄGL0oA똚qTqÝ`RU011t:bD[MjM-*4 3Bрi, #P&n(,iMB(UkX VC-˵򦦧]zUc;* {QCS?QQYEg"E7w!!2FY A} Je, s6h͠U >;QCR<_a( y7,ExL5yHb7{T, bDl dH&]柙m)5cqLcrhzd'6iZ\68TI7Қ K$t;r/b蓪*F> 6!81.'88AY6Put$-Zhʋ0.[G˓OUU(mhjr @)' THL;11IeqTn;KL䏌G4ߺY5Q$CdhmAv-$ +Z%T|/y){j3о̮Dr3N8uX* 5X.Jx mO!Oafjh  nE3, O[X,;w¶4u  Z1n:8bśZRvYJ\UUbbrSeH›7oiB.0>%Z[?֯[G1|٭X#[ k֬F<˂b1ڵymMi\fH6y޴q谛_X8lL:+V`Yܶ;n  6ߺu**6mlNq۶m\YTוܼyd={\le/c͚-ܿcc_XW{}} o s{i&_OF4s.$ l 읠6E-q$+iXNx'eVpp?N K no!yT&[p ngg'ͦxHR|l9:`7ڵi-F)&k@d+V {Ϣ2q&0bDrA]]]>>g "0?[Py$֭[Sx& DJpi7|`jj,B{8U'4Msb!_bnoطTE4kefM2P_5m#K7zp]h4ٖgk{#>O eH&hwa} IDATDq~?wqt]RXJv4W^}Dũpccc[L&)Fq/Ƕma;.U2ݘ .~_de˖g7FG,I2_}n.ÜAZʼn;G?|% ==8숣E{7 Z]l!rYjժՓ@<o "H /$m۰,J|s (AՉ\5~a8y52.62'>ض~s;LӤ{G֘\4TU8k7ahhjkɺ5 駟A2Z$"ns۶` <ēc9 sR\ر۶nJ&ɍCرc'{2%D6S.*XXXqhlgqX̀m[8m;صkg3dx5U={(pՉb=F36bF O>g!x"ٶ{]SO̡,IfƱkn #ϰs2??fuM ia߾nS,aU M" a=H$F8K rϠ\̧aH&magsJh2M N2qL&ǭEY-:< XYCl TzaW&7ƒ&JLӒhZF=%:קidҘc0~.ULTL5Iz$a4Q!ld8n齐 hNd2)lv UWԲmX幄ǑH$`FCWzeR9#F!veY%JV{”]\$ՙd i:8k.En- c'&ɠ? 5a-b;$˦:e屷6  ;ħlA3E؏1 f cttW\fXfei͂GAw*rEsZ lN3 Ri][c|be싋ן-Y vhL` >(Lg+pJ0?.B"tEB -̤c>!IK?R i`\ֈA4>{Y 45^PQNLޜV 9 G!H &))a# >|{ady.j=Q:Yx)=W~pJ ˶8V?e[:Y=kW.SG 8ϮOAVKݿ󛨐4;&YrM:I77BOgLo!̱4Ćk6",Ս˦ ñ\ "yT,Kʱ.=cg=n sͮb% X0^vN涳p ^VE^utA9 ^/h6=o߸[J)g׀xplasKF>qgg'r^{kpannw&HX|9KQ0==\v)?8H_MDOO7ēOBUT$qO::r9 |SnNp#4v2/iYThhppW}jX} *W*8o%XY4 <OƟ^OTĪZF3387aM? ^ҩ۶kY"p8]ή$wwX,ݎOCQLiK$xplY 4J{şx?v2 Xtd~a>p]HL '( }v+{nũ",^=t[XxFm (Y U )&K ~s! '(x;$ܢju'W6=4[C"-;1)QО cT2(#l}=CB]vnS+ tGd'Jgi( 07Wb[h1Lz *24j9(XIa; qٌMm[plD#vgo-_yIӘ ɂD"D/,WVCVUnU>*bSRñq {Dk:iPy4Sd9D,"krYEQP@Єy6f+xc! FpQTUy D' "7y c]$s8oejMS17?e_ L_EQ,){{!;!2fF6hT]ۙLF)9 I{*;XXĵͱ9PrYڍu1"y(6@b$N@$^`_O^rXQ{`u ,8v.GCxL4i,AɤQ*[wUP@yd2tr9l6!e26@搔 0˗ar2JVXxIuIK%OQkN`Y6- >3o<{tEp$HT TiB8zVi l" ғOzxGji\+do%jR+8R( `!p6'EG`z¶-$)jk{66@y6{QU׽̒m#Cש~J9U>s2D*D*S{Fmۘ2cҒn6&J%(`~~( &'IS-kooaEpzzFveool6X̀/ݫQo`zfu9mD"Vaaat۸0 tt|i$TյRIe˖֮'c1PTjs4v?X,ryH/ $^GaY^㬳Π-͓.,W}jLNNBQT,,,y7%NmINLY3 n6XX,YǗ>G`<(SO=kl/c;61yͷxUUE^GP| 0{pU:ƥ #<f}c'z|ʏӸ>G,C,fl.p]]]76!qE|o-g@UU'1vh g}k=::r-^oW~ xZarsH,\.K}9煅|/T*SNl6õ:z{{O| F /l '1==#\ũڵEض-[6!;Ϳ+y&zmdY@ۋ~h r>!wCE.k^wMmJO1iZ|$-"7dҸ2N7 `t.} ?鋟i$޳6\~Wcl|9Qss§? LMMsꈐލFaট~V˘o4fݦ_H`se!_ [nku L$7@xz7t3wz/|숵`xꩧ7^@cA9 UkU_.`E7Hi5W|X&%hfя YH5y&;:L&;5}q5s&Fx {{ձ8-bCY70mct}3{]VXkֲ\\m&#Y,Tʣ0'Ɍ1a,FiqooYQ ?{:tnnf1" `QC4c4/1~o"frH5&8"$*"C7-}oy>Uv}m+=ԪUUkxֳIZEɲ.Ir3dhoAݓw-9xŲ,Bg((CaS`bJK&~XSL1h2Aq7D(0d*,R {M Ia҉s]dTiѭ;eՋΰvSMg0<;uu>]|hk9*, %D4fXi1Ҷgպխ> r5>>fk(Z iNZj!1O Vp}‹sRV˪A7N]yE{lE5s9EIbNl<d- N!-PAAx+DI#Hp$2 t\kXȑw,/T/",ryH}Ї hj= ~uCs,̢6fO uM-6tQpuk}~)bܦn@$$kg!M˂ԍ< D]+G|fiX` "_>čE(M۝o_c DO?Cy^qtC/K؂Ӿ eT-gM7]iL]B,u]go>#̦+"'5Pt44ێdD{yRzD2h@3*><_~ިl.gch3 sÎ3c+*ժ8'ct"&utCV@g ]f6d+^W mlf~J<ыj~9d*(Y4PזT~&ur:T:|o6CuGԴ6hVAZ-Tk5:Y gj9슴.‡3][. F)%xڇIᢋyxpe4yBV @(W4(EX eDInN4 0tBx ,OG: MfT* Ʒrމu]Ꚓ7ˡV|fq0OeH"\J3U9fd2>貝 sE6%ߙgeO8pW25]piرcl[zzz"Z67+pY{Q"i;H#J!n Ǐi, xBam:Ĵd2, <(H&2ޥX_d@`OWk5|S|> n8C'#s躎GpWYL\l̝݉V\.O"Ncye_z#sp{/7@X(/}j mnn]|;&8.I|1T*;bs:CgX\\⢼ز,=z G,K(Ze###xյH!9bssc7`|lL:|emՂiC?SnYJRi@ 4,BD,CĻvlnn"ĉia!P<G&Wz666H̑Ux=Nk\6{=RzrEP1 G׾v3η5E^G;)‚*  667wJ5^tK] w@djCT..y)u>"F104.|盘 y+.Ub #Wx[ D$ejjJ<O D,Oܳ,cO~ߤ]^<n!5?ޠd2%<ԁa |Y/N|fDeHuTۑd|_y:h}j}.19~)%Vj$apݤ<Ĉ>}*vɿ{z==> ѣ2{ u & 9XNc*lg˲:Ts#De@z=\=p;* d8A-!-"Sտ67=т׍i7\"njDbQ9HK1~uGGVTmU\[IT6h8tttIA*#n1d"p`)1 ]aB5[އM{=xKZW 1b1Z.&SޏH.qaGV\;y^%3imѭIH=G~?CK5R|>2Q.;yJ`)X D2 I‚=eċFk,T%ݻPXA<G!BomhR PLrYy,/pw;s7hr(Kl<SFYQJ:Yḏ2ph0  Pe^`2-3R[J\>)Oid]if"nC"C "ˡP(0e8#*㡍T* 1u]ӕF!9|M .í cT]٦&=4gK_[o:kKoѩ)eF:wd2woz88s8q UƼI(РZ5 -ɪz$ eNT >89º/r׼Zض^aA4MLO`aa< $s(>Yx[6ʕ .\}Օo^m eMg? !$+QGbL&[whdR+y9[(fcc0$žQU*O)֙JSkP*022T*pZKSO2@BI_j']pa:tzօ`h4091ٹ9_Cce6n.h.2d2ifҟSSh5[b L&ַXNWh2+krr{4csL;۵׾`?{C/Ĩکy֕r~"00>>& o$I ĉ<ᾟp+_ n6L~@[nlˎp76UEؒ,|{kۃq!F+UZiZٵk'R^u׽1E0)sJzv䶝X\l{_.F6F Nc l;44ޭM'l"H-4yo}T)Ww^*N/~:<@x*boĔJ% `t|;n[\jG)U:uK vޅDx_>3dYR麌<\^cǎӱ pZF<`9y;tReY,Oc߾}>@7hv3:p쿳bZ!Lp4QVQT]bbFԕJ1f:bc.l&^VJ" >󸹨 3}Œ?wMy6SיE{R?qΙLRYeI$zZ}fUޢ4@|Cסz VRQ&f[{&RvSנ\t3 7z㾾^T`|2Z--}}}í@:SyH$g1DY20'\ͬ =Ҋw[,ժe'c63̄c9UIx U j*%˚N t)4ێx6u-taRp)R -Z.4l Aљ/HG=kSkB/́#s'hqzQY߈ĵ4&6_D +8dž--%^X 菜,@E'i:'զe6Sxmٶr*vx)]w%x|P"*4!fѾ/otIFȄa|aHtea.N{@ "iF]buڲX_خ%qh]q9 |)/Ϡ+kGnNgU ρLņ5b_R `U!P `L 7 ՚FYfOMs<2?B[74vslDӣiFbx]s' ,N,6ДYi(Uܴ֣^NI _]u 0-w}:P{%΃aiJ 맣H׈CsrI-ٵZiV㭜 u5_ÄMغ=24}k3s]\pyIz~߉ɉq\pnalϺmcbb<@Hu?a;6.8\3PY{DƧU^^ZBgp{_`**.RXDZ199!d 4Bs4 X 'NLc ߈L^ʗ#Ӷc?uJh6;;Lĩkb\pB)vM[ /8= ^u8gneAuz*RI~H(xы^Adg]Ȕtnne 6^4 8˴PU/la}vB J&fd2Y6z<3U!.tM7݌_Ғ;/xE |L%X^^}?4 (dBh4LMMf /~e[\Zbص\.ߋ M#|‹˲_]n'OD"cdQ3ifu%qlllk~\r18p t?_G?}} Bn,C>Ǘyb .麎}6b׮ \KI5k}W5Tq=?D>ɓ8S2~;D;X3ߞB< 67hF`$Is,þoe _ϟ?hx݀/-t|[r/L0s.{ߍ#G2R.;\JpȲtQ;ccc-d2RGeA40==d yG?A<CVck_ ˲;nŧU?ё2l\###ʗ?~##+<׃i'?_Wj:׿u`ee5Df:W܂.Նsc<MNen+u?k:nLNL`iy^{ `=OC˶kR^NDɕx%/"?:3q] VcccNJ "`fq3D}MJ`\듲Ӄx`ņCHYxxX\Z 1P@WyZ5Vr'0 hX&eZ 2 < FoFpCC"X &JAЯ0LcmkkkLIH$$&q777QT87~?RC)mݲa Ng&[Che,Qm m*0 eI45]븘]ue08S#ёPcCe*A4CRmNvr!Dښilu||,,U,tM'*d$d&IxXסP'd6!uc:W lV, 8Nhhw뺎J={i;o/8kϙ~3s嗿$T"›6wC9^ rYuek_#Ί֊߲Ne\.iuף\^S}c;ȲӮ!\+Oh66pT*8C2|"!NK7[>S}6s޳C}GGK=Coo/Et[[SUm_a|[_WlqrrK/#2;=g2EMy&'iL?y KK(sqSV8U}O1j{4MܹRց]ܹ{G Ab`p`o|[pW ׿eeq0Q(P<1Z-dH|6.^rU[^kq_>A}EZ-&tSX;ecԔ4>ٶt:CP:9ݻ ₎ J?r jP("Ǫ[axaR+`(kcqq <()aн+P5z<Ƭ^㩧<jU*CթOwhs9#C!8RᏘTVqeLrY8&+aW_}%jZ($A8xG a4Tw.AR΅i_@\ž3wղv(qޟ‹T*嗹i۶D";ﺛy zW_ue 5T ?O}+.{ *ժr}9x_3XȠ;48 /z]6bxb~z044w2r666Яyˤ} T5@ᏐNa;F6 EW3I˕Ʀ Oy/|)f{C?;eB,82ЮPˇ*!5@WiIF =VpLON W=r Mdz'^ptA`㨐(X$08NJ@|)  =V"'[Twy ^#Ev*awrs xV*\N:e](Q0}WǍ'(X]]%(n2Dv~;ɮw"uͤ;;y YF( 5MfLt;A2s hu3:Ѥ)(u׊8*ps7PUSd@NEq09`TЅ V\w^~Qchp ]\ 4 @zTݒt3NJbY6ib̀J,1d.V'l{jIB[T0 OA6]ees(vMݶ!.Q1bYR"(C5OE0m7I8|F1Pw6d#DͅQ4 Yg~ )DOPP P7sSR4LO]OeE?ũ?SW}P<JIɳP+JD(jd:m8jMEYmboR IDAT8Y*UǤ8nJFzD0Np Jd:l)*e6fC鱦뫟. ,u*;uep_ DmѠhquЀ8QE\A 5<7P:40ItJQrf3P\E|q>*+W<UzF8'>( U[;-<^d.`ـe?ݺf A؎b見Q<18tZGT] qNa2T$֖ *x<ֱ|P4MQGRt[}*Î]g%-"1ADŤ}WxN/UP;^M={044D"8fG|.I!ˆC}qޠ|F<CisO8T*g=xϻ߁}J\t]G\i۷0Vpy2(Zݻ@w8dq? .ZKaWL:p5dƿrw.~OqeZ=^v .eٿND wk:ƅ~ GilC;wpnP\Ƒ#Gصk''NJ722GСR+u] qRo|X]]vtXV q~#  SRuB>F9\voK 3oIuy(]eNOݍ꺎@2@VgZ}O[UqshZ!=1p!4 dB<;wpl.#, I3욦X,С8眳ɬNV O>udFCv9y>*=v0s!\.0;Ж 2J2sxp5\N?dcGtxޒl]!q/ UI`qQ0Rl]';覦"_4h I>C7Y@ 5b=dԚR*sQv -MUV!Ձ0a3o*뎧Vv<74-C7}ow ^4LB럠QVwI$2P5}|YmF:RB5<&N\z[k eֈbBrE&rOj IR#0z%Xquz  x%C,ޏ M7лxr/&ٌ4DKSo}r̵:<跏sj'9[nY*L&9g?)/gU[3lNghbA-ZG0ǎ{]l5}n-KKHR& Kw##HR!JcffƏh!# Ipɉ""e|8m=M7a͏+b1HWLdNmZe}>a}Di۷X,.7NR/(u8B"X-k.Q<BÑrno4Aǥ=bUT9appav5.y2tr,躆zhHCCcQ" T "]PYzt:ՑzFuڕJ% N`:GsP;s ǝihv;4LZ)C݉^8:J{4NN R'?drti$4d)ŨVbںG{ØYlV3&5 >y@-oU]uhJeοplT @,C^nGT=vtNdSJz=H&!Cbv+ZU 'E6",ĝ^*$Q'}֗ab1iNuv!2к(ˊq^GoAeZ^Ea<9PͿ"!'krCyXWJ~4j)];o{/}_؎ѢFRj`#ŦߠC$fsD@z/j|O&;nfhcCej&McWYMt*1Vs ;8.+R UV4Sc&Q ڇzfRC2 ΁l lAB qvTVՇ X_ѡ< 12 P d27Xqlic{ǻ?axյĚLDTxXeH$8Ld8JBj}dw"Wf麎Z^EkZh4"`?.@]qKJӴYkE$qRqnm!Z8"Kդ11 ,e _F.%C2 @S2W%9 0t y7CR2NMMbbt Op _B=p޿$0W'78'Ojzx eO10g2x}?g9կ@D]|>B4w.AO*'Tk<\^(8pFWDێRI$ b1w}|')4A"`,B&@@(q. R)xUB~uɽXjD ~d2i;c qBQXӱy y+ǘt:a,fL7F(B@?ie @OO$04U >R)XdL&{uF-dH+> WA@NvS*Kt vځO~?mUV7nik&w vlm*WW*I*B`e1tG9mVJUٌyb0 Êib붝yR6VF4J2ݾ; 6yDfk녂29_rlZ҆9<0L% )4E6vڮ&{pTN *\$MӰBSR2DZ ':[xj5lnnJ'&G۶p#]鴴i1ɒŖe2ڤDJlp]c.>!8vu$zbuI  IY{aaTRIijxyů uY5Jr]~N?4F_+d2idro}x+2^ &&78 *9(VIm4W YǑ]q]=ɵD0.&'QB>WMfudr}SQ\nrB\??8LTJ5qXZ'NGO0y2Fْk61>6W^{/_FGGXkQw|6R+4m|SuIY x"ρ'w,H&>,+5D23 78sb: 'h\l2m}S:X*%SMkOdވr #x+2I+ہ4uT{0]Pי20MR3E8 ]ә$Rf%()Cʵ:fI$nF}9˽C[DFUOQ5P$ eE1*L`qVKGp2l[lJHN~ZY@)i<'NhK,ui7H7< 3h[\4rmnC\5K-L," IDAT&ðkk!]M,l&۱ EwH9 ])5 cօ@d"˲2:H%HH,^h,,6A׶?1t:p)pY>$2-*DPVآxɢN]@FcD2k!h9!J6t?lPTbf&=D끮XCWTk:0USpZUYT.JJwA0IV+e۲9HrBdqحV@TEԁ̘*Bvd@aTFZm.6ZMh՚b#8&ˊv㞠5vV.l>ݸjEvzEnk+s+y~Ig*˃fFFhV+Ne>ʝR]DH& 8nABHRfY,QO1;f.gxxiXX\ 18oq+f`$ 0 =u]dYFc#`D"3h.  LːdEGFFdE :HVcڂ<,..*^Ĥ zʾ"KQ 5Ԛ֦FxҾ'!WvSЩ]=ф,'s!+JKiFx*?wahpբe7Mk&'& 0}'#?>b|nOߍD8qП<(b&v0 bt4ws11>iQEhp+g?V ]QT08H0MX"@Ï}191g=ێal?}7>P\P +_ d#2Eo^ctdr]GKg?{M8a<>Y%r, LcQVT0<<1l۾ al; z044Hb)(%s9G?d842\v%&&Yw-Z) ҹ>|pDc)0F_^80b/mLO a #,=4*)=d֭ПOKތɱ.6_ e02^mm -.kmm}ل ٌa$J;%F߅gwih5[!.-5l1B i@ P>$&47ͬDjɛHph.7|K; ְ+be^Tj DAOلMB7<[fzdm$vl8# PYR'Y&GAɼ;W|V%`O-vCi6^i\o\XԖ,(M'7Q0FJ#@wXg"p~*TZ9G̍z8UF=TSU.݄-"jF\;QϨ+zک:#&b(NU#E:ϜP--$B`Ӻ#JBզf vh ^whϣs3lց*Ѥ-_%^|CKj*,.z)h_:%hsl C7ͺD"MSR-p?J?O'XWs$BnȔ7J648ggUr\z~p?!{@Z o,bT;Tҡ6x 5EXΤl tC;ZkNpJԖa2` ׋bu=O@h)6<6M3 C,3a% @ jЋ3FXUg ҸeI$,U :ů)m_g; 4 J߇^h֥E Bh\ڱ;$rY48d2$t( "cbt:l6VGb<Ѕ\J*~թzH&d2,FblT@ \ɢ7;T2ד"t0)T= GmŖdseJT +lirYZ6c0L`L`qJ%'UIC!)tf3X]]eQn*n V /;cǎ#Ʉbp۶MaeeE `q s@)q|nn>{FX081ޯhHcwT V 4ON@I݁>e4@ (4091ٹy6VѪyؑ뺘DI33!3xJ~&''u'NLd܆$btteBI (4`td8@jWVP,CX@I&ƉӁ9B+Hxψ0h´L6v~NkX9=@76+<.rx_~(-wK1VЦˊo8z{fDӧgkVw>J%L&188@Jথi;mak4Mbvv.cjqeHx*w[&''bL3'O2D]z$s hk,+شc59/\vpĉ@fX]] Q$A*뺮a|l07?Dyi8~DSa?8tM= bO*(H]eY@PKj5<9l|Ȉ"}\!̸V!NTxCCРazfs@)]eX<91MtOǍj0 Jy W_W177(\ϯ83^{>bcc3;|'''pÑ#ǠqW;Dn|D·RR#l!JJ0 z/YqOA?gf=/z%}ķ5LO0ˈWo+ zzz02 aqՕW@%=n=‹๤IsWn:%#IEAǀc(Ψw 3&QqtFDH$7 4MwWuNZgާ`gIR;q>z_}߅x?(,H>L˗i.iGG; 3<݇W/ s>0w-޻ua2lIEhi#IplqQcE<>1i0X'6tM,RWLD_{sزZKN3sB5* P)WP*066õ(BVۼaeQExᢸ4'@V ]Ƨb肔ma  eϳNJT4ɢ{:YLrKKK>M!&m3H=QP U^h`4(+>Ŗɤ}o\@5allSn~~Y/..j}q.7?oRHj L!G/j,J(_ ڲ,GA}q Z P滏`0YT ,mR,dִunq 3L0J@08@p O.8 f&c 9^Yz}Wd,P zpxC6rVR#ǂƸ-ا%$2䭷z@mgLVT״()*C}IUTE`#^3aP<^Q k x0jS[T7 .WQك44:2Y!fD9z¯$Q4QD\z/s"j*Nh|r03$cȕ!JQB؊ ,Wy,Zr,{27c%SF`9-6.:D~*xF*_BxI sy˘d}G}жqA BDMcDMi}atUM.RҐ^[6<#RNruU_)B_NUlq&^qbdb[V(E Tŷ֮?Q@:;[Q|lJ`qaAY[X^U8 PT&pNAױ wy8bE»ZTAi„{9h|DF׭(T^ 9bhEY[hcy?QV17P8`&= Ӹy]z۷!ICUTL4_,cu&IV7<<۷!f2 M4-=BfގG,Mpi!?ˤ4 m[Yklho \78c}Bza)ޫn-d3XZ*4IiK[7[2HVJi@]*UUjZZ[0<<>]?T9R9 bhhJz,;ql@ww/=N-a]2Fo@)Xf91>݌So1Rz3==eMݏlACNiY:;;|@O,˗)<: .gjzC * \0ae08XXX`A[d2iӆa40 N 򱍎62}lӱ1@gg' (zoi ):`6 Wxhť%RU±)8trq F'&jPm"|l$}΁a%-Pmtt Dfxm'}>6BK466uMI",F[[ gu33!TC&F__FGǸ|lT mz1;:p~ 4z6֌&ei+tuvO…^~ClnMnЪTů~*& ?\fM=el&z{z\"Icll7!Ja~~33!eNKPnя5R,+ŋ^|:|گa 0ZcZ Cxåo:<&&'_߂rl6)8?|Ӹ߻Sm[HҀ?Hrc*­ Uض 8=|?քb&&''qq'{߽{Ly1a%2L&-eM8qƍxgpj-Ut C* p IT*#ˡX*Sf8th4+ (Xo{iP5 eA5:< ۶.|_[n%|0&׾W\j5uw}+_߂6$ \TU<)X*C00333:[6onXXXD&a}&~ʪb=bu\ފ;eA54nꣵv. m T?(J:ffgi* !9J&ط<.vj5|l ͐NNNa}iTUAu`0xKGqeD2FUUtww#c2c*.EQ03;P_ s=mm(}wpSR)<1LNNBiT*Ucr`^2knKLwPt3d B\l7Rְzz߽QwЩH^k.Lࡇa~*_QT ~~yy-S2@ǟS'L&Q,1E UY8Fkʊ>9}9Ce*e87l#2!ljL&"/kE o<:1"" YShVɄ"!l9љ:#Q οvP3R vB8<8cBiVC&qM):CϘeJENU'C4hCK{o>RcڤI58 1m9J~<b2e5M6iX|Aϣ4賄JBi<-9e{bXUlqKֵY8 FZEl)k~{\\\YW#OYf?i yh&&\*T*,YM Xs9 o (zDq0knP`LDoo/0>>EU0k[6ob@䎎v)Ɯ/i߽ېJTu* s7`:;;|֢9<(K&$ Øk/czzY\ CP@Tf]徥o{PU_“)* ,F__/lˆ1?lVC_yŻټ_4R$u=P5%$ ozzeOjJXYY6ffׇT*ɩ$ͷx,ى~KT*ϫ8.{˛XR?{^44Ms q r"czzjvw p\P,n___H \NR$$֭[&/!ZO<$i۶m5W*3Z[[/5lj'2^JՉPu?yضkXt:|Ql]\\ ş˛Nkc|؄QBat:ѱquq"]ױhi\`bbw]iB뱱q6v V\pxNm[̚SUS{l?f\uHٹ9ƾ%PcC2L&SplBj5JlFoOv?~wܵnEK?4Mî]' LwӴ= R;`yyLLLdHd2nån|$LNMKu\6~K{i\oqsKLƍq}﮺}ei\P9v*vNpjLشBmaE8SYv=7劮&SPun`ˍ?C'/8G(:;%@1c(o|ph UbvtV{eO*nv`K0n(jzbE9IsH u! .^w#j*㍊ 7{(P`ۿt` W$rƮ^W^E:;wzuK# *_;1[3͒Ɋ MyC1KP;HcJ"(d9u 23e! S1IׁEhM4,t4_d"Go֎-ཊn6|L,PU/>>kU\?uM(GXYLC5\\ K*?4?n :'UhX{=hRKƲyH(8wjs-Nմ[\\boA%34XCH]*WK7-nIS'R̄j* wߞ.Ce1786 NNM1C/s r_b24q: 28xTaX\\v#"nX4_Z^AvB $h.5nmL@{=Eu]c.UUa-^˲&F]Cц́nY18׻%`t |q9 r:OM0ac\I_i4\w^kL&Q_ EQqqǰ*گ_ZwI A4$I,.-KKds9蚆J^`iiYe133*Ww])FH$ ?_q}PTe;3NGGGo Qn.O~}t[{ґ҅i/{%`ǎrfEQRsν#8x}7[*DR%Ȯ0lRAOO7oD*BRF6E\ƿ011Bj ]# =aTMm4W7RsYdxq7| R7 fqʋN5=xWpFKK ˤS%az|WȒBqO774~pwT( ɰl{Whooa)[*ted* s8uرZ͇ŲmQuoLGXj۶^*mMRBNJBK,byegITjhj:84ضM:$WULLL]N}LR81;7xݗ;=vlߎA_"CJWDAwn*p' ([[[| c~f2H[4(jN;w6b,IēOavvXTq/y)pLVg9@AF  [mj wxI;eiiia"nr9E\G:*BQT,odҸ뮻j,{h&N?4TUV(^'X1B\? @r)$cGwazzs@[bdda邮~~K;_!m(G>GZZ ҫŭPпn=U8O}sO)JqO݇Vby Q-ٯ m&7{I{ Vǁ?Dnt\8'N7#øʐOɚ7~DyQM;8]ew@"+@|k7'B]Q`f7jEveJD o(7|5΁hA)Oޱ~si}e('1D( .:D2~w}ҀȒJO4ڃحzi14G=M*àزS)bJ`P9 {LU~o;D'H9y)}G)RrS!Ee ˃˛C)O9__0._2 /bxHGۍ#5 RW[-D+SS$ϖ[0E&I(｣L.wᏢāJG(*':⭯8Rx2rC~&ZGq)c恓yG,0c%J0ZTUL&Ex2rnfYؚ-g4TYD7G8餝a0Jlm[qI;C myDF---馛T(@Qe^nBvS]`yyMn"*pUUq!veql:a -oJg xA\"˲LMD*µ6E/y16lXBi7 .}D{eYhq/~ٹ9Zmo}32]ܶu=0v~d§TMC.k^}1C@QT8,“v2n8s*4EQʋ^!2>8i"o~۷ַ'iXLDkk+~a,Wh]p饯gcɲ7-&\z*?0>L=wN4>ټDoQ9MO7o|=la.+t8~hmm}#qlO}h#pL<.y# ÀU/'D6PU9He^p~133ZTQTcv7UTl~\ mP¥4 D߽| _{Bp]Q,qao4*Oayy}}5W߁z&M2\Y)裏D"{mm岡L*mۊ!,-Bc_^*IoM7 eh%<Y_LiC}]GXFXċ^|:#رTa 'z g&ƞ Z[e.8裠'q|;z͛7aӖ#Y}6<}xCA>Wst/ԧ߉w^n'ahii%]xlǟ||4dM)QLLL6hXa0JNK,ɶmr96;8-HqaIu'n\!$OwE  *dgs( 2N3J nP ycɁA9ҬF)@"ŝs̴a8n)"\Nh+++L:{埃"E-%RURHop޲LI+*t] qɲAp--y) @pl5" 4-8úk\]O@srN$M_EeX;Fvwd VQzT8eA"l|"^c^ Gotsu6Ie/dT!щ]4)d2eLT߈1:±˒EHE#W.^&R9)ϒ)2cL2t=/p+Z(} Ţ28YrcHwoQo]>,JB5z2i O@Y76{Tx1/I٤VF"yk08vo2-L`D)d NYre(J,\@& dhQfQ)p"eՠv-"ܨ b[ԃ0 semF2?3v3-N gڻy"_h6i:. : !`&_$oQޫ, %bVho\`Ylyk^ * f|D`$Ƀw ̲WR̾ze(~uy'L̡rт%r<x0J28J e`W!L^M䊊V0LZ(s\5؞ xNDCV :!U29Eu['m 1>ȊtIoIM؈;NӌW!aQ|a)<N7m,Ybr/J#KYRU]XQw)~+XȊ _N02qcRK4Mi? Gs牨V@iZs/˴P*022,#ym{g(bQ矇T*;x&kxH%p\wPTqůDZ anNFiH%P,uK1Z<߿s'6o%rYLD6gH( 8ӢM>ï~[TUXD"r/~%.64!Vm CpE/GXf4M#"N.WR$-=ݑɈ 4MÏ?ڊBelbMD.Oo0HoR0p^r`\Ge!݆Rz*ZZ8ProR)<ȣ8x2 [nQGR߰''pwW]dwQjކRK.yoS&eEE^r?{)~c|5A(rm[U_wQVq-UX~/=e?~wEoo47A<>/ _WBneYxG7Y89--y͌c}i(Ku ;:?F,zO=Bm}f29\+00 mۂ!g?P{\K^z_VU)-b߾}p!do|p!L\'0q}gu“eP50r6m9LJ Y:^ŴRG z8p0~Tغe36n2a{j7yf?t=,B__wJxegB)L?z_;oEOORj&&&pK/D*"ıS199NڲHGSqAͶe8{ry]rDZ㌂4D2-rQ/݌(,"7[C,!vgFgbk$af\Rɐ8)18B* cC2 %0"怭/&Bs}8-WE&Ab:Li0(@z-KS ˱UzgFST.!=(X959Xt24u#LJȤ.ƏP]$ IDAT2q˲i!GdeHxz.ͪijU/͸5ъr׏ r;Dp"zI UZ㴔<؃TPU~ZlVIuWUH l#R).aڠ9nf2H/sWnniJ )}xvvTWn% 6"T,KP(:JUQ,,yBj9ot:A,2 7/shȀf2 FDLܡ* \ ꮋ]Q\|Vb}%\Њ0ߔ /dU&H6=h"0JUGwn֘j(lÇ<<| ɬ >'xEe<Ջe{pyW,K4ր8&)TlqxHcORU)C`Qs82YBE+d5zqPÈӢnfFKXEPG+C~Q@đARlˤ5 `%PXDے=Cp=f'y*O,//[Kw0AŔH$p!yI=7QX,a}흨x:C=BTM%;TJ$tcvj{F5T*k^{)՗ }똝 Nfsݵ8B݄JͶmtvt/_c?w݁eU)-b},Fecj8<:/7z{ LHb}>^fF#*Yrmذ~}y=wlVZ@#xigqhs鋂۶V|k+T*ًl6@㓊_x]ub~~>j(Kxåo즟`-H&QdTWWzM̜Kd eXVqz:er.RpOaExj^3N<[qanΎWk5,%=G۶裻w\hi  ^T86.}e[lqx-PQGnGV垦A+͋QUR000ϠqJTTUQ7e& TU‚Y) LĺuL$099m?ok# `Z&3 X}d6+mr3ڱ\4ql"GehfggIU@f(ش,/0Z|>yX 3˴&Yld2Au*ktc@?cɌjzRL `"˗"UUEooSn>FRAmXdN`ԍ\ɷ\ƍ16>΀4LdZ֏ 4 a4M C[k[, MkC ױ*p((߬h~\Q0;7]Ӆ5b|v -boV-,,PuVr$wEaPBX7 R.oJ2lۆjLV , , ‹QZyƎ}D*fg|J ر^tT,..n%h&+"̞*J%R%d+"A-EQ%8 JCMǁjC\aR,~{i ˡJP,d:\ @sY>VUR}0@7 s8tuurkD/x9y 2˲Ų1a~a[& z\Z8==-u|)w@QiV@͋OP843(G_8(xT :|限*uuu.}?bENMMqy0UeYfg|9H#XF17Zoo9C?f(eSأhs>33|H@Vc'Oi}`|Qv(C2@gG'3V3`ZumOXX6Ooavd Zm0#Ñut ,,.xxx(4STN:>ò,cݺfJcLNM!H^7044( Z%NOϸ&mcă۔i$A(9KKK(KڄʥVcjz #¦A,:)$ x6o*+8 BTjۣ* XC8q//oFGGCq4Q`R` ظi;GBM@ņa`ppuxݾwF4s:}|_~ys3cg&Aڲ,<1MoNQ[{b~ W]n|욫)IIRE\Ʀ#wϺ7㏃i>׌vlzT(~s^ ˤm%[.{pϽܱ*>Ȓ?aGj`]y_$ݠ+#-{Rq{<M-- '/ؙeD}x/٥ e;6ܬO ~bȉv,.j!r9$ ( 2 `&Ԑ_0ަòb{zIFV?7 Cʣ?r},bML|>|8a 'Ɲ\4!I-`*>k`MQiWA2h*aCH&]*H&\*W5)At!MgG;ۯp kBlqxۥ=gծ8TʨV*,J(U K(s-S ·Ych3\2:DEdh5!{ėE+Zg8ƢM i.qǻsš5ĝQs[^`2,4 WVӛ .ڄva' Tlc:6PU2^/)z=.8n+%#5{dlYRbsl‚o`x2 r,f=I;9_=;\!ˢP(*<79N! 'Hl6+$  mjiAKzr4>>A7)ũltDzg]1D䤟gi҅'cn+aUVس)ޅO"JrS^|P0(n64Mþ}O؃ON[]5b>6GiL$jPЕuט'uw?eЍckrϞ ~lۆixg<@80]Çs+8TUE:(PxKMU1=3mӰH$PR ޽qd9H4= տcwNC uf2:+Or,š.JnPRg|Y#2 -UTzжXyeYTNFT*%2Q(EeH W2[>9gO\ˍuGo  t:9ZD*2Es;S9ݐ:u!cHٔM4S)8b .͒^KjY0!/K,!;+ŧq|>>w_}5GKK +,Ǥ.81n1;yA~S 1dYW^w<ET<0^:?#%' A`e*{NtGn;}8(,ēgԗ4gy'̀t]O}Z ߹{PMo|>Oall"4 H$tlz$&b߾&pVQElۺ|5߼Zam۶`F55kq ࣯oy;pͷOBN)Zby'Muew}|Y&UU+G>Oಷ&VJ%ؾlA>6VcMغ8tp؅\|2quuuʫf3(,`S{h9ވG݅u/H"^YPZT/: pM?V-A6=ٹ9d -r;vlG2wulܸ'b<3N:i',SOO.}e8y5f$ m۸7Ldps1ǝT&Zf2i><oC0 YJH!R7]Dt?S fY.!I!++(FEADz,n9es.QS?z@kK4ߨ댾G$s۞0xJJTTUZZ^/0Mttt0kcPdaEQ`&1=3c>65 l{mdcfAa|cww/c*kMmĦ+ʳVD~NrH/,,2EiGRaxL&L&vR%$M. gsܾ|z{˲ۍ|./\s7nFM޹ r!V-4m#4m|> DZYl0af e7SU= yPT,g ߞW==F # Ǥ0+*ܲpRFRD @k1h4<\t2e sTbr$٦8j J#bUQa֪mD8`# L? [G ʕ2;LӄiP-wdZ岰\ÓQRaDL),A+>WxeeEZRlRCQ1]ضʢKeq{&#i!/'A`kU_|4_zaqc?<:;NLXuލEp{.q0"uE?t%lC*Uu.9i؍8fMSx_FPסi:l`MC[OpVTXۛ*)צ:LƏ2MeEL]SY3 ؃L>t*q:Z/u 4P{1 C,4 ix(Eŭ9tc0˲, a-$|l|1TlvCCaԖI4\Wls4ME*–-+D0\#ş7"1Ǽ\Itsyf \\Zeٌf\DmY6 `Mޙm#cTQXgG֭[˲X HX~"C!Hlt:;D0qGZ1T*T*4{KU5#؈%@â.ц aY&TU z)Choojx|GRի8XnCCTnQ$t LT_/cxGLRa2 y48==,K* dJ1Ģ! L@K뚎ik5WR- hmlãcP@;"ɠ)U1 Ը: iSSSď]QB!۲1<28‚ˢXX EmԂzq8D4-!D?|xX\xmmhmk2-lD8F +"H{C6@Q LNM5&2tX%0 cу8Hd!aA:R`s$ىZQbbɈ J E  xnGIGvMX8exӇf o< '$2H8nVeZml%DIf^d2v?4M0E.en´|:vwp4Ҝ dz"ǫ*T*EoOST(ok/LIeCQwp0ιM(F騱IR.ım@UTaxE8 wͧlHDZZZ+pZul˲q,˲L`3H֮kZkӖ2^ٖIDATMPÒr#T6k]C/!.XV]kWSR׮ꁺ1LOM1DD 8/B*<U6'J:*6mڄILk)kM w"Pk6Ã܏_z!4MG"h^Ua=5 կp~@T ĭ]NXY^ƎG裏} x)k5Mdx  4's=rٴsݶm8T7 _|6::`[iզm[{{+v=r/<{o@\ uZ֮XMVhYF..4MղLX.JTB.m[E4[ڶtu,AVci-~^.xe8ʍ4;mmяݻ?s+r j-˂e4kןba; TQNk( B+Qt2Nn3ٲb|}Aω' Ys$I09ҿW7hDTf ӔL׾q-0FP>G6L6<|ww}};ec=WNQ=7X!+CUTDHD%Nq3TJ)#j/"z/(d1x2}lHd Kķ$zye>4>'K"cmV ТSSWTxNh|!Ujq y:΂qt=jy_% :L6N$h$cSj0e<5Ț gQf8Udv>\Et sxUW ojъYVH,{ߨ4.hD -KQ=EeXe.[MP^2k<Jq& 2טwY;ܰ0A}r%)vEe F6QQI1;7|Z7z>D Tq]:Qn] ͺnq*Sq]8?rErz 1%Kqd"R8"ΐŚeP*}ɘ}E#r"ՐhQRzYQpAF&,^g407?OGwX\\.xsI8plccN8Y?ʊYQcTo]ܲF¥$Afd'Kęύ^( W2HPְi&T5q`MJ $9sHRz "FD7s7YQf" 4#8!8lVrbEYUU~>KrMڜ $LL&(,\{^T*a{M4kW. E&"K8ŧbΝFZҝЖx7URˬ]QUUq@Kjv]MYlQYEQ#ۖmۏ޽{פv=kqaU]Sl<6UM$k\kתR HF\.b۲5I]k?J)^Czkfڵv]BC86n~UlkmZ֮?5fztrEvv֔ڵv]ruU]Qjݟ@Jڵv]v2rSw˾3Cdk+Y<6׮gw?|(Nkcr`4q߂+1jJ/+f#oB3r[BD3dfYv[+_sGpl=>Iͭw+?]Ɇånbw;Tw]#  @14,~c"?`a Hkj ۢld,ex[&")?bو`xZ-yK`SIENDB`gtkada-24.0.0/docs/gtkada_rm/gtk-notebook.png000066400000000000000000000110551446021174000210230ustar00rootroot00000000000000PNG  IHDR!sBIT|dIDATxy|Tϝd@F@EeLbEZA U|YUpԪu{PYVWx$sL$ !3$s9a|wja=e]Np p&"QM`MFw{R"\4|]pi{N`׆,>x2 ؚ2 w < CW:H?'P *D]4u"f"rhH?Di?,ȡ+ 4"rSL b0W_ذ}7/fQ[ & >u9"mµ^ Ǩrxj:*lfww<}U4.Is-|e3N#3+ؖŠy< 1kyUjHn%PZR!--{sS.m]6{vmD,l?NxbQ۶[TȆ?mN)n l@Mz2K>GP[Y^ʇ hg~v+?o\uKlp@}?͟Ii'aއiϟǪ=* ہqPt k=`a)=xe+ISQH3Ϸ _NypzdͩfvtMeYys%u?7g3ZAʮ5~ɑfqKytWj+:|2R4sYym/Ma=٨. Фk\7'[<#|֊S|^+F01]Bm=oԝë/:eWNdf%rq`8=gF~+8q:ȻOLaɞ ٴf 0{nà4iqx=׬1$_gv1Vn#c<={(8>Lf^w8ڲO6i.qyOx|)?+1NY>)s:]wS'Ԧ9c$ *Cц|TQKmu|8ZO>SQs",XksrZ۴vl䏛h΢7 l;L8)쭭jnWK>~ O{Z_*65Y>̂u,Z0h^YH1TWpU:qXnjZtOyX_7qxh|syNqYTqw=nF![FFmW}܁ E'u`+Y|F׈GړzScs45Td=\rI8c5! cy-]ܻY{wlUs\F~Pw؜5a'1;FB6wk2SRrƱ!k&q6P[Sf.SO+|ԣܖ_ѤжS:5+Pj)Bq~˓jM!{VIG+3E\8vOfׂ݄W1w_uff,^Zw  u4g=:]+oob​r1Ovgsx Uڧ8׵CyZ{.ǚK.yٽQGsܻx_3dl~n==p9|,+I5Rպ۷.?rIky7yg_M{nC 8@ZW_Ċ~q`Os]hU4Q-@|wg[-wƫHZuxHZW[6u ?JֽoϷu 1񐞑A}~\ P/%4R]UŮ?e˦M?` YYQG%m >bE BTJև@$FYeYQ}"SL b0"SL b0"SL b0"SL b0"SL b0"SL b0"SL b0"SL b0"SL b0"SL b0"SL b0"SL b0@ )yLnx}_ {叼r̰uun#mCuٳ?ގbUrP8o,V߾f͒cDDƝ5)X4* dŏMgɌ;o]WK'rmF^ϨJNmۺiz۳$s2kƸ̆m{? tU=\tO;>un[3>j,rR`EZ>2Nঋ~({$ &ï/,X̝/.aЉ1qF;I[t@ Lpe%&"PZZ_cvh pP%82L b0"SL b0"SL b0"SL b0"SL b0"SL b0"SL b0"SL b0"SL b0"SL b0"SL b0"SL b0"SL b0P]UVs", 'ziZ/> qjVHuuuTUUQ]UEFffIt㓏6з_?ӱ,˭EcYelٸ Z?@fVعc;%%ضV"x/E8}%RVߛ^'75G:PICӀv uH.ۛ@?Xn i3rKkjnx_j>C`V*f-C`H?_PpSX+rKkknx_j>c}T N>@<@e x A0ir;{0-œi .rKkj=:~A ?XG :mZ֚@8vgK-@!E @@~WE`p[4 A NӢMr Ƿn p0r_ +ҫ?>D +t[#@7]mA(IENDB`gtkada-24.0.0/docs/gtkada_rm/gtk-paned.png000066400000000000000000000066221446021174000202760ustar00rootroot00000000000000PNG  IHDR!sBIT|d IIDATx{tll )*7A P.)'AEh^m/@Ak *VJEH K=-Z)$!aoIބݐn3'a}gy"""""""bH&sdbodX k4$~INj[IR>XZ z|X43"q a ~ wK<"UH|< D@Ļ 9|G\RD>@?Gb@Ļz!O|ڟCs|x@b S֧kW]|{_d{c{cQǦswWT\LmM [lns;+lWi PX]fL^k[+lW}<A~W7#/thux6>Z"SXL b1"SXL b1"SXL b1"SXL b1"SXL b1"SXL b1"SXL b1owEJ`<"麈Wvu"^A%F`P Q `P @l0ۨ0h`P QTmTTm40( *6* *6TmbqEA(uݮndMLRA}}]Ӻjkj[ZJA 8] A%@- IP>yJW7A:N)@Ku̳e=%+zۡmܰQ(,LK:KaQXI)Moj}}]5~ugɎy6wW%}Kn5@ub9`ת0|yg;N0W ВJ;LUi^Glܰ Id*]7jخn"&e( Y<^ף%} A%t'`@ O ^=+u݌ߋ0ۨ0h`P QTmTTm40( *6* *6Tmbb *6 JJJfbA%F%A%F3)D,@b )D,@b )D,@b )D,@b )D,@b )D,@b )D,@bi bz8mjR6K\[SCR OjR6Kklݲ96گTl͒{O}{;-"&%}Kn5@ub9`$"SXL b1@;7s3Z<4~jv/bMik׊ >wi{=Ə߭kOªZ<z=Fm~aQ&i @'P8y턴!7/{1-:ZfM[Zw0rNKSJ_pYnv2+3v6KgSwWs_~|ݛ{6Uϕs5L(mw?}ige3t4;~-:To_vOxJEK'P6Q߳U8!t?}t0 ;ݏ?xcw4_kw߫cs>>Ǘ@[Sq}cOwd[c?7l =)ˢكCߢK蟗Àr‰ݯjTn/MZ .m# ~6iPX80@?:F rÓ>S' p&UN#䞊2_~=o?-2ޑ_~~Լ Ɲ aqD[O F|^.^>,fI&NFAzy|?u_Y[YpLLb (a:1y䞯ӧ#Sd9ly!qS Ե '_Rҡ~rߙs؍;?Qyw9 t7N=4QxKuI]ܸ3E3.6]{ h[+Y.re?XӖ1Wny{͋Io?D+⽩L,Uc ,/8[};:xӏ//;0?u۞.S?O~5==7qgYn..Mw=64Ɲqe} T:'IHăt3@b )D,@b )D,@b )D,@Ļ$K'>n'B@8DKhBczd"POsK@$A>L\DK|C4 2l, L ?OP;si!EV4h< 'x/Ls4 9ߥ9"]XO h|8s|@khĒ}-C|p74D{j'f, yXz,"ݓy_+lnMOIENDB`gtkada-24.0.0/docs/gtkada_rm/gtk-plot.png000066400000000000000000002656031446021174000201730ustar00rootroot00000000000000PNG  IHDRh&O bKGDC pHYs  tIME8&ѥ5 IDATx}y{Y`w(Ĉ["H5Kw@E$Q"5,qHbT#l=k.{@twUݺ˹09s_q0ݗQmq}1~} ~=?9{8<7=[u_ysmWOt#{wffLd΁}j%9ߩoLmK5~;tkNdFYu"l3][fsQz:c,x1il:ᨺӦl6n&A.3I8#~U&N.C&qY+/x'δ)9|^(fs;Od1S,kעlS>n1o٘֒}6M'kds9 A {% x?gT$J hFkĺ]^dy ~_"ͺϜ9OvPI\2-(:H$o< ;^?G" ']:Zg.SFCѪ v.$p1Ǡ{?!N{4 _F[1$ DQ9$IvIkUm+2TB4w(VisQ&kX6+UN4Y :Ӥ0E+sd(0^ sD|ZP&9t Ӯ,ݙsvR)c8 5xTAYai`7 StN3\ANqL(Ii@R6OJ,O W4ͩB@(F`k;ovy ^-Jtf٤-K* QAt$t &3_!(J4L M-NN2U` `Xms9-.cL2S8c/)7 6S5b[{LNUd$'b}aJ 9TK.ePEXT5MNXs(TNYVpS9bt.KQ-^ p[z-4j&VP-zj /:LhYn:ePUB/wLa0Nus@fBtQ@SvI_'5$E& =%ik"P.~U7&)DwTUU G-~=aSW P6z\.\.G2)~, L&* =&IfQbMcK'ߩT![bwb(͊ȪPې={j3WY' '4Ua,$x@lm_攩OLrBOuJ I&i7]*R@ y R)p4d2yK!TJ%'FFRU)$'UZ ƑO:L`555QluI07nZAIz޼y3͛f620ar!صk֩#T ҺUQZ[[|?8.RD"ضC9˖-Ø1c5ba頕*%BCr9}yH7|3}Q\zhooWƫ]'>dom`ɧ`_C/ 1wP]]}o9VRSN}&&Ǥ7b1aΝ$Ͼ/3%@otN!f;qGk7t ɛ2U}n:ٳ{en۶ G*^)Sʺ .N<`ƍd2k`ΝxQ(.qJ3Y6<ŢKtɱh4ݻ=蠃dzjwPI3Ob`OQS],TWWc؁CPW[;i4܊uEuuRp1 m2<].= R1qɘkDuK-(9"i a&СCQ__vS_˖-sIi:'jS5eDR>`{GD",z?X̸6u )m^ ,T )ovynxWH$p磪8KG`YT* +bvR D6E߾avlG#0 6CILJuSɁa2a+61zwm*M=a۶+(@ 08 G<o#GGիt0 )󾯮O?+V`~!^x Hl&uM/˲p嗻o<ҥK/⦛n")aQIBh{\0]%4 jUX-JJp˜i+&> cgX,V(lkҤI?>N>d<쳰mBx|bؖe!ò, qgcҥ0ayFfcP0D.˲pGᜣt_'N;:::֥dZ@ 455cҊ5z {4!;oG:FXwϹhni՚:@E;1;iQV5Z}wδi`o.^x02|l*XQ)S<8蠃p-?!f̘>}`ɒ%ַݻwcϞ= lܸnOH${ ~:,˜1c\a G}4."xRv)0tҷUfE)B# H T_6777o˴8blF"@&3h4b38C:)B:*i׺<`aǎ];D18z)dOtVoU&-1[6n_sPm~C=ԥa9s&z)444_ d28ScɓaYz~~h4\.Zpqwbn.@4"R-6*LP'IҦOՆ9G׮]9G, ]ҴlpJ*c>699!G*Yj6Y&9V 2冷:x82ق5AQfL&*NeUlX&0;giC{ ~e`W^ ^]-bR)D"lݺݻwG"@XD.C$A<GGG$4"?3Ei۶YWUU!P(L_U_ixx׍ԗ߰p[3]jR R-M@V fף uuu)# ͮ^'glw88PѳgOMtݕ\1d2|>۶]!Lhi*Bؑ)BCe5C)u|pVWVl"Y`weYH&=վ{:1et~ =CG$ 0bR/Ɣ)S>(Ny׿u44ste(\RwTU oSMhkks'_[[i:!"] CIdE`͚5-7?wklV&ߖj)9:HSW䫢SR!?wwq H<{1|hhhiӰ>O5\\4^s}:V\nݺyﾈFؼy3&L͛7wߎ ^x!VZ[O>1Ν׻t+WkW^y baLfFCq%*gu:'.H57# {Y70JBDӤ c6s/ab۶mk0x`lݺ ?{,̙Çò,=Xpαk.|G*!&`TD'<:|8KՅ#Bݻw /ɓ'׿5 ދW^y-Bn0{llذ^z)N?tp >g̙3L&q뭷nFzxqG\ |[n$Ecҕ29WdFM *kǤQRJX1T g+/O_\:_%LjgR:.mYZaC h$)\AmWuРAXx16mڄ뮻s<8q"^~e\|Ř7o^3 &oX6e5夓}) D{F.]F1tPy۷{kH( /+O?4nF̞=r׿ag~Lj#p㮻q5kD"^gȑ[oO= N^u#ٴL:l52&jdEiѠx`,Y Ē%K؈>}`>˷X,""ϻʹXT&NMHq"Ss(t Vضms߫^u|WPx-yb۶^x&g~Uy:'|2_LgsΝ_ds93y2H3Ƹol5<ܶm^,>vP(~̘1;z=#GJ;y/Uj~ʮ)XLT9ߙ+ۯpp5yp꼷98o8Z |ɒ%K.l1sC=/~͛7aÆ񫯾 ~Gr?Q֕lt@֗ƍmmmqגܘB.!gf~#7yRL$x,mC4%&&;_sr|9jjk؈L&\*MsOX n ( .4gܢ(Ѩ˳8y 9FhL7p?ڮs3^=8{d8&oYWBNMv(HG*s*z up߽c*=C>}p-`ٲeHn:ŋǨQ`YuQ83.T} T őLiup81l0?Ɩ-[ЀAa…`ot#*l{vin ^H ,p#14I80iC2T MStuΆSTt[2'dnw|c$MlS2 9"dޤ@TvotiU6P-HM4AnSRS#LZ# ~1S{`^J+V06*z(0}t<~1cvZl۶ _|`ƍ{ӟp>s7| qÆ f7CsuQ8cѿNi"K5(խMQ5P fUr˘Ƞ06#ˁŹNbq B/ J OHA,ݦUd6@{&WDv#a~ '[>e~0=,0x:EVWG*ߤG;~9 p,L3?,י1c<_3зo_|7n֮] @uQݻ/<ۧÆ Â гgOl߾d}8S?| C`J0e piN˜ax9LߤPpUSBgC* ~,K,j5]r6L tЗY&|ŋf pahU:352a"2FPzDiݻcܸqߞzr;0a7{9~pڊnA[RZ1xK Lsh**E.3/vd˖-K/ta mkECE6M\1 ̤:[L_}$6X8P T6 f6P &&dSe=sLtڼy3";찊Jpe7 i]PJcA{RJA:&e dS$.bX۶jժgZb\555(j6aqzU;<϶B[ <8{wG.5/Z[Z+SDGss3(A8"v]nQR,! k9] Tjc 1&lذ/ƍaÆa$NKᖺ= ɩdwfCLeB҈UQnJإn4 7Xr%0p@Yek qXAsQt73_&RX8cwo$=Lf*{@cszAقԴ%L2젋U)LVǸ#>h;>ҙݲgVY$`Si~IХ5: ){_sup„ ?T,EM$_׬SjT`pI"CP+vҵs,Yޣ7oֶ])IWƀT HI(VnӫBB`mJ͊3 j\{~ V1 Sl]_Qq\]vIIM:婳>m:ZI  3qJxI]|1xUؖ-BXyN q?aj, ĉ1sL$ sY`f'THx)t`"yWc[[|زP(O?3{.p۷}48C`y7K 'xfmf0$)ȜW-Bv&l&5RyJ!JsjW;kC֡&TʄP:K &S8xUB۔BP,yfm\l9ɫ/!L"u+rrS" ~9nTMEuϬL@v qHt|w#Q1yg{jk߼,woMH&\\WW>@Afpmߤt Ɛ Hyv7)TrDoG䢳L\2DSp5嗁#J4aS 7B,@Kijrd!FƢ =S 2pʁIGu4܍? poߛ*0Cb%e4Ǐ,k+Gn*k*O.x~P(񊣘񛪫eYsxoUW]Ua.Ҷ 2Ey?rm9&nN9O&}9NZ,J|!Omx]>8iu!]nlm#jU\e3{\6]{ü[ǾZcOvk֧Or 8UֹsDկt9ƍڤC;h Zڞ%?3{m$I#1A2_=z o߾hŐ Wd1OhiiAK: bVcn}\.'4grhjLq>϶>hhN=|hy*x1W`5G'6г_?TRh+%l^uXªyMqo;w jcASŹ&̓ RA2|\_(L!w*r%@yҹ={"kC `*!UxO lEt)p%,,\\h/~ /ŝy$S+0$L55b0`Jٳ WѣsTϛnS5 ;p{|4I-RY')6keY7! aƍ?_^q~cbϞ=H&(ՂwyǘէK0axqo%oGy6%PU|m-a\9sXV_hj߹쥗YouUr>D`_y2(ܬ:^S|UUUD"|3x5`׮]@}U.î]\'`XxaW{LF^M$ ^(56 Eˎb,C=B<_~ylV;~{G ƮC-/dqx bn[MLfOh6&sL< .!SN;<~x&MBMM byy U[6 LsYgqH'۔=]A@՞M9Xh-`F]ߕ"(08 )\,}!{ȍ(1tjJl+<;K*y0T*BUUw5.U='e Ccz7"r1o\ 9D=pe-|a2w\\}Jmg?{,؏~,_^w &*0vdJ mJ,]VgbϞ*޽V> +Y-ßN;'}5uN B`)#h;) ϺrBaЅUz$I1JT S)(2 ^ 5\#ѭڵƁ آKY\:|뚜"TWW;wo ;s7~};]=/ļ~tزk+@FrS!JQimgo9 /VҚ^G@Cʗu&6:_Mk2?uerLw)~az##,BSS 6ԺN8.)\B!/^|˛Q2?OJ0 b1SN)/Z աڼT;:::9_;`򫯂"X8'ƹge թjD#QmbJgutm:g"II89dܼ;"3K(jr6z;w3hJTӈ¦S\I곚&] NşpvM O2=Kp;fm**9ׯ_8@%BIm^z)aq+Gv}xu5)hnف;ѷo_G5) e«"%W:>}}-$TR5Y@2E(f>TNB8C4uSJARJeXI N%WF /8 "u:Ϲ̱Fދsh?ڧNJ2mƺupr/֤x8Op~8"OtôqGM_Ë6b]3Ue13J+850ps% ;/4<:.KGҿ:7O}e(%A5lH׾7U4a6Q RЈ&I7"iPFU4.wc'J72Q/G2doذagNwƌzETWWcӦMX|rSR#5LIp`F]'2lFL8jfa^RTXh'aA.SN93gΔj aZY9uuuw, dҥfӌZ CP0鶔A.>XBGSTU#/cسg}lkkiR /-I'DPt#{ɓ'ò,X; ,ܹsqYgX,²,ض3<HS :D%*KA\\[%T6"ZI3Vp<&\|lN=>#z$-A* ̙3Ç{8sԩSQ,q=hT]l:QSbix-ՕqJnx92dTӧH"^|EZGDUVmO=)$a*(1TUUȑHĥWKūlʦFWl,Aĥזy׻%Ӡ}F{u+v+dKXXSgt;% y^)rb1vaX~=OB\.իWm0|xW0uTqds4kZWWx_~4~1xL0]v#,X% sJ[soߎɓ'w` ={D{{/Qȫ=655wh~8AHTj[jŌ:OU Bl"-jx 8 .mf҈.CB*!{-B{*Rn}د~~U@M* F/^RS:O:qu!3gK~g{3f#*9slo?ZZZ/{:o8,B4ER2tfG@޽;?9s&f͚&P<vP &Sc0(~D"8TkBPdP`:&֐,@^lH5JP1?^xhSgלDY$aYRЬ- 3/. )>o)T&S|ϔBxh&uaС`a>`bZΘSS)aO( X4v8,|wv~6 HԹ$d!&q,~Y)c!m`յͣEH6 7-eI9@|p' <X2Y.Zִ@@^*,(&:[ؤQw1S: 2ᝦ`Q9L f!Й:E.СC}P )+Jİ36KIW*jFٙ'T&!Ld)iMLBd@PzC @ __J`nXπR(C; 1 s |5u/&Mh ZMeDDXr:ԠlD&b6*z~֪<ϫ`6^y7J#y IDATSMZrgRqP0$K6WLsý^M@./_ lY8)1G:(Eli[6w#xRe:׌F˖$:%ȸ Q0P0օ+u&)LG:@D#P0vSn*,tvANaɺmt9ewqg0؝.RTlBw*FSC"@Uc@%2)E#GyuJRy? P[ߘda}y6X< k)zhd_/ T\-A %R&%X]GLXkBha65B]9lJ|{" \x\.l" Äh(SMסʔ !hW9N}F@VЍ%3$^P*]ہ~= HDZ`8 _U:fG%:9iaR) JViόQ1u=8CB\;[XQ&9"NtQU6eR#) ]P9K%Kn|AءMǐʅBcAg]9b}Z64pZ;xuV]Kece.P~7JtU2 ]`%Q$2'=ߦMn:1R1f|șXöN`hiYyNL ZMt,dT ]N2i$$sP暩ѽz3Y]wKmbyE-KٽW- HvYiEQ{? T 8X੒|Xjoz+٤ZTÒ5B-75tiAM)c sq^UÕW}rXw"sD"n9EM΃)B;0jk6 XaRѣfN y\07C ͮ 5۶qEᥗ^2BS&d}(%MBTZ(2DkQiG /%2HEʂʪ?T;sQ۲;@% f*| x$ &X|ǂ6'D9=mbixl Z4Uj/$ w"aُ '#0_1 #pSǤ-;ǧя8pݻJu8|iY.\)S6q3"H ӑKփ)SQquT:E]"tlCkV;#$3"[sӦT:!ºQr %`55’JuasġJP9sZ9TŷqeM7qqJ19O0\n.wƍ3rLs 'HvmV)g2lQSHu<'p #GxSM|aZ,8O,B{{;v؁ 68zhdY,]SLA _8 t!'Hl.#q$;:ٱ4LBW/ ݽ;=<wy8Əxq9 N6?DϞ=C9u ԙ:qcRHV[*]'`$"K.e65qH:8Fߵ@EJb,˗3L]mն9ƍg%SLO7j =zXZВ x?I:Zvu3WƮy+^ ۈ90i xjhZ&YG(m#HW^g}45k.*p,_?E5Qy#Rœ;֮Q#q#pb59V^QF?!$$>#`} DK"l+WeH9vdY--/~X(;|W(0vlC8W{(CUw,;aUuu& x. q,ӥ ԩs9mȑ_#a뮲R(0 ֪LsAaD6l)Sj*ر0k,L>vɤ6^Y@"(Nn]쾔RJU*kGSXOkIxm 7g2t^}/C@Y_ L8f•W^~zlٲ{Qs۶W{gdS~*{d2ܶ9߹_~ќs.~Gr^(ؼyMm^wV/Z>Y6k1cϝyŢ|_[ښyX䭭F`cqݻmH<Z͛xukK:]~w-0{55ټO }hs?//ߝ%s&̫lnX.X,\.'c6!}g]_w_zR7uٳMMMJ9Qqό%_'kd};xs\۹kݔqqx[[]yW}pB.! fQTEh&}D\-УC.ѫǀe,X"ѬU4z;<͋/9ZZ׍V`ؼcp@KlY(z`Xf*Ϟ=2&6}YUC߾] ]Q#r?5`R +a"dž ̅{.ĹP}H$QrHJuqf>dyQT* M6Uڟ-rΥ8ֿ'^nNWY%QAXD(́"KIh0hU5ZU^jl3MJ~ŀŋqXg8qIkwưu8ZV`|^Od~k:2pEO |9Uhk'̰q#"" !\ b~s4m΁` w^_*T XRa֍/n:iUi971'3LTX_j%MrNQXB/,V@0g2}Ʋ"2 ;45 MvP/$2O#B3/DTڵJ,Gp#ŹN;8սz k 9HX(zڲjLĶ3< G: |e¶K@)kbsP}yc߿ЕJ94> Ũ p*b;-T͐A2둪xUBFPxBLLs5IMِ*DǃN #SZ{/3p%A(%(@,.a6ਫcX^ߟL`3&"n.RKZ.C&Sq`X޽3 YtW`ho8l,|";L]mTȎZZg٬,ݻ{1m/˂#xHx)2F1)]{&ktu4HQ*J*lURxAST!MIR(CePJQaEe ASq_7 MRjaʝF^D*h%0`aY6pBy!% =ưp!w+4V3LXg) +H¶ -\ i㡝P9oD8O4o;Dm F4IUR6eF5 > SٔT /TQT &ҼeХ.Pr/JrƣfCk:pSQ@SXLf8)JP84W3'K/9N@q45O>)|S mWG Fڪ,v°W`sr>Cn:+Aȁ8Gȑˉ2 !9✣[7$ݻsL#O΁UO5~f34Ɣ*T7u)308U$Cbaulv2aZPdB_&GwrXT~4\k ) u4N(y-NF'YWLrWu^^$Y1=Y(Fd;2)o ܿ}O;wM }a^:^?J*yU sF]3UE>n.h $BH] 5˲Օhs*HR[Q(u 9kQ`׋LtsA%;E3ktQ>3jNH$+&OjBf=8td A4nв #xq챕2uV9nHT=b7?y0l!Mż *,(m6'?QT?7,EeM$YPb& JerFI[Z#*hrM4*"JtV ӗQЪkrSqYڙb#lAUvesrT:U:|.cFjxWvڵprYp|{"[Dկ&߇q9 tAF޽;<8Ô)̅V:: ˜zB-jؒ6Ek-Ja]S>!řD >Ǣ QWTlZGy*"MOݹD*I¦0J&eL:Meap).}. @XസBVZ`6F^N:] GF'2P]6?Pb3f$2AI~,n\|JÔ)ZXNe`*rAUWQu87e2 x$cMm*ǭznAsUASH(SQ x1}+bQhP3}׮切Qh{Fo*1ĉ ։ª*([N#TP.пlXEZS黹Y5zjӱP=]$ATJ!MNp\3-*]|)R@(LHWz樉 *_pw]^Q)QHFG!2Ӆ0Y@4i2%(&R %FZJ[ pUWs,X peG3v6&'5}LFd=z +yY(:'YOMPqFr2MBP;·I iU'SW 9 }0P)Cՙ\~A ~79 )Q[z;xo5.p{YQekotnhI1JE*cÈ 3AED hAFfH"IL7Ħɡj}S{j駻ϩk׮z׻uEBEϕ.zesY0p`:̓ov/ل{ ?N?!+_͂<$.bߺ7syսYfYuwYMM6kR[,E}gAI,-ӳb&M{6h0@4P䁈E t^*ΝɄ=]Y|f̐WY0$a(ƕi`ygHWj Ӧtk}{Sgn^nJӼQ5EWƽY)>ci"~VDIgٌb V込omufEV,GљD  OBI3E,f+2ޘJbī~jtYf O7aXXX8ɃD5ύz$exayCcX=s_coV,:`VqunuR0WƘ=|]۰p>[fJYQ8DMbe<#".:1DQݪ%m5(⭰l,*/eO1AaQ^9+(OX8 'DZE7Y#QTd卲<^pL£Zi6[xȂhv/,! Re Y^`hfl޸3Igp;><=L߬+^>/8gbXt"*aY:yD('⫚xQr^08n8Kˊ6˚cxgJbɂZ=-gSc$R0c 71M%՘X) 3 ū, ,/"jX"囬DEYFjD"x<`"Y ;yh?~P,se E`5ˑhBm,1kdy fs+HgCa<'3r :9瘍m+ִ5&3#JQp8 wRDh4\H$PUX NI\aVfVRmm-ڴiӧOáex_EܴL߫Z $kѣXZj߲,s-!AUUc2&&mv_zM9^tEDI7bDf%-ى@`0@a. IDAT/˨ beVQ-*8nYH$x1o<_YYY ",Y{ЬY3%%%pt [II v;[(BIIIڋ0TUw}y-w ÿk6fϞǣ^Mtԩh۶-*B3|>d @p @;@zf$oEfaVzp:i/B֭( <cժUxÇܹsK /?sq׶Cl~t:QYY UUQZk繲"/ ~b"51۟.y <+sYݢ5sLxDor0K(B3 .Dzf]w݅iӦ$hݺuŋy׮]PEK[c>|8#5FeR?KgyӿW%-EDeDDe CeqDQ`v"~Ή'i&\x<l6\| "5 k+.Bn9"L:@[5c vǬ}uK-oB'&3Ƣ","y""zhȐ!믿Ҙ1clLLav.E_~HQc'RUU7Q(2yN6a4aY}i\o̾3jjjLu;ae.am1)|DO}3{yA:rHn ͚57:u4JxlVܖGO$ w}aO0ٳ'v܉+Wbܸq;pw.2!n'{3K֋*"ZxfruO">-S:ofl~fA6ʊiUd= EWY+mM"AAA#ZK<*Kea<1|͂D_|>f-vRVY8a I+I#"1 Km'$"e6XpJ`P$feE,^)2@3fY9vAz+L^,38l`fV&ogU3g &+< 3vAɂe5F`bD3\(mT$ x1xsH#2O]/ȫChEbfgͼttY % ,T,|,̪ "\s͢,laUm*Vg"Ϟp4{>f/82X9"œA*iv?e66ǛEEdRYF}q{de+sG^z4O͊|`t,(5)Ųy~s}EcM"鳼:} 3Oji\~j,f3 */E<[tREy9o1[B"ƍVEEɏokյcX ƘY< *"uحUO,w/K -j>Rxp ܓHSył ,NY[ylƊ}4x}iaaF1[x# Ь)]?(5TU5ERSU5럳,COk̛p^,P$~!MVq}Ѵ\^LcU4(2^:t⹱"D:Y H@2V3D^L}pImHn4hF ܲ,D-`&Ĝv ׋P(ojG4^\wu馛G{ｇ6mԏB"} 8ZhA'O4kժ ԱcGdh߾}d#dLE5yVIȒ~$aE$+3]OQJ$H${I7ߤh4J\r!u*t:\.v8N$M[K߾}FyK֬Y5d""믭ˍJ""n"߲,駟ƓO> UU''$I8sp]wAUU4i&Lraҥ_Fa O$Ib1~x9%%%xװuVM$ /{ｇK#Gtb^WWg|צM񠪪*ba F+4xX"/D\U*4iΝ]vYgk֪U+?~)/DwNǏ֭[aQUU8v`ݸQRRJ0Y{4hHUU?3f@޽1sLp ,uԲ2ڿyUU>|~qIUU:s UWWӑ#Gä* YD<'GϣHuq;*RUͅU~Dkl@ ,˪N2[TmڴAqYgoݺ5fk$yyyhժZn IЮ];c_YѺuk4mN8묳6ҷg}a}G"tgӧf9sEAA8Zlk>,b+Ų(EdyzVDt̴݇xP6Ȳq?;vD 0{c!3@.!XTFxݻw7ꪫ b4hժUZw޸b%YտRof.qUMM 8:tӋ'ZAD!xz "ҁ)=H+lg-`VH z+Z˼tLcOʲaÆf׋X, ۷oG8,_\*dXi3&^Ċc+''zo[hpBz#uOFV"c f̊O]vٳ'7o5ȗ4وkfZ&fV f=$!neᰱfC45jW Nf ZTY$fRg Bx<1FERz<#⌙TSS$ 5553_ K^H"XҷYmVL}6 r ॗ^½kOA>}CEvv6}YTWWn#77˖-K^.]C$I(**B6mӦMĉquaPC=xGH> "BMM fϞ3gΠO>h߾=.L4 {.ك|zBf/bʔ)_( :u`0'%%%ۑݻcڴi9s&*ATVVb3gZhŋ7p7o.$b1{jfދ*Y" KBKʒO<=hWBf[!d:uSH>޷ق`Md2f2y<ɲ`eHXvv6@-{O>AnХKK뮻PZZ7xÀп|駨D4:7ĬY`ٰ`|ބxYL-o,F k x^Aڵ O?4t1cƠSNų>!C`?~<Ν 5j5kAaڵxԩSxꩧ{W0~x}q\(N "RRE[)^`IƢ *@J=+|^7.)( h<Ƚ<#8I<(pݐ$F"raFQëGU\.azzN<O$IFӦMѫW/,\Иn7E0%In,i4GQ#cH!vF <w].񸡎@UUŞ={кuk[{6 GQ[\r+4'JPE'i6a0"-|-B+# IDATZ\Y(k[<ѲP؅dXf kA ̒b cE^^: \ZS4uzym7ш&[4@ m%ěy UʕLtQD xY{.N fgX49b>{)+ `,E he"Bڍ")m4 JgΜi0}E.Ӄ1cFgĜ9sž={ 1& !:c {it&UA' E ;+۷cBA˗?$el &>3&gf^ OID}lΔ uVyzg*kD"Eah٪!ROe9ri{.jkkpB#;*i&IyO^zz,رcB:udDdzWSN{ׯ*++!2O:999n߾}H$F~C} >:uŽ;*l1bDǐIrk׮ŗ_~H$o|r?~_,2fqYXMf A.[n(,,nDž^;v'.rHcicVjA,;HDewLcGD(O$믿wܑΜ9^yG}bId{뭷4{lJ$c'Lz=sO?n-^-ZDDD/J/mٲ{rz裏>""P(dmժU1>,zDž&L@DD_'O?DD_]w7믿NDD&M;w2z֮]KDD_}k?0W_?쳴tҴo=VW";; =&U%>}͚5[d;PU.(YU}=u 4B55(,Hs8p8~cNY I{I448XznqglӉТE3dˆfm8|>O6˲ UU5npn"Uh֬IƱf5YYK2gĉ|{ 7`?tPl޼.^xᅌ ^Vl/tXI}GXl^;F 7}kҤ N|(--ӱm6!n=K^jK*T1c"D.),ʟ'|Gy8ݻ͛5/SjZCF pۙ O?<nl6,A"ԛexm , mB G2ypO?`R7e| yuO൵u8q؆}apa@(t$ aϑk>?~6;-Cmuu~t6{@ upZԛ%lذ\3 ϯ | Fq֬H$>_{TV ϛ϶.Wk9sYYYF`֬YxK,a0d,]T( X3KHdQxэZz EQw 5EE2rnQ)U]n3=hH>#`ƍѣ6l؀4k֬Aeن\))IFVV.$  YY>6THD:?<,qHM;IvL@ɉp)ρnC~~.v[Z0dg)T8z(&`eggu7hכ QMTVV!77O6(J\\ du߬RYekA:Gsmz\ڢa3rDytcud8ۃ,e;'rssp>4/}vׯmظq# oK,'"UUflmmxلIGt`YslK>}B: K$al6?~ UeetxuyEDx Kُ[NTat,#// G "\zҥKN'RG MJDhT$bqdP}rrPZ @86jmVRӢ! xH,Q="i ؀v0\.'>t2T֦֦P=K;sNN6p3 u M$I?V ]3I)ރQ" k E^vfvqq!;;YYYi?>M4A0Dqq1|>_}O X(~*qKse2'h3ޭrI pѬ,rm߾@ݝ@Dx:CU .WG j6[Ҋۛ@Q\QSSo` A\ܳH(ilp[h6aknKn "ݝ*Ύ¸ֿB[AdH$\R{GV@,J\ICۛiIj &φDZ.hg̚.WG$ dBQdgUU_Y Ij݃G+= D=NH$8>mH$ #E5m;Ks !INO[h[Z4 U^mÆ Klر(..?ldy<~~=zh?eUUņ d˖-c v?'NĊ+m6;v,n6;6cJeGtM馛> IJJJۜ9ssϞ=TU1Y`V`s j%,R},C(;%Q$d@UAJ4ɓPv{@f)F^^A$1>O)/ql2#v%T5Y֭vJ(> :80^{DGNk?\ίu\tڔ<4R3ĩ]$DAw'tyfn-_BϪ*TnnͶBl!@:Dpw!fAoÌ/i9P9Y{Oj}Q' dٮ=abfX3kI-˲a=+ݎ`0P(bO=n%tkXFXc=7|6 999ٳ'_'NĒ%KpuAy֤YMM qcӦM8tzݻw664|2D"XgpSʘZ6mÇoy~dgg .m۰h"<ؿ? ZhYBlPHD&Dx #<5B[lA=P[[-[nO;ӳd6n>}zjs9p:1`8n)5cߺu+nF߿߀ͩGO&bg|s_.ԩS &Q4+@Dؾ};xbB!:"xk׮m݆2<طo"{[l15,?^0N_ zoEEEz={bÆ ]N矏Of͚CiY*f* hvV)3,3K.MCUA}9> @TIj U-,̙1(F4F.5l6| 8 %6rmTkINn(J5lqWdmJVݎqŗk엦H$n?8%8k(a1HߞGEצ#41r 670f1}F<UB- ?pkL?9)A+?IBA@@ѧS5|\.9sưXE?BQK=g ȑ#|/jt_ѣhժ[oM7Á+V79s&δ| ݻwGII Fr+o~?4iGiӦ1xP(MENUUAD"6D |>L~Gy555KkW4Ń> n6~hp[)9E4;,*[%yc,C P ฆ/ ^(.) t1r8vfkXgVjq~KvH N4dYF8'Mq6mZj 8aֺ# 0hUbPLmRrF{N*3ƾQ֧֒ )**Θ{$GiT*RU'#"I2M" DnH(H(tybiIAҟQƃޭ"} {M燎vqccV d& l޼O@X褠o|&O^zgϞ0aBq'NfC$AEEڴi"ٳ6m2&X}r}]pKǟu"`pcՆ Nڂ o߾x<5ujw "ѣ!I:wl iӦǾ;\fYLAd^\*gUE6,$̣e?%1WGʥd&#݅@I$%pҾ+( ⨷Gsu)l)I*z{2V]]dن<Ȳ3c~;GjRoY6as.;`Z˰ۜɎ}l6ٞ2Q2o6n;s;λJ8\.<:/&4Mpv_6oF]urX} ӉҴk`xm""4iOFv I^~eu]Ƣt:sji9+ 3, IDATՎHcЮ]/? ƍ[iVHr--HW_= '?'+1o"HRȲM!I^qC$7Vo^|5HRuIQX= oxF> lƔ[PQ<=x=d?!cgS^C>]/h8 p}$Z@K9n 7|$ɇ/\"g+H>3Iѹ?A޲ "D fɲ*ɳxUYVca5-2 b1,]{$I8y$gΜ10aITY)mU-// ӤI$ 5dgAAV^ "oogFeeiłx%RE/ifbV#ͼ}; Vyy9p]ʗ #";ۇ`0 l<8<#eY'. |#xPU0Pl6"nkfNYd x+>mm "z=H$jar9 4׬;vq#ܳI.{ֳBQip:Z!8,j0ȰkCvx]?\"B/*jܘUUESؼ{!\‹D8v '|,\K?zӿ^,*e঑p˅&MѢM;,?pYqK#//Ǹ'+q c͚e x6%!28<7}l\b>|8VX!Y@Go)S HŨB^^|rC"T ly:\У B(**)0sLw}ƸLdL7?{קEe`!/3PaX!aIm/nWZHjq+ʵ4 yCҢ^G[7)t7n3`9AH^Hp- 6Iާ[z5~~b(Ǝ}*C"9qO$pu i[?_lI?tbËΝceFۈJ%N@>5CG ,@PO7[K+pv`rɥ%_`C>ˮ#j$IF f3qK_Z&k $ٍ{MNζ4t""4K ,Z1tXlǵn:1\c$l6{Ck@feDXJ{}OUWW|TVV"??D+WEغu+5kfpyd^AQ}+E!E3ݤnGvv1 Ր$Ӣ@HG'I2$ U @غ'- zzMu@tRcSt&lu΃Sc4V $_f:sb'RB;@g'󋠪G@U+!I-ATIjif@ZYn={h#p:[BU8_7rZ{z W$JPUN+ "$vðpNTEfO(֯*Nv}mU$Q|qzX,j,v3Z0kb^O}hٲ%֬YUUga„ 裏ЧO4(Ff$I8pi"@3H!F޽1w\ׯߏ: bٲe4hYbz(nO> zmR7k ':DH$tҤ7#Ihޢ4+p{bǎLʧO#h9f̘1V2bٰj*4o?#-ZK/X K0NXAw]fګDsMDGhմo":J^ջhDt&LHjNy!RuvDt^zi5t71EDG[Q4}x{Dtx":B$==":s5kzlj}DTF_#&Mz"z|I.*)Ns=LhDTFcHN6+!*hVҬNs>}->IѼhUeu>F%ChqZ[GI!*9/K+hh 9N_VЗp?[SԺߞ 3F"*nrHDiݺTY E"{iٲYZч;6&o]V?E~0[/zpqzE+W44ߣgIG8Ӻu egu=ٳ BJIlIzq =4opG~zgkaÆΦ*~6HQ=r"RUh.~q>rr` yOY &O$I<̃hi H8vMgBgү)rx~~o‚ ''86DzfS`ǎ?t4psD>Kdg '# aS/bYą+_e$=\?6/]'QVgu;.Ą`28].$q8nDA)7Y \/!(1߉kH@MIvI$#ZcI :f1*apDIl2 <E<y睇ݻwg/l `"=3^.ϥ&"b1x<L0&MbZqW'|?Q@=Czׁf̀x54H-U6\U: C t%g̙3sšC"0Qgã7෪;I'aDvuDEpQqw~n(:( "8 *ƀ(" ;!@/tVuS]鮺ν֭s=l:\騒6Q:"7*&i={op8 IOmmmrIP(H$濌4B R$|##D$ՁΝ/ISe^?lg"@2d4ex!yDM2bbS8ASS 7\16ɲVsS) ˵&`2L& ݟ7Q$zpdX[)0S`n"bA鑃xܭV,d6l02ho>?Բʆs9ӦMcIزe o߾F &`޼y7n;w.~رϼ=WG|؏(HOOߎo1qD!W{Ӌ!OȂl7I!0|0E@! 9C;}"22`! 4 SzBإKri&l"42^xUGg$TW2">'N?|ǘ;w."Ν,_ |+Ｓv*w܉'={,Xz5v؁k7pCm۔mt Cq$˨(݇ȘyyJf~?<"-- qmފZJ(ȱX " 8ckaaꄤ@ P9r5KR`B(hk׮8sLvgl-[! 1W;:t(V\]bɒ%,C 5k5kkA.]`ِё_2qDY8.觊ʍW/p8>$aؿLn]t1τb 3O7Ecɒg1=aѢ{Kn'=3Ƣv{~ 7o >|%nQoϸL44CQp|=>Y\GhѦ0e<|?Y= fHU'DnsБxꃕX|{eD_=|ywnœʼn[> !L.25ѐR(-o ;m el}SUJZFDXx1JJJc̙IqF+>l6#%%%"Y"5L5jjjj89:)^/zRp:CMM zÇc͚5Xn.UŢVe,#3#Cvχ<56)[,ș>Mӳ'PWǑ!->Q3ɹ4`0|8#Amݺ< QUU <*** IFɓ'>l%H7Ʉ|Vis'믣||A & 1KYYիmp ^"VͦB7Aѵha7>UA0—1{m71md&Z[PT™t֬=QNЅZ2("^6 )7s {[HMm2Դ4?^,"a|89K,`GMh`E;7'x孂Շ"N1>~x/~n̙3UUU?:HV1>VSNڵkn>}[㮜*i}w@E:uW<Q1;B; :ll6+lFqq1`۶m0L/b.6Y&^&[x9لnwp:b`HxeҶXҰ}/L$ۅl T^""J2x1;7ymm ?80^A..@*.MMXnL\w`2bʔ}@:qn&DxX1j":w@L`p8Z|O20kHOGEEc d!,YoV\|L8  Y@q)>~.`O?݀6|YHIIAA̿6xQJšmi~2v#bllh2A4FOa(%dAϞj^% ӧ 7z}w+L,,`РP.t^K;)['ƕLODË/Z0~x~bԩ\Zb׮]~wƌ3eB;QYM&}Yt }b,Ĵ[P|FMǏc _x0L[f-$W^!Vou|6DDLM < eM@$F8pGOF,gDlD#Ok&K)|<'sEd(%i2D$7oct."7plc,%E٬_wòebI x7pرhjjE @!NGOQC:h i EK'|~eпo B"Qnj WkB'Ww=kI-dxLxz XpnrV)))>:`0׋=z:uҭ[[[QPPӉ^z)A @JJLjUGc=8%M}?>DDDZ3\s!ݼ^}Km4@^,]0(@dYOMbސ L ˕04Ib[C=T(ک!vLUP+!} 7>kt$5hɦI[`faM:1zjSo(]T~@l>[ \.C[i <[pO + Su"0T%U*U8~GJPOmH0MߑToF)SΙ3FMF' Bʲ~ӧOd*#ųC믿$Ix<|v:U=P1ɠvQ Sj'tl|I~9=y1xxDhhh_SW^c'࣏>BYY 'EDQԥR]8}AUUY%sMh6_;+pgK=MvѠAiuTQ+UYL.W1[o-""b4*ڽ{#U?Q6 vjر DDg7DTC'OjkQ ߿6Q-رjk$UZZQ kH;v#*Fi="j&I߉ر{ ksy<%tq2 IDAT/RC{~QiN"BeSC>l+gDTE{n"*+d_S,5ka}ZCuu{(9M@)L-UOB$Y߈~kjk;FDtDTCտ,WQ =m$ItODTC{|MDU}0a,+65@" fbֱ1}6UL {)55nwRzw>|YӨo&""jii]n *..cǎQqq1E"`#:vFjAk9R=fQ]]effɓ') ޫHdY#GҥKEEETPP@cǎÇi޽N+>|=J(--MC$ID Q  R0$A_~9M0v;Ip8/^/ɲLPHW> ћoIq :PG|N43*Ѥ=b`zOQ5q_(@/8ӬLu1g-;s5'JS֦2eqVi#:zt+ET9_-DMPMLD"d3D:gMmv:QyikuL_^>K/l}jV|Nt3uDOA&'" 4vX""?~I&TMj`0HmmmdN֭[DD"ꫯPnn.\$}Q]sESNKtm|effM^W>BjnjVI"M2@b0/O?s0jݻ㎭z)F~ QSS'zYq5U&D['EftAII 6s0zdc51c;]DYyyۍ[rh^$áy0bs98s y}EXQ)jӼ23z!>7! '@0ߏ{_~9Uhǭo߾ jbƍaH"X ٳ'"3j(gFh[G-rq$S 1cFDDAJR#2_JhWj" ]H$]2g(TND>Zk ";?.4eW?j :0Z"blRV| Ž!"ڨ6&0L-N2JS#Z!H>y[+.>m(/c4e>3ul㭠vD_$uui&r8$I?vӕW^/[&NHv-a}]Ƶqǎ|#PnޣDD+Wԭ@sWSMM ԵkWꫯDܹ3Lr8q_㯾j 1vQ~>C\9eeed)-&L0ϝ;wRSSٳ'4qDٱcKxHejmmy뮻( ҹKMMMԭ[7OM4gj?z(٦j $CEl4E;f&i0j1fc&M~3\b􇒠,f*ZCrM%l$"#MZMzY]Q4&Zq=i;hx|x5)  ""2}Տ2\.'SSi!5/5?O룮5QnJ ˒f؛HB{XRR#>Ƿq`ƍ~p146m%[kXz5*++Ԅݻsl2x<D"`d^t[g]a$fA2 D"OAՍj@9K⣏Q(:lGF51RS###+1Ư5>}j-Uy@(>I&e,y=<$} 09K5S%v$2(o$ k׮ŁХKHow}7~z,\_|1/gZqQ~ Ӊ ˠ=gSSN<sK6v+V@5)&M6Չm|1>|`~3 N_|Et`rW\!DvQΜ9:̜9Sg8p A@YYł6D4'"&MdgnWonn P__>? pL& $a)$ ^ AZxFt:1hiQUniib:d&mmbʺ..9V>Ga 664ǟنHDb``YJ+if`Æ e.W^o6 I21EhnALܦHRHc&*"{"IД̚5 GԩS!"y{/Z̙31mڴils='u~χo$ v'ӧv!jZ;kFFFz!+222C$zHKKwȲG}3APvmܮ0<8$IcƌYm $K.,Cȑ#imۦux /͆ZKw]?o}޽7hx,c4D"s<_E믟DD㏫]MD4aX"rj5'IT]/~ԩS5cg39h.!*(Ew5R*./-_ZhtMWGo^,yJKw{x`z@Ǐoco/R(T|-Q7RvK~/55g?"rŒFPYTVh͛?aZNF4r%.a0>%3g[_.B~e6bׄ~̜cll P(&StGS h:H1-I?0mF-0@|'O"->-Poߟ &>O&O-"+ E4L<.lXLׄTCRQ233Dp@1V{:;Y#hVMZ[mZ( ،2j6qYQ\\ UYڭd&ǙJt o3o5}Usr*ƦW!UijĶmxvr&~0V6g1[La휈tMMۤf} '!I2z=٬&256+,4+224`ׄmￏ:Wy: #whF?Ij*|ᇺs^mm-z{GEcƌ1<^W*9%%cǎ7̅\---k7] ھhCXt)`U]wɿ+1L曘;w._~p8aɒ%UuݻV ܅cx㍸+1x`_jl`ӦM8p`\l" duu yh7χW]w݅O?^õ^TQ9"v{oYY!x<e2A0g,\1DQ9k2+Y0E_>3S6x|>LtښQ\% A(x4M&3RS0zAo]w`(,Ì~ зo}acHMM1yx<6ޘ|~Aݱ+InLp }Sug*!55Ѝ2i16 yEѣKuVN(/Vc*Jҭ5?< ҥ dY_|;d,\0~n_lǦMti樕~ɰs(nVQU?:55W_}5/֥N@<fq8 łݻwŋdWUR6z"1~"L:+W_ ]./^ylOF7S=;N'U}7D}^>V+{1e- L_ZZ*D ݗC((lJp^1MYY glΝږh_^^{LqbD`2SU&53]߸/7lؠN tM96'х^HDDۡO_U%\۟C6}wY3z6bL{װ=pM]tE{^ˋ~hmmbG(j6]l#`ss3PxH19Sv;B!!֗ro;Z\2(!a;lzڸq| Nkt ߿7~q%233bbCb1o޽1UQ5$";* ;z]}dno3ȓ( 7?vÆslɓM2b 0 f^^g81eelx'pB" YYѣEIvjl6|#ط0&Mmm1׋ছO?E 49׊dg#-n9|pl6|gx'f 0 !Hѣ`\}O?322t: Z2Z]XǏA'nᆘ'䫾~ vEPY8qB va6gL8:K/;wC& /2~G<2eH$I<'Ǒ_'^UU=?9+-*Bvv6DQģ> AЀB+Q˖̙36mldk4|WXf fϞp`…Xtz8s(h)~ⱬ;"tV( ]+Vİ-!,VK8c]O#@/4@ڎ՚puQ FZFb- 1JSLP<&]}eZ-CzX6)h5Pms$r|Sk'+ӮQL;Q$Rc,W{ Z&amT!喩,[7,c&: .Z4 nݺN8ADD۷o'"?uDȋo7***h4xU#p5 o?M>-wޘ=z륪*ClBDD\s -^Y as,^kb[6+$Nh7nGh}czt+]v)IvUP(Dͣ?p}$n.1:8:4põL>SˈG|4AADvnwe' /3;B~hR4l9!:C+af\8elQN뮛 0XUY%Z!˕7(fSF[AQEo9L BjjFqxҤI\;Ct5k:uCD1%I 7܀nݺ_ſo߿%%%1b\.WBv"ߤ]|9&@RSS~zC=dv A7"mH{`n|MOzY<(1R mU}ُ?8n=.@@y9УpZu_ dgg3*qdĉx\pիNOEqRRRd@>I;t2jMF"\^RQ~/^ xʸtʕ_(bA~MS?ȁ(E8Vۧ]TTl/n_PjkkcC176מ ظq#^/"LH$m>|222`ۑ]v;Nlڴ =~gφ .hmoӦM͛ S}hZN 0VPP[,xu8ܼy3_PvaClxx=ŃQ0l3{3D΍ AMLWC~s>$ReQ!-llUukqׯЇ IG&E###W/Q}-zkq(Y4i)G-lt/8/VSMVfG~DMl5G3Ft̏_?(504^#/Ʉ.,%f7AăAqg-Z'b,… uG{܌3f`̙HII|,Ç#-- HIIqԤ04O>_Kyilv}JR zk%I1D0||1m4{rTu@xFc6%%W]un6r-Xv-9##>}蘄1,^@@W\\cS;'B%ZEHB/+^E܀Eh,ˆpV^3fa+,EY;l, IDATr&gx yIss/KzQ}S܌@`糶Wy`ذ)TAŋդH`kl6< ﺍC$TTTfPСCrJ]Ys2A0St9諯@2IkdpIb„ (,,j@ QFŠшHn7oIeQFDPĜ5rV8Dd*O?Aq. lY#TB>U ҡ]9(ejaР8$FVbGR=Pojayzat#CSA{5Æ % WzБ++wqR :!^~AnSڧ*-ɵAiDKUtSAȠSII 2z$˞-imD6[ohVF9NCah6vr$I/.R]Fo6kAcǎI( %Bqx{JJJx9wޡ$9TcRi\KldcŌ򭶕fѸqhΝ1v';2ģ&F?mN%%%8p .dgcq.f~="Aak[4>h;[mTl6vu!yJ*O>TQjlTd23U.~Z-I>\pȲꫭ$h @Bx, :5ga8L"^t63}ZuT>jdwulj$뀘>P6/"91c&K?#_%_m۶!++kLU 5l޼qMA bV΅rJ߿2"/]+Y,bԨQx<[^}'Qiz(&"Q\~Y 'p8]vK.]zﾛkk5,nV>I&@D`0cƌu\eYF8=!"j "᪫⮄lTUUB28m{!;;'OԹ wޞL cCҥKq!=g=ݍ72hdeeԩ\.ȩuQQ^~e^`A/#.?KV}K5rG}￟W;GCcc#F4\|h47ۑʴ@VV&ZZ1=W[nXHT~PVViдf^?eUoߞBTW-48N[ DIIYܠRjjJֆ4/˫cѣ+BA/|\ÕeII9 ;'4t@ѩS!0W"466#ZCe>]sk8![8.A&ې c…0ꫯ0}t|>]F@ `4eYƠAЩS'>;v wy' 6:^/Nj(bٜ!h~ >|}+VojE]]_,P(Ԙz֮]YfŴtrz^aÆaŊ1J @FF&O[޽\r ^/233fx^A̝;|׋HOOSO=%Kl6Ѐ^xq~;^lAqq1 G$R3o]~߾} Q^^nSNU'Nرc_j٦#'7^=u}zHxS4RuQZ?GANN^lذ[lOúuqE3k(Zdvų>  A@ffgbI}VB[e ,z/\sv5N=~{b&4A^o!9%%fs7|F0^o@ƇO? pζ ĴtcȫcǺbIQ,{ϞCxbH|x<Θz}>?n~ Œ0YRSS67|-{4iS 8<D"իjjj`Z aNڛg(++CSS_566⧟~2Trչx.xh'u;d+/^z%w}Z:Z8ƽދ+W!DI oǪU҂Ν;c„ ?8pIee%.\p{0i$ >81dÆ q)<|rVܽ{w|ǐe(deeaxϼ_n7;3nox'us#W$ UUU۷/MrUf6soeI:SIcMgeeч*A\5Z|eĈ\XQV) iU|ui5 a-/^o-.R)M4ezO Jۧ[]0 8|U, x c뭦=YH,y}\>:_Z9kmϩ8#嫙4M䣿v tur%y<%t?jIM&m&"7zk˾}M7DDEr-ZDP(i8Y [Νf%ԃ6?7|C|a 0:p8(//FI%|3fi^'  zϫh-ͼ'Q$Iim0-YV$͞MF%GKKKjjTeJJJ: % > p0zR__srssΫϔ#'C`mmYY(-gQr\ktZǟ}Z:\Ӯs"+V>8 ;ۚˬ̙%233@T K1Dh DULw:b! c͚5?hh_vexk޽{qbݺu8~x16rA,ӞJ՞!UðlUUUa<ƈ}ҥ l6{*Uv)))A~~>Ǝ2ju~6 [aa! Q~8čAk kWؚb*ïwp81>7zi_~%uE .˧&lGC s\ z&t*}Ki+jZħn by@[E8_].7!*"ˢa g9SPZZ A`0T$y.Qѧ֯}ɢ⟕:#i 0w ZD9v{5Z'av!{1ʅYt8BK0bJ5wc{0'l<'&k%Sp8AA7_( aNAK@v{ [!F?##? u\"^-aٲe8~8GiՎ.]ࢋ.{f2p7b޽xLk.̘1ۤ xl6@7 O@@P(=zO+?g}_)*txJIR}2F:B@I&C}Md$h[SSS~#r륜yIfŊo߾}ؘ1WNbW\_~YHKK((,,0!.klD0m˪Ut~1X{(}پT:]Q *^ JQ{AT.x*(HU)"(A@IHH9?fdfw^}m3Ϝ9~*, ,H4p\pxkbHzvCBkɜZ00; G? RŲlkjNǡ)u [.e+9ڰaߏ .`„ D"2DZ|rj'`;wF&Md P$ۛ?Kư~W_!?Dh"DQvmCVV֯_Om'JRjj`;d¯ vƙ'W_Aop, z4nX%{EѣG1p8TT܎h4!C(3<#2^+PDliK ܼy3JJJ(0S,!CRzwT4'O\f !qFO.N69M*~„ ěJz.6R?{ S ~nJLFYMGd7|rݙ#Ο@HEbO":|Gի'lق" 0ڷo/[xh7VKb| ;Fw  _Za[xU6 qSNVϩhJ!0A^~X?VzfB<W?qJKOlb\n0g8֫a9Ņ  aaժU0a~iIڜ,rw?&"ϟߋAWM۵kg8b #BwüV>|ǡkN ]#d:E1ucuK1ÃS$,6n/F~V._>-z[Rr[\9U5ƈzI/\ j۶-n7<~O fDHz=>s>}={=|0|>leT[|dAyȣRv;X6_2$Jłb:tzԖʲ,}xbbp݈D"0鉡{\J5 p4jpBpqB2 222v%%u&`Ϟ=6l\.]D0l4o!حx\[o3gRP0D$u]c>@~~>QB56xl8p[oQʁн{wٳGV0-I-+ 6EmY$ IDATXE!U[kZWNceR\+ EM:bKK/8#!_onw36MPt_ݾ#Ș–hqjxſ*4(I`%>|J~.+DP̛֭۠^! ahӦ nF?~<1EZ{-&IHme@i!V 7ī.`?$J0h:t]4uq,\P/_.Xv-uر#~?Fm۶Q 6<\& ZM~t޸:u˲D HǑѫC32΋ƽիNpT1!b?1fΜBIpVbl5NlZ[˫d'pR/&t|ߘ:)I&>bm_dN{kX,TVVl6+FкDŽ333 ĉիVZ&Mw煉ek f30%]H0޽{%+FՊ-Zرct |l6 $v(yذaDHJ֜tLR!eUW 6M?~?~߿_$r$+`0mٳ5'yrwyG2.@M4AQQU 6m,XN-B/^h24IoTfɠ"N8\n,͊X,NZ7t=8nٙu"77n GzD"0Lxp8Xzt#'' ^v x$d2tsro"D"Qa4qnC*|q<3Q!XS`O\bF$RW^y@^v{:7D|TO׃epPFuu.ftC(N*B'Tu䛼KL'… c0a:~OK'l[A^ a#{o)</**`0-0,rso`? -[v% ^xa6Gyy7a ͽz}K|D"Q? kn`fe^ Mo$+^}6** 1kBo e{3r ġC'pՇSi{<7ךD`Y ڶmᩧ^`}ڮ]?^;,GYY%b-;z|9V>w&Oqx饷8ШQwt,\:4ir ^}]bqw[iaѧ0(- ?9s>^Z}/hT!W5JBa7~W_}'O|",K qDKBV_^xj3 p8)U[\f=d s7*NJSS9ӧz=:v숺:UI`ՊKQYSxQ&MT=:x`(LՊ?طon*qx*3Ԁ 941 e G׮ի)0H~oM 7ߜJ<ìfT, iUBWʟg'ITW{q:OJ E!1H!NCP_+&3 beb$E$oG,^D䙄4bm=NrwFrmrcvIF/HL B>Buu'LRYbƢ=$jvZ̮t$ XZfK )N|GQL؈ǑX,F{=u$77Wvt\avSӢ'Ӯu:caȄ 0@ @8U裏dyBqU|ʹ؇~<&aCB]i_J5ç&9FDTI5~OZm8m$>̽uv0;a 2\v{0m$6Ꙅ|>N`zBa 8X)M#-`F6giU7߲jqvCN:ifŘC淘D?4ڠEm6UnI5j2"(>4DEd0 zMbEig\ RAOzpǎt5+Ks&ɦde%^e1h ~gvѪU+TTT|333qȡRrjmv;b *Nt:aZaX,>3 з?4]WNu?RJRA S'$LgXkb'9Tȑ.b;oDJAH46KШQn\iXl6᧟V+<@i*GKYC)Muup>$pѬӆ.aܸGU0hv{D^^NKwnr:"qpܥ<ī$[`0-a)YS;A6BxW^X>FkƏOc >`]tq.\HF[no;iT5*JfTˍb1DxlRLi~Xٳ,ۖR˨ nA0AapQzF\D:_];garq q 8l^FBM@:7t x~'1p3Eeb杴^zJ`0Ti(3fGJ'aٶ )TC02Lpwx饗h1c 77>DWQB*d$rJJ4;8Pe$\<Μ9MR0.YmUVQɓ, +1ydFb1XnكwyǏѩJ/`0cRYPׁ"3]xQqG2{l<`YIW F8NAI7L>}xɋQiXj* %A %5p(I`0`ҤI?>-[qaΝؼy3n&য়4`˖/yy98mۣp;=-[6Eyy%UaY!U<;v1 m..JWl I7,CH?Z+Ow~DضWE90زs 3RȰB4vMv.΅Y1b(,,L[^Uћy-!Jgŋ/gy:/nJcK$w r&a8TB6iW_I3Ռw2K LB@[4 :_APj꧖6`51!2Л`^R KA߾=qe %%Ѭ٭㐕Ⱥ+LB@LIػwo|wX|9mFѢ"ٓSaCt:y$Z mC=)..bcB,-lƲe駟bܹ3x 8.lX/+%-[য়~=8åK(SrΜ9-ZPX)Nki֬9G()ӫ:\|. quQGi@ &0GAaa!8 ѥKL:6H$gΜ`kkkC8o%KHf0j;:ن0\6l؀#??elmݤ顩Q0ޤQ_n- IOU J_^QtM{q7ưaðm6z}QQ>괘%eЩS'1b+**дiS+vŋx".\x<ر`pv;8 /Gcǎ~l޼СCMYfhڴ)fϞu=… `Yڵ`F۶mt:)D˖-ѨQ#j mڴ˗/}7v튳gJBTUU!//p8lҥp'q VZUQ"PN 7܀~htoAٯ>ƩHDB\)%)T&kv*R,<aXͯ $*ԅph45k$c)M]!mA4 UW\ ,'դ|6*%8XQYY*'-^< 39,]ډNd-n]Š~;tk@}ˊnn@PaӿJ*iJiك,^:tt: PPPSa򑬍!?~_VV_`ڵիW)h4^r/7!k-BV à7nC=*wFUUd̲,Kt!e`TToEJCʨ]۠c/BB$BCUBH,[NrBC⿣ԶʓL rDiCb'l<9Zzt1F^؉m9 JOxSUH+ ۯI󸘨o|)'LBHQh3ߧ!6HtFQ_ }ZE)M۷(3QDUƬNfNu'Klq7ڌB^O|XFXlYajjjۏn79tĎ"7x,բE j_pj~bZ$nmۖTWWK]|9 ^h8Nn7nȑ%KQ} LW&S2J!˴OZs&*]S{4C$r @M¤2u0ۣ^-2qMě<X U  o^Teb%X(_*MS~a #M 'W٫OÀWөACzӦ҅PC!ȷ{nPA1xN<~xK23[DЧUI&*!:k IĘ&xcLJ]%u6SW-r_~p]wѭߎ?7|leXb R7sLzaX,t] c]v0%#1<9̈{NR?Á]vf)Ru:JJJhW^y%{n… TUOWWWVL !F~A"(zL<ū7xCFd!PrxҤ?8O{8P(DTщ4qZP%6Aw|ob"p|$9ddذ(97!1lvR@@$ϩ>"DPmmv*|:i 3sp8I'*Tkf¾)MݷqR')x:N#jl+?AAff&Ʉh4hśo ^O''N۷/NJqſ 0g0 >X,;vLOpXV^0 {zXlYZBeqQ|>Z & 3f̠9~8._ ٌcǎ+Bƍi KWLlذfYrD"̛7O";p@fi_|,l8k")V6`ӱi%H bO|͗ٔ׭۔'&x } cl&ha"aôI8Is\-{w7$Ԯ$B;ƍiaE^,qM410qjNqѵR& FG4]Lr{kӕ5Y=0KT+I¤4"''v]&tM7BH0^N]uʕwy&MիW)zA`S'֭[j.';}Ql۶ v'O… %x|8&Mya)OB…  0aq=;])~wΜ98qYiDrv9Al Lٳgo߾Lvڕ֤$LF !iUVᙙvDE(VL͗˥VSkM)LLLZ$%4Ꮴ)ywҕe[LKMH1zK߿?O҆´ZSZdeea̘1*BrrrP\\GyD&Tb'|?Sv_Z3fS\nn.%pU}qrrrDШQ#:) իWKiӠFdBEEt0:t(j?EæM`2 em|0i$<䓘6m}16Lh߾$Zݭ[7Yy6H $'vqjއ֊B`0'ġC駟ҕO}bU+sN'OR60TLO>DbS$p 4n04x3f zx%uߺuDUl6<YYYIOxuشi,Y"aݑMZ IDAT \ N^J7$aӦM[,X+WӲɥ |rD~ۨ_U4lVwWC >xgfQwqE^DZcᩧz}iLJQSc573q^H<3Yq xqxo+WSp:݊/Ōg}^v.0ŕZ+^| {1]rE/!Jg磵U{5lĉ2H$㫯Mh/VT?֭99s8ABh׮o+Zc6m2f,^:}ߦ\O;ҥK<_D `2hd[q!j駟}v,[LoX֎g޽{%Z;bdj%0;-p<#? /Щ'Ơ7Ov |d޵ !o9sNI2jPzq\P9_DjjB$9Pn9<q:O*`riav2 v.#V*quMӲs9r"=zt#WD.$ƏpXk+_]̮݉D1_BB9M"uʨd֭>|l޼եjѺ`vJٳgɷ~K$p8L<>kՋ|>@_ɴrK>^ÇCJ kK.'68N[40>!ѣG !lڴIvIvvB j(W^M>S _8p!@yWsѶӁwK z3M BzŕhUR!)"H &k`2R`..{.+j?o;?کhbR}&xSM;Ϭ4& gED ۇ^ &%b QާWF$j6m!C`Ȑ!7QEvqd%&Vc>G_;vDNdvZшoGZؾ};UcY999 veeX͛7E~~>oSLr&AizSOI kR's^/ۍ,psNL7aKL7!p,ˋiAŻ˅1c  ķ~TWWI&p\2^*%|׸pdLMDIV b:.~kZ d%?X w†!&XD"Q#Q{M\˜w5enIb4~$SғNKQJGG8i6e]*59\.,ZHr>b֭ Jj n@˖->QXXH7g-33SNܹsѯ_?\pO /++CVV 222~1ۛcҥTTTH^;###V}ŀ0o<̟? .D4G}y2dI^$ q8>,bŊT8| $Z8Ɯ9sa6yf`ؽ{7-W3Fj*Z WjEzFQMZ_<3xǰ}vհjѣ%QPPf͚hwUUUPܹs 'Č3$DŽ V[nŬY0}t̞=& o6f͚֭C8F0TؼysƁ" 駟;ɄScϞ=b b+ bEe˗/Guu5:t@(<=%P(qƥP"(ڠl-R:L&@ !2ٶ+c Be2`@/BHm¦VLmlHMQRRB$3NJ\SJ#!|sRLFL\S.K|;ɓO 9r|{4#$4k֘N-NA'Sh z+Azm:)r"EE{ɬY/=COkHNdŊ[H,VDyOY>C$9O !WI !5߂RG-z? xNɓYذ`1 ӱ+kI>!M6ӿr-JnT(x<]vH] `nҥKM;f:qR/_VClNN5 T59xvqxb-:^PHڭ2 -_FCb*tTmBN L\H8Jo#I] BH1z!85L^}2D.x" BugO 'ㄐb:) :JRZ))+#4 4Hw)/#8% U&H',փN&ui 'ቕ$kx' zaҨQNiʷbڧ55GɈ4_HǁO~aWɲeXx<I--=@M6YBHTW!{EBHLCk ؙ|? `'NH8yIvdJNT: 333IUU7*j/YF[lQkKatݕ&JsSk GS:J+_9XdggR0ށ5Lʤ:ĉxvvf†B1eY:&(.'t:="٨U OUWƜ9sl2xp^ZƄSO5v+Ż[@ ѣGKtc>tP,KP(~v{n|g:`Ϟ=?,Њ8v/b1v0=?EIϛ`6קۛPmPHJ!9ϟ"7U I:^}`-B-aZVt!zJ++{hl# J:h BJR;V bE0sd}l$tim\X&wHB;\w%m 80G#i'? J':SqӧOL1ثC-ѲeK֬YC `ZpԩS1uTʜK~!3F},˂8?Duu5`ǎXbp?EX M4A(Bee%b(Rt-$z& -[Ttd\. 0nq䅙d•+W0qDD"Y㐙I:f'eqq1.\ժRcjWZ$tz 駟q>}:CդhH()ĕ+WeX8r:)kT8M;#§3 `g |ڵkj$ρzĈ`p5<2,+%VcPK5UڵtۆG !^"l,vXs #,ڶOwVX Nţ)AlCYY%F 0mߏ#F b_~رc1|p XQbw*u:b9p8x<.B-O=݋&%pɻ?FªU$TQQN'n&̟?/D!aXV|0 5j{9nIoqypK,/BPRReѬY3D"XVt X!hٲ*,++ Xt)jZb0LX~= ;vC=֭رc%}X,b̘1ؼy$Tb`@<RNld=2a屜7o d2G͛e΀];$<+D"_x75k*Ψ/Qw|08 pv_!UZZ*7Ħ !^2>[Xϟ?{/B7k W^0 ;`P^Nj/H$"zCѱ0`uD&-rnFY97pjkkQPP˅-ZFz<V>6aÆIbZ8qAkO?|2֬YzHFj"veNxh1Av׮]4"AB w7i;n N#:d#B8ESQ>|/b$kYtRӱ[TrRâA(ƄeYAYiK *,^<_B!W ,C]Llc),¹?|7Cee%ƎKnZN%i)#??ѣrss%͛7GNNTKw^#޲MW@aa!5/ ( 0ejzr8Nt˗/ 1S@ Eh4b…xѢE v*!GE/Sk-YK.gϞ||bQ&> ՔN~q N#ø1e x7[B]#y& "w5##CbkLA/%4ރCkFYnC”G0u`e vXL$ x&aF -zqp EǖPX|__ϛT̖|ԕVd &: ϓ0>t дQ6|~o3׵4i \.7e PKPpů^XxELN3 y}5Ba-P]]+ZIVl6CxXdΤt0IX:N:twcTWB; G׮]ѹsgÇF{QSIM/yyy`YW\ apQ̚5KvdffvĉGa <#F׺\.q vtʢ 43f?O,YgϞ~q_3)N> eON~Nt,ѻ,!!@ǎzjI=Ϡ4œu]]v d dba Q$K$\IL5$|#ԑl!RzNjf˓VĬ79E&LA9KΟNVxRCn֎\J|Wv$)1 SRb0})Q_D:k=EBt@6Ths5޽RNV93 njy@I8v$9OF/RC:th#csM:LG)gn 1 2&%F!֒w}tޝm۶>|_FTӧ`;$(DLٷ 7nxe'!_H"jkkJY8*~ðah4tW^/waذaشiU^ ⧣dfҺN b_8}4EWrm۶QTx<-vڡ"F"//@fYsRTTqaǎ'nG$df͚nKٳҥ 5$ s:ŢE0aIPSݳVVg==|\7jQjNȗsYD#"$3e BR3 3\-t4͚z3 F3823!ǜc׮Kt8ƦBUezhr{,ggNG;5J!x|i[`ؿ:wnEmV91Bau<2˕hѢIC2 0l0=؜H ''3'd[D5Ȣ046_]]222xv~l߾]&؟ fL5v]Na?#??_Q믿ԩS+qϞ=t:1|Xv-~aDQj%L¤(<½ , #66m ?5NI IDAT`xG%q KKK1ydL2}Xk8w(**vQFIqؑJ>-YQ-_8h)Y/7]e˖ǝ)vc00|pODݶjed8h$tbTc 3Qkٰ- (pm'OF&wЫWoᔑbwWGq*=Hi*кukt۷oǔ)S￣SLTtM/5W_Æ (%? ,D0h ?Lmsq:t(A֭iX*a0h l޼Y6'ճg :x/28\xQBlݺ5W%Tbn%`ڵxjt+j;h%T ZFQ\P]w B%( !q8bb8/N8?;81YZۋ{E؊?Kҿ?&k֬y !{!5`'$ x"UB nH|0l@K([nxY 8ECuҠ`\ә7ٍ_외0J5aoӂrnr _=8uJMl߾Tc ZB{:4$IV&(ND TH#[ՑV^7[myF%CUA} áY3{o[3j gx<OvލbF2VFZUU7p\6lUVaȑl(x駟bxgq)۷p햗cΝ(,,ԴEͯz 5qs"yTpSЈ?k8)wQ CPG 8^_Tm3ŘDcH@SYF,3Fb7pm @ZZ/#Adjݵ)4 .C(FrbUʸTS0In7SMPY,`0ޭ$b66FތYz7nv؁t&᪟IR9eשS'/^Ā|砛_JhJ͛7A8FQQۇwyG^͚q7EӉݻwԩS QCQifdI֞S& j#9wXy1]̠ !c0BːAڡbr)98EP^ ʢNǓI.I(3VR2_#7XH xaey靬l~hkp($fG-{Xhb2cVHP)si_xVxNVV"K݋֭[ɓQ;̙38s KaKU7j|ܸq)))wu8DN# HgJhXVV۴i4x<:uN> Ipi:u %%%Xr%222Ю];wIUU/97OP8}4e8pp|>[kݻ6V'U ݈T`XӮK' 绎Dk6i}(SZHC雈D"ص} o+j{$ކכ';V>9;N[hja@NT}H\g,S~ǦԱcpKW1Ǵ^. B)xׇ̚EEEv "$Iðap- ;HsV?#&mgC7ꫯ.\[$ سg-Zۍl8qB1ڇY2}{;~ JہЦM-p:9'N@R5 H$'N0lԶ{ ?=HMMEJJJTNCIP6mTU}#GpU\tIӿUO222av52Y?x B4h']vXn[ ?~FX(I{E"hG#v_2F "mZ!Z2&ZtKF2&{QO@&#%hCcI\?-"}BRG~ EOHHl|K[p=xY޹s,!O򡔛ŋcH>~x\x%%%6=UFGXqmڴa JlR! !"$z6\A,h̀mtzIƝ;w9ZZZʌ]c},I+ !V-/z 2nºuX&4bPUUxM Hﾻ֭;QJIɳX@ +> r hժ ݙ?}M  bٷSN>C3+gbqӦ;o2d-1`2ڦD$\V˗l46(j: +V$s VJJJvq CV4w +UV={6NAŠ{3OM ܹ3V\$DQdzUVWSS~21$;O>A~~>222pmh" 'q9r&M`jx Oa&\[픉oXͤgQYL=Z='Q- T:m*5%cy JwȠr CNCNPx -mNKf^'V:K;^*ډL4*) exSQDה)9cԀ85Y5Ijc̚'X6H1c$+#kM/C7  7&Vqnʨ1kDBעƯ@r$a(jT[C5̎V'khhѣYE,~<ݫW/L>O?4>S4k ?&0DA7w\8׃`00) :p ++K)5g.T=AAQQEزe Znm(;vڴFUrBL2ڀcry$N?!".\˻߶m,?m%<m[(D,Yr_~)FI.4O~@wA\DmÖT%am7%[Ot}L6e".5J<|U0jw(\OqU_mm ViO^ UMЪ͛7ǯkX&gij]xrbB'‹Eܹs7˅z K.EݑE駟ƀ4>OSQljp#\^^Ν;~`z{*S S2P(DCxPUUk|mvZ39XNRKF(t tGSu}F@*Z, }$\F`@?Y'|]ӿ$ 9 B\ZUM-M{^,ϓdb,:GhLScjș˔q\t+C $!0Yfa۶mmjbF;!Cu,\mg5/"(Rdh$!K%Իr|m $$''" ap1qa7&.O6 e|l*A_c5HΨIZbժ- @sr M)nt͕1MTlDD"pAMB2'u$!Oj-X2NFvuv2mԁ@1ydՅz 'OF~~>… NY,kOrqƙ3gb1@$iqSM:t(/1c^/,Y®\")#޺ukWW$ԩS5* IpIYr%Bݻ7G>jvD îV$xPPg7()"QxWx顨P$$'%~ xvP<lAہ  hVOmo2=fcŜyGG3ݵc|SEgzd'18D@D4FTBNguc$ 6G#zfѣG!DQokbŘ;w.cjno&Çp:4h& J ͅŮ]P__vcѢE8{,[Ohшl2zviU.pGl&F}Nh(X}KKK`8p=zC=4?~fBNN;WG†1^SRKmfx/߯*Ls Rx̓fD ܡ#YK8Orh2Bf֏j W5B^C\/ݫvς]SI_exo]=hP~g``.Gu]-F΢*5k B"v%6nD BHP@4ҽza~8N #Dm۶լ `߾}5kwEݺuCnb2W>\.Fi;wjxxQF~VBv^ ¯&kޣG«zegcfF9sXY,a,uϏJ΃t $DE3z`/}gc۶m=z4DQѵkWiiiZ؞HLrC/ʈ}WVwI(ʌ$D$@tՁs>~ zw18Dboܐ?; k%h=r#\ܤ PW4%zs Ƣ2/':Bw8 W/p(u!> c{ZRNK~ W ]@^F?2N"D@ӠWs$ׯ_͛7vZl޼`K.… ѧO9sT!sСC3f ƌ%gJW! IDATԅՈQuvOfPV'I:^L >Ecag(֚$ǯǏG>}^~1BSnٝHd/RC;))(Њa;|/@$XioeA0]F[W' 1@ee)<116MdԎCp@"BB&26@/iZ2[u Oluiڵ /Bѽ{w\pk֬i,1!/Jg>_hjV?f+u oGJ1Y݋^ ntegcqgJ ^?YmaOQfxb+WDvuׯ_ٓU~m8fhP7,JC!BO:~! j/h o۶-&Md{-P+hkwK`;vR8ٕhp: *//. Pv`  av7[1n;<18vP(t/^+M6Fii)vܩ.TGQ˸U(z6<җ$]DV? kWWmAlWҷSMn%ΓO>Ç#779996m9,l޼pX6[,f̖,ͬXgĸVh$I•+W!C -- }n޼ B2331dlذ!*~V>MLoƤ$yo fXܔW(biX:"I9x ),,$+V HBIiii2l0Op8LBYz5i߾=JYN)ϓ2c  !K^fק]D"' =z`ϝ;GFE 7LNiȑ_֤dܸq0;ݻ}֭dƌW_%PBNJON]~{ꩧ˗YW~z2c 2j( ѣ֭i&2n82|M_;{l2c r%[vv6#P[. {lْ;};!j Sg٪nz֘}g|jvg6zF^_݇7Vo *&`ΐ9e޲2DERYYI}YqIVV[d dلBKMA!^TWW{yy9D"$++444>c/^ :|lo$Z ȑ#=&]H$!#m۶%ƏOHΝ{ݻ!ܸqBȂ H `L0t}6z#wy衇HMM !1}50} ݻwMggZvw+ c_I{RWWG&OL!1r ylfsa[if|p88H-!P>?o߾ ^Gvvv^VWWcغu+;VAoѻwo~Kt_'Lcɒ%ٟTylϞ=Xne*/ؼkAӦM }e$! bܹxg4A<hH+o*Ž>KFjxef:Jwlwׯg3zEEEx}{jQQQ۷hhh_mi]ŒaZ3"+<AD_nTgd y[̄XpV-I@S֩@Rc}xKHW#yY-Z+_N;6ZVOԋCFX+d,nEFme7kÈ%TߎPaee;!v"8I]e`ΣX %+ь>[1Scˆ`A;cqSD-NIZY8)Nq"tB"nSǙt88 :D/AS q 9P;Μ8cL]SŜE4Xh8)Ny-)̹_-Iӝ$@NЧCS84UsJjPjCCgqS0hQJ͡g8)N?Iwےq\SO6\E IENDB`gtkada-24.0.0/docs/gtkada_rm/gtk-plot_3d.png000066400000000000000000002715111446021174000205540ustar00rootroot00000000000000PNG  IHDR,"xRbKGDC pHYs  tIME9 co- IDATxwxT|)P* %Tޤ"E)-( ( %K U ҋҔIIHBH/L9c{~<<<3{Z ( EQM'ϟ>FQEQp%O ~_^ AQ 7<-玜O*$PM7m߿ҥK{1ͭ[NOO7 oNO2q9?Cps̟8]Mw?Û8nܸq! gfXt:MEV8. r$B.[VFc(( qBrj5^Y +?%98<w > 5;MDlނtreyϭ N< H߾}-ɓ5kէO{d2l66+<E, `j|(a #Ȃº~ L! 6+4agُ^`z<93.>d+G#bԩwޝ>}:aR+;:lذSNtM6iڌ_~eԩ3f z|Ig}d; ' <==J <)M`p}P([EP`~  8*7((0_. r@PPLy{{$F*IA|[s`sۍa(j"##߯R$)KPd^ A<<J咥VYrAÖ-_rNbmW2sU&%%%o~. ðw}r/fFc( 89ݥ9vڝ;w~Gp86h`ӦMA4An k' +/74M?~^=~pQ%)rA5?JpwoQQ]9Ay'"Y~O?8YfyG۴i]VR"7AU +f=7cQ=y@Tzxx׻WV-UxܩښrA|;M뼜,?Yj~{Wɺ~Ҏm?}<#vVA$+3 cB4|0//OE^^^ۿ,EVfzVf7fe<}<;vL裏'555le2=󦮮4Luuu_Q'|b2HLMM]d C9<5[Wv\Db!IbvrL& X@{  EoH|'(auuN]?LR*QF 7nɲZ4M߹{/#ᐡ#޹ٿ).)?arꚚ/*zϗ ƷwyakqIVO2dzGpzGu}Ïμ|Y4Qy9OjkSvFF&Y*a5].r9?aXd~t:I~ff1NIeQdƯW'\.R ()zsgsNP䔖۷/))_ RRRNʷokNo@#KX~}ܹӮ]f͚] d5 POC!q@)hU J{(?3IR #IR!*JըI ?_5뾁{"B#EQw޻ۃazgš4M߽{njIL&oڤ1hpT#FiԤE࠵Ege=[z÷jR`{pΝ;;}DyfEt:  EQNװqF %n )4]T*-y'aOPmܴeg̴b8 HΝoݺ7Jrԩ[nvM&\cZ6m bDЩS :9_q6n7L&ei7NY7=9t\l3r׬x񒟟f{cf,7A{AQ˫s~ܶmwh4r*ڵkq2\}Gb9p𰗧gEEEzKq77 "I|||<߻{mȎ[Vl)N>pEQlwss`P r9OH0Ϸhm#;$I1vO(0 E011lW,T(:`…_~eHHȗ_~٠A fZVp $0k5jiӦ L8RyWwOv= (`oҤf͌%27ŋ#7nzз(>L?d5_?޺u+Z՗|`䘑#lbq+Wիdð]R4aX4E8Ғ2?k䤭4Mݿ5tM[_8jLʪh4[66cjL5vD%D&) g2?}kV\[ׇ}0:%uƎD[i4}{vNpJ̞̏P*G^q\.[h5cm# 2|k׭wd5kL&\q0iӦ֭yf=|||P}1 6( t555ȑ#gϞs;6k0C 84r@i`k\.L&0p(P(sÁ8NS.Ʉ(K}Oue. Bt-a ;t pAU ~駡C,?uؐm6ٳlJ5iҤg֫W/,,L"| ; %|1K )>{A>y-T&9O$.K׃{U qqqpXVWW7o\ѐ$YQQt:/_tRRiZkjj4 7OboBi4lM&SxxhꫯFѭ[FXb.W+2c߼yٳi޾}{uuҥK0cH,?H%#m!|!?W@ ҧjN"K \:7Ml'1QoǏ~ qR,d 1 $I!ϟ'%%޽~eeeqNdo˖-JF)+++**Zzl~iZZƍ?޼yݻb %bp|0?jffٳ;t/9s> q rpb$!jdYo%1AsVЦK|DZOK= ͙)$>|XZZJٳg]Ə |k?~OOO1 QF(| |`E h1bI%au8k֬q:y[$Ij4_}B0SL֭JZ_^N:]xĉݺup?4w1q}171ߕ1Y1O1_vM4[֔&]v(:y]vyzzrZIII "(j)EQð}a2NԩS@\y1P1O7o\QQAt޽g͚+W4j~[RR.gĞc T+짗pZQQQO>wϝ;FQ}_[A1t Hf77e˖奦pN >BE0?ˢb3Y#-xܱiӦMh6A9|ۃs-J$$ɮ]޼yYf}eCi0`O?T]]=sL6g8R / qQ~TOO7n|򋛛nLafd272 C !'O|N3!XG$G^^LcMMMÆ ǎؤIFӮ]3g,RەXAAA!,,LV7lPl1\|zŋXT@^@L ǯ9'%N[OI 8(jL- H$ߧizΜ9gϞ? ٳg?xAܱcǂ?2CQuЇjCZZZ޽r9&\.Q5Miii&MVXѵkב#G={vz>44$ILD/-H`\R-[FQTǎ/^xbڠA&XAxx8{@Lztt^"""F#I9x\>얽gϞ-///,,ҥ_ QRRP(HdlD0L_uBBZϟGPL:2P iA<3fLllɓ'ãrssaH ҥKlT00-E aXFFƌ3KXo!~6,s$uPtq7LZ(%1Z,֭[$ٶm[nq$_rٳg DJMMرc\ҼysH[o4 l~QQQ;wܰaիF͛7 v,Q?~<_} }L&T*F1 S(&iӦ}Y~~;p@3afWllO8q޽={*hN}Մ'g~Y|T&ծ]ׯw-Z$M 5lѢŶmfsvwaÆ6e˖`1q>}۷ð{K ]|9ALfee7n…K,9sŋ\_֯_ui&Ir[jN6MAf_MVðC*ʲYfEGG'%%m۶uuuP11 ON@.]TVV2u:q3b3F$)ҡ%8,L&vĉϝ;s-&_O '-[ܴiP;}4(8VUU;v "ܔJǥK Ao˗/aK^vt7QիW/&w1{(e˖6mڴhbժU۶m;x 7v;;$ig\.OJJZo TAQTzz:Ma*0ԦMrV彤N,l(!G"T?ˢ.\|T0E".]Y"O01t:L&rR$lO> aÇ~&>>>/^ Iˋ$I """=zc7770Yoݺrի{q?l^K5IӦM^hٳcbbҾ⋥Kz"9}@J0^(@T~'?r0,,,XH$4),,\z BBB/_aÆ}5Y_XAH/r=zNBbG%ZP0+WvLFd]]]xxŋW\),X}A=|M;h6l,@UJ@#"Ɋ8r}y:ի/_c7#7WPE.]q=Ee"NqbuZŌ]A-6|7sbjP(yk׮W\)((x7c|VuȐ!k׮MMM]fpLvƍ04AJKK}vqqqϞ=oXz= IDAT._T._APPꪪDFѣW޺uK&T*L$Idnn.|ж={d2hf3lr~X/Hqqqqq `׭[g0 3 b]d.BÂ(PN$Iu# 55p0bڦDRk{PItJ,'O={߆ܟnݺm޼bO99ƍx͛ H~~> js6o3jZ,HO IM4֭Awq|ڴi8ǶlӦMc:`o$RIh߿䲲28hoR6],s~~~7( n $$f͚|RPh;#66M6Nrss,.L!1,(Jē'O_;,*]Ն值8r.nRO^SnXG7feedK.իW^b=r@(ʋ/͠;bdɒ>pvEzg\Il߾ሏj$IZVj;ذjzٲe۷oO7of͚[nذ!""F/A̼xu @m:~GXXL1?L&{Ipp05\.bپ}O8ѵkטwFDD&V+Fq]v}\.:tgҐV~c+D3sTg1X건*H0SqȐ!%%2tŐ1P u5i~?jl6BaZAnܸa$]6wYfA0>b in޼9ts\&MHOOw:|M>SA"ݤIC]~=##޽{PKnΜ9yoȢп7AQ62YŲvj,Y ȍ7|BHB-QVds6`?0:Aan ]@W}̘1fy 6|%ܷo_B^ۧڹsgZ}ر˗/r• 6lڵtox∈0v%AfQ. 2 -[0b;vL"DŠZMzaN>}5gXG3A DB 8ES[[j׬Y ^'cjeeeYYYv2yyy~}z Huu5hZLQE EQԏ?c6꛳(&fQb0Tbg1"ǃN'e{*8"+w7n(//g꠱w6mʮ 'qJJJϞ=׮]kؕ0 ۷oرckjjz=g>ܻwo^LRUUUuԩu>}:d0A+5xt G]P 77?|Lb+5Muu_TTTTTϣGNZ^^p8 f9s&X(ֳqԫWtřL&ZXRH#D"ἴT7)))66,[6bQ`=z BUDFEd_I-#3ekpo  $qqq+Q)5gU*_׮]_F W!!!ƍ)+ tujd2'%%իWe˖ AM Fe 0˗SRRp믙~3>bl cǎ-Zٳ?_f0c@7~Ǧ( l6m6J8_AKsMJJ $7?Ν;ϝ;l6UUU1>̢ЛOV>~ 6}"B=-F bsW|ר`IFA=i0BBB :u_FJ6ƢEmI 1baXM&Ӄ _ഴ={x{{s|ҥK###|AAAOVG1n8Ju޽S֫W NVݺu !,r`fPA{cQחO0aʔ)sνr :p:x^^^z80JQmذ!w\555iii}a[eb! mڴi.KRoӦM֭`صkOÆ  I̋'󞹌 bA NpFb,'lM\kSFLk!xH4Wttի׮]ˤu&` ̟?%, m6@{xx=СCL.Iޓ&M4*88x߾}k֬yI۶m_z%bӧZh46 &4mرcΝ+))/^ i 2 cO>ѣNa)YBP۷t_̙3OСC.]rl][$KKK !{p`bvڥ֭[[&[r 6wIQ2AO:ѥ˻rbpRnPs[-#PEC >H̃,5ߐXoA`@pqs&w86M.?{ EQ///8 󫮮jP H8U*յkp߼yg}nqѣG333Q}IΝqBP+M͚5c3pj4tyxx <ŋ .0`G}+Z͉1#0u) 0ڶmۜN˗çLry\Μ&2pnNMMh4/_lٲe233)3gεkhͅSPPвeK&XT6*j̙f .]X, ]688 pʔ)ѿvې$BhmciZ&%%\cQ6c|֗(!(! fx>;ݻw檪*#I\[0`PPñxbͦT*!_aĉ3v׬YT*q駟< ~QݹsF񑣨BOz{ooEN\C(8rnW*P<B1bB1f<uN6-i+ƢԐM?%b;slpun b0n5 @L(rH\&a6lo+߯i^^_&M;f٪5kjϞ=e0}R~g=T*jɉ9rdΝ:lٲ+WԫW]`J UTTv*p6 F$a,--ܸqcǎgϞ+VԫWb8Eq^1A68^VVVUU5bRw^ &M)RZQa6B(P.]% o "r؎5iXjرcQݵk;@QTmm-u~;wڵ ZŪ.\h4}KQl47npBHb#!!!vիW(fEEEUUUQuΝӧk!X#FXV E]]]EEŀV\٧OػwVWW2vLEvnFvГ! ,ᣱ@P*%%%Ç_t)4uoJJJp33j}ŏ$Y]]t:LQԞ={h9Oa}gggV{РAwIRSS֭[w'Ou ۷ݻwi dZɓ͛}c(bO`NX`ܖ}knݺo>(1`*g~:ԥf ̙3 e dP-/_>|pWm޼$Iplog6Ϝ9斗y3 &a6۶m[oa1 CV=~8Ut۷uܺuQ ƀawʢ" 222Xb]4j ,^k׮{),,LNNg#4Bݻw/T-#G&'gC Ϟ=CܹsVׯ_[BѣG?{l6©d O 񼽽i׮b0|MI0@'`R޽%ɖ-[~{l)!Irɒ%7o " 8CQ^zǎ[h'hԡٳgǎٙyPYYYWWO&d烂P<իWcZ'Nd ]bML0?~뭷?,.?'Jv)#Gݻ&Df.ǯ \M4M?}4:::$$d̙1117n4C aFy N:G Y{NMM@ĉիרQVMX^^74M7mt׮]PYh׬Y#ziX^bA,Cf`7 jb 9uss$228*BQtƌfvr i6\ӬY3h| 'www13a>}׿[ɞ hZ!(O>O@_j2oL bo*SDussKIIܹŋ, (x;j+1bć~T*===/]t:٧>fZl} R-ZԼyիW9rdҤI. ģX0rHѠC4 р_d u @G횢!C4iN9r$44t_oA ` y#X#k!Hg@} mڴa$Eђ)S,Zcǎe\.Wbbb||iz15k>8}4Is+s^B("l2C>}Poy%n6L&ӪU@gf@3P555555񱱱'Nrʕ+pBaa!߰wŐ!C;tPPP `69g֣G(8q}–-[V\\jg8>RXEaNАonA>}pbo:n.⤘#N!+uʯ(`| ÷xJ͛`K$Ûyedd EuB]&}| .#IR9d2"## 0,..$ĩVC-[,]J30 vgwwt*s0`VXzl:o-ZOgo߾j -[ Y|yT ;17 Z|%JWxm/~ JxÎ)=̜93114Mö˜pv:x`322mڴiUUUuu5A򋷷7DG HV.^HjΜ98{{{F(\.ZZti_ XJɯ//d(vSm)2L#Gꫯ.\Ί?~BBB]]ҥK-^ԳgovȐ!d4 (6MVhт}at:O:U[[۪U_ 2!v5CFq8m۶0aBEEE^vjkkkccc׭[e6@EJrƌlC?>j(Rt: of̘!]LV Bt0(cǎ 8ql6رcSRR łV\\aΝ; [+55Uӱw/:n,ˠAZhAQT^^oޣGڨQ#yX>rSpE޽{i&Z R)Zn… e˖8Ri6O<9e^/f|FD֟Lk[ =%j97bT>;]v…l yqqq7q V]xc`Ժuk`(:rHBBܹsfEQǏ_lYYYԳ'zfCl6B{n߾=!!!00tG:u2g?'aÆ9={(ʃĀOӳ$I:΢"8G?hРT__3glݺuժU*bh4Je>FYYWJJ EQ~)I IDATRܽ{7S8㱫XPzd2\q۷7klܸqɉuHj+X,Չ%BQ4>>$ɵkbVZZڰauF&HXK&xΌ1emڴZ֭O<ɔnxŹsJ5zd2v+%3\ Mq: .-<֮] I'V\ 6]f,d0͛7w.lEP{O[!2fCnnnRR7HN1'dK22`w>rȨ(\sĉgܹs٫VbP4Mt:P1h=z6m d°``$X*:M0۶m~޽3gF+— :l!8q"I˗/w8'NLHHܹsnn.sFD=#1DҸXք-o~ŋaÆ<ٷ?~<|~лw9AAAvbw*{N+h8C˅ FGGs4(8'M4|pHfVG/Y'NxzzhRRRBBB5jTSSsʕ#GX,Q!-&8Adj-[Pex؁FBaU1#GLJJ_~6mt…@Z͈5`VYY tW6555q\lI(VgyN(FWrrmۼv3g4h * LڸqcJEQԴiӔJe@@,SDF";vTENmt.;±T*ARڵKOO`lUt钞VСC>}3|p0`@lllaa!laܸq4MC;x&_ Y^z8$=ڵŋ, ÌFc>}:%@H |9mVRR9hРӧߺu+&&fʔ)nnn6ۛZ $I~`[, 8] ?c&q I`0ث9իWs:t+Wv1wf͚S k HNN: ki@Vuss+**ZzRt|}}I?~ va._ %_0<ܻ9͛]vn>}(lP~Ǐah4GUE}wA9sN>][[Ч8ޤI___`q??>&&FPp"^^^'N!C 3O>et]@g ྺƍx{{,^Νz^T0UƘeq0B GDZZM&EGFAdÆ 壏>R ` bժU-1nܸo|˖-6o8^TT@KZ ѣG[VFsNǡ`(Ap%!Q[[۬Y6m@{M:޽{Az&y~wTE@`A N cM`ĶD1)P* AK.]tрs炂 ܺu+@L˗ܪ.**bO'|e2Ynnf[f dE0"!!!{_իW¢V}K.@QZ&M:{g͙G\j SRΝ3ʕ#nD qPmYٳeˆVzxOT82OO*߱Ӛz22lΝvW^6ܹs!!!~~~ЫPz].d$(ӦMS͚5;|SVXѺukPkjj4Xi$, 7lڴi~>SO?͙3"ѣڽ{7:S޽7mڄ Ⱦ}:tE&X/B76vAm#1TݻK,pJa$Yʕ+ ַo߈GDD0Zt˳Wf;h...㏛7oWiEر>|d2A*$1G6mrrrV\i4J^qchTotCߏ[TW=~3zxI֤CF~2+=9Á$uUvqAιQ^ ($is]B MQ(Ir APDH7+VXP@jxxP5--$Iwww8،Nٳgbua6_zڠA ڵkW^ bDqN?-mpL "22 1nZDnӦ͛ ŋGv;t@5)r_޽{333Ʊe( }, <.SYHkK]@ףGjkk9 ܹ3?2|^zMphٲy= qcǎ'N(((`0,** ٳg\.Nb``ȑ#O:F|sΠA-Z$cenڴ;tGEh1aժo)O4jS*Pˋpde4V3%:u/SRiټ2qܥV;uJu#4DUUg>v;ၮ\iw)** )++7nDWTTL6k׮JjDl=eʔ͛73',Y@ "&&ɓ l%Z81bIIɝ;w;hrz={@hdիWr+c|y6`o[v^3҆ R^^^l}]^^\.JKK[n]QQ6qoذaϞ=ps#_A \vgt"Je:pg(UVb&TkwDaCtqJSҥ:aAa 1ڹs2 nnUP8AP4.'iɜ$)(Fq ˓'VBR)0jѢ80 x䉛cJI $5jTRR<A`UzxxXCR19 bhr>hjjj.\V/^ȮfQ^HwNwʕ˗3`.]@︸e˖]v=00`\zuΝg̘oX O,?Hwd2d˗/Ը\.(xSa=:zht(jիWP#--MP\?`3/˗/_aX1 :bkwT"I0z!/f`#h&E%//e˖L^,N߳IՎ=tQFWJE?\PPS6H_WlnӦ !qRZVV|QQR-t1b!dٺ3/{s}8;dϞ='Nx̙&NE;^aHп:w\UUK/ཝYDK" `ԩdNWCxI*AAGt&^xaܿ) ~e{vqq?^믿vq1na%%%zpٳ7m$޲כw}7n\hÆ>}ϜEXgdyZHWcDnw~$11!Ű9a s*MfgO$NjIJ»GR=+K׿jׯ_nݺ~ u}Ν}5~:{lqZTUOD_{7dȐ?k׮]tiqq^Z,^xѣ{E%KiӦ\z(''G익 SJaz'O1c{Ǐèjo JiVVփ>xW9X[nxunN݊kDϟ_^p0_^$sPI$TEYticccΝ(@@lD&ֳ_:u*));w_i&[?ǹ۽Gؿ]v+WrnE. Hgb>Uj'##}Xx  I2Fd9h(cJ"Q@'~cBq{pT'lҷh^wT8Y&ҊeKb? |>ݻ{믿UVEx?G=Νddd~С`0pt(B,L 0޾[Hرc4(]"ˊP(jժD"'O$Ol{Ls_jҞH׿W^DӤhd&MmВ%'Of$%q'z#W\R (M9#3,!$"5QWUE P#GAuo1f`LCBP42J/6JȊeGEY.],X`ݺueee+++kjjvUtq?Yf?ae?5&Mš,ˍzzEAs;wn޼y .ŜϑŊK.E(Jy8Q3HGKh 0 Z;v[o3̙3g:5\o_ |[_\\ܭ[͛7c~ߝ:uZxX-㏱`x&Db֭]wݯZYYS[+ ~o(N0;Jyd cI!& ˤj.o4ANs#<#pM2E9g9oIR3Y2rKB|~had0F ÃoQ1sTƟ$ؑ'DM0-ZxaÆE"?9". c{zyxNeA]pСCnߏb !W$( eiD3gμ;ׯѣرcQ k8 CX$]}RfRS'7N;[!&}C(߿-755:u cn۶ 3v튉 X\ 1KO2 IDATnFǃ6e˖;aΞ=[SSC)-((|O6 Ǝ@9cٲ!'/((7 ĘĘԡgh0]bd t= )),!Ip!`ad :.IM)@P  YWFj$$\)$t-#D 1c*!Z<ޏU#T*pX3!V<ᇗ,YD]x7PU5$IIN<9jԨ*qidɒyYɱX>}ڵkUUڵ!xoի ќ4cEɥKb%1v1cp|Y?MV]]ɧ"XODqmcɓ+V\pӲaB(WD"p6mEzꩫ_U0DJ$zH>|x$7nڵkkӾ}GRr[:ӻ.H8a(P\4)ԯ2*{BJd|C Fh >[DKI B"Hd!1M-3Y 3OH̥m5(mbL4h)!RZ{QUwz( .HLy}3grN :e(,Οcݺ(Lq},WTTD"$M:Ly|#GpT9}4){ӦM 6~P(+++77j29( b3<u=''g̙&L@1>׷o߿/;v@,ZpD.xFFF<킿"2 ƠrcBW_}Ց}_޲$7|dJKKeYŷ222rrrQFn.ϨlX4@V P1EIot<.!M *h ɄC H:cIBܢ$3e&[74 ֪ !cM! F$aᘸ'`LEP@aLV 7!6dɡ2_~WdㅈCyyy^:SO\ܽ{}ڴiv/喅PhF͛7oܸŋwQRH 6voo۷/ѯZ@ij9j*8Ȳvw}>9333vԩ^r޵'[VVfW۹s;_CraYYgxqi 0D45&d9=QRZ3gy,5tldz%#I|gƒfcasx9Bxs?ϟ@B:㑎WǸHPgmscʆa9S(Ç?USx.2.àM0nS;i`!hf %IzW\٧OZti>qQȆG48pYVZUUU5w)S_⪼cǎ~zÆ >ݻ->Y qfR;V0~aذax\UՅ ㇟}e˖UDիW'>"{wС ;vٳuuu?xշrW\QQQ!!w}S$ƤsS4?MXFTi߂B@H@ȜKL@ܼiAGxE.:7igf1,HB*{ Y!QHeAycWSO&L(.=eG(>H4Qi^jjrrI1\aÙ-[jE)!%32{1+G6*a^)k넎`(Lz,Ynݺ_|FEAUtr}ڂ"m 7Ο?\LׯW_9h \YfaO9'N8eʔݻcۈv޽]v~_Œ|M,vYf?J_~QSde4!zv^,?cRuK͜!IzJ͊s"Rkt =4?@`u/&150/g*yj!g.+:~≧$Μ9#755TVֽJe7u:ZV F;(p*^2 ?Tr0|z۷o߃>8n8ܿ(Uvma߿/:`x<>v„ #GDb@~~>vB:Eӑc/iX[PB^nݺq-ŋK,1 … O?kM:ED^~(L7t(GO>KCNAAL755͘1 J;vܼy~Šv9fЖ$q&( ?i^ )!*@ǘ D&$ !*"TXkqFݙ[5Kԩd"f?ɘ 37`Y ,&!kK{`YY;':t֪UNNm'Ps zcnBҤa(f91F#5 jOp֬knԠA=;|wf͚b|/\뮺'O3'''zg)'$Xߚ5k뮒?y"!//Sֺui ư躛$!58뱉4iPB$Jk0 |CHgp;&ٜS6BvBD2@<OPeޒC,"_sxid~aip$/~M Ԅ~2 4 Da^*nXG"5~ذ;>RpEqݘUWWk׮]va%V(W\qe+rnI!>]Q QQ?ĦZ`abߨQ0[7lPTTԶm[5>|X;s"[QQq'E(vrwj^޽;T~7ڴis|͵N0,0!PC#rfLM4Ǣ(c.s+8ZCHfvڳ8NF ?dA̰FQ-'c, f&NFT@͚@#1ﳊ4w?#|wg޷K14:\+xZwݻ`de%Ib֍7D8'p# 4d. 5M8k4܂pcW:ƂHXV뺞vǏ??@1c|iVZZe˖={>bYW^7nER:mڴ7ѐ$$da17 ǐzƼft85o͵ yHxy8H|30Qv<=1ē1|^ OK>f+8-C17L33$rZ,*5XQѱ.?2d?7~ރ)F,WtexN:͝;7F~~wߍS9rd?TBeeeecƌAKD?wܐ!C,nd_~y}_[+IpNFPԬF8#fHp5/of!II:x,5a4K<"ĽKԊq̲2sNT ~|VgEk^ka|OYh%/ƠMs!I!%SӻGLp\u@ /2eʔ)SN8XgeF}}=w;ZqbUW^XW_XBZw:ز zjK5,J08ړX$IСC}}o- 5MK$]v=p#5,3<ω , LJ|"K]0uJH0[&ÊFi>_I2)155Pn}R]U 﫩[`…gΜ2eJ4M$h$5͊y0Yu]VUU\.tKb`KjkzzG Gd2o;wX/={/FE""3+R__ĉs̟?g^z饧zv{[׳g6c< g1*N<s@$E 8 KЂ[b*IƢi;ľ,3!hsZ"(CcAylg-9m G)yX1«"(J,"I#\BaHAGI1#G.0֯/M&XI]ϟ/((>}:xOs̑ev%SUubaR#7lb 6264CǪc! @VV/r֭[2?QyYYYX$dkoA &?/WUo+*Np;+cH0e!5'b63w?!:!aqPƐX\z 4pz41"\P2Wc|7@aqҶj^oOL%a쇔pJ>A0uֈ 7Җ!833$rujȘE "|zc#!Df PwRko(b5C]L[\\|“'O>G V\ѣGϝ;WӴ1cL0Zhc&PN -~,}뭷>3bf~͜QX^^Ҏ;8q|>_EEE,{7'MkU~չmqXgFHX7pf&07㗙4#j4-K&fҘH)ڙ)4Kl2DS I4.:^ P䯈%UaRcXffq0x&,I^ J=m4MٳzÐ 1v2[:MTTT`{xo5kV x0 Tvt7C޽;GZ6mQ:Pt[pTM:V3n;3\uUۊP}ݧi ~ojjС}E;-IdYڳGD<|e׮z<]#CxB2 C5%$]%YHBR1Z\JP&M'a.Bz38gsAB#=A>  "ܸ=(0V-BD/(T/z&fkUĝ$k ,]JI8&#F.O>o߾zv(XZ*dPWWWϛ7Ђܤ$Z.+-DW_;Ǐo/ܹs˖-V4׏5j޽ǏK w8yrH:3,ԴDL׮;F^^Ozk!J)4(r45hj憳D a6|LFN"l.gc9!iH$PK)5Mjxq9ղ!urF1e07̬F{ck],*A0撕رdK@8<_r4MWU I\K9it]ǎΝ;/[gϞ>ﾻdɒ;at}wliI&{MMMm: iDP0b})N}=+((P[!W\qE>}ɤtCе^뺦i⛢f$ܹ.@$W<^ֻcH;[ףT r1L}cBLMܟ FG:dnx';/fbbi}HA&Z@qMOI3l lúgv?JB@b=J¢Ae,&p;c_}_,v^3 cadJP<*47cy(n]o0֮]`|ܢg crjkk{oG Bpxԩ6y#htuueĉݺuS=m$ ͘1K.'OL$<933so־}ƌ7pΫ4iҚ5k|>ߏ?[dY IDAT|sϞ=۶m B_~9gRJ ??$6Ҽnwl s:c,:lت̎ؽ{ÒȠAR*ɲP)&_A,2KeܩZ93heu;rvBTE8qG;wBQ :w2ƠalpVM:upx$<'@@80^Q!^oO?8p^,vBhf@( 麇#+kad$)h `|ْw?:uj<ѣǑ#GڴiSPPFtd29yףx_]]ݫںu;pB4JGN:PcDypT($=z_qƕ+W 7pSO=eI& !,WUU ƍm۶,Iwo>d}嗃 B\xƍrssQcxAޗSw˻]]Pp\5DPbtR׭[{%YQENvW\(رc !:u*++ N9 y/sB^@HݻUUh\3fٳ-X@& XzUՍ@|mmI?&>Ei0 !1B S"I*g *KKG0h<㏯P\v. b @РtYuϮ]kEY\KҼ$&Aז-/Cgj7+8Dx~nMSwZ2|ߓXx1eƱKW?ʁ,_4 +/S30E%Jpk] U$S2,;IQtuuuݜE⴯sD_^i>699ɤ}S7̻': D2 fF9p ʔ6 !+)d2_Qj&!Ƒ#%٧ϗ9>u}6mڴud2;Hm$y*Ed3ӎSJ3[qQп}#F<Ęo{tAuSQL]'O^__95E$NtI饮QfC`TOōyHj*qCj's$rJĎ'BbeINM#(TU8!g1}]dd}ee~~UW]F" 6̟?oEWYdkY2>4?CzֈDuԠp5v Hclw\@`…HcFw}w$illꪫnᆋ/"(߿?;;;L=:33b0 x44LqdVb*4:8R{di9IT=PAր ȕMɲ(#.W\) 2UUUgϞEH$ҷoߛo駟YfZf͊+wB#tSM)D"p͑бkn#c;v|G7m$,444\ve/*{'C91c@{u]ܩwa#ˌyS;GIT#GQwD<0ʖ)6(7eOI~&8?;"@@Ƕ43']VI-X†#lGcmm[I/RxƷ|xHk߾՗]vO"Md,>ϩL25 v21I \VGfV01@1Κ뮻/cǎ:ujԩ>-ƒ5\9st]c !N7ɽb1_?~322dģu_/..&P $Tcc1iH(TYCs V++Q]*.Q"`c¤֨ Uҧǵk`@ `@ @4x&E@Ri:saaz8gZz8dtsדRk\-./"%Ew{M ffVjD"O!CVh=ak}`:FFϟ?Q)$EQ6oެ(ʔ)S<ϕW^X51⋲䐎ƿ6ydڵk iӦ"YJnݺ+@\9fϞrʁ7C-6?]t9r(Kz+L)գ\Bp]k~YF=B*\4ʁRteB-NTɬ;67a7jc0-`3PecΚn[>n!Nez{18?aAZ:[S3[t )SbJ۝o_o?Z( ʊFjr-!!K(Y=ɤ4?XtU.+pJQx*++Lv4& >ƐBuhGc̙w}$Iv5\bOΝXp)$ I֭[h۷oxƨy*j،3p`4G1MٰgR1R j*rbaxU]PQ@ M*ӴDm72/Q² 8݌ú $'"*`P2!1vaHm;!) {HI*b-hZF}}QnEÐ̆]e!t7r}fȥCG[[S_.\(IQf^'*JFcN~L sDjjB5` (d2G~g\uU&d9[A4;j(z-J^2da}Ա-RXK8vj}WÇŋǙ6H<^w̙[l֧ t]_!F,H "!F4:b(H0X/"/nEU2GVBl%WY4;I-/)+mNN].-ٯS`~FvX]!8Mud\X,+!l{F5EE}"jKoVpXNuř {,D钤bEsz:nΝ ^X}YDe0 B%%%>?GL0***Z MmiRjSKax_egLQYnjZ,vc„ Oh|x̙_d224;(hX#?Hx^&qoY(-9'4,墎 ݴv1H̚5K4z Ϝ9óPIZj\qŘ3gj|\aE D"#7u׍NjNOa,j)|ΘΘMDnkK̕r)p†!II~8A4Lϓ:Yu@^招[G˻h)Rd@ IMMGU]Oi WQhQ)+(=Q||H2}"xRiFG9p IDAT4?)~+T. !( (!׿t]G}ĒXVVBR-\|>ƍ V`Ʊ0y H$~ኊrKHUkWXqĉx<1(Y'|R[[۷om۶BK`ل^m^}%%Ν!I*+|&L/._I6 Xm[z3w @Ð ah6!,3ZUds?0?y6<)UW g .e~˜1sdY8^ `0e.׍1fA~k*)u%I;vHɅrDUU?>wN8o,X0|L&c)RH9^r%SNE{1\겲21$㻍d|Xj"6lX8ްa*goD={{ÁjbMMd'/MKM$۶1u{!$j4\2~Z($0tFcJ`$:"T̈} !b(Q$Ī#6zEAưi^eYw5nܸ;g̘?)ض=w\Xd"W_8DQ1? aǮꙸz *4a\y~0tQ4M{goLȿjj;drp6[1f, PX{1l R::zFV OqVoMv2y,c2T@," BHQ ƉDL *F0!Ab.p9V!$i  >q1 (P%I/qD I >mk [eA4C~B;Ḹ,f0̿`>}x&Fgiڟn4h/X3EXDc\s5M馛-[E&!C# X0Ra6MMMwqǖ-[5k̚5kԩ\r ^zCSh4D eeUQqC㯸t:}g_zeY"Xh?M6<{n0NCCW_[ol-c0aÌ)1I+)c "!C H3&[74CʾmсealA;+QE|W>( gGQɔ+OU!D8D ʒTɎ搿aw-` cv9eS3Xt05-qພ!RҔ3`?A3v߾ W30sx.W2#o| ="v1(nUX+6$!ˌ1^薚'=ъ֬?FO<ҥK)3f̘3gH)EzsXUJW@w_.;sB._Z>YBG}TSSL.d`N{ ,ؽ{c$I &D%KpenM*++׿5 .-]1c,Nk4ĘLHc*@`{9WnY=/@=Ea96FCf@Pd Tc! cؖ\( ΄Kb}oHhh=p,yВp8QZ't= uUT+#R]b6;:R][lWy1 :5JHXJLG|RSL\.,1 c00ޭedSy&RRo1WFx1jY10!3B*I —)]"H0믿޲,۶ ,Y(?!C{8M⺸O9"sҰwSB3g|w[[[#Ȇ c}rpS[aREQ4MP$B pweIJR*n$Ӷr#@_O"C ܅=cX~F @6]Ë !ft0U5fLSCz";5b b@ (AoU9(0,o'拎~vWTɲIiKyy,x@ c< n۶RZTD #dDH-S7n+3O1Ɗ]#͓dwA fB ֭.&x{WA؍7޸}vNA[#Kӻ!$^fvdm{֭wu(pc1jԨD"QRR2`aE0lnnZ2XlÆ wy'|ƒ{xeP~q Sd?H۹g6[ ۖ,gDXbBpl@;peDB2#$m c&IYprM /ƅ1l!ǻ&"tD`񓲲MKSJŌF;<$˦@RP.fSE,c׃/QpgMͷz x )պ~"(,Iszu%]'GTz/2w$c2 \rŊLRtӷ-[O3Ɩ-[NzNy>#_eP٫ ۍ $N[zuUU[Z~=6]uJbLs% cJiFWME@a(bٶo0(B҇>r0&9S 3ME,Ј !m0u`'b`L*޺_$ pg,֒Lq`l$v67RMJa@j/!DBO9B,JرAy2!T2Q(>UXEyF!#?o8?X5ڌI4sLMdYwmkk$74 laBR`#f͚={v*l6 jVG'Xşk  AܾlFyy֭[ǎ p;[Jiyys=aooo߾\ 㯔EcShL f,@=O>Iڵ]{okQ@;7}vOIa%\ (JUưiUS=MSwgg*2i, p0ƌ[ѴL/u:E:' e<"uV|*(h"alcy;)02vHkÚ]wu_}8Nq>,To\.O>X,V<^ߓ ~fmۮmJ_:Qq^] i{H_keaY_ 6mb{_zkȑF !eZe}xGHBHv誼SYv0L`v:>g'ZVƶmW~JU$sOQ$ ׌APBةP'rQ 1! P Y4{ִ4 KJSQ֭[ H$?x( Zz{ꩧVVVnذ1|͠A~ N/) <vVhZ`grk<Իm;$i,*e1DJ]pc<~ JJza($P*`'_$@pjHMI2d94CMSuZۀGmN4ƣ;=B[b 1 c(?)B'B`!tEdqQF\qٲe%%%`ģSEyg(Žz=IP*+6x 3P\Xޝ +a̚5 kÇ/X:0Xlx<˝}ّHmaL16q! es+p:tavMS?Bl͚'DD"gS@ɉi#4l(~aTw#l#:YR*Q*QJ(F|pLQt ^3:fq`qS,d0E麾cǎA͘17ѣɤ,~!$1s㙌:yc9 ibL8dz04b1镔3& ڙg4q\0 &$]&_]REi*T(b]gY|bd9)8A  !.9bE">g`1N88 M(R$Oz<@Iq>ph%TGZ5E)Nnautވpl-r/߻K)!f$ũvGG/BoL@Y*TY_ gO?(}… |^zb1.XW^ؘ.$PՏ>|o?SZ%^k 5Q1B'94J]xǏӟTSS#ވx_7כZȎ/BӴO?tѢE0ƶnz'~im)'EH0MQbl yNNHw1daH^Zm ԻEEiF?4!&Ɣ1=:vUF (xeC(Ϩjq{ U'1ׂXYďF_K#R2.j8IQ S `KQ94.CA(1TGrGi雼Yd";cjYQAHN3mF勞n%Ņ:E27:SOVKKw, IDAT'}aq"Ie0@Hm2Y2J*HRζ5]㑐mö%@Ef1brwaa c2Ƅ1i $dPkCñ.ߡO( ;U,w8MH&eZ8 ص.]z-[xq:>KJJz(JKKK&4KYDaJO !+W\fMSSr#SG$ .PUt/+Cer^|Pu=̝;!4c HaG.4mwu w[P9$%KJށ|[ +h`7"ϠFJUm!&c 3!$M Q)" o3q$R`G4- oU5CêHp^o Ih5^"@q0ml\0v.b 7~>˥)U։7I!]!fEEpLL&ybF)E{{{ss3PyByK_Uv3G5rȅ 666Z0 ҈q C] &\p_|q޼y"@lO8qԨQvzz!hB1!k5Te:th֬3M#1|u"43f.L1ɲJ) $w?yMO!$};m;X҈3Qc#]}PdGurvFԝbt1IlSJ$) 6;S%UMƘIR0}@\m!g)ڒ4ͨedٿ5yÆK>ޛ=Ho?yXX̗ڙJ@oٲe>AJ)hR\y!+j XUM6ѽ+ H$=D"MG}EO?M9Uލ%0f79UuXH ~ !;@ĸg3&WV2B"Wd8Jϻx'c)xA&"zEIal7u%lV, K$pz'=29*I9g,E  !oz㠂`:]6lXщ' (?--Nj. lv(P>}:? q La1s7;rI2xOHH/;;;>Ng/{v}5Լc=<3x_]]]]]]޽{cǎ޿{'IR{{;Cn߾=[oݺu5 EQ)Ib00Q[Tu> !sGeeƔDTBr vB,JUJG!fJ~S{l[yP]oiq~%PiBL]ou ,-;$(00](1pd$1hYqvq!2&{Z ҈3eEʞl$)_{gΜ9{o:VH<&MB4O?SNlnnvLpSSڲaPBoK{(D8ʮ.B=/R:xබѣGw1b7f΄ {즛n۷o]]J+s5\ga FxmQBG 0胋'[BFP0 cfYQێwueL$S4A5W(qq>9tYw=YTxj:эIӌUv+|/IbgA 1v!{Il[eK,ưa觊N̛"#~ MaÆ7WWW8ppeǓdYimmms=7lڴiȑm),mp _N__T:>x#\%w}|]RS3 0ZQFPБE~8/JYCP=䓇(%\2cƌ޽k+IVZ^zilֲ޽{R'uFx߉_hqoC$0^xCum$W~w.r)=1A =\`s-&"<*Q%7c}( ZVxzKiei<RӢm +q)7/|<SLEI55rdKːdDL]d] |Ki"Q9[ZB~gN<Æ}PU-BH3T ܶJv!lҴ[6W8eaٳ?g}_orK$LZq<m744$]VD!C:%\$F~eN{Z aƍ͛wt:-\+$"rj*L$:R\|J+97|3"P<@oZ @k}r϶x~qNq;sմ6;vz T6 t/,hNضOKB È|/r` BAIʕڱlda1bYY& G4[UMG}iu'q$*8)JeұI[ܪ]4W2ib\rtZ1c}ѳg϶mnv1^zx#Ăp4ROjm\&"?"Fdʆ'lٲ$l2o޼_|qǎK,롵"rM̀޽cT`LM{ȧSP^r-#ĄCё-- |.oE Ebg{w|ђ4e#7kZ ꖍՍG?#k߾cij,$.Gö媪5ʉDc(p=ҒU5}q|ͬ|c{)0@Ͳt2Hdi%HRҶ5IeB2"1jJY{{Epu׉\Fʲ<|?J>C/"W 1Y}M٬s[4O9oֲW^yo<@7vih!?ꦛn3gOPq _˖-۳gcn ݻ.7mI(X]ti (dXy.RyM^m\wI!7/L6|cxo|QZ P2ͰiQ)e P_Ww\.cVQry H14_Ս,-g IRKQ2TVn\o@icCUKK(Um[5JKEy'5ל&+rUWn\￿ !zu=JfG}4f>A%O8m^^}^n2@R(ۗz卋/dR|#۷Od29gΜW_}6˲֬YzHUoq0vI*DKmj6a„;wBW8B@Y[$7뗤Yg䜉ʺJ2N,K=w`}jZ6rdij'1p pa1#FsNM Sg%g7J!IX,GGz B24\Va |;^˽" \lh. ֤9# x766jF{{7kjjTUMP,+SJg2fmz+ ?8@ 2N{ʠ03aYwٷo>},^u=!ϟёx/ zq!14QC6v_|V( {z]&NKdzy](I`wa]Vֈ1*dJaGAz4屝ʶi8!EkjBIn{Mͧt*ec0- 4i,+dxOx@Hcv@m1&㸾;>|x6MRdK]zCB'x(~qmiiA7"Qr.%J,ϯJ$ Dr?&Ɛ$Ū ̇*h׍7: D{ pjn `p!Y8!86Je 1Bpx;:gci3]oe@S(Tg:!6!$90+ #b㴪nU1CdXq6w&Ϯo%.9眓fZ $ɲ D^>;::$Im_0:`O>r9R?w[MzwҥKQIGmuڴiWR.^z)Bhʕ| @uXI&O|r4!~\.7mڴ?6P4@Hl1ܾc&Iˎlnn{D=Ç.B,Qȱ UGUrvBg1B,%Q&SHimD{nvPQBiS*@pq<;͘&J D"-GG`Yޫ$A۲N;J]D_!q&!m޼h"N!L}뭷!mB!p%RN-|VCf$3fr{ @[lّGO˖eEQ~r{")S\r%.¢w-\[nA{}.k B_|+"4k$ ^nE U91rq-rl<ӧs+J+|KzV i"OHRw1&!DBbL.Ic]UIv6vYǀ#'!N/ڈ !1щ61CLD q!wMBÆ ㏕cqyhzmۗ\r tÆ 438cLD_~z]Mu]Ç:ueY޻woII Ks#֮]{EPŧm۶!4nܸC p-ZSH$͂>1 e^Đ`mʼn]Wr9 ֲ,Ki}:ϗHU ûD]"?!ڧ? c;y\{ĈEzmTٶUNEI3 G(1Zv<<LX˜B&{p8lCC֊cEѣ` 0M3Ȳ}}11EtT?aY}si LXe:3Ǐ_[[{WٳXUbo۶m&O\^^ԐL&3{lEQ H;UUmoo?s>x_ih#zg+1+裏pK[eTx+YVgb3 nnw$lQI EQHR#BHqr^/F)2&;yvZt=o!XUUUuwL2&fY:p-"];hٶ %zUU rEɲlgu~KUZ)'=! $b? DSoyyyYYYuu5B#pxe6l@ x`0(iB3̔)S Ø4if2BP'Z ]c+Wjooꪫ /SE-v-$ JS3:P8~`p6YU݆1x3BQ&@v8YO+*ka( &-4Txx5~,X~I3f̸+xМ(bu14MSu bGhZ{6}Ͷ$R ;'3fI'Կ0|ACBxDEF"KN8q͚555UN` vD֘`7%HdC\uU/CUoOϗxl*rx oZrE /D" tKR(KR,*cj Lh;L\L 撮oW2У@,"#X4 pyɒ%/>s֮]{w|C I&dRT)M^xᅲL}Vu87VA(JL&7e4 I<[ ,N^.;~֬Yau]9roI޻!O K$[묪 lΝCn*nu4p@Bȁ:/T9  (X/g,ԗw]$I믫vڅ1+Tk׮ח YKL3DW$\"٬]]O?}ĉtW ' 26?+@c3[$f.x 3 f;|2E48}Tr0C+Y~(ϝJ(q`wzv/ _|14 ]^4 >K.1b}>G}t>}R"M8I!!,!eJ1c(=i vp+쁭K\;4MWro2F"7F"۶x k/X>s1]]]9۹\ő.dm*F˙?ٳW_D⬳Κ0aS? &*1Fl;Bie+-T`LUG1X\0B#9j`\?i"p 9s i9QdEZ-rU) 7 F"SJ4o޼m۶}SN6N[t:3n۶c Q BU^Re[n%ڵ j\'2<.lҤImmm@;Ճ&HbeYoFmmmsss{{ȑ#ѢEKMP!ZmօB%o6~_AQ)S>?rB ;@جh IDATo7P x_"p~I骋4osf4f ,Ng|eAU\[(xy%ۊ_P|:tҕ6o $tɒ%}}ꩧ>l6[QQaB1ƭ55i6lnY:0k:UUχ`yD"on߾ݗjD'L<_~駟1^n 7ɲaÆuvvRڭ΄,TI S'LU%09'3f7n\6]vyB8X6<_(QӺ0aUUy<"U;N PӬGoڵJ:Ep8|A7zh2Jk7h4iӦx<޻wW0cA1qB@@,Rۦ9snWD&MŴիWRT*T4}5@MqPP\+ x1?_T^7Fp ;d8\!1 &Lq 'EZ89g^ \SSio~J'|1~xe}P(TZZzQG=CHdͿں C,5 cʔ)\iH}~{s=G}Nrq& YϿx)$IK9Wz^߲e˯k۶+++d2!"d`7?gsnnO+_ו˧yi /=z۶mxc]yWkG -ֲu-Զc𒛇avP~coBE0`+B k¸+ ci31F \0G@WWԶT*|rBȄ @R:`8}x+Ji{{;(BYa ,8ꨣZED=l=+Vx3Ȋ_~%O;4-v/+5*8TmĈO=XYD"֭[\.ɳa3B55uilyA)tiN%I1,tz{!3q\؊F?uᤅG1K; &h 5alr{j0@e R N: *V}NXD8l(2cCpx!I8˵B|!pĩ&o5={v"9s&lTe777C~zoRh=ɛBfC.w={lu]ܗw9X,r|SN^T^j4m<2`޽.SHMBp #$%0'\Κ@T,k `7,Q02\F-8%j@7@/UU/B1:sω'NIFNWX l@$-466(M=ctÞ|#<7͊+.]ګW#8}2iYfĉO>dss… Q1/⥨zPP8@;wN4cH$nƍꫯ*++ a5>cJ {׿~fΜ p֯_Z bש}\1YjeF\a^A~SWy ڱ`08~s/(~;ZGGQVI4+HУZl\To߾;]ft]߷o믿~W|͇jhh>}zIIخq+bĈfͺ̻jl٤0/Xt#<'&HhtW_}a| C<ˁ G:>1vF2:a'(RvB$I۶h"m4#H>}&L\ p| }_)Bu C׆15?͊l&r?9HI1Fu9c ;dYs뚢_~9_sUdY>}z6ibTts𷫷,o&~ Siy(IitzSN]~}YY]K˗/B1( |w,oȐ!b@uJeY`p޽֭#̞={˖-]P.Xgپ}ҥKa]',ć_dI"Bwylr dY9򭷾 ul8d8{(K^'IlӦMvpfĉ,$I2dpEþy_0̋)Q4}½W-ƁSljv/3)9g!'4o>@d.݌TU0`>;vXEQMv/W^a@wXH ,˲,꫊{r)o]1QgghmS) !^zUV}!y ٹsg]]4BLo6MsȐ!<%8>mٲ1X.AK A((B--ƍǎ{]wg}ö7|TF .?(vThHf>bBagÉ{\ Cu4cz.iTqL$"yЪJS?bIF3L0LӇzg.袋/xժU͛>}zuu#<D UUUOR^Nx m+ж+W4 IWٗs ņ{!C}Qpt޽T Zf=t Xt^{ݎ; /o۷ڵkk}ee,cƌDnq4Sx<-ߏ Ɲe9SIN}fs]d8Exӹ x`1mCS%_655_pcǎvvv;ZYYYUUt\;bw=,@Vvidf7pҥK[ZZ'O 2ˏf/tVK$O?4%aÆ]up`C؅`걛mk4f̘]v呲dyРAVxx<#^OiA<.*`{s|t罞99 %,oœ1p5ŋkNMY"P Ac5R #{zPJE4-JxwI'O,Z?1o ۷bV)i,%K:zhMӞx JA\5Ж 5 A /D" +|p8駟wq6mxC(#=Zp׿n+ ϦNo>04Fif{"Xm\0EЗps M?Z_Ak MHH A s1YƍM\Pm[oݻw/Bn k׮P*:Ji]]o/>k 8p1o :?x#TX!o&yڵk!tMs/P @yzJn.שT/Ν;u]ߺux w\wʽ/0Pp)7n\[ƌ^Q%J1Gg1Wh], K'1lۉ@@ҋolٲP[D O> ;c…?|>}hii`Mܱc4 B-[H$̙rձX;' OZ2*qf͚>hȞ fm^f!C&@p.ةE8cUU&O>{s][oihTo d썿4 Nofܿb1Q/$Il۷|R  ~7L= AR"00088q\F~{~gv4MAx7޼yOFDD#,UJ8T1mX~Ô)Snݺe˷ jl\_WnuA!e'h!dT*CXXZ͛Yz5B#f~ݻwC ]T*p8!!!\]V]|p``c8pСvJt ;`ިEB]ٮ]ݻ4[ cVRMTH}C$ңG3TWWwqHHAlذaӦM>>>V5L* ІXm z7ԜtB]T=לbjq58{A o V5K,_ߠn?رc!p"`0 bE"і-[jullL&sOPP***&M4w?~۱F]jFFF$9x`NtvvtYvw r<##cǎ(v І1M<@Ta opƌӸ`H3 آE{ǎ"ۛ}Fqǎ&ɥw,;nwK@r8(EbToʱ߰tiVWCGJbæ2:d$iiq L$I={.+O `?:h\.iJ/4MTVVc $CCCl׮]6lHMMmٲ%ϣbblXŋwArlFmy}~ڴi@Dz ۝KL4Mwҥ:00pڵkO0DP .WvmOy cG=>uRĉ짠P(`cDzw; 2xP( TrvP@t)Nwf1 I.UlKjA  g˥u;_X] 7OofŜ9s>cPmgt!qB0 Rr zZ,17u#I&IҊe˖mܸqر Xr)2Z 3à 3g͚EdZZZ߾}}6o  2cao+ơ#xiѮL8KG7?x]vMLL>x}?~p4Ü4#>#H9ĠL a>}_^^hPσLf p8\.`0o^"@ٱcG$*ߍ x#qmM7o>xð`^ϖWUVV~ᇛ7o{P`@oʕmڴay|~pH҄R Cbl8nsgE׮]qo~]Xd$0Ρ s|>?##ÝYn}\EvK$A H躱8ޘ7f9Ɩp\&v~cû!j?2Kg ſAJ믿&'' PRRRϝ;w>Giٲljxff&H D Äl2$$h4޻wa/// J/H4f PBzj\ah" ,h޼yn,XxzD={x@nHR0]d4*ib=Sð*5C40FqРA dee-_YrnpIhl )H:P(=zSxUff&^6%sg9ps49 ?aʘz[-qϯCinnmɰE B zM^?tP E|g'Oq2͛7h4 BGt޽^) $z`>>>rpIl6mB~DpzpJ.q8Kϟ?D"sNppڵkm6I$I5jΝ@Aa 8nq#y!0V[]n߾ݼy7o"TnڡCBѣGvJ x .L< @`0^z^w3ӹv @peta]FBkM% l'H r7z#Fp8A߼yt{LL̮]JehhNRqH\WW%H~gLpz=I6mBVw^]uXjvڕoܸlq7͵  x7fs' 8ndwBfĻl0N8תU+I ͛#ݎ~2Ϟ=srd2>?Be%C?e)¹p2ujQ.(}q2ۡ6}gw IDATuDbcY@ʕ+@q|wclոruzrcn,J38Ai@4a5$ƠFuVi>H oܠj?>ʻB PMod4M|d'O駟Ν;ױcGDV%]D$txp ;FDhh(9:gMu(8D,<یa hyyy&+P06<a΃X'. ._|exx3fuh}ٺuҥK ō7Ba۶mU*bt111jzذaZvǎ_̍`Ùrr7p7U<ktFՙPi|XV Ùt/_b֣Gor8ٳ=9@sg4,5XhxcGe788ΈDo1a1$iFzo8pڴiץKR)4qX,E[n̘1l6wM偶`zbF({ʕ+W;֯_ݻ4hYYYbI{")Çs8hit҅i(gvx_/0uAs}fc26o͛'Owx (ǿ~$'N54kN@\NMI(j׮]k׮D$IB.h44( 7nlx<l6/]4##͙(iӦuuu$IN8}ᇠj8eހ2qqw9=4K^Zlm  RO* " bF(|l |_2,**jҤIÇj)o8h"LH$2CPסi,0裏eOQh߾}{ jժڦMF9md[n۷oE#4dq7qorz1eʔhtt_ti*́<^؝x8ΘL'5jTvv60DpZڵgDy_$I>|sХd2!bSUSSЩS-[B{ϥcg4a;7aFӦi,0e{cUAj 8Rnp/4ͅ"Zf3gf7YoH`j8~E`!1&+;;{Ĉw޵lM6YO8n0ZhQPP JكU[[0ݻw{Rt fL&}||juV^-ɤRǏP(\<o,XP(R;)9x(cߚ(Jooo$0ѳgOԶm[`| }DIӶy mHh00Xb1ܹԈ?3-((`& `0[zIDGG9٤I3gΔt}̙s3f EQE}59? YAeeea;\=ԊG6 Q=ipw7\Dq, I\lڕ/qB=ztyh4wݻggg7k֬UV3gΌ(J ;,jkkǎ{u .\g Xdꍍ%IA!++kҥ}-,,,..j޼VWbڴi\QСCϟ07|3f̘tqgAxTwf:h[n_$/_hт[,stx3FEv;V[֯طooܹs  !`h޼yeeKNZ[[ W˗ͣt˗/OJJRT(mxW"#Fzrʍ."ke0 h64e.HCa4"(Pm6 $k|isd^^^z@͆۷"`q>>>jpEveHgϞϟ?x[Z=xժ׹5›WVVFDD۷O,k44%&^G'È|7ׯ4hPzz8,C=VgKx Z={ܷo$_ϟ?_lJiްkW\&#m:jHB}||{.[]]&_~Ptah񼽽SVV&̙駟nܸGTpLH$JMMLD9U=e<[>Ε7g a4c5߰ Bi;pYmAU 2R СC;t bbbr9j4|$RA.],wiiiEET*߿LL 7555#FȀ@Ht59r;rQiF ,mҤINNNLLLΝ~ٳg@r '8[Lwz~jJG%&i˖-[n5ð)S榧Cyvu۳g+ j '!HtM$SL7 C h4Fq֭۶md\.iT|(l6D~w{[j\O%RCA]|‹f_ū# "xC05v޽TavHvvΝ6As*1Baf@iA1D ;qℯ^t8E")B˗ dE/Ϟ=ʪrjYk_|ٽ{:Ĵw9rFy߼yt(N {nx񢗗׋/RV7oBdNYWVV6o޼]vdMK3R&V{\V{P_~ٵkxDZ%:l6O?_!I[׮uB֬=,, NKJJb( ### fFvbr[=H&_~PUUx#GȐJPJzd2]v̙3Z`nUݙI87} w $qcc~zIX+Y2ً\׿s΍NZLNN)njpR)IPj͚5CV[n 5j)))EA=ݻwN !sssifWxxxUUUnzQQQ1rȈիWxX_BDV:v(AG4GO~hf̘Qu.HxӦM9NVVL&SՃ ~:;ZgϞ8ɓ֭[ڵ/X,BZjձc&OMvѸdɒO:5:::))$I@@سmٲ%!!d2M Lu쬬,RYY` :D$Tm{|l*]0̎ar00HVCT RW }s CpZ\(R[ϵJ{P ^O޽{~~>y<1 SQQC(zP(J{ΝVZ%&&ZVT\~ў+ :u;ZNU6t:]@@aׯ"@m ^xP("##fsXX؋/\$N:gXjSJEUVV~ѤIժR*E Ξ=;dooo<8ew۷{ p Fj6Mf ۷[^zݸqi^8<#DR^^ҹs缼}e˖jB].8q:oe2Yeeepppiii`` sfrwͺGPsH+V޽{׮]`СlKqWKJJfϞwh]*xB"hZooo\ \PR* /0P>lEE ufΜ J?c.]RSSM_@}EVZ{.D2|>]r%˕SLٷo۷oEQ%%%EM 6L*]X0@ 7o޸q]v&MϠovիWGEEW 9 F'ˊf(Zmtt/2vC}.0ϟ?ߦMJd ŋ'$$޽D;vGh4H8.00PA Aw߁^$@n… Ϟ=k0]Pҥ˓'O7o)H* #G%۳ I #K!$ ^AIYR@(,r "n81vP̌$  32vTUUPG't-[,--TjkkAEYL0e6DQԍ7:v. #Ph4)Γ~ݻs0  ~n4)J9A%͹RץraWee_FF"t$gϞ ,HKKs(o$]v9 Zʕ+?Dfx۷\Gy T u-`* v -DQO/;pqm6[ttׯCCC)))XhС{r=z2d<8Wz`N§EhiݎXď&D(;4'\;" c|>cǎ\.l60(pBAAU\\kXܯ_ <}Ezq h(]v(J(>ÇCwO&?k׮dPRF<C|;#Mӏ=\kFAww+3͹Yӹs˗/Cnַk.))iJaVZUTTIHDNNNn x@z-€Hd+z///foZZСCa #yg2 A!T*ճg}-ZT\\#W"iӆm ^5gΜ/^tݻwK.xCX_޽{`Νx0lܸq ,سgٳg۵k'`1=;C=`RBE Pd~;TK#$rk4 ]ЯfS&Os'hZ8R4>KUV&g6x6bŊrjj-Z8xkzG9r֭ҋFkjj$ ڠ!PNN׷m&HV\IEQ4Mt:YA@?>rHv޽sδ/^~}ٲe .sss l %~͝\BAaHdoz>S0AOF#\M_X*n(֠0%f KjzձF<7åRibbl(*55f3"A#򂃃iٲ]bcc{IQ#E 4PlX\QQ1v˗/P⢾DDEQKKK֯_hѢW^8GTQQ!._ܧOFAξ(HpILvJ(o )߸q?7` llӦ̓Ë;wܰaCNI-o߾@.VZnݺu^^emX6l5k?zz͛7ڵKף@U|޽믿V*2bhիD ?g̘[ s@cǎC9Jtcq!05a*gV#F秥C& 4!_tw}g0ر,b)2PC貉.8%]L`m{ɓ1˭HIIٴiSNN2/^(<B "4m0ӻwqƳgC uKz5kIQTnn.0˖-x aܹsZmΝ׮][8<.46χեKFaؒ%K> !UV8p`0p8wdee}gΜ).. ܹs4M߻wo߾ f %&&Չb f͚rv毿_V7&D |C5U ?0%JnTOl0 77W(oׯ_dׯ@% 2 .|Gׯ_Æ `yvf̘.md>{ӧC J"<|lb\./)) 3gNqq`^fӦMKJJ po۶wRRH$h4Z}Jr޽Ǐ'IR(B(Ji>|8\m$ɚׯ_  *s8aÆSz1c@͛7~~~<<=:-,38I$ `322 DD\\l0^`yM]j:!n܀B. X,w裏v<''ð}EEEǜ`JQ2W7hѣG>}{PGag&,Rȝ;Wnt 7>>ͭD")))B\.K.A|Ž˵Zm.],^h4Æ +))-Z{+WLMME 5d(xl &lܸVn0ŋrsݺuK*f[,*//+V(,-qӦM?ôZV$7xySPP;H6m={xXu$IB' [ tYB=z=٤'8nw.0, b(*@;s8___T]]ݯ_?aֵk\`deeIRޱwyW!?[x1EQ|M"޽{/_ -lQQQ:u0,,,,,,,77CFFHt,Q!رc|A\\̜SNs΅3tAa B edd#|ʕWiہC>(cB$(%J(\„ 'Nزe˦MfAQup4-_R8[^^>o޼={aԈ☘NWYY9{aÆ]v;v(*++~vAӴV=z… -K=D"ѬY.)4iRYY!jtzW^bxΝ:tx)o‚}\6{8.hPBL&6WCcÆׯjWXx B,mXm&JB!zz`0<9r$7nO /ʜ:dPTo>NסCNj)߲W_%$$ ;jUPv7L@A¤B}v˗/[h&,^ߥKlHqŋPBzVr!u MMMf͚>ӣr__Y2;c0L09,qfzzDRƚ>~|ŋ翂V zP)9s۷o!gF`,cP,Z!C>oERRҸqi.,,رF! 6d2Al/o߾ h;g܀6&;LuIqWtvЯL$IΘ1å&(Ƶjժd2%''CBP ~7UǏGj رcp8H`޿rN7c `Eg}"T>R8qgڷo+V 8qfx-Ziz`d.---**j׮ݘ1c,Y2qD N{1/ 88~Ν:P5l0G  KJJPAQXZZ;͛7Xcj kc'(鼨BƆn>Rݟhx'U(jQF))S"HӦMU mR 5k6raÆ}7d2?|ɒ%^^^& Q+TUUgy`^߽{w87`qw zw] Gwڵk-K\\n_dIBB+JXPp K={VRAl .9Pu%??_~r\Tp"8NZD3f8zFAweTN:Ajjj~嗯`06k֬nZ5\.7 Ax. jBUVl6Ú?X,111?{#B .`;x'lܹs;ؑӧ\Å LxCid+*e>pCM޽[T(P,AE>$Ϝ93c ZֳFD|IFFf`8('7}-d2-Yرclq t̀x }App0<@6_"A%]yH8O܈.֭[!O%It LJBɴ~z ̋/"3a^8 {yy5_~J `(8{{{ŋ%$$p8Y>jh#Et??yF(~m۶=~8`@]#G_I|>"+D@Ym1 bqNNNaa!֭۰aön kצ"l" ̄l6ڵ 2 $3g@ch4;wӧ˗q>@ v8z$w92fC vZ Z5Tw./HΘ1!חaҤIPb+h]r6d޽8?~Ϟ=NGxT:EZZHܿi@?1#.;oܸqΝpvQjPPq6Mj5_%I $Mv;[Os$:ujܹU*--%IKY~}Ν% Ϸlw1^† Yf͞={۶m*=z˚ÄiZ& .tneC&Пpy%\z{n;[Rٺu/_Wv]&Ϟ=j\۷o߾}={a{ꕛ gMݺu{d6#0]0;;8 !;ZOFFFY޽{}gyyyB=+јې]͛@C@p²Ç!WXv-tlٳgþb%,1q/^@ϽyM4IOOcjL[޺uwް=xgϞ͟?g2ݻ7`yl<{lƍA~UHHȃ-}l;v̞=!l0ҥK֭[Cr#g`#;X%?b*z(3#0##y?~y</3D"^R (^p֭Wn۶ >s ylIŒo2V+jp1 kgz\.o޼WZ-j$>>~…)6ϯrIM6-[ %. ˛4iHM V*,,޽;(UUUj  qi ^j* )JtDD?~ӧx%{%'jqܦ6}}q0\~nٮ^:|d WGFX6///_z?x<^uuŋLLNX,NMM5kbJh աCvAAA^lNm7 B5iX0Ocz ,spsS;CoO{޶mܳT*Hl?~|bbĉm,6lX@`0|gBldd{%%%x :{lJJ֭[ ljjjH|fkѢ@ HJJ<(2L>}BdXj50$ɀ=zE4q\(;V "u:]II\.ۿbbbHH蔳!<^zzjʕP󈉉ݻGu=(۶ i<:]pI*Y݌CʃZi!!afС@D")--mڴI=a9s_դI_A0M Df9""Vpfp|\.1cG}Ժu۷oN!t(Xeeemڴxp{h4"<[$&Lw=zSPNl6,/// "w~~`?mz(䆅={=zF/&<Ilnbc/K1th:0zաCG}m6/f_;wJco,@Gxfȑ/_q:H(((ʀ߿?33m۶'FfJlZroѢ@ ڵ> e/%-~xaN>駟:j E]r`0 ̀x!H ߿_~ɓ'SN^ZNJJ@ ¢~un/[ ypµF_~/4m2 hٲVeC; hfm۶_nZRRbZQzƖxqf1bς /_ UUUФ6 -r 64}uTZ\\\\\(;:uTDDDkKv1rd|>Z)!rGT5|?~ƍ ?/8t'F(E]wѣGg͚vZ5Çvٌd2۷-Zd2P@|`p 66W_}5}M6Iׯ;C:ٓ9:::<<<>>~^^^%.i.˧xF\g6^(*???$$h@O>W^>}|' h ^^^p_ 7nroooNm %_*Q1 ൵aLv. ` BaUUUϞ=srr\5 ]tP9u*NQUU%8Dl?#S^^NQTBBš5k؃ Wn :`WRZhQRR(~ǃ: ̐s׍@\=Fzr !wPF^PPB u^ɓaChK\Оeeff4]]] 2d|3DQԐ!C|~>}bbb ΁R 3f(**B%Dyݺuau5@ }h KLL!Eq?68ɹ\#z Ib?jԨ$𷃂b*>}:aeeeݳf! ya֯_SNٳzҥKAKӕVbZbPsP1݋0all$y([AեKADx `t|×nϟl<.:?"RW yf+u[\3WR[L-[ M\]/^(!}303XReh4_5H go U*L WCCpRiX $2~??qwd& Z D"A*ծ 0@ժT*R{4Nt&ԩSjJy/P\\::1*\$qC OI&=˗/W(zhnn.JCq( <@ܭdi@㰹.! :Q]g7k5v-(kޟ^>1ZA[UU%tRT IҦZ,eee111X`_/1ԙLVr_~Ncq… A ]of3Vȉ'.\afu:֘`PոF9sfFFچa_E.O4 V>Nzw҅rT9рあ .ct`^FIQYYY ,9r _%q'|,&ý  TT;v28nӦMt2CtF!.MMMnŋ\`zM] M¡p[Hw4)@ބWUU==?( #eC~:7G=zdggw>}:%%P]آxȐ!$**J nsҥVU#V~)yŋqÕQQQޡC>"vک.]?~|ܸqJ'M@477ٳ}ڵ ޾}{jj*Oϰ,B-`! UPP0aݕ>>{ _B2bqĸ3g`/}2% kD(kuW35|EÁDe-$0aq PY0gΜ3Fl\&V%.2 бM8qƌsQnEE`5 ,ˢ?;vlsssEE0ݻ1k J \BBBJJ 2:pf3FazZwu8!@!길8uuu'%%IIIZ9--g .! ǎ9.-JHgرFx JNK^xd2  H,f\\w}QII Łt;ctے3gμbS1jJ%JrvFr-((HPDHnjcZY޽{pp0_VV6h - +HڵZ֩S>}phשS`tux ` VVVN:Z~gܹooO@ )GX>|8 7!hA=|}}2d裄^@HٳcǎBG޽{[,`0Bl&M(,9`XL`ڴi~~~LXd}ٷoǞﶳKw]szYo\?O=NK/dfetߨjZq\bbbJJJZZ, Nˮ]H$8|'rP(H$;wܽ{7x9JMMݾ};v܆*اUfN/&povR| B4tRddJPò1c t:Rh] VCvv6tĄk"*Ϳ1rͦ/^,׭[7P[[Dzlff&'BA C:thc,*JuVVV`y!CH/%ra4Z4/[P+u ;W^y &iݺuT9_$,Y@N'H/^|Fu`MMMhǷ`!^BW*@~gC3ƎRh>`jbQ :3g"${O?'ģ.]"N2ÊopMMM͠&Wĩ8;p,7!V BuuJ*..޿HH6MBrrr}dYU#<իW[,tr'd%RrAO' E}MQq#V,/_6mZ0@,'#Е$>iiiGH=)D%ȅpw ZmQa͟F!^Raa'4$qG9r$T`td'I$e"۷Fߡ\./,,/p!/8pFxl>y$R{ZݻwWՍ 4hΝCZ[M +VƒA GӍ?H,T*%͒cbbH kmm `ݺuKTb2bѷrP1uG=JCzTm4{}Jvld~IMRU,k6-Z7lؐ:zhЁ G:L2P#)**"(ǘ2 hҥ[n}7sD$ \kٜ۽{Ck~&oɓI|eٷz` H*d2, g\ dgimm8qb}}=Qz,?Ϙ1c޼yX! lT 0Luu5IKb=CjBؐ׮]lׯ9sfI;##CR i0v;(Ο?vJ`롨#BOX85 W/9zÇW[[OF>?'X@-zW nn9p„ YYY 'PFlJl E^/|x@ZO) 峵5k߿s b VH$`3Ғ%K6n޷V}vpPK.J{Q__؝;w.++ѣ"C|V+!>Jŋt@l"!udXڴi#Fnݺv5kָC)궜#'uI{wJO-n_Xܹsdd$-k(ՑC;uHxgΜvZJW_}Uםl>x`.]|r2R~R]]ݩS'eg͚5o޼^zCH5M&SHHz8Ntjii0af'+V$''O>}Æ ںuH 6mڄI$Xi׮]~~~=zHII 4͛Rf??sΡ_~%K%p ]lL&#ucǮ]v޽_} ,lӃ\HQCA׈#GĠaO5E^NQ* "gJ[,"ݻĸhv^:b! 2ݽ{w֬Yd2u. iii;v8rHiiի);E.T ׮7Soa4NG;C!ȑ9<7oE$7`$HV 8$ɞ^ollt6l6#;7<;vP*HW Hykhh d0>#V׫wuMg[V& l`8ʕ+jϞ=ۘD"l͛Ph@?}8'/RiACp;7'KK.|)q(ۃ!t:]µ`ld+W@L[p~?$AҪe233 #1*J{L p<(|ZlٲBݹsJzMQm+o@ -̥g?۶m† /fonݺ c.B L&˱9g̼zjSSI~~>jpHRR[ J`L&O? :/R\\,CcRRR)-- $_z%DYq\(++ 4@WV@SSI»w:͛7$@C"w3$118H/,zئZ׭zM(\ Egݻwc" rD)V4Eݹsg|||nn.qʗ_~ɲb+gYO,n<$?333O?C_0VI*̙3GeYvZ" cf޼yw!11 HE IJ,)v]^C /ɾSn"[l),,~[=fݦ^HBǎ? [%B܈"ݻiӦtCn:̙3*ݻwBj׮ݛo ZM*!4::.CCC۶mzs熄r:\vmt:Njii3gNAAAee%?ϦL0!77ĖMMM}-((ڵ+A:.ꫯ61NQcIz㉥=Ix_+L:PdԄ}u|d@u";ݾrʷ~0Zث(I./UWW߼y8/]h! ۳g Qt}}=?PD"NO><,XZov}2cƌԭ[rWWWW^^|rR`WPB w2~wo6a,ԤL2Q.IOd2UVVN<deea84uLQ0:Rn%"^_X;m4Q)Jo߾ ,JLVu Exx8-(BɔlUr|XIFeYgIp9ؐjzҤI(}0z^P}t:Q:1,ib@""" 3odYST,޼y322nJ 7(~w;NB4(55_s|6٢PyrǓ!RdV; r/RKo(Q0#gV"BjQ@>7~,PPP.]/_޵kWŒ 7s nJh@۶mE8$$̙3hC !!!.]jmm khh HسgϬY0e˖\gZ L8ՠAy`Vm۶ϣȸ"""HիXN'. &En_hU>}Pu]ZZ:iҤ;݂2/2==Ν;D`fB gZARx&) H^nf ߾}}]F"?F@ J"RIDATgkk+Rĉ۷LTVkZBB}0Ї---GAn޼yfc:ٳ@"j*~4/l6iii2 5%\z֬Ypܒb?{Ⲳ2S!:*H&*B:_%ϡ466VT>}zҥzT b)4~ iZ[[O<9f̘~ZMā)*c<^cӭT׀Г_ \Α5|a~~~7nYߌ$4֭[ I6Ipp e2)**JNN w.::Z(戋âFd>p˗A$YSS ::P]] lX%Mo$OxLQ`f͚tw:tXtiUUa? SxdXx_otrcYw099_{@缡ÿĉC[nРAmݺeY&?Z>thر#HHر%BO>dŊÆ C$ ⺺xBAdY{ΝꫯꐁPa$,XY:w,HτLdժURT.6mؘF#|H[S|A۷JJHH}vZZZ޽W\x8(M,#{$k<7=Гb)//Gpݺu (pzimUo9s&Yxl jel6' 0 H+@X0Aî fHH%=]ΝKȦ %h82=d2 8PR%&&ק^zy\]?eb>Ghw_{)3ɛl[GGG[j tڴi @9D;b|仧LB-ekjj{Q.Ly׀f.k !55-`%&&h4 XWhHB\JUSS3jԨ{v˲_`b8~xbb"' NZ~)wA;Ԅ,XwP._,QS:x,_@fYSN'O1.m۶mڴ\,))=ztjj]d1`F#Hӓ^999?>v;R֩S7nW9$CXXصkF)r9Im۶͟?e"TQXb˖-53ST:2DGsfC}EŇYYY}ϊT>}:**@q=uTڳX, BZ\&A;,,ׯ7LwQ(P\l(D& z5tW^]ôE@ wB==YTZbE" yY/{SH*A6L9U0XegTR[σvw˱Cb (hՈ^|b2^oDMFɋÇgϞ rqAN)/l~'ˑ,G#ʕ+7mDn0pwЁP6Q)6#B˒%K222\WzÃy J 7Ut ptHSp箅uܿ{_LHHXl0;w7nkJ AWWTT(Jɓ'iܸqJΣP(͛gTرcǐ?$Q( i׮$*+;w<{+h"F=Xr۷o'=gMo;wn֭T|/"Ʈ`>SnR / %)oy[o9V<O@B_~$> JExdY\|ן{9J:H.a=;wdggrr @rWYYveWpjuVeeyUf>)p^n>-='I$or7{loP AQFEDD$*$=Vpzv5`0ܸq=jze—E:!q0ݺu ͛7V>)=_z6:oX'άHD +:A z֭Ȫ;w<|Km0]jܸqcddMU*"ȶm:XDV544 { ٌvаGuVǎ8P(V\ LbBٳz}CCSO=%f~8GANQ*moPO+ #0-[{NHanv{fh46-<<H>1L|}}]ֹs稨7oĠls:}+УTQqqqf900pzm۶fߟTvرcY·}ϟ555#F U0ٳM&ӸqmۆbbImL>)/f @АXC{!p" 0Ĩ)E͔GHH~ፀ-SOJrРAwBaƍ.@l6GGG tRoFGLQ!Via\z /߭oBnԮ.}:O( ݻ(&`=Pp]tB5ܹsƖ$44pO t6kYS1 ߆Xk'1.:dX+ /nգR?^@Ahݝ_ 'оrƌՠ?*#""p~ٳ6,,yʔ)(8f2)+0|wNMW_b sۚCfղ Ғ]WWGqjnn6mڞ={@ I]L@6w\akjj #=g(A|KͿ96mRaf,e꿿Wx +}lB6e?ȯ: @޿]uݼql,ާ.F=߳S^fs 2z)tRg ]Gp4`YVa, ]x$v-`>X&yGo<+@َM̲/F=~I@iryWfmb1;|UO9Wf,+wb֣wPwB XL #<#$e[kbדk$0Ms Va)>a`ԏ{ YBnf[VA&(~=e2]OصP]]]2zU`ɧ⊵XÀXXZ.H0Lʜ.z -o#йeĚ4bӫBC]^&۶mO9RS.XGа^X_B4M83B}6 YԌyD %3"-H)D"L a+dبup ?sO>xef]w9΄wOf2 @זVfD5{O.u'Zpig/ިGzNP* 闎`+[i~ vK">> 4כ4,g={\kvn_3{ .C0MD@$"0H)D"L a SD@$"0H)D"L a SD@$"0H)D"L a SD@$"X:ܞ"wqM/^zII A"}Yq}PERͿ h= 2ׁyu.-Gn8?׵On"uFbSaJH:gՒ8lphƥ g_3MSھԏ W;rh׮=CEvZƍGFFW\nL>q#n=-daD>oDTQ^gc8Nqw{iKkNٷ=#ygmoIwXkm<7yW~x7F[%ȃ=zJ͂)<ؽyĿk M,оÅ[˲ ׭[@ػwvGepaՙ9ye$Mz<:6]r{9VS.݉ԶMls|ӈ#Ձhl6doh,S/ڋi;Xswc'*ڢl;@RCn#w&;)$'ӌ}[FAbŊ 7?L8 Sxp*_20{GJzWV5h܁]wT}miSgUS~:|r5077hϠۈ->ԇFAp~F]5eO.| ]=uSp_>-] l.,gڮҒd. %|~Fkquː6؝m8_ce^16[| h}˹ʃ&oZE\c`v;㓓jIxvz% '>!RD}=We7dҶy\l#Ӹ.s3O쥿0:z,G–񤷏Gpdndh;Aca5|Uuu<7"~廗kiӡyK&i˂Y7d Ͽnʌa/MZ(~ӉJ'5fѸIc5z;~`tt?cCd) _Fav n¡v;зo?S٠iz|KπADl(x(**', ]//tP` )D 1@` )D 1@` Paia04t 0;'MRշ?G6fgj嫌LzC̕{NgNX>؞,|o(6}Z2kf\{>]F%vxcîtg*3Xr_Oo#s &;F;K²,;o&5 ٸ!m[ajĕ s`g SaCLTo0Ȳ r%;Uet(}Kٞt0ABzph-q8ujSG3f 9}|yù&&v?[mKao>} I?v[Zk ns'tc"m:19UCgϚŌ Q{ `qB;mE”zG^$0H(w]S ߡwb ffגI5?(@  ~dߎ䆒Xݣ"(~W") ͆l(za$V/лI``0H&Yd]oL eط#df4" )]ƍtk{)^$0H(Θ˸9X};;--,O76Q0H8* aa0 OnaÆe8|:G] BA|ۂ9B1\@* "+NNP LE 1@` )D 1@` )D 1 \ L HCTIWLƜRRw w*$+]Q k7vc,mݎ8cjAn|NA4>]+]V{Y&Rg$V?w~;( 'A" SQ ssٺe3\\2yt0m"7"(mYȳsG`y yֱ|\GNĻ_$q5d'[Y!1԰V/ rn}/ ~ N&_@ߢOO ^y EÉ=lw]B֊E8a7}2sאǯBҕ/~.oҌi,VLtqb.I%sTlX!KmA0+ Rj<}IVelsr5~uw^D "* r/(T2sb*FaK;)<;/",Jwʣ7u5;@DMEET9 ^X^G3"rN9 [T='`G r+4U 6*=.? }@\6U/YɆsᣪ='"禲/*Mj`^6{,"MpRIENDB`gtkada-24.0.0/docs/gtkada_rm/gtk-range.png000066400000000000000000000113611446021174000202770ustar00rootroot00000000000000PNG  IHDRh5lqHbKGDC pHYs  tIME: L~IDATx]}$UUuz6w{N| `lbR@1X8d!F1qD" 6-&JC (bql{ofw>{f{j^U[f?~իW `u2ǿ])kޔBhǾkך{NjL}1[\(k>!gehٕu/_'le^~ʑ  ]$BX_UA3~l6qGJ }$w~~/aTB@)D@zy»y3jt\e"z0ļV/cw/ڞSw=ud>1m3 l9A $xpluuEr'%t-<"L j~,%8F| ҽ{'Kk`~ +3JMTK˰UK{}.Qړ-Of] (Ba;o#qUkJ.I IJ4qnuc1]zo%(B4jXi+Hk#ZJ}Cf7 I녀ǟ+A\??:|  |q\z\[bšЖFF \뷭W-VkeӒlyiM6r+o.awܧLWmv%D)qE.k6|=KgBG1tfވy {Ϩ5Exp_\8GA$ TI6X[#gMhpq:i9>aҖ(muޕ_Y%ᲩʚBcV :ȵh1aia$wdEEk@)|Ӎ8'C@7捵N珑_2H\}ЀX_GzfC@V{˨#;e7&\>" |Jsc K*Sݙ[yO @ðA8Duh }7-%tMޫufNV+x._ >,(}qi`Ԍt,nEieoEV.;i(稉pjTAmv{2sZ-r{?ڟ<|߆`$)Blxk6nkC, $59BiK쒔bK%`B ;4;CmM!c =}XiB*ӰE1W^n|G!t5x  :T{pMP\>M&tif>\DͥxV؞ӎl%<5vpgFR1www !=I͢Msfq]CT'"@ds$0O -%D?d~V m>N$KxP=@ l=Ve+ OiHU. KC..nC\e\C1/ѩ}!ԟ}oEqC DKh}(0HpAzwA-M7v$^[~{>1$ ʯq3nj> ~Dّ}v*rץIS>. }[= 2z߰ew%7oA`;  $̡ }Յ8 HS݆ ;X=I534#h<D_qr}cISc)YȂ J[5xjb5{ Pw4{oHLy>T>A:bH.~3O |=, 4_sys}&U6d )ifCy]nUKcM7 uT 2 <}H)tP3`4)VVVEQElI4Y@32b6q)#t5$E%֙$In'O/4i!R~)s&`lܚRLK*""p;5h!$V ̎.\=$*#?Oj0}EQe<9֐R݀ZVz>y~dc@=*5֠ ƖCJM>qcpo[]c`0Zn凯8I4M߆;|i4IhȴmW*9Nü<VY2G^||ju׻6c14TN; յmF*Cz_]iV!i'sw[mHGuiת&=n㖷'QռOKUks ԖS["~Fn4܀S杔神_׎ӝ<⁙-r3ɪݐMY}.iݝC' oz 왺6A6R gϞw5nHl@Ifs7 @|!?d4 w*۶KيWqmpDKC[%Cѵµ0, jKனkswg¡KO YYSLz̺Rbuu_7nuz}iήGD!a rH;>l+"̦QQ/jZQF-䰭ri,Ԉ,CVfQ##9P-JInnȘ]@Cq^_4-4*/IdQRHF&XZZ7*Bi`}#RTs֐B`mm5h wqqCevI{_l~y[ٍCC7Y-hc!y+Srwt"󅖸ڟ©Sq.n;[E*,}\cB}f~ݻQ~Hlm1CIBiN<}l,4Mݗ]~^y|@/'^`0[+E/B=}iU5>ʐܭ"w@MTk'}Ivrq><_W+X>gyۻ } nR.Ri.e&8rc5`0*X `3 c-q ڸX!s.,  $*`=?4`0^@2xNX͏u`0ΏVp^ep:ԤcCj?f0#d(WB9Ffڐ\v -Z1f,o`l.~.`0[rKG̩VIENDB`gtkada-24.0.0/docs/gtkada_rm/gtk-rulers.png000066400000000000000000000425201446021174000205200ustar00rootroot00000000000000PNG  IHDR688bKGDC pHYs  tIME:*%ޜ IDATx}w$USq3 DE@P$QPTEĬ.꺟yuW?utsVTbXA&憹?:Lwꞟ={y}&@{^zd]Mo:?8@EƿSWUOZC0ݯ}^HǴţ{bKv5  6KiFu~K֨f-cM?Ö`VݒZ:1j]-lnמ(?-e!jJ ʍ~%Fͯj5>E<J>@ mp0 JUur9 pGYC ޯnXge67BSO~4_l}_Tw 6l8Z{\ƚ#cl|>b>=X\c~u^(2#jݎ`A\pS~z#{+W|>O\6`,T)#xqZdWӊ3Y{BL4&zE@EHjR_3?9RLksRc3\*'ͫ7M5cHRMۅi?;ܹRmlg yd2hu|j}1CQgu]TU0>/Cc_Oay p4&!~\X5yw9I.9˖McUx[ߎ|б 9 C` L;2=={݂jZy{ߏ5kVwX&.y?~'~OǕWzh e B|Ûlz E| _ڵknw[\KZB`5.q']._rGbr%?+VZz^Fnjr׼($ή+_TujJ?m n3t]p1N~8qc[^җnyi8ƞ{:W,4v5WbhjuPƦMa7g'pOƪ5pum ˗w݅JlsBXvMij;,[Caʫ^t:mĥc]9|ⓟƅOLSxGo8z&.H3KӸUؗ o`Ѽ ^_>7|jrlJw>m t`.a||\ECQElb xk܀/~H)e eEJ% clb9݇bP8p_o{;qG>_.(:mgZbpdRbB: {k3ru]ve/֯_ZSPDwrChAX?l݊I8pé}!oshJׯNٳy)6W.br)صkw9/u(042:~gڱT*Xbnַq`f0 _uFLLc󘟟ǝ?9ڵ x7|Xby6Ϗ;vl3U[wo :62۳g/w56oAbݺo#-lns]<Gv$4 Fܫ^Y}T,al| 7A?ģO>t*[6݊'<̆T  V Dlttd2ݻCCCp]Zxyֹ{N?\wx'}aٙYuԑWoic=g_|" n\/~'{J2/׭{= 't" <"tn gq:||r+=l-mT ׁӰpV!Bڽss8G54d-WxOBLv;N?T0P,1>1^wvtm80N0;;͔[$C!Ԇ GP( Tͷ܊Ϯ!jZBmێs/=l"NSt&\;vhõt108͛^ǞR\6~{)}aa~~+V@TBݷow^q# B8fs.u]jW9gRZmwu]^{{)OB w}8∵XfuK\-܊xnc \E\p B?矏j ǩp=bŊ- j``?/[#;'B4n6yy>\ŷo ^aDnMpu#xƟyA`rՑxeannsss-ۇ;5LNLZQԎ5"`JRoZN]f2ע(:X*!˶$R 2Z"42k(#N(( HS# C|th5^ֹ9[ϫө5K%d2]R,!vQ!BTFm_ @Rs*Ud@0 ṝb\6ۡ0jwnw^UR:M.M2}7! P.W¡ZC8TkHg!R)5"4]ZL6r 82 "tZӬw$jJQow;ⴞWT%B!~:Ԫ5rz: Q|48ͶɭuK\:;!9B\Wբ`];wusCx^zL&͘Z؂^^.OauoGGT-bsppJe.Ky9"yQE M)q\4R>#ex$؂i%j8S17; s1<:^U`z(S.N=M7=KzGӽ'iD4,q/-㡹\*g<^w@.˟ s3#)I}pLY&Ӛv>GiX*44ԁ{/#xl9ݻPYSl+َ>&L)z&dSF5CJkHH aX xdeqF|7b90|>D[Kڧ稚@ ݽ+x6i*͠L䶘#x,R4~×p`;|c`umdKf%Hʅ֩ș֜RWQFaH2@E[nHa\ LNNZb]!hL[ɴ?^2).%WHz-lx$6AL\.YD&lb!q8kP$ʫ1ԳgZt}^aH2={ߴP(=uqU!aJpɂ?!pf9EKZS#5.5ZaH:= f2? cccXv=B"Nњ&32Oл)iJ#Z<,IǣA,dҪr&g)RkxTY ݓ"{aH"=YlmE:hE#%QhZ@%rZ7hO-Tu\bY<,Kخhۑ}.;[3r w\Ʒy@;09X<,Ipla<}涔͕p%oIShn)ށ+O M \&9ŧp(GYKb˟\ O48' 彘ݏ"U)~FhjW"Lk5i=>aX xWTg>}{7,hpLSwHQk4"݁*ɥhZ<,IãoW]2!5f*BRwXxPqAKIuX-$WT}aAhhNqGK!jS5%ACBTI%E,ѓ`s]SS[u/NhN23ZSiN l*21#xA={b[sP-\ıG V":9-6m}8r3˩B)dbs .,ї`k^rjJT{yMA1(5ur $ML=ƹi3G8,`b|CljD^Κ/e|kƇqe&~@˯hy͞jX<,IãoּQOFnnʔ&p$M&3ŃpfSTHz* lkZX<,I/Gy&&5zV*Ty'ŵIRڊ&DT:I [<,K 96uqJ2岚|8rPI\&A%J},qX=3@.N?p4W81Lqg( ƭ:RwoѦX<,Iã/E ޽-p]A$v*)gHKFr.yK/)ʤ gx$ -նs.iLO7oNk.蚲.'F;qGU(&^#ikJs)\0#ixűu|ʕT)"!% Jx$Cj‘$C&M xXExmկt:_.c׮(f{P]hw&E*l5E4ſ`x$(詧?؂͛ƑGիW!;0(C2mQ4U;F%N4j8fig#x$00<˗OCCu3q j]H'NyMwTM9U T#xķ؜z|7b~~\6=_)e4/ES!}ʚJ[=ͽ9-',%G|Z @5x.xd2*SYnHm GJfdO3MC黥q,;xE<;Q'?/z.||7@5[ezS1MKW s xX<EE&y%aH2= /!Q/EPkHWjRRDRmd8]˽p-$ѷ`Ρ_hn.ۚP\yf$T2 S%܁h\c)ѳּYR+J K|D+ҰTm YBf !|VnbdK)G;*|hT_\!EEՀQQ%<2qr)t&w2eS~GK5|Ņ-M2'{iЏI*Y2܏j4aH:c[me wDz/mgM25è"5_=t?xX=uؤܦI ;L\cmN>,ѳ`,/ܶ= yǙ?Hq¼\YI 8FR<ƴ69bx$](N񺿸X{2fN!W™Z_{@v6~ir,$ѓ`P#}aaR EFjJcnF"L-^hD#xlaM~7q]S sD%h4Z!QYTO*nKEšȑSex$؂\nz<gs>^}_Cœm1+z>Mqow{h0MxX\ׅyַ(WŷN} kB\6DrrEqd87rM2S-GtJg\~nWqkl4<atԋjq6Yj"[ք)NAFP^pS,᡹a.۷op' !Nx)EҍiuL5~kRaH"=Yl< #A An 6ekz`q/G%6_iHzL,~QNDxXLb;u(9C[+hBqxJ[<,K] ~q]44\+ᐆJĥ ekRȞ:x7!R-$wTl6\.:XR gKJmFKf7UA{],i.w8}4ZaH:%csR Ͻ8#j{t'Q5q\N{P=qкP\m(kELdbk(=Wa՚ucLB\R))RҠT-{He(RaDR'paX xljqC7}L}׻cpԶI*TiZ6 I`jX<,K `"`۶mZ]9t*ĕHLt4 KR8ͣɒU(w\w װxXo݄GR}[~Et"Դ9hm.0TI%\ʷxX-l& \(]*)LM6 5\!dZxX8Ѽq aƕiGRYyj*jrEAZ`M(^4*sK~˯hy͞jX<,IãǨOTƟ)=ӣ5#@}$Ф|cOJkesMxX< } >7=B6͵R|vSj8ZOG;ipӺC)kx$["<ϋ+hgrZĤ4$MdSK{#y@98N#@#)x-ֿ{r,2lfSZp!uϺPq:ǥ,Lckq.Y90 1;;O P ׌4955RF:TTWmT.cx$,6^N-HRZıI6BVͨ8,.GV%Zr,MHaH:} a1dr#Z( -5"M\/)qgɢBw4d<6o^,ps&+%wT9im{sZ..lx$]Qdx߿ Xs$k lʛp4f҅;8֒ǑRf\7aH:=[l,<tz"ΜTcaX x-J?1ҩFFFBEvJmM-7B Es8ә*45x!@NJ#x<(JxޕWu]xF zx μ֚6154&4΍\BG¶xX<[b}SSqZks=MZpG%-hq1nKh㑊G_[L&ӑ7j}_Kr-eC nΎz@;WǁY<,IƣtFEWu]-ehs%$qiNSHvPz7\+.Gm^l111UC DmdI)zFIQ Q_׸\D5ҘGb3ILuqќ,HphjBi릠TxXstƔQCӀ wk2PX:Mnx$]QBBQ!N\Z& qJ>8]mw#5%Ea#GRK5# q`HItMY&ӤTX[: JhZP@i`.% lxEm L\ckq.P MDhV7M7G4eYiqZkR4{w}5pD<Ԃ-JTNbR6WBܿ茦ִ\R<+6rTre,$* <3JɅVUd»R(Y,u!4q.\Gi;"PT<Ԃ-N#jixIQrH:׀N5)-pBGRRtrJrE4KM.گh\Eja-ԁ2p$)$mox$\a f44\ҪM2Pⱔ-t:m 8R]"L/_S&5HҌ8m%M%dJ΅Mϕ&Q8#xZ8կ|[ĺe H&hؤC8$MNnbw]`#x[*j u]uZJdIKiM}4dr5l@xt~ƹi3GPsl7== qpa=#ljD^RgR*)X6M洎g^x͞jX<,I#`E!nԂFQ.n?sTղQx 0|N=Y&4Yܠc)S88 8q?~.*^'tbFM$Y(Z#őipӺJ{Z<,Iţ'֌V^AA2Ǧ$3J|4 L6DMϱxXO7f1%M\A&&P)܁.[\:Ҵ"=,GZ '0@FpaGIydk|qGj5f֡Ʒj\ !ekc)_Eh 1ǩ{N,_CJRu|rivKhYhr\4KC<[<,Iǣ'!BTjM88ZaܦSR>7#q&H!s;HaH2=Xl:k?q1ظA/sÑ6+s[)Q{ 92}q̵uF\Y<,I#`kG.U|H:qp$dK-]i-yqq#x$؀z,,Qհy-f4Sʬ7N|8W ZhJ{jx$[c%V^z ֔4A_q)ĉfi]*DMFY<,Iǣ'ֽ{te K zaIASfl\AVX`p"$nn֐S!'_ڄe/{=[АUjVD~P 7ǡln-l e5-":5+e/{=[Snlm3Ⴚve/{=̯YkwG-1O{^z$?.uEe/{=\Qt]KusIENDB`gtkada-24.0.0/docs/gtkada_rm/gtk-scale.png000066400000000000000000000101671446021174000202750ustar00rootroot00000000000000PNG  IHDR!sBIT|d.IDATxyxuww'! ,*ȱ>@P9B@eu^:@@e|QPTYeXVT@PPAQW$$4IGBw:E}^SOwUWWX嶰ף͋HŸ7ԈmD$jF)PLC6kE$wA}L G 1LB 6yo{"r|"kj?` r"j&{ ] r$o|O r'C7t r\s<7j?`SR 5j PA}VDw  SX@"[pƐq]B 1C24múwpAVJK3xS#nK:؆.4bjJ]7}v[X(l.\ ()rP`|駥t蛓E eT^CF÷oc2 } R-~'5c87]4W!Xļj ʁ`sD,L ba  SX@"g[Q͛پs<ON'={9`o#RlܰJIIs91 #`Vc A `P.g 00eIE1[P4r$陙lYCУ-F~㫯p݉,R@L)##a~F @#tRYYr,D,L ba  91Y3l |bz ZPUU$D,L=1=@LO-C S@LO-!@@"0NhoC\dV 1nyyy *7ѵ8V\-NAAl /<>\.=z$/?Hb:v>}-/ ˗Q8ARR^ōnpЮ];Piedd@0tHJ")) AVVV?}- %څp0 >;ؔD[⓷itSܳY:FimسyNT #/cv"Bt[)9΢tkYk!"$ lNs5E@NJ7/}sZ !eT^CF÷ock!"$[l; p8A^ƹ@$r!ЅnK;H8 0)D,L ba  SX@ral۶n=8NQP]Y%kq -7x[lv***7زe3}a"q:ؾsFIzzAht:)QĎq(UbpxpF0i{i.'T;|ss .Cڐm`֌,xha#Y|z̦L7_z F, Gr:c[^*%Hz~ת1Á#Iw1؈] ";=`p0|Y獽zX ;7@9@3gͮ[y$7NX+bi1ߏ]NjZZx<\.*n'˅@={b)/+# x` S89޽[k7k3閟OvbX@nzyr8 q^-###c1"0)D,L ba  SX@"0)D,L ba  SX@"0)D,L ba  SX@"0)D,L ba  SX@"0)D,,)ի]))Բss^2;e@L-S^V2LKD,L ba  SX@"h央5XVjNΟ|T)^}7fu-yzc}SB׍P`ټ]k81n3~ZAE~Y5~%\oN`׆Q1.\w^ʯytd*Vx+[|R{i\*`2aT2|x#t<ӽ7fx1}!.xK/kOr#Y_R0y8;+װx[IUU fQ%<|vr_n̿a lr%|Wrl}Z??`p/m-^FƜOw1bONDvL^6^ލ "숸njX]EOmӑҙ6f}.8qs)3,?vezr/eߔ|xxG;ޜNƍ߰ Oi@3y}NMzu5ظhI?{6&Ҵ0n]lum:M$Fd~ ~;|+$#5ymӈ>NN{Sq_.3[nbӽK8oޫ||e_}ʘ1C/>+>M.߿.M )-C0PQ4SJF[6Z7_ja5g 6:kyf>؀<9~4ni^>#3K8<>s_͝ob'V;g\(Gu˿ba4N@߮3X{t{_J<9۰5SFN؀[OѬ pˆ3n&UX$؅݁tNqpza1ޚͿ6v>r{ܗc@v/]f+qerd@PR ǼKq>S2(6/]u3rؓsYFJ0*7lEWyLn6k87Pȝ?)<: '7~˝|7ar{ѓ6r u)T//-k>J]yFUQ4yES'AX*pZ:,*rf:ܭC SX@"0m/Lj 1r(.4kK;o4ƺ<_0z[b-%4<H1858i~@F~;Q@b )D,@b )D,@b )D,@b )D,@b )D,@b )D,@b )D,@b )D,@b )D,@b )D,`w1N>+=Ht9w,b9mɿٺ}޴nM3{gbbɪ.K:aK+tޔ9Aq^SΟ?6u ]/㕳x.Tx0޿3o[sI^x cqC18+:0.]YbMd.jLan,Oξ)Q(X?v9Oo 9H߱?%Wj\/%}Oǖ\sx.!C(la מJn+x.7Y@=}pf&,GE}\}dyrm qˉm%+͒ #yyؼwGID:G <|>saʷ%sq ?WOn+/9C[𖕜uQ6~ ᎳFyb?U*~?p'%XS^b'Ŷ ~kdǿO[՟S {˿gd]4/_~~WU9w-1UaQp~ܿE 'rLzṧ[:$eW@'ض~9-j2Ǎ[g - Qu5'zm=/ǰEv/-7yJX΍{u+K ኜ[mǹA9W'wڥlwi8-`iͶs<2>.-2*ÅwlQ.@c8oӂ 041~,_8?.C3vC28.b2wM ]bLrF+k,\[Pqdӯswyt<>n=ZyO4_TtTUIϦ8@SNqp">{Ȓò{yNN .Gho5~ckcs肋sYinMzvx2a^~7c&3pEڟmt4hn?s)xlgؤyQ轃Eg]·7P̟7nj}ָ;YT=[EsC2|?ιi1 Ǎ2|&y9L)~pmn_-^IYqt]u's-l)߮ךg_^S"p lg*7{,@R}Uz-eNIj_Dzu{_t,Vmh\? #k˸wfV60PE@b )D,@b )D,@b )D,@b )D,@b )D,@b )D,@b )D,@b )D,@b )D,@b )D,@b.m2x qBcCi$, 9շ^%0 Ztb1Mo1z'~t<4K b8&r88444ļ/ (b1"d=fU_ nY` +_zzJʠN@n2p<7|H۫}3R}˔A-nr8ml!ؾ<ꔕA-nrsX<V~P @۹\.Ց[ ".m p\I*@$eҼnmټiii;RWHqylڴm# Xc gGE%L -MӉ*yy|kd){un,&OLn^^Pw2i;8#ӡXL bTTT7Gmn-,HBǺ\.Ҽ^;*Al*HѤ7]KtDC$>z>ݾ]c;k([t/xXn->P5""!Oc5:ߝ!xbdK 2P(14 U E> F' Lee?pK(@Π\n}&&lѾ{+R]}L| "+TS8L!Z]sOSz%mK"˖2xV6n&zdJlh&cXC2m,B`@DR4l^ͦsc24og.vQ 6!/޼t\2-?99|E쒄@0rfV6C س{y'vǾ( 1K<[~UI=>|glx<OBtUo^:.qϜA>0#$J vo~~p*vcS蚩Js4~y<uW,av9RS#dX~>t-Qs= 4`ffyqG5=ITVU1qCYgNj!a0q$VZŰC;n\cx 0 #5A#_R_8 X^g;w2u.: Hqǣ_JO֙_N>aWA4"H/Dk)D,@b )D,@b )D,L~ h"rd D 2"}~W2+W@-MaN[#"=!\wk @M6A@tiI,tMcѭ?ZW~? PTDTh fm@pEo4$%"ݡOS4vi y@c74QSY6 q{ W|7@ !8t܍>/qPeߙEg啀GGOjIENDB`gtkada-24.0.0/docs/gtkada_rm/gtk-separator.png000066400000000000000000000063301446021174000212030ustar00rootroot00000000000000PNG  IHDR!sBIT|d IDATxytTga(m5,F#K)ŶnAуlŕ R+ZW"hPdQQ$H&!!$0`BsI&s%ÝQ!XDb?_qA|o"R7֟ }ֶ]{'T{?bDׂw,.x+iZK9! @jI`З ƫ@௸' HՂ#O 4)9+ģ"ZrmO"8 x5!0ˁDT ..׊HcHѶh٪uCIE1L1L1L1L1L1L1L1L1L1L1L1L1L1L1L1L1L1L1L1L1L1L1L1L1L1L1L1L1L1L1L1L1L1L1L1L1L1L1L1L1L1L1L1L1L1L1L1L1L1L1L1L1L1,6ѶjSrл 10`u)9z$Y %r=i4RYxw㤢D/:]cerZǴku_KT;=:{>c{K}lz0#ͷoѱ<[q,s8PNZ~R'oɶY1j ڿ~,uyzONn%<7{]SxKWz{Vmsjiױu.\|v"nc];‚]l/k/<#Od!~:%.Wلt:'2[vH+aټ}=wK9M)p]bg3;KaهI$8Ρy9uAձ(u`Kw 3뼞̞4ɎD ?^LΝ{;^|oir_S6Ό+h`Yx&e,Y4WfZ&!z;^}un n3tm*ćku}N36:1'o OxϣōdV] 3SӑܙXsg^mYl[?|F}wƸSDUacW_Kuc`hn#\??R|?_-`m$wȡy|`MĪ$6M޻y"R$򍫜]^NJj}>Ό,\4*\"~3Xʠ+b8#Ρ~^\. io֮ ~oQ)Q{[YZ"#.v{,#Ig|QpTg׸L@{OC/cYŪxvd_iJ.ܹJ9md:;]+5SobWRy>F duOg Icw9:]ԁvg!/dx_!m/_)cywr⊧iI-s?cpdr]~1&ʫsucu7 ?rfxR6^SnL:5O˂[^[hw&eO I @_[u!sX2G%'-f}k;;~k<:'I6QNxJx9o¦`8,>^&`;p}sg=Kk[䚒`oW3}":I'J;edfg8#֑ء+s_rEz:͒qz:!h!i7_7{St$^o"Mzg靕t.n{4gSCy193'Jμj]@"rTz 6 r2a a a a a a a a a a a HT|@~N("'2pwp^j @9|"@2zy9~~(*E &P2SB>_^_{."ߙ-%T] ?zBHǝ"eUc@9G~c""O-*^/^wC_;/"]M?U!衖{ O{("x\1 8;"[c m耏9M Y5bĦM 5TIENDB`gtkada-24.0.0/docs/gtkada_rm/gtk-sheet.png000066400000000000000000001270431446021174000203200ustar00rootroot00000000000000PNG  IHDR6F'bKGDC pHYs  tIME;B5 IDATx}y{zaaD1 D%k{5O1.Ѩ%q+" ( 0[]Twh'33ݵ9{V="2_XR8PZ,a}nμ0U=3ZbϽ&!d!Kv3ؿF?@L>&Cz)4 adslx|j{^&r2%MAMzfp7灢2QMKt!x<νoGGܓ@479St V0-C sthD2x<MӄX d\ωG>et=aHӮXutt؎s(z7sڅ<( @2,GGܚsn98ۑfݲu+L9\c5y)ψ0\9ܘ lъ6a/`1\0ÎD.+yO=>Du}IXHoloV~KW_%;^ /_k4]VZ2,Ud28ē ! ZD1ۮBn`sE٣GG?]׋ܼF+êӧ==iϿ]׋ ƌxݙîSip^}e:C0MMRzwLx0HR8b10 ~Yrp!D3s x'ܳOg1>Wa19ev:˗.@ P6(;]W}O> ;D5yЧwoS<pƝRdЖ9=L9Xl޼Xv&rBugcUh-D؈ݻct=wƍpם"I&s0Bq?fZy b`շ[ ,sǕd>:fcF0mxWcG @)0 d2is#.* Qd?ϳ"md#)>;3^  xxغm;>sl޼ .gi9^1yL|!,p~i466oV7\ 4‰V\k֭ @^=lm=g>qyiH3^P{ٟЫW/UV㢋|>4 ]Ʉ-ށ/>k؇>شy3z5q n#'dsz%>d6B>ò%I &xb(m^I)gb f Xd>B6oق5k⢋/99D[C7fxװ|aKڵDšG: U5DsLgy}@ L&FbɢyD"ذa#ޜ4^}u|bklmI[:FAA(ZɄI})^zy &췿ehUnsh؏}"M#r_WA,Z4ZDQ\j8@G⣏>@}}=ׅ}6E<, ;z1+8蠃0%K:7^=zǖMk*v8^v֭Q&gX)(b"MKDWl٣l4wݼo6X yQfV4; n6Efr <3ʰyX<Ӫ Nb$@ ]9' x+}xUhs/{UGTFW"܊_̟pZ@>squ|1j8ϭ.3{1s.U0)bE$I %Rz^"_ZuT 2@Vn~.!z1b%+jӘIx5{qsE[޽{g>flwvνRkI׃؀TyR[6oAsE !hm@8p /tkWwBARÆ﫟ReP'̍R{a-c̯&eKᗿ5}}kAD"غmVHc'ei \|9zhIjx^{-6o^⭩`㝒x.cٳgc{#-[Θۂ {tJ>4!tS(BrJ 0SfZ[[~Š q1G /(hyDadoE4 3~RGpO'Oz\tEE'r@ no(e[Qg̔Ȉ.Rf2~8iEbYv oNy9 *J9eS?ѕ97JY`eOB j"b;X*5Ѩk /2&w3~2a1Ϡ3<-=JeQedw"GAuNJ +<^j(av\T ]}^.Vqx9Inb1гGtkh3f]oṬG 1;qzܒUQD׹a˃H7T!2_ 0V`x7XDt6JѕHJL<%dgl/3S1'sko߈P(ڼ(`LFV3gRBAtZFBQ,\*t -HX'JVvH5< VK_XTcOJV|«֦hCՈR섉'/Ə8̳A{{;beo?_x%p.Rtvx<\'lR)Eے zX3FɪeT+ )XbcXOTtU V ng/Mwe{>߰՚3pervI??siV'D$U *L <-W+Ë- V"yXeedtj#xµdt*(AFXJE"/\5aև K7\m},f}$3=5ט#7 (;gΨjW"QUa9XɶY2QVvJJEHIWoRVƒ:/"wp1!QiR6zY֍qN(~7 wHq6:hXA2oZ%xJ՞#bNQh,bU.] zWdt%ӭ+?ll/V$wD MCv6lBfShCu'{% 5ש{)^"ʶMxJʘ{J՘b!jЕV* V`E6]uVlL˼W#OÏ3_ʕˆT [IɓƑS֭[<[צVUt7OU9Z+nJ+Vw:G?J'][ ,GpTZ)oSi#?]y5׬:p8nz|m<4,[%}6۳4yTlZ^`%̞! *V*2T߫0Va~?b[+ՐJѕJ(M<(k\`D+[\ _\? `˖-̈́aV47݀L&M';32+0/ږ5/,.<j[4V2F&Ez h*'U =ʴA?ʫЪxc.+]U+jml*:lH@J q 5Yl5 ZիgK/MB&E +ˢU0d%?»~aU-+J yu*UKҕd20 l:bf͚D/@5S|K^W2JB*b%bj/+Ut\ʍ X,s= #8CpT9a3Q__?ٳ';Y;6oތVNhnnF4E޽܌~Au477cؼy3ZZZskjjЧO477)n: 0[l;s#k1lݺ۷o/9CSSB] E BH$X~=mۆm۶YB!455}E8}vlݺ @ss3un>}D,oߎ-[XnERyhWzvX*@a8t=|i/N]y}=/DϞ=ѭ[7) N ?f5 f̕t 35`0=>رc7"=< ;!Xt) ",9=իW[igc{{;|+// =L-[GVT4+BJs ,TZEWt/e֭[QB!+dncz2o18kjew+g2ݮigJ),t]/y_Լ)Ԝ)s[r% T$EWJ&?8x9/{̓a+jĔlOg"UJsJU+V*yJ͙^rcT\hAA IDATbxeT+*"۲t&ʋoe;j5!x\["G(`Pv; ς8 \)G< \ZyPged%t#+U<"WD SYYaBfC [nƚ5kZjCՈyQЩXc#p_} 6}1|MFn~a^ T^ y&55B+V2A*-JoQnM H[h,VtÇ+i"ۮd[\X֩7_v~ӕr*75ΓWS.6njjBB£4`s,[t45 P0J/DlVrr$*6J)h&N)dKc"0U*vTW&a%XeN5?JƧU[QIf6E6ڡTʋ\m 0֥ Aͳiv^pu5MiA[ٵQtkNvb5 WHlA?-ϹyodzD;\4H$RL^$c]}^jKJS"mWƧͥJ U-RF4BԷ u˺W^nMNY/ rm1Q0@&N]n17)Lq?'`Pu!4dϳf^bd@#4dس3Лoܚeo}R|R<9N05i%?MMx) cy(x] 3ťq @vl|TJ`]g-Nᇅrƍ@,$ ig mD*@?0^6|5#,k 0{Ai&c{`Ȋr L%d#HdCW"rRiS(+q$z:܆ ml"/J94!gB`5 믁>}3/*H[[ٽ /3Ӑ܎=0V4%< HK pa3t(D4L2䣏@O=ՙe2 d2t55ŠRŋJ쳡r! ]zl|y s >(eϲw۴ 4bجY Cf U޽k[]q"rLW灬^ù=>kb7mJB3p 0y F&(&Of[[na#uka6`(g?.ua7mb̜Kc#0L dtv^~[g1a7r vR6 k"l$Ffӭdz2s6!Nc ^ 09,_?DF$xZIt%= /vjjuJRmWVmkZPJ~+ z}dalR[ ̙1(1]}5pUO09{Rߏ=xKFL~ѥca۽.NӘ Mj۶fh p\\s }]:].04!I'1N԰yx gµ+J40* / uTUPԥJJtJ=ܪ̓`U2ՙ{$JQFu">KƎe[W_$L4[/t2on_gs˖NFLu@H^4L<5 8ع`+%a>:iog ;fA;:S) <{3mZ71^ ϖ冕(Să^r嗃R;|%/IW"`'k׺L(knHAgkM=4%Ur4Jd2Vz̈́V\9R4|3Ŗ\"fcf"6i c23yX:VK &݄\𨔮D++JRi7lݕ[QKCV6jŊUHPVEO#[iEKtn@"&h Ek+iD0&NذByȿU54Ж@ Na~a D`L& 3D9Ĭu)>/ d&'])U鍍Ե0A ]yAWwZV^yDdin')ڊ!NJ`-jE7*M[Ӂ[hREW^v*XxPd(+V΃.Js3<)v>'{`=1zԞ{X+CfKQ3p}ay'ZX0hՊ@0gG3x)NaR8E28(~g (e* t]Dm_aٱQնGBYRLW+W:17x~t%{J؆ }X `z.yb/ [h;_у  G7dib-mHlR2"9JqynM4 `jBW^as4E^HMh<~ҕfVxgRJ*WTŃ=9Tۀy+V˧8DDBU-(̅mA(DjEMVA i(?mTSOQr{A\lKлw^7SjvA8Lv0]SA~q5g۷"ϪY7hiռr6P8$&0Lx)s1cƍ#XpO~b5B: 춛R~:A]W3 ţGt45kMM$ѕhT~z+kJ˺jf_9XTt$*5EnAFULdP|1;w47)U#?̟y.v76`js[`i b(jm)`t1ca&>Y<.LO< K/֖lR| znBѥ d)t3  &-*g Z~˖J񻐗KW"2R;H+*~i/L2*0+tiA03')9?X}H&iI86n_|>_<⫯XiE;V8Jo_f'ccIh{ntt7:X6BܫfijޱS\u0y20w.i5/TT~/K3U]R)VUIORUޡ)橸g 7m>`T؝RhZA(ZLlD`AA1S8\LCd}Tr9`]:p Њ:=3g-kgPY575'!;dOT\EBkX tڕbL$8OmQ&'73ɞbBW€S$̀ _}2}1S2 ŚXM+~%Сq `ZYT!fιBU"[eKA(j B(O'/_fۊ5JECWpq\><A4rJ[uU.OR n;8ĕ5.]х3+%(yɃl`姍MSKd~%^@Rב%k]L5eyvRwoX&l{~7=18d|fbRxA:m);o:/l-lnfHgS#F82`(\; ZV{{Ἷݝ{p؊ l/X )8S) àgRy$+whֳv%tD(aa :t0)a2Yb 7i12ͨ\./kI)AŃ*xJQP\5G#Sb㘀9`9s NXg0˦1`bG f}aZԞwX躁ŋ E IDATˁUXlY P@, /D"ץ Bq0|8WԻ HwobB1<\RضQ~35y2ghC5l۶MAvY@C\*R 7GW: ܶ2OXyfUi^zDij~}+/FA7ɭZg =1EmG(>̨k,.lt#裙L$~i]mm4.3k0&$~J1! _2a}|y!(֭֜ns2Sؤ\4V mcc 녤gc[x]3ă qr֭C._c!Hk𕮼Z*+U DŃxП*i馒bRT)4pYRڏ2FQ"EGi/cB曁X6&'.ͰңG$BqY'  S)gVfȺ`NZ4J  yoB_Z N3|,YBJZtmd9Y$7 JxЏMH܌"J-t3Yl9>fVu Q b+bQ!ڿ!E"l9# B8䃕 /Pk](KebNCm-;ǝ鈥ڳ qk3mTpXCtv^55,OREW2rz+UҖTfgl[#mlPq* ɪdeXD+f ]xc+J+7V kj ۽(7Yo1R9XCWb%+U_tUMc+*m[TKcb ;LlnJVn宆X.p JdG*+REWIW^WzO_JhHk^W s{JeseXyNEQè٥JYd7]yU5y zp]ɢ@|Y3޸D@\^,_iBK4<,gy<#l@^P|ʻ٥J Jw#HЕ} QQOTf?ymhƖɤ滕} kѿ?.sl &}gڵ+(߿?JPSSW^y3,Z*'>h tdpӦM!G]]F ]߾} Oj*+Dс@ Gy5 [z!{'Bۡ:>sB6mڄ>}q! b۶m4 ~;!9r$!رc@ iZ[[AM7BFB:::п|YI \{% E߻ى4MCV[JԊ2%^T'@ V"i؂AM@=6ѕ_-B3 ~LJￋ[Z}݋.] #N#L"!Rh4xE,C8Ɩ ^ [ ofCPh=~ʹƨ*r ~ѕUr\+/<X^hR[J(Aq'zhoojC\(zZU z-’%a2{=SO<P\>r<>qd Vկ}?gBjxp̃'HRwXp+vj 㛆o@@aX@.p+FY-pA >9@dܵ6} tCgD7'GfhW[ARO%҂ӆMÂ^ Ыnx3 bS{cA +WbGxƬ&܆ '=k7",GxPBS֏rx~f;8d,q5\u~FŸ])_MA2ĦMY?C7 ŤUI'!@348E\x}렄#.>`ئa Grf\VTSN6 #Gu^PT~F%WS5pRԧKk2%`^yբ-\ާ8 yB&5 ֢ZbmjTé N '߼0&B1~x| 1όx{c-1шD( xo{f:kз/u]J( b g\9-E[ g; Y=[#eΆ(6R¶=;z@9-AZOcSԳO! kǑղXWj7-0m C/ VPBtfKSm ']mēƒ"~(4C%G\gތ?|$ 46K Z`uHh 32ת!ЕL`WʃnϪ+z(+/ac4 t$MT[ i>kqi'OW\Ƃ\6^~q: àXVq|0h6--Y^ЬE0h b G AJ3,`A01[A ˁ`{d3BPsl\iyS8سiF0DFXN6СQĀF{sAPPvEǶ>0fל_eLr˃r Ĵ ROWF*tp1@4r{B9dZ Z G +Qi$0ֆ]΃R,_2O{W91 cwt{^EQ * 0ayMw(Ǵ)Ql3XB4vz<:u:s1<̻x9w󹦰*Bq(8γyc.CoS *t%F k~bCwUt8ZՉ뺦t3(]j+0`N ^Q׿}8meȟAH ~a+T|;߿L9+1>6.6ȋM5RI%}I%?̽RTp,غ޽XlA)N{Sen[BPO4aΚ7!pӞW.p8̚㝈ggL7n>-K?m떭xݷ~)Uӧ=)St!믱;w R+<!ϰV0)!K.Ů)ԴuֳV^Nya@]]۔R|墊pް@Psdz D*)5УGOWfEGe굽,Oj[֠ĜwgЕ_VN0U)V"4ͪQ trn eU ^9 7oKX]b~F- bz!_j4Űa@)E='uuuիkA,̙3h2ˡ5kFq衇 RS`\]vرc-않R_=7@(B6E]]ZF6Emmh}шbe]ЧO"a(N2VTdCI+Wb1Ƣ :+z͹ X` طVH$p8 hnn|J)t{1uTPJqWW^{-"[v-9躎X,wy+V pQG_ƢE /KQ3t]yfL0o8Ɗ+pE.+ϤIގ: V´iӬJO<L J)?\.\HĪf~dcJ%ƍVr!?{^U䤇C A(`AP 6+UA@EA@@"@I9}0v ~yr{ʚ53kֻ^`ڴiK/X,صk_Pp.]G޽t:yd@ĉ8}4SСCQ~;ԈvDEE2ߏC@gqux8C `0رcXh$UQTT~x^\X,CFX80ar bccA噖yE  ,, #F`XSJ5] - =JJ5鮎w|4 bRf󶖑VӞ4?7qZD5  BUovd6qpqgk׮hڴ)n7>34m7obA˖-1rHԭ[24W^Eݺu1rHԯ_W\`ĉme̙ԩȆDT˖-1o̝;FVV!hܸ1Zl={5eZ@+j4 ~PZUXur0a{ w_&I=DN馥!66fY( --YR'[g唹))w7UQM M}1<~ hrJJ6 QQQK@.]B\\TMp -3R ?+aEU|索oz\cƒ;Jy+JӋ5h]a¥VZ{8x~_lǡGHxA\[QVuﲒ/WMVJ3%CM̡a[- ݎ+5R>Fn IDAT/G;_'A'`xr`PXRj8q<)RsTq(((bիBیpj=d$ׯ5}o/VZIMָҒ0!99ٯ8f|YSm\)?>HRLTWԬ8]={N ӉڳRGN65?`< 9P}ڥFJ+h4믿ƣ><р)_ &fܹFua>֭MHѺ ʟ=K|zhs=Rlݺa,mnSO~O?1 Ffǔѣj˖->ʊ_@I1^u14/l%6?{!Ҳ}Mi eܢ˰}PlzJlt]J;T^8M^fvmu8 g31YTt:Qvm\. 6 {Ajհ`L4y9w ,\I&a8aaa5kaÇUV={68B@@ڵk(,,ѣGsN̞=:tY pL2~![|y 3gF)Y\.⣏>B޽r?>L&[8p 郂\.$$$} b9ܹs ɄE>k 2L"تUi&l۶ }&h֬4iիWcƍ;w.CNNZnW^y8v֬Y?>,F#:u2o}]L f .]*6lqܹ38 Ol2|p݈O?˗/!!!A1k߾=bcc3 --M$9… Ѿ}{`̘1]6 99>,qp 66cǎő#Gdڵk1gTVg|F,Zj֬yǴiо}{}*U;`̘1uz>oY.'RHbiW9r)<+Wy勵_J;ORΝ"cƌ& HbZޕ>Sw2Y0g&&E ?Bc|2m4wSSSIaa!@v;r Yr%!cǎi:w?'bI%$!!M  #RVVFN'k&(jd `唔dҺukRzuQ[oݺELb!~B!,4hzoA!oaFgqq1iܸ1m˖-`0p&OVB4h!F|ҼysB!fC>|!##ڵS4V@KLIOO'++U-ػ}!#F F BaB̙C^qUIOOgw8B.]*jC۶mIDDH/"!'NJQQzB !tܙ:tdggZ*kWzz::tt<,lO웙d/ɑC_ÿ#>@7}e< +p])v(fq (̌aR/ &fe wLJ>Խk!>t7E)<^z%U?_bbb|p#жm[x^U%Z۷:dҼys< n8v Z_իWHFyǩSII6\k.<]rEA իWg}CFt(..!i?R{@@~[gΜ/ѩS'Q'|ׯ_3 Bbb"ƍXjJh4"-- . ה7ТE 0:87iN86mڰ1"LڵCqq(4fhVBZn6 v؁f͚bccE|)+Q:RD-0` ; i*cNxnyfABNaX` :uꄈx<ԨQAAAq*_a41n8=Fo s̙(wj~>TQo b r…x`0pu={8zl_ ?l64k֬{vh4F0ҥ  ԢE  ޽GEpp0ڴi#j"55!!!Z*`0Q7++ pq /"$$5jԀeb˖-Frr2h޼9p8rǎLEDD`ذaHHH`bUVEXX Y -["zӚ5kan|,Wj/׋f͚h40YB2al4Э[7p{2ܰjŒ%KХKy0 qtf,Ӊ'A9w lܸQDɓ'a4o>8NL8_&Nl ::ϟgg"9MR*Q Rppn(K͌^+r̳X˓ˋbEi:NKKj41.Ez ߄<. FF.WypLjӢ%5L>!3pr`6}anNBv`2{4}Oa)5Ahi{].C4?;7͇oFIfɈje$Wg{C˹ݻ/5hw״bl2()ySbXK&N%tT1IXtvmB&l)餠W kXDJ: BCp'º uiQ9!I2$z 'NVOm?'K~!_UJn6¼ W{5 zc Sj S3"u"<3'/mp.e"͛Ytr8V].ucQ&qHF9=wv=?z~Nӧ"+]f_UPAtbf409U&[Kܐ(6.韈%;w~_2C+Z-g-Բ婕#W]am ^(V45YQ;^YkTz_S5NJm\Q;XEJn7MޫD;JyCt݊n(>+=d ~V}T&|*MS Qwwk~-P )+}WtJ(Ri˄x뱭*J$.i/S(]ԵJFV}JPc= @z#hjqXʽ/+8p+ZH#n[UZdŋsǏWTZH ب->-_-ܢ(]C7'i\.h*`=*,!!!>\JN.J cCߕƎ0Ϝp`N> ,Z)2Bk'vBY |{)))EnbJ4-?zacYgE0[̊ĬYPݼy^fmD/_ s\\\W2+Wf:^rEw-dee Z>sk׮>#33Sͽz*t"##CV7od@~Z/im㐙~ULF1RDa5ԅvh/׿]7odf͆W*_TK_vʕ+(,,dm7Y\\usXx1222"otDA!dr/˗eڵkHOOfdffAk`00~x3+W0 * )F\IZOnot7z莄xU-BdJW~!81}t(ш7",, QQQx'{n\.ԨQǭZ  \Œ3SLAa0sLɥnݺ8}4n߾Yf!''X>qQ1,--E||<"""NOOǑ#GD-49,]8uSO=`6r*72nO& 6 00ј8q"L&F#66jՂA PV-TRE4cbbTX,ԨQ񈋋CPPj֬x+ڵkW,-Z^|Eo@XXT`ԨQ?hӦ bcc}0j}=ؔjɄZjbo"""ׯ_!4|`4.8rkrնpO8(֬YիGvDxx8&L r1bBBBp8pBQ yٳgqBCC1~x o(\;sL{0LlIԃ,ժUQRRsΉƴ{~n׮|Mvԩ8ժU)CM㞢VT,x^7]J_-V9mٹ&g?r_wT*!9+ԟ)y/^/_F||<;߿?O~X Mj'*m۶!117n!:D^t NGܹsga۶m1`0 88f1¿6lM<ϳ1ƍ{ɓqmo$ٌ'ObŊصkkɓE=Cl>4ŋقCp8;8r䈬r رcѱcGY<#G0>%*{bΝ?>6m*ʕ+ʎoiup\ v̕&eӦM,*ҥK0D˵kahJ:BBBйsg` AHq{nƱiݟ`wcST)YHxC' 4KAZWт Ur((ϝ>{M6ApHMB=<֭[툏/| ??vZdpm4m$''iӦBn~w.](;v m۶U`00*Vg5>OںoWrr24i6=3Rŋ_W=UJW\aXѻ+z)F?sBkJyE++J@x0ꋿu`f1_ z&^ͷ^rrرc"ZŸB8Ciièkbo<~Nӫ7tn݌Kƕ?qEoD-<<.$tl6Qwb.wEpBl6.^X)mkezeW+{d۰~:LHld(.]vp8Xb+..FBBB +8TZۤ]Vff&scJ*m\q Vllzl j6,5ܘ-Zj۾kSzؽȊSjY]Ejzd% 9t? u$wʢ m^!+zӨ,ZGWe'#+S;ȽM5C9f$sP9:9{oV`SS'8PGc5Q-YQRtYzGVjCkUr,_rvVxGi*IGV6i\Q]$ w*)qƨ<_!ME&|.Udf^EFF&f6|k FY7`=gſM#J8e04F߿Vسg4([ wfO?4 .'W+Wwh94_ZR YZG)GBn mMHHP39sf###1l0W_eTy .D`` PZZԭ[Zŋbq̹(Ǒ?~9j0<3'$$0orZ`X,X,lٲ@9g| 88jb̘1>Zvm4nܘ}ߪU+0+L/d[p!, 6mՊ(gGhp%ϰX,iVXF1h\]6Zlɨy|X9Cll,&N|xG~ B\\z PXX}h7nł .={"!!A$yx,ZQ=n޼Y-[`Xp6V5jÙڤIlْF駟fcv:u>a\`AWv R -|Jګw_TVU]s !0amۆh4bضmk #'`)))C𣰰0sy}/ 3h -Qzu9s׮]C=X?S_EEE0L_`& IDATyx<HPGRR>ft ^aaatA]@wTHIIaΥKbܸq" |gp\HLLfpANOOÇl=@A߾}QRRݻO~iذ!<}QjbĉǠA@AΝt:ѯ_? xɠQFHMMѮ];_3Ww܉<<5j97n0r*UPXXltUq+~&.^Yy8|RSCGd`֚YGP=v z)Qy˗/g$tgG>4w\dddYFkbVZ"^@@mv}i>9Mc FF0w\111Jx<6mxb,^4mذQQQx7vZ梬 nG`;?zc-pi1MwxB'$;w"22R|YEta /--eh |nUV+/Frr2"=q{)]NKK.b,**bјQ0ݓb))U+zD%rPqP鈪epP(.(4@>5pۣzQL>&qRҲ|AL6 [Y&BBB0ok׮E^^v؁^x 3֮]˔Mlxw3ψd;wG}L<8x/F-p)$''m۶7nv-CFٳgX NQ@)ݘ]Z߉'{J75eee󺞲*kIB5:瀀"J!% 24J&}vtJmz h_=rTG[;tWrb)뒿 >NNN/ʝ,|FHT'|i9Jfa0&|.//٭}.޼j嫴q1"""t d;-y^8S'TѺ5{cV2J)ҔeZ>5JZ\KWW-EZ9`0`׮] TG-,[_H& [l@n1 ܂槤Z#ryKKid]UF+AhzZ6iDhJ/n߾:tl0PRRHF4 MJ-JQ˾m0}=ypo";p݈-PrQ=xjzsP -TQ{/^&q99Z);W]S[-Kn 0:AAwԉk׮n԰yŋESryHKKWT'}5AiyDž de&pJz 'H~_1{u0>9Y eNۖȃ`1D.w;J/"&@ qw_[Qr S bAP`+@5TS\3 x"v9Ĉjn8~I&›4-57jԈ!b EuF`0tiӦ"cPsEΝoݺuU|gϞcǎ2d d}C]Cn~}9w\ ›`0_~a5*?I"{1ӴiS۬߅Mr[jOyqKX,f^n,WЮ56HJŦD\+r+bAbYlݲiW\&Wyg0銴JQ!(W̙3q%DDD%$$fBk83" s֭1n8<_{5^D' u=y$k裏EJ8>|y/[ <رc 7`ڴiiY΋(P7Z*s͙3Om`ĉ8>®=&M]vZطoTwzIQ)#"zLzUTinq6nphb'ײ; @0` 0BV Xá(!jŗ_~ ш;O?V68s ""oFV`DYYYرcDl6ׯcݺũرc ;J=?ضmbǺup8Y.P4i/^ Ӊu_~Lfbyyy>}:tPO^ƍ _~8w؁,[FUZ]vEzz:1a1y .a2 O>)EPPO?PEKY8Czz:n݊H5 jB\\rss٘޽;Ə8?楜^֑VNv6UHdXЫw?^8%\(gs-h 7P:xWr1a2('3dǝ[*7}f͚l(,,`H ߺu+ xA8O|@9r~~>rss3I}jJXFXSjܴi}lٲC Dyyyl6<#G? 'OF=`„ ,|Ї~( #+ B$իWuQ`x<|0:vSNafmҭoℸ[鸊oQFy(++󹑤ұSȩg*)!1^n:t:qmܵ? 4ReW)++C)lӁkW `ر0͈je|6۴ij*pDV=PJшiӦ1hDtt4f3?xI9Cfؤ)++s=vZ;vlF||cK:ƕ'UE؜ (.7h zl$Hnݺ3gׯ_*|-/p Wrrbj\V\)[^W@@JJJ҄w^&/1zE rnJz9Ŋ .Lz4X UZף i}vђOE8*SPښJsIFظdpNj] kEPQF"ހ44lؐ:L-joҔXZ?J/E4WjBnn.0rH|85kd_~%%%XbڶmCX,z]K.E׮]Ѻuk>|1;F F# HwvbTS#G2Va AV0l0űC;vhu1Fu!""kFFF_5W6I믳]HOS͚5a1c ;woơCHOOǀ0p@Q={7j#dDխ[:tC!44h %''';v, FaZ|85kv{sP N: ((%%%xwcGr\((([Ĩ%4;v IIIdmr XPPzC2P.]@A}Hxd6Ta@V+fΜwy;wƏ?_~͚5Cdd$xbQyr4oBP%ۻwoAժUgO> .:4(ѳRy 'Oȑ#{n 4 P*?oڴi($%%aѢEl|2{ ]QsPK'MDmzѦ]`o彊 b=7vrX7%%P=<4hX;BN:d2/dvΝ {}vDFFb08s .\'0NڵkcիWW^y;v,ÚxWGHJJBtt4z)/yV?8t\. bɒ%0hӦ b=zj`L^[lAݺu`ժUZhł˗raظq#m&=hآD$&&2eva ~W"ӂhWTT7w;77@II k׮wgϞ-Թu~g_~ k֬q͛#++ h޼9bbbPRR۷cݺu>hX~=3qcӦM4h^|EܹSW͊qyU 9cCw.wY {b^Q%%kdaGAVV#HV(貲2?_Fرcxg ?8-Y;wM6e\W'T?͛7Fsw>;222PNY=:'dM gO:SNaĈ}(Ċ ɮwJM]bE u-Zdm2|ZZytԉw%(ԽIWAd;?V"uVzG-篿GPNzZVJMl͙Pl=o>ZAH<^/3ϽTie͛~_߭;0J2nܸqR-dd+O^Yl_6MWۨM^ǫdS+x2`4qTNfnQm[7l[W;bѾqq+eBV&a2qϯ>v(DXQR-dSآkNӋ}cQQ rZzbi#+5x=8Ainl~+a*BVZ4QEJɤ+z/㊚*ʊAK$&diL5tH+ǢdgKw:V"f.sUQrQRI*+-`VBsA\mS/镕h&dRrfHǯָA5YIGi qQ֚²fop'fn޵b PiiX%M.B'ϛX,())k0L"w$%@TVJk-9(ŝ~ٲe>G͚5p_IO ;Dbq8>nTLJI%꾠Axҋ|׈N1 )LECt tIDATpqzk]hHeVRR^GilB։Hmkݔ$4l(TV_* ƻWl҉0#Gv| 4j9sp)={DVS}]۷kf,|nݺ-ZCx'wߡF,nݺ^z58tݻw󈋋c^݇€9s&4i>!W@܂ ӧQZZ6aV?*%K0ƫLAڵd婧beee >b  9sM:uŋaad 8y4?o<ܵ<~aɥRZ It\L9M.'SGO>t'rEr9Nd -;,3(%?< ,AC %Tr&ȃ>H!?{zB͛G\.@v;kbB!ϟ'|!7oS^_8Q]RRR'|B!O> 2tPB!VB!>Ϝw?رDEECXT_5! & <ϓ={~dffbի;:ubymݺ YM̙>ˍ9CK#{!YYYt ꭷ"r1[``#F.O?Dl6 '/&Fbz^)))!'O&.vRnSO=!4k֌`Y(-z$qￒKi)d1$b2Ie< +pLJ(%q0p2{S˦WTF~4ܢ.;Q4*mM&._?$%%#6 o>G 2 &}Ox+HO8C п?^i/KA6m͛kPz<=z`ժUhݺ]vtTVVǏĉx'+d= ݎz 3fP]{E>}P^=2q/3ψdlYBp9f΋ƍW^ Ӊ~ 5jԐ=ʍ+HCEQO?'(++=zķ~cbʕfB%Tv DEEv6 Æ Cbb"bbb|v)tq + ǣ+ ?"Glvs^N RѠA<:#wphZ\>e0ۏk U{JL9)a4k ;uz-+3hڴ HDDDb_IXTR420}""#bxQVVcǎcȑ(NzE} oL`GNle `cïp|ǘ6m*v}[4ǠA/࣏>W_}7o`ޟD`07B&MЦm[qrLl6k_0bQvL2(**hD~~>$ (Ȋ#G~hD׮00VX^^>ƍX @NNBIdK턒}8qd˖-G}ryb `n ,ĉY^㏙cpbƌhޢ؝Ua;J=_$;3}YBrJ;wG8?_3fڵk8pg.W%% .oC0cLL:ÇGVѰQ#Y" MgłB.]'X$4jHb)'~B`xh0e{C 83QG)Vdg0 8(CF<,&-`6`2{ (eΦm" ό[;V!$ "$~R WBl"Ă ꂪ*H]U {mǎ㏰7$敢H3cy9OY)`]D^^ձYWhSOWyeVYV}WK8( &,&FiYlEQyVE븄QiL0)LjD7 ˲IW"S22,kǙXL)HKU2DL}JӴYߜNm$j.TLay>aLkmQCE ̉I} L&dy ljyiP%x.B@L&gAfNh !O.XaE8S B6=܏ \ץ ʲĜAyI!%Y.RJ0~aJ)(Dibbi"9K3 üHIdĊ7w ^zU@l'W2;ע6޿ɍr qa6;W_^WCPyo8mO?_ymM?y17O>{XcW_8MWvԮ6m: P}/Syp8%58hPx< f9jT҆[($p`ذ~JdРxtv1' RQkVC^^@4U(]p` wW3q.U1mnz ?wanQ8AlС枙R^Ĝu*+50pMcl٨(/f{^'OG2lccr̝KII sΥqm@]dL=[s#5{e|P E}^4Ţ`l~~-nUvRSU.}y!){T0ޣ?eL*]fsqn+deg} gp|Vj+tI,Cegwqy(|2Eŗ2 ?# J5<5ҽ'xo䱖JxWHZtL>/Ws42idfL/dx-ۨ_J-HZrG\}`X<\v wvqp?w.j˫gw/oS~U˛ո> | qjX֯[uر=,­uo]t0t 0*ke 些y߳|Zi 6e5u<)}3a\sPGc?CO> >춾̎$ DF])3DzG$i HhRx95h ]?'7}OS4; h/D݊iS;)b'Cs !(D.7_h7bO!t Ӆ[@ʃ,"oxOm"L nnZ 4xl."_+ʞ ^9IENDB`gtkada-24.0.0/docs/gtkada_rm/gtk-status_bar.png000066400000000000000000000044421446021174000213540ustar00rootroot00000000000000PNG  IHDR[L[sBIT|dIDATxyp@ &!ErG2$0xhI:)Yik3 ΐ֣ HH@GX(Pr'{>cwgecHyfg*fqmq ~ ϱO*8dcǵ3\lɼbf暫bK_F0Ac s~rf\]FN,R> stޥ]UH~LQʹRXX9OԲz8vw7_TIgȏ>s쓝!ﱿ7 ~_U j~+ />aڃ/hl }gX~@Q{5lټ-Rd 3gXg!cI>x73_Nd8rzO/^2jn/حOr8\ Mq;dݢ@tRgRT69+{n={3+nݯeۿH1-{&ٰ.c1۝a4xr7{߄԰אأg1[?f5?-%+/HR/v7^3Obrx]uT׵ꇩ>ĄY,Yc#kj-2hN8}$Ih 7wǒ`>Joj'*1˙-Jǰ쬺UL(89Ç0axtz8' 8Z9;Y9L<}7=PA@Ѻ Y@#o&-DlL bc Sؘ@"61)DlL bc Sؘ@"61)DlL bc Sؘ@"61)Dl,W}a`99 @Cz bc GVF;+8ckv{F-=D ޣs>?d.s(8jzZX2mٌNQ^ab&~&Sn?;.'EMz|NJ}}L^6+s]? &N u{;9!XDIg: e@+ ş$EtAa<7 ~&@$ֹ-S`]şЧEbK$ւOrLDbS?^Kt7v="Hl~';2t,;hIENDB`gtkada-24.0.0/docs/gtkada_rm/gtk-text_view.png000066400000000000000000000042531446021174000212230ustar00rootroot00000000000000PNG  IHDR!sBIT|dbIDATx}lUϹmAzba\1ӹC9XD2l֩sV(͡&&JHb-l('rǹ᜛rWrҞ{nOOsw+ ;ҙ}Hؑ N@O [~ȑǏnlI(7%QW-w=KL1>P#wg<_R3tg2K(xZAZ/Wng % PuO @iP&^%mFwW(3%9(]2 J #a v`ٯoλF?wVS[>u:>K..**+?),;z9a=WGSԱuIR_h~߆e 'r9Eݭ/=GWUfamz[{ж&.TT}I >i[ IR;AE2|Wusqt 5:}tV`GY;K{E,}=po4*:ZWk&ZX4N/ֆHi߬y?}?~wkzvwG}rS-ެqCԉݮ}{n֦II@) l6_KHw_>.hVUir}OȋWo]E>_o}&5k^} p*r]HN6)B0$з]GJ7ܒxY3~ IJ%y'$ޠwvR<Z (u~ E YyW}a-Y5™klY'Sڶi|sVmlO-YS> T\5қ$ tr@󮿑;%qeq_'$'7|ϝa00xmROu}G^R+IZֱ_?~:߇t6]QWCGv2Uė#Oysknp?7 [g2?e'鼶g$i⫵o;=;vK%陥 N0yE @I:woԼ t僻i8Zl+Z M҉8"ұ$]YC+5&۵c~}uIM0vE ;I#ݶdHWHXJz9}9R;-w@MtoX](.0F` #a00K%n` @HJexfIHJ@ΗT%)ZJ I,LM; 8zGIENDB`gtkada-24.0.0/docs/gtkada_rm/gtk-toggle_button.png000066400000000000000000000046031446021174000220600ustar00rootroot00000000000000PNG  IHDR[L[sBIT|d :IDATx{pTb@C;m`lTh VZv2tKéZku^j2AŊP1 $@ 9gnv7TBygyݗ! """""""CisH2CH/tX&N!=n'T*Xel 9U/hZsIx5 >Ҋ5j`Y~C|f`)DFj&U5(U^X1& @DF*,zj/#Q@H 2z/|ۤrWDF;H)DL ` S@$" 0H)DL ` S@$"? V{Ƙ@P˲q,4yFپ}6lw׮bXEuM ---̘D8)EGśqf3m*)h-7ҋ/`6ӦkT@ <=̳֯BSb$E"9vv$̚W^Z#c L>C)ySNh4Zfy>mk 0u*0DL307$JˬDkk+ܸuay1yC:ecN{{;f%7MN션>4]%jrr'm}e6IGGrٲ-:N:;׳q>?_sP9q)Uv19o Ӿy*~?O^5{,cH}TiVNiݎ1bU@b"'5~C3Y!@c0cӹ8_x7No3n9[|b%a3oԶ9u9G)?~1U3b|ssyyk(qgpLc x>eug/ꇯ۪D$Y_)lΞBeqGKu?DcX1~.خW=}๹E _)%Hge.#}_Q(( 1n8ihh(pJZOO7uu Seno5r)H( c7֮'DYYY( P"RB9`6c+nhE$" 0H)DL ` S@$" 0H)DL ` S@$" 0H)DL ` S^&K8A @  nE-xuQ@U:m(ȧg>`?0H?Wēc׈Yiǝ|\D>3CvR/^1 g Aş> pp`EEJ!U x0Rx =O/2EK. c5/qB k6 RKko/| ]C Ra-=<eSxq'o vLDJS?yMx'H"Rү~%y=`&IENDB`gtkada-24.0.0/docs/gtkada_rm/gtk-toolbar.png000066400000000000000000000076561446021174000206610ustar00rootroot00000000000000PNG  IHDR[L[sBIT|deIDATxyl}ٝ].oDKI (hDZbp6v}$p8㢅Q7R8A. 1M:VT ;&DmI[7%):>;P{òB!B!*:j~B^&*c_dA=&aǕ ib,O/6 !Ji@5GS&!ĜWCޘ2C-aK1h1}>*V!Xj?h< U ?5!P/H@y-QJW0 @o3,ke$!*$!*X446jUBqzOzKRJQ&I `9LBYEjBT0IBT] $M!QJ X !FjBT0I @ &}BT0˲{>܅6cQ#5Y45fP*6 pw:Bڽ ZpDplwǂU@Cэ1@7u x~SN_|Wƶi\hmnp]IW9fe*1Z:{݇}1hfqbA#ĝOW~fj[QŘ$]oy= ;߹\vwV{pٴvtqgOk8 Uhq%F?dãH'ab`[}h!tF;r(g«Z(sw;ߘʕ李>IS ;/cOʋKIa'd28NAyq^z<|j*1|wt>yMZk adQ[C\8uJPKz\^YTcL/0; Lk5]sey iw*/,E"# R?34U Mu^xh9;/ `@U cb?G%,唪3.w](Ճ1O9yvrj֬_j?|xsQ^[T}۲>"T6,ooc)?I1w7aLt1(ȣ }7N]Xza0%ٮA?osy'yW4/ZDuuKx+.pH?oѺeKrgm Z8B1Gx322`TDe|G#|apNmA{R_D͘11<\~~ Tt7 ~n.; t؏3[L`?d0Qek8<',?@1nУo۶pÍW4/Z~=?д /hn=d pF>U|񉗨J9p<+I8659X&)f@)=˜p>W($IVe0mG1/3^U*|[$ar*hʱ\r)įރ=sפinU8qc# R(14`}wG Ka VL6`ZۡT%F 8@)^n=||7=42Ϲw,5؉, >x}h-zrd8O~Ymu^@J%KvbRVT Pj0> AF!0%bLK5?BsW&<`j#E%|_tF358\?N|-l|i U- UN84Otb<[Oȷ_'8?3*s Jh(RvJf0cƲ/d;6+; Aavk`j;D.uh \U)<Jg|&}]*@"a{1~`[㣫/k0ߐ?[kg8O5v_1KRH;D[_17uM3J Xcj\4e4*C>_0@8&@C?t3JB{vQv,6'(R \`goX uq~(}YsX 4ʎڶ9Lx=/}oD?Ը7MqG.$:Oy>g5R/V@\m0&zLu+4z33b4u] [(>x|mTԤ#88U$Lqd8pi:`7`9r;徧iii96w#fkS5S2l&hb1T*Uʤ#Wٖmq`OrL%5xKT]NY^̱7]BQ D Q D DN@!*Q D D+]4s D D+Y`߾=Zb, !f4```````````S^ =[L1wAT4'Kh2@$%>\O1 0dPLfhamdЄ @n$&bm `D3ǢR|VGG9FkcS6GoVĐ lo~L)p @3,£=7Z$!fb-X 8](IB^oL9T}N@vT4'ǯ?)GBjBv[FNIRSa4Fd?F.HIENDB`gtkada-24.0.0/docs/gtkada_rm/gtk-tree_view.png000066400000000000000000001441741446021174000212050ustar00rootroot00000000000000PNG  IHDR6ObKGDC pHYs  tIME  IDATx}w Ko(5lkĆXQJ`c 6H(hDAee nܙ{wNo<>{ܙϗhZ"mIB@)?ۥqw^;|Yǣ mu;FT}p]9e+[4&wDm;*$Sql?o"&[k~>^y'^ʬWMh?/Y&ۺ_6H6g!՗^9r2ɾg3&*m}6喝Co΍,js6sM{N?g̳%H] mHnFL_ġC? zW3P.ᰘwl~U:x< L@nn>t]W:Q~髰i򋂢sמb/d-puJQ8zN)5a0؄:m;5v-@ hz\fr?O=#wwxezyknm澨ʗfd꧔:**ٸF4g*s(7qw]_@ E5K0jU*@7%KF6Sf֥Z^{N%LӒiw%Ҥ&_VF9sxDc6_7"-{fݾA_9K6uZU[C4MI#@4́rw.b=^'3˓HuS9m`M6ށ2B{n4}F7ngv`]mݹm(] 6#ۍk#ZO 7w !4X,p8dRw(\J$4X,6V{4MC2{ p!֟`Mvop~.4ʹ6GQ=w(DH$T!8i %Ex7OtH$'ifB!t4躎[NǴ[g4[~n:/*$$1g|ܷA0@RGPPP/Y A4_OL~;^|͵-_uv7-So{'y<lܸ ͘?<(k`<cy]ػw/ h6w̚x<AAA!ZlذӦߎeP(/~F‹/C}}fΚg<ؠzi"%XXKڵ n`DROb=5{N{?nv N=dL>D{ 'ԛoĸNAfڵ`}H|oz ϯƆ0{xjɳ:|4.|{{x  `˖Ř6f|e za$|m\w}hhhGII  5)LĕOB׮]QWW;v#GܳD$Eii)yJKsPE۰qkH&hӦ^w߳<JJK5RmRDYbЯ_ 89eK_F,M7^AC&{c@ǎ@WICqQbU;OEVdT0M{s_µ/V/2FG{ Ν;b„ѯo_GF]]~wݍؿw'0ugΆG<@Qq!ƍ4ѧwo1kk׮ë]qgX޶m,QW_D|>$fi_k֮{}in[6 zӔ){ mUUUA0iGCC#(uq%Y&4 ly!@x`>&U1Ep'ڐ*f;UW)XuX";LziScM8XUO8ÇC0`_  A)#LTu ٬nf?-1, !hyyy  `e !d霚Ooj~x^x^9`%p D0DNnrssbPPjڊ*]ױg^z x5z@Mǣ! $]LU׋Ғ446㉧FѵkW卷pԐv;Xl&: w~LD*93M Ǧܤ&w@4* TMKM%Mݝ (㌦R6lF]YrP԰͓PSrrr@SW}}=ڴ@ B梱1BGAo-UaP2sB"JyXf=K;:E0/ڶGI'ʪ*Pj0 :Te H7G}}CBZDxOf9"cxI\Ix7mFiY'BAD1ܷh>郾}` ס}CAĢ1٧0d`r((j Bv܊%O>SN; ͘p8elY]]55:0|Qt%:\1Mh /{y.E$3nűnjƝnGAq[x=86gg?=qǏGqqfGڊS; 4fs]QSS&>dT#趭c ]G68t6-DKi8rrr`m"fڶ-C1Ci Au i0M;va(/? ]7УaعGx<(+khUUՠsNؿܮSǎ_^4ѭkWٻєYEd^f"G-*SVO-"Ѣw(m,**BNN駃6[H$Ѯ];䠮}vB7QYUe B5`&:vߏݻW]c Ѷ x LC8p>:w}ۄmY vލ={`׮ݠ{nؽ{<wb iH[^EEE69xkRaO0v֓I{s<ŒfQs`%3,-=gyրZuy^Fg0rf(J5"J(RD.*9{/x!ssG"fL4sͤLͩД\Mܘ]Cs謲ٚA8q#smR[~|ιv݈sgdL o9ersNj3nwl:ܔT-q萹b9eʽlڦ{DI)2t\,=sdfV٬Mxm&0̔Lzְid4A2p79^ev{JcZds;I߫qd֫jpQ儠 ^f{}^WKxu ;]+j:nl lEc]g  7{6mt+Ma#jOiUFūS?UlU[ ˬ 7ͫm֫2mJEa&>È4Ʃ6\Y:TTTaU(x  _}!Iv@r?U5vGMy{nUMH,zUDK$]'X %,p>zY}:{H^~', H`yV :d@V([69/,SaC;X[FMxpJ<7[# WA5۟桺aMQqsmm-,GOAA^fox0p{7Fl*h*2`9@MrIAI{@QAS_ (ggA,CV _M?ȀB8 z8䶙D7"C^du#:e~*ws.iLyx醑ok->>4B7L]ބK"% H&u0j $"^XtTʤa@hXO8&tC0g8#gY0`8+,Ӥm7;`&S4 4B4|`E< r>Zԛ9"9N H$ع[w;/6`#b*-vq^"(&(:eGQnl0Su-V>='wg\DRi2O矄 v%LJ'GD~n+ʧ禹Z7;&Ki mWKWk`#A,Kރz,y".;qA6&EbtxљҾ I7Bбm ^T,l `Jx+ŀ]nǟ 4v(N5>~'_xsC ySO$neےBf|dn<AS!X2=Dz_R7'NŅ7axЭC^Lk8nhǙ̫LiAֹnrB !?1C&LSV22݉Hf2EtVr¦a]`1񌱸3!H༛CAn+.{"r4}eh*$? 6 S,< ۀ{ kSmOЉ$m. (-*_'Gg7ړܧ{G\2$:>yn>κaAZr~,y"ο^h[8X{*`d۟Si1Ow<4*LY4F~7+g\8>}q!F_:u=T[±@N(BX [<@~n. l6Oͽ=lغ9A1|{"7bOUkdvU`b\ph\uމxO nTbv{6{ &EA.dx QQ>g˟*~؅B|}=?"9a~u >A~nXPZ/;k <R,sEIa^ִ:T) /'N=Ik$&$sȴN?}ضJ Q]~.t(-Fc$`ocfjrǸA`w)(UT MNQACM]#: BTWdJ$KQգK;%xӯpg %6M9 ~&i_.B4@}c{uEEU9CA?t#]C_S׀+9a+V aB#7C\Ͻ~,Ǽ) k/@$}>' g#2^D1Y"HlHm, Ǘ){*px;OޅU5G3X;-kG,+}<\7I,::Q6~ܴiyT|>zLZ >>  `ub@nEG #J)q͜G)hߦ;V`3nqh[R?f|yX\և1?4MBR|=c&ށ!(ˁnxh}V׫ᦅߊϋMwPg^v4 `-qeg/-ǵw?ތ%ضZD*θ)?5)37PD"#SZ9Dr=9'[\,ٲi` {qWhJIf d沀ӤH aՙ hޚF564VO :'/,IWρIW6%}MI=Nk:$!6tNb5LξZ:4ɤ4AM ϛ[ݞ?9&}~Z2P&T(#Kzd«J*ʓy?y֠ 'ƜCOE~d|n씿+h>k[,i=Q:^[K=߾M!v?$IH3ksf=vL';ގT5pњE6L֔^em;<ŚGFU4B7ǂxX^ld$R$ 4㚹;8tt4YUQ̖dQ=~$UdruZ|Ak +JWJSCL+@k}z4&th'hZ6Lqlk7HB y; IDAT*_5_v&K˜-dSxӋ4neH 3KB5g R냊gѼM}˻Y>9)]y Y,(SMA듛BGwۚS-˧̵m>T$ V,ń%YhmTq7% &d&h$b bSvhRSP`iH&AqV$V[Ԯ ),.8&UGpE<$͞U1:s!@M+Bf6Stk/o=0_궗df>U_RmB?g moۼ_|1hC۶}'6?P|oYׁt \y}v)6p)ȑM^ ~K/<L6uUT?]x!ХKS_@|xa Xy'^x!Hn6ϊR`,{_w&Mb|6у+*[3n {E^^~ib+$*e EœEcK6[KRPB@}99 CllRQ_ql&|Ky..}>t8X 8/8xF9o4cBZO@F=p}T2w> XxESN5 ݌_=c ' vlӝr g8$O ; :dK/ z]% lZƸg; ' };H>pn tn_W/ۥGFa2GY](,,DaaMod̶]DQ$)E6gWpOHxUsٲ- /Y8,бcA.Q)SiQFSւ.(nY]1_yR7`m~zX}i͛f'Moy!Auyq:Wfӧ3/(_Xl<c;dfGXhq=aF3 V1߹3={g>~hi)rAeI#e&Tj3cUQPٳ" ?2ӘȭY-Rs,ʬ%Dث$ra0{w` N:-:kWvOӀ@T^e:v7;V[FLu};Ho+lN2r|vۤu {7cd󀣯3M&2PSҺ0j zcAMeh^k[~~:w"P4ݺunύJ˲f|esLT [[ZUQt 6>@"ڰ-u똲=tĩ1uӞj;`Ʀ&u#ubb-nξSXs8{2'Iכ_4')'E eTA&CU oUѨLH*VY2je>jl G4IwrUiN+n+w4-,7:O ;K/A{Ymr3SXm:])YE]D֎lOo9lxVD/  M2ψbdUuKܢӁPS3q^Ir1,Aݨ%2%͠⋛\ę#5F2'՜ap\Ҵg,4m";\7sQLs[)KmPURr E' PY\xg{[@q8B@H,iE>2Y> f~HG&qO) -{4MOgN Mr3Üf?MtV[RF4PJVI*cUQ]WY>g|f]:<  ~MtZ`@+ӊrRrg!lcSdzxyٳAa &P6;YQлfݑH3{K {=LLPԒQV7J&*Ws3rss|rD2W4W*WE{-! D.xDl͖g6i6}C^/HQqcsRq(lᱜ|,2M v8(Y8.QlR1s񔎢2 jOYl}~8FEE ԚhM]Y[AO=zE@Y <9&̺:L+`A&LIH^Ekzu\qpDzR ZSþ_|1г'襗aN +x]D@n.σ,^ zՠo z: \s CwcEYزς].WW3A;t9$ٳ3<ә :8`|d gE);yVOU~bVlmOk%d6m[[H4Mj&u^w3?A3~ӟܿN7HdzϔRs3IiߪU|մ2~?|95/ftI`m:K8/ZDU/\H˛SJMT]47pS_ : J)=(W/jMSe.cy9;?gͧ;鼿qFҞYd mhhpmKfxmEu xc91?]gxc`p1z(LH|"YX A< oB/Q ,16lh{FydgN>V^g{=mi};w/904A'Lٺ=,#ׁ)S@&Of}q;Xv(ݹQvNYq1+_Z$%6u)-err{`}I Щл7U}f4 S'#@ƍ#cŌ|@ޠz#PY>Ur`e K.A9>,>chhC  )GA>ۙ;uj:8gB0;(`?ݟ?)FnAY& %O93o@< `fu56 8@@^{H4=SGm̩W$A%OK4<'_H;D}23Uȏ>y[ ژRʨ- ?کг'c?=`z |-H edbd<`P=䣏@S9Y MۯPV֔ cPƚ6 jː`tᄧ]ӌg߃TUvt޴qw`PɇΐMAJJWۇ+* cl}q1k|CHar%pI0Q٣T$U!˨/Yy-*7\۶~4mnrSBX m%tB c@2 @W3M&kcŭJL@R55Mz )xlÚfm̞ tNH-4`[4 IDSNC. ͚LpOHmfk ,sIVeD]QĢ«zڳUlDz>UOفS ve7.N@'K 6Q[:xdsv[R44%{@HJYc%8Ycęh 儇BNN[hmrkRm `@\=m1G1* ,KDX-ce`"2 %E)df*x!r@ Xf<٢5gkOm2vP-DKagf`T\@ɯ35kiO.:PZ|2Y>LaT) E 8-JdT=eUNo%|ld%P ,T6L/#0Y>Ee`s7b e2L-̤bkUV>W$Dl9,LOMˆy m[,K&b{UOq[hLF%ENSƟs\͹LvE!H*,jOQҿlhD~nn:aLT&BEQlL*BĆkU] y"2Ŕ,]D*SZɲy(JV\ȜSdv袲ez&L6˧&cwTl* H$CȰBwza"/,u X,-АE&0ƀFx_,C@UCح-n&xuT_HͥeCE R1[po2UzRbO>ҥK.]AaFZ#S$ۊ™׫#]ױfTTT'OO]vaӦMv9i8v)++Cnn$R۷oѣA)7ݣG9^z0 躎}! wވD"֭ƍ?CN)EJwi'{g?h29]vZrϞ=a& @uu5}~\ˀлwo;w m|w]qA|KaǜmU,3t$uIi4iUEF`ENT2"O,i C>Zhgȧ1[UU73<\PJǃ\$ TWWgϞسg(hӦ]V<_ ۬Q ˜1cgDQ7n9a&?xk0`!b7o:u+GICC}x&);''aƍ4hjkkx$IC4$ DQ466oĥ^W_}< 0sAAAe>H~nSw 77`a`8Fgi(,,D$ihhhH+#4M1gF]]1rHѣ+m>_"L hhh@yy9~TVV7oތg̙k.444`͘3gkkkQPP`ATTT?FCCڶmkO^^~x^#??`yyyG^^:X˖-믿0CaРABMM f̘mۢ@~yHI"e(.sɧb؈_ᨡ#1޳@ "E "Pq(K s|fEҒ,nB![oSO=ѣGNΝ;g^{5 6 Æ K3 Yfڵx1j(m ,e&LE/r; 'pqF,Yȑ#1tP:to.CMӬ[_PH_~9K|Xp!q 7fB(!>ݺu?n]vE4>#зo_ҥKژ" B4޽{ѦM <7x#SO=xSL4 ڵ耀iY>UL*<5g[.kcp ðaئ&#H,z*2K@ xNɩ< IDATD"62slx6q>"e,*)Zbgr@5~f*|F4-mZiv M4VAb6cYe9벞]tnl`9b\sGg2hWXwY%f2wPQbl\}e9زEaQzٺ&nlk#;UթțI5 wz<bҥ-VTe̅B|9@Xiq2_zq"S&gUA<:'eR59H6T1SDY>I 3(E,yj_3"fS5&;5?͵5˧Z(ckY>Ϫ: {EQ5\NAdx \sO'՚UeTbU2PfTeE*>* /[ |_Dh UVd"%rbQQ(˨ E!-:(CQ2HE C;U{Uu,*Xk5g& [.q^zXvl-d Odr)^YD$sQD4/WLP<%[/@PmIx2^&Rek#jǹ a*`)T|PpN<ʬ0aر܍D"\Mu2D$A"H]ǛsvbEsYh4mo++f/PnbCBF r}ݚf.X,p8lIf_z}"SNݻw9Hq/wtίMqO>7_M|M|b/RP&!t2"ށk旯j~HI5[γ_;ԩ{|v@u-[ cƌܹsm2j(1{J>80o޼2~i{iJ@7|ߏ#ŋq '37|ĉq6V8&NSO=7oNCf P[[38W]uUځW_ak0\pG[9c3f |AVː!C`9\wuvβw>C$Ia\tE83cN:aǎ?~-.&ըn%7E#Rk/3ϤO<D"GǏ{˖-}ݻw\ZUUEi2D&Ij&M&t瞣[lgϦ\r u^}믧{5:tRJ駟~JO+++)Rzн{]v ۶mݵk tǎTu\ver 6|zAyf:]ACo98ߩ|ʹܾ׾}fO4Ν;RJi<?HؠiEE0a]xֵmfZup?=o7]sJi_%bkM.$ٓ.X666 'z?HX,f 8H$B:DGAmۖup8zGҙ3g͛7dL&i2RZTT֮nΞ=I(СCСCGMtB~0OK'nO>v PJ E": TgZRJZD1ߡĢbS9X"C9+`Rah~h555hEAuu5*TVV;wNKRA, ZDpUWOG(bH,"ۧ!@@^9995gؼy3+K.\ekݺuٳ=[0zhATRgy^a(ę[8_AkOu۹ԉE^$SX!xz*x wy&sdtIg+B* aǎ8p `ʕӧPSSarssxzBQQu_4|7iPMpbi+Wرc>ec:u*Og}aժUdlmqZ|9>|+d.{wmpûﾻٸXװa;8/"1/eeeRs~8]r%9r$WWt^XٟaʓYU^hHNlO^Tr!d2  Zmp+Of%x<6{|4M. Ң[Z4 5556wj^v8vDnͨs"{%dG4ap~U=~N\/3o,2 .kh),5*msps,Sg'Z 16Jp: ?0H"k嶱U3@eDЙ}tf[ۚS_SE9=dVEg ܗ[555iB%G$-(WS6Xg"1Yrk,R,\5˧`6~Y>[|Iߑ+cwTQ2UE %jEan' BM$ETdlIhʴ) V=EbRd`*oو^Bdp0e!2(* L "C$QU+MiB!e Ice܋h{Yܶ2Kk!(R!"Wڬܪp6ȏiTexڢN d?ő]D!D-ELw TQZ@ d]@@iP%'v2喱*-C mvYlrBř8Xc -b9e9U42hQQhn@T)=/-o6r6d,5An% sSdgKP 9p@@)mXρh>M&efY4i)(q[ OD",] aV;DTW ,JfءZSzp/<끊fJZր,J)?d];͟5Mj PQt!C u[`6M={@fTVUZ eDEV`2(U lHᨚ%EfgJ;[OQJAIx4(!Z=@,4a@(}2|ГI]F?^| h<$RZ@D<8xT(3M&YR}H4 ꫠ\RY M[M!gR`C7 ؿ#>O3H< 5 h#ktH&̧jnJЅ:m۶h߾=ڶm!C_S_iED'`^Uͮb 5qK|Z,'ݷع-.=pؾ-X x@ A֮eEͷlap ھ8x-ւgXiWm22^_ϾlvݿHdǮ]vnם;lx/2jH0tXlM,{2z@zVV6Li]~){l۶ XhQZ,|O%DI! twҥ L4}X8|{Yk,7Y}f@L9'!]|zq6mԂ' {7rѠc4կ@>fe%= =z&iƍ_}6)e0kkAAe@z Ă8rY FY &Aiر7hPx}k?4v< 7q/W-tCP-w 6//ǭފ7skm*с["KK3"QH6)XkdK$BoPs4J7ntfj{/5Υv}0>8s/;\隚滮am:蓽@If?ȸji˂Ah A6|\n]W4n0X4 \s  cz2qwoҙj̡2‘dlg}&4u|Bh__aD TU|5Hmv-O ?؟+= t*293O s:LdfsO9ե['9Q9y2ĉ0̪Ov\8 ̝ ujh?cm4݌ }M`fܟkv||PlT[ πRЯ >lf`83㎳ȌC O v`lh+@$`w;쬳>LMON[ׁÇA~sP'@,5/D%Ky$\ɠ}[}99V[܅]L旬\ 6b9瀝qoc0%JL&Çcʔ)t/S}fi62\.GY#eƢU Uڸ!f:=#3F$-v Ƭ{Y 3\pnJYRe]ϲm鷕E**$2 t)yl .LTh+K֠NQIs&I0Ak6՜Nl糯%ZVկZgv]M ۹:v.?XV]f7[?0,*z^EZ6AEA"֪|,ҰL<|'I n]\eP=\;5MUuϪ?%dfXtV_9~){;X>a],,`t||.2eD A,WىpQ ī,3\x"~T,2>j*(N]&,>eVɬ"Xfa}9 W5T~nU2/2,OҨb^TUӍۋCdAn5Wu ``Q{D>vYem友V6!@U=oA{r)vzAJ`d ^d8QeVg<'1Kh(vqbn EdVetH`,Jj"G,rѸnve>@KB>nؽH(U:-s7pnmVؼNݢdRhI*" G% Le1G\&-U\wB\&FF[w06nUUba]?#nmXe3J3ǃ> HOn˪$cʺ#}u~M|gɂYxa6?ڨH\Y& )X;:N,˧tvoƽ򬥲2z`VG.׷/1cn:|H"+-@99@׮YJo6X&|>'~~AgJȊfɆt)PXv`g2#4nXY0hO~aÀt)O$9(/z(qXy9ۗ_Id.;Ő޵\Ii ڵ˂T馛R -$RdRh«dxvr]E5{\ 26l K,0}|2^{t kDdixu"2 >T "}t?ѣ3I-˶'"2?tyc<ҿ׿f3]'ظ}~U="<ߟӡ&"ȨxE;wqѫJh4A 3E*Cv]{ Dρ*XCc1`B:h Rkft<\w2K9W[4}:p_U4V.qoy[}PP ?|8M7YRC1iӀv&N[w;a_}-YՍ(~L)͙烥AQZ9R)Pu_=ЩiQE!ʂ%Tnڵ }F3fxrg؅DQ^_bshnu+~ y^>> tdi\?t8|AKm)G[JKA h3p$Qhj@.*j,;4 'CMsߧLVeh{}I@VY-#FpeӦi|bw.]2*DqO=QETyL4 ={{聣: 3gD~~{N50F}E%Ƌ5[sj^Y>**N<e]`rvw|5'z&kA<~S^qGU;?:護]w p|RM$bУ3Y <0z4ͅ ᰣ&NA1-tӟͲEOs7zǖ\˧1`tu7 àDXx}oi rTS$ذcE"VhPG9t魕2./Xu|RB);w^}4Hw   v;?`Æqc`\uǸ^Ui?Vy%hwozxV&L涖_}%cTP E©0F S]TEIMnvrP-ݝ IDAT^dY^S\rluG1+K@D"yy@K X8'C4jHyPǯ3D@i56kt/"SL`@Ƹ sM% MkEA1_v4R }2!DjJNà"މEEmol+,\Z't45Uw-iK[Uu v#UדJAQ;T$rDln;yγXzȒBN3"Z@ MB+0 Z`u0}6P:٦7ߴ&v6c w5;> Dv&q`c@:X>;X>UXT,oT˧%vW"^Qe$t쀈.An.N:"N*M膲"nF$W{,fD̎!4e9ڢO*z[2lym`U&%꙲tW7Q]^'Z+OpkC{6XG^m.my5Se{lqH*t*y2" ;t[UeT''6˧?˧4BMt[T~e+dJ g)jd EXF &2Ð j[n NI b6/ ˻WOq.5."qDźbM@eh nVTo j( TYkR5E~XefYhXX[,c!JY?gN]V$Pn"]ad d 'J/-YDO42f5B#Bq1E} *[DF5/CbNîFmEpeNRBQ2KΨHb?JpaxXp*)^HeF>Lݮ?sSg267^%'5PUɲӾ/˧gWa8wsYYNP1~T -J?Fuu5t]GNN& `GpUU+(J?8|H!#oE"M,^%U%wH|ߛ1`ý 0w?~|n `&L -袋pie q饗f4|gMgSLA(Baa!^xᅌ6ٳGu:uM69vҶmЧOW^3,X|[9s  aXp!6oތd2in:d}f0x@4{lzg)R}}=B!2 vMVq2ppvlZOׯ[b_R,SOȀ#dn^+DC\#[nşgr-V0|0` d{=# J+1f["j94~a!롥Tsd s&YǦ k b?aB(/+V|ʌ1lY0>ȼ25HFJB%[YQQn-cba`ɒ%\ dDD"4֟}$Iq L }GN{o]tAcc}ĈعsgFwy'}Q[YOџaNj/Zg%cf͚?ٳѯ_? :/D"d2X,x<"Bmm-?xi,:7[%qRDAD@%:wuG:;(Hfqv E2Jx*מ%I/⪫{R)աDdMB֟yt o4Mmi~a͚5H&طok]t邖@<GNNe4۷o51t]ؕW\޽{guW??QPPχ XgT*={8s-ןއT dD7 VZiӦO?E,5\/2FMRu m ]R ihhllȑ#,FEyY>:d2f躎{ [lA  PWWrssq5׀1޽{[/1p8Rڵk1eW^qm_B0P^^s=W^OD8tN=T0PVV6e ֭C^СCq';̙33bL:1bŊ3^0P䒻lI*h---hnnaX~=͛C" 1ŋ[H$( pG<򐗗uyy^5B.n۟#IzHDi%\"W-KKBb/p|^:ɜ|^X2D^e?LBvySu裏sQυXK #L֋;D4Gg*"JƪsEV9epQD3XNAfQJz=>ظq.,CNn Å*ۮ5(Rd 8|u-=΢QP5-X^O#D/O'nj֎hqLyPbUPGeL" Gfhs38ɠd)ncM' ^q2DPs,ryVNQ1݋EJ %89TA!T^d Q-OZUU}6mO=&˒[ Owe"KsD9LUe2gㅐ΋8u}i@jRQ9dy2[#CnQQdYs2Hj)p[VSh+bitrUEbCOuukȕ.q,* fMltɲDmM$(}W8#ZDe"Okѳ[&v[,Dbx*Z:Vu%2d*D6EOEAv)z'XX_fpMx}ctj8hHUAFS-nˌYfQlܨd*(E\+ e"T |{l] j!GDr0Qz'D/Ɩ-[WzWB.@ L5mbM<'_}/4Ǝ E'Ey&"J#?SbQPP&|>Ïh4q^Fcc# ٍ5&MRbw5u+WDnn. Jp8 ߏ&r-1c 2Ԏh4 ]٢(rssќ>2i~>fX[$@ psXn҂<}a~0 P6mdY(yyVZAAz: mU W2wLSSd;H2c.\7|:ojkkwޱ&O> ;w.:ر<}݌۷oǣ>%Kd>裘?>vZ,^xnfȢE/ZZZzjyޱ~!~a|GGDh"/'x0g{V{/^555ֹs.\7x}|8L{챨2af1ЩS'L8&Mo>?я0`ܹӒ fΜ χ}qW.**Buu59 8;wV]W^ݻ7vڅѣGC4AB!tB 8p `ڴiVñvZ3hll:i$=***P^^O>pw1uT}ǠAлwo~c/oq  !''999ز_` Ee%O~.#GDuu5O?H$2dV^4ЀX,(--ED r3iL0q*++tRaAl۶ Ò%KPWW_~Çٳ1k,TUU;Ą 0}t \s >l䠡+W믿n*d#H`РA/kpwgϞ8s`Ν#F /HɎ/)))/ܚ>s -[00dG~~fdo֭8PSSd2>sũ@ :tO?tٳe 6E%{)*)i/?,l͛7s|(--E"h?OXv-4M_' FW_}5D9 |yg?Yʉa˃a(--m^ЀTUUY :td2dǎ8ADѣGTT{&y:t>,yxpEH%`00h騪Œ3,)(++ȑ#-]>``0]3a/EEE|rk _T˧C=͝.¢Ep饗aÆ >o& XD"7n`޽8Cuu5z!lt>7}z6y9994 gO姃S>e:ڲi]@6PҀS]]ifۗH=S aJrssJJJ( Ν;I4>|8~:|0} F۶mڵk),//9sX϶[nɸ0 D"/B---mihuQ(T2pD]"DQ Ѿ#:hURLXA-Q kts0ϩN0*^5yd\}8s~鞢7[~e~CDHRޯN6W[,PUUZԪ }auƋ6 d>#0 "[ddCoB鵟LUCC"ST)[߬b MB,L^*@`M6Ϫ|:ENZU2B*)P*}*T B*CFJl/7QgNSVVfEaTK 1/,47/aHYܰ(xC%i\Dno37n/F8[F,J bTItnaNl-uC .[Me*"l&˜WɉV۪#zy*t2b} ۢ%bL&6#{mQRjGzMh8Е'F{uU8֠#%~n+lt Tm%-v O.)e,~ VUes;'X]TSh#Y$`~=WEbP!v.dF17(!2B9ӲS8)#v^pxy^egϮ=[>Vq.4/[ T nb m$,2D#pdh?,"[@i%ab1asJm&yci;\E6H_utDpn%&uKv|*+ sd CdOD;U SfTޯ ʓXmt!VgD[+=H10"0@fl3^ !$n8s*I>t@ Y[Fl*֊BCeꊪPV1ZJwtF$qݹe/;׶!0W8:[3od%j`( &;Uu}=T 8pxlowsQ`"xK_f28M*q,~J (**;３ydY>u6@ii-zEY1 0M> ځX" `.Rv7IŽ= j[Ju~Y:l$TQU^9㗿M|w{͘0}p`&~ଳ MYϢ"3B!=Cn%%g %շy ft.lΥ3@0jj@bZ'@Ϟ'gΙV:%5 xuܺpk@E(:(/:Agü<ԩ|Z3In:l˧;B99T\܉V~mXc(K1% J2K!c [Z "t""N2>'7ߐe|߻#Cɸ^GMeed44d崦Jω#wͯܙyѫQ:zS\ηhBh~2,!'?!Wee /]5)o~oss3 |7WB, HAm/xAdn:t55_f (a%%|bk2 ǹW =xxiгς{.=r@k0ڱǂ9):g!u[Zٺn" yP}Šhiƾ-[ c pQorІ ܄Mů*RٓᤓNBqq5YJJJpK:DtM2!sɒ\DI7*JڑȮO<i8qXP~hU,'0v57`pt-a%%Ϋ[Qp=`׃n8^W'57ᓇOu.>}@=XNo>Lk3|>n:t[`%%͛*xm^W@c\W7 j{w $]}gA IDAT=֭0.̔w|MC1r%/ ~зB ۢlUob T n2whEΉ^OW}Yڽ{7Da:T0]W 6m6[/`K&O6h#`˖q '6[cƀ}1s=swn`@OxX 8kj R ++e \>y+_v9j`[w}+=*a֣X'= b1ˁp4v,:VQz>.a܏?ť/=y4{֬o+%#mʒўi/ I $Y*2@87gZP(CG(\\4PNNkJK g((7On"L%"vI`̀2]H`kLX09S)~O oYmeͭK?0bY4zWۑH@?RT:/Y"]T&ΪF͢VW|rǢ {3vnYDJFj̱H$oȂ۔Cڹ/I /KbD^Nez**'/,N1C|ZeA0H*{%[d"(WQ,k W40˧hH1Xq ZeR"6<:h2i$^OQY*ꮓ`t.VnQW aC2wۋWsu1\-'t ^vH@ReR~aSn.HV/l˧lAq% ^X>[ن1C.],*Odc.筺 q]ye6#~Ru#us@N]}`h6@ee684k!q D%Yfu.k`\pL`vh21 :SӃش iZZ={46aIرP6l1ЛofVx\<ۮ]>D/^2% Qе+Ex++y;<oքt;LMᇁ=xQС>}@(p0?t5,&7k(xI*n /PΛ7onB {$2,͝'RvB`UqJ',Tx]%F쮻`9Eqj  AHˁ$R)PUhj7ԣOeeN,D0p饗OĘ1cpǢsθ+Qvy;:X>$K5àF9Wx1hם=#v&3V߂G`3fW]wù}g`40nhZ`Tc}5΃Bkh;`qوg= ӢmG>-ߟO9.ܝwrq?//} "NX/8W5jXEc/nW^т(Z'@$x=Tr[ߊ9LrAl'?)6@iK2X&&qi|Vf,6)6aFنf{%|IX4aoLtV r *חj LWV#!՘pά@"AP)Ws{5҈"C'!@lED4VoXo(ÿ o~{oMi{m""a M˘f}h/Bf`/UTQX3"|Tnd1` 32EHbd2IT(Ud2dCyN_%X"{^Tdx*A,2܋sBƸMe]ыtj*p(TT7I%'|PeNf7͗*;A֞kYN* NI&򋩰|XS`*yVMF+ xPDzQCDNiQ*Ȉ4PD*1"V]$'̠%+, QBmdx$h,ɲ U$(%kc 2=EJX(!E((E*-zʠ\eUO&޸S ꑍc©*_][j!n/NeǔM|y^D,72"hD[[D>>U+=e!v2$HJP*ҮJlY>An($B‰E-]v*mqU?˧*fgd Tu1*H7,)EBf}M&uřn @INHN @*JVneQ`eUߗ""[Н&4UQNDTf6:5EBd+Wm Bvz77^z)Ѳ҂7Xlx{= DD"+W⮻xT)trUϫJ$IR"}U&m82h-Yf:e0ʧrj@SS χP(ZZZًy JRb꺎X,<}h#7[nN.ǡ:B,'7Ku4ΚǼyyyhjjB^^Uظq#.b*(cM4V @<G(@A!Y>mt >M4wcxeef#2Ѯ]YYÇcƌ曭a/ԩSqmYwq2dbʔ)u] Dq}:o|뭷3|q{n̚5 g}6/^D"[ GСCUUU9眃0 ZL<&LCn݊ӧ+̨Ikaʔ)x, pݻwCϞ=гgOGlUH* "iJb9"h{ZmXM0 w@g}6[K|rɡuoM( w}GMMMD(ÇnvhժUO1C{***hժU_uZZZ裏UVw}Guuudھ};UWWS^諯۷ө ڸq#z]DDd_|A[nӒ%K񯡡bM6w}G/g>c֭s~҆ h˖-SOٳi۶m;̙3)HP^^;@_5 0֮]KU|IZ~=͛);sw{>6[Mu{T_R,sone},ny:˷ξef`DάsUNQtFi%oݺ Ž;н{wK޲e ֬YaÆPQQ<ۇF|8묳ocԨQXz5Hׯ_#GrJ >qF uuuXz5p{EΝ9a߾}ܹ37ߠ X G"uЧO~|opꩧHc VBeeXH---ҥ 8"qF 4999ضmƏf躎Kbذao1d:k=z4iiZt.)烦i(,.ߠ2-w|yO-9ܢm5wڹGyy9B󕕕\|Mz=Hо}֬Y,wGm۳g]y啴qF""kiʕusΥ7|37ҴihT]]M{ݻwHRl2)W?̙CDD6lr4h-_<}޽{i޽yfJϨqGB~݁}DzDъ+[encV&y\붛%۩U%7iEenWA[o1C/^z58j q'#Μ6l^{5t]vEcc#`ڄvyyy8p@ƹi[@$A,կ~1cdWVVŋ޽;uO?T:tcǎ7ߌQFa˖-zGQ߿8t<'b;v,-[T*oW_}5ufem"@SSS˼g$3Z-]> } @ +ܒDV}wWHeYȪO-~d;񧾾T {/V\ -M{!0 \wuV'"//ϲTࡇZg}SO=p8} (++C8ƞ={p饗Z۽{7"RvލI&Y-X;w(||>e񮭭E*wW#ȰaC(ѿu麎f444 J@,aܸqX|9̙.]X۷$uB"PJY6cbcXwcPr,24PQ FЫLň&J0*iAT~|0 =#ۚ;s1N9=Ǽ񺮻T*]d2۬Lj#pBTUU mfn}뺵B}fzyƋʦW;j*,O5_Aխ( qc'kP.˚q:&ӳ(9aɂҠ 4 Dl10j*ˈ'2ȸ-4fQ$˺=NFFNqrc΋AQ6O ѣrB<kTE>J &`0œM2*ff,MH.dvQj,o-TTUͿ"&JT4BMaGS0_& :4`/˧l7qQ+s;X>!\:X>#鄫%V(O"%}SŨbLwaTY(e,OC|:UUce:/^l^Q&@Y>e: ;_Sf]U1nyA/ZtUdT=\\gN,*qپcTvXlWdL2c+T2˰Z.jLX>1U^[¿H?aYen Nd2 09^SQaoבbePu|0,LT sd^Ueu4Xrr۳g4}WRl0XHe Nl2qh+ Au[&M$hʠE * #TL2#G<G0D2c 0;'JewnvԚYCOua f)qVBnn.B ð|>|>pM7a;vl`ddz̘Qifwv |D2#YMӬݻcݺuBBsSTf72˷Kޯ}r@8ǧcȐ!;V bNJQd%kIaqVPS8tm߾ Buu50vjL&Q]]\뼉R[[ 4q$ TWWkjj2;fLy(BEEb8"Bn QWWg69Dss3wYi ԠwިiիriZy{nSSjjj0`6uGcc# ѥKwFNN***w^uQ۷/mئfDQ1:b1Ztv؁>B֭b|%>`wD*{6JdO]EbMѹ4˧y <@ F 0 b1B!}XuFxdD"s9Xh^|Eu---1c~k?SKKCR$d2IX***ʍw'"e˖O7o;v/L?3KRtaԩضyqH,2tߎ‹F" ŭ|(s`,mD4I,c ˗/2}>h4 Y駟aܹO~x-AGeeeJ]/-))w܁ohԊ 7WMχT*ec׮]D"xgi&LF7wofͲ$#GbӦMR{"UW]_hjjŠ+0j(׸mQL(¼yL&H$yfgE kn=~;w̭ߐ0 'NN81lٲyvzloHM0}t3c"|>Qm_D2e/q}e޻wo᷿u.JY cƌҥK1i$>3kAd .?ZqXr{b1[n|i{tә` vH h~7k"^J|mD;{?dgw6bޅST0E<7o0]泜~Z!sͪD` AMg"xkPl/,s$99y"ggVg fgg_Ϻvˮ>{ߛ>lV'`S-8u:X> ˧_ſB!:|>a:>y7([g,Lө@zn$2dd2?;g'3R 6Q dd@~..eOd&ˉq峃fLۋ![ De2VG&z"(JOU&LrAʕ% UQ(MUIB!̐$t~yYQ sReY|,E5I68 /`UA.$"dSdmWSl>$H݈DOn n( /HQe$(7ͿvFhp:=SKK@gW^&u^TaKfVC*;H2vB՝D02(~(O`X`~,ʉ#̬f˝(U:y=VUY$7(>%: x2> DJ]hBëVE:ͫbƫJ;l!dzέt{Z'7b acZױa|~%gvÊK~FlB"{s!jl 4d\)*}Νl^khhh3p&be&ZxT\2(|Uws-Ŷ b,s5'}wa `^sᅭ8{`ݑYo@i4|9 @@*ϙ6PI?]/u nݹfƹf,FdDlx1p7A3gѨ%(0[?SVe*r Q&OO?~:LN; k֬!tУj‰Cl⪊Ѣ4UQ`ȵeVڹerWwYdZf"<[GDwj#Y[a`=:2:tȎ2k_P2 f|?tHYYxZ6aoS4/~0!xL%\F$?裏 b߁Ts]p!S-D#jy jG哥'`0Х L#tHw+vy@o1˝:dehSҤ{|MOp4y2Э(vXOb , )Dz)8uޝ_=8|?&$ ! Am-`VA 8N; uRZDEX[T"S)HH".I=={ˉ;d{\?c` ķuLՆ$9<X}@B<~nDdpmmdUWo9 >."ӟZSھڿ?g"+JGb=~M%::Xǎc[oE`^~eZ]W^;T/d ]al%ЩqK=(\K=t$X4 8@܂] oO:8pS~[!pcPƯg`,ƌVnf.$> : ,c1{֧hjx Ƭh?˴|> TSv5e`;,uhh9ۑ|6}:`(gȯ={,->_2?~@}=o&h%%ݻ^0'Ma!>3'_K,lڴSN8y|,nY<80|8h^F̟<_v8 GJK?O=%틊9s!C@=OpMYPڳXJLŠhkw\~ tmiN>p`%%<ݯبQ@^嗁YxfG?> <4p p` L2nj PeAicX>H,UgX$UTT4-ѳ'J{fW%T\Mh,Lr߭[@&h/>7Mu% BXa!(Ix+7(EA7Q~ns!?ۙ"w/}E-@8_ x=fݺyEӲoy@Ϟ<9g*oUOnN[.-U[F!4K_E8"ҡ_+8ٲ@л7ee=uNu>B|:y.:^P]T%\c[U#ZD\f|WY>Ei$ɱ|ju4ꂪu̴5U r=:.KLQAT**8%U!ۡR^:@":/!]_%˧ Mǯ""W@*2tNFGy2KG~Au Tgft]3$4^Ef(8a'?Z)z/BUA Wl+T>O,B6q~" L+OX4g5c\3d;XuXx#L3`଩B"?-p?SswAa uH:HTn̴{nYVK7S*v*Pt-lyA ʄK5C[9p8O1XBt-զ~I *MM`#F$9lB#X\5&/`ɼN DcrqFya$#rLq]P>w`Z% t%f0yun9?/waK_ǎ[\wh̙`gMBB;l1ԭحyy@+V]r XϞ}@4 R" Dgg'85Ms{\UhwK9b/:2K&)y\/9_" FLcY@/̞͛+> f[]2M.wjɓ`GS7[_~0G5s G?8)B-[״?4Pe aY1noFy{/z=q@6= *J÷SEeW&"98رc(..ƀЧO45"ȷGڬ[@ɀx:,,=gG"}q417;// #iSa!DZ1n\ K6(@1**qc*RhV!7 &G֭K7F&8Yл7`ZL@W\C!Hc,`N;(C'G0fnGQ:ٍ˧TnX5#xrG77X8л7]_F 1ͤv=}7б,x}A J:3Mw,hbGAs.o` PD W|1$ 3Mi6|8:b4v|3w)LSNY:SV憄"Kf]vV3Bbj!d'BuNYP|[`~'y|tllњ,v4 r9>4`o 9i->).NyC!В%|>'9qTrFSָDCdI>}mR =sd 3 GA}}=1m4HHX>zOe@MuFXnܿ3` sؿoWXT XhT@m׸Cٿ;x07mgv^mm\N<(' ` ƴiEUU;,(o饰N]uq4vwN0SuuϏFF`rCw R ԩ밳`mMm^ը :'h,mTsdieY+ܪ`B`irƸ@۽ӉmaidIA1Y""0b%>>ҀQr^XxpnF 7%[?_<~e%1h"YY^pe8 ЃjB !:.Aϗ@Z&Xbg43֖-+aփX!DxUj'! ]mM&cR4WUht#0KMӓPVTY)C6QkΒQ0cGzfq s[<\ÂA>x(R4RY!_,Yӆ (BM^'/Eփе8r,$n:ٻnCOu?vzЀHfyeH [t|*TuEX>iqNd)V񩼰-ꘜn HݬU=nUR[d4jASb\nޚeܢB+J_RҞr*4eH# "=҅[AuzU8n"+NFi ,yY T8ټTٓsT*ց) ϚK zGRT&]GG Od^۟G"LS]X"J:ehi"^k+YJ!)!(Dˬ0[f0WLsVi7Fp 2N,-Տ<:bn݊,7RS'}=UtCMDSSlقT/{}H OcjX> Qu% E~ BPI ߏp8HpW/4cp3M39%K>$}AKK @Dc GQl۶ @ Hz饗=ʲ&ٿFC^///;wׯ UDUΛ7[nE(i^x0ư~z-Bkk+֮]]v86lXtip:GSSV^Ǐǚ5k{kjjnК5krJAaÆ Xv-ZZZtvvGؾ};6l؀p8%عs'^}U477'وD"_kرc0M`Xx1_eYxP__#Gbʔ)(((2W\P(˲Dn:oKoVѣGzj)P.B{ cOaOnOn*cLE }, )n. =U%ͭkem݆FX`Q^^Ew҂J;wDee%b$x}{D0D0D ӧꫯ[nAUU6n܈n 'Nݻ1h K3ΝP(@ b :CE0Ě5kPYY!C`C[[~?&N'N󡸸` %\|~+ ݻwCEEx b1TWWFkAuu5G᭷ٳganƤ?qz^z1pP?,X`hnnNjpȺLBĨFS<"SD-IDATT*kBrTK䖩ҸH{r"'K,ASStEȑ#0a,Y2,]=лwottt#G$A(Baܹsb5k~mc„ |駸c۶m(--?J?~?OсP(#GbI[|91x`=&OgBٳ5\e˖[m߾}B8}4`ڴiOq:t(..ƩS㮻B]]ƍUVax3FQSSbq=6lPVV_GZ|>~uB0r&3MKJ*+)dq3EIk! $;t܆eYdYVgwmӷo_""|i_y啮̙3Ç'׿E;w;vڵk]QҶ+---[ќ9s:x`r_|nݚv#G7L6mwyvA~!ٳgi…t7Saazegz駉>PYYY>v۷iƍǛ3g} ^:W߷:ε҉F"+JDD{H$[n/e[n9x91E+yn3Lp=&6˧=Ξ= ^Itԩx70%A~tvv&=.?dcyy9L 78PӧQ^^.]DA{{;Ət?~%%%hooǙ3g=ؼysڱu={`۶m>\QKJJ裏4M;ID777̙3hkkÉ'555` :u*vޝX v|6Uby mxa$3p''iɮ :R jnʣjٚ4Mjmm%GX+ 裏&k_~iZ>n<&*((oԷo_2 # àѣGS݅'#GRSS1LaPEEm޼N8A'N$}ߧ={-ZDhԨQMFHjkk۹]!CаahРAmիWr?~Zf ͛7N:EvI&QGG;wPKK  :GC%Il/ӤIh׮] ~iG2_i L˾i}v;Z :sYJ MN]qYa,n.>S;:5R,V 47'}Vj<~x̜9'Oj8kbf2E-#_Fx!jT jBoMe{R 3_Y͹XE'TsxnFn\xm&3!v#mH|D*Uȍ S`w$״5/C;o;7r %S %q#wr#7öNϖ}>d/vtFm^!zc><"_${iqkx'TLMy穻*%uڍCdwAG ŏu[v˵|;O艱X# s4.++ =Z8W:~uNcyşa++'7w9ǍWf2yt}qӺ۩=4%]s ^cME59|풙T'\>E% b(+kBѦsA 05aP"8XE0{'HLK0j:hbsIfZ-7^ U><5@gX5_Zs8鄊ζGұ,+,,s-c,,tEG4+xM{}汚gup=G G67 wDs`y.e@(/X9E5@OntF[DA O#("SKlȮ$]xşf$F&"K] u"ɍ4مnF~g("SWd(  _("S]~F {T+:;HRp`kX, # i@KvaO Ԕ߁1<em}\?uD+RͭIENDB`gtkada-24.0.0/docs/gtkada_rm/gtkada-canvas.png000066400000000000000000001650371446021174000211360ustar00rootroot00000000000000PNG  IHDR6  bKGDC pHYs  tIME;: IDATxweǿ3s{۽[ɦt^ M HA {SA)RT EDz -=Mےl˔3{]䳟;wL9sS~ƶmlۺ6܏5M5Myou1zc}Rf̜gʮbG'j3m1zc>zmBN;K>%kljHd2Aז j+4 $Q$ QT^2k "X e $ ^o}nKLS85jfCr(2.8QI$(鼚! "h׃$OUEQ"{c&L:x"9!}O6AI{[ .&A N8q2m-n4M}lIlnorfeҁ(jhJ}}Ȋ cBsXQp\~z{{Xd߀(9T-[ b=44L`T*Ÿ񴷵t:쇤(I8)aϏ!$hӱ Ql(d2 'ւ~C;9Y&/Q`pp>R7O$˖-鴖t dS-[ck׬rsʏg ān}W,[U^tln!TQd2eM֏zl6p(r"2$h Q=V4TU5#Jiɤ:u*//H&AE @2իp͵7k,̏p:6ƏO͚o6%'Ⱥ:O0ijjvFŭu7V4ɷ虺Α$iXz`(D"Q448u2y$כ;zzdY[8ʽrm[G}=1F70P:Ə?mqHcܠe :k'$t2>' Lp8PU \~ h^x\z9.dI`fwBqnj瑞9d1oI?/<Ú5kx<%MYx<x~455D(QϷʭzx(ϊN6Uuj$7S "^S]"8h! T*e>RNe+~ken|+f0 CBǕ/>_ӳlХZ"TITv$J( -R)&L\[@bU; :.ɡ-V ;(p:I)i1VI$I TU7[?Kz#ljzĤ*YQ>r)4$AjNkʆ;+ȥhM1w|V._^ ܬ|6Lsfznanj,̘1MtpeǫF !+ 9#$ *[=C,cܹd2$~*rhEUWZеӾt;i !:u 7n21uVBV$2,gb5'T4qRjR!HJFa&^^>#2q*7\ Qh,rdbZҖѺP$yPq-[\EahLSs3`dօFvuOGD$@ig|8qxnS;IIgīﶠ {YȎ;F66o}7`0X"4Mp( ͝**8Ѓ>DQOz3K,Ȳ\ $rA?Io__A$`IL8MlظqT.K- J:9Ț+F!-rN?-Oɱ[=A|+[("i6<fZAV._z<V._jj2j;t$zZzhj^GeEehko睷^p8ly,Ah4ʽE! 9f5RVYûA{{;m;~QYYijl-懜Ү ~UUb[&QǢEqAc[9DUU*+uجҲu=~TUŲ;#L|q?m,v929 +tttDH$X`VdͲe+̼bSԘ xXl9n&Ix@#tݬX Y01|:u֓f (y""mmm=CXcvc}[30Qtk8N1Uaw_oo/eL$tttrUUe bl IV)Zc+NRU-g¨y= :Nxl-zN!h$I4')\U~_ɠ 6?@5TU5{jB\2*Ιv# X[=rЋj.>N_Rp~hSl[Nۚ[=e|2veg7 /&0m4:;;6m*6lGo_/A`Fz{2e2-ӧH$2Coo]3@d2ii)Lh ?d<8So_D"]ˍ);`'8fz#w_8Fc-@wXmx簷3Giu6zY}9?}ƐtD"|0z9N?\λoE2WCkyGW}?+C:~,oO=;mVHcs:%9x˖q2ǓO(; fޫ`|>G:><U`$+LjƟ"C2 MC:Y* iKHoBI>G;L4^)~M>A~q]dH$~^ ^{E~LN=(~r1$8~z\{\Yj K?x݇Rƍa$lmFjE!LJFcTTCUUu+?dx< ?$I"v=jVEhQrd^jjɚK3 hgwz#lX:^S9`z&킐ˉ 㽺+6GewpQbzwM 84x!Mm,mk?UUU4YQGAmm}~D"hn6+ P暝Fp]?gMYD􉶕0V+G"Dl!GaޣД!f5IGr ~^}wG>;M]4yeELFUU8TUĹ%I:;:F]#IDQv!+ ":J] ZE^vʋt9\.͝\uuww'?bv3y]̣>_>ٳf w}^w#W]y9'ʬũyjfb79hԺԐq ̸yjFM: M3sTxeOՆ15,fVP>&l H.jZ eMb< ^K:)/1POH%o.g(cB5DQ,ql(f6m LvRl7ܿ.8a J劫aN[x7$ QJRj@u4|9";"RʁځMxqT:"(,g.%#@ J*nG؁ҁ QT*d9qxxh4(X[DfL2Y &)4N?$0J]] ױ 4B@2㦺 % t+"(2~|t̥PO;9 %7ٹP(X;\, ;:;_c``jV*B,ګ$LQx+sH:'izhXxq,Z+XyUUbby$јe4UraǙ@ ?TVEa=yiСk7|Jjohd?K5w_&@:\'z2`,4^'sr2>D+-p8ի}QUڦ/8iSKI'Oatvmڴ1LRlޜ01-]N.VNuw2߹_KeR4't*>3f_9EEl.UtxEFQ j-|n3в]q;etR~Z'J\Aj8*&UK} JC4ǛL$!\YoI_o?^ay߆)83):E % HOB5*$1˃汢S$ݞ~1׍R83Bj 2p8Dٚwr%?/ek1MQF}|~|տA_>k8n]rq=넶0gQ+g$dHz{{93%k4MCIYju,k αqo^W7  (Vpes(5Nӄ-c#K/=ܝT:˘ɏ$mƌ ƛo!I7n˅CʏhO &'`n(fz(oem'$](-wn}i#B|k(`˿D2A zQL2`&N[1 %OH(E(HB0J0t}+_XqިbqMJ"%9,X,FE(ĉ'„ H$8C?2ܘe2NCɓH嚨b1KYzxɴiS98DZh}x7匿YTYVH&4DQf2\y/9̳g/qʷg? P׋*h蹬CZ{޹FyrUUц74+СPѐUI'cX,a @mm {9`%$[him%L&ZSO_U@D$4V殻1AVQ$S)~ + 0cy1+r&4]λE[᪒N9P9a:Ro 5r_do}c}+X@/z-{_K5E^Vl6+iJ$N`n-ɚ6Inf͊#ן̗ϥkg~z$^3gvt:me&J V>?#8KH`#3ƌeݬgT8>R&*ӲkU?(?K EmKOzLX@$%@3$S)K#jh^7lڨVPNKI6r$l2KC4w"A@Ub KOE71 #\Eɔۆ2n\( S4 E|*3ܒ E""+> N,vQDEћ0 m8JQd=vcEwUB(Z9Ar,j(r0aӏt[/}LS|TO+*l83f}.L]vٙ> r~*h+*۩ix\ XQk^auI;[/>,i|zTovm0K˞{ΫΤIE1kGwws6?7w܊曮;gw/:9j[v&^14ޒ$4LL$EUU9dn6%r:.8\:::9o}X|97t+yn7nnOʆX߼6ض~F. ߭DϨCKEzdFs!zNt:1_ =XߴkgҤIbYiV gM/1iNlvNsQuꊫus/~Ƒ\.{CUUE!HH$qaĺ+9C2yl#yw5I`Hi \ 3MMͬo^sUU5g{>nݦ) 2?хo>>u3uы+}DQ^DQ:1cz%e˄ u-q9Ӑe@ 7N:YwQG%ׇD$bl\'I@<7 nK4}dhO2{G_M[TCuX2yl\aiJ \xB!6nĬY۱blڰߗߞ>܏H$1d2I,#UVH$X]^%jkkpL6psqmƳ{<dEXa#^}}}}A|^fY~|>[:Zp0y$|cV+Yvzvegz{{q̘1_:6Bsfwaܦaa"vnp#V&t:F|5TXqI3 ,?Y`-ڕo|eYBp>]]̞=+48#QJxC 7•%.AsRX9.^/cۯ즪*̎ a4rQ]]/PżsI(9xө|;!'O{1p-S 55\v"ˊmn,qeL&c4|,555\} BARu!P;D !EQvߞL&S˜bAlrbEl6K[[;<N`T̝;MK.Aoo_JWh4Jmm GkZMo]s%z:WS5EVAr(ϩT Ǎ7BuuըS$ }=khMa|lR)^ںZm~6-6م=n755`.npGrRQ*-ڙ D0$ XڲӾu 8⨯rͷYP;_VUw7qb#7wz/@46o`; OMu5uuu&h*-# Q]3⚫~E:Ц'4PTK.<~? ȹＳwZN{_6g]wo患*^~=l|t㵴 r ^BQ+ishl}fRcEL&̙ۑNg:A N3kLs% [&av3\yd]śWov$ j >uu ~xmW]K Y;VӧGENfϚWrT./.vy'Y ?JEhƂC?M>?A0T&\UUUxL6~ߑ8:;ci̜5>/+v(/RUXEꃕ}jAjXi`+,ƊaH)ne5x!\%+ehF|i &Mi_ќs\1c=f݌7Y\.yU4-駟\tw!utuwcI2?/155zw"1A(fq8~کYgNUUʪqhF$)n_d~l`;CpaNK|aбFd2 u C,z^EQ l\yy%#oofv3ذiNcvJc Fdŀ'_tz J1ud:hfϞ hmkg``~Z Y5 Cvoh^QV6e3*4i=z97@V UUֶ6jdzE$bmO$֭@s:7NcvYcmxzQƦd+!Eg8YV8/i< w/T:ms2l6K(74ߗI\|ke^HR&~bʔX/,p*N>`IkIr)IÝ(%E |>mm{]7hpey:@oo'I# 6hHn _Tzž5ruW~Ys̱'0udbX0꺆Z^YQUKYpGnZ\}^nƨj n0|9T',3ed? WVnp\p|><,_|}ٛӦ\05ճ{FL&˴Sijjg˖plZZnk-+f9룹i^38luuuDc1pyicd6$I^~%Iywyu6KoZa-_Δɓ pPA@SU\nW. |^/hmEQ"ʫb,ܕ>Enj} tuQ}UJ]t姌XEA&]iUN@!sVazrlkL&˥gˇƇ.?;-"zJ[٬̸qX~^yU?dnVﰳU~G,zL!>R~N,NBA.Ul~?ŗ^*?nWq Oc++V_Z|8K}}o{1?FW$ܚkNgp:ݖ ;UPbsL ,_݊V%(i(M~dfwM-Ve ߛe0a}b_#~mhko7{D޾QKikkcŊU&TU-̏ 23f[@{fYcWOnEa֬,_)'[C7N TYͷȚULZ1磌x7y9 Յ c#3)|+x >Vb~@ s@_-ϋ/. Kc[oUPܲ|NXx<^ҢΊɭmtvn)lF{`pk P^,(’%(W˯vE]wMcXr5LDBr؆l /_\~d DjxA;?e.ޠduK/b4ϧ;yDZ[p:Ri +?~)Sf]`PU***}n<'~|,ST4DOweⵕݣG,zwIECiۅ{EQ| (M;ؒ$tslX,nUt'?.`>DQ"|Yz)k֮儓Naw000@SjF9Yz)_q!G`nRi$.-?$IbppϫWrwɁb`` qz O=wTU%${p8ޛ,DRUu$S)Ngp|xoO;ћamy߷ۃbrJxv;-=Z wz38p=r27^ Fc2#IHQa]x݌&b|$?K~bgϢf ?r7~+Vq&7New'nU-< ?;jim孷`;J0tocԅ&K 9Wgr4+m;`|(IcwV>|'~s4Ji qS`eǂ^DI0$2m v Xkz ޻Xp7N'}}f9g|Ї~?nR'A@rFms+**X}ݝ\py72NY'9chll4Z9 o7x߉M6G{IdRTcgݘH^a'`̞=$1{$+iTVV޾ڃszt!;零Bo P6di?$,]ڋ%? ~6@0MZ}QIg2B~=A]w9W:\,fY ߦ :;6?>"@w$pZ#Ӎ^1PvϢWW\MEEV:N\.˗D4f͜ɑGûOH$R`6,Qߟч`ӦVdY7#[j?v*x0s!Y OӉ祲ֶӽyak8 z8ۤsYFwq7Nezc[Fclr+F}c%\z9KqdfՆFeIbwcEZ{}}}%>`^'`Ӧ?TU%OpI#9$M>=vYp!/%ܷl,]@?[VED N>DK͏QFk~z'n7[tx'SNtvPdeD7TBoaxظ~ .x-A"d:UUwϫ*;창\޺(',lofU2ѭ%*e+Ik6Ͽ@uuujl~|:**v*6M"3 qs0k~OOL iIXވtg.8b8s_|sw L$ۡ#Fu\+tp]pW2s,XYбd:vW*}Q|ߟ(?Л8\b6ʫ%flȂ_UUO=g=HƍgbIG2 S:zE#Ur:VEEV÷OLI`feYݪbWճۉD¶uY1xɻ+~fm\O jjjWV))#ᇱUVHӬ\>:Ge;Yj5!d3im3n۲p.% T֬YsϛV<4100H("mkocĂ-BLp8̭c%[n*SUUo&**P~OVCGs~sZi åKYf^neN^~$Q2tl6+~϶Z<^TVVX+G%v%?.Msýwsg\̬9,h#gǏB•x~L "dz(rÍ8yI|xbHJbϢj 8KfwXU%,ڵs;C(H#A:;e ]PXU@ՊCnzL&<"{}H.n- EfH>@fSXL|tTTcj}Ԧ+X,x<vڍGgٲli-#' F{ ?mgv(l6y=C**)CYQN=),, 7R76oaѢ/}7-`4y7xR\C\b M)(rHJ}wGOAA_gFuF|RQv;ii<|lt6{c^e֝wrIINl=)TWҋreò6x<ЈNALGNʫ`QI``qlqlJ*UJs2ha`%;Qj+ZYQ4b>=ĪS6E3Fd@>J^ REI%z8V+dz- ^b,{ϗDgg'Uw9\qյL6JGՆyoJjeŊo)*.$>>^u@;::HLLT mb0B=a+Zۂw;n[،c֟ګx?oHybD -O{O{₨jٺy=ϛ3OCFKG%@,R#.11{﹋/3N?Ϟ1p:1QmQ:`oYYa?q2\UogZH|T ˾_&33S`G?^ x9n,3Z jr|4?+y? Z4lKtp?1tzAj~V+qqqb$Ypw T:*+*ILJ)Сj!##^{B|EܬHc-~ISs ]ERSRR̮]?-F?Fh!ޘE,lѸGn+?퉅b\v\xѥ\{ 2N[brFCx8chjji;pAA_b/(߹S X/Op@DJ!e S4d$ Qd"ukc#33S1 g㰘tЁttt})ҿ|iccޱvX*MфioO#oZ)߾%%YRZINNH߹cFw655u$%%FU'fOko 999,&?VLy:۷w (בi4;:ʃhRJ%UJFZLV t:q+݋qTtD3@ =L,eRfP:d}kc劥lټUpwNjj2n6٣#wBB<}SRRDYY)eePڟACK#+:Zj2Vh4Uh4rboO<dXҽ{+(WXh4ӆ5lۺ{+HGѠjz6.Z-}GZϞڋt$2;phWG]:`읭TjxO5 Sˮ륔~" )DuC z~wo0=Uq#xTDEz=n[om@ @zz%(.)OR[W'MR+r)4&>PrZl ޟ8H$|sϝԭ//|S ̝/[HZ7׋fgy|vTG  ;;!CG׋oh ^kLD;)+gIGAvYijOibaY.,;dP&zWP1cOo~>N+j Rv`詯o [P\A'J}4T򨩩 "*pc444J5J׉l85ȅjxd$QqGSErrrN]^PRk=>}򨨨5~O{jIwaڽU~dfd`U,(磠/LZ8TijFxm_Rڿ?7x=!:qLi }塹03 S{P]SùNb`Z}}<<4~8TEJgp:q8&P z&N:lm/?=L&f7)c@i,K@p=f3_-YᇍIzJb6rrIq'3Ȁ!ڢT"_v#f{A%dH d+_T" V#qE {<FƠAeER}F[Z0ˎD /1DQ4)yr͵70oTUVq|ٗOPU\~L}&&]}E)_[o-niӱK^zߨU8TLs ^/K-FVqGeְ+G cv{B}d!Jhn&iSˎcZ0ҳtxZ/\fIZчrj<^|zq\.g禔є8^z֬YQGW^yqN;nC /1~uu2?z HHhª5Oi1zƍ;ye_x !446rEs=w҉0jF^Og=t.*UW]!-5Ʀ \'L1ټ[h4n7}pp!ZBv~Iӱy,#kX,id#1.&O(Ņu:FK{{;VN228k$>:&^~9 Pڿ6mXKff&Ee~-uq]|z h4j{vjYI\[nv3i,l!vCF"99~Gyg3c6hinE f:ne**TX,f4`o7rp:]L&ncg?u}RROI:Qi@RR" ~r8N'f[9_E|><AZŽ`h4FrJ2:$P&ʝ`z6]0Ant&MhZʢEs@]Qw' h9,3#6Vkg;:cbnRSSPxz+|ݻ AHINNF|0iiq pЯd3ӉZda\{ ;\|R b9w$&=l(gq:_5II]j&N$Ol6;~V+ghmmK/noikh4%fk܂Z&;;\蓟O^^.9YфV?&:{&^|ߌw"A(iZic(%'I$q/o߾}˖-ƛn /Qz];m0d`jxhF>jj8a,[FMjj ttvb %F|!yiqj4.^mC}Gl Z-}!mm,r! 1"R\n qTUUG5UdeeYM1qe, ?|hpOX IDAT4YAKKЃMNNfݺu̘9Enng݁`V?b|bYсN'GKzAhcUj/Ze mm\d=- <Z= ~$t^<πRk+hooGq3PIގ#ͯ2>_;Rq:\w5\ݵ8PrpFNagIUZOKO5G,))gee)Ժ~ꫮ&pUWpؘCH女!O@SoʫeM7kY_z545pI N|"eT.'+V~˨:<. UQCS ٢Uio !!NJ_$...{_i"'`%=6*#=/ FNY#f'.J*U ăW^.+; {kF-ˊ;:j5hZviooGHĊ^Ʀ&8j-0OCcF!l·K^O$xMQ6Ѡr8fZ[nC HJH*qYV/_k1LXrq\\pXe]ޠGv{m4/~3Ogℳj40r6M9g"tZT*hiiK.O|8}L" -tJT*r9C;pGXYF!.uHΝl`oqy]yl).T:zxӢޯJ _AL FqQiأ]~? 3/y}HȥGccS6)?j nVV,_AVk,-ҨLq ; ?NsKKvl444㋡Fcc.WPim*u,<4~ ZOY~R!\.l6x|x< ֏kw83IP+ֆ̐{>g۱BNg{leFjbߺ\.غmFntx<_Ν]J׷/UUaGhq Z[$CNJs%&&ÂўORM *YT}VVjRK Q^ES҂u0e*h>Art8>`WK(ۗ 'ex'4x E%[SZZ"7gQ@Tst2p&OȲfwRSS3sک'swfZRRٳg/9̦[8I̝~ >&N>#<+LTeoEiJ]ݾLh  --vzZ֮SGNN6Udgܭ7{Y&θ?c<4^griE;vPw\|z=;w8$УV˞wMVSWO_6:::.PV.V Mh]vw;.F+cǟvb^ x^<3uj  F232xB%>>^GJJ R Vӥ }^/:nv wv18.= 8`E\hÛu ~.W`[q\lڼO;9팳9kdӥ~h@#8|r0ٵk7^T˒şŭg{{yy9|ck91|=|} 3F˕W]πAW_} B^^.E1`@yS)h4j,0z9̳)/sϿȭ݁dBӱ{nzii2+{Zb)/Ώql\ @aW#&=ו, lGNV1XJ%'NI#~n9yy ;:8a~NзoF ƁFt:PZILH򂘲.cc8{Yv zZZZm "Ťj5y 8v'/XF2tI`gvMK>FTڠtV\kuV{~??s* X,\.Wf tdS2`07a׮IMM k7Y"W ("+E㦜X=)oGcwttÎbǶTUUX-ϚG'?_5ԔjVlF#b,2]r0jO1@X-O'+avГ^ޭ#)'h>vGU#!N'~=NAbbb/"55!`ͷb Z͠,WQPmۨfZ.K1b;jW-'\nw1sA.X}q{zgg{’GJeD.rc*cАR9E,e('Ϭ @qqQX*Z-'//W/N,JLLڞ|5dgeɯ)Q I(XP*ᇔ2B=n 8h{5|KͷCMMmXۯGI6}gO8IϰbINNiKJJ \Ů$f3hHvGsPG$b^nA蛟ȟQbfxР)ɋ A۷nE XRhw,E{0? &Pg|83r(4@ț|ObryGŶ*r1`I@I'!hK`3i4JS 7#T)ĒXM7ߊd9Vikkfq1ǑMbL6RSS-ǥ:;m_Vkl@, Q]~jf'޽̚9JESS3oM#)(///с^c&5KQ\\DbJ&KNvŚs. 5%Eq_RBvn?rioj1w UIUdm 4dv#J4`4InR؁`?zGE<)2!P?@vv&--RIU,0`bb"~N[LjJ⮙ފnB ٱ[]~?RIUn2GۣHDMa*=:O“اba8C0,9(oHlVVdffMC--T'|FgMj'ZNGnnQ'Fam:xʌ|_Nw+Z~kciݞK/*$Q#ouAώ;3OK (.)ĵ$IIIر@ @^^ YY G툉_-Q<7p?;p:øWTwn]s [o"ZR JnOwqI1&ǗʊK0QI~~{$''s2lw"AGGGHR ks9dj}l>N3,"fCs/2xP BaA[&z)f%="hmw(t:{d<c[71Rȃ~6o܈)վJrݼP:qxM=hl4^h@XO{D),'"Eb'0c]<8g6}am9899#8aCp[dd?{F#-M߭`J:#6N lݺ_|IN'111 _z^K/#;_+hmO23397D>@I[d '>0Ji2ddÏo0v1vL K2luI:hƩ{M]]Ç >0 3NO>ʇDO0n9y}s5{d6{u_>H]/k* :%vM?A-v,rK@ӑlKfybkG:uJm=nVr҂ Q؀` , d6ebV+/)fSvw 6V'yTn{7kϨ&f36'Onݏa?E{- 1i d<Ł@Ht@w=6Qe1n;,x~ Cqq0z'ҵ~L~&. !itQ $---lT2D|^^b]]PYTX#D{_V^{j'>]{|CsYs1.y~P,9@UR`E ^>|wë!Ŝb-NHH /<øSNƲe${q:re((,e`Ї ( L8}jEv1F X~QTTTh|So>=6FNn> I/y.eXS)-nZ())&'lcdgsGJ,ڣj*UW]}=;U"C|="}罰%,`͚>cfXH3j۱4tIwRT*m$S Wo-X“NY<wyr:],^c9NldddJffK"rhWӉ@Rr88i\.<q\~յ<$$&GsɥWiZDަ z, ={}p4{4 HHMMtPJٺy=O=*bkj%: =ZFɹ]ģͧd`@d7+ b T_D^nPo9?z JIg5cFx{V(y OUUu}󓝝I}}C71Z'%%N$+":eJӆtEcfk~JIIEDzP]]VctGc1{C|>ނg֟X[~!~/t<$ddfeRYQIiiA222HL rUTT͞={h4x%.JjJ ` C1ſ_~5Ɠ IDAT&SXd2p8 '\T K9qV}t,999TU5V].7'..h4܌`vwG[[#G-ףjlg2i}%\xy66l3>܇+xƦFIU2?zSRۥAbPt$$$(+rPig7q%dNTE2J* 1}ݔ,ȆCE3^и.:;mݔbD=׊*<"kz=۷wS!G sOSL&#˗-N:N-Xn} kw 8Xnb6Gm/rAJRYG4Cti} VXGaZzT-.+{*9gLx6 EհmvӲCP\Djwij8p |ɧ,_I׸|b>|7L ?gN?oΨFϳp᧜w9\uettHJJ^F~h8NYk}_z7tG= #n6ڵgrȡG̷+}$(^*߹ys`0Яh?FEeef >j啗_K|N1Lq:ldeeں=b69T*t!Jq^χl6'Ϗ_-Z.i\479NQ +!ǣ}&ZddvI {Kz֠B'99k|%,_%K7ut:}0>WacǎrZ-mmms1wtv^I'ΫolB<,[5VavkVAyǩq8\#s%W`2Y ~z>gO/yTVT*z*-[Ԍ5>Q銰Bȼ{t9c)beZSiў6 IـRL$VbjbZYAj4Y7?,@-@M3ί^?q'ү>_A_<6^yU{Z DsK v{vmcӦ͌=$t:\?&Œo|gPn>RSY; Euu CXf3,Sfy7:Aéۇ 455SOs駋AY#OK`@]QēNcElڴsc;^E{S TDK7"ǵ'MþJ*+cF@D+4Z x|x^zkHffZ?C'~Ni\|<8P<Adgg[Kс`h0C38X A>\ȑ#j5ܵtZ],!9Q2&&L::n[Z|>zu9F\.7b F~\Օ8x8mmQf-[ʯ{ikk9yלξzz]8녭NJD*}6V,Ŀn7G$b^/6Mmc‚`0),!C0JJJE<|2Î&Bh۾NVYWKhhhk!''+II0u+V|ˁ`degQ[[M8nc2y/Po_עR ձv:s>EZZ*UX,ظq{9rwμaTjjjY\q2& =nGVAa6[hiiahtxzQqb*> &Rx֛k ƒϊ".D i<k}Hf_!/ؼq?_MeUOJ}C?_/O~> PR\Dݾ}|d%/ׯ@J\jIMMS"p1x@>tw,F1PSSKnNN0MdrfxcU%`7z F#>fhoO|KV֋Xf6Vtmݨo,_kZfnϽO>V}1u=h.bm"'@,={oiij0qyY-Ua6%Ťecwu !-UFbᦛo7ߦjIY,^* KvV&^Z6}GffF@fOjjj _sbbZ&*}-0 鈏9Qϛ |2HfhEGVVf,';M0|P?.`Ff2QGRɕ,3ۍΏxMBB# LBB +\sl޺\Zq.j&Uu`=1>Csjg!99o7?++* ;;CQQ0^ڶL~[ɛG%==]*06H9 C@axȒ]eϞ G;/|KŦMy1 a>w6 W^KJJ=ȕ8SSim;'Q7%t:>(n;fEgge|A"Xj?JGHeJr=7!!!DeZ+ O99dgg̙aX88Ù8<ܵ1ŕW]'`𡀆A2X οR:x&}7XVFNxi*U|;FLG{3?KYN$~N"^ôZmN#ڱD0JKs&̳&&Gzz>>V:~ ʧb7ˉۯcpT~WoGfz)_BVV6o={CiS__fjt\rٕT*kQ )%Kʮ\zE̾jj8å}LΙ<X?qÔkzCe~ZE hhii !c<4 ---D[ ӶuS4v{bjE|#wd(,sg9GNd I pr=XF/A`sk e4⿞6XxGQt.Jeȍ@׳t2l(>=>"*)).ͷbU|JXs\rٕ$%%IJɤ@KC^,_L*t: 5nT*[nga@cD!p~|z-,vW:yRЕ<Vxs=%)z 8*I^4vM'{kgx;b^|}!* i_`8Kx۷ 99ujVSS[<-[9SXJO?Gi.*jjj4isOcc#FcP2~<l#ziH8x 3I#x봒Ġ?eFz3QQ/^|v͏͍e3{L;o23ŬomߗBCCz+W~Ǯ]6]HΈ6q`UÅN UZ;:IHhp8{4/J&D7$aϟP(@4- 24 U~_Z2 \=z< 6?ފZd2ES.imi:"dhmm\WQȏ/55$ "55w#q*SC`t6֩|> >ü;x_ʍM?GQ /6GIGq V/^ /ŽҪap*NTVhV0VJǬ&'>BVFPy1}gGeS[[kُǶ{9yF[a X"U>ʃLmc a+w)T۽]_Ay<}0n˅r|׷__>yޢwb8]gf ݲ7q~c/U:YNkP޶'2x17zFb狸/ʸ}Qpt r9Ws"TUE"̖ZQB<**rD֤ Ts/y+ĴEn~]d2y=@_/^B{G,j5El6MpG\<Pui2 / ~߱A:?M(tr3 U=(y׺D"A[[+3gb" dw}l-.cӦM|4.4$EP,+ jm{q$ $()}@ ])(BUH9HErE3>?;P0ؖEzc]ؼy3˅˥Ս64~oA@>ܟ]uU8%~ ѯ%\X#8H$,yDQX,ơL24P;Zd2Ɍ}[ WlVfI6le7#"Ֆk׸SHӎ"pAc׶pWS]feyv}dYm`}tx~RxYO8S{K[<1U!ly^cӇ) T܌XS--Ͳ. L~a+f~~|^ײV*feGsi1s[2Z '|&m_:v;WM?7oQgXUUI$~1,Z K.Ez?w}ϼ"Nys73=&0 I`FYH" /o|&TϜx7nň(K4&i 6n7q$2-Ƀ/wV)c՜:+_MsuTUeɢy%=/~=+Y#7>K"A[1տ˲͛xrmv0f~jEEQDQwvK2/k] #|]P7G[kJ81+_b]&+䚫%E~ulƍsHor߭@UUȣV7^Ss塇2}Ty= =-_U-; }K:ȦϞSɤQ nHdC+SqIHXD7P6anwb{1(!JI'O,+vH( |^/߶_=Ffe<7{MA839wsI'Mg=y%r8M_TE%ݟ*(vI8?as̍1(狢ȪU8C[9dξuz%V-JQEx"6l@4YorͯwGU,YT* M7@ww( rzU@x)9-j [@{Ώ}H.!RF3pӜ./+`T+/f7,nN^Nı$dPU;wۍx"Q3ׇ( m-465q!_L:!}|>/k#>lV&#*qDUF(RA?V CTu `׎C$tcGVs9ēKuu5u3-%x5c, ieʴfITT4{S@Z[[,KE5k2nXぷ2hvm"v8zYh1'r!ߦ:oQZVy<̣a;y .q 1e=ؽ$I"o}'"*P0lh+xQm=bǪkiki&J:6pݬY!ylRIdLV8]y(ˑ:eTVx PʅbEQB<s󳎸JE|&r gV;Wr1g\ј5jj֮]giL̟ɲLOO/țV B&Ae~]^eӼ"z<^|eW룺g՗_[s cEwHD"N%^']w˺5+Hz6uo.\Duu1tJm~(ʲL4Ϧ5]Yj Xr~kYv+fqkVwz:Vj}c״n*70e^lڴYCG.[2_c^t>DE}-p= SwO2,f-+l>mSE?^o9(cas}2;HRZwG"(7OQDd3Y~yŕb\Va3xÇkxV ؊˼Ub ~UG",9UU'9zc̸Id4ʽ.`mg ]6HA.'oEDYupl6S2CcK4s 픉)DFVlғD"1rjL / "˖-gȑF > ed2SS[k+?(//2FDUU>^D"QTcku1.fc\c\Ĝ1)ܺV4dlwQx1OwK]ISʎmɯ}MW[*JdnYLWh'y{(fƍq]$)/(I$0n7nP(D&aN`v2GyA}طu:k=p{''rq)'L$7˛LNpGKYvmuVrj%s̊"OE!3p$„sF=#߾Kϳq&2 HÌƚUx{BUՇB@edYf>}|mѩZZG{Ȥ3|`?wFk"zzzzLc*'$L>:TUe9,XE}]]Q|lyxڊ;BT(Ozi>@Yj-Y;zӰb^|Qr~壏?sd*0vd$`03q,Z0x\opYn:K/>9au9SyWm~|MmTT(}yWv^$IVAAHD8*PEhI" pQ XŽ+Q W[5|eUJSSe H8 =4z=h^|Yޘ2zO .2$I(mp @8vߛ{ﻟ>l֭gkdGQUUE(2̩JvH7pQGaa>>ފ;'BUTˎV)]g(ĿANbx[јvkr=-[awfY~?0mT>:;;q\)p'+.7 mx<;Am]A0 t}XL&A__!!27nh=nwYB}8vE aIYQvԽ I"D!oj cmm{ޅ4b;]t15 KeGP8X(]~zɔVھkæ̖/_Ï!=n7H&.Eh&&1d2Ye% $cM⩧mGLq &,]]xH47dII[[+/H墪*M }}an7'I a<^/>:ÇsO#AdhnnsTW_Ɇ O~H$+(@$֭[ϐ!דH$k?z> Vi x<ؠPdf}EQDeꍱ ~hcμx\>FJT}0U $\s\+M$#Xw[7mTZ(%Ib}W#"}Eoו31@J$jVv6% ѣi|ỄÚRUWEǙ7SAWQ$Iַ >o_0x7mڌ(B!N=$,YG1:1 }U'rމ(y*5f"rQG0}TV\EWF^aԜhl>=%JfMׇy燽C%N~S7,rK &s K+TSW大zqvZjkkƼrz6oL}}=?ɥ\? /jdRQd9Z2TOWF?bD"P#Kr1M>vhGGaB!9^~~JUuy:~u|>'ۮ*KJΏ/,}^˗-b܉/t¦8vdy:j<W_g|orZMߟZ}~ƏaFrCW}}anv8Tp߽gÆ.dE[@w3ޤv@#ɐJm9ym]η.#Foo/H QډUAyBY[QQ#I3FQtG_ۥwdy hnju+YleYyBp/fF6%}}a|wX`!}}}95_AUӹR,Y8/#C EHⱇֿdXn7w2 +EZ=|.g?βg@rvAā(OgV;~Wz[a;Ygs¸qcb,DwwcM2}466򽋾 yhhh(r\#v"Z⇶RK"%ѱb1?_|UUYVXʲ7(42vRұr'LO;@'h4r2bx_c?i4ӏEH$%Kpݴ0th\(89z~3oleΣcb&NڝIv&NbLj;kn3gteOO/--d2Y:GE x﷬35a [#ϼȕj U_d2IOO/~6555şZ򥦺i8jjˋB"(ɬe4v< awz2,d|E! kO$:’*3J[-2|#G4n=WQFZךkFlp,mmEU:EQ2PUwt:M6"[ӤR1H$xsdNcil"wSq%'+E<v3eʞ̝ѨD %:;7B"`[RUU l}d2I,'0e Ag__OC^|Yb8]] zyǴ~sdz7n,Ǐ#.KF,ΐH$0Uz&JH$ ^D"aTb>ο;8YdI;ԾpTWWϬ7*upPUP(DeeeYK]]]QժS-tysݝ3B8S箿j\~-Tݳ=q*b ikj/XHEG,ˌ51c'ɜXN0Wginn∣M86V1 >r> i8V$lqvؐsP _= P,P4Xř8iׂgm5r`T*mQaZijjd/^7J7v6ׇ(455rGswR lr6o>.-]@<ߏ8ԓ2dfr?ZZ <"ӱrƎaE7@M6ѹښ tww#Zx$j/^u9ˍ7=wɞ{NEE.IwM71gvB%*72,w xaB |0^(8K-W^gYΒE($I{]̣<@OOoצ ô1mZ_[Nuu3qҞj|$u}ر,^$wdNӌ=+Vv eYfذ]jo?dH}}au2zNu,]DQDŵqDxV1z{}ۦ"4~j.x 2wT(Ah4JW\ĝ't2=, /r?gɻ~z2,C**̛{Oчοͱ~5u_FG{vFQyc֛7ѣGv:#6 cEsϽ&9F2-ϩ-B$QDf:cet֫vΊydedYFVݹJ+XQl v {<;::R5hk֬5V3Xqțou|Wg:{̨8t/L&K]]-]7Xc8Zݮ10FUur:O>/.G2q*,Y4P(Wy`j}L&qq|&LOss3'O=uzw]^tuuqpI'v;f4vl~<;o/^Q駝bLO/[n㑇 AÌb}^CSst`8k+!PQ%Ψ Q Ö¾qL&)$ur׭[oT7]Nr*T?`! u)/5 IDAT崭Pgil =YrŰc[Ă$ƃ s~BGGyY#FWVP`>fϽ~Hgqt^^/nmO<&:sfˤI9刢ČQZXn=d&x@Q<`(uuyx"e_)M7T{fz>🧟Np/&2{Ȭ7$p1m>p6'ro9ε0cb[Gly3nBa^B꧓q@b~_`UV `)"DBH–o6 cS]m-=TœLcLÆ %PY~V\#,^{r'm\._n~3fڵkI$L6YQ pFu Ϗ*,vp75W_}öMs9r)0p{ȳ7nvR^WVJIMh4F:aϽc)==4psQGmS'n{gX 7zߋ7_^{oCWcnjFDKuu5~<;q-DQ480Lhx;}~b8|# **a:S4iK.䓎g=v%J1śo--x<n7wv3H;n %.Tvnkkmɓw/ʕ+xq(JEJrʼ|V‡ʉu 9 iZAG;d|s VYf5߻b<~u/r҉ 2e͚5dY=Bo 90f(:8/_Xz5XN PQVC$,_ax~a 3ad P[[k &gчNhv\ zNa<\Aҏ1݈;T*m\BjRϦijXEsCzm[+4jmeܬ2XI$fy_;<dXd)WʼnDd2iVZ2S6tL$Ivc*cM⪫e葄B!z{D?"nZBA:qK7Blָ>EhFfܥ >d2iȱ9 ǓJmy9&.&(u~AKꨮ͇TTTܜBy5ȑ#EԮ`_O4?;wcq>7z4FkP<*ƍoS+L2q$$w l-2ǍVzl{@[k+Sj{{{V+t0|EF?SRq|C}]%؛j:;;5fx|P?\'?0ioA2 yz.<7Ξ L~1c9 :V,r]/(z[{t/;G7(9,{K.9~?#raGhIK}}mG1f([bm~D7n,&#<~N(wF&JV^M&aL-u,]Kj:'NĂO?ղO6nN3ax-Zxʶ{l6˨Q#YraQtؕTCj}Ue7pDH3K(]kg+;*~2d2^9s8^s-_A".>L.<9X,FwO{Ls]̧sͷ [39Xr57^j0e> gMu5"DȢ(z +ٰvZUUZ[[Xi˕d;fQfET*ń'@QcMrJVZms4^^yΧڲ=5|EJ z^,Xh(ntdٲF+$f#&P~\es ,98[7\qo.tn9$A2 )6ˉ'ƣO2ba\ßq{OܞTqKxLJuXǞx@ 27˰CyQr#悪$j*r_tR::VqC`=qqߠP(kDQUT%Eek;n1]+n&n8wwikm%DiӦc`SkG ["vaNv)!Xx&-&r-xr@u}88 d ɅE\" V뮻83xGdh`2ax.Zq~|W]y Gq8΅iz>&1#C(%ذKrq'fsc5(ՓWV? nN :;3aಀV~+/=Ϙ1b@:u`wPWO6ߊY[;j{y2-11v2˄%I- l|%HpN&><`?y<3};v,s~_;w7Xz5=$2~8uO>~ ktr^ ~qJ7o>˅Nn1nGz2l'F_QL]-2'E&S˱_a[Ϊj 3e\ TIbkH-c8U KbL6 ֺ]ktVGwB2deDQƌo cn/Gq8]{u-s>W_}O>O??2 ÇrQ__o!x!\JUUUgbH6>l3\N^!M`UJUӔfgP)|ꬨ(ZXZN\I;'i&ϢB#k@IEр=FOqlrn?7f͋d2ZvOr)]]uK;yd/JG= YŰU]7EPH"պEuitqEk׮cE|>괶Lmm-wy;JOk( 3O?eӦZ4D_RorW$իh}mRBv֢BȊi]]]qsш6:VtF{; +H7'`@Ue% /HaxU06<Ⱥ'N09,3nXꆴJ_dJi ƔږJD( ˢKI]~1M< d2ÉFkW݋L66EebZZ""6oe}͈HDc먪?de{guJif::Vr*wѱX,fKx+)|6w{K.e Fh4!I션Kx6| M%<:رcCLy=?>r˖ץ#%K]`^_,J"ٵbE+bE_'VӞ4cǎfɒځ2?>a{%#_흴D+ҩŜ"^ JvY|- ‹ڵSF3+v{p=HL&˦Mxn\oۍآT3>NF+<7Eـ(A@5V*+|(E UUwYVi|n6.d&ص lXq@ԇ*`@ xoXXQill$86EQ#inkk5cblh֡3cǍ5[ TqƲq3xxg `TqF~91P[[kp`_KGeK䩨Jx<XseYj.I9J/M2"rA̡EQ$ G"\.$e ߢ(` H"{aXmq[S0_}FQH*oT:Moomoڔum1%I2Xc"+TB6.Y BymS, KQ{@r% |%꛶vNEI&$\(*QAEJm<Yn.$w&4 d!Xm- *;1i %vxR3vp9WL;ɧ_fii+)NUM]#Iu-*eЇݽ:eKTgP;>JrM9ȝbC^钪? ,^0p[AIBU@4V֫; #+~NK^Jrpݫv}mnRYQF։v-p&ȲLuU#4D?VQB*ˋ/,Prv _DhQVQ1bƩsjI$O\q),ۧV,k?aI{"ݤ$ 6^YYYѴ:VU1Qa+D"Iss '|:Ç 5ؒ,]y2d*ekPE&uub1G`}]-\ X$I~n֮]G2,ZSm䑻8"lWs騥N9Æ}5̚fe҉Q,Yʽݏ㱤pӏb$I‰rLNr^şjc`Zx!{MݗKJ:ta/$`VYI顦:xg j9ZZx<-"/R-`V6gv¥?Y΍M׆լ]ۅM[njMczkY$ K2 + 8Oc=f5[e"7Ӵ唢rb)tq+ZVC;%Ǧ:-ڲڝ_W^̜@чս;,0v][E2=K/JPÝĨA 1$_0(Q«D;/jT H0eYBkp2>5[SSU]3+l{NLϙ͜>c+/1Ŧ3U{ LLZ'j͑B3$?Xu#~u7P[*PԤf&I̟h\J(ԻU˶.#~įrEm6du[+gcYTuR,A- 7d1( jFV~ďՉ_bg^=χsdOTM"> y6ʫj *v&Zp΀]~ab(QC'"U**v~8bjN//]&£>xX+6%s>B9٤MM3t򪤅5H13{ݷV8_x`Sce˯fA z1t ?tW˲ S'DQyvrr}w ![w]Aرp]iڷc: %]!cTvq }=rZ15x qn[kƏ? E$I4Mwcݺv|}0 呣'<ꎇU@ֆ!cۻQ)KD2"߷QMTqc]Hӎr{yc/n^1Ö[DChrt/ʉ1i CYa=SdطoCv8mڸkہy(mKT=Zic:\YaH< as  -`||goJ"cZ6qwna瑦) Ц|t:ʘȳo} oy :r͗&OZZDDDDOeF-NDDDT'*t0+rnuHPeb&Ks܈RW%Z |_,D FDDT7J]9|ɬZ)6"")6Rwe\ -_.ɎĽLtGeK̕FA.&DDDusE` BIENDB`gtkada-24.0.0/docs/gtkada_rm/gtkada.css000066400000000000000000000052071446021174000176610ustar00rootroot00000000000000body { background: white; } div.page { margin:0px 0px 0px 10px; } div#leftSide div#leftSideInside, div#rightSideInside, div.topBarInside { background:none; } div#leftSide, div#rightSide { width:205px; padding-bottom:10px; } #documentation { padding:0; margin: 0 215px 10px 5px; } div#rightSide, div.topBar, div#leftSide { background:#F3F3F3; border:1px solid grey; margin:3px; } div.topBar { margin-left:215px; right:5px; width:auto; } div#Index li { border:none; margin-bottom:2px; } div.entity { color:#666666; } a:link, a:active, a:visited { color: #0000BB; color: #0000BB; } a:hover { color: red; } a.hide:link, a.hide:active, a.hide:hover, a.hide:visited { color:grey; font-size:12px; } h4 a.hide { margin: 0 3px 0 2px; } div.classroot a.hide:link, div.classroot a.hide:active, div.classroot a.hide:hover, div.classroot a.hide:visited { color:grey; font-size:10px; left:3px; margin-top:2px; margin-right:0; position:absolute; } div.subprograms h1 { margin-top:20px; border-bottom: 2px solid black; margin-left:2px; } div.subprograms .class { border: none; margin: 10px 0px 20px 15px; } div.subprograms .name { color: #007F62; } div.subprograms .name_emphasis { color: #007F62; font-weight:normal; } div.subprograms div.details span.keyword { font-weight:normal; } div.subprograms h3, div.subprograms h4, div.subprograms div a { font-weight:normal; font-family: monospace; } div.subprograms div { margin-left:15px; } div.subprograms div.details { background:#EAEAEA; font-size:10px; } div.subprograms div.comment *, div.subprograms div.comment { border:0px; font-size:10px; font-family: monospace; font-style:normal; } div.classroot { margin-bottom: 0px; color: white; white-space:nowrap; background:none; } div.classtree { background: none; } div.classtreechildren { background: none; top: 0px; margin: 0px 0px 0px 8px; padding: 0px; } div.classtreechildreninside { background: none; padding: 0px 0px 0px 8px; } div.classroot h3, div.classtree h3 { height: 15px; font-size: 12px; font-size:12px; margin: 0px 0px 0px 0px; } .droplink { text-decoration:none; padding: 0px; background: none; } .default .droplink ul, .default .droplink:hover ul { visibility:visible; overflow:none; height:auto; display:inline; position:static; background:none; border:none; width:auto; float:right; } .default .droplink ul li { display:inline; float:none; } .default .droplink ul li a { font-variant:normal; font-family:arial,verdana; font-size:10px; color:#4444BB; } .default .droplink ul li a:hover { color:red; } gtkada-24.0.0/docs/gtkada_rm/gtkada_documentation.gpr000066400000000000000000000007351446021174000226130ustar00rootroot00000000000000project GtkAda_Documentation is for Source_Dirs use ("../../src/generated", "../../src/"); for Object_Dir use "doc_obj"; package Compiler is for Default_Switches ("Ada") use ("-gnatc", "-gnatQ"); end Compiler; package Builder is for Default_Switches ("Ada") use ("-m"); end Builder; package Documentation is for Documentation_Dir use "gtkada_rm"; for HTML_Custom_Dir use "html"; end Documentation; end GtkAda_Documentation; gtkada-24.0.0/docs/gtkada_rm/gtkada_rm.css000066400000000000000000000177111446021174000203620ustar00rootroot00000000000000img { border: 0px; padding: 1px; } h2 { background: #098aba; padding: 0px 0px 0px 5px; margin: 0px; font-variant: small-caps; font-size: 16px; } body { font-size: 14px; } /* Generate page layout */ div#objectName { font-variant: small-caps; font-weight: bold; font-size: 20px; background: #0ca7e1; padding: 3px 0px 3px 0px; width: 100%; margin: 0px 0px 0px 0px; top: 0px; left: 0px; vertical-align: middle; border: 1px solid black} div#leftSide { float: left; /* min-width: 200px; /* width of screenshots */ margin: 0px 0px 0px 0px; } div#documentation { float: left; margin: 10px 0px 0px 10px; padding: 0px 10px 0px 0px; width: 730px; /* So that it works in 1024x768 */ } div.notebookPage { padding: 0px 4px 0px 0px; } div#rightSide { float: left; margin: 0px 0px 0px 10px; } div.Toc { border: 1px solid black; margin: 10px 10px 0px 0px; float: left; min-height: 370px; width: 220px; } div.GeneralIndex { border: 1px solid black; margin: 10px 10px 0px 100px; } div#IndexIndex { width: 80px; float: left; margin: 10px 0px 0px 0px; position: fixed; border: 1px solid black; } div.gallery { float: left; padding: 5px 10px 5px 0px; } div.gallery-spacer { clear: both; } /* Automatic scrollbars in some of the lists Uncomment this to have local scrollbars in the Alphabetical index and the main documentation page. This is not perfect without javascript support: the maximum height should depend on the screen height and the number of toolbars displayed in the browser. Otherwise, we also have a general scrollbar for the page, which interacts badly with the rest. Also, some browsers, in particular Konqueror 3.5.3 do not work well with anchors in such a case, and the index can't be clicked on to jump to a specific subprogram as a result. */ /* div.notebookPage, div#Index ul { max-height: 800px; // SCREEN SIZE overflow: auto; } */ /* Styles within each region */ div#objectName span { margin: 10px 50px 0px 0px; } div#objectName span img { margin: 0px; } div#leftSide div, div#rightSide div { border: 1px solid black; padding: 0px 0px 0px 0px; margin-top: 10px; } a:link, a:active, a:visited { text-decoration: none; color: blue; } div#leftSide a:hover, div#rightSide a:hover { color: red; } div#leftSide ul, div.GeneralIndex ul, div#widgetTree ul, div.Toc ul, div#rightSide ul { margin: 2px 0px 0px 10px; padding: 0px 0px 0px 0px; } div#navigation ul ul { margin: 0px 0px 0px 10px; } div#navigation li li { list-style-type: square; list-style-position: inside; font-style: oblique; font-size: 0.9em; } div#classHierarchy ul.top { padding-right: 5px; } div#classHierarchy img { border-width: 0px; padding: 0px; margin: 0px 0px 0px 0px; outline-width: 0px } div#classHierarchy ul { margin: 0px 0px 5px 0px; } div#classHierarchy ul ul { margin: 0px; } div#widgetTree ul ul { margin: 0px; } div#classHierarchy li, div#widgetTree li { margin: 0px; padding: 0px; font-size: 14px; vertical-align: middle; } div#widgetTreeButtons input { font-size: 12px; padding: 0px; } div#widgetTree li { margin: 0px; padding: 0px; height: 18px; font-size: 14px; vertical-align: middle; } div#leftSide li, div.GeneralIndex li, div#widgetTree li, div.Toc li, div#rightSide li { list-style-type: none; list-style-position: inside } div#screenshot { text-align: center; background: #dcdad5; } div.description { background: #eee4cb; white-space: normal; margin-bottom: 20px; } div#subprograms ul, div#types ul { padding: 0px; margin: 0px; } div#subprograms li, div#types li { list-style-type: none; /* padding: 0px 5px 0px 5px; */ margin: 0px 0px 20px 0px; border: 1px solid black;} div#subprograms span.name, div#types span.name, div.properties div.name, div#signals div.name { color: red; } div#signals div.name { background: #ddd3ba; width: 100%;} div#subprograms div.profile, div#types div.profile, div.properties div.profile, div#signals div.profile { white-space: pre; font-family: "Courier New", Courier; padding: 0px 5px 0px 5px; background: #ddddee; } div#example, div#testgtk { font-family: "Courier New", Courier; white-space: pre; } div#subprograms div.comment, div.properties div.comment, div#types div.comment, div#signals div.comment { padding: 0px 5px 0px 5px; } div#subprograms h3 { font-size: 16px; background: #ddd3ba; margin: 0px; } div#signals ul, div.properties ul { margin: 0px; } div#signals li, div.properties li { list-style-type: none; border: 1px solid black; margin: 0px 0px 10px 0px; } /* Notebooks */ ul#notebook { border-bottom: 1px solid black; padding: 0px; margin: 3px 0px 5px 0px; } ul#notebook li { display: inline; margin: 0px; padding: 0px 5px 0px 0px; border-bottom: 1px solid black; list-style-type: none; } ul#notebook a:link, ul#notebook a:active, ul#notebook a:visited { text-decoration: none; background: #ddd; padding: 0px 4px 0px 4px; border: 1px solid black; color: #333; } ul#notebook li.current a:link, ul#notebook li.current a:active, ul#notebook li.current a:visited { background: #bbb; } ul#notebook li.current { border-bottom: 0px solid red; } gtkada-24.0.0/docs/gtkada_rm/gtkada_rm.js000066400000000000000000000070761446021174000202110ustar00rootroot00000000000000var current_page=''; function switchPage (name) { if (current_page == name) { return true; } current_page = name; var children = document.getElementById ('documentation').getElementsByTagName ('div'); for (var i=0; i < children.length; i++) { if (children[i].id == 'notebook_' + name) { children[i].style.display = 'block'; } else if (children[i].className == 'notebookPage') { children[i].style.display = 'none'; } } children = document.getElementById ('notebook').getElementsByTagName ('li'); for (i=0; i < children.length; i++) { if (children[i].id == 'tab_' + name) { children[i].className = 'current'; } else { children[i].className = ''; } } return true; } /************************************************ ** Toggle the closing or opening of a tree node ************************************************/ function setTreeState (li, img, close) { if (close) { img.src = "treeclose.png"; img.alt = '[+]'; } else { img.src = "treeopen.png"; img.alt = '[-]'; } var ul = li.nextSibling; while (ul && ul.nodeName != 'UL' && ul.nodeName != 'LI') { ul = ul.nextSibling; } if (ul && ul.nodeName == 'UL') { if (close) { ul.style.display = 'none'; } else { ul.style.display = 'block'; } } } function treetoggle (widget) { var img = widget.getElementsByTagName ('img'); var li = widget.parentNode; var is_expanded = (img[0].src.indexOf ('treeopen') > -1); setTreeState (li, img[0], is_expanded); } function treeChangeFoldAll(fold) { var children = document.getElementById ('widgetTree').getElementsByTagName ('LI'); var img, m; for (var c=0; c < children.length; c++) { a = children[c].getElementsByTagName ('a'); for (m=0; m < a.length; m++) { if (a[m].className == 'tree') { setTreeState (children[c], a[m].getElementsByTagName ('img')[0], fold); } } } } /************************************************ ** Return the window's height ********************************************** */ function getWindowHeight() { var wh=0; if ( typeof window.innerHeight != 'undefined') wh = window.innerHeight; else { d = document; if ( d.documentElement && typeof d.documentElement.clientHeight != 'undefined' && d.documentElement.clientHeight != 0) wh = d.documentElement.clientHeight; else if (d.body && typeof d.body.clientHeight != 'undefined' ) wh = d.body.clientHeight; else alert ("Can't identify window height") } return wh; } /* Adjust the height of various elements to adapt to the screen size */ function adjust_height() { /* Do nothing at present (see comment about automatic scrollbars in gtkada_rm.css */ return; var screenHeight = getWindowHeight(); var objectName = document.getElementById ('objectName'); screenHeight = screenHeight - objectName.clientHeight - 10; var rightSide = document.getElementById ('rightSide'); var h = rightSide.getElementsByTagName ('h2'); screenHeight = screenHeight - h[0].clientHeight - 20; /* The following code works with Opera, but not firefox */ var ul = rightSide.getElementsByTagName ('ul'); ul[0].style.maxHeight = screenHeight; ul[0].style.height = screenHeight; var divs = document.getElementsByTagName ('div'); for (var n=0; n < divs.length; n++) { if (divs[n].className == 'notebookPage') { divs[n].style.maxHeight = screenHeight; divs[n].style.height = screenHeight; } } } gtkada-24.0.0/docs/gtkada_rm/gtkada_rm.texi000066400000000000000000000026701446021174000205410ustar00rootroot00000000000000\input texinfo @c -*-texinfo-*- @settitle GtkAda Reference Manual @setfilename gtkada_rm.info @syncodeindex fn cp @c oooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo @c o @c GtkAda DOCUMENTATION o @c o @c Copyright (C) 2000-2016, AdaCore o @c o @c oooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo @dircategory User Interface Toolkit @direntry * GtkAda_Rm: (gtkada_rm). Ada graphical tookit based on GTK+ (Reference Manual) @end direntry @c -------------------------------------------- @finalout @c -------------------------------------------- @titlepage @title GtkAda Reference Manual @subtitle Version 18.0 @subtitle Document revision level $Revision$ @subtitle Date: $Date$ @author E. Briot, J. Brobecker, A. Charlet @page @vskip 0pt plus 1filll Copyright @copyright{} 1998-2000, Emmanuel Briot, Joel Brobecker, Arnaud Charlet Copyright @copyright{} 2000-2016, AdaCore @end titlepage @ifnottex @node Top @top GtkAda Reference Manual @include generated_menu.texi @end ifnottex @include generated.texi @node Index @unnumbered Index @printindex cp @contents @bye gtkada-24.0.0/docs/gtkada_rm/home.png000066400000000000000000000006701446021174000173510ustar00rootroot00000000000000PNG  IHDRubKGD pHYs  tIMERZEIDAT8=n@M,D"KJ \!˾KDAC8 Y!@$\;ɤ1Q UTyHh=((9CxRSV/s88dmCk-ض-&JbYj:Z GtkAda @PACKAGE_VERSION@ Reference Manual

    Date:

    gtkada-24.0.0/docs/gtkada_rm/icon-view.png000066400000000000000000000226631446021174000203270ustar00rootroot00000000000000PNG  IHDR!sBIT|d IDATx{eoUuWߦg:3\H@TEt5]D{VP2P ǮZ.-j \cZdkuW)$@]A*_T @wA8։ vFV^}J\paj'>ȓarR<}~ &@mrYvqS( D_!˒HFx\/* s^۱?>(^Φ2f 1k ΚCbx=cG|.VҐmD>oau$L#ߍJ39~u睤m:Y n'[aeaZj:05DzmcY:NRW߀ Ĺ~Igg'T "3LgHA8@ulBoo/eyf pM`6TD?}8e0-mB0>l9 d8dOOIJ-|<8x,bx0Eone۴'¤I0rI2Aҙ4\]70-]v1{lEC9ja6BV"_*(KL,,l"uĢXE.G74R4RN*ƶ2m~?m﨡i:;Ig$q/&PaY${)$]| eRI)hS5,&9 4ʘAI0MӲ) ~_-$ 2(jE $Y♍ώEdYml`y+LCXc_wmhhh5ws}mS( g1,m[n(L$c&`Z&\C w?IBRdE&`(D2=g׍al&K6aɔolų/m"/ IuuuL2.|ށ=$ItIL66l0 IJml-LĴL,4-4C0 t mY6f|2fV٧ B&ʤ(H %ٺ}+?E p4BHMM_8[t/qWrq1m4[Zxٺ ztq\{L2E0-IYغmen4Lò, YQ܌5r.M2dIQ|>| JIGVO@ fX cvG0JHt=?SV\E}^;w.X  0c z{ŘvGPUu^~x|($Ȳ(~?H@@G}CMMc1rm3EYBQ|+)Ȫ?g\M^xOh Nc ]=k b&,#ITx}߇c/˒ĵ_ ϮChi($I< SÔ4 YV4X.=aY;HҠ(~>Js77`C$ap0@Ea_g~Ò؆-Gٹ7ATB 5+@_Z2y2e2-yb;REVeq򜓸N:}qa`pID"5hFXR!O!c)sedڙRO@8=!zzz;$o~;ȲOQ} ~E! aRB@>A  aΉ`K~XEQ(iTB_~4 Tjk9n|33&34-˓6Pi' Tf9!l^`Ę̙3ꚿchoo礓NOfxxVq4;$Ljhh`xh^Dwo|P(D&=#giB3?r?]/#ecYdEQ4B/MӐG: >4) E6mkG5lI)*MaW/>a/Gz|;խT˲L$RIn}SO9H$B&FeLL dڷ^FP,( 4:u/ @("1N<jkkp8L8FUU& 2\Tp*M8eBh jFk5y*t,{2q~0 24+SGd,S*HgfDUU2tޮ$(BM4(Q'E:`ڴi466z&LOMMgc/x~p#jP*/ö%BP?2Ƭ*mS.1 }@ P7t@uL&qd Ąq |-=mB x:I?VPHc>'7!Y)ٹB._U4 EQ*b$q^޴_ۂ52s8ևxT\8g۶/`sxٵsl߲p$gοIT*f#c\UUQ44 I !!! "l۲4&&7Ϧxa|\l{pWD2]7ӗ`}$Rq#]% Z@>&/P(+ lݹ77wPtwJ>)XQspAG~dN>2#B!b[H >m۶ضD:p8L:2m o&]q,ˌ7yկ~s9gmp[|8jjҙ bѽ]Lª)NM@* 9yeF*f(A[lk}{0L!>ԥ|S_$ˍz/}HXss3]tK,!Hٷc3j H0"ۅV*bY"iv % ϥ^f͚Ekk+`4ISd)Jb4JsK;R(e( awe1ЛI``= c%%ˬI!˹S]}>rٓHD 5(2EߥDeg>nfΜ.:LL 0է *[_~uoyN;9AOry溮A!%dD1y'LTUu!P=ePM/c۠i%jj+ӀH2 Jf̘öʴlfedRCE @$ׯ*NSȝ}6%z"PM~C+<@T[Fhe`,J%&@lk%LӠ*PMhmmenɶmRal{\zƦ(CGw?;v.\LF\.W.wr9 eTJU)J3gT*:m_˲$jSZPM-`#L P`0xP_mmon߅"NQ5J"PӋP(C3ߊS/ dYrܨ( n!l|T% 5DX*( EJR M(~:RVQ*0MLn@2 ˍZ/~&M66p4H$p-S*v GF @4p$Ibhh RDXX,!:Rm8+5L.CI|~`ڔI̟w>2ﾋT*,˴qE'\i H\_L:`08Gzdl:­( tp8anU-Ι9ID:չ$˲Sw:q~_b_}}=b^*h74*;O29gy=Xq Ajjj8sٷs+zYlwP+.\H$C<"xpi;C|Y\.ڜ3iQ p x>wk5~k>]v N|`$HD´L`|clc>'L Ϣ(>zص X,)!C\kѫrEQ\,:rp gYNuX,kY9aI ) OA,˦.ƸFjT2AGQ| yF瞝uuٱ7fpBЂ >}箽x+sVN3t(I&f,-tnjjjFUݝ IR%g(t欋9OcD5ZZ`|X.NSK|R!Ojx{ٴum KŕU8v7n_Whkk#:x 80whNUUP\ɔ)Su}0,W&88]Q~?`@ @(r A(dYfw?4M1buoxˆ` ,+=z@e >񏋥O?ΙO:>d2~^T-" UP-U{UU B!jjjFB!wy@ >^t̹Xh[naؽh$LSc,ma4 gE<N5]݆ضMkk+6mR4jʮӮw: }:'x"'NoÓF ^ `08WOq/j3Pw˩e8}Dpk"9EQԌ3\y\&snn;C{Ӂ/<ܳS?TzT'I;Jx<9i/:U!ӀE@ΥN?]w>:{_. cs8xBWp kuOsS t8k@>L P+,꜂a"D &@۶ms+NsUWH}}=W]u|~ FY#Opꩧ7ߌ,lٲ۶ٲe P?\|b1(Fwm۶%\r}\r O?yÆ زe '7wWH$ؽ{7r8uK.N֬Yyꩧx'G|rټy36l`ժUcG8O MMMDT\j|^ȋ/ms-ňF\ЎX;'|B+ªUXf P KϚ5kя~D${C8byj@]%63qQqhԽ-߫JT*g .4Mw A;sXf viwy|ߦP(3pM7O(qg?WLD"ʕ+Yv-7||Ihkkodpp۶G>OP(뮻8s8OҥKݦYss3K.妛nP(000w_>Gpdt|硇{凉?M6n:Ν&1gXx1ޢ*/ge˖N0 Z[[3g~; s/:Բ'Ah\pnuX-[Fkk+@-U}5A2a"D &@H"0ssg0}tΝM7ޟH$꫙9s&soT*a:^IDAT۶{o~yŋ9صk!_k455-3gOf``}l+V0gf͚Ŋ+( ض͟g,Xmض/~ رcmcNJX`<]pxo~Ν;yg>o~W_}z뭣c޽<#]Erʃ^G$E.so7M￟˗roL&yy饗r-,XNzzzX~=SNe[O?`0>!pp[oeƌHD4eضM<gn u]Qϳb EA$>O믿k^zݻ۶yꩧf\|ţ?ΪU^IOdݺuE6o̊+X~= ,8o۶9y<)iֺ߫ioMMM{w}q{|%r $I*5],ZI'IJe~@X^;;y+#HKK $ܹs f̘@oo/(_/_2\s k׮G9&L&Mt,\{ &pBbӦM׿5r '?87/޽۶rlܸIhjj3oP(ǹ;>^wѢEL0ٳg}HDss3g}67|3CCCضO?SO=bϢEJ(y睜ynD828vm,\/~̘13<{̽__0Myd͛Ǎ7_O$dY.-;_%K0sL."6o93|~…dY?*@AV[#[ &@G60yjڪkw^ΦR@aP[- j*_F!#yV&`HT '‘əcUm?o?~T=~ۮIENDB`gtkada-24.0.0/docs/gtkada_rm/messagedialog.png000066400000000000000000000230471446021174000212300ustar00rootroot00000000000000PNG  IHDR>sBIT|d IDATxwxlɒBH[! iJSb\Q ~UVT*^w-BhJG:R.I6es^3Μs   TŲΩׂ \9dr^R ȃn k?|!G`5@-yttGC%ە{U l?oSҋ.ŏmRK&j0CƽN735QoAUd wo#6Zh+YMs,/̒3ȧ/_Q.I. #'[] Dt|V!n8qdq mn ]/=.>s+a"Ī \2r z+4NfnK@Xŵ$!@׀#Y|tMr|nvcOUXW^{cd* \mv p1J뇇XKt;  С]K_qdʑ 0;O;]V $1‚P+Ï fɶNZebJ\~ź^ӽU YtWs u>wwnP:Vγ厙 vqeh]A'{KWOeԛ8kHpNPɣΥ&w[H۞Ty%#7(WZfySob⬯]]^2{1A\ 2U1qۖy^;TXFFnYvefpL+x⬯ܯgIR `dI1Zָb-Z(hf=< \ \%U8f2#pOcNyڞ \EV)$ID) n̕tavpe'ńȨȮv[vi[R'>e#eo}-\'JlD]5"$ |=la^9+Wx.{OLl NJJJr?0?Q"(@'+<"#丫$II$7$~=  ePhxwK=1L;ﺛ9sr9ڶmCFFaƒ7~lMӈ'''+WzcܹHS\\LJJ v;[~ŗSPuճ':g~))HH@=J駟ظq#$Uq#K_|%ɓL)ױ^-_^ˡ؜ RHM@FF?踽Ђ xu{6mm۶WTߪ٫'7kfiZJJJB4f7/|& 0.Mi8ܢVRvZ* x^Ah5C~o0vXt]gx;L;wq} _.-߱>}oЭ{u};{UVI'Ӯ]Q IJZvܞ={6tȈ{ַ*'*7ɮ]Ke06t;wrfOKϵa6JF0B5ΤaX j,aPddI3Y躎j:!fW{]Gs=Ovv6gtReȊйs2ۨW/?-?oaǎ|ŗ|W~-:ut4 c6f(ַ*6nM6>Tz1XU$ vt$`t.doBf!?< lC F46r|w, wywyLkJ*=,kVǚ߱bL<w^Ə,a:I5]ٹkWwvN&Md e꒐V*voU7TU]' 3':%ʷCΝ;y']Xm$SdUuSĆ'9u>މ@ɀծV. Y8YEHnͮS}m3xx{~Y>}ӧ?7xڵCQd~EEEh_DfLz!f3~,EV;fLto%8m6hŤТq} E 49O|d"<< q$I,c&ODӦM8|0Ǐ !!'M#$${0GVVm۶e֬ճW,X@NtMeyrx"##LfJȉ'ٳgܫs/AQ f<߿?._FϞ=HOOŋtލ˖ѿ*|L0pg.?H 4j:&̜"Vl:;a6* FEA%t]ئL;&LN+]i /***"''( $%%9wܟy1,zr)yOtFn;kqSr l(DlT0vŠ ,x: LN`=Gi$\"##.I]ޭaa=,<]WgY8QHdtݿ,a4 FEFuʢwb rrQm'yo3uUPP}a׮]deefujC躊\*iT iEXv}NB-0K>MHL4M+FTtt]ǮXv2s k]"qd[nB0\EzN!`T'5]î*6" EvK4mO;U0 "K;%Ơ(H8ikXvv6,΃?E \-|.%6¢cd d1H#[P_y{ח ::$IOT7[>cٚ@l`FyE, ;t}4O|25;zar;ņ8) jW.QhNsp?UZalC1?>c/뀤dY|GN[KX+'9~M֒CH t]'?+Io smbG܀(5 ID40k{VV|v"45_t6k]0/s'a Nfa0*AW>fՊ:c_ya+Ln"Am1z$;'dr}ד %>fz=Qvt֯,~o M,fcgU:&$ѯw2A 3 X4 ٌ,˕~0^ύEAQY6 f:cЍ\ȭO>зԫg! dt`0 uϵ̊`X0vlV+dh|,RdɄhtX$\l PuA2"̂'DO0׀m۶I~~~9D+p";Sd=HNطw_>E+܋ӧOsI׼ͩDGGykVz''c4$)TN yskޖ[xp~gCnn.ɽto2X#" ,3wu4!C9vxYc:uБ Zңg/G16T t]gt֝Fo߁kynn.?&MѦm;f|s~r뛕ŝwEtt  C'ۯch٪5|R_f }KtL,OONJm#//&MٴicT={V۰l2W^L {hU"\ EQѣ.ZپcF$ h7kVfܱ}{oR_{mo?iܹs<#wӶiѲko%K/m+ߚy7]e^yUfϙ͌I۶e|Lf]˧N}jշ=>C-z>:}5k 3y)̙l K~={>cF2o9sf9uƍc޽nb7DDD\ΗWt+;F5_ɧ?q۷Ӽysճ'7-[H BCxgA.]xyNFF2%66ֵj2{V|۝FGGsO0u[;w7|111tj^^_~>8q"&Lx;v,3yƵQ\cbb1c7/ÙSחO?3lrFaLyۛc0Yr%'M&77ntM^HՋ#Gpy6ngك%-͛I}e;s=bLmҵkWa>4o=<|w>F4m?sa8|w {q1v;o|M9rTWzZye4n}$iڬ9dffb\eTv;uӧOʘѣ+vL+mm-F#ݺu㧟~_GQQK~Ldd$[\qf`00x ^zE͛˗_}iiݚ@N:M-L$Ѻu+, ?mhݻ\vIV<wÇOӵkWZlI 6z-,SG|yۛcC'c1t&N:YkhܫzP4i8>գ{w[nll,$U FgΝVȪUh$G}G>JaQ!zns.9£>l'1(pE~mwu'AAAg%*!YY̛7)xU nq>GûZhdE{ٻw,jw1#nD$n ˖w9F3fq*~RR͚5#..c]Eǻc²IY@ =Mϱ 4VZUﳺyL0pdxfCBsaȐ!]S'ygb-X2%S\2 >bz:}!&Au"̂k. 2{zV߈##<_^ ĥ)A"̂'DO0 a?!,~BY fA"̂'DO0 a?!,~BY fA"̂'DO0 a?!,~BY %uhZꖥw$IBeˆoBvӧOoQչȲLHӬYs 60Qryq݀4kuqr6G (Bj0Qk L-k:WHPR bXu'(]̤If]ZllS23l]LӴZ^F# Djqi*vM]GAQ!=k^W+fVU7mb渁Qu 9v^zos0 çi,K@6 Ihڴ)$%%1k,y2륦2b&Mij>[{[DjO-L|F:G?m IQl3#I]jNj*VZUxE1cƌRSRR6mӦMmMaGw݌֛z{Odc2He0l0*fi0 ġ EBrmѣJǎ=̎;￣뺫=z4Ǐgڴi5߾@j+~IDATÌ6PH$ˀ;Nx]QUǛF L͎%Ϸ3Æ ?f޽z[W2qv ^yA/[mTaPetJv c1J%빮 C\7 j- 66EQرc;+swA˖-٬Dž 0azV^M6e?}h8]k/X؀;MWr*|;EV ۤcW-i 2-|v7pm7001{S~~>o6~|Ǿɲ{GRRѣ:hDƆ1܅Hvd`0ƒG"aA3,Wrm\z+ 0;＋Bƍ9t?? LyحQu |cƌaa|wV:2WbXP=YH a!b"B==&6.-Z` /2zhԨz+O<8Kk?u]d2tRFɈ7cj__!\LWITKldEJ yV^rӤI-ZX:]v%;;VXQv"u\My,j;o#Vu 9ɲ\BCx32tV"u\Mt5Mf*v1}[8ȂsIOOw$YPEQ0 (hD/s]Vml6|ƓiȲ\^FшxTvL&*aj3w/J7onIž,u"u]5%Id29vTUEUUtEvuP;'GDJ1{8M&!R"u,:$Ts D(I ŋDFFvuZ @0QȖMtу^Juϱ_K5IRƍر#v$;; /Q;YiР ;9RUaˌF#-Z&:&&N>U$MF,z]@Sz{3z]j!,~BY fA"̂'DO0 a?!,~BY fA"̂'DO0 a?!,~BY U=Aa*SuI>PU*bZ2J&;[@ .y q{T\ÕA| 0p݆@.춼j.B):t!ZigˬJ =vXgpn\L [wΥ,s)Ÿ+ #q{MR4 /+B<fAs): "̂WMg+ {7dˈ7_Ilr h.MI8|t|2AjM"ۤ^ufp9UZzISȮIENDB`gtkada-24.0.0/docs/gtkada_rm/parent.png000066400000000000000000000004161446021174000177100ustar00rootroot00000000000000PNG  IHDRFΨbKGD pHYs  tIME;IDAT8c`T3?fE2,C FFPFc߼yb… 666nFwpp"dv5r7ϟÇ C =fIENDB`gtkada-24.0.0/docs/gtkada_rm/texinfo.tex000066400000000000000000005026511446021174000201170ustar00rootroot00000000000000%% TeX macros to handle Texinfo files. %% $Id$ % Copyright (C) 1985, 86, 88, 90, 91, 92, 93, % 94, 95, 96, 97 Free Software Foundation, Inc. %This texinfo.tex file is free software; you can redistribute it and/or %modify it under the terms of the GNU General Public License as %published by the Free Software Foundation; either version 2, or (at %your option) any later version. %This texinfo.tex file is distributed in the hope that it will be %useful, but WITHOUT ANY WARRANTY; without even the implied warranty %of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU %General Public License for more details. %You should have received a copy of the GNU General Public License %along with this texinfo.tex file; see the file COPYING. If not, write %to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, %Boston, MA 02111-1307, USA. %In other words, you are welcome to use, share and improve this program. %You are forbidden to forbid anyone else to use, share and improve %what you give them. Help stamp out software-hoarding! % Send bug reports to bug-texinfo@prep.ai.mit.edu. % Please include a *precise* test case in each bug report. % Make it possible to create a .fmt file just by loading this file: % if the underlying format is not loaded, start by loading it now. % Added by gildea November 1993. \expandafter\ifx\csname fmtname\endcsname\relax\input plain\fi % This automatically updates the version number based on RCS. \def\deftexinfoversion$#1: #2 ${\def\texinfoversion{#2}} \deftexinfoversion$Revision$ \message{Loading texinfo package [Version \texinfoversion]:} % If in a .fmt file, print the version number % and turn on active characters that we couldn't do earlier because % they might have appeared in the input file name. \everyjob{\message{[Texinfo version \texinfoversion]}\message{} \catcode`+=\active \catcode`\_=\active} % Save some parts of plain tex whose names we will redefine. \let\ptexb=\b \let\ptexbullet=\bullet \let\ptexc=\c \let\ptexcomma=\, \let\ptexdot=\. \let\ptexdots=\dots \let\ptexend=\end \let\ptexequiv = \equiv \let\ptexi=\i \let\ptexlbrace=\{ \let\ptexrbrace=\} \let\ptexstar=\* \let\ptext=\t % Be sure we're in horizontal mode when doing a tie, since we make space % equivalent to this in @example-like environments. Otherwise, a space % at the beginning of a line will start with \penalty -- and % since \penalty is valid in vertical mode, we'd end up putting the % penalty on the vertical list instead of in the new paragraph. {\catcode`@ = 11 % Avoid using \@M directly, because that causes trouble % if the definition is written into an index file. \global\let\tiepenalty = \@M \gdef\tie{\leavevmode\penalty\tiepenalty\ } } \message{Basics,} \chardef\other=12 % If this character appears in an error message or help string, it % starts a new line in the output. \newlinechar = `^^J % Set up fixed words for English. \ifx\putwordChapter\undefined{\gdef\putwordChapter{Chapter}}\fi% \def\putwordInfo{Info}% \ifx\putwordSee\undefined{\gdef\putwordSee{See}}\fi% \ifx\putwordsee\undefined{\gdef\putwordsee{see}}\fi% \ifx\putwordfile\undefined{\gdef\putwordfile{file}}\fi% \ifx\putwordpage\undefined{\gdef\putwordpage{page}}\fi% \ifx\putwordsection\undefined{\gdef\putwordsection{section}}\fi% \ifx\putwordSection\undefined{\gdef\putwordSection{Section}}\fi% \ifx\putwordTableofContents\undefined{\gdef\putwordTableofContents{Table of Contents}}\fi% \ifx\putwordShortContents\undefined{\gdef\putwordShortContents{Short Contents}}\fi% \ifx\putwordAppendix\undefined{\gdef\putwordAppendix{Appendix}}\fi% % Ignore a token. % \def\gobble#1{} \hyphenation{ap-pen-dix} \hyphenation{mini-buf-fer mini-buf-fers} \hyphenation{eshell} \hyphenation{white-space} % Margin to add to right of even pages, to left of odd pages. \newdimen \bindingoffset \newdimen \normaloffset \newdimen\pagewidth \newdimen\pageheight % Sometimes it is convenient to have everything in the transcript file % and nothing on the terminal. We don't just call \tracingall here, % since that produces some useless output on the terminal. % \def\gloggingall{\begingroup \globaldefs = 1 \loggingall \endgroup}% \def\loggingall{\tracingcommands2 \tracingstats2 \tracingpages1 \tracingoutput1 \tracinglostchars1 \tracingmacros2 \tracingparagraphs1 \tracingrestores1 \showboxbreadth\maxdimen\showboxdepth\maxdimen }% % For @cropmarks command. % Do @cropmarks to get crop marks. % \newif\ifcropmarks \let\cropmarks = \cropmarkstrue % % Dimensions to add cropmarks at corners. % Added by P. A. MacKay, 12 Nov. 1986 % \newdimen\cornerlong \newdimen\cornerthick \newdimen\topandbottommargin \newdimen\outerhsize \newdimen\outervsize \cornerlong=1pc\cornerthick=.3pt % These set size of cropmarks \outerhsize=7in %\outervsize=9.5in % Alternative @smallbook page size is 9.25in \outervsize=9.25in \topandbottommargin=.75in % Main output routine. \chardef\PAGE = 255 \output = {\onepageout{\pagecontents\PAGE}} \newbox\headlinebox \newbox\footlinebox % \onepageout takes a vbox as an argument. Note that \pagecontents % does insertions, but you have to call it yourself. \def\onepageout#1{% \ifcropmarks \hoffset=0pt \else \hoffset=\normaloffset \fi % \ifodd\pageno \advance\hoffset by \bindingoffset \else \advance\hoffset by -\bindingoffset\fi % % Do this outside of the \shipout so @code etc. will be expanded in % the headline as they should be, not taken literally (outputting ''code). \setbox\headlinebox = \vbox{\let\hsize=\pagewidth \makeheadline}% \setbox\footlinebox = \vbox{\let\hsize=\pagewidth \makefootline}% % {% % Have to do this stuff outside the \shipout because we want it to % take effect in \write's, yet the group defined by the \vbox ends % before the \shipout runs. % \escapechar = `\\ % use backslash in output files. \indexdummies % don't expand commands in the output. \normalturnoffactive % \ in index entries must not stay \, e.g., if % the page break happens to be in the middle of an example. \shipout\vbox{% \ifcropmarks \vbox to \outervsize\bgroup \hsize = \outerhsize \line{\ewtop\hfil\ewtop}% \nointerlineskip \line{% \vbox{\moveleft\cornerthick\nstop}% \hfill \vbox{\moveright\cornerthick\nstop}% }% \vskip\topandbottommargin \line\bgroup \hfil % center the page within the outer (page) hsize. \ifodd\pageno\hskip\bindingoffset\fi \vbox\bgroup \fi % \unvbox\headlinebox \pagebody{#1}% \ifdim\ht\footlinebox > 0pt % Only leave this space if the footline is nonempty. % (We lessened \vsize for it in \oddfootingxxx.) % The \baselineskip=24pt in plain's \makefootline has no effect. \vskip 2\baselineskip \unvbox\footlinebox \fi % \ifcropmarks \egroup % end of \vbox\bgroup \hfil\egroup % end of (centering) \line\bgroup \vskip\topandbottommargin plus1fill minus1fill \boxmaxdepth = \cornerthick \line{% \vbox{\moveleft\cornerthick\nsbot}% \hfill \vbox{\moveright\cornerthick\nsbot}% }% \nointerlineskip \line{\ewbot\hfil\ewbot}% \egroup % \vbox from first cropmarks clause \fi }% end of \shipout\vbox }% end of group with \turnoffactive \advancepageno \ifnum\outputpenalty>-20000 \else\dosupereject\fi } \newinsert\margin \dimen\margin=\maxdimen \def\pagebody#1{\vbox to\pageheight{\boxmaxdepth=\maxdepth #1}} {\catcode`\@ =11 \gdef\pagecontents#1{\ifvoid\topins\else\unvbox\topins\fi % marginal hacks, juha@viisa.uucp (Juha Takala) \ifvoid\margin\else % marginal info is present \rlap{\kern\hsize\vbox to\z@{\kern1pt\box\margin \vss}}\fi \dimen@=\dp#1 \unvbox#1 \ifvoid\footins\else\vskip\skip\footins\footnoterule \unvbox\footins\fi \ifr@ggedbottom \kern-\dimen@ \vfil \fi} } % Here are the rules for the cropmarks. Note that they are % offset so that the space between them is truly \outerhsize or \outervsize % (P. A. MacKay, 12 November, 1986) % \def\ewtop{\vrule height\cornerthick depth0pt width\cornerlong} \def\nstop{\vbox {\hrule height\cornerthick depth\cornerlong width\cornerthick}} \def\ewbot{\vrule height0pt depth\cornerthick width\cornerlong} \def\nsbot{\vbox {\hrule height\cornerlong depth\cornerthick width\cornerthick}} % Parse an argument, then pass it to #1. The argument is the rest of % the input line (except we remove a trailing comment). #1 should be a % macro which expects an ordinary undelimited TeX argument. % \def\parsearg#1{% \let\next = #1% \begingroup \obeylines \futurelet\temp\parseargx } % If the next token is an obeyed space (from an @example environment or % the like), remove it and recurse. Otherwise, we're done. \def\parseargx{% % \obeyedspace is defined far below, after the definition of \sepspaces. \ifx\obeyedspace\temp \expandafter\parseargdiscardspace \else \expandafter\parseargline \fi } % Remove a single space (as the delimiter token to the macro call). {\obeyspaces % \gdef\parseargdiscardspace {\futurelet\temp\parseargx}} {\obeylines % \gdef\parseargline#1^^M{% \endgroup % End of the group started in \parsearg. % % First remove any @c comment, then any @comment. % Result of each macro is put in \toks0. \argremovec #1\c\relax % \expandafter\argremovecomment \the\toks0 \comment\relax % % % Call the caller's macro, saved as \next in \parsearg. \expandafter\next\expandafter{\the\toks0}% }% } % Since all \c{,omment} does is throw away the argument, we can let TeX % do that for us. The \relax here is matched by the \relax in the call % in \parseargline; it could be more or less anything, its purpose is % just to delimit the argument to the \c. \def\argremovec#1\c#2\relax{\toks0 = {#1}} \def\argremovecomment#1\comment#2\relax{\toks0 = {#1}} % \argremovec{,omment} might leave us with trailing spaces, though; e.g., % @end itemize @c foo % will have two active spaces as part of the argument with the % `itemize'. Here we remove all active spaces from #1, and assign the % result to \toks0. % % This loses if there are any *other* active characters besides spaces % in the argument -- _ ^ +, for example -- since they get expanded. % Fortunately, Texinfo does not define any such commands. (If it ever % does, the catcode of the characters in questionwill have to be changed % here.) But this means we cannot call \removeactivespaces as part of % \argremovec{,omment}, since @c uses \parsearg, and thus the argument % that \parsearg gets might well have any character at all in it. % \def\removeactivespaces#1{% \begingroup \ignoreactivespaces \edef\temp{#1}% \global\toks0 = \expandafter{\temp}% \endgroup } % Change the active space to expand to nothing. % \begingroup \obeyspaces \gdef\ignoreactivespaces{\obeyspaces\let =\empty} \endgroup \def\flushcr{\ifx\par\lisppar \def\next##1{}\else \let\next=\relax \fi \next} %% These are used to keep @begin/@end levels from running away %% Call \inENV within environments (after a \begingroup) \newif\ifENV \ENVfalse \def\inENV{\ifENV\relax\else\ENVtrue\fi} \def\ENVcheck{% \ifENV\errmessage{Still within an environment. Type Return to continue.} \endgroup\fi} % This is not perfect, but it should reduce lossage % @begin foo is the same as @foo, for now. \newhelp\EMsimple{Type to continue.} \outer\def\begin{\parsearg\beginxxx} \def\beginxxx #1{% \expandafter\ifx\csname #1\endcsname\relax {\errhelp=\EMsimple \errmessage{Undefined command @begin #1}}\else \csname #1\endcsname\fi} % @end foo executes the definition of \Efoo. % \def\end{\parsearg\endxxx} \def\endxxx #1{% \removeactivespaces{#1}% \edef\endthing{\the\toks0}% % \expandafter\ifx\csname E\endthing\endcsname\relax \expandafter\ifx\csname \endthing\endcsname\relax % There's no \foo, i.e., no ``environment'' foo. \errhelp = \EMsimple \errmessage{Undefined command `@end \endthing'}% \else \unmatchedenderror\endthing \fi \else % Everything's ok; the right environment has been started. \csname E\endthing\endcsname \fi } % There is an environment #1, but it hasn't been started. Give an error. % \def\unmatchedenderror#1{% \errhelp = \EMsimple \errmessage{This `@end #1' doesn't have a matching `@#1'}% } % Define the control sequence \E#1 to give an unmatched @end error. % \def\defineunmatchedend#1{% \expandafter\def\csname E#1\endcsname{\unmatchedenderror{#1}}% } % Single-spacing is done by various environments (specifically, in % \nonfillstart and \quotations). \newskip\singlespaceskip \singlespaceskip = 12.5pt \def\singlespace{% % Why was this kern here? It messes up equalizing space above and below % environments. --karl, 6may93 %{\advance \baselineskip by -\singlespaceskip %\kern \baselineskip}% \setleading \singlespaceskip } %% Simple single-character @ commands % @@ prints an @ % Kludge this until the fonts are right (grr). \def\@{{\tt \char '100}} % This is turned off because it was never documented % and you can use @w{...} around a quote to suppress ligatures. %% Define @` and @' to be the same as ` and ' %% but suppressing ligatures. %\def\`{{`}} %\def\'{{'}} % Used to generate quoted braces. \def\mylbrace {{\tt \char '173}} \def\myrbrace {{\tt \char '175}} \let\{=\mylbrace \let\}=\myrbrace \begingroup % Definitions to produce actual \{ & \} command in an index. \catcode`\{ = 12 \catcode`\} = 12 \catcode`\[ = 1 \catcode`\] = 2 \catcode`\@ = 0 \catcode`\\ = 12 @gdef@lbracecmd[\{]% @gdef@rbracecmd[\}]% @endgroup % Accents: @, @dotaccent @ringaccent @ubaraccent @udotaccent % Others are defined by plain TeX: @` @' @" @^ @~ @= @v @H. \let\, = \c \let\dotaccent = \. \def\ringaccent#1{{\accent23 #1}} \let\tieaccent = \t \let\ubaraccent = \b \let\udotaccent = \d % Other special characters: @questiondown @exclamdown % Plain TeX defines: @AA @AE @O @OE @L (and lowercase versions) @ss. \def\questiondown{?`} \def\exclamdown{!`} % Dotless i and dotless j, used for accents. \def\imacro{i} \def\jmacro{j} \def\dotless#1{% \def\temp{#1}% \ifx\temp\imacro \ptexi \else\ifx\temp\jmacro \j \else \errmessage{@dotless can be used only with i or j}% \fi\fi } % @: forces normal size whitespace following. \def\:{\spacefactor=1000 } % @* forces a line break. \def\*{\hfil\break\hbox{}\ignorespaces} % @. is an end-of-sentence period. \def\.{.\spacefactor=3000 } % @enddots{} is an end-of-sentence ellipsis. \gdef\enddots{$\mathinner{\ldotp\ldotp\ldotp\ldotp}$\spacefactor=3000} % @! is an end-of-sentence bang. \gdef\!{!\spacefactor=3000 } % @? is an end-of-sentence query. \gdef\?{?\spacefactor=3000 } % @w prevents a word break. Without the \leavevmode, @w at the % beginning of a paragraph, when TeX is still in vertical mode, would % produce a whole line of output instead of starting the paragraph. \def\w#1{\leavevmode\hbox{#1}} % @group ... @end group forces ... to be all on one page, by enclosing % it in a TeX vbox. We use \vtop instead of \vbox to construct the box % to keep its height that of a normal line. According to the rules for % \topskip (p.114 of the TeXbook), the glue inserted is % max (\topskip - \ht (first item), 0). If that height is large, % therefore, no glue is inserted, and the space between the headline and % the text is small, which looks bad. % \def\group{\begingroup \ifnum\catcode13=\active \else \errhelp = \groupinvalidhelp \errmessage{@group invalid in context where filling is enabled}% \fi % % The \vtop we start below produces a box with normal height and large % depth; thus, TeX puts \baselineskip glue before it, and (when the % next line of text is done) \lineskip glue after it. (See p.82 of % the TeXbook.) Thus, space below is not quite equal to space % above. But it's pretty close. \def\Egroup{% \egroup % End the \vtop. \endgroup % End the \group. }% % \vtop\bgroup % We have to put a strut on the last line in case the @group is in % the midst of an example, rather than completely enclosing it. % Otherwise, the interline space between the last line of the group % and the first line afterwards is too small. But we can't put the % strut in \Egroup, since there it would be on a line by itself. % Hence this just inserts a strut at the beginning of each line. \everypar = {\strut}% % % Since we have a strut on every line, we don't need any of TeX's % normal interline spacing. \offinterlineskip % % OK, but now we have to do something about blank % lines in the input in @example-like environments, which normally % just turn into \lisppar, which will insert no space now that we've % turned off the interline space. Simplest is to make them be an % empty paragraph. \ifx\par\lisppar \edef\par{\leavevmode \par}% % % Reset ^^M's definition to new definition of \par. \obeylines \fi % % Do @comment since we are called inside an environment such as % @example, where each end-of-line in the input causes an % end-of-line in the output. We don't want the end-of-line after % the `@group' to put extra space in the output. Since @group % should appear on a line by itself (according to the Texinfo % manual), we don't worry about eating any user text. \comment } % % TeX puts in an \escapechar (i.e., `@') at the beginning of the help % message, so this ends up printing `@group can only ...'. % \newhelp\groupinvalidhelp{% group can only be used in environments such as @example,^^J% where each line of input produces a line of output.} % @need space-in-mils % forces a page break if there is not space-in-mils remaining. \newdimen\mil \mil=0.001in \def\need{\parsearg\needx} % Old definition--didn't work. %\def\needx #1{\par % %% This method tries to make TeX break the page naturally %% if the depth of the box does not fit. %{\baselineskip=0pt% %\vtop to #1\mil{\vfil}\kern -#1\mil\penalty 10000 %\prevdepth=-1000pt %}} \def\needx#1{% % Go into vertical mode, so we don't make a big box in the middle of a % paragraph. \par % % Don't add any leading before our big empty box, but allow a page % break, since the best break might be right here. \allowbreak \nointerlineskip \vtop to #1\mil{\vfil}% % % TeX does not even consider page breaks if a penalty added to the % main vertical list is 10000 or more. But in order to see if the % empty box we just added fits on the page, we must make it consider % page breaks. On the other hand, we don't want to actually break the % page after the empty box. So we use a penalty of 9999. % % There is an extremely small chance that TeX will actually break the % page at this \penalty, if there are no other feasible breakpoints in % sight. (If the user is using lots of big @group commands, which % almost-but-not-quite fill up a page, TeX will have a hard time doing % good page breaking, for example.) However, I could not construct an % example where a page broke at this \penalty; if it happens in a real % document, then we can reconsider our strategy. \penalty9999 % % Back up by the size of the box, whether we did a page break or not. \kern -#1\mil % % Do not allow a page break right after this kern. \nobreak } % @br forces paragraph break \let\br = \par % @dots{} output some dots \def\dots{$\ldots$} % @page forces the start of a new page \def\page{\par\vfill\supereject} % @exdent text.... % outputs text on separate line in roman font, starting at standard page margin % This records the amount of indent in the innermost environment. % That's how much \exdent should take out. \newskip\exdentamount % This defn is used inside fill environments such as @defun. \def\exdent{\parsearg\exdentyyy} \def\exdentyyy #1{{\hfil\break\hbox{\kern -\exdentamount{\rm#1}}\hfil\break}} % This defn is used inside nofill environments such as @example. \def\nofillexdent{\parsearg\nofillexdentyyy} \def\nofillexdentyyy #1{{\advance \leftskip by -\exdentamount \leftline{\hskip\leftskip{\rm#1}}}} % @inmargin{TEXT} puts TEXT in the margin next to the current paragraph. \def\inmargin#1{% \strut\vadjust{\nobreak\kern-\strutdepth \vtop to \strutdepth{\baselineskip\strutdepth\vss \llap{\rightskip=\inmarginspacing \vbox{\noindent #1}}\null}}} \newskip\inmarginspacing \inmarginspacing=1cm \def\strutdepth{\dp\strutbox} %\hbox{{\rm#1}}\hfil\break}} % @include file insert text of that file as input. % Allow normal characters that we make active in the argument (a file name). \def\include{\begingroup \catcode`\\=12 \catcode`~=12 \catcode`^=12 \catcode`_=12 \catcode`|=12 \catcode`<=12 \catcode`>=12 \catcode`+=12 \parsearg\includezzz} % Restore active chars for included file. \def\includezzz#1{\endgroup\begingroup % Read the included file in a group so nested @include's work. \def\thisfile{#1}% \input\thisfile \endgroup} \def\thisfile{} % @center line outputs that line, centered \def\center{\parsearg\centerzzz} \def\centerzzz #1{{\advance\hsize by -\leftskip \advance\hsize by -\rightskip \centerline{#1}}} % @sp n outputs n lines of vertical space \def\sp{\parsearg\spxxx} \def\spxxx #1{\vskip #1\baselineskip} % @comment ...line which is ignored... % @c is the same as @comment % @ignore ... @end ignore is another way to write a comment \def\comment{\catcode 64=\other \catcode 123=\other \catcode 125=\other% \parsearg \commentxxx} \def\commentxxx #1{\catcode 64=0 \catcode 123=1 \catcode 125=2 } \let\c=\comment % @paragraphindent is defined for the Info formatting commands only. \let\paragraphindent=\comment % Prevent errors for section commands. % Used in @ignore and in failing conditionals. \def\ignoresections{% \let\chapter=\relax \let\unnumbered=\relax \let\top=\relax \let\unnumberedsec=\relax \let\unnumberedsection=\relax \let\unnumberedsubsec=\relax \let\unnumberedsubsection=\relax \let\unnumberedsubsubsec=\relax \let\unnumberedsubsubsection=\relax \let\section=\relax \let\subsec=\relax \let\subsubsec=\relax \let\subsection=\relax \let\subsubsection=\relax \let\appendix=\relax \let\appendixsec=\relax \let\appendixsection=\relax \let\appendixsubsec=\relax \let\appendixsubsection=\relax \let\appendixsubsubsec=\relax \let\appendixsubsubsection=\relax \let\contents=\relax \let\smallbook=\relax \let\titlepage=\relax } % Used in nested conditionals, where we have to parse the Texinfo source % and so want to turn off most commands, in case they are used % incorrectly. % \def\ignoremorecommands{% \let\defcodeindex = \relax \let\defcv = \relax \let\deffn = \relax \let\deffnx = \relax \let\defindex = \relax \let\defivar = \relax \let\defmac = \relax \let\defmethod = \relax \let\defop = \relax \let\defopt = \relax \let\defspec = \relax \let\deftp = \relax \let\deftypefn = \relax \let\deftypefun = \relax \let\deftypevar = \relax \let\deftypevr = \relax \let\defun = \relax \let\defvar = \relax \let\defvr = \relax \let\ref = \relax \let\xref = \relax \let\printindex = \relax \let\pxref = \relax \let\settitle = \relax \let\setchapternewpage = \relax \let\setchapterstyle = \relax \let\everyheading = \relax \let\evenheading = \relax \let\oddheading = \relax \let\everyfooting = \relax \let\evenfooting = \relax \let\oddfooting = \relax \let\headings = \relax \let\include = \relax \let\lowersections = \relax \let\down = \relax \let\raisesections = \relax \let\up = \relax \let\set = \relax \let\clear = \relax \let\item = \relax } % Ignore @ignore ... @end ignore. % \def\ignore{\doignore{ignore}} % Ignore @ifinfo, @ifhtml, @ifnottex, @html, @menu, and @direntry text. % \def\ifinfo{\doignore{ifinfo}} \def\ifhtml{\doignore{ifhtml}} \def\ifnottex{\doignore{ifnottex}} \def\html{\doignore{html}} \def\menu{\doignore{menu}} \def\direntry{\doignore{direntry}} % Also ignore @macro ... @end macro. The user must run texi2dvi, % which runs makeinfo to do macro expansion. Ignore @unmacro, too. \def\macro{\doignore{macro}} \let\unmacro = \comment % @dircategory CATEGORY -- specify a category of the dir file % which this file should belong to. Ignore this in TeX. \let\dircategory = \comment % Ignore text until a line `@end #1'. % \def\doignore#1{\begingroup % Don't complain about control sequences we have declared \outer. \ignoresections % % Define a command to swallow text until we reach `@end #1'. \long\def\doignoretext##1\end #1{\enddoignore}% % % Make sure that spaces turn into tokens that match what \doignoretext wants. \catcode32 = 10 % % Ignore braces, too, so mismatched braces don't cause trouble. \catcode`\{ = 9 \catcode`\} = 9 % % And now expand that command. \doignoretext } % What we do to finish off ignored text. % \def\enddoignore{\endgroup\ignorespaces}% \newif\ifwarnedobs\warnedobsfalse \def\obstexwarn{% \ifwarnedobs\relax\else % We need to warn folks that they may have trouble with TeX 3.0. % This uses \immediate\write16 rather than \message to get newlines. \immediate\write16{} \immediate\write16{***WARNING*** for users of Unix TeX 3.0!} \immediate\write16{This manual trips a bug in TeX version 3.0 (tex hangs).} \immediate\write16{If you are running another version of TeX, relax.} \immediate\write16{If you are running Unix TeX 3.0, kill this TeX process.} \immediate\write16{ Then upgrade your TeX installation if you can.} \immediate\write16{ (See ftp://ftp.gnu.ai.mit.edu/pub/gnu/TeX.README.)} \immediate\write16{If you are stuck with version 3.0, run the} \immediate\write16{ script ``tex3patch'' from the Texinfo distribution} \immediate\write16{ to use a workaround.} \immediate\write16{} \global\warnedobstrue \fi } % **In TeX 3.0, setting text in \nullfont hangs tex. For a % workaround (which requires the file ``dummy.tfm'' to be installed), % uncomment the following line: %%%%%\font\nullfont=dummy\let\obstexwarn=\relax % Ignore text, except that we keep track of conditional commands for % purposes of nesting, up to an `@end #1' command. % \def\nestedignore#1{% \obstexwarn % We must actually expand the ignored text to look for the @end % command, so that nested ignore constructs work. Thus, we put the % text into a \vbox and then do nothing with the result. To minimize % the change of memory overflow, we follow the approach outlined on % page 401 of the TeXbook: make the current font be a dummy font. % \setbox0 = \vbox\bgroup % Don't complain about control sequences we have declared \outer. \ignoresections % % Define `@end #1' to end the box, which will in turn undefine the % @end command again. \expandafter\def\csname E#1\endcsname{\egroup\ignorespaces}% % % We are going to be parsing Texinfo commands. Most cause no % trouble when they are used incorrectly, but some commands do % complicated argument parsing or otherwise get confused, so we % undefine them. % % We can't do anything about stray @-signs, unfortunately; % they'll produce `undefined control sequence' errors. \ignoremorecommands % % Set the current font to be \nullfont, a TeX primitive, and define % all the font commands to also use \nullfont. We don't use % dummy.tfm, as suggested in the TeXbook, because not all sites % might have that installed. Therefore, math mode will still % produce output, but that should be an extremely small amount of % stuff compared to the main input. % \nullfont \let\tenrm = \nullfont \let\tenit = \nullfont \let\tensl = \nullfont \let\tenbf = \nullfont \let\tentt = \nullfont \let\smallcaps = \nullfont \let\tensf = \nullfont % Similarly for index fonts (mostly for their use in % smallexample) \let\indrm = \nullfont \let\indit = \nullfont \let\indsl = \nullfont \let\indbf = \nullfont \let\indtt = \nullfont \let\indsc = \nullfont \let\indsf = \nullfont % % Don't complain when characters are missing from the fonts. \tracinglostchars = 0 % % Don't bother to do space factor calculations. \frenchspacing % % Don't report underfull hboxes. \hbadness = 10000 % % Do minimal line-breaking. \pretolerance = 10000 % % Do not execute instructions in @tex \def\tex{\doignore{tex}}% } % @set VAR sets the variable VAR to an empty value. % @set VAR REST-OF-LINE sets VAR to the value REST-OF-LINE. % % Since we want to separate VAR from REST-OF-LINE (which might be % empty), we can't just use \parsearg; we have to insert a space of our % own to delimit the rest of the line, and then take it out again if we % didn't need it. Make sure the catcode of space is correct to avoid % losing inside @example, for instance. % \def\set{\begingroup\catcode` =10 \catcode`\-=12 \catcode`\_=12 % Allow - and _ in VAR. \parsearg\setxxx} \def\setxxx#1{\setyyy#1 \endsetyyy} \def\setyyy#1 #2\endsetyyy{% \def\temp{#2}% \ifx\temp\empty \global\expandafter\let\csname SET#1\endcsname = \empty \else \setzzz{#1}#2\endsetzzz % Remove the trailing space \setxxx inserted. \fi \endgroup } % Can't use \xdef to pre-expand #2 and save some time, since \temp or % \next or other control sequences that we've defined might get us into % an infinite loop. Consider `@set foo @cite{bar}'. \def\setzzz#1#2 \endsetzzz{\expandafter\gdef\csname SET#1\endcsname{#2}} % @clear VAR clears (i.e., unsets) the variable VAR. % \def\clear{\parsearg\clearxxx} \def\clearxxx#1{\global\expandafter\let\csname SET#1\endcsname=\relax} % @value{foo} gets the text saved in variable foo. % \def\value{\begingroup \catcode`\-=12 \catcode`\_=12 % Allow - and _ in VAR. \valuexxx} \def\valuexxx#1{% \expandafter\ifx\csname SET#1\endcsname\relax {\{No value for ``#1''\}}% \else \csname SET#1\endcsname \fi \endgroup} % @ifset VAR ... @end ifset reads the `...' iff VAR has been defined % with @set. % \def\ifset{\parsearg\ifsetxxx} \def\ifsetxxx #1{% \expandafter\ifx\csname SET#1\endcsname\relax \expandafter\ifsetfail \else \expandafter\ifsetsucceed \fi } \def\ifsetsucceed{\conditionalsucceed{ifset}} \def\ifsetfail{\nestedignore{ifset}} \defineunmatchedend{ifset} % @ifclear VAR ... @end ifclear reads the `...' iff VAR has never been % defined with @set, or has been undefined with @clear. % \def\ifclear{\parsearg\ifclearxxx} \def\ifclearxxx #1{% \expandafter\ifx\csname SET#1\endcsname\relax \expandafter\ifclearsucceed \else \expandafter\ifclearfail \fi } \def\ifclearsucceed{\conditionalsucceed{ifclear}} \def\ifclearfail{\nestedignore{ifclear}} \defineunmatchedend{ifclear} % @iftex, @ifnothtml, @ifnotinfo always succeed; we read the text % following, through the first @end iftex (etc.). Make `@end iftex' % (etc.) valid only after an @iftex. % \def\iftex{\conditionalsucceed{iftex}} \def\ifnothtml{\conditionalsucceed{ifnothtml}} \def\ifnotinfo{\conditionalsucceed{ifnotinfo}} \defineunmatchedend{iftex} \defineunmatchedend{ifnothtml} \defineunmatchedend{ifnotinfo} % We can't just want to start a group at @iftex (for example) and end it % at @end iftex, since then @set commands inside the conditional have no % effect (they'd get reverted at the end of the group). So we must % define \Eiftex to redefine itself to be its previous value. (We can't % just define it to fail again with an ``unmatched end'' error, since % the @ifset might be nested.) % \def\conditionalsucceed#1{% \edef\temp{% % Remember the current value of \E#1. \let\nece{prevE#1} = \nece{E#1}% % % At the `@end #1', redefine \E#1 to be its previous value. \def\nece{E#1}{\let\nece{E#1} = \nece{prevE#1}}% }% \temp } % We need to expand lots of \csname's, but we don't want to expand the % control sequences after we've constructed them. % \def\nece#1{\expandafter\noexpand\csname#1\endcsname} % @asis just yields its argument. Used with @table, for example. % \def\asis#1{#1} % @math means output in math mode. % We don't use $'s directly in the definition of \math because control % sequences like \math are expanded when the toc file is written. Then, % we read the toc file back, the $'s will be normal characters (as they % should be, according to the definition of Texinfo). So we must use a % control sequence to switch into and out of math mode. % % This isn't quite enough for @math to work properly in indices, but it % seems unlikely it will ever be needed there. % \let\implicitmath = $ \def\math#1{\implicitmath #1\implicitmath} % @bullet and @minus need the same treatment as @math, just above. \def\bullet{\implicitmath\ptexbullet\implicitmath} \def\minus{\implicitmath-\implicitmath} \def\node{\ENVcheck\parsearg\nodezzz} \def\nodezzz#1{\nodexxx [#1,]} \def\nodexxx[#1,#2]{\gdef\lastnode{#1}} \let\nwnode=\node \let\lastnode=\relax \def\donoderef{\ifx\lastnode\relax\else \expandafter\expandafter\expandafter\setref{\lastnode}\fi \global\let\lastnode=\relax} \def\unnumbnoderef{\ifx\lastnode\relax\else \expandafter\expandafter\expandafter\unnumbsetref{\lastnode}\fi \global\let\lastnode=\relax} \def\appendixnoderef{\ifx\lastnode\relax\else \expandafter\expandafter\expandafter\appendixsetref{\lastnode}\fi \global\let\lastnode=\relax} % @refill is a no-op. \let\refill=\relax % @setfilename is done at the beginning of every texinfo file. % So open here the files we need to have open while reading the input. % This makes it possible to make a .fmt file for texinfo. \def\setfilename{% \readauxfile \opencontents \openindices \fixbackslash % Turn off hack to swallow `\input texinfo'. \global\let\setfilename=\comment % Ignore extra @setfilename cmds. % % If texinfo.cnf is present on the system, read it. % Useful for site-wide @afourpaper, etc. % Just to be on the safe side, close the input stream before the \input. \openin 1 texinfo.cnf \ifeof1 \let\temp=\relax \else \def\temp{\input texinfo.cnf }\fi \closein1 \temp % \comment % Ignore the actual filename. } % @bye. \outer\def\bye{\pagealignmacro\tracingstats=1\ptexend} % \def\macro#1{\begingroup\ignoresections\catcode`\#=6\def\macrotemp{#1}\parsearg\macroxxx} % \def\macroxxx#1#2 \end macro{% % \expandafter\gdef\macrotemp#1{#2}% % \endgroup} %\def\linemacro#1{\begingroup\ignoresections\catcode`\#=6\def\macrotemp{#1}\parsearg\linemacroxxx} %\def\linemacroxxx#1#2 \end linemacro{% %\let\parsearg=\relax %\edef\macrotempx{\csname M\butfirst\expandafter\string\macrotemp\endcsname}% %\expandafter\xdef\macrotemp{\parsearg\macrotempx}% %\expandafter\gdef\macrotempx#1{#2}% %\endgroup} %\def\butfirst#1{} \message{fonts,} % Font-change commands. % Texinfo supports the sans serif font style, which plain TeX does not. % So we set up a \sf analogous to plain's \rm, etc. \newfam\sffam \def\sf{\fam=\sffam \tensf} \let\li = \sf % Sometimes we call it \li, not \sf. % We don't need math for this one. \def\ttsl{\tenttsl} % Use Computer Modern fonts at \magstephalf (11pt). \newcount\mainmagstep \mainmagstep=\magstephalf % Set the font macro #1 to the font named #2, adding on the % specified font prefix (normally `cm'). % #3 is the font's design size, #4 is a scale factor \def\setfont#1#2#3#4{\font#1=\fontprefix#2#3 scaled #4} % Use cm as the default font prefix. % To specify the font prefix, you must define \fontprefix % before you read in texinfo.tex. \ifx\fontprefix\undefined \def\fontprefix{cm} \fi % Support font families that don't use the same naming scheme as CM. \def\rmshape{r} \def\rmbshape{bx} %where the normal face is bold \def\bfshape{b} \def\bxshape{bx} \def\ttshape{tt} \def\ttbshape{tt} \def\ttslshape{sltt} \def\itshape{ti} \def\itbshape{bxti} \def\slshape{sl} \def\slbshape{bxsl} \def\sfshape{ss} \def\sfbshape{ss} \def\scshape{csc} \def\scbshape{csc} \ifx\bigger\relax \let\mainmagstep=\magstep1 \setfont\textrm\rmshape{12}{1000} \setfont\texttt\ttshape{12}{1000} \else \setfont\textrm\rmshape{10}{\mainmagstep} \setfont\texttt\ttshape{10}{\mainmagstep} \fi % Instead of cmb10, you many want to use cmbx10. % cmbx10 is a prettier font on its own, but cmb10 % looks better when embedded in a line with cmr10. \setfont\textbf\bfshape{10}{\mainmagstep} \setfont\textit\itshape{10}{\mainmagstep} \setfont\textsl\slshape{10}{\mainmagstep} \setfont\textsf\sfshape{10}{\mainmagstep} \setfont\textsc\scshape{10}{\mainmagstep} \setfont\textttsl\ttslshape{10}{\mainmagstep} \font\texti=cmmi10 scaled \mainmagstep \font\textsy=cmsy10 scaled \mainmagstep % A few fonts for @defun, etc. \setfont\defbf\bxshape{10}{\magstep1} %was 1314 \setfont\deftt\ttshape{10}{\magstep1} \def\df{\let\tentt=\deftt \let\tenbf = \defbf \bf} % Fonts for indices and small examples (9pt). % We actually use the slanted font rather than the italic, % because texinfo normally uses the slanted fonts for that. % Do not make many font distinctions in general in the index, since they % aren't very useful. \setfont\ninett\ttshape{9}{1000} \setfont\indrm\rmshape{9}{1000} \setfont\indit\slshape{9}{1000} \let\indsl=\indit \let\indtt=\ninett \let\indttsl=\ninett \let\indsf=\indrm \let\indbf=\indrm \setfont\indsc\scshape{10}{900} \font\indi=cmmi9 \font\indsy=cmsy9 % Fonts for title page: \setfont\titlerm\rmbshape{12}{\magstep3} \setfont\titleit\itbshape{10}{\magstep4} \setfont\titlesl\slbshape{10}{\magstep4} \setfont\titlett\ttbshape{12}{\magstep3} \setfont\titlettsl\ttslshape{10}{\magstep4} \setfont\titlesf\sfbshape{17}{\magstep1} \let\titlebf=\titlerm \setfont\titlesc\scbshape{10}{\magstep4} \font\titlei=cmmi12 scaled \magstep3 \font\titlesy=cmsy10 scaled \magstep4 \def\authorrm{\secrm} % Chapter (and unnumbered) fonts (17.28pt). \setfont\chaprm\rmbshape{12}{\magstep2} \setfont\chapit\itbshape{10}{\magstep3} \setfont\chapsl\slbshape{10}{\magstep3} \setfont\chaptt\ttbshape{12}{\magstep2} \setfont\chapttsl\ttslshape{10}{\magstep3} \setfont\chapsf\sfbshape{17}{1000} \let\chapbf=\chaprm \setfont\chapsc\scbshape{10}{\magstep3} \font\chapi=cmmi12 scaled \magstep2 \font\chapsy=cmsy10 scaled \magstep3 % Section fonts (14.4pt). \setfont\secrm\rmbshape{12}{\magstep1} \setfont\secit\itbshape{10}{\magstep2} \setfont\secsl\slbshape{10}{\magstep2} \setfont\sectt\ttbshape{12}{\magstep1} \setfont\secttsl\ttslshape{10}{\magstep2} \setfont\secsf\sfbshape{12}{\magstep1} \let\secbf\secrm \setfont\secsc\scbshape{10}{\magstep2} \font\seci=cmmi12 scaled \magstep1 \font\secsy=cmsy10 scaled \magstep2 % \setfont\ssecrm\bxshape{10}{\magstep1} % This size an font looked bad. % \setfont\ssecit\itshape{10}{\magstep1} % The letters were too crowded. % \setfont\ssecsl\slshape{10}{\magstep1} % \setfont\ssectt\ttshape{10}{\magstep1} % \setfont\ssecsf\sfshape{10}{\magstep1} %\setfont\ssecrm\bfshape{10}{1315} % Note the use of cmb rather than cmbx. %\setfont\ssecit\itshape{10}{1315} % Also, the size is a little larger than %\setfont\ssecsl\slshape{10}{1315} % being scaled magstep1. %\setfont\ssectt\ttshape{10}{1315} %\setfont\ssecsf\sfshape{10}{1315} %\let\ssecbf=\ssecrm % Subsection fonts (13.15pt). \setfont\ssecrm\rmbshape{12}{\magstephalf} \setfont\ssecit\itbshape{10}{1315} \setfont\ssecsl\slbshape{10}{1315} \setfont\ssectt\ttbshape{12}{\magstephalf} \setfont\ssecttsl\ttslshape{10}{1315} \setfont\ssecsf\sfbshape{12}{\magstephalf} \let\ssecbf\ssecrm \setfont\ssecsc\scbshape{10}{\magstep1} \font\sseci=cmmi12 scaled \magstephalf \font\ssecsy=cmsy10 scaled 1315 % The smallcaps and symbol fonts should actually be scaled \magstep1.5, % but that is not a standard magnification. % In order for the font changes to affect most math symbols and letters, % we have to define the \textfont of the standard families. Since % texinfo doesn't allow for producing subscripts and superscripts, we % don't bother to reset \scriptfont and \scriptscriptfont (which would % also require loading a lot more fonts). % \def\resetmathfonts{% \textfont0 = \tenrm \textfont1 = \teni \textfont2 = \tensy \textfont\itfam = \tenit \textfont\slfam = \tensl \textfont\bffam = \tenbf \textfont\ttfam = \tentt \textfont\sffam = \tensf } % The font-changing commands redefine the meanings of \tenSTYLE, instead % of just \STYLE. We do this so that font changes will continue to work % in math mode, where it is the current \fam that is relevant in most % cases, not the current font. Plain TeX does \def\bf{\fam=\bffam % \tenbf}, for example. By redefining \tenbf, we obviate the need to % redefine \bf itself. \def\textfonts{% \let\tenrm=\textrm \let\tenit=\textit \let\tensl=\textsl \let\tenbf=\textbf \let\tentt=\texttt \let\smallcaps=\textsc \let\tensf=\textsf \let\teni=\texti \let\tensy=\textsy \let\tenttsl=\textttsl \resetmathfonts} \def\titlefonts{% \let\tenrm=\titlerm \let\tenit=\titleit \let\tensl=\titlesl \let\tenbf=\titlebf \let\tentt=\titlett \let\smallcaps=\titlesc \let\tensf=\titlesf \let\teni=\titlei \let\tensy=\titlesy \let\tenttsl=\titlettsl \resetmathfonts \setleading{25pt}} \def\titlefont#1{{\titlefonts #1}} \def\chapfonts{% \let\tenrm=\chaprm \let\tenit=\chapit \let\tensl=\chapsl \let\tenbf=\chapbf \let\tentt=\chaptt \let\smallcaps=\chapsc \let\tensf=\chapsf \let\teni=\chapi \let\tensy=\chapsy \let\tenttsl=\chapttsl \resetmathfonts \setleading{19pt}} \def\secfonts{% \let\tenrm=\secrm \let\tenit=\secit \let\tensl=\secsl \let\tenbf=\secbf \let\tentt=\sectt \let\smallcaps=\secsc \let\tensf=\secsf \let\teni=\seci \let\tensy=\secsy \let\tenttsl=\secttsl \resetmathfonts \setleading{16pt}} \def\subsecfonts{% \let\tenrm=\ssecrm \let\tenit=\ssecit \let\tensl=\ssecsl \let\tenbf=\ssecbf \let\tentt=\ssectt \let\smallcaps=\ssecsc \let\tensf=\ssecsf \let\teni=\sseci \let\tensy=\ssecsy \let\tenttsl=\ssecttsl \resetmathfonts \setleading{15pt}} \let\subsubsecfonts = \subsecfonts % Maybe make sssec fonts scaled magstephalf? \def\indexfonts{% \let\tenrm=\indrm \let\tenit=\indit \let\tensl=\indsl \let\tenbf=\indbf \let\tentt=\indtt \let\smallcaps=\indsc \let\tensf=\indsf \let\teni=\indi \let\tensy=\indsy \let\tenttsl=\indttsl \resetmathfonts \setleading{12pt}} % Set up the default fonts, so we can use them for creating boxes. % \textfonts % Count depth in font-changes, for error checks \newcount\fontdepth \fontdepth=0 % Fonts for short table of contents. \setfont\shortcontrm\rmshape{12}{1000} \setfont\shortcontbf\bxshape{12}{1000} \setfont\shortcontsl\slshape{12}{1000} %% Add scribe-like font environments, plus @l for inline lisp (usually sans %% serif) and @ii for TeX italic % \smartitalic{ARG} outputs arg in italics, followed by an italic correction % unless the following character is such as not to need one. \def\smartitalicx{\ifx\next,\else\ifx\next-\else\ifx\next.\else\/\fi\fi\fi} \def\smartitalic#1{{\sl #1}\futurelet\next\smartitalicx} \let\i=\smartitalic \let\var=\smartitalic \let\dfn=\smartitalic \let\emph=\smartitalic \let\cite=\smartitalic \def\b#1{{\bf #1}} \let\strong=\b % We can't just use \exhyphenpenalty, because that only has effect at % the end of a paragraph. Restore normal hyphenation at the end of the % group within which \nohyphenation is presumably called. % \def\nohyphenation{\hyphenchar\font = -1 \aftergroup\restorehyphenation} \def\restorehyphenation{\hyphenchar\font = `- } \def\t#1{% {\tt \rawbackslash \frenchspacing #1}% \null } \let\ttfont=\t \def\samp #1{`\tclose{#1}'\null} \setfont\smallrm\rmshape{8}{1000} \font\smallsy=cmsy9 \def\key#1{{\smallrm\textfont2=\smallsy \leavevmode\hbox{% \raise0.4pt\hbox{$\langle$}\kern-.08em\vtop{% \vbox{\hrule\kern-0.4pt \hbox{\raise0.4pt\hbox{\vphantom{$\langle$}}#1}}% \kern-0.4pt\hrule}% \kern-.06em\raise0.4pt\hbox{$\rangle$}}}} % The old definition, with no lozenge: %\def\key #1{{\ttsl \nohyphenation \uppercase{#1}}\null} \def\ctrl #1{{\tt \rawbackslash \hat}#1} \let\file=\samp % @code is a modification of @t, % which makes spaces the same size as normal in the surrounding text. \def\tclose#1{% {% % Change normal interword space to be same as for the current font. \spaceskip = \fontdimen2\font % % Switch to typewriter. \tt % % But `\ ' produces the large typewriter interword space. \def\ {{\spaceskip = 0pt{} }}% % % Turn off hyphenation. \nohyphenation % \rawbackslash \frenchspacing #1% }% \null } % We *must* turn on hyphenation at `-' and `_' in \code. % Otherwise, it is too hard to avoid overfull hboxes % in the Emacs manual, the Library manual, etc. % Unfortunately, TeX uses one parameter (\hyphenchar) to control % both hyphenation at - and hyphenation within words. % We must therefore turn them both off (\tclose does that) % and arrange explicitly to hyphenate at a dash. % -- rms. { \catcode`\-=\active \catcode`\_=\active \catcode`\|=\active \global\def\code{\begingroup \catcode`\-=\active \let-\codedash \catcode`\_=\active \let_\codeunder \codex} % The following is used by \doprintindex to insure that long function names % wrap around. It is necessary for - and _ to be active before the index is % read from the file, as \entry parses the arguments long before \code is % ever called. -- mycroft % _ is always active; and it shouldn't be \let = to an _ that is a % subscript character anyway. Then, @cindex @samp{_} (for example) % fails. --karl \global\def\indexbreaks{% \catcode`\-=\active \let-\realdash } } \def\realdash{-} \def\codedash{-\discretionary{}{}{}} \def\codeunder{\ifusingtt{\normalunderscore\discretionary{}{}{}}{\_}} \def\codex #1{\tclose{#1}\endgroup} %\let\exp=\tclose %Was temporary % @kbd is like @code, except that if the argument is just one @key command, % then @kbd has no effect. % @kbdinputstyle -- arg is `distinct' (@kbd uses slanted tty font always), % `example' (@kbd uses ttsl only inside of @example and friends), % or `code' (@kbd uses normal tty font always). \def\kbdinputstyle{\parsearg\kbdinputstylexxx} \def\kbdinputstylexxx#1{% \def\arg{#1}% \ifx\arg\worddistinct \gdef\kbdexamplefont{\ttsl}\gdef\kbdfont{\ttsl}% \else\ifx\arg\wordexample \gdef\kbdexamplefont{\ttsl}\gdef\kbdfont{\tt}% \else\ifx\arg\wordcode \gdef\kbdexamplefont{\tt}\gdef\kbdfont{\tt}% \fi\fi\fi } \def\worddistinct{distinct} \def\wordexample{example} \def\wordcode{code} % Default is kbdinputdistinct. (Too much of a hassle to call the macro, % the catcodes are wrong for parsearg to work.) \gdef\kbdexamplefont{\ttsl}\gdef\kbdfont{\ttsl} \def\xkey{\key} \def\kbdfoo#1#2#3\par{\def\one{#1}\def\three{#3}\def\threex{??}% \ifx\one\xkey\ifx\threex\three \key{#2}% \else{\tclose{\kbdfont\look}}\fi \else{\tclose{\kbdfont\look}}\fi} % @url. Quotes do not seem necessary, so use \code. \let\url=\code % @uref (abbreviation for `urlref') takes an optional second argument % specifying the text to display. First (mandatory) arg is the url. % Perhaps eventually put in a hypertex \special here. % \def\uref#1{\urefxxx #1,,\finish} \def\urefxxx#1,#2,#3\finish{% \setbox0 = \hbox{\ignorespaces #2}% \ifdim\wd0 > 0pt \unhbox0\ (\code{#1})% \else \code{#1}% \fi } % rms does not like the angle brackets --karl, 17may97. % So now @email is just like @uref. %\def\email#1{$\langle${\tt #1}$\rangle$} \let\email=\uref % Check if we are currently using a typewriter font. Since all the % Computer Modern typewriter fonts have zero interword stretch (and % shrink), and it is reasonable to expect all typewriter fonts to have % this property, we can check that font parameter. % \def\ifmonospace{\ifdim\fontdimen3\font=0pt } % Typeset a dimension, e.g., `in' or `pt'. The only reason for the % argument is to make the input look right: @dmn{pt} instead of % @dmn{}pt. % \def\dmn#1{\thinspace #1} \def\kbd#1{\def\look{#1}\expandafter\kbdfoo\look??\par} % @l was never documented to mean ``switch to the Lisp font'', % and it is not used as such in any manual I can find. We need it for % Polish suppressed-l. --karl, 22sep96. %\def\l#1{{\li #1}\null} \def\r#1{{\rm #1}} % roman font % Use of \lowercase was suggested. \def\sc#1{{\smallcaps#1}} % smallcaps font \def\ii#1{{\it #1}} % italic font % @pounds{} is a sterling sign. \def\pounds{{\it\$}} \message{page headings,} \newskip\titlepagetopglue \titlepagetopglue = 1.5in \newskip\titlepagebottomglue \titlepagebottomglue = 2pc % First the title page. Must do @settitle before @titlepage. \newif\ifseenauthor \newif\iffinishedtitlepage \def\shorttitlepage{\parsearg\shorttitlepagezzz} \def\shorttitlepagezzz #1{\begingroup\hbox{}\vskip 1.5in \chaprm \centerline{#1}% \endgroup\page\hbox{}\page} \def\titlepage{\begingroup \parindent=0pt \textfonts \let\subtitlerm=\tenrm % I deinstalled the following change because \cmr12 is undefined. % This change was not in the ChangeLog anyway. --rms. % \let\subtitlerm=\cmr12 \def\subtitlefont{\subtitlerm \normalbaselineskip = 13pt \normalbaselines}% % \def\authorfont{\authorrm \normalbaselineskip = 16pt \normalbaselines}% % % Leave some space at the very top of the page. \vglue\titlepagetopglue % % Now you can print the title using @title. \def\title{\parsearg\titlezzz}% \def\titlezzz##1{\leftline{\titlefonts\rm ##1} % print a rule at the page bottom also. \finishedtitlepagefalse \vskip4pt \hrule height 4pt width \hsize \vskip4pt}% % No rule at page bottom unless we print one at the top with @title. \finishedtitlepagetrue % % Now you can put text using @subtitle. \def\subtitle{\parsearg\subtitlezzz}% \def\subtitlezzz##1{{\subtitlefont \rightline{##1}}}% % % @author should come last, but may come many times. \def\author{\parsearg\authorzzz}% \def\authorzzz##1{\ifseenauthor\else\vskip 0pt plus 1filll\seenauthortrue\fi {\authorfont \leftline{##1}}}% % % Most title ``pages'' are actually two pages long, with space % at the top of the second. We don't want the ragged left on the second. \let\oldpage = \page \def\page{% \iffinishedtitlepage\else \finishtitlepage \fi \oldpage \let\page = \oldpage \hbox{}}% % \def\page{\oldpage \hbox{}} } \def\Etitlepage{% \iffinishedtitlepage\else \finishtitlepage \fi % It is important to do the page break before ending the group, % because the headline and footline are only empty inside the group. % If we use the new definition of \page, we always get a blank page % after the title page, which we certainly don't want. \oldpage \endgroup \HEADINGSon } \def\finishtitlepage{% \vskip4pt \hrule height 2pt width \hsize \vskip\titlepagebottomglue \finishedtitlepagetrue } %%% Set up page headings and footings. \let\thispage=\folio \newtoks \evenheadline % Token sequence for heading line of even pages \newtoks \oddheadline % Token sequence for heading line of odd pages \newtoks \evenfootline % Token sequence for footing line of even pages \newtoks \oddfootline % Token sequence for footing line of odd pages % Now make Tex use those variables \headline={{\textfonts\rm \ifodd\pageno \the\oddheadline \else \the\evenheadline \fi}} \footline={{\textfonts\rm \ifodd\pageno \the\oddfootline \else \the\evenfootline \fi}\HEADINGShook} \let\HEADINGShook=\relax % Commands to set those variables. % For example, this is what @headings on does % @evenheading @thistitle|@thispage|@thischapter % @oddheading @thischapter|@thispage|@thistitle % @evenfooting @thisfile|| % @oddfooting ||@thisfile \def\evenheading{\parsearg\evenheadingxxx} \def\oddheading{\parsearg\oddheadingxxx} \def\everyheading{\parsearg\everyheadingxxx} \def\evenfooting{\parsearg\evenfootingxxx} \def\oddfooting{\parsearg\oddfootingxxx} \def\everyfooting{\parsearg\everyfootingxxx} {\catcode`\@=0 % \gdef\evenheadingxxx #1{\evenheadingyyy #1@|@|@|@|\finish} \gdef\evenheadingyyy #1@|#2@|#3@|#4\finish{% \global\evenheadline={\rlap{\centerline{#2}}\line{#1\hfil#3}}} \gdef\oddheadingxxx #1{\oddheadingyyy #1@|@|@|@|\finish} \gdef\oddheadingyyy #1@|#2@|#3@|#4\finish{% \global\oddheadline={\rlap{\centerline{#2}}\line{#1\hfil#3}}} \gdef\everyheadingxxx#1{\oddheadingxxx{#1}\evenheadingxxx{#1}}% \gdef\evenfootingxxx #1{\evenfootingyyy #1@|@|@|@|\finish} \gdef\evenfootingyyy #1@|#2@|#3@|#4\finish{% \global\evenfootline={\rlap{\centerline{#2}}\line{#1\hfil#3}}} \gdef\oddfootingxxx #1{\oddfootingyyy #1@|@|@|@|\finish} \gdef\oddfootingyyy #1@|#2@|#3@|#4\finish{% \global\oddfootline = {\rlap{\centerline{#2}}\line{#1\hfil#3}}% % % Leave some space for the footline. Hopefully ok to assume % @evenfooting will not be used by itself. \global\advance\pageheight by -\baselineskip \global\advance\vsize by -\baselineskip } \gdef\everyfootingxxx#1{\oddfootingxxx{#1}\evenfootingxxx{#1}} % }% unbind the catcode of @. % @headings double turns headings on for double-sided printing. % @headings single turns headings on for single-sided printing. % @headings off turns them off. % @headings on same as @headings double, retained for compatibility. % @headings after turns on double-sided headings after this page. % @headings doubleafter turns on double-sided headings after this page. % @headings singleafter turns on single-sided headings after this page. % By default, they are off at the start of a document, % and turned `on' after @end titlepage. \def\headings #1 {\csname HEADINGS#1\endcsname} \def\HEADINGSoff{ \global\evenheadline={\hfil} \global\evenfootline={\hfil} \global\oddheadline={\hfil} \global\oddfootline={\hfil}} \HEADINGSoff % When we turn headings on, set the page number to 1. % For double-sided printing, put current file name in lower left corner, % chapter name on inside top of right hand pages, document % title on inside top of left hand pages, and page numbers on outside top % edge of all pages. \def\HEADINGSdouble{ \global\pageno=1 \global\evenfootline={\hfil} \global\oddfootline={\hfil} \global\evenheadline={\line{\folio\hfil\thistitle}} \global\oddheadline={\line{\thischapter\hfil\folio}} \global\let\contentsalignmacro = \chapoddpage } \let\contentsalignmacro = \chappager % For single-sided printing, chapter title goes across top left of page, % page number on top right. \def\HEADINGSsingle{ \global\pageno=1 \global\evenfootline={\hfil} \global\oddfootline={\hfil} \global\evenheadline={\line{\thischapter\hfil\folio}} \global\oddheadline={\line{\thischapter\hfil\folio}} \global\let\contentsalignmacro = \chappager } \def\HEADINGSon{\HEADINGSdouble} \def\HEADINGSafter{\let\HEADINGShook=\HEADINGSdoublex} \let\HEADINGSdoubleafter=\HEADINGSafter \def\HEADINGSdoublex{% \global\evenfootline={\hfil} \global\oddfootline={\hfil} \global\evenheadline={\line{\folio\hfil\thistitle}} \global\oddheadline={\line{\thischapter\hfil\folio}} \global\let\contentsalignmacro = \chapoddpage } \def\HEADINGSsingleafter{\let\HEADINGShook=\HEADINGSsinglex} \def\HEADINGSsinglex{% \global\evenfootline={\hfil} \global\oddfootline={\hfil} \global\evenheadline={\line{\thischapter\hfil\folio}} \global\oddheadline={\line{\thischapter\hfil\folio}} \global\let\contentsalignmacro = \chappager } % Subroutines used in generating headings % Produces Day Month Year style of output. \def\today{\number\day\space \ifcase\month\or January\or February\or March\or April\or May\or June\or July\or August\or September\or October\or November\or December\fi \space\number\year} % Use this if you want the Month Day, Year style of output. %\def\today{\ifcase\month\or %January\or February\or March\or April\or May\or June\or %July\or August\or September\or October\or November\or December\fi %\space\number\day, \number\year} % @settitle line... specifies the title of the document, for headings % It generates no output of its own \def\thistitle{No Title} \def\settitle{\parsearg\settitlezzz} \def\settitlezzz #1{\gdef\thistitle{#1}} \message{tables,} % @tabs -- simple alignment % These don't work. For one thing, \+ is defined as outer. % So these macros cannot even be defined. %\def\tabs{\parsearg\tabszzz} %\def\tabszzz #1{\settabs\+#1\cr} %\def\tabline{\parsearg\tablinezzz} %\def\tablinezzz #1{\+#1\cr} %\def\&{&} % Tables -- @table, @ftable, @vtable, @item(x), @kitem(x), @xitem(x). % default indentation of table text \newdimen\tableindent \tableindent=.8in % default indentation of @itemize and @enumerate text \newdimen\itemindent \itemindent=.3in % margin between end of table item and start of table text. \newdimen\itemmargin \itemmargin=.1in % used internally for \itemindent minus \itemmargin \newdimen\itemmax % Note @table, @vtable, and @vtable define @item, @itemx, etc., with % these defs. % They also define \itemindex % to index the item name in whatever manner is desired (perhaps none). \newif\ifitemxneedsnegativevskip \def\itemxpar{\par\ifitemxneedsnegativevskip\nobreak\vskip-\parskip\nobreak\fi} \def\internalBitem{\smallbreak \parsearg\itemzzz} \def\internalBitemx{\itemxpar \parsearg\itemzzz} \def\internalBxitem "#1"{\def\xitemsubtopix{#1} \smallbreak \parsearg\xitemzzz} \def\internalBxitemx "#1"{\def\xitemsubtopix{#1} \itemxpar \parsearg\xitemzzz} \def\internalBkitem{\smallbreak \parsearg\kitemzzz} \def\internalBkitemx{\itemxpar \parsearg\kitemzzz} \def\kitemzzz #1{\dosubind {kw}{\code{#1}}{for {\bf \lastfunction}}% \itemzzz {#1}} \def\xitemzzz #1{\dosubind {kw}{\code{#1}}{for {\bf \xitemsubtopic}}% \itemzzz {#1}} \def\itemzzz #1{\begingroup % \advance\hsize by -\rightskip \advance\hsize by -\tableindent \setbox0=\hbox{\itemfont{#1}}% \itemindex{#1}% \nobreak % This prevents a break before @itemx. % % Be sure we are not still in the middle of a paragraph. %{\parskip = 0in %\par %}% % % If the item text does not fit in the space we have, put it on a line % by itself, and do not allow a page break either before or after that % line. We do not start a paragraph here because then if the next % command is, e.g., @kindex, the whatsit would get put into the % horizontal list on a line by itself, resulting in extra blank space. \ifdim \wd0>\itemmax % % Make this a paragraph so we get the \parskip glue and wrapping, % but leave it ragged-right. \begingroup \advance\leftskip by-\tableindent \advance\hsize by\tableindent \advance\rightskip by0pt plus1fil \leavevmode\unhbox0\par \endgroup % % We're going to be starting a paragraph, but we don't want the % \parskip glue -- logically it's part of the @item we just started. \nobreak \vskip-\parskip % % Stop a page break at the \parskip glue coming up. Unfortunately % we can't prevent a possible page break at the following % \baselineskip glue. \nobreak \endgroup \itemxneedsnegativevskipfalse \else % The item text fits into the space. Start a paragraph, so that the % following text (if any) will end up on the same line. Since that % text will be indented by \tableindent, we make the item text be in % a zero-width box. \noindent \rlap{\hskip -\tableindent\box0}\ignorespaces% \endgroup% \itemxneedsnegativevskiptrue% \fi } \def\item{\errmessage{@item while not in a table}} \def\itemx{\errmessage{@itemx while not in a table}} \def\kitem{\errmessage{@kitem while not in a table}} \def\kitemx{\errmessage{@kitemx while not in a table}} \def\xitem{\errmessage{@xitem while not in a table}} \def\xitemx{\errmessage{@xitemx while not in a table}} %% Contains a kludge to get @end[description] to work \def\description{\tablez{\dontindex}{1}{}{}{}{}} \def\table{\begingroup\inENV\obeylines\obeyspaces\tablex} {\obeylines\obeyspaces% \gdef\tablex #1^^M{% \tabley\dontindex#1 \endtabley}} \def\ftable{\begingroup\inENV\obeylines\obeyspaces\ftablex} {\obeylines\obeyspaces% \gdef\ftablex #1^^M{% \tabley\fnitemindex#1 \endtabley \def\Eftable{\endgraf\afterenvbreak\endgroup}% \let\Etable=\relax}} \def\vtable{\begingroup\inENV\obeylines\obeyspaces\vtablex} {\obeylines\obeyspaces% \gdef\vtablex #1^^M{% \tabley\vritemindex#1 \endtabley \def\Evtable{\endgraf\afterenvbreak\endgroup}% \let\Etable=\relax}} \def\dontindex #1{} \def\fnitemindex #1{\doind {fn}{\code{#1}}}% \def\vritemindex #1{\doind {vr}{\code{#1}}}% {\obeyspaces % \gdef\tabley#1#2 #3 #4 #5 #6 #7\endtabley{\endgroup% \tablez{#1}{#2}{#3}{#4}{#5}{#6}}} \def\tablez #1#2#3#4#5#6{% \aboveenvbreak % \begingroup % \def\Edescription{\Etable}% Necessary kludge. \let\itemindex=#1% \ifnum 0#3>0 \advance \leftskip by #3\mil \fi % \ifnum 0#4>0 \tableindent=#4\mil \fi % \ifnum 0#5>0 \advance \rightskip by #5\mil \fi % \def\itemfont{#2}% \itemmax=\tableindent % \advance \itemmax by -\itemmargin % \advance \leftskip by \tableindent % \exdentamount=\tableindent \parindent = 0pt \parskip = \smallskipamount \ifdim \parskip=0pt \parskip=2pt \fi% \def\Etable{\endgraf\afterenvbreak\endgroup}% \let\item = \internalBitem % \let\itemx = \internalBitemx % \let\kitem = \internalBkitem % \let\kitemx = \internalBkitemx % \let\xitem = \internalBxitem % \let\xitemx = \internalBxitemx % } % This is the counter used by @enumerate, which is really @itemize \newcount \itemno \def\itemize{\parsearg\itemizezzz} \def\itemizezzz #1{% \begingroup % ended by the @end itemsize \itemizey {#1}{\Eitemize} } \def\itemizey #1#2{% \aboveenvbreak % \itemmax=\itemindent % \advance \itemmax by -\itemmargin % \advance \leftskip by \itemindent % \exdentamount=\itemindent \parindent = 0pt % \parskip = \smallskipamount % \ifdim \parskip=0pt \parskip=2pt \fi% \def#2{\endgraf\afterenvbreak\endgroup}% \def\itemcontents{#1}% \let\item=\itemizeitem} % Set sfcode to normal for the chars that usually have another value. % These are `.?!:;,' \def\frenchspacing{\sfcode46=1000 \sfcode63=1000 \sfcode33=1000 \sfcode58=1000 \sfcode59=1000 \sfcode44=1000 } % \splitoff TOKENS\endmark defines \first to be the first token in % TOKENS, and \rest to be the remainder. % \def\splitoff#1#2\endmark{\def\first{#1}\def\rest{#2}}% % Allow an optional argument of an uppercase letter, lowercase letter, % or number, to specify the first label in the enumerated list. No % argument is the same as `1'. % \def\enumerate{\parsearg\enumeratezzz} \def\enumeratezzz #1{\enumeratey #1 \endenumeratey} \def\enumeratey #1 #2\endenumeratey{% \begingroup % ended by the @end enumerate % % If we were given no argument, pretend we were given `1'. \def\thearg{#1}% \ifx\thearg\empty \def\thearg{1}\fi % % Detect if the argument is a single token. If so, it might be a % letter. Otherwise, the only valid thing it can be is a number. % (We will always have one token, because of the test we just made. % This is a good thing, since \splitoff doesn't work given nothing at % all -- the first parameter is undelimited.) \expandafter\splitoff\thearg\endmark \ifx\rest\empty % Only one token in the argument. It could still be anything. % A ``lowercase letter'' is one whose \lccode is nonzero. % An ``uppercase letter'' is one whose \lccode is both nonzero, and % not equal to itself. % Otherwise, we assume it's a number. % % We need the \relax at the end of the \ifnum lines to stop TeX from % continuing to look for a . % \ifnum\lccode\expandafter`\thearg=0\relax \numericenumerate % a number (we hope) \else % It's a letter. \ifnum\lccode\expandafter`\thearg=\expandafter`\thearg\relax \lowercaseenumerate % lowercase letter \else \uppercaseenumerate % uppercase letter \fi \fi \else % Multiple tokens in the argument. We hope it's a number. \numericenumerate \fi } % An @enumerate whose labels are integers. The starting integer is % given in \thearg. % \def\numericenumerate{% \itemno = \thearg \startenumeration{\the\itemno}% } % The starting (lowercase) letter is in \thearg. \def\lowercaseenumerate{% \itemno = \expandafter`\thearg \startenumeration{% % Be sure we're not beyond the end of the alphabet. \ifnum\itemno=0 \errmessage{No more lowercase letters in @enumerate; get a bigger alphabet}% \fi \char\lccode\itemno }% } % The starting (uppercase) letter is in \thearg. \def\uppercaseenumerate{% \itemno = \expandafter`\thearg \startenumeration{% % Be sure we're not beyond the end of the alphabet. \ifnum\itemno=0 \errmessage{No more uppercase letters in @enumerate; get a bigger alphabet} \fi \char\uccode\itemno }% } % Call itemizey, adding a period to the first argument and supplying the % common last two arguments. Also subtract one from the initial value in % \itemno, since @item increments \itemno. % \def\startenumeration#1{% \advance\itemno by -1 \itemizey{#1.}\Eenumerate\flushcr } % @alphaenumerate and @capsenumerate are abbreviations for giving an arg % to @enumerate. % \def\alphaenumerate{\enumerate{a}} \def\capsenumerate{\enumerate{A}} \def\Ealphaenumerate{\Eenumerate} \def\Ecapsenumerate{\Eenumerate} % Definition of @item while inside @itemize. \def\itemizeitem{% \advance\itemno by 1 {\let\par=\endgraf \smallbreak}% \ifhmode \errmessage{In hmode at itemizeitem}\fi {\parskip=0in \hskip 0pt \hbox to 0pt{\hss \itemcontents\hskip \itemmargin}% \vadjust{\penalty 1200}}% \flushcr} % @multitable macros % Amy Hendrickson, 8/18/94, 3/6/96 % % @multitable ... @end multitable will make as many columns as desired. % Contents of each column will wrap at width given in preamble. Width % can be specified either with sample text given in a template line, % or in percent of \hsize, the current width of text on page. % Table can continue over pages but will only break between lines. % To make preamble: % % Either define widths of columns in terms of percent of \hsize: % @multitable @columnfractions .25 .3 .45 % @item ... % % Numbers following @columnfractions are the percent of the total % current hsize to be used for each column. You may use as many % columns as desired. % Or use a template: % @multitable {Column 1 template} {Column 2 template} {Column 3 template} % @item ... % using the widest term desired in each column. % % For those who want to use more than one line's worth of words in % the preamble, break the line within one argument and it % will parse correctly, i.e., % % @multitable {Column 1 template} {Column 2 template} {Column 3 % template} % Not: % @multitable {Column 1 template} {Column 2 template} % {Column 3 template} % Each new table line starts with @item, each subsequent new column % starts with @tab. Empty columns may be produced by supplying @tab's % with nothing between them for as many times as empty columns are needed, % ie, @tab@tab@tab will produce two empty columns. % @item, @tab, @multitable or @end multitable do not need to be on their % own lines, but it will not hurt if they are. % Sample multitable: % @multitable {Column 1 template} {Column 2 template} {Column 3 template} % @item first col stuff @tab second col stuff @tab third col % @item % first col stuff % @tab % second col stuff % @tab % third col % @item first col stuff @tab second col stuff % @tab Many paragraphs of text may be used in any column. % % They will wrap at the width determined by the template. % @item@tab@tab This will be in third column. % @end multitable % Default dimensions may be reset by user. % @multitableparskip is vertical space between paragraphs in table. % @multitableparindent is paragraph indent in table. % @multitablecolmargin is horizontal space to be left between columns. % @multitablelinespace is space to leave between table items, baseline % to baseline. % 0pt means it depends on current normal line spacing. %%%% % Dimensions \newskip\multitableparskip \newskip\multitableparindent \newdimen\multitablecolspace \newskip\multitablelinespace \multitableparskip=0pt \multitableparindent=6pt \multitablecolspace=12pt \multitablelinespace=0pt %%%% % Macros used to set up halign preamble: \let\endsetuptable\relax \def\xendsetuptable{\endsetuptable} \let\columnfractions\relax \def\xcolumnfractions{\columnfractions} \newif\ifsetpercent %% 2/1/96, to allow fractions to be given with more than one digit. \def\pickupwholefraction#1 {\global\advance\colcount by1 % \expandafter\xdef\csname col\the\colcount\endcsname{.#1\hsize}% \setuptable} \newcount\colcount \def\setuptable#1{\def\firstarg{#1}% \ifx\firstarg\xendsetuptable\let\go\relax% \else \ifx\firstarg\xcolumnfractions\global\setpercenttrue% \else \ifsetpercent \let\go\pickupwholefraction % In this case arg of setuptable % is the decimal point before the % number given in percent of hsize. % We don't need this so we don't use it. \else \global\advance\colcount by1 \setbox0=\hbox{#1 }% Add a normal word space as a separator; % typically that is always in the input, anyway. \expandafter\xdef\csname col\the\colcount\endcsname{\the\wd0}% \fi% \fi% \ifx\go\pickupwholefraction\else\let\go\setuptable\fi% \fi\go} %%%% % multitable syntax \def\tab{&\hskip1sp\relax} % 2/2/96 % tiny skip here makes sure this column space is % maintained, even if it is never used. %%%% % @multitable ... @end multitable definitions: \def\multitable{\parsearg\dotable} \def\dotable#1{\bgroup \let\item\cr \tolerance=9500 \hbadness=9500 \setmultitablespacing \parskip=\multitableparskip \parindent=\multitableparindent \overfullrule=0pt \global\colcount=0\relax% \def\Emultitable{\global\setpercentfalse\global\everycr{}\cr\egroup\egroup}% % To parse everything between @multitable and @item : \setuptable#1 \endsetuptable % Need to reset this to 0 after \setuptable. \global\colcount=0\relax% % % This preamble sets up a generic column definition, which will % be used as many times as user calls for columns. % \vtop will set a single line and will also let text wrap and % continue for many paragraphs if desired. \halign\bgroup&\global\advance\colcount by 1\relax% \multistrut\vtop{\hsize=\expandafter\csname col\the\colcount\endcsname % In order to keep entries from bumping into each other % we will add a \leftskip of \multitablecolspace to all columns after % the first one. % If a template has been used, we will add \multitablecolspace % to the width of each template entry. % If user has set preamble in terms of percent of \hsize % we will use that dimension as the width of the column, and % the \leftskip will keep entries from bumping into each other. % Table will start at left margin and final column will justify at % right margin. \ifnum\colcount=1 \else \ifsetpercent \else % If user has set preamble in terms of percent of \hsize % we will advance \hsize by \multitablecolspace \advance\hsize by \multitablecolspace \fi % In either case we will make \leftskip=\multitablecolspace: \leftskip=\multitablecolspace \fi % Ignoring space at the beginning and end avoids an occasional spurious % blank line, when TeX decides to break the line at the space before the % box from the multistrut, so the strut ends up on a line by itself. % For example: % @multitable @columnfractions .11 .89 % @item @code{#} % @tab Legal holiday which is valid in major parts of the whole country. % Is automatically provided with highlighting sequences respectively marking % characters. \noindent\ignorespaces##\unskip\multistrut}\cr % \everycr will reset column counter, \colcount, at the end of % each line. Every column entry will cause \colcount to advance by one. % The table preamble % looks at the current \colcount to find the correct column width. \global\everycr{\noalign{% % \filbreak%% keeps underfull box messages off when table breaks over pages. % Maybe so, but it also creates really weird page breaks when the table % breaks over pages Wouldn't \vfil be better? Wait until the problem % manifests itself, so it can be fixed for real --karl. \global\colcount=0\relax}} } \def\setmultitablespacing{% test to see if user has set \multitablelinespace. % If so, do nothing. If not, give it an appropriate dimension based on % current baselineskip. \ifdim\multitablelinespace=0pt %% strut to put in table in case some entry doesn't have descenders, %% to keep lines equally spaced \let\multistrut = \strut %% Test to see if parskip is larger than space between lines of %% table. If not, do nothing. %% If so, set to same dimension as multitablelinespace. \else \gdef\multistrut{\vrule height\multitablelinespace depth\dp0 width0pt\relax} \fi \ifdim\multitableparskip>\multitablelinespace \global\multitableparskip=\multitablelinespace \global\advance\multitableparskip-7pt %% to keep parskip somewhat smaller %% than skip between lines in the table. \fi% \ifdim\multitableparskip=0pt \global\multitableparskip=\multitablelinespace \global\advance\multitableparskip-7pt %% to keep parskip somewhat smaller %% than skip between lines in the table. \fi} \message{indexing,} % Index generation facilities % Define \newwrite to be identical to plain tex's \newwrite % except not \outer, so it can be used within \newindex. {\catcode`\@=11 \gdef\newwrite{\alloc@7\write\chardef\sixt@@n}} % \newindex {foo} defines an index named foo. % It automatically defines \fooindex such that % \fooindex ...rest of line... puts an entry in the index foo. % It also defines \fooindfile to be the number of the output channel for % the file that accumulates this index. The file's extension is foo. % The name of an index should be no more than 2 characters long % for the sake of vms. \def\newindex #1{ \expandafter\newwrite \csname#1indfile\endcsname% Define number for output file \openout \csname#1indfile\endcsname \jobname.#1 % Open the file \expandafter\xdef\csname#1index\endcsname{% % Define \xxxindex \noexpand\doindex {#1}} } % @defindex foo == \newindex{foo} \def\defindex{\parsearg\newindex} % Define @defcodeindex, like @defindex except put all entries in @code. \def\newcodeindex #1{ \expandafter\newwrite \csname#1indfile\endcsname% Define number for output file \openout \csname#1indfile\endcsname \jobname.#1 % Open the file \expandafter\xdef\csname#1index\endcsname{% % Define \xxxindex \noexpand\docodeindex {#1}} } \def\defcodeindex{\parsearg\newcodeindex} % @synindex foo bar makes index foo feed into index bar. % Do this instead of @defindex foo if you don't want it as a separate index. \def\synindex #1 #2 {% \expandafter\let\expandafter\synindexfoo\expandafter=\csname#2indfile\endcsname \expandafter\let\csname#1indfile\endcsname=\synindexfoo \expandafter\xdef\csname#1index\endcsname{% % Define \xxxindex \noexpand\doindex {#2}}% } % @syncodeindex foo bar similar, but put all entries made for index foo % inside @code. \def\syncodeindex #1 #2 {% \expandafter\let\expandafter\synindexfoo\expandafter=\csname#2indfile\endcsname \expandafter\let\csname#1indfile\endcsname=\synindexfoo \expandafter\xdef\csname#1index\endcsname{% % Define \xxxindex \noexpand\docodeindex {#2}}% } % Define \doindex, the driver for all \fooindex macros. % Argument #1 is generated by the calling \fooindex macro, % and it is "foo", the name of the index. % \doindex just uses \parsearg; it calls \doind for the actual work. % This is because \doind is more useful to call from other macros. % There is also \dosubind {index}{topic}{subtopic} % which makes an entry in a two-level index such as the operation index. \def\doindex#1{\edef\indexname{#1}\parsearg\singleindexer} \def\singleindexer #1{\doind{\indexname}{#1}} % like the previous two, but they put @code around the argument. \def\docodeindex#1{\edef\indexname{#1}\parsearg\singlecodeindexer} \def\singlecodeindexer #1{\doind{\indexname}{\code{#1}}} \def\indexdummies{% % Take care of the plain tex accent commands. \def\"{\realbackslash "}% \def\`{\realbackslash `}% \def\'{\realbackslash '}% \def\^{\realbackslash ^}% \def\~{\realbackslash ~}% \def\={\realbackslash =}% \def\b{\realbackslash b}% \def\c{\realbackslash c}% \def\d{\realbackslash d}% \def\u{\realbackslash u}% \def\v{\realbackslash v}% \def\H{\realbackslash H}% % Take care of the plain tex special European modified letters. \def\oe{\realbackslash oe}% \def\ae{\realbackslash ae}% \def\aa{\realbackslash aa}% \def\OE{\realbackslash OE}% \def\AE{\realbackslash AE}% \def\AA{\realbackslash AA}% \def\o{\realbackslash o}% \def\O{\realbackslash O}% \def\l{\realbackslash l}% \def\L{\realbackslash L}% \def\ss{\realbackslash ss}% % Take care of texinfo commands likely to appear in an index entry. % (Must be a way to avoid doing expansion at all, and thus not have to % laboriously list every single command here.) \def\@{@}% will be @@ when we switch to @ as escape char. %\let\{ = \lbracecmd %\let\} = \rbracecmd \def\_{{\realbackslash _}}% \def\w{\realbackslash w }% \def\bf{\realbackslash bf }% %\def\rm{\realbackslash rm }% \def\sl{\realbackslash sl }% \def\sf{\realbackslash sf}% \def\tt{\realbackslash tt}% \def\gtr{\realbackslash gtr}% \def\less{\realbackslash less}% \def\hat{\realbackslash hat}% %\def\char{\realbackslash char}% \def\TeX{\realbackslash TeX}% \def\dots{\realbackslash dots }% \def\result{\realbackslash result}% \def\equiv{\realbackslash equiv}% \def\expansion{\realbackslash expansion}% \def\print{\realbackslash print}% \def\error{\realbackslash error}% \def\point{\realbackslash point}% \def\copyright{\realbackslash copyright}% \def\tclose##1{\realbackslash tclose {##1}}% \def\code##1{\realbackslash code {##1}}% \def\dotless##1{\realbackslash dotless {##1}}% \def\samp##1{\realbackslash samp {##1}}% \def\,##1{\realbackslash ,{##1}}% \def\t##1{\realbackslash t {##1}}% \def\r##1{\realbackslash r {##1}}% \def\i##1{\realbackslash i {##1}}% \def\b##1{\realbackslash b {##1}}% \def\sc##1{\realbackslash sc {##1}}% \def\cite##1{\realbackslash cite {##1}}% \def\key##1{\realbackslash key {##1}}% \def\file##1{\realbackslash file {##1}}% \def\var##1{\realbackslash var {##1}}% \def\kbd##1{\realbackslash kbd {##1}}% \def\dfn##1{\realbackslash dfn {##1}}% \def\emph##1{\realbackslash emph {##1}}% \def\value##1{\realbackslash value {##1}}% \unsepspaces } % If an index command is used in an @example environment, any spaces % therein should become regular spaces in the raw index file, not the % expansion of \tie (\\leavevmode \penalty \@M \ ). {\obeyspaces \gdef\unsepspaces{\obeyspaces\let =\space}} % \indexnofonts no-ops all font-change commands. % This is used when outputting the strings to sort the index by. \def\indexdummyfont#1{#1} \def\indexdummytex{TeX} \def\indexdummydots{...} \def\indexnofonts{% % Just ignore accents. \let\,=\indexdummyfont \let\"=\indexdummyfont \let\`=\indexdummyfont \let\'=\indexdummyfont \let\^=\indexdummyfont \let\~=\indexdummyfont \let\==\indexdummyfont \let\b=\indexdummyfont \let\c=\indexdummyfont \let\d=\indexdummyfont \let\u=\indexdummyfont \let\v=\indexdummyfont \let\H=\indexdummyfont \let\dotless=\indexdummyfont % Take care of the plain tex special European modified letters. \def\oe{oe}% \def\ae{ae}% \def\aa{aa}% \def\OE{OE}% \def\AE{AE}% \def\AA{AA}% \def\o{o}% \def\O{O}% \def\l{l}% \def\L{L}% \def\ss{ss}% \let\w=\indexdummyfont \let\t=\indexdummyfont \let\r=\indexdummyfont \let\i=\indexdummyfont \let\b=\indexdummyfont \let\emph=\indexdummyfont \let\strong=\indexdummyfont \let\cite=\indexdummyfont \let\sc=\indexdummyfont %Don't no-op \tt, since it isn't a user-level command % and is used in the definitions of the active chars like <, >, |... %\let\tt=\indexdummyfont \let\tclose=\indexdummyfont \let\code=\indexdummyfont \let\file=\indexdummyfont \let\samp=\indexdummyfont \let\kbd=\indexdummyfont \let\key=\indexdummyfont \let\var=\indexdummyfont \let\TeX=\indexdummytex \let\dots=\indexdummydots \def\@{@}% } % To define \realbackslash, we must make \ not be an escape. % We must first make another character (@) an escape % so we do not become unable to do a definition. {\catcode`\@=0 \catcode`\\=\other @gdef@realbackslash{\}} \let\indexbackslash=0 %overridden during \printindex. \let\SETmarginindex=\relax %initialize! % workhorse for all \fooindexes % #1 is name of index, #2 is stuff to put there \def\doind #1#2{% % Put the index entry in the margin if desired. \ifx\SETmarginindex\relax\else \insert\margin{\hbox{\vrule height8pt depth3pt width0pt #2}}% \fi {% \count255=\lastpenalty {% \indexdummies % Must do this here, since \bf, etc expand at this stage \escapechar=`\\ {% \let\folio=0% We will expand all macros now EXCEPT \folio. \def\rawbackslashxx{\indexbackslash}% \indexbackslash isn't defined now % so it will be output as is; and it will print as backslash. % % First process the index-string with all font commands turned off % to get the string to sort by. {\indexnofonts \xdef\indexsorttmp{#2}}% % % Now produce the complete index entry, with both the sort key and the % original text, including any font commands. \toks0 = {#2}% \edef\temp{% \write\csname#1indfile\endcsname{% \realbackslash entry{\indexsorttmp}{\folio}{\the\toks0}}% }% \temp }% }% \penalty\count255 }% } \def\dosubind #1#2#3{% {\count10=\lastpenalty % {\indexdummies % Must do this here, since \bf, etc expand at this stage \escapechar=`\\% {\let\folio=0% \def\rawbackslashxx{\indexbackslash}% % % Now process the index-string once, with all font commands turned off, % to get the string to sort the index by. {\indexnofonts \xdef\temp1{#2 #3}% }% % Now produce the complete index entry. We process the index-string again, % this time with font commands expanded, to get what to print in the index. \edef\temp{% \write \csname#1indfile\endcsname{% \realbackslash entry {\temp1}{\folio}{#2}{#3}}}% \temp }% }\penalty\count10}} % The index entry written in the file actually looks like % \entry {sortstring}{page}{topic} % or % \entry {sortstring}{page}{topic}{subtopic} % The texindex program reads in these files and writes files % containing these kinds of lines: % \initial {c} % before the first topic whose initial is c % \entry {topic}{pagelist} % for a topic that is used without subtopics % \primary {topic} % for the beginning of a topic that is used with subtopics % \secondary {subtopic}{pagelist} % for each subtopic. % Define the user-accessible indexing commands % @findex, @vindex, @kindex, @cindex. \def\findex {\fnindex} \def\kindex {\kyindex} \def\cindex {\cpindex} \def\vindex {\vrindex} \def\tindex {\tpindex} \def\pindex {\pgindex} \def\cindexsub {\begingroup\obeylines\cindexsub} {\obeylines % \gdef\cindexsub "#1" #2^^M{\endgroup % \dosubind{cp}{#2}{#1}}} % Define the macros used in formatting output of the sorted index material. % @printindex causes a particular index (the ??s file) to get printed. % It does not print any chapter heading (usually an @unnumbered). % \def\printindex{\parsearg\doprintindex} \def\doprintindex#1{\begingroup \dobreak \chapheadingskip{10000}% % \indexfonts \rm \tolerance = 9500 \indexbreaks % % See if the index file exists and is nonempty. \openin 1 \jobname.#1s \ifeof 1 % \enddoublecolumns gets confused if there is no text in the index, % and it loses the chapter title and the aux file entries for the % index. The easiest way to prevent this problem is to make sure % there is some text. (Index is nonexistent) \else % % If the index file exists but is empty, then \openin leaves \ifeof % false. We have to make TeX try to read something from the file, so % it can discover if there is anything in it. \read 1 to \temp \ifeof 1 (Index is empty) \else % Index files are almost Texinfo source, but we use \ as the escape % character. It would be better to use @, but that's too big a change % to make right now. \def\indexbackslash{\rawbackslashxx}% \catcode`\\ = 0 \catcode`\@ = 11 \escapechar = `\\ \begindoublecolumns \input \jobname.#1s \enddoublecolumns \fi \fi \closein 1 \endgroup} % These macros are used by the sorted index file itself. % Change them to control the appearance of the index. % Same as \bigskipamount except no shrink. % \balancecolumns gets confused if there is any shrink. \newskip\initialskipamount \initialskipamount 12pt plus4pt \def\initial #1{% {\let\tentt=\sectt \let\tt=\sectt \let\sf=\sectt \ifdim\lastskip<\initialskipamount \removelastskip \penalty-200 \vskip \initialskipamount\fi \line{\secbf#1\hfill}\kern 2pt\penalty10000}} % This typesets a paragraph consisting of #1, dot leaders, and then #2 % flush to the right margin. It is used for index and table of contents % entries. The paragraph is indented by \leftskip. % \def\entry #1#2{\begingroup % % Start a new paragraph if necessary, so our assignments below can't % affect previous text. \par % % Do not fill out the last line with white space. \parfillskip = 0in % % No extra space above this paragraph. \parskip = 0in % % Do not prefer a separate line ending with a hyphen to fewer lines. \finalhyphendemerits = 0 % % \hangindent is only relevant when the entry text and page number % don't both fit on one line. In that case, bob suggests starting the % dots pretty far over on the line. Unfortunately, a large % indentation looks wrong when the entry text itself is broken across % lines. So we use a small indentation and put up with long leaders. % % \hangafter is reset to 1 (which is the value we want) at the start % of each paragraph, so we need not do anything with that. \hangindent=2em % % When the entry text needs to be broken, just fill out the first line % with blank space. \rightskip = 0pt plus1fil % % Start a ``paragraph'' for the index entry so the line breaking % parameters we've set above will have an effect. \noindent % % Insert the text of the index entry. TeX will do line-breaking on it. #1% % The following is kludged to not output a line of dots in the index if % there are no page numbers. The next person who breaks this will be % cursed by a Unix daemon. \def\tempa{{\rm }}% \def\tempb{#2}% \edef\tempc{\tempa}% \edef\tempd{\tempb}% \ifx\tempc\tempd\ \else% % % If we must, put the page number on a line of its own, and fill out % this line with blank space. (The \hfil is overwhelmed with the % fill leaders glue in \indexdotfill if the page number does fit.) \hfil\penalty50 \null\nobreak\indexdotfill % Have leaders before the page number. % % The `\ ' here is removed by the implicit \unskip that TeX does as % part of (the primitive) \par. Without it, a spurious underfull % \hbox ensues. \ #2% The page number ends the paragraph. \fi% \par \endgroup} % Like \dotfill except takes at least 1 em. \def\indexdotfill{\cleaders \hbox{$\mathsurround=0pt \mkern1.5mu ${\it .}$ \mkern1.5mu$}\hskip 1em plus 1fill} \def\primary #1{\line{#1\hfil}} \newskip\secondaryindent \secondaryindent=0.5cm \def\secondary #1#2{ {\parfillskip=0in \parskip=0in \hangindent =1in \hangafter=1 \noindent\hskip\secondaryindent\hbox{#1}\indexdotfill #2\par }} % Define two-column mode, which we use to typeset indexes. % Adapted from the TeXbook, page 416, which is to say, % the manmac.tex format used to print the TeXbook itself. \catcode`\@=11 \newbox\partialpage \newdimen\doublecolumnhsize \def\begindoublecolumns{\begingroup % ended by \enddoublecolumns % Grab any single-column material above us. \output = {\global\setbox\partialpage = \vbox{% % % Here is a possibility not foreseen in manmac: if we accumulate a % whole lot of material, we might end up calling this \output % routine twice in a row (see the doublecol-lose test, which is % essentially a couple of indexes with @setchapternewpage off). In % that case, we must prevent the second \partialpage from % simply overwriting the first, causing us to lose the page. % This will preserve it until a real output routine can ship it % out. Generally, \partialpage will be empty when this runs and % this will be a no-op. \unvbox\partialpage % % Unvbox the main output page. \unvbox255 \kern-\topskip \kern\baselineskip }}% \eject % % Use the double-column output routine for subsequent pages. \output = {\doublecolumnout}% % % Change the page size parameters. We could do this once outside this % routine, in each of @smallbook, @afourpaper, and the default 8.5x11 % format, but then we repeat the same computation. Repeating a couple % of assignments once per index is clearly meaningless for the % execution time, so we may as well do it in one place. % % First we halve the line length, less a little for the gutter between % the columns. We compute the gutter based on the line length, so it % changes automatically with the paper format. The magic constant % below is chosen so that the gutter has the same value (well, +-<1pt) % as it did when we hard-coded it. % % We put the result in a separate register, \doublecolumhsize, so we % can restore it in \pagesofar, after \hsize itself has (potentially) % been clobbered. % \doublecolumnhsize = \hsize \advance\doublecolumnhsize by -.04154\hsize \divide\doublecolumnhsize by 2 \hsize = \doublecolumnhsize % % Double the \vsize as well. (We don't need a separate register here, % since nobody clobbers \vsize.) \vsize = 2\vsize } \def\doublecolumnout{% \splittopskip=\topskip \splitmaxdepth=\maxdepth % Get the available space for the double columns -- the normal % (undoubled) page height minus any material left over from the % previous page. \dimen@=\pageheight \advance\dimen@ by-\ht\partialpage % box0 will be the left-hand column, box2 the right. \setbox0=\vsplit255 to\dimen@ \setbox2=\vsplit255 to\dimen@ \onepageout\pagesofar \unvbox255 \penalty\outputpenalty } \def\pagesofar{% % Re-output the contents of the output page -- any previous material, % followed by the two boxes we just split. \unvbox\partialpage \hsize = \doublecolumnhsize \wd0=\hsize \wd2=\hsize \hbox to\pagewidth{\box0\hfil\box2}% } \def\enddoublecolumns{% \output = {\balancecolumns}\eject % split what we have \endgroup % started in \begindoublecolumns % % Back to normal single-column typesetting, but take account of the % fact that we just accumulated some stuff on the output page. \pagegoal = \vsize } \def\balancecolumns{% % Called at the end of the double column material. \setbox0 = \vbox{\unvbox255}% \dimen@ = \ht0 \advance\dimen@ by \topskip \advance\dimen@ by-\baselineskip \divide\dimen@ by 2 \splittopskip = \topskip % Loop until we get a decent breakpoint. {\vbadness=10000 \loop \global\setbox3=\copy0 \global\setbox1=\vsplit3 to\dimen@ \ifdim\ht3>\dimen@ \global\advance\dimen@ by1pt \repeat}% \setbox0=\vbox to\dimen@{\unvbox1}% \setbox2=\vbox to\dimen@{\unvbox3}% \pagesofar } \catcode`\@ = \other \message{sectioning,} % Define chapters, sections, etc. \newcount\chapno \newcount\secno \secno=0 \newcount\subsecno \subsecno=0 \newcount\subsubsecno \subsubsecno=0 % This counter is funny since it counts through charcodes of letters A, B, ... \newcount\appendixno \appendixno = `\@ \def\appendixletter{\char\the\appendixno} \newwrite\contentsfile % This is called from \setfilename. \def\opencontents{\openout\contentsfile = \jobname.toc } % Each @chapter defines this as the name of the chapter. % page headings and footings can use it. @section does likewise \def\thischapter{} \def\thissection{} \def\seccheck#1{\ifnum \pageno<0 \errmessage{@#1 not allowed after generating table of contents}% \fi} \def\chapternofonts{% \let\rawbackslash=\relax \let\frenchspacing=\relax \def\result{\realbackslash result}% \def\equiv{\realbackslash equiv}% \def\expansion{\realbackslash expansion}% \def\print{\realbackslash print}% \def\TeX{\realbackslash TeX}% \def\dots{\realbackslash dots}% \def\result{\realbackslash result}% \def\equiv{\realbackslash equiv}% \def\expansion{\realbackslash expansion}% \def\print{\realbackslash print}% \def\error{\realbackslash error}% \def\point{\realbackslash point}% \def\copyright{\realbackslash copyright}% \def\tt{\realbackslash tt}% \def\bf{\realbackslash bf}% \def\w{\realbackslash w}% \def\less{\realbackslash less}% \def\gtr{\realbackslash gtr}% \def\hat{\realbackslash hat}% \def\char{\realbackslash char}% \def\tclose##1{\realbackslash tclose{##1}}% \def\code##1{\realbackslash code{##1}}% \def\samp##1{\realbackslash samp{##1}}% \def\r##1{\realbackslash r{##1}}% \def\b##1{\realbackslash b{##1}}% \def\key##1{\realbackslash key{##1}}% \def\file##1{\realbackslash file{##1}}% \def\kbd##1{\realbackslash kbd{##1}}% % These are redefined because @smartitalic wouldn't work inside xdef. \def\i##1{\realbackslash i{##1}}% \def\cite##1{\realbackslash cite{##1}}% \def\var##1{\realbackslash var{##1}}% \def\emph##1{\realbackslash emph{##1}}% \def\dfn##1{\realbackslash dfn{##1}}% } \newcount\absseclevel % used to calculate proper heading level \newcount\secbase\secbase=0 % @raise/lowersections modify this count % @raisesections: treat @section as chapter, @subsection as section, etc. \def\raisesections{\global\advance\secbase by -1} \let\up=\raisesections % original BFox name % @lowersections: treat @chapter as section, @section as subsection, etc. \def\lowersections{\global\advance\secbase by 1} \let\down=\lowersections % original BFox name % Choose a numbered-heading macro % #1 is heading level if unmodified by @raisesections or @lowersections % #2 is text for heading \def\numhead#1#2{\absseclevel=\secbase\advance\absseclevel by #1 \ifcase\absseclevel \chapterzzz{#2} \or \seczzz{#2} \or \numberedsubseczzz{#2} \or \numberedsubsubseczzz{#2} \else \ifnum \absseclevel<0 \chapterzzz{#2} \else \numberedsubsubseczzz{#2} \fi \fi } % like \numhead, but chooses appendix heading levels \def\apphead#1#2{\absseclevel=\secbase\advance\absseclevel by #1 \ifcase\absseclevel \appendixzzz{#2} \or \appendixsectionzzz{#2} \or \appendixsubseczzz{#2} \or \appendixsubsubseczzz{#2} \else \ifnum \absseclevel<0 \appendixzzz{#2} \else \appendixsubsubseczzz{#2} \fi \fi } % like \numhead, but chooses numberless heading levels \def\unnmhead#1#2{\absseclevel=\secbase\advance\absseclevel by #1 \ifcase\absseclevel \unnumberedzzz{#2} \or \unnumberedseczzz{#2} \or \unnumberedsubseczzz{#2} \or \unnumberedsubsubseczzz{#2} \else \ifnum \absseclevel<0 \unnumberedzzz{#2} \else \unnumberedsubsubseczzz{#2} \fi \fi } \def\thischaptername{No Chapter Title} \outer\def\chapter{\parsearg\chapteryyy} \def\chapteryyy #1{\numhead0{#1}} % normally numhead0 calls chapterzzz \def\chapterzzz #1{\seccheck{chapter}% \secno=0 \subsecno=0 \subsubsecno=0 \global\advance \chapno by 1 \message{\putwordChapter \the\chapno}% \chapmacro {#1}{\the\chapno}% \gdef\thissection{#1}% \gdef\thischaptername{#1}% % We don't substitute the actual chapter name into \thischapter % because we don't want its macros evaluated now. \xdef\thischapter{\putwordChapter{} \the\chapno: \noexpand\thischaptername}% {\chapternofonts% \toks0 = {#1}% \edef\temp{{\realbackslash chapentry{\the\toks0}{\the\chapno}{\noexpand\folio}}}% \escapechar=`\\% \write \contentsfile \temp % \donoderef % \global\let\section = \numberedsec \global\let\subsection = \numberedsubsec \global\let\subsubsection = \numberedsubsubsec }} \outer\def\appendix{\parsearg\appendixyyy} \def\appendixyyy #1{\apphead0{#1}} % normally apphead0 calls appendixzzz \def\appendixzzz #1{\seccheck{appendix}% \secno=0 \subsecno=0 \subsubsecno=0 \global\advance \appendixno by 1 \message{Appendix \appendixletter}% \chapmacro {#1}{\putwordAppendix{} \appendixletter}% \gdef\thissection{#1}% \gdef\thischaptername{#1}% \xdef\thischapter{\putwordAppendix{} \appendixletter: \noexpand\thischaptername}% {\chapternofonts% \toks0 = {#1}% \edef\temp{{\realbackslash chapentry{\the\toks0}% {\putwordAppendix{} \appendixletter}{\noexpand\folio}}}% \escapechar=`\\% \write \contentsfile \temp % \appendixnoderef % \global\let\section = \appendixsec \global\let\subsection = \appendixsubsec \global\let\subsubsection = \appendixsubsubsec }} % @centerchap is like @unnumbered, but the heading is centered. \outer\def\centerchap{\parsearg\centerchapyyy} \def\centerchapyyy #1{{\let\unnumbchapmacro=\centerchapmacro \unnumberedyyy{#1}}} \outer\def\top{\parsearg\unnumberedyyy} \outer\def\unnumbered{\parsearg\unnumberedyyy} \def\unnumberedyyy #1{\unnmhead0{#1}} % normally unnmhead0 calls unnumberedzzz \def\unnumberedzzz #1{\seccheck{unnumbered}% \secno=0 \subsecno=0 \subsubsecno=0 % % This used to be simply \message{#1}, but TeX fully expands the % argument to \message. Therefore, if #1 contained @-commands, TeX % expanded them. For example, in `@unnumbered The @cite{Book}', TeX % expanded @cite (which turns out to cause errors because \cite is meant % to be executed, not expanded). % % Anyway, we don't want the fully-expanded definition of @cite to appear % as a result of the \message, we just want `@cite' itself. We use % \the to achieve this: TeX expands \the only once, % simply yielding the contents of the . \toks0 = {#1}\message{(\the\toks0)}% % \unnumbchapmacro {#1}% \gdef\thischapter{#1}\gdef\thissection{#1}% {\chapternofonts% \toks0 = {#1}% \edef\temp{{\realbackslash unnumbchapentry{\the\toks0}{\noexpand\folio}}}% \escapechar=`\\% \write \contentsfile \temp % \unnumbnoderef % \global\let\section = \unnumberedsec \global\let\subsection = \unnumberedsubsec \global\let\subsubsection = \unnumberedsubsubsec }} \outer\def\numberedsec{\parsearg\secyyy} \def\secyyy #1{\numhead1{#1}} % normally calls seczzz \def\seczzz #1{\seccheck{section}% \subsecno=0 \subsubsecno=0 \global\advance \secno by 1 % \gdef\thissection{#1}\secheading {#1}{\the\chapno}{\the\secno}% {\chapternofonts% \toks0 = {#1}% \edef\temp{{\realbackslash secentry % {\the\toks0}{\the\chapno}{\the\secno}{\noexpand\folio}}}% \escapechar=`\\% \write \contentsfile \temp % \donoderef % \penalty 10000 % }} \outer\def\appendixsection{\parsearg\appendixsecyyy} \outer\def\appendixsec{\parsearg\appendixsecyyy} \def\appendixsecyyy #1{\apphead1{#1}} % normally calls appendixsectionzzz \def\appendixsectionzzz #1{\seccheck{appendixsection}% \subsecno=0 \subsubsecno=0 \global\advance \secno by 1 % \gdef\thissection{#1}\secheading {#1}{\appendixletter}{\the\secno}% {\chapternofonts% \toks0 = {#1}% \edef\temp{{\realbackslash secentry % {\the\toks0}{\appendixletter}{\the\secno}{\noexpand\folio}}}% \escapechar=`\\% \write \contentsfile \temp % \appendixnoderef % \penalty 10000 % }} \outer\def\unnumberedsec{\parsearg\unnumberedsecyyy} \def\unnumberedsecyyy #1{\unnmhead1{#1}} % normally calls unnumberedseczzz \def\unnumberedseczzz #1{\seccheck{unnumberedsec}% \plainsecheading {#1}\gdef\thissection{#1}% {\chapternofonts% \toks0 = {#1}% \edef\temp{{\realbackslash unnumbsecentry{\the\toks0}{\noexpand\folio}}}% \escapechar=`\\% \write \contentsfile \temp % \unnumbnoderef % \penalty 10000 % }} \outer\def\numberedsubsec{\parsearg\numberedsubsecyyy} \def\numberedsubsecyyy #1{\numhead2{#1}} % normally calls numberedsubseczzz \def\numberedsubseczzz #1{\seccheck{subsection}% \gdef\thissection{#1}\subsubsecno=0 \global\advance \subsecno by 1 % \subsecheading {#1}{\the\chapno}{\the\secno}{\the\subsecno}% {\chapternofonts% \toks0 = {#1}% \edef\temp{{\realbackslash subsecentry % {\the\toks0}{\the\chapno}{\the\secno}{\the\subsecno}{\noexpand\folio}}}% \escapechar=`\\% \write \contentsfile \temp % \donoderef % \penalty 10000 % }} \outer\def\appendixsubsec{\parsearg\appendixsubsecyyy} \def\appendixsubsecyyy #1{\apphead2{#1}} % normally calls appendixsubseczzz \def\appendixsubseczzz #1{\seccheck{appendixsubsec}% \gdef\thissection{#1}\subsubsecno=0 \global\advance \subsecno by 1 % \subsecheading {#1}{\appendixletter}{\the\secno}{\the\subsecno}% {\chapternofonts% \toks0 = {#1}% \edef\temp{{\realbackslash subsecentry % {\the\toks0}{\appendixletter}{\the\secno}{\the\subsecno}{\noexpand\folio}}}% \escapechar=`\\% \write \contentsfile \temp % \appendixnoderef % \penalty 10000 % }} \outer\def\unnumberedsubsec{\parsearg\unnumberedsubsecyyy} \def\unnumberedsubsecyyy #1{\unnmhead2{#1}} %normally calls unnumberedsubseczzz \def\unnumberedsubseczzz #1{\seccheck{unnumberedsubsec}% \plainsubsecheading {#1}\gdef\thissection{#1}% {\chapternofonts% \toks0 = {#1}% \edef\temp{{\realbackslash unnumbsubsecentry{\the\toks0}{\noexpand\folio}}}% \escapechar=`\\% \write \contentsfile \temp % \unnumbnoderef % \penalty 10000 % }} \outer\def\numberedsubsubsec{\parsearg\numberedsubsubsecyyy} \def\numberedsubsubsecyyy #1{\numhead3{#1}} % normally numberedsubsubseczzz \def\numberedsubsubseczzz #1{\seccheck{subsubsection}% \gdef\thissection{#1}\global\advance \subsubsecno by 1 % \subsubsecheading {#1} {\the\chapno}{\the\secno}{\the\subsecno}{\the\subsubsecno}% {\chapternofonts% \toks0 = {#1}% \edef\temp{{\realbackslash subsubsecentry{\the\toks0} {\the\chapno}{\the\secno}{\the\subsecno}{\the\subsubsecno} {\noexpand\folio}}}% \escapechar=`\\% \write \contentsfile \temp % \donoderef % \penalty 10000 % }} \outer\def\appendixsubsubsec{\parsearg\appendixsubsubsecyyy} \def\appendixsubsubsecyyy #1{\apphead3{#1}} % normally appendixsubsubseczzz \def\appendixsubsubseczzz #1{\seccheck{appendixsubsubsec}% \gdef\thissection{#1}\global\advance \subsubsecno by 1 % \subsubsecheading {#1} {\appendixletter}{\the\secno}{\the\subsecno}{\the\subsubsecno}% {\chapternofonts% \toks0 = {#1}% \edef\temp{{\realbackslash subsubsecentry{\the\toks0}% {\appendixletter} {\the\secno}{\the\subsecno}{\the\subsubsecno}{\noexpand\folio}}}% \escapechar=`\\% \write \contentsfile \temp % \appendixnoderef % \penalty 10000 % }} \outer\def\unnumberedsubsubsec{\parsearg\unnumberedsubsubsecyyy} \def\unnumberedsubsubsecyyy #1{\unnmhead3{#1}} %normally unnumberedsubsubseczzz \def\unnumberedsubsubseczzz #1{\seccheck{unnumberedsubsubsec}% \plainsubsubsecheading {#1}\gdef\thissection{#1}% {\chapternofonts% \toks0 = {#1}% \edef\temp{{\realbackslash unnumbsubsubsecentry{\the\toks0}{\noexpand\folio}}}% \escapechar=`\\% \write \contentsfile \temp % \unnumbnoderef % \penalty 10000 % }} % These are variants which are not "outer", so they can appear in @ifinfo. % Actually, they should now be obsolete; ordinary section commands should work. \def\infotop{\parsearg\unnumberedzzz} \def\infounnumbered{\parsearg\unnumberedzzz} \def\infounnumberedsec{\parsearg\unnumberedseczzz} \def\infounnumberedsubsec{\parsearg\unnumberedsubseczzz} \def\infounnumberedsubsubsec{\parsearg\unnumberedsubsubseczzz} \def\infoappendix{\parsearg\appendixzzz} \def\infoappendixsec{\parsearg\appendixseczzz} \def\infoappendixsubsec{\parsearg\appendixsubseczzz} \def\infoappendixsubsubsec{\parsearg\appendixsubsubseczzz} \def\infochapter{\parsearg\chapterzzz} \def\infosection{\parsearg\sectionzzz} \def\infosubsection{\parsearg\subsectionzzz} \def\infosubsubsection{\parsearg\subsubsectionzzz} % These macros control what the section commands do, according % to what kind of chapter we are in (ordinary, appendix, or unnumbered). % Define them by default for a numbered chapter. \global\let\section = \numberedsec \global\let\subsection = \numberedsubsec \global\let\subsubsection = \numberedsubsubsec % Define @majorheading, @heading and @subheading % NOTE on use of \vbox for chapter headings, section headings, and % such: % 1) We use \vbox rather than the earlier \line to permit % overlong headings to fold. % 2) \hyphenpenalty is set to 10000 because hyphenation in a % heading is obnoxious; this forbids it. % 3) Likewise, headings look best if no \parindent is used, and % if justification is not attempted. Hence \raggedright. \def\majorheading{\parsearg\majorheadingzzz} \def\majorheadingzzz #1{% {\advance\chapheadingskip by 10pt \chapbreak }% {\chapfonts \vbox{\hyphenpenalty=10000\tolerance=5000 \parindent=0pt\raggedright \rm #1\hfill}}\bigskip \par\penalty 200} \def\chapheading{\parsearg\chapheadingzzz} \def\chapheadingzzz #1{\chapbreak % {\chapfonts \vbox{\hyphenpenalty=10000\tolerance=5000 \parindent=0pt\raggedright \rm #1\hfill}}\bigskip \par\penalty 200} % @heading, @subheading, @subsubheading. \def\heading{\parsearg\plainsecheading} \def\subheading{\parsearg\plainsubsecheading} \def\subsubheading{\parsearg\plainsubsubsecheading} % These macros generate a chapter, section, etc. heading only % (including whitespace, linebreaking, etc. around it), % given all the information in convenient, parsed form. %%% Args are the skip and penalty (usually negative) \def\dobreak#1#2{\par\ifdim\lastskip<#1\removelastskip\penalty#2\vskip#1\fi} \def\setchapterstyle #1 {\csname CHAPF#1\endcsname} %%% Define plain chapter starts, and page on/off switching for it % Parameter controlling skip before chapter headings (if needed) \newskip\chapheadingskip \def\chapbreak{\dobreak \chapheadingskip {-4000}} \def\chappager{\par\vfill\supereject} \def\chapoddpage{\chappager \ifodd\pageno \else \hbox to 0pt{} \chappager\fi} \def\setchapternewpage #1 {\csname CHAPPAG#1\endcsname} \def\CHAPPAGoff{ \global\let\contentsalignmacro = \chappager \global\let\pchapsepmacro=\chapbreak \global\let\pagealignmacro=\chappager} \def\CHAPPAGon{ \global\let\contentsalignmacro = \chappager \global\let\pchapsepmacro=\chappager \global\let\pagealignmacro=\chappager \global\def\HEADINGSon{\HEADINGSsingle}} \def\CHAPPAGodd{ \global\let\contentsalignmacro = \chapoddpage \global\let\pchapsepmacro=\chapoddpage \global\let\pagealignmacro=\chapoddpage \global\def\HEADINGSon{\HEADINGSdouble}} \CHAPPAGon \def\CHAPFplain{ \global\let\chapmacro=\chfplain \global\let\unnumbchapmacro=\unnchfplain \global\let\centerchapmacro=\centerchfplain} % Plain chapter opening. % #1 is the text, #2 the chapter number or empty if unnumbered. \def\chfplain#1#2{% \pchapsepmacro {% \chapfonts \rm \def\chapnum{#2}% \setbox0 = \hbox{#2\ifx\chapnum\empty\else\enspace\fi}% \vbox{\hyphenpenalty=10000 \tolerance=5000 \parindent=0pt \raggedright \hangindent = \wd0 \centerparametersmaybe \unhbox0 #1\par}% }% \nobreak\bigskip % no page break after a chapter title \nobreak } % Plain opening for unnumbered. \def\unnchfplain#1{\chfplain{#1}{}} % @centerchap -- centered and unnumbered. \let\centerparametersmaybe = \relax \def\centerchfplain#1{{% \def\centerparametersmaybe{% \advance\rightskip by 3\rightskip \leftskip = \rightskip \parfillskip = 0pt }% \chfplain{#1}{}% }} \CHAPFplain % The default \def\unnchfopen #1{% \chapoddpage {\chapfonts \vbox{\hyphenpenalty=10000\tolerance=5000 \parindent=0pt\raggedright \rm #1\hfill}}\bigskip \par\penalty 10000 % } \def\chfopen #1#2{\chapoddpage {\chapfonts \vbox to 3in{\vfil \hbox to\hsize{\hfil #2} \hbox to\hsize{\hfil #1} \vfil}}% \par\penalty 5000 % } \def\centerchfopen #1{% \chapoddpage {\chapfonts \vbox{\hyphenpenalty=10000\tolerance=5000 \parindent=0pt \hfill {\rm #1}\hfill}}\bigskip \par\penalty 10000 % } \def\CHAPFopen{ \global\let\chapmacro=\chfopen \global\let\unnumbchapmacro=\unnchfopen \global\let\centerchapmacro=\centerchfopen} % Section titles. \newskip\secheadingskip \def\secheadingbreak{\dobreak \secheadingskip {-1000}} \def\secheading#1#2#3{\sectionheading{sec}{#2.#3}{#1}} \def\plainsecheading#1{\sectionheading{sec}{}{#1}} % Subsection titles. \newskip \subsecheadingskip \def\subsecheadingbreak{\dobreak \subsecheadingskip {-500}} \def\subsecheading#1#2#3#4{\sectionheading{subsec}{#2.#3.#4}{#1}} \def\plainsubsecheading#1{\sectionheading{subsec}{}{#1}} % Subsubsection titles. \let\subsubsecheadingskip = \subsecheadingskip \let\subsubsecheadingbreak = \subsecheadingbreak \def\subsubsecheading#1#2#3#4#5{\sectionheading{subsubsec}{#2.#3.#4.#5}{#1}} \def\plainsubsubsecheading#1{\sectionheading{subsubsec}{}{#1}} % Print any size section title. % % #1 is the section type (sec/subsec/subsubsec), #2 is the section % number (maybe empty), #3 the text. \def\sectionheading#1#2#3{% {% \expandafter\advance\csname #1headingskip\endcsname by \parskip \csname #1headingbreak\endcsname }% {% % Switch to the right set of fonts. \csname #1fonts\endcsname \rm % % Only insert the separating space if we have a section number. \def\secnum{#2}% \setbox0 = \hbox{#2\ifx\secnum\empty\else\enspace\fi}% % \vbox{\hyphenpenalty=10000 \tolerance=5000 \parindent=0pt \raggedright \hangindent = \wd0 % zero if no section number \unhbox0 #3}% }% \ifdim\parskip<10pt \nobreak\kern10pt\nobreak\kern-\parskip\fi \nobreak } \message{toc printing,} % Finish up the main text and prepare to read what we've written % to \contentsfile. \newskip\contentsrightmargin \contentsrightmargin=1in \def\startcontents#1{% % If @setchapternewpage on, and @headings double, the contents should % start on an odd page, unlike chapters. Thus, we maintain % \contentsalignmacro in parallel with \pagealignmacro. % From: Torbjorn Granlund \contentsalignmacro \immediate\closeout \contentsfile \ifnum \pageno>0 \pageno = -1 % Request roman numbered pages. \fi % Don't need to put `Contents' or `Short Contents' in the headline. % It is abundantly clear what they are. \unnumbchapmacro{#1}\def\thischapter{}% \begingroup % Set up to handle contents files properly. \catcode`\\=0 \catcode`\{=1 \catcode`\}=2 \catcode`\@=11 % We can't do this, because then an actual ^ in a section % title fails, e.g., @chapter ^ -- exponentiation. --karl, 9jul97. %\catcode`\^=7 % to see ^^e4 as \"a etc. juha@piuha.ydi.vtt.fi \raggedbottom % Worry more about breakpoints than the bottom. \advance\hsize by -\contentsrightmargin % Don't use the full line length. } % Normal (long) toc. \outer\def\contents{% \startcontents{\putwordTableofContents}% \input \jobname.toc \endgroup \vfill \eject } % And just the chapters. \outer\def\summarycontents{% \startcontents{\putwordShortContents}% % \let\chapentry = \shortchapentry \let\unnumbchapentry = \shortunnumberedentry % We want a true roman here for the page numbers. \secfonts \let\rm=\shortcontrm \let\bf=\shortcontbf \let\sl=\shortcontsl \rm \hyphenpenalty = 10000 \advance\baselineskip by 1pt % Open it up a little. \def\secentry ##1##2##3##4{} \def\unnumbsecentry ##1##2{} \def\subsecentry ##1##2##3##4##5{} \def\unnumbsubsecentry ##1##2{} \def\subsubsecentry ##1##2##3##4##5##6{} \def\unnumbsubsubsecentry ##1##2{} \input \jobname.toc \endgroup \vfill \eject } \let\shortcontents = \summarycontents % These macros generate individual entries in the table of contents. % The first argument is the chapter or section name. % The last argument is the page number. % The arguments in between are the chapter number, section number, ... % Chapter-level things, for both the long and short contents. \def\chapentry#1#2#3{\dochapentry{#2\labelspace#1}{#3}} % See comments in \dochapentry re vbox and related settings \def\shortchapentry#1#2#3{% \tocentry{\shortchaplabel{#2}\labelspace #1}{\doshortpageno{#3}}% } % Typeset the label for a chapter or appendix for the short contents. % The arg is, e.g. `Appendix A' for an appendix, or `3' for a chapter. % We could simplify the code here by writing out an \appendixentry % command in the toc file for appendices, instead of using \chapentry % for both, but it doesn't seem worth it. \setbox0 = \hbox{\shortcontrm \putwordAppendix } \newdimen\shortappendixwidth \shortappendixwidth = \wd0 \def\shortchaplabel#1{% % We typeset #1 in a box of constant width, regardless of the text of % #1, so the chapter titles will come out aligned. \setbox0 = \hbox{#1}% \dimen0 = \ifdim\wd0 > \shortappendixwidth \shortappendixwidth \else 0pt \fi % % This space should be plenty, since a single number is .5em, and the % widest letter (M) is 1em, at least in the Computer Modern fonts. % (This space doesn't include the extra space that gets added after % the label; that gets put in by \shortchapentry above.) \advance\dimen0 by 1.1em \hbox to \dimen0{#1\hfil}% } \def\unnumbchapentry#1#2{\dochapentry{#1}{#2}} \def\shortunnumberedentry#1#2{\tocentry{#1}{\doshortpageno{#2}}} % Sections. \def\secentry#1#2#3#4{\dosecentry{#2.#3\labelspace#1}{#4}} \def\unnumbsecentry#1#2{\dosecentry{#1}{#2}} % Subsections. \def\subsecentry#1#2#3#4#5{\dosubsecentry{#2.#3.#4\labelspace#1}{#5}} \def\unnumbsubsecentry#1#2{\dosubsecentry{#1}{#2}} % And subsubsections. \def\subsubsecentry#1#2#3#4#5#6{% \dosubsubsecentry{#2.#3.#4.#5\labelspace#1}{#6}} \def\unnumbsubsubsecentry#1#2{\dosubsubsecentry{#1}{#2}} % This parameter controls the indentation of the various levels. \newdimen\tocindent \tocindent = 3pc % Now for the actual typesetting. In all these, #1 is the text and #2 is the % page number. % % If the toc has to be broken over pages, we want it to be at chapters % if at all possible; hence the \penalty. \def\dochapentry#1#2{% \penalty-300 \vskip1\baselineskip plus.33\baselineskip minus.25\baselineskip \begingroup \chapentryfonts \tocentry{#1}{\dopageno{#2}}% \endgroup \nobreak\vskip .25\baselineskip plus.1\baselineskip } \def\dosecentry#1#2{\begingroup \secentryfonts \leftskip=\tocindent \tocentry{#1}{\dopageno{#2}}% \endgroup} \def\dosubsecentry#1#2{\begingroup \subsecentryfonts \leftskip=2\tocindent \tocentry{#1}{\dopageno{#2}}% \endgroup} \def\dosubsubsecentry#1#2{\begingroup \subsubsecentryfonts \leftskip=3\tocindent \tocentry{#1}{\dopageno{#2}}% \endgroup} % Final typesetting of a toc entry; we use the same \entry macro as for % the index entries, but we want to suppress hyphenation here. (We % can't do that in the \entry macro, since index entries might consist % of hyphenated-identifiers-that-do-not-fit-on-a-line-and-nothing-else.) % % \turnoffactive is for the sake of @" used for umlauts. \def\tocentry#1#2{\begingroup \vskip 0pt plus1pt % allow a little stretch for the sake of nice page breaks \entry{\turnoffactive #1}{\turnoffactive #2}% \endgroup} % Space between chapter (or whatever) number and the title. \def\labelspace{\hskip1em \relax} \def\dopageno#1{{\rm #1}} \def\doshortpageno#1{{\rm #1}} \def\chapentryfonts{\secfonts \rm} \def\secentryfonts{\textfonts} \let\subsecentryfonts = \textfonts \let\subsubsecentryfonts = \textfonts \message{environments,} % Since these characters are used in examples, it should be an even number of % \tt widths. Each \tt character is 1en, so two makes it 1em. % Furthermore, these definitions must come after we define our fonts. \newbox\dblarrowbox \newbox\longdblarrowbox \newbox\pushcharbox \newbox\bullbox \newbox\equivbox \newbox\errorbox %{\tentt %\global\setbox\dblarrowbox = \hbox to 1em{\hfil$\Rightarrow$\hfil} %\global\setbox\longdblarrowbox = \hbox to 1em{\hfil$\mapsto$\hfil} %\global\setbox\pushcharbox = \hbox to 1em{\hfil$\dashv$\hfil} %\global\setbox\equivbox = \hbox to 1em{\hfil$\ptexequiv$\hfil} % Adapted from the manmac format (p.420 of TeXbook) %\global\setbox\bullbox = \hbox to 1em{\kern.15em\vrule height .75ex width .85ex % depth .1ex\hfil} %} % @point{}, @result{}, @expansion{}, @print{}, @equiv{}. \def\point{$\star$} \def\result{\leavevmode\raise.15ex\hbox to 1em{\hfil$\Rightarrow$\hfil}} \def\expansion{\leavevmode\raise.1ex\hbox to 1em{\hfil$\mapsto$\hfil}} \def\print{\leavevmode\lower.1ex\hbox to 1em{\hfil$\dashv$\hfil}} \def\equiv{\leavevmode\lower.1ex\hbox to 1em{\hfil$\ptexequiv$\hfil}} % Adapted from the TeXbook's \boxit. {\tentt \global\dimen0 = 3em}% Width of the box. \dimen2 = .55pt % Thickness of rules % The text. (`r' is open on the right, `e' somewhat less so on the left.) \setbox0 = \hbox{\kern-.75pt \tensf error\kern-1.5pt} \global\setbox\errorbox=\hbox to \dimen0{\hfil \hsize = \dimen0 \advance\hsize by -5.8pt % Space to left+right. \advance\hsize by -2\dimen2 % Rules. \vbox{ \hrule height\dimen2 \hbox{\vrule width\dimen2 \kern3pt % Space to left of text. \vtop{\kern2.4pt \box0 \kern2.4pt}% Space above/below. \kern3pt\vrule width\dimen2}% Space to right. \hrule height\dimen2} \hfil} % The @error{} command. \def\error{\leavevmode\lower.7ex\copy\errorbox} % @tex ... @end tex escapes into raw Tex temporarily. % One exception: @ is still an escape character, so that @end tex works. % But \@ or @@ will get a plain tex @ character. \def\tex{\begingroup \catcode `\\=0 \catcode `\{=1 \catcode `\}=2 \catcode `\$=3 \catcode `\&=4 \catcode `\#=6 \catcode `\^=7 \catcode `\_=8 \catcode `\~=13 \let~=\tie \catcode `\%=14 \catcode 43=12 % plus \catcode`\"=12 \catcode`\==12 \catcode`\|=12 \catcode`\<=12 \catcode`\>=12 \escapechar=`\\ % \let\,=\ptexcomma \let\{=\ptexlbrace \let\}=\ptexrbrace \let\.=\ptexdot \let\*=\ptexstar \let\dots=\ptexdots \def\endldots{\mathinner{\ldots\ldots\ldots\ldots}}% \def\enddots{\relax\ifmmode\endldots\else$\mathsurround=0pt \endldots\,$\fi}% \def\@{@}% \let\bullet=\ptexbullet \let\b=\ptexb \let\c=\ptexc \let\i=\ptexi \let\t=\ptext % \let\Etex=\endgroup} % Define @lisp ... @endlisp. % @lisp does a \begingroup so it can rebind things, % including the definition of @endlisp (which normally is erroneous). % Amount to narrow the margins by for @lisp. \newskip\lispnarrowing \lispnarrowing=0.4in % This is the definition that ^^M gets inside @lisp, @example, and other % such environments. \null is better than a space, since it doesn't % have any width. \def\lisppar{\null\endgraf} % Make each space character in the input produce a normal interword % space in the output. Don't allow a line break at this space, as this % is used only in environments like @example, where each line of input % should produce a line of output anyway. % {\obeyspaces % \gdef\sepspaces{\obeyspaces\let =\tie}} % Define \obeyedspace to be our active space, whatever it is. This is % for use in \parsearg. {\sepspaces% \global\let\obeyedspace= } % This space is always present above and below environments. \newskip\envskipamount \envskipamount = 0pt % Make spacing and below environment symmetrical. We use \parskip here % to help in doing that, since in @example-like environments \parskip % is reset to zero; thus the \afterenvbreak inserts no space -- but the % start of the next paragraph will insert \parskip % \def\aboveenvbreak{{\advance\envskipamount by \parskip \endgraf \ifdim\lastskip<\envskipamount \removelastskip \penalty-50 \vskip\envskipamount \fi}} \let\afterenvbreak = \aboveenvbreak % \nonarrowing is a flag. If "set", @lisp etc don't narrow margins. \let\nonarrowing=\relax %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % \cartouche: draw rectangle w/rounded corners around argument \font\circle=lcircle10 \newdimen\circthick \newdimen\cartouter\newdimen\cartinner \newskip\normbskip\newskip\normpskip\newskip\normlskip \circthick=\fontdimen8\circle % \def\ctl{{\circle\char'013\hskip -6pt}}% 6pt from pl file: 1/2charwidth \def\ctr{{\hskip 6pt\circle\char'010}} \def\cbl{{\circle\char'012\hskip -6pt}} \def\cbr{{\hskip 6pt\circle\char'011}} \def\carttop{\hbox to \cartouter{\hskip\lskip \ctl\leaders\hrule height\circthick\hfil\ctr \hskip\rskip}} \def\cartbot{\hbox to \cartouter{\hskip\lskip \cbl\leaders\hrule height\circthick\hfil\cbr \hskip\rskip}} % \newskip\lskip\newskip\rskip \long\def\cartouche{% \begingroup \lskip=\leftskip \rskip=\rightskip \leftskip=0pt\rightskip=0pt %we want these *outside*. \cartinner=\hsize \advance\cartinner by-\lskip \advance\cartinner by-\rskip \cartouter=\hsize \advance\cartouter by 18pt % allow for 3pt kerns on either % side, and for 6pt waste from % each corner char \normbskip=\baselineskip \normpskip=\parskip \normlskip=\lineskip % Flag to tell @lisp, etc., not to narrow margin. \let\nonarrowing=\comment \vbox\bgroup \baselineskip=0pt\parskip=0pt\lineskip=0pt \carttop \hbox\bgroup \hskip\lskip \vrule\kern3pt \vbox\bgroup \hsize=\cartinner \kern3pt \begingroup \baselineskip=\normbskip \lineskip=\normlskip \parskip=\normpskip \vskip -\parskip \def\Ecartouche{% \endgroup \kern3pt \egroup \kern3pt\vrule \hskip\rskip \egroup \cartbot \egroup \endgroup }} % This macro is called at the beginning of all the @example variants, % inside a group. \def\nonfillstart{% \aboveenvbreak \inENV % This group ends at the end of the body \hfuzz = 12pt % Don't be fussy \sepspaces % Make spaces be word-separators rather than space tokens. \singlespace \let\par = \lisppar % don't ignore blank lines \obeylines % each line of input is a line of output \parskip = 0pt \parindent = 0pt \emergencystretch = 0pt % don't try to avoid overfull boxes % @cartouche defines \nonarrowing to inhibit narrowing % at next level down. \ifx\nonarrowing\relax \advance \leftskip by \lispnarrowing \exdentamount=\lispnarrowing \let\exdent=\nofillexdent \let\nonarrowing=\relax \fi } % To ending an @example-like environment, we first end the paragraph % (via \afterenvbreak's vertical glue), and then the group. That way we % keep the zero \parskip that the environments set -- \parskip glue % will be inserted at the beginning of the next paragraph in the % document, after the environment. % \def\nonfillfinish{\afterenvbreak\endgroup}% \def\lisp{\begingroup \nonfillstart \let\Elisp = \nonfillfinish \tt % Make @kbd do something special, if requested. \let\kbdfont\kbdexamplefont \rawbackslash % have \ input char produce \ char from current font \gobble } % Define the \E... control sequence only if we are inside the % environment, so the error checking in \end will work. % % We must call \lisp last in the definition, since it reads the % return following the @example (or whatever) command. % \def\example{\begingroup \def\Eexample{\nonfillfinish\endgroup}\lisp} \def\smallexample{\begingroup \def\Esmallexample{\nonfillfinish\endgroup}\lisp} \def\smalllisp{\begingroup \def\Esmalllisp{\nonfillfinish\endgroup}\lisp} % @smallexample and @smalllisp. This is not used unless the @smallbook % command is given. Originally contributed by Pavel@xerox. % \def\smalllispx{\begingroup \nonfillstart \let\Esmalllisp = \nonfillfinish \let\Esmallexample = \nonfillfinish % % Smaller fonts for small examples. \indexfonts \tt \rawbackslash % make \ output the \ character from the current font (tt) \gobble } % This is @display; same as @lisp except use roman font. % \def\display{\begingroup \nonfillstart \let\Edisplay = \nonfillfinish \gobble } % This is @format; same as @display except don't narrow margins. % \def\format{\begingroup \let\nonarrowing = t \nonfillstart \let\Eformat = \nonfillfinish \gobble } % @flushleft (same as @format) and @flushright. % \def\flushleft{\begingroup \let\nonarrowing = t \nonfillstart \let\Eflushleft = \nonfillfinish \gobble } \def\flushright{\begingroup \let\nonarrowing = t \nonfillstart \let\Eflushright = \nonfillfinish \advance\leftskip by 0pt plus 1fill \gobble} % @quotation does normal linebreaking (hence we can't use \nonfillstart) % and narrows the margins. % \def\quotation{% \begingroup\inENV %This group ends at the end of the @quotation body {\parskip=0pt \aboveenvbreak}% because \aboveenvbreak inserts \parskip \singlespace \parindent=0pt % We have retained a nonzero parskip for the environment, since we're % doing normal filling. So to avoid extra space below the environment... \def\Equotation{\parskip = 0pt \nonfillfinish}% % % @cartouche defines \nonarrowing to inhibit narrowing at next level down. \ifx\nonarrowing\relax \advance\leftskip by \lispnarrowing \advance\rightskip by \lispnarrowing \exdentamount = \lispnarrowing \let\nonarrowing = \relax \fi } \message{defuns,} % Define formatter for defuns % First, allow user to change definition object font (\df) internally \def\setdeffont #1 {\csname DEF#1\endcsname} \newskip\defbodyindent \defbodyindent=.4in \newskip\defargsindent \defargsindent=50pt \newskip\deftypemargin \deftypemargin=12pt \newskip\deflastargmargin \deflastargmargin=18pt \newcount\parencount % define \functionparens, which makes ( and ) and & do special things. % \functionparens affects the group it is contained in. \def\activeparens{% \catcode`\(=\active \catcode`\)=\active \catcode`\&=\active \catcode`\[=\active \catcode`\]=\active} % Make control sequences which act like normal parenthesis chars. \let\lparen = ( \let\rparen = ) {\activeparens % Now, smart parens don't turn on until &foo (see \amprm) % Be sure that we always have a definition for `(', etc. For example, % if the fn name has parens in it, \boldbrax will not be in effect yet, % so TeX would otherwise complain about undefined control sequence. \global\let(=\lparen \global\let)=\rparen \global\let[=\lbrack \global\let]=\rbrack \gdef\functionparens{\boldbrax\let&=\amprm\parencount=0 } \gdef\boldbrax{\let(=\opnr\let)=\clnr\let[=\lbrb\let]=\rbrb} % This is used to turn on special parens % but make & act ordinary (given that it's active). \gdef\boldbraxnoamp{\let(=\opnr\let)=\clnr\let[=\lbrb\let]=\rbrb\let&=\ampnr} % Definitions of (, ) and & used in args for functions. % This is the definition of ( outside of all parentheses. \gdef\oprm#1 {{\rm\char`\(}#1 \bf \let(=\opnested \global\advance\parencount by 1 } % % This is the definition of ( when already inside a level of parens. \gdef\opnested{\char`\(\global\advance\parencount by 1 } % \gdef\clrm{% Print a paren in roman if it is taking us back to depth of 0. % also in that case restore the outer-level definition of (. \ifnum \parencount=1 {\rm \char `\)}\sl \let(=\oprm \else \char `\) \fi \global\advance \parencount by -1 } % If we encounter &foo, then turn on ()-hacking afterwards \gdef\amprm#1 {{\rm\}\let(=\oprm \let)=\clrm\ } % \gdef\normalparens{\boldbrax\let&=\ampnr} } % End of definition inside \activeparens %% These parens (in \boldbrax) actually are a little bolder than the %% contained text. This is especially needed for [ and ] \def\opnr{{\sf\char`\(}\global\advance\parencount by 1 } \def\clnr{{\sf\char`\)}\global\advance\parencount by -1 } \def\ampnr{\&} \def\lbrb{{\bf\char`\[}} \def\rbrb{{\bf\char`\]}} % First, defname, which formats the header line itself. % #1 should be the function name. % #2 should be the type of definition, such as "Function". \def\defname #1#2{% % Get the values of \leftskip and \rightskip as they were % outside the @def... \dimen2=\leftskip \advance\dimen2 by -\defbodyindent \dimen3=\rightskip \advance\dimen3 by -\defbodyindent \noindent % \setbox0=\hbox{\hskip \deflastargmargin{\rm #2}\hskip \deftypemargin}% \dimen0=\hsize \advance \dimen0 by -\wd0 % compute size for first line \dimen1=\hsize \advance \dimen1 by -\defargsindent %size for continuations \parshape 2 0in \dimen0 \defargsindent \dimen1 % % Now output arg 2 ("Function" or some such) % ending at \deftypemargin from the right margin, % but stuck inside a box of width 0 so it does not interfere with linebreaking {% Adjust \hsize to exclude the ambient margins, % so that \rightline will obey them. \advance \hsize by -\dimen2 \advance \hsize by -\dimen3 \rlap{\rightline{{\rm #2}\hskip \deftypemargin}}}% % Make all lines underfull and no complaints: \tolerance=10000 \hbadness=10000 \advance\leftskip by -\defbodyindent \exdentamount=\defbodyindent {\df #1}\enskip % Generate function name } % Actually process the body of a definition % #1 should be the terminating control sequence, such as \Edefun. % #2 should be the "another name" control sequence, such as \defunx. % #3 should be the control sequence that actually processes the header, % such as \defunheader. \def\defparsebody #1#2#3{\begingroup\inENV% Environment for definitionbody \medbreak % % Define the end token that this defining construct specifies % so that it will exit this group. \def#1{\endgraf\endgroup\medbreak}% \def#2{\begingroup\obeylines\activeparens\spacesplit#3}% \parindent=0in \advance\leftskip by \defbodyindent \advance \rightskip by \defbodyindent \exdentamount=\defbodyindent \begingroup % \catcode 61=\active % 61 is `=' \obeylines\activeparens\spacesplit#3} \def\defmethparsebody #1#2#3#4 {\begingroup\inENV % \medbreak % % Define the end token that this defining construct specifies % so that it will exit this group. \def#1{\endgraf\endgroup\medbreak}% \def#2##1 {\begingroup\obeylines\activeparens\spacesplit{#3{##1}}}% \parindent=0in \advance\leftskip by \defbodyindent \advance \rightskip by \defbodyindent \exdentamount=\defbodyindent \begingroup\obeylines\activeparens\spacesplit{#3{#4}}} \def\defopparsebody #1#2#3#4#5 {\begingroup\inENV % \medbreak % % Define the end token that this defining construct specifies % so that it will exit this group. \def#1{\endgraf\endgroup\medbreak}% \def#2##1 ##2 {\def#4{##1}% \begingroup\obeylines\activeparens\spacesplit{#3{##2}}}% \parindent=0in \advance\leftskip by \defbodyindent \advance \rightskip by \defbodyindent \exdentamount=\defbodyindent \begingroup\obeylines\activeparens\spacesplit{#3{#5}}} % These parsing functions are similar to the preceding ones % except that they do not make parens into active characters. % These are used for "variables" since they have no arguments. \def\defvarparsebody #1#2#3{\begingroup\inENV% Environment for definitionbody \medbreak % % Define the end token that this defining construct specifies % so that it will exit this group. \def#1{\endgraf\endgroup\medbreak}% \def#2{\begingroup\obeylines\spacesplit#3}% \parindent=0in \advance\leftskip by \defbodyindent \advance \rightskip by \defbodyindent \exdentamount=\defbodyindent \begingroup % \catcode 61=\active % \obeylines\spacesplit#3} % This is used for \def{tp,vr}parsebody. It could probably be used for % some of the others, too, with some judicious conditionals. % \def\parsebodycommon#1#2#3{% \begingroup\inENV % \medbreak % % Define the end token that this defining construct specifies % so that it will exit this group. \def#1{\endgraf\endgroup\medbreak}% \def#2##1 {\begingroup\obeylines\spacesplit{#3{##1}}}% \parindent=0in \advance\leftskip by \defbodyindent \advance \rightskip by \defbodyindent \exdentamount=\defbodyindent \begingroup\obeylines } \def\defvrparsebody#1#2#3#4 {% \parsebodycommon{#1}{#2}{#3}% \spacesplit{#3{#4}}% } % This loses on `@deftp {Data Type} {struct termios}' -- it thinks the % type is just `struct', because we lose the braces in `{struct % termios}' when \spacesplit reads its undelimited argument. Sigh. % \let\deftpparsebody=\defvrparsebody % % So, to get around this, we put \empty in with the type name. That % way, TeX won't find exactly `{...}' as an undelimited argument, and % won't strip off the braces. % \def\deftpparsebody #1#2#3#4 {% \parsebodycommon{#1}{#2}{#3}% \spacesplit{\parsetpheaderline{#3{#4}}}\empty } % Fine, but then we have to eventually remove the \empty *and* the % braces (if any). That's what this does. % \def\removeemptybraces\empty#1\relax{#1} % After \spacesplit has done its work, this is called -- #1 is the final % thing to call, #2 the type name (which starts with \empty), and #3 % (which might be empty) the arguments. % \def\parsetpheaderline#1#2#3{% #1{\removeemptybraces#2\relax}{#3}% }% \def\defopvarparsebody #1#2#3#4#5 {\begingroup\inENV % \medbreak % % Define the end token that this defining construct specifies % so that it will exit this group. \def#1{\endgraf\endgroup\medbreak}% \def#2##1 ##2 {\def#4{##1}% \begingroup\obeylines\spacesplit{#3{##2}}}% \parindent=0in \advance\leftskip by \defbodyindent \advance \rightskip by \defbodyindent \exdentamount=\defbodyindent \begingroup\obeylines\spacesplit{#3{#5}}} % Split up #2 at the first space token. % call #1 with two arguments: % the first is all of #2 before the space token, % the second is all of #2 after that space token. % If #2 contains no space token, all of it is passed as the first arg % and the second is passed as empty. {\obeylines \gdef\spacesplit#1#2^^M{\endgroup\spacesplitfoo{#1}#2 \relax\spacesplitfoo}% \long\gdef\spacesplitfoo#1#2 #3#4\spacesplitfoo{% \ifx\relax #3% #1{#2}{}\else #1{#2}{#3#4}\fi}} % So much for the things common to all kinds of definitions. % Define @defun. % First, define the processing that is wanted for arguments of \defun % Use this to expand the args and terminate the paragraph they make up \def\defunargs #1{\functionparens \sl % Expand, preventing hyphenation at `-' chars. % Note that groups don't affect changes in \hyphenchar. \hyphenchar\tensl=0 #1% \hyphenchar\tensl=45 \ifnum\parencount=0 \else \errmessage{Unbalanced parentheses in @def}\fi% \interlinepenalty=10000 \advance\rightskip by 0pt plus 1fil \endgraf\penalty 10000\vskip -\parskip\penalty 10000% } \def\deftypefunargs #1{% % Expand, preventing hyphenation at `-' chars. % Note that groups don't affect changes in \hyphenchar. % Use \boldbraxnoamp, not \functionparens, so that & is not special. \boldbraxnoamp \tclose{#1}% avoid \code because of side effects on active chars \interlinepenalty=10000 \advance\rightskip by 0pt plus 1fil \endgraf\penalty 10000\vskip -\parskip\penalty 10000% } % Do complete processing of one @defun or @defunx line already parsed. % @deffn Command forward-char nchars \def\deffn{\defmethparsebody\Edeffn\deffnx\deffnheader} \def\deffnheader #1#2#3{\doind {fn}{\code{#2}}% \begingroup\defname {#2}{#1}\defunargs{#3}\endgroup % \catcode 61=\other % Turn off change made in \defparsebody } % @defun == @deffn Function \def\defun{\defparsebody\Edefun\defunx\defunheader} \def\defunheader #1#2{\doind {fn}{\code{#1}}% Make entry in function index \begingroup\defname {#1}{Function}% \defunargs {#2}\endgroup % \catcode 61=\other % Turn off change made in \defparsebody } % @deftypefun int foobar (int @var{foo}, float @var{bar}) \def\deftypefun{\defparsebody\Edeftypefun\deftypefunx\deftypefunheader} % #1 is the data type. #2 is the name and args. \def\deftypefunheader #1#2{\deftypefunheaderx{#1}#2 \relax} % #1 is the data type, #2 the name, #3 the args. \def\deftypefunheaderx #1#2 #3\relax{% \doind {fn}{\code{#2}}% Make entry in function index \begingroup\defname {\defheaderxcond#1\relax$$$#2}{Function}% \deftypefunargs {#3}\endgroup % \catcode 61=\other % Turn off change made in \defparsebody } % @deftypefn {Library Function} int foobar (int @var{foo}, float @var{bar}) \def\deftypefn{\defmethparsebody\Edeftypefn\deftypefnx\deftypefnheader} % \defheaderxcond#1\relax$$$ % puts #1 in @code, followed by a space, but does nothing if #1 is null. \def\defheaderxcond#1#2$$${\ifx#1\relax\else\code{#1#2} \fi} % #1 is the classification. #2 is the data type. #3 is the name and args. \def\deftypefnheader #1#2#3{\deftypefnheaderx{#1}{#2}#3 \relax} % #1 is the classification, #2 the data type, #3 the name, #4 the args. \def\deftypefnheaderx #1#2#3 #4\relax{% \doind {fn}{\code{#3}}% Make entry in function index \begingroup \normalparens % notably, turn off `&' magic, which prevents % at least some C++ text from working \defname {\defheaderxcond#2\relax$$$#3}{#1}% \deftypefunargs {#4}\endgroup % \catcode 61=\other % Turn off change made in \defparsebody } % @defmac == @deffn Macro \def\defmac{\defparsebody\Edefmac\defmacx\defmacheader} \def\defmacheader #1#2{\doind {fn}{\code{#1}}% Make entry in function index \begingroup\defname {#1}{Macro}% \defunargs {#2}\endgroup % \catcode 61=\other % Turn off change made in \defparsebody } % @defspec == @deffn Special Form \def\defspec{\defparsebody\Edefspec\defspecx\defspecheader} \def\defspecheader #1#2{\doind {fn}{\code{#1}}% Make entry in function index \begingroup\defname {#1}{Special Form}% \defunargs {#2}\endgroup % \catcode 61=\other % Turn off change made in \defparsebody } % This definition is run if you use @defunx % anywhere other than immediately after a @defun or @defunx. \def\deffnx #1 {\errmessage{@deffnx in invalid context}} \def\defunx #1 {\errmessage{@defunx in invalid context}} \def\defmacx #1 {\errmessage{@defmacx in invalid context}} \def\defspecx #1 {\errmessage{@defspecx in invalid context}} \def\deftypefnx #1 {\errmessage{@deftypefnx in invalid context}} \def\deftypemethodx #1 {\errmessage{@deftypemethodx in invalid context}} \def\deftypeunx #1 {\errmessage{@deftypeunx in invalid context}} % @defmethod, and so on % @defop {Funny Method} foo-class frobnicate argument \def\defop #1 {\def\defoptype{#1}% \defopparsebody\Edefop\defopx\defopheader\defoptype} \def\defopheader #1#2#3{% \dosubind {fn}{\code{#2}}{on #1}% Make entry in function index \begingroup\defname {#2}{\defoptype{} on #1}% \defunargs {#3}\endgroup % } % @deftypemethod foo-class return-type foo-method args % \def\deftypemethod{% \defmethparsebody\Edeftypemethod\deftypemethodx\deftypemethodheader} % % #1 is the class name, #2 the data type, #3 the method name, #4 the args. \def\deftypemethodheader#1#2#3#4{% \deftypefnheaderx{Method on #1}{#2}#3 #4\relax } % @defmethod == @defop Method \def\defmethod{\defmethparsebody\Edefmethod\defmethodx\defmethodheader} \def\defmethodheader #1#2#3{% \dosubind {fn}{\code{#2}}{on #1}% entry in function index \begingroup\defname {#2}{Method on #1}% \defunargs {#3}\endgroup % } % @defcv {Class Option} foo-class foo-flag \def\defcv #1 {\def\defcvtype{#1}% \defopvarparsebody\Edefcv\defcvx\defcvarheader\defcvtype} \def\defcvarheader #1#2#3{% \dosubind {vr}{\code{#2}}{of #1}% Make entry in var index \begingroup\defname {#2}{\defcvtype{} of #1}% \defvarargs {#3}\endgroup % } % @defivar == @defcv {Instance Variable} \def\defivar{\defvrparsebody\Edefivar\defivarx\defivarheader} \def\defivarheader #1#2#3{% \dosubind {vr}{\code{#2}}{of #1}% Make entry in var index \begingroup\defname {#2}{Instance Variable of #1}% \defvarargs {#3}\endgroup % } % These definitions are run if you use @defmethodx, etc., % anywhere other than immediately after a @defmethod, etc. \def\defopx #1 {\errmessage{@defopx in invalid context}} \def\defmethodx #1 {\errmessage{@defmethodx in invalid context}} \def\defcvx #1 {\errmessage{@defcvx in invalid context}} \def\defivarx #1 {\errmessage{@defivarx in invalid context}} % Now @defvar % First, define the processing that is wanted for arguments of @defvar. % This is actually simple: just print them in roman. % This must expand the args and terminate the paragraph they make up \def\defvarargs #1{\normalparens #1% \interlinepenalty=10000 \endgraf\penalty 10000\vskip -\parskip\penalty 10000} % @defvr Counter foo-count \def\defvr{\defvrparsebody\Edefvr\defvrx\defvrheader} \def\defvrheader #1#2#3{\doind {vr}{\code{#2}}% \begingroup\defname {#2}{#1}\defvarargs{#3}\endgroup} % @defvar == @defvr Variable \def\defvar{\defvarparsebody\Edefvar\defvarx\defvarheader} \def\defvarheader #1#2{\doind {vr}{\code{#1}}% Make entry in var index \begingroup\defname {#1}{Variable}% \defvarargs {#2}\endgroup % } % @defopt == @defvr {User Option} \def\defopt{\defvarparsebody\Edefopt\defoptx\defoptheader} \def\defoptheader #1#2{\doind {vr}{\code{#1}}% Make entry in var index \begingroup\defname {#1}{User Option}% \defvarargs {#2}\endgroup % } % @deftypevar int foobar \def\deftypevar{\defvarparsebody\Edeftypevar\deftypevarx\deftypevarheader} % #1 is the data type. #2 is the name, perhaps followed by text that % is actually part of the data type, which should not be put into the index. \def\deftypevarheader #1#2{% \dovarind#2 \relax% Make entry in variables index \begingroup\defname {\defheaderxcond#1\relax$$$#2}{Variable}% \interlinepenalty=10000 \endgraf\penalty 10000\vskip -\parskip\penalty 10000 \endgroup} \def\dovarind#1 #2\relax{\doind{vr}{\code{#1}}} % @deftypevr {Global Flag} int enable \def\deftypevr{\defvrparsebody\Edeftypevr\deftypevrx\deftypevrheader} \def\deftypevrheader #1#2#3{\dovarind#3 \relax% \begingroup\defname {\defheaderxcond#2\relax$$$#3}{#1} \interlinepenalty=10000 \endgraf\penalty 10000\vskip -\parskip\penalty 10000 \endgroup} % This definition is run if you use @defvarx % anywhere other than immediately after a @defvar or @defvarx. \def\defvrx #1 {\errmessage{@defvrx in invalid context}} \def\defvarx #1 {\errmessage{@defvarx in invalid context}} \def\defoptx #1 {\errmessage{@defoptx in invalid context}} \def\deftypevarx #1 {\errmessage{@deftypevarx in invalid context}} \def\deftypevrx #1 {\errmessage{@deftypevrx in invalid context}} % Now define @deftp % Args are printed in bold, a slight difference from @defvar. \def\deftpargs #1{\bf \defvarargs{#1}} % @deftp Class window height width ... \def\deftp{\deftpparsebody\Edeftp\deftpx\deftpheader} \def\deftpheader #1#2#3{\doind {tp}{\code{#2}}% \begingroup\defname {#2}{#1}\deftpargs{#3}\endgroup} % This definition is run if you use @deftpx, etc % anywhere other than immediately after a @deftp, etc. \def\deftpx #1 {\errmessage{@deftpx in invalid context}} \message{cross reference,} % Define cross-reference macros \newwrite \auxfile \newif\ifhavexrefs % True if xref values are known. \newif\ifwarnedxrefs % True if we warned once that they aren't known. % @inforef is simple. \def\inforef #1{\inforefzzz #1,,,,**} \def\inforefzzz #1,#2,#3,#4**{\putwordSee{} \putwordInfo{} \putwordfile{} \file{\ignorespaces #3{}}, node \samp{\ignorespaces#1{}}} % \setref{foo} defines a cross-reference point named foo. \def\setref#1{% \dosetq{#1-title}{Ytitle}% \dosetq{#1-pg}{Ypagenumber}% \dosetq{#1-snt}{Ysectionnumberandtype}} \def\unnumbsetref#1{% \dosetq{#1-title}{Ytitle}% \dosetq{#1-pg}{Ypagenumber}% \dosetq{#1-snt}{Ynothing}} \def\appendixsetref#1{% \dosetq{#1-title}{Ytitle}% \dosetq{#1-pg}{Ypagenumber}% \dosetq{#1-snt}{Yappendixletterandtype}} % \xref, \pxref, and \ref generate cross-references to specified points. % For \xrefX, #1 is the node name, #2 the name of the Info % cross-reference, #3 the printed node name, #4 the name of the Info % file, #5 the name of the printed manual. All but the node name can be % omitted. % \def\pxref#1{\putwordsee{} \xrefX[#1,,,,,,,]} \def\xref#1{\putwordSee{} \xrefX[#1,,,,,,,]} \def\ref#1{\xrefX[#1,,,,,,,]} \def\xrefX[#1,#2,#3,#4,#5,#6]{\begingroup \def\printedmanual{\ignorespaces #5}% \def\printednodename{\ignorespaces #3}% \setbox1=\hbox{\printedmanual}% \setbox0=\hbox{\printednodename}% \ifdim \wd0 = 0pt % No printed node name was explicitly given. \expandafter\ifx\csname SETxref-automatic-section-title\endcsname\relax % Use the node name inside the square brackets. \def\printednodename{\ignorespaces #1}% \else % Use the actual chapter/section title appear inside % the square brackets. Use the real section title if we have it. \ifdim \wd1>0pt% % It is in another manual, so we don't have it. \def\printednodename{\ignorespaces #1}% \else \ifhavexrefs % We know the real title if we have the xref values. \def\printednodename{\refx{#1-title}{}}% \else % Otherwise just copy the Info node name. \def\printednodename{\ignorespaces #1}% \fi% \fi \fi \fi % % If we use \unhbox0 and \unhbox1 to print the node names, TeX does not % insert empty discretionaries after hyphens, which means that it will % not find a line break at a hyphen in a node names. Since some manuals % are best written with fairly long node names, containing hyphens, this % is a loss. Therefore, we give the text of the node name again, so it % is as if TeX is seeing it for the first time. \ifdim \wd1 > 0pt \putwordsection{} ``\printednodename'' in \cite{\printedmanual}% \else % _ (for example) has to be the character _ for the purposes of the % control sequence corresponding to the node, but it has to expand % into the usual \leavevmode...\vrule stuff for purposes of % printing. So we \turnoffactive for the \refx-snt, back on for the % printing, back off for the \refx-pg. {\turnoffactive \refx{#1-snt}{}}% \space [\printednodename],\space \turnoffactive \putwordpage\tie\refx{#1-pg}{}% \fi \endgroup} % \dosetq is the interface for calls from other macros % Use \turnoffactive so that punctuation chars such as underscore % work in node names. \def\dosetq #1#2{{\let\folio=0 \turnoffactive \edef\next{\write\auxfile{\internalsetq {#1}{#2}}}% \next}} % \internalsetq {foo}{page} expands into % CHARACTERS 'xrdef {foo}{...expansion of \Ypage...} % When the aux file is read, ' is the escape character \def\internalsetq #1#2{'xrdef {#1}{\csname #2\endcsname}} % Things to be expanded by \internalsetq \def\Ypagenumber{\folio} \def\Ytitle{\thissection} \def\Ynothing{} \def\Ysectionnumberandtype{% \ifnum\secno=0 \putwordChapter\xreftie\the\chapno % \else \ifnum \subsecno=0 \putwordSection\xreftie\the\chapno.\the\secno % \else \ifnum \subsubsecno=0 % \putwordSection\xreftie\the\chapno.\the\secno.\the\subsecno % \else % \putwordSection\xreftie\the\chapno.\the\secno.\the\subsecno.\the\subsubsecno % \fi \fi \fi } \def\Yappendixletterandtype{% \ifnum\secno=0 \putwordAppendix\xreftie'char\the\appendixno{}% \else \ifnum \subsecno=0 \putwordSection\xreftie'char\the\appendixno.\the\secno % \else \ifnum \subsubsecno=0 % \putwordSection\xreftie'char\the\appendixno.\the\secno.\the\subsecno % \else % \putwordSection\xreftie'char\the\appendixno.\the\secno.\the\subsecno.\the\subsubsecno % \fi \fi \fi } \gdef\xreftie{'tie} % Use TeX 3.0's \inputlineno to get the line number, for better error % messages, but if we're using an old version of TeX, don't do anything. % \ifx\inputlineno\thisisundefined \let\linenumber = \empty % Non-3.0. \else \def\linenumber{\the\inputlineno:\space} \fi % Define \refx{NAME}{SUFFIX} to reference a cross-reference string named NAME. % If its value is nonempty, SUFFIX is output afterward. \def\refx#1#2{% \expandafter\ifx\csname X#1\endcsname\relax % If not defined, say something at least. $\langle$un\-de\-fined$\rangle$% \ifhavexrefs \message{\linenumber Undefined cross reference `#1'.}% \else \ifwarnedxrefs\else \global\warnedxrefstrue \message{Cross reference values unknown; you must run TeX again.}% \fi \fi \else % It's defined, so just use it. \csname X#1\endcsname \fi #2% Output the suffix in any case. } % This is the macro invoked by entries in the aux file. \def\xrdef #1#2{{% \catcode`\'=\other \expandafter\gdef\csname X#1\endcsname{#2}% }} % Read the last existing aux file, if any. No error if none exists. \def\readauxfile{\begingroup \catcode`\^^@=\other \catcode`\^^A=\other \catcode`\^^B=\other \catcode`\^^C=\other \catcode`\^^D=\other \catcode`\^^E=\other \catcode`\^^F=\other \catcode`\^^G=\other \catcode`\^^H=\other \catcode`\^^K=\other \catcode`\^^L=\other \catcode`\^^N=\other \catcode`\^^P=\other \catcode`\^^Q=\other \catcode`\^^R=\other \catcode`\^^S=\other \catcode`\^^T=\other \catcode`\^^U=\other \catcode`\^^V=\other \catcode`\^^W=\other \catcode`\^^X=\other \catcode`\^^Z=\other \catcode`\^^[=\other \catcode`\^^\=\other \catcode`\^^]=\other \catcode`\^^^=\other \catcode`\^^_=\other \catcode`\@=\other \catcode`\^=\other % It was suggested to define this as 7, which would allow ^^e4 etc. % in xref tags, i.e., node names. But since ^^e4 notation isn't % supported in the main text, it doesn't seem desirable. Furthermore, % that is not enough: for node names that actually contain a ^ % character, we would end up writing a line like this: 'xrdef {'hat % b-title}{'hat b} and \xrdef does a \csname...\endcsname on the first % argument, and \hat is not an expandable control sequence. It could % all be worked out, but why? Either we support ^^ or we don't. % % The other change necessary for this was to define \auxhat: % \def\auxhat{\def^{'hat }}% extra space so ok if followed by letter % and then to call \auxhat in \setq. % \catcode`\~=\other \catcode`\[=\other \catcode`\]=\other \catcode`\"=\other \catcode`\_=\other \catcode`\|=\other \catcode`\<=\other \catcode`\>=\other \catcode`\$=\other \catcode`\#=\other \catcode`\&=\other % `\+ does not work, so use 43. \catcode43=\other % Make the characters 128-255 be printing characters {% \count 1=128 \def\loop{% \catcode\count 1=\other \advance\count 1 by 1 \ifnum \count 1<256 \loop \fi }% }% % The aux file uses ' as the escape (for now). % Turn off \ as an escape so we do not lose on % entries which were dumped with control sequences in their names. % For example, 'xrdef {$\leq $-fun}{page ...} made by @defun ^^ % Reference to such entries still does not work the way one would wish, % but at least they do not bomb out when the aux file is read in. \catcode`\{=1 \catcode`\}=2 \catcode`\%=\other \catcode`\'=0 \catcode`\\=\other % \openin 1 \jobname.aux \ifeof 1 \else \closein 1 \input \jobname.aux \global\havexrefstrue \global\warnedobstrue \fi % Open the new aux file. TeX will close it automatically at exit. \openout\auxfile=\jobname.aux \endgroup} % Footnotes. \newcount \footnoteno % The trailing space in the following definition for supereject is % vital for proper filling; pages come out unaligned when you do a % pagealignmacro call if that space before the closing brace is % removed. (Generally, numeric constants should always be followed by a % space to prevent strange expansion errors.) \def\supereject{\par\penalty -20000\footnoteno =0 } % @footnotestyle is meaningful for info output only. \let\footnotestyle=\comment \let\ptexfootnote=\footnote {\catcode `\@=11 % % Auto-number footnotes. Otherwise like plain. \gdef\footnote{% \global\advance\footnoteno by \@ne \edef\thisfootno{$^{\the\footnoteno}$}% % % In case the footnote comes at the end of a sentence, preserve the % extra spacing after we do the footnote number. \let\@sf\empty \ifhmode\edef\@sf{\spacefactor\the\spacefactor}\/\fi % % Remove inadvertent blank space before typesetting the footnote number. \unskip \thisfootno\@sf \footnotezzz }% % Don't bother with the trickery in plain.tex to not require the % footnote text as a parameter. Our footnotes don't need to be so general. % % Oh yes, they do; otherwise, @ifset and anything else that uses % \parseargline fail inside footnotes because the tokens are fixed when % the footnote is read. --karl, 16nov96. % \long\gdef\footnotezzz{\insert\footins\bgroup % We want to typeset this text as a normal paragraph, even if the % footnote reference occurs in (for example) a display environment. % So reset some parameters. \interlinepenalty\interfootnotelinepenalty \splittopskip\ht\strutbox % top baseline for broken footnotes \splitmaxdepth\dp\strutbox \floatingpenalty\@MM \leftskip\z@skip \rightskip\z@skip \spaceskip\z@skip \xspaceskip\z@skip \parindent\defaultparindent % % Hang the footnote text off the number. \hang \textindent{\thisfootno}% % % Don't crash into the line above the footnote text. Since this % expands into a box, it must come within the paragraph, lest it % provide a place where TeX can split the footnote. \footstrut \futurelet\next\fo@t } \def\fo@t{\ifcat\bgroup\noexpand\next \let\next\f@@t \else\let\next\f@t\fi \next} \def\f@@t{\bgroup\aftergroup\@foot\let\next} \def\f@t#1{#1\@foot} \def\@foot{\strut\egroup} }%end \catcode `\@=11 % Set the baselineskip to #1, and the lineskip and strut size % correspondingly. There is no deep meaning behind these magic numbers % used as factors; they just match (closely enough) what Knuth defined. % \def\lineskipfactor{.08333} \def\strutheightpercent{.70833} \def\strutdepthpercent {.29167} % \def\setleading#1{% \normalbaselineskip = #1\relax \normallineskip = \lineskipfactor\normalbaselineskip \normalbaselines \setbox\strutbox =\hbox{% \vrule width0pt height\strutheightpercent\baselineskip depth \strutdepthpercent \baselineskip }% } % @| inserts a changebar to the left of the current line. It should % surround any changed text. This approach does *not* work if the % change spans more than two lines of output. To handle that, we would % have adopt a much more difficult approach (putting marks into the main % vertical list for the beginning and end of each change). % \def\|{% % \vadjust can only be used in horizontal mode. \leavevmode % % Append this vertical mode material after the current line in the output. \vadjust{% % We want to insert a rule with the height and depth of the current % leading; that is exactly what \strutbox is supposed to record. \vskip-\baselineskip % % \vadjust-items are inserted at the left edge of the type. So % the \llap here moves out into the left-hand margin. \llap{% % % For a thicker or thinner bar, change the `1pt'. \vrule height\baselineskip width1pt % % This is the space between the bar and the text. \hskip 12pt }% }% } % For a final copy, take out the rectangles % that mark overfull boxes (in case you have decided % that the text looks ok even though it passes the margin). % \def\finalout{\overfullrule=0pt} % @image. We use the macros from epsf.tex to support this. % If epsf.tex is not installed and @image is used, we complain. % % Check for and read epsf.tex up front. If we read it only at @image % time, we might be inside a group, and then its definitions would get % undone and the next image would fail. \openin 1 = xepsf.tex \ifeof 1 \else \closein 1 \def\epsfannounce{\toks0 = }% do not bother showing banner \input epsf.tex \fi % \newif\ifwarnednoepsf \newhelp\noepsfhelp{epsf.tex must be installed for images to work. It is also included in the Texinfo distribution, or you can get it from ftp://ftp.tug.org/tex/epsf.tex.} % % Only complain once about lack of epsf.tex. \def\image#1{% \ifx\epsfbox\undefined \ifwarnednoepsf \else \errhelp = \noepsfhelp \errmessage{epsf.tex not found, images will be ignored}% \global\warnednoepsftrue \fi \else \imagexxx #1,,,\finish \fi } % % Arguments to @image: % #1 is (mandatory) image filename; we tack on .eps extension. % #2 is (optional) width, #3 is (optional) height. % #4 is just the usual extra ignored arg for parsing this stuff. \def\imagexxx#1,#2,#3,#4\finish{% % \epsfbox itself resets \epsf?size at each figure. \setbox0 = \hbox{\ignorespaces #2}\ifdim\wd0 > 0pt \epsfxsize=#2\relax \fi \setbox0 = \hbox{\ignorespaces #3}\ifdim\wd0 > 0pt \epsfysize=#3\relax \fi \epsfbox{#1.eps}% } % End of control word definitions. \message{and turning on texinfo input format.} \def\openindices{% \newindex{cp}% \newcodeindex{fn}% \newcodeindex{vr}% \newcodeindex{tp}% \newcodeindex{ky}% \newcodeindex{pg}% } % Set some numeric style parameters, for 8.5 x 11 format. \hsize = 6in \hoffset = .25in \newdimen\defaultparindent \defaultparindent = 15pt \parindent = \defaultparindent \parskip 3pt plus 2pt minus 1pt \setleading{13.2pt} \advance\topskip by 1.2cm \chapheadingskip = 15pt plus 4pt minus 2pt \secheadingskip = 12pt plus 3pt minus 2pt \subsecheadingskip = 9pt plus 2pt minus 2pt % Prevent underfull vbox error messages. \vbadness=10000 % Following George Bush, just get rid of widows and orphans. \widowpenalty=10000 \clubpenalty=10000 % Use TeX 3.0's \emergencystretch to help line breaking, but if we're % using an old version of TeX, don't do anything. We want the amount of % stretch added to depend on the line length, hence the dependence on % \hsize. This makes it come to about 9pt for the 8.5x11 format. % \ifx\emergencystretch\thisisundefined % Allow us to assign to \emergencystretch anyway. \def\emergencystretch{\dimen0}% \else \emergencystretch = \hsize \divide\emergencystretch by 45 \fi % Use @smallbook to reset parameters for 7x9.5 format (or else 7x9.25) \def\smallbook{ \global\chapheadingskip = 15pt plus 4pt minus 2pt \global\secheadingskip = 12pt plus 3pt minus 2pt \global\subsecheadingskip = 9pt plus 2pt minus 2pt % \global\lispnarrowing = 0.3in \setleading{12pt} \advance\topskip by -1cm \global\parskip 2pt plus 1pt \global\hsize = 5in \global\vsize=7.5in \global\tolerance=700 \global\hfuzz=1pt \global\contentsrightmargin=0pt \global\deftypemargin=0pt \global\defbodyindent=.5cm % \global\pagewidth=\hsize \global\pageheight=\vsize % \global\let\smalllisp=\smalllispx \global\let\smallexample=\smalllispx \global\def\Esmallexample{\Esmalllisp} } % Use @afourpaper to print on European A4 paper. \def\afourpaper{ \global\tolerance=700 \global\hfuzz=1pt \setleading{12pt} \global\parskip 15pt plus 1pt \global\vsize= 53\baselineskip \advance\vsize by \topskip %\global\hsize= 5.85in % A4 wide 10pt \global\hsize= 6.5in \global\outerhsize=\hsize \global\advance\outerhsize by 0.5in \global\outervsize=\vsize \global\advance\outervsize by 0.6in \global\pagewidth=\hsize \global\pageheight=\vsize } \bindingoffset=0pt \normaloffset=\hoffset \pagewidth=\hsize \pageheight=\vsize % Allow control of the text dimensions. Parameters in order: textheight; % textwidth; voffset; hoffset; binding offset; topskip. % All require a dimension; % header is additional; added length extends the bottom of the page. \def\changepagesizes#1#2#3#4#5#6{ \global\vsize= #1 \global\topskip= #6 \advance\vsize by \topskip \global\voffset= #3 \global\hsize= #2 \global\outerhsize=\hsize \global\advance\outerhsize by 0.5in \global\outervsize=\vsize \global\advance\outervsize by 0.6in \global\pagewidth=\hsize \global\pageheight=\vsize \global\normaloffset= #4 \global\bindingoffset= #5} % A specific text layout, 24x15cm overall, intended for A4 paper. Top margin % 29mm, hence bottom margin 28mm, nominal side margin 3cm. \def\afourlatex {\global\tolerance=700 \global\hfuzz=1pt \setleading{12pt} \global\parskip 15pt plus 1pt \advance\baselineskip by 1.6pt \changepagesizes{237mm}{150mm}{3.6mm}{3.6mm}{3mm}{7mm} } % Use @afourwide to print on European A4 paper in wide format. \def\afourwide{\afourpaper \changepagesizes{9.5in}{6.5in}{\hoffset}{\normaloffset}{\bindingoffset}{7mm}} % Define macros to output various characters with catcode for normal text. \catcode`\"=\other \catcode`\~=\other \catcode`\^=\other \catcode`\_=\other \catcode`\|=\other \catcode`\<=\other \catcode`\>=\other \catcode`\+=\other \def\normaldoublequote{"} \def\normaltilde{~} \def\normalcaret{^} \def\normalunderscore{_} \def\normalverticalbar{|} \def\normalless{<} \def\normalgreater{>} \def\normalplus{+} % This macro is used to make a character print one way in ttfont % where it can probably just be output, and another way in other fonts, % where something hairier probably needs to be done. % % #1 is what to print if we are indeed using \tt; #2 is what to print % otherwise. Since all the Computer Modern typewriter fonts have zero % interword stretch (and shrink), and it is reasonable to expect all % typewriter fonts to have this, we can check that font parameter. % \def\ifusingtt#1#2{\ifdim \fontdimen3\the\font=0pt #1\else #2\fi} % Turn off all special characters except @ % (and those which the user can use as if they were ordinary). % Most of these we simply print from the \tt font, but for some, we can % use math or other variants that look better in normal text. \catcode`\"=\active \def\activedoublequote{{\tt \char '042}} \let"=\activedoublequote \catcode`\~=\active \def~{{\tt \char '176}} \chardef\hat=`\^ \catcode`\^=\active \def^{{\tt \hat}} \catcode`\_=\active \def_{\ifusingtt\normalunderscore\_} % Subroutine for the previous macro. \def\_{\leavevmode \kern.06em \vbox{\hrule width.3em height.1ex}} \catcode`\|=\active \def|{{\tt \char '174}} \chardef \less=`\< \catcode`\<=\active \def<{{\tt \less}} \chardef \gtr=`\> \catcode`\>=\active \def>{{\tt \gtr}} \catcode`\+=\active \def+{{\tt \char 43}} %\catcode 27=\active %\def^^[{$\diamondsuit$} % Set up an active definition for =, but don't enable it most of the time. {\catcode`\==\active \global\def={{\tt \char 61}}} \catcode`+=\active \catcode`\_=\active % If a .fmt file is being used, characters that might appear in a file % name cannot be active until we have parsed the command line. % So turn them off again, and have \everyjob (or @setfilename) turn them on. % \otherifyactive is called near the end of this file. \def\otherifyactive{\catcode`+=\other \catcode`\_=\other} \catcode`\@=0 % \rawbackslashxx output one backslash character in current font \global\chardef\rawbackslashxx=`\\ %{\catcode`\\=\other %@gdef@rawbackslashxx{\}} % \rawbackslash redefines \ as input to do \rawbackslashxx. {\catcode`\\=\active @gdef@rawbackslash{@let\=@rawbackslashxx }} % \normalbackslash outputs one backslash in fixed width font. \def\normalbackslash{{\tt\rawbackslashxx}} % Say @foo, not \foo, in error messages. \escapechar=`\@ % \catcode 17=0 % Define control-q \catcode`\\=\active % Used sometimes to turn off (effectively) the active characters % even after parsing them. @def@turnoffactive{@let"=@normaldoublequote @let\=@realbackslash @let~=@normaltilde @let^=@normalcaret @let_=@normalunderscore @let|=@normalverticalbar @let<=@normalless @let>=@normalgreater @let+=@normalplus} @def@normalturnoffactive{@let"=@normaldoublequote @let\=@normalbackslash @let~=@normaltilde @let^=@normalcaret @let_=@normalunderscore @let|=@normalverticalbar @let<=@normalless @let>=@normalgreater @let+=@normalplus} % Make _ and + \other characters, temporarily. % This is canceled by @fixbackslash. @otherifyactive % If a .fmt file is being used, we don't want the `\input texinfo' to show up. % That is what \eatinput is for; after that, the `\' should revert to printing % a backslash. % @gdef@eatinput input texinfo{@fixbackslash} @global@let\ = @eatinput % On the other hand, perhaps the file did not have a `\input texinfo'. Then % the first `\{ in the file would cause an error. This macro tries to fix % that, assuming it is called before the first `\' could plausibly occur. % Also back turn on active characters that might appear in the input % file name, in case not using a pre-dumped format. % @gdef@fixbackslash{@ifx\@eatinput @let\ = @normalbackslash @fi @catcode`+=@active @catcode`@_=@active} %% These look ok in all fonts, so just make them not special. The @rm below %% makes sure that the current font starts out as the newly loaded cmr10 @catcode`@$=@other @catcode`@%=@other @catcode`@&=@other @catcode`@#=@other @textfonts @rm @c Local variables: @c page-delimiter: "^\\\\message" @c End: gtkada-24.0.0/docs/gtkada_rm/togglebutton.eps000066400000000000000000000656771446021174000211630ustar00rootroot00000000000000%!PS-Adobe-2.0 EPSF-2.0 %%Title: /home/briot/gtk/GtkAda/t/toggle_button.eps %%Creator: XV Version 3.10a Rev: 12/29/94 (PNG patch 1.2) - by John Bradley %%BoundingBox: 275 363 337 430 %%Pages: 1 %%DocumentFonts: %%EndComments %%EndProlog %%Page: 1 1 % remember original state /origstate save def % build a temporary dictionary 20 dict begin % define string to hold a scanline's worth of data /pix 186 string def % define space for color conversions /grays 62 string def % space for gray scale line /npixls 0 def /rgbindx 0 def % lower left corner 275 363 translate % size of image (on paper, in 1/72inch coords) 61.99200 67.03200 scale % define 'colorimage' if it isn't defined % ('colortogray' and 'mergeprocs' come from xwd2ps % via xgrab) /colorimage where % do we know about 'colorimage'? { pop } % yes: pop off the 'dict' returned { % no: define one /colortogray { % define an RGB->I function /rgbdata exch store % call input 'rgbdata' rgbdata length 3 idiv /npixls exch store /rgbindx 0 store 0 1 npixls 1 sub { grays exch rgbdata rgbindx get 20 mul % Red rgbdata rgbindx 1 add get 32 mul % Green rgbdata rgbindx 2 add get 12 mul % Blue add add 64 idiv % I = .5G + .31R + .18B put /rgbindx rgbindx 3 add store } for grays 0 npixls getinterval } bind def % Utility procedure for colorimage operator. % This procedure takes two procedures off the % stack and merges them into a single procedure. /mergeprocs { % def dup length 3 -1 roll dup length dup 5 1 roll 3 -1 roll add array cvx dup 3 -1 roll 0 exch putinterval dup 4 2 roll putinterval } bind def /colorimage { % def pop pop % remove 'false 3' operands {colortogray} mergeprocs image } bind def } ifelse % end of 'false' case 62 67 8 % dimensions of data [62 0 0 -67 0 67] % mapping matrix {currentfile pix readhexstring pop} false 3 colorimage d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0f8fcf8f8fcf8f8fcf8f8fcf8 f8fcf8f8fcf8f8fcf8f8fcf8f8fcf8f8fcf8f8fcf8f8fcf8f8fcf8f8fcf8f8fcf8f8fcf8 f8fcf8f8fcf8f8fcf8f8fcf8f8fcf8f8fcf8f8fcf8f8fcf8f8fcf8f8fcf8f8fcf8f8fcf8 f8fcf8f8fcf8f8fcf8f8fcf8f8fcf8f8fcf8f8fcf8f8fcf8f8fcf8f8fcf8f8fcf8f8fcf8 f8fcf8f8fcf8f8fcf8f8fcf8f8fcf8f8fcf8000000d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0f8fcf8d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0000000d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0f8fcf8d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0909490000000d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0f8fcf8d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0909490000000d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0f8fcf8d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0909490000000d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0f8fcf8d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0909490000000d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0f8fcf8d0d4d0d0d4d0d0d4d0 000000d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0000000d0d4d0d0d4d0000000d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 000000d0d4d0d0d4d0d0d4d0d0d4d0909490000000d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0f8fcf8d0d4d0d0d4d0d0d4d0 000000d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0000000d0d4d0d0d4d0000000d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0000000000000 000000d0d4d0d0d4d0d0d4d0d0d4d0909490000000d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0f8fcf8d0d4d0d0d4d0d0d4d0 000000d0d4d0000000000000d0d4d0d0d4d0d0d4d0000000d0d4d0d0d4d0d0d4d0000000 d0d4d0000000000000000000000000000000000000d0d4d0d0d4d0000000000000000000 d0d4d0d0d4d0d0d4d0000000d0d4d0000000000000d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 000000d0d4d0d0d4d0d0d4d0d0d4d0909490000000d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0f8fcf8d0d4d0d0d4d0d0d4d0 000000000000d0d4d0d0d4d0000000d0d4d0d0d4d0000000d0d4d0d0d4d0d0d4d0000000 d0d4d0d0d4d0000000d0d4d0d0d4d0000000d0d4d0d0d4d0000000d0d4d0d0d4d0d0d4d0 000000d0d4d0d0d4d0000000000000d0d4d0d0d4d0000000d0d4d0d0d4d0d0d4d0d0d4d0 000000d0d4d0d0d4d0d0d4d0d0d4d0909490000000d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0f8fcf8d0d4d0d0d4d0d0d4d0 000000d0d4d0d0d4d0d0d4d0000000d0d4d0d0d4d0000000d0d4d0d0d4d0d0d4d0000000 d0d4d0d0d4d0000000d0d4d0d0d4d0000000d0d4d0d0d4d0000000d0d4d0d0d4d0d0d4d0 000000d0d4d0d0d4d0000000d0d4d0d0d4d0d0d4d0000000d0d4d0d0d4d0d0d4d0d0d4d0 000000d0d4d0d0d4d0d0d4d0d0d4d0909490000000d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0f8fcf8d0d4d0d0d4d0d0d4d0 000000d0d4d0d0d4d0d0d4d0000000d0d4d0d0d4d0000000d0d4d0d0d4d0d0d4d0000000 d0d4d0d0d4d0000000d0d4d0d0d4d0000000d0d4d0d0d4d0000000d0d4d0d0d4d0d0d4d0 000000d0d4d0d0d4d0000000d0d4d0d0d4d0d0d4d0000000d0d4d0d0d4d0d0d4d0d0d4d0 000000d0d4d0d0d4d0d0d4d0d0d4d0909490000000d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0f8fcf8d0d4d0d0d4d0d0d4d0 000000d0d4d0d0d4d0d0d4d0000000d0d4d0d0d4d0000000d0d4d0d0d4d0d0d4d0000000 d0d4d0d0d4d0000000d0d4d0d0d4d0000000d0d4d0d0d4d0000000d0d4d0d0d4d0d0d4d0 000000d0d4d0d0d4d0000000d0d4d0d0d4d0d0d4d0000000d0d4d0d0d4d0d0d4d0d0d4d0 000000d0d4d0d0d4d0d0d4d0d0d4d0909490000000d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0f8fcf8d0d4d0d0d4d0d0d4d0 000000000000d0d4d0d0d4d0000000d0d4d0d0d4d0000000d0d4d0d0d4d0000000000000 d0d4d0d0d4d0000000d0d4d0d0d4d0000000d0d4d0d0d4d0000000d0d4d0d0d4d0d0d4d0 000000d0d4d0d0d4d0000000d0d4d0d0d4d0d0d4d0000000d0d4d0d0d4d0d0d4d0d0d4d0 000000d0d4d0d0d4d0d0d4d0d0d4d0909490000000d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0f8fcf8d0d4d0d0d4d0d0d4d0 000000d0d4d0000000000000d0d4d0d0d4d0d0d4d0d0d4d0000000000000d0d4d0000000 d0d4d0d0d4d0000000000000d0d4d0000000000000d0d4d0d0d4d0000000000000000000 d0d4d0d0d4d0d0d4d0000000d0d4d0d0d4d0d0d4d0000000d0d4d0d0d4d0d0d4d0d0d4d0 000000d0d4d0d0d4d0d0d4d0d0d4d0909490000000d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0f8fcf8d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0909490000000d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0f8fcf8d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0909490000000d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0f8fcf8d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0909490000000d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0f8fcf8d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0909490000000d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0f8fcf8d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0909490000000d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0f8fcf8d0d4d0909490909490 909490909490909490909490909490909490909490909490909490909490909490909490 909490909490909490909490909490909490909490909490909490909490909490909490 909490909490909490909490909490909490909490909490909490909490909490909490 909490909490909490909490909490909490000000d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0000000000000000000000000 000000000000000000000000000000000000000000000000000000000000000000000000 000000000000000000000000000000000000000000000000000000000000000000000000 000000000000000000000000000000000000000000000000000000000000000000000000 000000000000000000000000000000000000000000d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0000000000000000000000000 000000000000000000000000000000000000000000000000000000000000000000000000 000000000000000000000000000000000000000000000000000000000000000000000000 000000000000000000000000000000000000000000000000000000000000000000000000 000000000000000000000000000000000000000000d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0000000888888888888888888 888888888888888888888888888888888888888888888888888888888888888888888888 888888888888888888888888888888888888888888888888888888888888888888888888 888888888888888888888888888888888888888888888888888888888888888888888888 888888888888888888888888888888888888000000d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0000000888888000000000000 000000000000000000000000000000000000000000000000000000000000000000000000 000000000000000000000000000000000000000000000000000000000000000000000000 000000000000000000000000000000000000000000000000000000000000000000000000 000000000000000000000000000000f8fcf8000000d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0000000888888000000c0c0c0 c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0 c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0 c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0 c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0f8fcf8000000d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0000000888888000000c0c0c0 c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0 c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0 c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0 c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0f8fcf8000000d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0000000888888000000c0c0c0 c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0 c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0 c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0 c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0f8fcf8000000d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0000000888888000000c0c0c0 000000c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0 c0c0c0c0c0c0000000c0c0c0c0c0c0000000c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0 c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0000000 000000000000c0c0c0c0c0c0c0c0c0f8fcf8000000d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0000000888888000000c0c0c0 000000c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0 c0c0c0c0c0c0000000c0c0c0c0c0c0000000c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0 c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0000000c0c0c0 c0c0c0c0c0c0000000c0c0c0c0c0c0f8fcf8000000d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0000000888888000000c0c0c0 000000c0c0c0000000000000c0c0c0c0c0c0c0c0c0000000c0c0c0c0c0c0c0c0c0000000 c0c0c0000000000000000000000000000000000000c0c0c0c0c0c0000000000000000000 c0c0c0c0c0c0c0c0c0000000c0c0c0000000000000c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0 c0c0c0c0c0c0000000c0c0c0c0c0c0f8fcf8000000d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0000000888888000000c0c0c0 000000000000c0c0c0c0c0c0000000c0c0c0c0c0c0000000c0c0c0c0c0c0c0c0c0000000 c0c0c0c0c0c0000000c0c0c0c0c0c0000000c0c0c0c0c0c0000000c0c0c0c0c0c0c0c0c0 000000c0c0c0c0c0c0000000000000c0c0c0c0c0c0000000c0c0c0c0c0c0c0c0c0c0c0c0 c0c0c0000000c0c0c0c0c0c0c0c0c0f8fcf8000000d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0000000888888000000c0c0c0 000000c0c0c0c0c0c0c0c0c0000000c0c0c0c0c0c0000000c0c0c0c0c0c0c0c0c0000000 c0c0c0c0c0c0000000c0c0c0c0c0c0000000c0c0c0c0c0c0000000c0c0c0c0c0c0c0c0c0 000000c0c0c0c0c0c0000000c0c0c0c0c0c0c0c0c0000000c0c0c0c0c0c0c0c0c0c0c0c0 000000c0c0c0c0c0c0c0c0c0c0c0c0f8fcf8000000d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0000000888888000000c0c0c0 000000c0c0c0c0c0c0c0c0c0000000c0c0c0c0c0c0000000c0c0c0c0c0c0c0c0c0000000 c0c0c0c0c0c0000000c0c0c0c0c0c0000000c0c0c0c0c0c0000000c0c0c0c0c0c0c0c0c0 000000c0c0c0c0c0c0000000c0c0c0c0c0c0c0c0c0000000c0c0c0c0c0c0c0c0c0000000 c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0f8fcf8000000d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0000000888888000000c0c0c0 000000c0c0c0c0c0c0c0c0c0000000c0c0c0c0c0c0000000c0c0c0c0c0c0c0c0c0000000 c0c0c0c0c0c0000000c0c0c0c0c0c0000000c0c0c0c0c0c0000000c0c0c0c0c0c0c0c0c0 000000c0c0c0c0c0c0000000c0c0c0c0c0c0c0c0c0000000c0c0c0c0c0c0000000c0c0c0 c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0f8fcf8000000d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0000000888888000000c0c0c0 000000000000c0c0c0c0c0c0000000c0c0c0c0c0c0000000c0c0c0c0c0c0000000000000 c0c0c0c0c0c0000000c0c0c0c0c0c0000000c0c0c0c0c0c0000000c0c0c0c0c0c0c0c0c0 000000c0c0c0c0c0c0000000c0c0c0c0c0c0c0c0c0000000c0c0c0c0c0c0000000c0c0c0 c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0f8fcf8000000d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0000000888888000000c0c0c0 000000c0c0c0000000000000c0c0c0c0c0c0c0c0c0c0c0c0000000000000c0c0c0000000 c0c0c0c0c0c0000000000000c0c0c0000000000000c0c0c0c0c0c0000000000000000000 c0c0c0c0c0c0c0c0c0000000c0c0c0c0c0c0c0c0c0000000c0c0c0c0c0c0000000000000 000000000000000000c0c0c0c0c0c0f8fcf8000000d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0000000888888000000c0c0c0 c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0 c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0 c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0 c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0f8fcf8000000d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0000000888888000000c0c0c0 c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0 c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0 c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0 c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0f8fcf8000000d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0000000888888000000c0c0c0 c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0 c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0 c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0 c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0f8fcf8000000d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0000000888888000000c0c0c0 c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0 c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0 c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0 c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0f8fcf8000000d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0000000888888000000c0c0c0 c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0 c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0 c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0 c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0f8fcf8000000d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0000000888888f8fcf8f8fcf8 f8fcf8f8fcf8f8fcf8f8fcf8f8fcf8f8fcf8f8fcf8f8fcf8f8fcf8f8fcf8f8fcf8f8fcf8 f8fcf8f8fcf8f8fcf8f8fcf8f8fcf8f8fcf8f8fcf8f8fcf8f8fcf8f8fcf8f8fcf8f8fcf8 f8fcf8f8fcf8f8fcf8f8fcf8f8fcf8f8fcf8f8fcf8f8fcf8f8fcf8f8fcf8f8fcf8f8fcf8 f8fcf8f8fcf8f8fcf8f8fcf8f8fcf8f8fcf8000000d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0000000000000000000000000 000000000000000000000000000000000000000000000000000000000000000000000000 000000000000000000000000000000000000000000000000000000000000000000000000 000000000000000000000000000000000000000000000000000000000000000000000000 000000000000000000000000000000000000000000d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0d0d4d0 d0d4d0d0d4d0 showpage % stop using temporary dictionary end % restore original state origstate restore %%Trailer gtkada-24.0.0/docs/gtkada_rm/togglebutton.jpg000066400000000000000000000040041446021174000211250ustar00rootroot00000000000000JFIFXCREATOR: XV Version 3.10a Rev: 12/29/94 (PNG patch 1.2) Quality = 75, Smoothing = 0 C    $.' ",#(7),01444'9=82<.342C  2!!22222222222222222222222222222222222222222222222222C>" }!1AQa"q2#BR$3br %&'()*456789:CDEFGHIJSTUVWXYZcdefghijstuvwxyz w!1AQaq"2B #3Rbr $4%&'()*56789:CDEFGHIJSTUVWXYZcdefghijstuvwxyz ?*HcpAơwN ʾ.yPƭ#FэH$"M4}_528.g7hZ- .UF2x Wo7i}<y{~ϝYwƏ5' p<*J2FJ@̛̿|Zݬ~>L@#Ȭp<ªpHpvӂq@7ŧۉeD@ w'`=5C[žԼ+wl^7c8z++^ڞ,4W0 ˲ycFCmǖNpzc]ZœCGj-MdKTDLn,F$;gW9l~Wd5AlY/\618nK4=Go?dR3O5ItFd{4.>k"m^ǯ*J9sJ]5}GKdf( x:ZKw]XKŽ*V4r)$a> endobj 2 0 obj << /Type /Catalog /Pages 3 0 R >> endobj 3 0 obj << /Type /Pages /Kids [ 4 0 R ] /Count 1 >> endobj 4 0 obj << /Type /Page /Parent 3 0 R /Resources << /Font << /F0 8 0 R >> /XObject << /Im0 9 0 R >> /ProcSet 7 0 R >> /MediaBox [0 0 612 792] /CropBox [275 362 337 429] /Contents 5 0 R /Thumb 12 0 R >> endobj 5 0 obj << /Length 6 0 R >> stream q 62 0 0 67 275 362 cm /Im0 Do Q endstream endobj 6 0 obj 33 endobj 7 0 obj [ /PDF /Text /ImageC ] endobj 8 0 obj << /Type /Font /Subtype /Type1 /Name /F0 /BaseFont /Helvetica /Encoding /MacRomanEncoding >> endobj 9 0 obj << /Type /XObject /Subtype /Image /Name /Im0 /Filter [ /DCTDecode ] /Width 62 /Height 67 /ColorSpace 11 0 R /BitsPerComponent 8 /Length 10 0 R >> stream JFIFHHXCREATOR: XV Version 3.10a Rev: 12/29/94 (PNG patch 1.2) Quality = 75, Smoothing = 0 C    $.' ",#(7),01444'9=82<.342C  2!!22222222222222222222222222222222222222222222222222C>"5!"12R#3STVaQqAB ?ZiRA1:d_m)7i*UTʆ5i6mXbDy'$FM;Q*vwU\jAQ9Fkeu0rp"7(ΟVo.fǽ}vUwUGDkKS?iui ^%i#%~@lj7C9E}[tsW;O& V8ªpHpvӂqcY4TzQ#2G!e(ힽ5o7^r]?/v危 >xvҫѸmZ9 4U0 Ks9e suܭtz.+fq =;V9:5|'s5=Iw&R\018QhڟRnCNuyݼY'h,IoR·9lmӲgȲsmr ǯ$42G嗕=-< ѼsbE:YݼY'h,IoB[gpվfFTg25ez\n9`J38ۏ#窍D9^7RCAj\Śi"it J'| Yy'HS{uaJLzR SҭdH!`8!|@o,~J~w_tñs;f|y۪EWVįʟ۫WeODwn^%gE:_3v=j=c4i` ;0![n1kC^i$2[K3PY@T%zk%UƎI(RbBKz ?^\MK )%vMvNp|^; ]8zش4Q|ۦ.QP3ttzUU([s[Z˳FsGی{5_4` /!6pî+OOR ܥ|H=EQD6^9C:[.R\*h%^ +FHYATܒ`0^M?LZ;?LZuDUtYL+)cc7`M *IBj%jF ѣFѣFѣF endstream endobj 10 0 obj 1635 endobj 11 0 obj /DeviceRGB endobj 12 0 obj << /Filter [ /DCTDecode ] /Width 62 /Height 67 /ColorSpace 11 0 R /BitsPerComponent 8 /Length 13 0 R >> stream JFIFHHXCREATOR: XV Version 3.10a Rev: 12/29/94 (PNG patch 1.2) Quality = 75, Smoothing = 0 C    $.' ",#(7),01444'9=82<.342C  2!!22222222222222222222222222222222222222222222222222C>"5!"12R#3STVaQqAB ?ZiRA1:d_m)7i*UTʆ5i6mXbDy'$FM;Q*vwU\jAQ9Fkeu0rp"7(ΟVo.fǽ}vUwUGDkKS?iui ^%i#%~@lj7C9E}[tsW;O& V8ªpHpvӂqcY4TzQ#2G!e(ힽ5o7^r]?/v危 >xvҫѸmZ9 4U0 Ks9e suܭtz.+fq =;V9:5|'s5=Iw&R\018QhڟRnCNuyݼY'h,IoR·9lmӲgȲsmr ǯ$42G嗕=-< ѼsbE:YݼY'h,IoB[gpվfFTg25ez\n9`J38ۏ#窍D9^7RCAj\Śi"it J'| Yy'HS{uaJLzR SҭdH!`8!|@o,~J~w_tñs;f|y۪EWVįʟ۫WeODwn^%gE:_3v=j=c4i` ;0![n1kC^i$2[K3PY@T%zk%UƎI(RbBKz ?^\MK )%vMvNp|^; ]8zش4Q|ۦ.QP3ttzUU([s[Z˳FsGی{5_4` /!6pî+OOR ܥ|H=EQD6^9C:[.R\*h%^ +FHYATܒ`0^M?LZ;?LZuDUtYL+)cc7`M *IBj%jF ѣFѣFѣF endstream endobj 13 0 obj 1635 endobj xref 0 16 0000000000 65535 f 0000000010 00000 n 0000000141 00000 n 0000000190 00000 n 0000000249 00000 n 0000000457 00000 n 0000000542 00000 n 0000000560 00000 n 0000000598 00000 n 0000000706 00000 n 0000002520 00000 n 0000002541 00000 n 0000002568 00000 n 0000004341 00000 n 0000000000 00000 n 0000000000 00000 n trailer << /Size 16 /Info 1 0 R /Root 2 0 R >> startxref 4362 %%EOF gtkada-24.0.0/docs/gtkada_rm/tree.png000066400000000000000000000002221446021174000173510ustar00rootroot00000000000000PNG  IHDR bKGD pHYs  2IDAT8c`dC?!@8`CׅdB S+y ~y '>IENDB`gtkada-24.0.0/docs/gtkada_rm/treeclose.png000066400000000000000000000003021446021174000203760ustar00rootroot00000000000000PNG  IHDR &qbKGD pHYs  tIME 3 %@OIDATӅP 0K}X<֤_!̔_mfX9H@ʐ;QZw‰};#߈R& D8(jLIENDB`gtkada-24.0.0/docs/gtkada_rm/treeopen.png000066400000000000000000000002701446021174000202360ustar00rootroot00000000000000PNG  IHDR &qbKGD pHYs  tIME 30YEIDATӕPA gѡ͵ZY) W8nvy\6T7,Y]s\^^KkG+IENDB`gtkada-24.0.0/docs/gtkada_ug/000077500000000000000000000000001446021174000157055ustar00rootroot00000000000000gtkada-24.0.0/docs/gtkada_ug/Makefile000066400000000000000000000107761446021174000173600ustar00rootroot00000000000000# Makefile for Sphinx documentation # # You can set these variables from the command line. SPHINXOPTS = SPHINXBUILD = sphinx-build PAPER = BUILDDIR = _build # Internal variables. PAPEROPT_a4 = -D latex_paper_size=a4 PAPEROPT_letter = -D latex_paper_size=letter ALLSPHINXOPTS = -d $(BUILDDIR)/doctrees $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) . .PHONY: help clean html dirhtml singlehtml pickle json htmlhelp qthelp devhelp epub latex latexpdf text man changes linkcheck doctest help: @echo "Please use \`make ' where is one of" @echo " html to make standalone HTML files" @echo " dirhtml to make HTML files named index.html in directories" @echo " singlehtml to make a single large HTML file" @echo " pickle to make pickle files" @echo " json to make JSON files" @echo " htmlhelp to make HTML files and a HTML help project" @echo " qthelp to make HTML files and a qthelp project" @echo " devhelp to make HTML files and a Devhelp project" @echo " epub to make an epub" @echo " latex to make LaTeX files, you can set PAPER=a4 or PAPER=letter" @echo " latexpdf to make LaTeX files and run them through pdflatex" @echo " text to make text files" @echo " man to make manual pages" @echo " changes to make an overview of all changed/added/deprecated items" @echo " linkcheck to check all external links for integrity" @echo " doctest to run all doctests embedded in the documentation (if enabled)" clean: -rm -rf $(BUILDDIR) distclean: clean html: $(SPHINXBUILD) -b html $(ALLSPHINXOPTS) $(BUILDDIR)/html @echo @echo "Build finished. The HTML pages are in $(BUILDDIR)/html." dirhtml: $(SPHINXBUILD) -b dirhtml $(ALLSPHINXOPTS) $(BUILDDIR)/dirhtml @echo @echo "Build finished. The HTML pages are in $(BUILDDIR)/dirhtml." singlehtml: $(SPHINXBUILD) -b singlehtml $(ALLSPHINXOPTS) $(BUILDDIR)/singlehtml @echo @echo "Build finished. The HTML page is in $(BUILDDIR)/singlehtml." pickle: $(SPHINXBUILD) -b pickle $(ALLSPHINXOPTS) $(BUILDDIR)/pickle @echo @echo "Build finished; now you can process the pickle files." json: $(SPHINXBUILD) -b json $(ALLSPHINXOPTS) $(BUILDDIR)/json @echo @echo "Build finished; now you can process the JSON files." htmlhelp: $(SPHINXBUILD) -b htmlhelp $(ALLSPHINXOPTS) $(BUILDDIR)/htmlhelp @echo @echo "Build finished; now you can run HTML Help Workshop with the" \ ".hhp project file in $(BUILDDIR)/htmlhelp." qthelp: $(SPHINXBUILD) -b qthelp $(ALLSPHINXOPTS) $(BUILDDIR)/qthelp @echo @echo "Build finished; now you can run "qcollectiongenerator" with the" \ ".qhcp project file in $(BUILDDIR)/qthelp, like this:" @echo "# qcollectiongenerator $(BUILDDIR)/qthelp/GtkAda.qhcp" @echo "To view the help file:" @echo "# assistant -collectionFile $(BUILDDIR)/qthelp/GtkAda.qhc" devhelp: $(SPHINXBUILD) -b devhelp $(ALLSPHINXOPTS) $(BUILDDIR)/devhelp @echo @echo "Build finished." @echo "To view the help file:" @echo "# mkdir -p $$HOME/.local/share/devhelp/GtkAda" @echo "# ln -s $(BUILDDIR)/devhelp $$HOME/.local/share/devhelp/GtkAda" @echo "# devhelp" epub: $(SPHINXBUILD) -b epub $(ALLSPHINXOPTS) $(BUILDDIR)/epub @echo @echo "Build finished. The epub file is in $(BUILDDIR)/epub." latex: $(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex @echo @echo "Build finished; the LaTeX files are in $(BUILDDIR)/latex." @echo "Run \`make' in that directory to run these through (pdf)latex" \ "(use \`make latexpdf' here to do that automatically)." latexpdf: $(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex @echo "Running LaTeX files through pdflatex..." make -C $(BUILDDIR)/latex all-pdf @echo "pdflatex finished; the PDF files are in $(BUILDDIR)/latex." text: $(SPHINXBUILD) -b text $(ALLSPHINXOPTS) $(BUILDDIR)/text @echo @echo "Build finished. The text files are in $(BUILDDIR)/text." man: $(SPHINXBUILD) -b man $(ALLSPHINXOPTS) $(BUILDDIR)/man @echo @echo "Build finished. The manual pages are in $(BUILDDIR)/man." changes: $(SPHINXBUILD) -b changes $(ALLSPHINXOPTS) $(BUILDDIR)/changes @echo @echo "The overview file is in $(BUILDDIR)/changes." linkcheck: $(SPHINXBUILD) -b linkcheck $(ALLSPHINXOPTS) $(BUILDDIR)/linkcheck @echo @echo "Link check complete; look for any errors in the above output " \ "or in $(BUILDDIR)/linkcheck/output.txt." doctest: $(SPHINXBUILD) -b doctest $(ALLSPHINXOPTS) $(BUILDDIR)/doctest @echo "Testing of doctests in the sources finished, look at the " \ "results in $(BUILDDIR)/doctest/output.txt." gtkada-24.0.0/docs/gtkada_ug/adacore_transparent.png000066400000000000000000000151101446021174000224300ustar00rootroot00000000000000PNG  IHDR3 tEXtSoftwareAdobe ImageReadyqe<IDATx]xյ>3[$Ydٖ-86ǘ$ Sb Nz!pxĔ4 <ӛ!Wܰdny]}}̝[{ν3ϱ +X?C%*wNE%18. Ik*YG:1֮w%qK=MXZDkC_ndmj{ֳXەc?b7 X?Z pZqv'ޯhx4֏+ 4pÇ0C&u+Ye'HE"Xg4.ugMb}un~N6na̺uFyz/3.:4z߷ J] XaIѬKHǝ|_zK}ڟ2]kK2`5;пT V=()292}6mvGC!,62lXW'U?9`\P5!:>|^\@%^[n]:yYkXq 9W2덬V5BLKf 2WATy A`񬗀fԅP-w X\'pHXwdjOagY ubf*kź~;):v,n*?HZ@t>,a$pQomu HgD QɵwK~BPF&(6j 5U֋r4 ԋ ATvCt g =$f(w,/UfB귔ZCIZ:<[5k Tg16V]0øM54qt VTʿM- LeJ$|]E37M uJTqwReESpլG: 0եKϡRǕjCJQ֧J*Kr n#>pG߆eEmp5賀c.}6v,u:F5 !Y mL+Bǎ2'ʘKO}4(Z&Gחe p 7a 8/و,$1)D&}[տnh0:@*  d#,ֻ@YBʝ`䯬eX,m&+!}TiR(vAIڱsXsd2'Tyy ­Do!Xe^:; ټA*㗇 mޜVݢB%m&,W1n'icֿ02< 2p|_["=)}֎TIJ,=8hW kبrkH&r-C8$ 975.T}' -j]}`-S ZY^Kpz[vRǑ UjgR]&2 mEfR^نtH*)L^4|3Wu~ӄ[ `&in S&7pǥ8j7ej?]t!VSVBǖ,*^ӳ3i˚NN6ЏѶ^7s7T݀ \>c 7wH^ntnگٟю:4YJeTj2\$끖1>ޏ]) U9+ՆI?`| 3Iv-H+@ {S"y1 ؕo`H \{go50Ao|Cj!zYs1r6TE"oشgw*Ok*:jn-^z>p Yez2<|ko ;)ьΜ +a?]`DBxu13O ![ [ DԖl*7Ȏ*٘2غz{(g`!Fh D& 癃Rh2 PT)g! `*D%AIi4't(8dO-$%퐅#.F$z>7 Xՠ`G+oVv5A9zVL"Yrd;KBħWΆWD%ih0BEs Whl#:m*~,7xeR$S{TqMïiY+Y2o5K!ގz|i_ԮyD.at;2VnbET]L(Oըx [f3\3A! x7S~$U Kܐ%|Ά;ipm4pz2 .3wB\UIL#7 PE}-۰R\)oQygLkGݕ߂qf#Zg@k 즽#2QOʄdk*1(x.4b Ͻokl ae#pIp#` mW#ePWP(. ݦ=k#Qڴ%edQr} Y e[&Ajp) pJҧѶpU;G|n2׎ļu$ ,#8p @0{\5z2y,+GG/'*q๝ O${/!ӑz-+发4)kii.el 9Nw'A~/VN ;B;{l%,)[rƤ؉I4MێJZ-V-hUCq+qT!Svd#30x70LŽҚ.֙H̓vO4ec=DzHu`;&WS+?f/Hiǐ͠TP$^N[A+@k,59߳\N92Adr3nJKG3k&뀥^Ӷ:6Lm䦻> 劜=l4rG:F 8'c5zǢ(f耲.^ZFű{:CFviJpgƂK;J ƴ}`Qڛ\m]# (ނ+/^.@ezykxTe;}z#4O &@Sf$[G9?PYkpLSq[p|w_XWG㻔6D-^GNR_YfV_vH+,S3Ѵcww8qw|XnR^ﮇ.--o_ mz4HΠ]}:!m~&HKtJMTo=Xc|iRr.%P5"Վ h"QVNRTKWV{9UIK\-G QiH iK=6쉕m s\~7zOi8<ȼg"(+a*{QUB[mBvGgQKF ?o8V#R2ŧP,Qzo Vz bbqU’ݍ=]&Ɵ;e7F^v!}BL;=x=ϑ:^Ʋm B6biKaTq1VpH=G&J}+nΓEЖ~Yi/wD4<$$FF[) Xۘ +1X_E~3 @@} ѭ_("ze$&Db]8v F" lJ+X,eיX)Xw2l_"S"x˰^OV_>q\Wb,r5X1a/싈N*Q>G'Vm70CoRȓ :q-jn .PR!oULq{4 &g0I&&ef d3 01~vOU*`MKџo`~ ,pDϣ*j<Ώgb߅-g.cӈ?_BQ<#9ʾ4 ~?FpcV An[1r#?Pm}\o1(f/ HeAK9mq"?0L[RqhȪQ֠.e C T٭-@*#Oo Me ve#b]TƔ$|C$?c~riXـ? '8~('p[sp}.r*"`e|U^#7D&A^ouûT N<.i.ÐIUO {Qa)MϹ%l,ET>lKjiMVFIb944Xp۩{n_(/Wa}m-n%&ֵhO3NaGP1]v~ceT${.ht{DBX~/GEӊ2h'j v@+-HloiQtD`56s W]W7+x;RT:tCPxF#erId4։6(4`@˝Q2'IgAYޕLi[Q7:-ŵQ0׃;|م1NڼNIIۂ_{+[bW?u乌8$!hxx]Q*] XfTF&[OKXWIENDB`gtkada-24.0.0/docs/gtkada_ug/applications.rst000066400000000000000000000022661446021174000211330ustar00rootroot00000000000000.. _Starting_an_application_with_GtkAda: *********************************** Starting an application with GtkAda *********************************** You need to perform some initializations to start a GtkAda application:: -- predefined units of the library with Gtk.Main; with Gtk.Enums; with Gtk.Window; ... -- My units with Callbacks; ... procedure Application is procedure Create_Window is ... begin -- Set the locale specific datas (e.g time and date format) Gtk.Main.Set_Locale; -- Initializes GtkAda Gtk.Main.Init; -- Create the main window Create_Window; -- Signal handling loop Gtk.Main.Main; end Application; the `Create_Window` procedure looks like:: procedure Create_Window is Main_Window : Gtk.Window.Gtk_Window; ... begin Gtk.Window.Gtk_New (Window => Main_Window, The_Type => Gtk.Enums.Window_Toplevel); -- From Gtk.Widget: Gtk.Window.Set_Title (Window => Main_Window, Title => "Editor"); -- Construct the window and connect various callbacks ... Gtk.Window.Show_All (Main_Window); end Create_Window; gtkada-24.0.0/docs/gtkada_ug/bibliography.rst000066400000000000000000000012751446021174000211170ustar00rootroot00000000000000************ Bibliography ************ We recommand the following documents. Most of them were written with C in mind, but should be easily adapted after you've read the rest of this document. * [1] "Gtk+/Gome Application Development" -- Havoc Pennington This book, by one of the main authors of the the GNOME environment, describes in detail some of the inner mechanisms of gtk+, including signal handling, and a complete description of all the widgets and all the events found in `Gdk.Event`. It is worth noting that this book has been published under the Open Publication License. You can get an electronic copy of it at `http://www.opencontent.org/ `_. gtkada-24.0.0/docs/gtkada_ug/boxes.fig000066400000000000000000000023741446021174000175220ustar00rootroot00000000000000#FIG 3.2 Landscape Center Inches Letter 100.00 Single -2 1200 2 2 5 0 1 0 -1 0 0 -1 0.000 0 0 -1 0 0 5 0 boxes.gif 450 525 6810 525 6810 8325 450 8325 450 525 2 1 0 1 0 7 0 0 -1 0.000 0 0 -1 0 1 2 0 0 1.00 60.00 120.00 4050 900 7650 900 2 1 0 1 0 7 0 0 -1 0.000 0 0 -1 0 1 2 0 0 1.00 60.00 120.00 4500 1200 7650 1200 2 1 0 1 0 7 0 0 -1 0.000 0 0 -1 0 1 2 0 0 1.00 60.00 120.00 5850 1575 7650 1575 2 1 0 1 0 7 0 0 -1 0.000 0 0 -1 0 1 2 0 0 1.00 60.00 120.00 6000 3375 7650 3375 2 1 0 1 0 7 0 0 -1 0.000 0 0 -1 0 1 2 0 0 1.00 60.00 120.00 6000 4275 7650 4275 2 1 0 1 0 7 0 0 -1 0.000 0 0 -1 0 1 2 0 0 1.00 60.00 120.00 6450 5175 7575 5175 2 1 0 1 0 7 0 0 -1 0.000 0 0 -1 0 1 2 0 0 1.00 60.00 120.00 4950 6600 7575 6600 2 1 0 1 0 7 0 0 -1 0.000 0 0 -1 0 1 2 0 0 1.00 60.00 120.00 5550 6975 7575 6975 4 0 0 0 0 0 12 0.0000 4 180 675 7725 1275 Gtk_Box\001 4 0 0 0 0 0 12 0.0000 4 180 1005 7725 975 Gtk_Window\001 4 0 0 0 0 0 12 0.0000 4 180 675 7725 1650 Gtk_Box\001 4 0 0 0 0 0 12 0.0000 4 180 1110 7725 3450 Gtk_Separator\001 4 0 0 0 0 0 12 0.0000 4 180 675 7725 4350 Gtk_Box\001 4 0 0 0 0 0 12 0.0000 4 180 885 7650 5250 Gtk_Button\001 4 0 0 0 0 0 12 0.0000 4 180 885 7650 6675 Gtk_Button\001 4 0 0 0 0 0 12 0.0000 4 180 795 7650 7050 Gtk_Label\001 gtkada-24.0.0/docs/gtkada_ug/boxes.png000066400000000000000000000121701446021174000175340ustar00rootroot00000000000000PNG  IHDR PLTE2լ{˘; wbKGD- pHYsHHFk>IDATxmvT,NK< 9=_- @rPE췟1v~oW6m# ???, چ?Q,O*Nm3dm6SO$3 m FO}*V+jJ%+BKAFjgq@m`ߍJ&ڠmRgu8 6N`q@mvPi:YPfu 6h;Y9,G {R)rXP9T\=utY,{ \*UV˖jT<-m&+eM}=*MV>˚j6JU$>"eIA[@*d@m`߀JU2'ڠ-Rcuay&! 3m*-VWBm` +d6J2Y {RbLP aRAT:TP*J HRBS@* Vxk*J R`U@uIR`U@uI* SŨJT1*q"p FJܪ*H* `DʨTq*aB* FJتK*`$dJT)*Qb*w FJԪI*r`$$ʩTi*A+չ#M%hE:Re(T jO"Qk0rTbV$-UJʊFRIYѨTy*!+"պ#O%dEZR!dT jN"Sk00T"Vdg*j8* +:dqTVTQ XUPM#U7U QuQuQQBRuD٪j4ZRM4ZUSibRhUOЊJ>+*uVTxYPibRfC̊J.+6*UV\T4YQibRdGȊJ#+V*5VTjxXRibRbKĊJ3+v*VT*4XSij@JU *yTVMĭZP[jB%mՈJت U+*YFTVͨDZQZjF%iՐJЪUK*9TrVMĬZRYjJ%e՘JȪ-Uk*T2VͩDZSXjN%aՁJ=UV[unՃUV]z[ulՇjv'*nE5!^Tiu7*ս&d]݊"EeVZWZ^"nHվAZ݊"EoD_-TRl]-U5?EpAesUWU5`ꤪ ;SM:j:WUn~PXuMʡ8ս/B޾վU@f__ýUH'`_^^ y*T@x{{* 5ޞ "B_݋ ooNnN{SHkPaoM%5 ƬnEeܙ*$Y݊*Avcxx{*h/Uޖ >YZ݋*Zo1VQ§k,DU?X6~gqT+**M SWi* wE k%Z᭷P!4VLU iJKUmVY*rT(+U eSaV-TAGz<'a* < tU-0TwI/d l8*UM*ZZX!X~=J⨔XaN+ᨴYQ)JmtXk}G ]Us]atXx-Jc J6S4Ye-JU[d}} G%o j8*y+QI[O+o JJU:nT_H*Y+5r*ue2mQZV,WqTVQsTJ(c@54U 'v=0K%hUzZ1SyG`s&o\HX37ͭd6N[=>RŭL5ɶQulcE*Uz|T2;*E[Ld>{TT\bVX@9滛*PG*jjm 3'yTɪfV{`PTQ ZUiUzVV&dsT`RV8GFi 2TQjQup?lU]vVX;jpTs;̹EzeuP+iR TͬȧS}U***TU KUTU*N+V>,on*F & |U?-VUU K5RMUimʻep~}} z ,UMU_ajͪ财9U&uU_ں lVsTuUd:PWUXa[BU92j2R,V'TW%TU`~u)9*K1CUm5"WBz ,}ܩVU2eFUie-VSHTu,r~չ*SDTLUgE3RqUUU*v۟z ,[Uqί*z*3MkX*e QVSHZUTJVX*ުb_]y2To?~8HM_E?U-Ϟ9RqWUX*j:jWUPx)snь}r?X@U<b]bUU3fO5R* ڪzWZUJU;>Gwՙ|Ez2ֳTUxJJk-QVcx?DgWUiŜjβzfE IU5z?ѐ*RAT ϪT+u3OT_TrL*jJ[y!Du7jn^u2UlSLE*Wk?0GZ`+xN\*bmUELϳbӪ۽c=U )վx]ѩT#q \_hk+KcHKuϱ⪪9:".S TuEZSURrV+ rm]*gF)+ `HH/UWgz?_7U%Uq*wٵȳmZWkq J*o1pD~5U5Uaxg:?|r B*W!F奂L@U}CԳkq0Uh] ~L䧄R Ϯ=WpA~mmpUTQӟm[겿cGMme"u51ɣ?۶.p^|DcGMm]`!T# bŗj/SP| o{^{?'|x-%tEXtdate:create2011-12-08T15:54:08+01:00|^%tEXtdate:modify2009-03-31T00:58:45+02:00~cIENDB`gtkada-24.0.0/docs/gtkada_ug/conf.py000066400000000000000000000204531446021174000172100ustar00rootroot00000000000000# -*- coding: utf-8 -*- # # GtkAda documentation build configuration file, created by # sphinx-quickstart on Thu Dec 8 15:31:22 2011. # # This file is execfile()d with the current directory set to its containing # dir. # # Note that not all possible configuration values are present in this # autogenerated file. # # All configuration values have a default; values that are commented out # serve to show the default. import time # If extensions (or modules to document with autodoc) are in another directory, # add these directories to sys.path here. If the directory is relative to the # documentation root, use os.path.abspath to make it absolute, like shown here. # sys.path.insert(0, os.path.abspath('.')) # -- General configuration ---------------------------------------------------- # If your documentation needs a minimal Sphinx version, state it here. # needs_sphinx = '1.0' # Add any Sphinx extension module names here, as strings. They can be # extensions coming with Sphinx (named 'sphinx.ext.*') or your custom ones. extensions = [ 'sphinx.ext.viewcode', 'sphinx_rtd_theme', ] # Add any paths that contain templates here, relative to this directory. templates_path = ['_templates'] # The suffix of source filenames. source_suffix = '.rst' # The encoding of source files. # source_encoding = 'utf-8-sig' # The master toctree document. master_doc = 'index' def get_copyright(): return u'2000-%s, AdaCore' % time.strftime("%Y") # General information about the project. project = u'GtkAda' copyright = get_copyright() def get_version(): for line in open("../../configure.ac").readlines(): if line.startswith("AC_INIT"): return line.split(",")[1] raise Exception("Cannot find version number") # The version info for the project you're documenting, acts as replacement for # |version| and |release|, also used in various other places throughout the # built documents. # # The short X.Y version. version = get_version() # The full version, including alpha/beta/rc tags. release = version # The language for content autogenerated by Sphinx. Refer to documentation # for a list of supported languages. # language = None # There are two options for replacing |today|: either, you set today to some # non-false value, then it is used: # today = '' # Else, today_fmt is used as the format for a strftime call. # today_fmt = '%B %d, %Y' # List of patterns, relative to source directory, that match files and # directories to ignore when looking for source files. exclude_patterns = ['_build'] # The reST default role (used for this markup: `text`) to use for all # documents. # default_role = None # If true, '()' will be appended to :func: etc. cross-reference text. # add_function_parentheses = True # If true, the current module name will be prepended to all description # unit titles (such as .. function::). # add_module_names = True # If true, sectionauthor and moduleauthor directives will be shown in the # output. They are ignored by default. # show_authors = False # The name of the Pygments (syntax highlighting) style to use. pygments_style = None # A list of ignored prefixes for module index sorting. # modindex_common_prefix = [] # -- Options for HTML output -------------------------------------------------- # The theme to use for HTML and HTML Help pages. See the documentation for # a list of builtin themes. html_theme = 'sphinx_rtd_theme' # Theme options are theme-specific and customize the look and feel of a theme # further. For a list of options available for each theme, see the # documentation. # html_theme_options = {} # Add any paths that contain custom themes here, relative to this directory. # html_theme_path = [] # The name for this set of Sphinx documents. If None, it defaults to # " v documentation". # html_title = None # A shorter title for the navigation bar. Default is the same as html_title. # html_short_title = None # The name of an image file (relative to this directory) to place at the top # of the sidebar. html_logo = 'adacore_transparent.png' # The name of an image file (within the static path) to use as favicon of the # docs. This file should be a Windows icon file (.ico) being 16x16 or 32x32 # pixels large. html_favicon = 'favicon.ico' # Add any paths that contain custom static files (such as style sheets) here, # relative to this directory. They are copied after the builtin static files, # so a file named "default.css" will overwrite the builtin "default.css". html_static_path = ['_static'] # If not '', a 'Last updated on:' timestamp is inserted at every page bottom, # using the given strftime format. # html_last_updated_fmt = '%b %d, %Y' # If true, SmartyPants will be used to convert quotes and dashes to # typographically correct entities. # html_use_smartypants = True # Custom sidebar templates, maps document names to template names. # html_sidebars = {} # Additional templates that should be rendered to pages, maps page names to # template names. # html_additional_pages = {} # If false, no module index is generated. # html_domain_indices = True # If false, no index is generated. # html_use_index = True # If true, the index is split into individual pages for each letter. # html_split_index = False # If true, links to the reST sources are added to the pages. # html_show_sourcelink = True # If true, "Created using Sphinx" is shown in the HTML footer. Default is True. # html_show_sphinx = True # If true, "(C) Copyright ..." is shown in the HTML footer. Default is True. # html_show_copyright = True # If true, an OpenSearch description file will be output, and all pages will # contain a tag referring to it. The value of this option must be the # base URL from which the finished HTML is served. # html_use_opensearch = '' # This is the file name suffix for HTML files (e.g. ".xhtml"). # html_file_suffix = None # Output file base name for HTML help builder. htmlhelp_basename = 'GtkAdadoc' # -- Options for LaTeX output ------------------------------------------------- # The paper size ('letter' or 'a4'). # latex_paper_size = 'letter' # The font size ('10pt', '11pt' or '12pt'). # latex_font_size = '10pt' # Grouping the document tree into LaTeX files. List of tuples # (source start file, target name, title, author, documentclass [howto/manual]) latex_documents = [ ('index', 'GtkAda.tex', u'GtkAda Documentation', u'AdaCore', 'manual'), ] # The name of an image file (relative to this directory) to place at the top of # the title page. # latex_logo = None # For "manual" documents, if this is true, then toplevel headings are parts, # not chapters. # latex_use_parts = False # If true, show page references after internal links. # latex_show_pagerefs = False # If true, show URL addresses after external links. # latex_show_urls = False # Additional stuff for the LaTeX preamble. # latex_preamble = '' # Documents to append as an appendix to all manuals. # latex_appendices = [] # If false, no module index is generated. # latex_domain_indices = True # -- Options for manual page output ------------------------------------------- # One entry per manual page. List of tuples # (source start file, name, description, authors, manual section). man_pages = [ ('index', 'gtkada', u'GtkAda Documentation', [u'AdaCore'], 1) ] # -- Options for Epub output -------------------------------------------------- # Bibliographic Dublin Core info. epub_title = u'GtkAda' epub_author = u'AdaCore' epub_publisher = u'AdaCore' epub_copyright = copyright # The language of the text. It defaults to the language option # or en if the language is not set. # epub_language = '' # The scheme of the identifier. Typical schemes are ISBN or URL. # epub_scheme = '' # The unique identifier of the text. This can be a ISBN number # or the project homepage. # epub_identifier = '' # A unique identification for the text. # epub_uid = '' # HTML files that should be inserted before the pages created by sphinx. # The format is a list of tuples containing the path and title. # epub_pre_files = [] # HTML files shat should be inserted after the pages created by sphinx. # The format is a list of tuples containing the path and title. # epub_post_files = [] # A list of files that should not be packed into the epub file. # epub_exclude_files = [] # The depth of the table of contents in toc.ncx. # epub_tocdepth = 3 # Allow duplicate toc entries. # epub_tocdup = True gtkada-24.0.0/docs/gtkada_ug/debugging.rst000066400000000000000000000134031446021174000203730ustar00rootroot00000000000000.. _Debugging_GtkAda_applications: ***************************** Debugging GtkAda applications ***************************** This chapter presents a number of technics that can be used when debugging GtkAda applications. First, the standard tools to debug Ada applications can be used: *Compile with -g* You should almost always include debugging information when compiling and linking your code. This gives you the possibility to use the debugger. See below the variable GDK_DEBUG for how to disable grabs. *bind with -E* Using this argument on the `gnatbind` or `gnatmake` command line will force the compiler to include backtraces when an exception is raised. These backtraces can be converted to symbolic backtraces by using the `addr2line` tool. *Link with -lgmem* Using this switch gives access to the `gnatmem` tool, that helps you to detect memory leaks or doubly-deallocated memory. The latter often results in hard-to-fix Storage_Error exceptions. See the GNAT User's guide for more information. There are also a number of technics specific to GtkAda or gtk+ applications. For most of them, you might need to recompile these libraries with the appropriate switches to get access to the extended debugging features. *Use the `--sync` switch* Under unix systems, all applications compiled with gtk+ automatically support this switch, which forces events to be processed synchronously, thus making it easier to detect problems as soon as they happen. This switch is not relevant to Windows systems. *break on g_log* In the debugger, it is often useful to put a breakpoint on the glib function `g_log`. When gtk+ is linked dynamically, you will need to first start your application with `begin`, then put the breakpoint and continue the application with `cont`. This helps understand internal errors or warnings reported by gtk+ and glib *compile glib with `--disable-mem-pools`* Glib, the underlying layer that provides system-independent services to gtk+, has an extensive and optimized system for memory allocation. Bigger chunks of Memory are allocated initially, and then subdivided by glib itself. Although this is extremely performant, this also make the debugging of memory-related problems (storage_error) more difficult. Compiling with the above switch forces glib to use the standard malloc() and free() system calls. On GNU/Linux systems, it might be useful to set the variable `MALLOC_CHECK_` to 1 to use error-detecting algorithms (see the man page for malloc()). *compile glib and gtk+ with `--enable-debug=yes`* It is recommended that you specify this switch on the `configure` command line when compiling these two libraries. In addition to compiling the libraries with debugging information for the debugger, additional runtime debug options (controllable via environment variables) become available. Specifying `--enable-debug=no` is not recommended for production releases (see glib or gtk+ documentation for details). For these three variables, the possible values are given below. These are lists of colon-separated keywords. You can choose to remove any of these value from the variable *GOBJECT_DEBUG=objects:signals* This sets up the debugging output for glib. The value @samp{objects} is probably the most useful, and displays, on exit of the application, the list of unfreed objects. This helps detect memory leaks. The second value @samp{signals} will display all the signals emitted by the objects. Note that this results in a significant amount of output. *GDK_DEBUG=updates:nograbs:events:dnd:misc:@*xim:colormap:gdkrgb:gc:pixmap:image:input:cursor* This sets up the debugging output for gdk. The most useful value is @samp{nograbs}, which prevents the application from ever grabbing the mouse or keyboards. If you don't set this, it might happen that the debugger becomes unusable, since you don't have access to the mouse when the debugger stops on a breakpoint. Another simpler solution is to debug remotely from another machine, in which case the grabs won't affect the terminal on which the debugger is running. *GTK_DEBUG=misc:plugsocket:text:tree:updates:keybindings* This sets up the debugging output for gtk. Almost all of these values are mostly for internal use by gtk+ developpers, although @samp{keybindings} might prove useful sometimes. *keyboard input buffers/freezes while debugging on Windows* GTK on windows is installing a low level hook to handle snapping via `set_up_low_level_keyboard_hook`. When the GTK application is stopped by the debugger, the GTK handler will become irresponsive and freeze the Keyboard input for `LowLevelHooksTimeout` ms. Workarounds: - Set :file:`HKEY_CURRENT_USER\Control Panel\Desktop\LowLevelHooksTimeout` registry to 30ms and restart the session. - Recompile GTK after removing `set_up_low_level_keyboard_hook` calls. See https://gitlab.gnome.org/GNOME/gtk/-/issues/2015 for more details. .. highlight:: ada *Import the C function ada_gtk_debug_get_ref_count* This function has the following Ada profile:: function Ref_Count (Add : System.Address) return Guint; pragma Import (C, Ref_Count, "ada_gtk_debug_get_ref_count"); and should be called in a manner similar to:: declare Widget : Gtk_Widget; Count : Guint; begin Count := Ref_Count (Get_Object (Widget)); end; and returns the internal reference counter for the widget. When this counter reaches 0, the memory allocated for the widget is automatically freed. This is mostly a debugging aid for people writting their own containers, and shouldn't generally be needed. You shouldn't rely on the internal reference counter in your actual code, which is why it isn't exported by default in GtkAda. gtkada-24.0.0/docs/gtkada_ug/external_events.rst000066400000000000000000000032551446021174000216520ustar00rootroot00000000000000.. _Processing_external_events: ************************** Processing external events ************************** It often happens that your application, in addition to processing graphical events through the GtkAda main loop, also needs to monitor external events. This is the case if, for instance, you are running external processes and need to display their output, or if you are listening to incoming data on a socket. If you implement your own main loop to poll for these external events and then invoke the GUI, the GUI will enter its main loop and not return control back to you. There are several ways to handle this situation: * The cleanest solution, especially if you intend to make the GUI a major part of your application (as opposed to just popping up a few dialogs here and there), would be to use the gtk+ main loop as the infinite loop, instead of yours. You can then use gtk+ 'idle callbacks' (which are called every time the gtk+ loop is not busy processing graphical events) or 'timeout callbacks' (which are called every n milliseconds), and in those callbacks do the work you were doing before in your own main loop (that assumes the check is relatively fast, otherwise the GUI will be frozen during that time). Such callbacks are created through packages in glib-main.ads * Another approach is to not start the gtk+ main loop, but to check periodically whether there are some events to be handled. See the subprogram `Gtk.Main.Main_Iteration`. This second approach is not necessarily recommended, since you would basically duplicate code that's already in gtk+ to manage the main loop, and you also get finer control using idle and timeout callbacks gtkada-24.0.0/docs/gtkada_ug/favicon.ico000066400000000000000000000015761446021174000200370ustar00rootroot00000000000000h(   طططططططططططططططططmQQӓQQططӓQQгmQQططg2QrA\$Qg2ططгQQֽQQгططQQг^QQQQQQطط^Qg2ȶ}P}P}PQQ^ططȶQQֽQQȶطط\$Q|^Q\$طط|Qg2QQ|ططӓQQгQQططrAQmrAQrAططֽQ\$ӓQQֽططQQrAQ\$ططmQQQmطططططططططططططططططle:Ph<ey <ri>fe:lolht/gBk/DAREibgtkada-24.0.0/docs/gtkada_ug/getting_started.rst000066400000000000000000000401071446021174000216300ustar00rootroot00000000000000.. _Getting_started_with_GtkAda: *************************** Getting started with GtkAda *************************** This chapter describes how to start a new GtkAda application. It explains the basic features of the toolkit, and shows how to compile and run your application. It also gives a brief overview of the extensive widget hierarchy available in GtkAda. How to build and install GtkAda =============================== This section explains how to build and install GtkAda on your machine. On Windows systems, we provide an automatic installer that installs GtkAda along with dependent components like gtk+ libraries and `Glade`. If you are a Windows user, you can skip the rest of this section which will address installation on Unix systems. On Unix systems, you first need to install the glib and gtk+ libraries. Download the compatible packages from the gtk+ web site (`http://www.gtk.org `_), compile and install it. Alternatively, if your operating system vendor provides glib and gtk+ development packages, you can install the libraries they provide. Change your PATH environment variable so that the script `pkg-config`, which indicates where gtk+ was installed and what libraries it needs is automatically found by GtkAda. You will no longer need this script once GtkAda is installed, unless you develop part of your application in C. OpenGL support will not be activated in GtkAda unless you already have the OpenGL libraries on your systems. You can for instance look at Mesa, which is free implementation. Optionally, you can also install the `Glade` interface builder. Get the compatible package from the Glade web site, compile and install it. You can finally download the latest version of GtkAda from the web site. Untar and uncompress the package, then simply do the following steps:: $ ./configure $ make $ make tests (this step is optional) $ make install As usual with the `configure` script, you can specify where you want to install the GtkAda libraries by using the `--prefix` switch. You can specify the switch `--disable-shared` to prevent building shared libraries, even if your system supports them (by default, both shared and static libraries are installed). By default, your application will be linked statically with the GtkAda libraries. You can override this default by specifying `--enable-shared` as a switch to `configure`, although you can override it later through the LIBRARY_TYPE scenario variable. If you have some OpenGL libraries installed on your system, you can make sure that `configure` finds them by specifying the `--with-GL-prefix` switch on the command line. `configure` should be able to automatically detect the libraries however. You must then make sure that the system will be able to find the dynamic libraries at run time if your application uses them. Typically, you would do one of the following: * run `ldconfig` if you installed GtkAda in one of the standard location and you are super-user on your machine * edit `/etc/ld.conf` if you are super-user but did not install GtkAda in one of the standard location. Add the path that contains libgtkada.so (by default :file:`/usr/local/lib` or :file:`$prefix/lib`. * modify your `LD_LIBRARY_PATH` environment variable if you are not super-user. You should simply add the path to libgtkada. In addition, if you are using precompiled Gtk+ binary packages, you will also need to set the `FONTCONFIG_FILE` environment variable to point to the :file:`prefix/etc/fonts/fonts.conf` file of your binary installation. For example, assuming you have installed Gtk+ under :file:`/opt/gtk` and using bash:: $ export FONTCONFIG_FILE=/opt/gtk/etc/fonts/fonts.conf If your application is using printing, on UNIX and Linux you will need to point your environment variable GTK_PATH to the directory that contains your Gtk+ libraries, appending it with the :file:`gtk-3.0` suffix:: $ export GTK_PATH=/lib/gtk-3.0 This will allow Gtk+ to show the available printers and options when using `Gtk.Print` and `Gtk.PrintOperations` packages (or `Gtkada.Printing`, which is a high-level interface built on top of these packages). How to distribute a GtkAda application ====================================== Since GtkAda depends on Gtk+, you usually need to distribute some Gtk+ libraries along with your application. Under some OSes such as Linux, Gtk+ comes preinstalled, so in this case, a simple solution is to rely on the preinstalled Gtk+ libraries. See below for more information on the gtkada library itself. Under other unix systems, GtkAda usually comes with a precompiled set of Gtk+ libraries that have been specifically designed to be easily redistributed. In order to use the precompiled Gtk+ binaries that we distribute with GtkAda, you need to distribute all the Gtk+ .so libraries along with your application, and use the LD_LIBRARY_PATH environment variable to point to these libraries. The list of libraries needed is :file:`/lib/lib*.so.?` or :file:`/lib64/lib*.so.?` along with your executable, and set LD_LIBRARY_PATH. You may also need the :file:`libgtkada-xxx.so` file. This dependency is optional since gtkada supports both static and dynamic linking, depending on how your project sets up the library type in :file:`gtkada.gpr`. You might chose to link with the static library :file:`libgtkada.a` for convenience. Under Windows, you need to distribute the following files and directories along with your application, and respect the original directory set up: * :file:`bin/*.dll` * :file:`etc/` * :file:`lib/gtk-2.0` How to use GtkAda ================= On Unix systems, to use GtkAda, you need to have you PATH and LD_LIBRARY_PATH environment variables set, as explained above:: PATH=$prefix/bin:$PATH LD_LIBRARY_PATH=$prefix/lib:$LD_LIBRARY_PATH export PATH LD_LIBRARY_PATH Set the following variables as well when using a custom gtk+ build (but not if you are using the system's libraries):: GDK_PIXBUF_MODULE_FILE=$prefix/lib/gdk-pixbuf-2.0/2.10.0/loaders.cache GDK_PIXBUF_MODULEDIR=$prefix/lib/gdk-pixbuf-2.0/2.10.0/loaders/ export GDK_PIXBUF_MODULEDIR GDK_PIXBUF_MODULE_FILE FONTCONFIG_FILE=$prefix/etc/fonts/fonts.conf export FONTCONFIG_FILE XDG_DATA_DIRS=$XDG_DATA_DIRS:$prefix/share export XDG_DATA_DIRS GDK_PIXBUF_MODULE_FILE contains the paths to find the libpixbufloader-* libraries. By default, the paths are relative to the executable loading the libraries: thus, GDK_PIXBUF_MODULEDIR must be installed relatively to the executable. When the paths are absolute, the location of GDK_PIXBUF_MODULEDIR doesn't matter when loading the libraries however it will be necessary to re-generate GDK_PIXBUF_MODULE_FILE on each host. Two executables are packaged with GtkAda to re-generate the modules' paths: `gdk-pixbuf-query-loaders`, which generates relative paths, and `gdk-pixbuf-query-loaders-absolute`, which generates absolute paths. Both should be launched with the `--update-cache` option to re-generate the proper cache file (by default it will just output the contents on stdout). Organization of the GtkAda package ================================== In addition to the full sources, the GtkAda package contains a lot of heavily commented examples. If you haven't been through those examples, we really recommend that you look at them and try to understand them, since they contain some examples of code that you might find interesting for your own application. * :file:`testgtk/` directory: This directory contains the application `testgtk` that tests all the widgets in GtkAda. It gives you a quick overview of what can be found in the toolkit, as well as some detailed information on the widgets and their parameters. Each demo is associated with contextual help pointing to aspects worth studying. It also contains an OpenGL demo, if GtkAda was compiled with support for OpenGL. This program is far more extensive that its C counterpart, and the GtkAda team has added a lot of new examples. This directory also contains the application `testcairo` which demonstrates the use of various Cairo functions in GtkAda. * :file:`docs/` directory: It contains the html, info, text and @TeX{} versions of the documentation you are currently reading. Note that the documentation is divided into two subdirectories, one containing the user guide, which you are currently reading, the other containing the reference manual, which gives detailed information on all the widgets found in GtkAda. The docs directory also contains a subdirectory with some slides that were used to present GtkAda at various shows. How to compile an application with GtkAda ========================================= This section explains how you can compile your own applications. A set of project files is installed along with GtkAda. If you have installed GtkAda in the same location as GNAT itself, nothing else needs to be done. Otherwise, you need to make the directory that contains these project files visible to the compiler. This is done by adding the directory to the `GPR_PROJECT_PATH` environment variable. Assuming you have installed the library in :file:`prefix`, the directory you need to add is :file:`prefix/lib/gnat`. On Unix, this is done with:: csh: setenv GPR_PROJECT_PATH $prefix/lib/gnat:$GPR_PROJECT_PATH sh: GPR_PROJECT_PATH=$prefix/lib/gnat:$GPR_PROJECT_PATH export GPR_PROJECT_PATH .. highlight:: ada To build your own application, you should then setup a project file (see the GNAT documentation for more details on project files), which simply contains the statement:: with "gtkada"; This will automatically set the right compiler and linker options, so that your application is linked with GtkAda. By default, the linker will use GtkAda's shared library, if it was built. If you would prefer to link with the static library, you can set the environment variable:: LIBRARY_TYPE=static export LIBRARY_TYPE before launching the compiler or linker, which will force it to use the static library instead. Architecture of the toolkit =========================== The gtk+ toolkit has been designed from the beginning to be portable. It is made of two libraries: `gtk` and `gdk`. In addition, GtkAda provides binding to three supporting libraries: `pango`, `cairo` and `glib`. `Glib` is a non-graphical library that includes support for lists, h-tables, threads, and so on. It is a highly optimized, platform-independent library. Since most of its contents are already available in Ada (or in the :file:`GNAT.*` hierarchy in the GNAT distribution), GtkAda does not include a complete binding to it. For the parts of `Glib` that we do depend on, we provide :file:`Glib.*` packages in the GtkAda distribution. `Gdk` is the platform-dependent part of gtk+, and so there are different implementations (for instance, for Win32 and X11 based systems) that implement a common API. `Gdk` provides basic graphical functionality to, for instance, draw lines, rectangles and pixmaps on the screen, as well as manipulate colors. The :file:`Gdk.*` packages provide a full Ada interface to `Gdk`. `Pango` is a modern font handling system. Bindings in GtkAda gives access to the API to manipulate font descriptions and text attributes. `Cairo` is the low-level 2D drawing library used by `Gdk` to render widgets. `Cairo` provides a rich set of vector drawing features, supporting anti-aliasing, transparency, and 2D matrix transformations.The :file:`Cairo.*` packages provide a complete Ada binding to `Cairo`. `Gtk` is the top level library. It is platform independent, and does all its drawing through calls to Gdk and Cairo. This is where the high-level widgets are defined. It also includes support for callbacks. Its equivalent in the GtkAda libraries are the :file:`Gtk.*` packages. It is made of a fully object-oriented hierarchy of widgets (see :ref:`Widgets_Hierarchy`). Since your application only calls GtkAda, it is fully portable, and can be recompiled as-is on other platforms:: +------------------------------- ----------+ | Your Application | +------------------------------------------+ | GtkAda | | +-----------------+ | | | GTK | | | +----+-----------------+----+ | | | GDK | | | +----+------+ +----------+----+ | | Pango | | Cairo | +----+-----------+----+----+---------------+ | GLIB | X-Window / Win32 | +---------------------+--------------------+ Although the packages have been evolving a lot since the first versions of GtkAda, the specs are stabilizing now. We will try as much as possible to provide backward compatibility whenever possible. Since GtkAda is based on gtk+ we have tried to stay as close to it as possible while using high-level features of the Ada language. It is thus relatively easy to convert external examples from C to Ada. We have tried to adopt a consistent naming scheme for Ada identifiers: * The widget names are the same as in C, except that an underscore sign (_) is used to separate words, e.g:: Gtk_Button Gtk_Color_Selection_Dialog * Because of a clash between Ada keywords and widget names, there are two exceptions to the above general rule:: Gtk.GEntry.Gtk_Entry Gtk.GRange.Gtk_Range * The function names are the same as in C, ignoring the leading `gtk_` and the widget name, e.g:: gtk_misc_set_padding => Gtk.Misc.Set_Padding gtk_toggle_button_set_state => Gtk.Toggle_Button.Set_State * Most enum types have been grouped in the :file:`gtk-enums.ads` file * Some features have been implemented as generic packages. These are the timeout functions (see `Gtk.Main.Timeout`), the idle functions (see `Gtk.Main.Idle`), and the data that can be attached to any object (see `Gtk.Object.User_Data`). Type safety is ensured through these generic packages. * Callbacks were the most difficult thing to interface with. These are extremely powerful and versatile, since the callbacks can have any number of arguments and may or may not return values. These are once again implemented as generic packages, that require more explanation (:ref:`Signal_handling`). **WARNING:** all the generic packages allocate some memory for internal structures, and call internal functions. This memory is freed by gtk itself, by calling some Ada functions. Therefore the generic packages have to be instantiated at library level, not inside a subprogram, so that the functions are still defined when gtk needs to free the memory. **WARNING** Before any other call to the GtkAda library is performed, `Gtk.Main.Init` must be invoked first. Most of the time, this procedure is invoked from the main procedure of the application, in which case no use of GtkAda can be done during the application elaboration. Widgets Hierarchy ================= All widgets in `GtkAda` are implemented as tagged types. They all have a common ancestor, called `Gtk.Object.Gtk_Object`. All visual objects have a common ancestor called `Gtk.Widget.Gtk_Widget`. The following table describes the list of objects and their inheritance tree. As usual with tagged types, all the primitive subprograms defined for a type are also known for all of its children. This is a very powerful way to create new widgets, as will be explained in :ref:`Creating_new_widgets_in_Ada`. Although gtk+ was written in C its design is object-oriented, and thus GtkAda has the same structure. The following rules have been applied to convert from C names to Ada names: a widget `Gtk_XXX` is defined in the Ada package `Gtk.XXX`, in the file :file:`gtk-xxx.ads`. This follows the GNAT convention for file names. For instance, the `Gtk_Text` widget is defined in the package `Gtk.Text`, in the file :file:`gtk-text.ads`. Note also that most of the documentation for GtkAda is found in the spec files themselves. It is important to be familiar with this hierarchy. It is then easier to know how to build and organize your windows. Most widgets are demonstrated in the :file:`testgtk/` directory in the GtkAda distribution. .. _Widgets_Hierarchy: .. figure:: hierarchy.jpg Widgets Hierarchy gtkada-24.0.0/docs/gtkada_ug/glade.rst000066400000000000000000000034371446021174000175220ustar00rootroot00000000000000.. _Support_for_Glade,_the_Gtk_GUI_builder: ************************************** Support for Glade, the Gtk GUI builder ************************************** Introduction ============ GtkAda now comes with support for the GUI builder Glade-3. Glade-3 provides a graphical interface for designing windows and dialogs. The interface description is saved in an XML file which can be loaded at run-time by your GtkAda application. With this approach, there is no need to write or generate Ada code to describe the interface, all is needed is to write the callbacks for various actions. Launching Glade =============== Under UNIX and Linux, Glade is invoked by the command-line script `glade-3` which is located in the `bin` directory of your GtkAda installation. Under Windows, Glade is invoked by clicking on the executable `glade-3.exe`, also located in the `bin` directory of your GtkAda installation. Building your interface ======================= In Glade-3 the interface is done by point-and-clicking. The first step is to create one or more toplevel window and then placing widgets in these windows. Detailed tutorials can be found at: `https://wiki.gnome.org/Apps/Glade/Tutorials `_ In the Preferences for your project (menu Edit->Preferences), make sure that the preference "Project file format" is set to "GtkBuilder". Using the interface in your application. ======================================== Once the interface is built and saved in an XML file, you can use it in your GtkAda application. You will need to use objects defined in the package `Gtkada.Builder` to load the interface file and to connect subprograms defined in your application to signals emitted by the interface. See the detailed explanations and examples in `gtkada-builder.ads` gtkada-24.0.0/docs/gtkada_ug/gtk_parasite.rst000066400000000000000000000017641446021174000211240ustar00rootroot00000000000000******************************************************************* Using GtkParasite to inspect and modify running GtkAda applications ******************************************************************* GtkParasite is a tool that enables one to inspect running Gtk+ applications. It’s usable with GtkAda application without any Ada specific recommendations. When it is installed, you have to make sure that your application will be able to access GtkParasite library. This means either : * Linking against the GtkParasite library during compilation of your application. * Make sure that the dynamic library file is accessible at runtime, for example by adding its path to the LD_LIBRARY_PATH environnment variable before running your application. Then, to run GtkParasite with your application:: $ GTK_MODULES=gtkparasite yourapp You can find more information about how to use GtkParasite on it’s web page here : `GtkParasite Home`_ .. _`GtkParasite Home`: http://chipx86.github.com/gtkparasite/ gtkada-24.0.0/docs/gtkada_ug/hierarchical_composition.rst000066400000000000000000000037461446021174000235120ustar00rootroot00000000000000************************************ Hierarchical composition of a window ************************************ Interfaces in GtkAda are built in layers, as in Motif. For instance, a typical dialog is basically a Gtk_Window, that in turn contains a Gtk_Box, itself divided into two boxes and a Gtk_Separator, and so on. .. image:: boxes.png Altough this may seem more complicated than setting absolute positions for children, this is the simplest way to automatically handle the resizing of windows. Each container that creates a layer knows how it should behave when it is resized, and how it should move its children. Thus almost everything is handled automatically, and you don't have to do anything to support resizing. If you really insist on moving the children to a specific position, look at the `Gtk_Fixed` widget and its demo in :file:`testgtk/`. But you really should not use this container, since you will then have to do everything by hand. All the containers are demonstrated in :file:`testgtk/`, in the GtkAda distribution. This should help you understand all the parameters associated with the containers. It is very important to master these containers, since using the appropriate containers will make building interfaces a lot easier. If you look at the widget hierarchy (:ref:`Widgets_Hierarchy`), you can see that a Gtk_Window inherits from Gtk_Bin, and thus can have only one child. In most cases, the child of a Gtk_Window will thus be a Gtk_Box, which can have any number of children. Some widgets in GtkAda itself are built using this strategy, from the very basic `Gtk_Button` to the more advanced `Gtk_File_Selection`. For example, by default a Gtk_Button contains a Gtk_Label, which displays the text of the button (like 'OK' or 'Cancel'). However, it is easy to put a pixmap in a button instead. When you create the button, do not specify any label. Thus, no child will be added, and you can give it your own. See :file:`testgtk/create_pixmap.adb` for an example on how to do that. gtkada-24.0.0/docs/gtkada_ug/hierarchy.jpg000066400000000000000000002217361446021174000204000ustar00rootroot00000000000000JFIFSoftware::XV Version 3.10a Rev: 12/29/94 (PNG patch 1.2) CREATOR: XV Version 3.10a Rev: 12/29/94 (PNG patch 1.2) Quality = 75, Smoothing = 0 C    $.' ",#(7),01444'9=82<.342 BP }!1AQa"q2#BR$3br %&'()*456789:CDEFGHIJSTUVWXYZcdefghijstuvwxyz?(((((((((((((((((((j`׷"JD1g`,If޲3?\L^_L?E{hLzk"4gϮ;5G&Zg"4eϮ+5G&Z_"4eϮ+3G&Z_"4eϮ+3N{C$q^ ـ`ʷ(fsv]M,Qp'ڲ?3iQ >iQ >i >i >i >5|oI/纐G]iyH$`u"*(zHh=Vc Eܩ 'Q >'&z_"Ti >i >Q >idO,1ƀ<%⪁ԒbZ5[=gOQ5& |Ea] k*C"V Ri >P'&z_"4i >ig_QO^E$M "8((WNjK,: D<ȖY#dȢFr0{b95H0ڈXI㹊L1FX=KZޯX2Qrpig.qSk\$[5kbnZMa, d޹5ռڄ35)V-O F޻<4,X Iv[ 1sƵuueuKsu,/%%c!qu*(ڇ_Lv݌p}s[??cK C??cG,ƏX? ozi|>7ybamA_j *?jX[]L,cXA@8G$/$AA6ͦM.HSaN~b]3׶tI,nO;3dD5!=2;qqt"R&'V`̻rS-|lIY7R1/[srH]}QEyQ#FC^Ew+_EZh%Fji#M")n_AH`t4]9ue{rA4דK|7BF(Xt`@g84֮@5C+`]܅e\;\q+h|EOOO5K _OOO5G,_??9?|EDTTSV&+Ofš껻# ǒIE?Z (\W!gV 武éhrx'Pԭw D .$g0A횪ku[vA,p2#Q]fmnHeiwJ՝ x?;铌E;mbkko~jw&vܱ2u۴\LrIsQ>!VHjq]Ϝ;`? j gU:ȗ!y坷HPpOj&&HƨRH"q2G튎O^-'ÍaHG/}jWnZqrK~I&YE*{&>RzՕ?n5a 51"E,JeSOBhÝ_`y'.c;T0hIQk#?[)cY1g,˩.vi$͛y ,'=@/αtl 1T0tKpÍ`:&n'U.&3#bF,2 X"~ru}i\l V+y5Y&D n]x=}RŪx`-BpQ/ZY5Dh "f֥?0xZfZ>h9hg?oE|[+/jzE moZdU;NrWaڊ(LWakw]`"paERHI`zFF1ޫ5QK6$l-].2AԤ[0eZuPҼ>d6mɜf~0=-!hmDH2ޗ//xZfZOzfZ_xZfZ|ceOH{a5L9tIP;?WmuKq=5wWFJT[(N2zՏZ'eZ>9hozeZ_zeZ>9hohzeZ>9hg?oE0xZfZ}No4-ɶ-FN8$~վmѿEmzzglf5@Kp?{Vα6͆iS\=QchX$Gaңo" boEC̿G|_@=2-m?ȴmmC̿Ic@zeZ_xzeZOzeZ>9ho_E/ٗj˻xvJ9̇;0cCJ((cΉoa];Ka^!HxY/́ Id#9vNx.r-mPE۬ٶ;Gǒzg% j͝ē=ߑn`>i"ͧ˘5N?v Ade#Xw0$i-rH`PÑ0FqT%M6G} 7V 0,X>|Pqshjέ5IfBA >}?kpNHQEyγ@7=z5QEWwNgjG OBMc=3ֺ?%Oidd8̅#%p=+ :峭ŵw2,P}捋3󌜛^PR_-ms(vDyK#"Ԭ:ƧX٨w+uwǝ/xozȰ~70+ F7䐿urFH۩5.yvv Go']U =H5q/@3{SfB D?q9&(Yg|Ay?W>iiCvIbku$_} B9:Ii4]@,1Z _ѳ޺/=\"GCc8CS۟4Ī?wPPZH-?Ռ"%b( ̛9s-V]ВO#r0!g-0sV^ڼ3 8r9+5Y+H 簴ʹ,I'Kp@PNY|_n[K* I.7;$5B7:]w0\F_[=V $[dȩ/CWzK4A/>9=z/eyuui5^jY-A時*߰r_5tV%kh f?dI?6Ҩi.eNƟB_8FMJX{[F0bz#j|x.}>QEQEaK l"K I);U$\ ,uK}>_ؙ۴*Tnm'D/W1hC&~K9KkhC&~KJct_9$V}_3KOM+ W_3G??4f2i_&macxϓm\Az5&ih+0k֗_T}P|Pb3Ğc|RKkh'3&?2_Lohm9]>rh#"xIUQ%~M/7,ɥߵ4!ҕ3lRbR*]/ffR?2i_d_2i_dҿ?)ɥߵ4cSJkj LZ[(FM+?MfE_2',q2\U9Pc܀H F3V1/O!0Y˸IbI1I$IMDe;tUkJݏ3@Ѿ)ci#&~h& Տ O:ov[S 4-c ]IZ()1\WwҽkGZ7^+M^NkZ8Yy6#*uƒOK_H Lu~l4-JE 3OBY^h:rz@͗#?c?k?5,4c8O8\6_KC~lGu?e;ߛ/G-TfZ{;[1$m

    Q1#wQE@Z&hVvZ?n)f#w-VQF֡fα+H*6I#2kK_#E(',:;45Ou!VD2A=F"g)y^]q|2z*o&+?^u#Yƚ#C,V$GuOeCYҾ':wWW6<glp ^I޸B?fOMGQ]Xe#b8$yxI9$52MkT($u['j:5ۨfBV+)*=*f^>"`cEe{tʟʯ`j9k#l&5֘mmX?J|P@՞Y cH`?##ڴ?r?͗#=ߛ/GS-s=Qt_L5 B/%**q8Z&y2PMu7$e:]%Rbsg˸O7뷺}k2P6KŌtRwt6~#u3 +SmST zdʞfY 7U텤W>5RX{2}0$9=̰m2SZFJ3QzpG^+S R6gqYgP˦%7und1E f#?goʒMg&mvHlQF-T6WxqOROigmmHېvie0?u(xoe=նov|ox=qԿj9kƩk%o=6Cj "v*NWsEQE~*͎߳4݌̌34a|AҌvx?%>[f\i4v^%~Et#o41`A9o-MCrW{M5yڹqjC]cy.$XCHz`F2zVe܂9&tf$X~>W̠a6q )כthm~CZZns}Z"s-Dv\34loO?98%[DˬXXmu){|R,sW:>^YͬC`mDcV2)S; ęypWd! f8*L,/ _~Zx6WRRJLkśf>( /:i|-w xpUv<x5H8aG$oy)d$!@#=3YBI,ǧ}<0rC%[2K]?ȲelR"yi3zk,t :VV(\%Tn+vIѨ(kC> Ӽ\ֿo#mg3ns9{LJT˜1W9H> mNVS̏™kWQ gگOS>>۪?u_G)E/)c(1?E<;? ?|+I}aqy$Daa;.A=sG `(7,UGc}-qG0L Gpx?Lxs5N[OSPX?LwuOLJTZ> xUu1?E<;?y1?E<;?E<;? ᖍfTyݵe T]'zG[QMzךWIf,@2OW3/3?uN?E!19?Lxwj>FJ?Lxwu_G)c=1?E<8F G|?/)>X?Lxw5OI gÿ~2GWgI%x ݱ`Xb$:ڴ袊+?+z__^G*B! R*ypOmWl7<ͬ cŒ]3x8dE|;?nχOlχT|˜,E<;X?LxwuNz?"|9nI cÿ˜?"/ x/NR}f=nq(4n斊(o4٥mƱ;63$$^`xZMֺ鷮cު[Pc8Ͻ>H\K ICN= BמX Lsp]:# |MMu?Xźb˦ă)$^@S4RA͊}*8dC CW_A z/|9}_ x~9 *0*pqȥ |ɵAb6ԟ//[i|<OךxgM 4 4?C'T]\>t |`H`[%H X;-!?Q n? Kt?O[BkO[cEQEQEQE'z:W~?lgQL O{P$cM쪊 r#r < XNepk( x#ӴjN}L 1>RFv6 S'<iws ׆4(ey'Fv~Bwwmxjd,=Uv-{~yPxz[YAbecz3ZV ʖ ċ,T@_PG}* SCt_Mx?M4 4?C_k_ jѢ+)9%e`A.AKŻϯ޽uQEWzV{<٥@vϘ=EhG@/q}\I +xZxGCԮmDž$wB;"Y4dca´5;v62'4EQno*U09%դ {{%ٴ*†lBzWl_jYm#C(Usrmb;X~qo);15/K>n}zEW c 9$e2 TB_!geQ5a3mV=?[  &f KD뚡46 ٓ6(((N,u_7ٳewgZZnyQ.K$"Ib'8\֠_UT_,G$ 9.Nr{v~)ooluBY%̛iëv[f:)ڛƞԮ%~қ?Y_gB=*<k|H]DLa4$Ufzs1ڗ Oq}Z)s',T bԚ-m[5d%eO-cb<t#I܀ű:T/=$.Zl& S 0_;J1Kީko{9~(%qVJFuQExG}'Z"7V́D]6K C"1Q^} Ockحs(3'{%/?{O!'9siy ?VQ(̯qB?b??+\-s(B?bhѬcf=iQ ?G{hL]sWfL?E{hK]sWfL?E{hK]sWfL?E{hK]sWfL?E{i֞1ѯuHtĒ+ف1uc=0@V'zGO{g9fUb$1$3 Z k1G<B?b?-q/?hO K\<Э??bx+k%hO K\_??+\-s(B?b%ׁbRExbU@I0`tBx'V%ӛwE AcAҊ(+*_ 7)&I ,%t!em |l9|mQ̷oK!cM |]A! }}O1*1]+C,jʲ-RCC)p7o^ZKwb 34J+eس7zNnCA#GRxOڲ>;ҿz袊(((((+WӼ_j/WOnRV˽`ąoF1ڸCzxg]{uko6 `\,`*GwS5׀5AXݛs 1 V4itjE5[2+|F.xKɭ<Z]$ˈdpµ^J͊{YoR4)lQ"I1GoQ]Ouup<D0D^;M. c]hc&y([]1Oê?5MrCbx(`b Tg!I^EQ\O 5k^ŢVl:@)>dq]$>ɐmurc BWaO jV)lj\sIicA3Rx_"5kSebheݑ`fޒWw}XMܲ4ӳgc?+Bz卜5D(tj1z /ꟜjX"~r?bƨ/''/ꟜjX"~rӮ|S_ChܯܔXKWSHȮ/?95`ɮjl:'u Jr H I\Fq٪Ʒ_nkD-̎Pg3!a0xɥ%mN VVtY ǃ8$UVjͼ) |9#ɌI{tRye W`Rk6wKwmX\<游g$BH w,_??9?T|o-OGTVCn#8kukqeM6 `<ʅYs+A"((((((G#laЌ|NվֵH'Ҵ.I-P,OG}ďCG|_a8ho_E. Df_E^xxC̿KCG,f=Aa+J֜/\G&y#f_EռQ mImT`zeZ>h9hw=>2-/<_@=3-l?ȴ}s7" CUﵟ}ƅy64yz6'֯c[ֺٍ7\\LњFX4>{yES$GaҢwoEo_E//?/ȴ}s/" CKCIC̿K CG|_@=2-m?ȵ|Y7u ^O}2Q;*e(ONsںz((k#Wui-6A.u_M5ϱ~u\?_oyIyy$wm ?o{fhDJŢUHM*^WE5!;>Zr I\ ogw7ZtYAį咤s<(;`M%ɚY,N6K%u}A5[,嵳5 c8@@V_jݣ/*D(VVU/scik ct{ѨӾt8T! kǿwU೙!ҭgQO"ʲn$l6IS8:pHcRf)2yt"t6 G{k"B[6j5-F18pa .-U!rP#]%>+)b-Ec QPC ?(㓞۵QE:=F^_lcZZD7?.")&F$AHf\@APn Oӧ7K}:KV,~M dzsR6 7K"WllBKGA:\LQq =E$6 @#<Z=2M|*0$"pFgR|F\AdŨ\Gِ.GLa[wIŗG2 # (.JHǓ;v-V?PxOڸSgz|_]W?ϑGWȣ+T:ggʼ*ψ\-J5|)w|V2 sY++)&Gi+e~qaK zZjɣ-$ne 㞄s\& oOַQBAЬa " pssSwwڵo&a}o,afxc.VV\W*@CaRƷidesqʪN?/j%W8V6.;$t##OY[EqvV|a$*1 tok-'Vlmln'jB[S^]\͏zbmv\pGCV!kzhH2.9'1qWïvdº꟔vW^"q̝@>o8xQg;ɜ׈?j'svW^!?`jv׈jvW^"~R?]xIi?]Ii]xv?xWk2 {1Qdw{EEAwk_^66jr 5%@.2c׈jyvO;H RpzYl_ 2!ޡ'$"8E¹'׈jw%u/('׈jvW^"~R?]xIhu/('׈jvh/tkw%R]B$V\]'zaK:Žy$׈N3SIi|4צPxQ295ס@xRD#yW^"`jv׈O_'u/('׈jvW^"~R?]xIhu/('kO 7)"u*!VSev>?nfw9n8ڶ1K1F+gAqcqcϥMjlBFC.Qk׈jvW^!`jv_}i:xQV8 N끌 ?P5OO;Q[77g"_jj@N?-;׈jIi?\9S?]xIkk “jSK6-#;[*XNKWYEQEW?b! k^+4M^NkZ8YG w[kz2 (Sp ͿVNx$DYyv9._AKsZZsqmn8aFGhI?ZxYYqii$~;ٝC( c8#ߑ[Ft[rT`eGYcƺ۴/@"%[hlFjoGOe=ߛ/GS=s=j9 @5uzVIO*rLh]QEq?22x1|֧7Z=ۯgH i^ѡ1]lrIQzQjMx\8눬N=ޙ.{7{oK? Q)xZ(Hyv89.Kp_L̞q=/#Zz_GOe=ߛ/GS=s=j9{T\6_\5+~I_X4}(\c8z 'z?=5BSvc wב;E(⸒5'j{X&KG:?~5j mm3!+aA~ү#D*ѢڬH**S?2:M#`j9kj9k{T\6_G#ڧzz??s?͗#C~l:^h^/Kki&U =UIqZ&y6o6_3{ Hp0:])hlLm5{:7U1+t5,ƚ8`#zpu"H38/GR \A!|n:ݏgoV\OS0?͗# Rl=pq 5Nx6_G#Zz_GOe=ߛ/GS=s=cxX5 wĶG܈`y#[RNPI; h(_oXonvFAoxGZtڬ) e '"% %8nI g]۰_\AN!TI8S}sR.iwNu֬ː#95RegtGnQV1s6AERv6,ڼG 4SjVQI2lqhdQ'qk9iJDHXsl9>`-Gi|}- Cm'7qVkig{mOdI'n Q8 x#Np,!Ҟa^Gc֦ÿ2?KƏJ;A/#=ym{]){$N[pGxL('.?x? ν!Lj<5]jq :HW6Kz~5$LǨxȲN$\n*x<+kMqV[IPF:4k>vax`̤p+6}CMU]/mO79UDe}y?#,n}ǧRi:ug$宫poqr/Ǎ172YkEQ_,ٶ}OLkOѵk=sO{K&{bёly(rYJ`cZմ=auƇW(6yI 98Xm 7 Xy5$O4eu>{ #慩iZf7mL k'=~πqty{KƏJ;A/#?+ hÿ2?KƲK] kíiK%ʈhYF<O^} ?va1#OֺW'?*?_O U?\~}g>3t|4}.f? |&_*V@?7K a ?7G+L]<@s3t°w֎׍w}feI3 1KZ('ÿ]![=Rρdˆr+#nG{OJ sF ģfa c|¯}#&fXCĿ]ᇃ sSt°w ?7G+L]<@s3ukL'mF+ ;ȹ X5Ҏq#lzu·wV瑥(rNcOcA]'+Go.3L,"bI'I8kf((+;?FkψL2yE?=AY d2-WJŌ,-"$&Su3Q'v&2tLb"nIR~Zׅ|#Z<%;Z[I>DZClR'o:M{V͘A v1} '#-@W>Gyi qN1Y-<`5/p%Im䍋y@m%M[qa\FF\}OF4[#-.c Kn9r4R$|eFxGqs9Aoa3IgE]#C" +dKo[ZM-t.E.- {Ke~dVcCLaI ҪX|:{|7ZB.d,`_7i*G9늻. me|2ĥ@M#o) $hdi?/c>Tm>o h ͧC&f8\utfx`[4XAKmvq*͇+ wAg-\*h.OЩ&_vv$0Ez8PPJ(+OцZᦆ+MѤWPA9}ꞯ]#87S4QƠe$A#XZ _I\Od9Mf˩\gnm5$]p\kw??TQtj?.\-SG ÿߨCàǞ~2⏻.:j('N%7Ɠi}Y6J,d*s^4wwyV XGcgꖡf̺BIUKt$#,+yIwPNڥ};2N {c;MVQmeƿw;Mlj?.\-SGowZWXnT9V~EzuQEQ\Ww55?qq_8ޭWqtӵ5bύU]bέzREН/H-OsYEjyGkc5$Rj'k_:)"7\_G$Z ?"!ߧ/HS7\_I Bv" SsYEGq;Ynn|#(dC- d. zVF-# vŔ+9*~ 8_ oZ?Ulnf0CFrduP*$ZGk(S</HP̛/H-OsYEjdsYEj&)!?M?$Q Bn"HuOueCЛ/HSsYEWRxBѵ+ i#[%1]@I޸BgUstӛ/ kPGq5Ѷ"N?$RCЛ`k/HO&(T7\_G$:M?$RCcDwYE&(T7\_G$: ?!?M?$T7>):PBIfB'ZZmUI l*x0xfk+Ҹa]`Y|M7[J4lƒ`y+ExS;\_K Bn"-OsYEjy;\_JEf~$%ӭ5WwvoۼA,qc9>owomg\E 1H@PG=.}&i* nmb (,g5WC>3 [VO.~g=|Zvv_D#PyL?d8=MTQKh}b/9PÎWmxK^%~s8uG--ّy1:|CAs\kn<\}b$s׍ :Tw0.fH$Aی*aBYt8g5//{Jȡ[ c&=[3^[ou 7JPeƈH˘؞z"`QNCdu .h5Z=Akyu6+/nzcZ|%؍]V ) K$c#>q֭xQӭtw454劶wxᕏL^8. E73E;TΪrNcA]oSo@gQa.@Tbjx}U'OF8.lr;~G} aLZvdx✾4-k ElN7eBd#{fmzB..P ڷ2( C[l'm\5zkqm>E%eߴC;w랙[޻Ҹk5YVsyۤ6ۏ9}?Zx;z[޴K+s֬_kgKkە2 d#*$ rP-UgTAIڠӑrRYOgq I*ˀ)зǩ>)зǨBޕc zWz폊-_ꫦi~1~"izkO 4Pd؟J(/ݪ:Ul.onfC;DF pQM;DZRNQ&[ kF2H&ַ?iΛmpUդYVs!4Yě+ w6N[ҀP< <Uqxtn-Әe)vї * 8SEA)=8N튅LR?Z\Ic-&cG+6r#]9V??[ҿl|SoJUmBvX4Es %PXq&yx6OɺplfFa$t"AҸ#Aeڸk'ß^>Q/|uo?l>[^Q՝ ݈L`)g>4LfXGm3Tћw*u,  V$ȪW e,PqsJQ7xT-n!?|A t#dh14w~:`x?mCνxFeb>Qs׊}׌.oU"331x|MmeppBW8=c9$FCv0't\tךPK:S4/ai_j%^g,dψ F1yG*(1|fo};WY+Ir7)N6 t8V&χ *x^ zw~}k<'eqx7CʺhEW?c vO?Xօ޻u3Lӭ`'ݥyT!֞xU3(:&;_J~/i*~/t?G@;x  Ćw(9 uZ^i ̪*C=J޹jWsS HePC)U;G\ߊ; C}"Q$OW?]A]ADQf}OڨH|Y!pkcG8W~t 䪥_kSF' f@Dp\dp[KlG E?/i*~/i*jm/IW%<1J8N35wLj<+eݤI4mvQzZޮ'ÿ]q^#I?0k\W?xտc޹?u-i^)Ṻ[h8%;2A$&x]6/?ۚ >i* O8M/%RBǯ4G|_AU!xu_J'9_J0i*x >h_&6/M7%Vx;w_/sGt{'ݞ(k?V֩wMYEm>c+ .T^ub|)=q4v^%vyM9,'#/[B++͸{!vbpNz+= 3n0ɈWH4k ;Xl[>1:/.2W _:nwV:$Gp>n])hL^wc]h=4ӿNM+YO.$X;T |ax`̤p+b[?:(/<̠v=bZYn4'/Ghҏ" >So2qˊ|=ͬy/|*8q3[ Z(cK`gF#}-wZͪʂ8래U OZ[kug8$f\a:Lյ\Ϧ eeIYAIGUlW:ZXg1B#vTƠI q 3V}advFlg~bj+']-l.1 3I߻|csMokzqr℁ 뿐A[9:}֕Ǹ134\ cGGX΢oq XyԻB@>l#}J]f-"(Mh6o1`܁N_ِ3$ U_O[P:V?R?jc$J5믮'ÿ]q^#I?0k\W?xտ/kxM[l5)mEKG_6WapYZs[>.jis=$:RUY58PڈXxa{99#b,7c9{w6/j7(.d@U]*mcW{KtLRF}$'q*DžGAQ>4Z͠PXg?eiP w0;onC[oIFod,|k:|}Ċ,$!r08οsKQ Ze) Ck掬pwyoS晨MIuiϴd x=:לG_H[47HˤN L#c%A%G8C#:ƽu[մXghf',N+N?׷ GtRHkhk(CĞ ֵi#Xۤ-6d xW^"~R?]x'_ۣ7j_W^"R?\|v׈j̟v׈j̟vW^"2?]x|i?^xWӿ]x@?ծGG̸ieTc?QEq??Z*!SMN1),Bc!zGïuTGoȅǺ2Gbi@z`HZyu.5OO;J~x?P5_Ihu/('u/('׈j̟vW^"2?]x|hu/(':/7z.5)-,pU`=+\W!gn=bN7'[XUT31 O8sYCX'%1#Zu???/+@}^"?̜Z?\??꟔vW^"Td㴣׈ S>!?P5L'׈X'׈jv/Mvx^yIWGI =AZ|19]'h7ٻst^կb#N#_jG#laָo+n3^\A-ķRH*e^X?{ d BȠg?»cǍQOY~8a@Yoo¢Ϻ_xj OrU`ߟEnƾ3g;ƨ3ʐ|,A{zS{;5tlLuףEq&##TQfnCj}SԮ &,5 !ˬꥌN;=wmV<)8 ys^xIܗheO3x޽v 1?:{O{ybB#[bI JI$0j-BF1rmj7V iGPA'o(/us۷?1H<)VV8V߽>߾mڎd EoM/u}?u~u vF~ծQn?ZoW5֞α!Ys#1:Z(~ rtkUYꚇ!ԟe΢2^.-glcrڙioSt,5#o7n>nw̢6 5Ӵ ?YOЊAr^Z #hϯލ͂p?}RxgDK]CYY_ j3~u^_Ct?{{Ǩ7KszCt?{{Ǩ7KszCt?{{Ǩ7Ksz+>ijwhޣ4[I]tJu/_c?]> MCMs ,8ڽ9jicxHu]G\/.jvI¬I<*cᩜ P>Fľv`4 Cj4K}$g:9G(צ-֥EUfy-Ӥ#SA(Zt1"^zy"xOH;/uקkV^c.X..F?@kHWGynw6o'8O_iN[#k׿zyχmtKXy.gծrFB:+oM;W?c vsG[OҭxKP {%T>lr(8KkxV.M.;õzn]ߧZk/ ׯHܤAcک_i~'H/um^ dE}~-ק?hidZzQs׿v]h,.M^4?/FqtK?4[[I.֣3$6z$*/ie4 eUG*~?\/~^-2m~eW? 󧯄EteYurL~g{%խBw6 ˃[ kzY&]2F,%$y$EW unn䄕#BGP )? LKՂ̗s*Dx (u7yՔqKTҮ{4+nc%1UO?98%N1[=cLGN8R"m RA$:W3{gmv:ĢE]an=$ѹ @atM#][t1zkgx9BIţ$Z./}ŀ" mm"Ʒ~{6ط0a2^X546!-ί^YIn Y9|S@J`wK _?dG%~q^ٮZO=' 8#WQEWaSmSC<5xkQSIq" 6p+%5[v4bF`<S3}BHVYiDE]B"m[B+($mx:5s.m Sɕr<Xo;&q{ۘ{xiwiʪY8#k{ݦXIvdR]G<n |xø/%~w_G4W _?dG%~yt_a+Wei-eW3c##=/~/?i?_&? ״ /~tn.dYf(T֛L ivV/"kr=E-խnA2ZgEtr]p[*iWG5u:-BI%nѤ*#)99}jE&+6%@Ld MS}:[MwFDH5JҐAc5MaZ̉ k8 + #=ޟkyfxm"^9UbIYA"&]$crhHo~4_,SEIx XۭFom]7oڰ Z+Īw20Lnǜtz|Ve/:_?gSBm? h_:'|?m!Ҿ~m:g?3!M_쯃uiOCm+?KńV6w o MCMa;>ZcOCYԣ/4ui??3iSCǧm/4?O쿄 Fm/_ h:f| G_ h:_M_/1ӣ~؊F˫8YZ:iIJOцMO_4Su[7>_ڮ-q#C1U}}SW2c|k#,rN*>%)%hy)GZ_h_| #?JQ=R-R|=Ճ6xbTML*'#º i?V?]G ~?][A V$0D#5 `ڤ+eOpJDF55iB>̒^e} m}2-6Kpa 6Фf CFL˄% $M#Ol)VZ-Ψv]UK`}j^$Kԓ:$7 Acx0U̾TyVՔv}*) MCMq~-s4գsZ~LqSKq4}07HH8 bNx֩[&mqe#ݭI@9v AGU#Zl㸶pYW0- 89& NfB|9Ə$7@upu53B/lIu"khYa79aKnMe.c/:(YrdqO}*]?Yӵ`ͧt1@:Ηuu|ilSڌ\p ہ=jkJ^'m27l`cבZmu wҬH7$rzj) B; 4錄%vxd4lqN͌ jIAkCAg;aD@ mYJ-I8BWqtiڴ\v#G#tKi0*XIt*DvHԵF'qZ@)Tirwje ]D2𬀲?LZSՠҖݲWe?,O!'{Ohqn Dİg#5-4}BsVn:+N+~ 1&FEQEWhOiqFVd9F/Z>-Xݖ% Y`H[zuZq-$.4اh{&PQ6 A1ϵKdV>nZԺүlZ= dT9}NŔEݐ7 ¾a:y=1ް`Fmc$jlQEylX !v `x7\XɬZ4Ӓ?+$΄Ï|.Dں"\`LX?TQtj?.\-SG ÿߨVo:ƫiE/ :޽^(;Mxad*Gk(vVp:g_QE&_5+T.A10_OKWHz0m# Շp/ŝAZ#lL4뜿s+]xo I3)61o1,vc9)wm8J_:{UG,y . cc41Z̭4EH7G?[?];>Z?TQtj?.,?ٶcQ+,~!h4⺄*%!16TȤ OO2Z \i$ױ]N(ܨA6~lu$ۊ_ |@%a5;RvI!IvdbC8-ߍ|JI7$;YC#8y9߉ƞVȔl<:dq?/w(t|gZ[5Ρ2[g-'%Q$`|9͟4Kiǿ)EEg80Upv<՝+^, ]F% Q];c:=j^IhijDds֐O9vqP} O~a ƧK'QJO;Q{4ߋmk<:C-b63IW= 9Rf&tP e y tӾVus-{:=Mp~0] zŜܭ{c/َn8ߟJ;k ޵̓gg fbHAҼkڻjRDH*ѬQƠfVAvG]x#r΅$j0`V4>\&9qn=X?wK)[|$I(yK񧇴mD][k &VU?+Hr&b?uu*h:Z5~3Ʉv褏|cf{|n~kWդ!\^`wpP.Y z|GƩٳϷ>g ?;.ϖ~?];>Z cԵ_®\$r43((c nju+KtF)fXL#jQX#Ƚ=MA BveCwn"H?uk/HS7\_G$: ?!?M?$Q Bn"HuOueCЛ/HSsYE&*-+.tGo hs+݁$0=k(+0]Z5dhVk˃oXb7#*6U>??$Q wYEdsYE/$Z7\_G$Z ?"?M?$Q Bn"HuOueCЛ/HSsYE&*Ė捩X_]#Iy,69GjJN|??=iE⻛x_X+UvF:7)?O!QL5ej&(S7\_K Bn"HOueEЛ/HS7\_G$Z3n"HN?$Tw>*:PBI$2ِI'ZzoTd}P|T{޴qkN%vRKF)1KF)1KEQIKEQEW%V2ždlw0JuKwيiw?tɻ2z 5JI+]>EK91mp36̅n!veo8[𶣨F]RN~T-#c++ EZre U"QJǦ^o1qVmI GlndkI#FY4F%b#m><0۶[v$աx qR&#rYO 5ZG= F(+O-;Tu^-BȀj0%s}px&YcI efu!"@PPNDE.zx&3?ʧ61Hi 7L:o\]zc,5ȕ jZHŤ 8*-Of -E3 7FM9$ˀr02;d=w fh3 9S=3qyp4בژV`pI Qrx;)̦i $qOl/'[aL)1玸͉pX&usY |@ < XDՕT?hj [K6bY/Ȣ+vp̱d90f'#?AoEl! w_Ł79󊳧Kw{O iΡ2m&®?(폊-_?>)зǨBޕCG7'چZ}&)p1p>gږ+ӏu* H쯼V L2I.z$x.< պrKL#;ܷHSpxCD4m(Bʟ7mqRq:"=2>iV(pW?H AAX̙s^32,q/' >}j8%^{jF7G6cO-i_/??[ҿl|SoJQO+=Ut/:M/]״-bfT*{5zxI޸Bf[_ZZxvJhyT;J`G;E+L<+b1t'q IkoNw@0p2b2`h,K6ޛg ;KMoG$rb_?[P K/K%=9ԒG*5ğjBʀI3\TYbA$xXǵ{UlJ,x 0J~>eA$v"߷'$Hri!48͛37[3x#v* KlD.2V4qR_@-n ºj 3 hcU/<_AU'<_AU/|_h&6/M7%QOsC4G<_sC>sC4i*?- 㷎X) s,vAbDO.$|uG\"A7g^8(+;?Fkռ5]jwQCO |gCsNe0uHum".H:^/۝so+9\`py{P^'TxL݊.Ɍ;qw`e2_5Dǖ@N2ֲͬV+X!y2L0:*PBBcۨ?T w'< S?k:u˖cET˲8*7G8RmAK821"p睊8;u~ԟVa33)mCmbf{WZ1Ol}+"H0!z֗mKTkxaڨi6ٌd#q`T0b8=kOnǃ\uQ\OOiڦVc yBE&`t#ZLi63ǨxϑeY^7J.2nlO5庇HcRfn >e [#mYd6HA~0(e@Ԋcִo[iRX-;b7UQ 1Ƀ*m7=ɒ[hd+k< |>j2yyX8ma7 9AhTՑIޕmk_\4ogxCwH뎘Ҳ?@]H?ezGh_gׯOjK'^Kߴ]͠+hD_}9a$~UvU1ivqdpbOA|ImvN0)$VtFG.Uyr|?Şi>(M.SC:?$`RpF~cbV^m6ݮ[SO 3:*e@v9-=VVh֚wi>ϼ3vR*x$S%u%H/fYfdh".9mu]ڼBf(.#-$jukNծH[2\Y l_b( j&wg|^EW?c vxE/oc!PAcTx/)ou!5LiH|7^jjS>>۪1ı5+k[#dzl皓LJ j#=>/)"Tt/ nLT)|:;?_N1?" ^št62$RJf&v@`0袸?exbZtV7Gs @ԃ*> pLJu\XE-zA$E;χU™j?#ڃgäW>lE|;?LJT˜?"SSQ cÿm;;AvՕЧ̥Np=);C_PKjZzs3&ŸrqUSrcu@#?4LJP> w9n_6?"S>/uA<;?O"SSGR˜?"SSQ cÿOS>S?7][xG$H ݴŎpr{VI\W5k;u.{E5K3+,$ƧՋ ~aMBJ$ύOPڶGꔑ|%i5@3SV¬=܏}[Eo3ƾ3[TJ|+ _x0տ _Uh7(X?{s ?oT#OT?*|X#~7?]_ןuDgry2uMJKKLoS#`d z=Q\7flҶXiחv(c}t-nˉ- (N?~=6glnf IC'9 uq׊4 x։&T7a@>ou]: wŝ(K$S,M ).AR}j6CFCJ8 \>l9^]n&Y~߽,ֹ=Kn?ZoQn?ZoW5֞α!Ys#1:Z(~ ;kz-u  imgloBgVHhҼ8c[GZTosޤ=xL3} >vė9ہy }x:ͧJ7eްU3vu-] |Cyd wL NbIu[r뷿!`pOd%L}~v(s7ZOi6u>$0mc`RZxbVuhCA"8<8[Aӵ4˫A1mFke xjRy{+m6lY4M3QЯ5GR ߞ-V1ԪBgf  LJ8B6&LiFAU?h[^$vʒ dz =ɅCڃ Bמj i!}[ߌ޽=qG4v -I8k緧4 ͌_kG< k9|%Ƞ޸#^ i DյHs{ 0A >9N{G"9h_Oi^ԯﵡ5wIRV\^xMY7|flJ}++ܾS1CMtU:qmw=ܲ[f(N?~^ry(Vb ]wH2Gͫ=kkn3|2Lk eu<{S5 Dn!Y|M$#ȫ! CSKm7p$&Y|Q/^:ubkfHcI_:\^|T59!?r5?3~? \/~? \/~\I/M{wqn710 z(䜜WEQEx$<-]AlZG^ o›5N\ (ȱ97e#4xSDX/$D>2,ѬQƠn {: ?o\Hڥ)e{{:Ke Jy7Gi XeJ`derBF|tl cf_F;KK8MK+k+m6beHI+Bw6r1 \j2_Cghp,ly%ld$G˜sƋx°^=:]O@y>׈4k>]T$7F (TU!!5Ge"Ũc)򼗍o/ҟ7%>ńſMЛ c,_6֫6Yf*P#9v bhW_+Qm !.®0}M{'z:~2;ЏAYWnuծf) lyc 3ך'E.KO,Mj^Uwr*ǿ9+gq}X ˸FĠA) cmܮ~ i8%巔D#0xBTmf͢eP>b`sܾtj ?TmV/OO5, KLyԅVxE43oi- 1 $NVȋ?23ձ[ׇ4oRPY>q FBP}c wIkŨHq%ykʿIYz4MRk`,ܲMH[*"#mیԚ;R\OԀL w ٍdϱ1m<=e}~ѵhZb*9X#QwS]'zP5믢 )@Gv[N4{.n'sT]^H&'%f mT9s?Dmq5F 4k [$S "M5FrU*r1ۿK67VuD~vR8?XǭYDp DҨfSp_hh\eA|?av֖vN#ē)LGÃ.8PMs5ד( c 09~9|On5~?o"ZKMQ Ci?hx;-7G-c%+ 7$ݻdFUb#:צv(+Oц'N [/;ƩCw_x@}%Q/imI<m yL?i?>߃/Cox;<mh[?b_uLf<-k)]๷F# ^':!=_UkXV:&k {m/E23V?-tH"MEF_pk]?h|./G_kI~mƗCox?<mƏm4h|-Z?>烿 ֯}B6$"60:g=3]@I޸_=I{{/v%o?m4h|/=o<}o[i?>z6۟փ79iEmuf8ؓSgƕ_son:QEq?SIӵ=oٝ|*s\.hS]&HS!UĀ 8[MZ1C9G\FT?W?<sKo:?>mҝGwSymI~mh]?~h.Z_kV|IL.l5 Zy]tSW"NtBs?kXV:&k {m/E23V(+;?Fk5mC/Ǔ^^oݷ9^MnӬۿvytzzcM׵ .. RlWR*_3F0[rJ wu v$[8$F; 0O1;Vtn1rrFq1RYx-qIy#`Gv*U1瑊̻ocC58I6X+x^vBp%A#>zȥn3y<3σ .:Z(' .y? '?Q{o 2HO8=kVE[-/qo ]rc ] E$G^HWkAsq +C6#3CmG1m7sh8'ֶ1Iyfpi$QKcgq|U$ ku 67>v䃽p F#hxs6##>\f](2(6ߎJ-g4V4AssI>dmlg쒬003,>.k9⹁(*`cOVFME.h 'rB?Mj{H 3+9S bC#_yuC4[ cjrOSWƚlztW=k'eS䙙 ^+~udY\D({FjZPC[ [VGJ-k_EO?ƻjhOjw>GIcۿn2p}*=uoZcl8ӽi.\[]N,G"pī. Arq|`ڶ64#E@6As@I3Mqg8/~r_X"~r?bƨ/''/''? l/t C}i=$bgt5Eq?2?pxs|կycXi2Cm̭ =;W[1\p̠13~˨YxZyDpՇB88$^.Ug2nVC+~8)5X9Wb.\L~P{\gw\[,XBb ,p(ӯoz̒ȲgP 4[pI%FN^:W`c#>N!xr[h#؊a{ eP 3 v'd> g 2=ŬnTy*k\Ӻ5&V`oR/#'#Q5Dg"+4ryʨ6|r֧-W)(8O5B%Pqz"}Iuq}_`o/{7l;sgXPC[ XwUkgO:,w2lMv=>\ᾰ!PX|j2[:rGBjޫ@N$VY$O-@`0b0`Ah9hgoE0.9i O%<ڇch6yfps1ں:('ÿ[w6 WWF‹cT2.\nQHӅNqhgqK{ڇT:8Q/2ީZ=M0P9k.hr%D;diY#vxJg=jZ'%Z_xZeZOCĿK@ZeZ>9i>Cs/"h9i~h9hgoEo_E/Ҿ^RTp  kxvW7پѿ[p=3ӽlQEq?S_Xmu /L.@4K7$(:T_m~?_EZ'fZ>/xZfZO8s/"--l?ȴm?ȴ}s/"s7"\!5{=-'%c2\q=t(k#Wui-6AӼ/ :oe>sYFnkǛRmdfF.*+ Wq#YmX⹼~B?t=x@HN 6䖰F*r2p#~ Γn)jonU/軲0F\n¨mOV;GX-M%-ޞ.n--Dc^@?{$Yrjke#[&5f Ҵ}ZQ$\x& \kNIɌzg+^i.:Z('tיִ1:' k2m{֫Ag2C[ä㾟>EexI/2nlqcWևۅ:DGxʓ0O / nxkGc([ͱ;+w;붒PK0AxepYwӈlA$r O&R/MF(o0(o% 9+Y7Qپką$I 6b-*|-G4v$H$BHvB-f ![eq!mFw9B1Mvå-~/w. 7?l6k+Q(w^".B6zq֨imPj}6C+3dHqSNEm'zxN94anAe@_X1⛋Ȏ "ټk#+`UO^wVk!K&HڠAz0xWe7 s9pWAOlj,),!DI%]J#8*8Nk}>"Dw"e7 :wxQZe g-™$ؤ5ԱTT9GnyȽwMMmR8ۂ9>MpN8Z]3777!FTOibe.*@(#5׮k_kٟB[/*0F=}/'z_ѯ]}Wjo}+1PO{ ?ĆS@[Zva^/Zzv-WRyg΁N(w(Fx x^J@_Ivf)1 囦^G3^{ME%̎2Dh@'#Y׾%uiЉЈ/!Bv)<;AB՛W@ate*U}\N[ɬ"C[R@$Y\dT;dH4ΌZ.K/&[aۥ0rq4E Bpd6s *sڐPc#l&̶7$g IwXnjw-n&-yv:+^uGԚ((+;?F bkHڗ++%+yb# 1YdҿG(H=,  U|-"ə-  YIߵ4bQM/<7/4wHɥߵ4dҿ?)ɥߵ4dK2i h3Io$]4bWTwuQ\O__ڥhw0[jw~|rAH[ʹ__2i#_%B-% i#AkD`HU?s &3_3G/,ɥqki)u$4E?dҽvfoXK?_cfM/ W_3G??4fxCşi]7iWGWчJ\Q<9;5:O{u TI+HrLGF?+{f-a, iO F/ح N}s"xcbxNC Pa¿^oXЍŸ6 gkGy'WЄaQVP(xI+6_|Fur:4&Ok8|<ZFQ?S_Js;I jz #fbۉ_pKrORhxwRI e|p@#>҈+{-݉ŬbO~o#<~>I/rZKj֌KoWXT@"g<\{¶ZUsDĩzJޢV|[xvw$bs 匭-yj͞" ү~ G$ZG[!B`xȤm"0r!N=2_ |Diu} FY$-lx`AGE?,6m }FX@L ޵~m?10rFOu DXMW25ʕ-v3| 㔁`[ +'(F3SI2&NB][>G \Pۦ$ ±aDmF6G| OM+_Xu\OȒ, $P2[vQIZ( hk_o^ZjZt3X\Jֱn?xįSC[ƺfA'%ԁ\8ǯ_Ҷ"oj2I?0&/kRpJbF zXH<G\6_NwT\6_G#Zz??r?͗#C~lGuOejL|=uO}gkf$}9&4Qd+~ dg`dcOxn+K-F{j)&#g-VQFֳEa:n F߽.wp7;2+%Cw)QͦIJxVF;TȖ#q 9Y`epd[.\ 5֕;Tb cC~lGuOe;ߛ/GS-s=9kwT\6_\5+vu}cslK` 8(+h2 STԧfg_8⸒5cPdj+IWƞ#n,b \n#dzڲPm|q*gɲ&5c6NhRopZHI8P򅷏5ic2",6Ðm7AF*-͏GhݏO_.:_ldz#ڟZz??r?͗#C~lGuOeGY}3D5_\g]@EQ^stPWQEWgSEOM睻Q [z\'J֚HΟ2f yNX2bGx-x?jAws;w;\j:[4E*:(C Tas5ť)kr͘XPI1qD}6=m(^l:Es/}p:Wp:REWxOãYW`F8}_}Q?Q ƒ.~_yeΧi雙v? '\{X`{i &%f+@0r$篮vkXRDtChFsTcr:ڧo47ЇI U1nfj~{rnչo-Fӕڬ۪)_ ꁽDEӿLwuOI gÿ?LxwuLzy˜?"LJT˜j?"SSQ cÿ'ºK$F$G?(rh+0k׉3eo8L  5™js?7J> xw?|;EχGj?{G)KK gÿOS>SQ gÿ?Lw?_SSQ cÿоhm;K YܥN@Pz޻QҊ+Oj:zq+꒠PY|IU1cKK gùSGR˜c(1/}UR˜j?"SSQ cÿ?Lxw5OI gÿ~2GWgI%x ݱ`Xb$:ڴ袸x֧|5׬>]OM0vRO9q(? “{BN\?ˏ9G)?#9q('?/]G>\t“{@I#9q('?\?I=?ORG>m㔿'.?/)O ˏ9I Oo)mExd4lqN͌ ioc]])&-skKmG:XgL wGWHA]jZe|7HRj[ O.5/ZweӢoFI^xRi_#{$dkgqCj> Z|C~ZOЩ&A<B?  h*h.OЩ&A<B|5;H-mc`Q"p$5QE@wj?_h^%ռ3A}jN[`-.O!85 Og[{^rc ](7ngF6xc4w8GgDJ&>^d3Ԏ8,xBrw|7aR/yo=89F| \x;HXe)ť"ĎUP =qW'qm5rxkHȺBȇm'``&? eIbu N𕟈j$\A RO1MݒU_mg'[s=*)!xB˟3(09`gۭ?i=x?DncӣFBTLy?  h*h.R1E6vugt"D%Pr~]vO v? K?O)i>w:Iu;%9%U$TGQV<eewuxL[UWs&nPA GQb hԝ@b:|;mG-A.?h+Ν*;s~ڛ |1zdpF޹YM̷[ǢeY66BHvx. }3!aÀJ"*h.OЩ&A<B?  k/~ 𵯆5{ hMaF  b?gϿ^( \ܾc88Tz߆AInxï\njx4? XDqOەڸ%ss.|>դ΄yH|;($ Au/ V=E$K+t P2F, 4UE0ӡA(15*h4_ Q878ap6Ӛ*h.OЩ&A<B?  h*h.OЩ&_vv$0Ez8PPJ(+:Bu9זlvq]REWk+)ns$ {r(8ְuo6@ v7p=%qa v9CN{Omߵٖ+y&m2y|ۑsn]G֧ዝ3b{'J;!\;rx}+]cGzZf H$華QO&s#-5,xe"r16pJi!eھ0dCi8@@ dկZKMQ Ci?hx;-7G-c%( Es,zޡZ`6I8Az^QEUCGLf7ϘgB=r^$<+]A\ZusEk%u(ShGT/em< GOe:^Y-r0md88$5~jڶ`Ѽdd?+*enh2'|$nb,9G9йy`}juY V F3mlU%|3yf[彷qm#PvO^,^&HY$eduU=c׾_@`Y30 j3,981p#ihU5rୣ&e^B|Р3hx;+7G-c%+o^ZoGW 3cq^<%<+Ty/Us,_0c;U OkM/<=y5նu$`A$Q[%g8֠_UT_,G$ 9.Nr{v~)ooluBY%̛iëv[f:)㜷S/>le'ZJ_4Hf#ب<x_HRdJ"x,w?# 8Hd'OtQ܌ cFFrOz^yB.%i[$!vOJ E<A1w?Zo"A·-mBg4qd;bC׮+*ÚUZ76c\w-;}JE.k|pPmau;ZI8{v{}X^P@.q$mUš&ŷD"Eqh(P7ga=wA#[-y-{70wSyx߯ŞUP$V°Hl س@'8mV-=7Qlb< yaka4vw);Wzhx;-7G-c%( E<A1w?Zo"{O۸{yHeY 8#zgj(({ڙCakug G+>"i6?g_gMs'Q{h:_)x8E<:?q/"qxw_)iQG"qxw_bCt:ev*QEZNԡZ[DA?xw_+A?xSã`_)iQG"t(Sÿ?OK8E<;@ / ?4(Sÿ?m=\ͦao:}bDa8 git1e=绺gUH?O0iUΰp O4ϴx+k%hW K\<Z?+\>?VZQ'k%'<B?bO K\<ЭqO K\d^7O Ih 3ዅU$Һm KEXNmW1 sڵJ(:vPZyy¯=qJH|)QKI _E<;@/ ?4(Sÿ?OK8E<;@ / ?4*ՎiͅD+tSWh(('j5QEQEQEQEQEQEQEQE!8טx?hͯf-6}kxV/InDȍ-|\:oW6q$d$*+sϦM u˽Bc--O *Iڠr; 'v s=Z+C) o'mY _FuQEQEQEQEQEQEQ\OCeZ>h9i~h9hgoE/xZfZ>]/yw 7Ns{;WGEQEQEQEQEQEQEQERc((((((_}3YUE?y" :[#0{c5;q-aukzqb,689`3x|+M Yj@3"+~bp=)hz:>.:j(((((((((((((((xԾ%mKO Ɣ -] ! o<SY_D5OIi3'@xSAd<!iDzh'jIhs5L=$¹ Sº S _P5OO;G+@?)?EET㴇߈%TZD4y{2 {1Qdw{IEQEQEQEQEQEQEQEQEQEQEQEQEQEQEW5;>FOyuF*N+ospӸi52MkU($e[GƭC_\!x|md%b 2?ߨ …ѯw|kQUVY Āߡ**S]6_G#ZzO S$ezzw#ڧzz??s?͗#C~lGOe\azc^ ީtn'KƉX"a@vQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEy歧jxk/76wc>تiu)BZiƷ2,q*C![Rϝ#]p8RRȬV> cs |c]|4GN2t|c>/G+ L]<@s3t°w ?7H~x;:Gs/[6x~t"39b}iQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEy[Ƀq!O1jO,zsW GPyτt$q<;E'>\?w5{OcEM4 4?C'T]G SCt?M' Ok>E^EQEQEQEQEQEQEQEQEQEQEQEQEQEQEW 41\|Jh$ʺ!CY(t/ _`I"vJנ&c]OKmŻK"ۂ e* I6t{]Qfie Br8|MѤ^mnv8s3s+:>xQ46'Н%ifO.oR{}j[y-Ö'H6WAcg6<1Z4|Hi8#7@-SGj?.\-SG ÿߨCàǞ~2⏻.:j(((((((((((((((xkkQ3>j>dѤzL Eܩ eϮ+5K ?E{i?3\L]sWfL?E{hL]sWfL?E{hL]sWf3+5@>#H'XuE,&xu$?5[=gOQ5& ((((((((((((((xk޼@Ե=?i߷oWvG^˪ī*, :3mF\{/ڠ"KvUvefÝQ&L(Ὅ 8 l'8[^:7t1TaɉH8}&<ͽhSs eJ!>l. 9I[k7x2!] X\c}]Gúm|ۛX|72qYҵKMy $uwn<t8z xj7/!O ApJbs#8"՞o7̶It4RΑv1*pd{㯬go?jc$J?FuQEQEQEQEQEQEQEQEQEQEQEQEQEQEW5?{CՋskUtO]R\O*uwTzȥil^f1[B x9#-m#ޛh8pB&CLFB3Ԁ3 I,n-/edv`MB$_jCʹ |[ JVFlnIOy ج)+eE3C(*nuV,n,io|xD#HxW #"-\ks_Ѯ7ۨfBW^ 2?uU;/bWա} @? ]O iWv'8^:۱K FqfoJ=B=ϽQMQEMǑ}e(((((((((((((+gtkada-24.0.0/docs/gtkada_ug/index.rst000066400000000000000000000015321446021174000175470ustar00rootroot00000000000000GtkAda User's Guide =================== .. toctree:: :numbered: :maxdepth: 3 intro getting_started hierarchical_composition signals applications resource_files memory tasking external_events object_oriented glade new_widgets debugging transition reporting_bugs system_dependencies gtk_parasite bibliography license Copyright C 1998-2000, Emmanuel Briot, Joel Brobecker, Arnaud Charlet Copyright C 2000-2014, AdaCore Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.1 or any later version published by the Free Software Foundation; with no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts. A copy of the license is included in the section entitled 'GNU Free Documentation License'. gtkada-24.0.0/docs/gtkada_ug/intro.rst000066400000000000000000000065571446021174000176070ustar00rootroot00000000000000****************************** Introduction: What is GtkAda ? ****************************** GtkAda is a high-level portable graphical toolkit, based on the gtk+ toolkit, one of the official GNU toolkits. It makes it easy to create portable user interfaces for multiple platforms, including most platforms that have a X11 server and Win32 platforms. Although it is based on a C library, GtkAda uses some advanced Ada features such as tagged types, generic packages, access to subprograms, and exceptions to make it easier to use and design interfaces. For efficiency reasons, it does not use controlled types, but takes care of all the memory management for you in other ways. As a result, this library provides a *secure*, *easy to use* and *extensible* toolkit. Compared to the C library, GtkAda provides type safety (especially in the callbacks area), and object-oriented programming. As opposed to common knowledge, it requires *less* type casting than with in C. Its efficiency is about the same as the C library through the use of inline subprograms. GtkAda comes with a complete integration to the graphical interface builder `Glade`. This makes it even easier to develop interfaces, since you just have to click to create a description of the window and all the dialogs. Ada code can simply import that description to bring the windows to life. Under some platforms, GtkAda also provides a bridge to use OpenGL, with which you can create graphical applications that display 3D graphics, and display them in a GtkAda window, as with any other 2D graphics. This manual does not document OpenGL at all, see any book on OpenGL, or the specification that came with your OpenGL library, for more information. The following Internet sites will always contain the latest public packages for `GtkAda`, `gtk+`, `Glade` and `Cairo` * `https://github.com/AdaCore/gtkada `_ * `http://www.gtk.org/ `_ * `http://glade.gnome.org/ `_ * `http://www.cairographics.org/ `_ This toolkit was tested on the following systems: * GNU Linux/x86 * GNU Linux/x86-64 * Mac OS/x86-64 * Windows 2008r2,7,10/x86 * Windows 2008r2,7,10/x86-64 with the latest version of the `GNAT` compiler, developed and supported by Ada Core Technologies (see `http://www.adacore.com `_). This version of GtkAda is known to be compatible with `gtk+` **3.24.x** This release may or may not be compatible with older versions of gtk+. This document does not describe all the widgets available in GtkAda, nor does it try to explain all the subprograms. The GtkAda Reference Manual provides this documentation instead, as well as the GtkAda sources spec files themselves, whose extension is :file:`.ads`. No complete example is provided in this documentation. Instead, please refer to the examples that you can find in the :file:`testgtk/` and :file:`examples/` directory in the GtkAda distribution, since these are more up-to-date (and more extensive). They are heavily commented, and are likely to contain a lot of information that you might find interesting. If you are interested in getting support for GtkAda--including priority bug fixes, early releases, help in using the toolkit, help in designing your interface, and on site consulting--please contact AdaCore (`mailto:sales@adacore.com `_). gtkada-24.0.0/docs/gtkada_ug/layout.html000066400000000000000000000002541446021174000201110ustar00rootroot00000000000000{% extends "!layout.html" %} {% block menu %} {{ super() }}

  • Index
    • {% endblock %} gtkada-24.0.0/docs/gtkada_ug/license.rst000066400000000000000000000436511446021174000200720ustar00rootroot00000000000000****************************** GNU Free Documentation License ****************************** Version 1.1, March 2000 Copyright (C) 2000 Free Software Foundation, Inc. 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. PREAMBLE ======== The purpose of this License is to make a manual, textbook, or other written document 'free' in the sense of freedom: to assure everyone the effective freedom to copy and redistribute it, with or without modifying it, either commercially or noncommercially. Secondarily, this License preserves for the author and publisher a way to get credit for their work, while not being considered responsible for modifications made by others. This License is a kind of 'copyleft', which means that derivative works of the document must themselves be free in the same sense. It complements the GNU General Public License, which is a copyleft license designed for free software. We have designed this License in order to use it for manuals for free software, because free software needs free documentation: a free program should come with manuals providing the same freedoms that the software does. But this License is not limited to software manuals; it can be used for any textual work, regardless of subject matter or whether it is published as a printed book. We recommend this License principally for works whose purpose is instruction or reference. APPLICABILITY AND DEFINITIONS ============================= This License applies to any manual or other work that contains a notice placed by the copyright holder saying it can be distributed under the terms of this License. The 'Document', below, refers to any such manual or work. Any member of the public is a licensee, and is addressed as 'you'. A 'Modified Version' of the Document means any work containing the Document or a portion of it, either copied verbatim, or with modifications and/or translated into another language. A 'Secondary Section' is a named appendix or a front-matter section of the Document that deals exclusively with the relationship of the publishers or authors of the Document to the Document's overall subject (or to related matters) and contains nothing that could fall directly within that overall subject. (For example, if the Document is in part a textbook of mathematics, a Secondary Section may not explain any mathematics.) The relationship could be a matter of historical connection with the subject or with related matters, or of legal, commercial, philosophical, ethical or political position regarding them. The 'Invariant Sections' are certain Secondary Sections whose titles are designated, as being those of Invariant Sections, in the notice that says that the Document is released under this License. The 'Cover Texts' are certain short passages of text that are listed, as Front-Cover Texts or Back-Cover Texts, in the notice that says that the Document is released under this License. A 'Transparent' copy of the Document means a machine-readable copy, represented in a format whose specification is available to the general public, whose contents can be viewed and edited directly and straightforwardly with generic text editors or (for images composed of pixels) generic paint programs or (for drawings) some widely available drawing editor, and that is suitable for input to text formatters or for automatic translation to a variety of formats suitable for input to text formatters. A copy made in an otherwise Transparent file format whose markup has been designed to thwart or discourage subsequent modification by readers is not Transparent. A copy that is not 'Transparent' is called 'Opaque'. Examples of suitable formats for Transparent copies include plain ASCII without markup, Texinfo input format, LaTeX input format, SGML or XML using a publicly available DTD, and standard-conforming simple HTML designed for human modification. Opaque formats include PostScript, PDF, proprietary formats that can be read and edited only by proprietary word processors, SGML or XML for which the DTD and/or processing tools are not generally available, and the machine-generated HTML produced by some word processors for output purposes only. The 'Title Page' means, for a printed book, the title page itself, plus such following pages as are needed to hold, legibly, the material this License requires to appear in the title page. For works in formats which do not have any title page as such, 'Title Page' means the text near the most prominent appearance of the work's title, preceding the beginning of the body of the text. VERBATIM COPYING ================ You may copy and distribute the Document in any medium, either commercially or noncommercially, provided that this License, the copyright notices, and the license notice saying this License applies to the Document are reproduced in all copies, and that you add no other conditions whatsoever to those of this License. You may not use technical measures to obstruct or control the reading or further copying of the copies you make or distribute. However, you may accept compensation in exchange for copies. If you distribute a large enough number of copies you must also follow the conditions in section 3. You may also lend copies, under the same conditions stated above, and you may publicly display copies. COPYING IN QUANTITY =================== If you publish printed copies of the Document numbering more than 100, and the Document's license notice requires Cover Texts, you must enclose the copies in covers that carry, clearly and legibly, all these Cover Texts: Front-Cover Texts on the front cover, and Back-Cover Texts on the back cover. Both covers must also clearly and legibly identify you as the publisher of these copies. The front cover must present the full title with all words of the title equally prominent and visible. You may add other material on the covers in addition. Copying with changes limited to the covers, as long as they preserve the title of the Document and satisfy these conditions, can be treated as verbatim copying in other respects. If the required texts for either cover are too voluminous to fit legibly, you should put the first ones listed (as many as fit reasonably) on the actual cover, and continue the rest onto adjacent pages. If you publish or distribute Opaque copies of the Document numbering more than 100, you must either include a machine-readable Transparent copy along with each Opaque copy, or state in or with each Opaque copy a publicly-accessible computer-network location containing a complete Transparent copy of the Document, free of added material, which the general network-using public has access to download anonymously at no charge using public-standard network protocols. If you use the latter option, you must take reasonably prudent steps, when you begin distribution of Opaque copies in quantity, to ensure that this Transparent copy will remain thus accessible at the stated location until at least one year after the last time you distribute an Opaque copy (directly or through your agents or retailers) of that edition to the public. It is requested, but not required, that you contact the authors of the Document well before redistributing any large number of copies, to give them a chance to provide you with an updated version of the Document. MODIFICATIONS ============= You may copy and distribute a Modified Version of the Document under the conditions of sections 2 and 3 above, provided that you release the Modified Version under precisely this License, with the Modified Version filling the role of the Document, thus licensing distribution and modification of the Modified Version to whoever possesses a copy of it. In addition, you must do these things in the Modified Version: * Use in the Title Page (and on the covers, if any) a title distinct from that of the Document, and from those of previous versions (which should, if there were any, be listed in the History section of the Document). You may use the same title as a previous version if the original publisher of that version gives permission. * List on the Title Page, as authors, one or more persons or entities responsible for authorship of the modifications in the Modified Version, together with at least five of the principal authors of the Document (all of its principal authors, if it has less than five). * State on the Title page the name of the publisher of the Modified Version, as the publisher. * Preserve all the copyright notices of the Document. * Add an appropriate copyright notice for your modifications adjacent to the other copyright notices. * Include, immediately after the copyright notices, a license notice giving the public permission to use the Modified Version under the terms of this License, in the form shown in the Addendum below. * Preserve in that license notice the full lists of Invariant Sections and required Cover Texts given in the Document's license notice. * Include an unaltered copy of this License. * Preserve the section entitled 'History', and its title, and add to it an item stating at least the title, year, new authors, and publisher of the Modified Version as given on the Title Page. If there is no section entitled 'History' in the Document, create one stating the title, year, authors, and publisher of the Document as given on its Title Page, then add an item describing the Modified Version as stated in the previous sentence. * Preserve the network location, if any, given in the Document for public access to a Transparent copy of the Document, and likewise the network locations given in the Document for previous versions it was based on. These may be placed in the 'History' section. You may omit a network location for a work that was published at least four years before the Document itself, or if the original publisher of the version it refers to gives permission. * In any section entitled 'Acknowledgements' or 'Dedications', preserve the section's title, and preserve in the section all the substance and tone of each of the contributor acknowledgements and/or dedications given therein. * Preserve all the Invariant Sections of the Document, unaltered in their text and in their titles. Section numbers or the equivalent are not considered part of the section titles. * Delete any section entitled 'Endorsements'. Such a section may not be included in the Modified Version. * Do not retitle any existing section as 'Endorsements' or to conflict in title with any Invariant Section. If the Modified Version includes new front-matter sections or appendices that qualify as Secondary Sections and contain no material copied from the Document, you may at your option designate some or all of these sections as invariant. To do this, add their titles to the list of Invariant Sections in the Modified Version's license notice. These titles must be distinct from any other section titles. You may add a section entitled 'Endorsements', provided it contains nothing but endorsements of your Modified Version by various parties -- for example, statements of peer review or that the text has been approved by an organization as the authoritative definition of a standard. You may add a passage of up to five words as a Front-Cover Text, and a passage of up to 25 words as a Back-Cover Text, to the end of the list of Cover Texts in the Modified Version. Only one passage of Front-Cover Text and one of Back-Cover Text may be added by (or through arrangements made by) any one entity. If the Document already includes a cover text for the same cover, previously added by you or by arrangement made by the same entity you are acting on behalf of, you may not add another; but you may replace the old one, on explicit permission from the previous publisher that added the old one. The author(s) and publisher(s) of the Document do not by this License give permission to use their names for publicity for or to assert or imply endorsement of any Modified Version. COMBINING DOCUMENTS =================== You may combine the Document with other documents released under this License, under the terms defined in section 4 above for modified versions, provided that you include in the combination all of the Invariant Sections of all of the original documents, unmodified, and list them all as Invariant Sections of your combined work in its license notice. The combined work need only contain one copy of this License, and multiple identical Invariant Sections may be replaced with a single copy. If there are multiple Invariant Sections with the same name but different contents, make the title of each such section unique by adding at the end of it, in parentheses, the name of the original author or publisher of that section if known, or else a unique number. Make the same adjustment to the section titles in the list of Invariant Sections in the license notice of the combined work. In the combination, you must combine any sections entitled 'History' in the various original documents, forming one section entitled 'History'; likewise combine any sections entitled 'Acknowledgements', and any sections entitled 'Dedications'. You must delete all sections entitled 'Endorsements.' COLLECTIONS OF DOCUMENTS ======================== You may make a collection consisting of the Document and other documents released under this License, and replace the individual copies of this License in the various documents with a single copy that is included in the collection, provided that you follow the rules of this License for verbatim copying of each of the documents in all other respects. You may extract a single document from such a collection, and distribute it individually under this License, provided you insert a copy of this License into the extracted document, and follow this License in all other respects regarding verbatim copying of that document. AGGREGATION WITH INDEPENDENT WORKS ================================== A compilation of the Document or its derivatives with other separate and independent documents or works, in or on a volume of a storage or distribution medium, does not as a whole count as a Modified Version of the Document, provided no compilation copyright is claimed for the compilation. Such a compilation is called an 'aggregate', and this License does not apply to the other self-contained works thus compiled with the Document, on account of their being thus compiled, if they are not themselves derivative works of the Document. If the Cover Text requirement of section 3 is applicable to these copies of the Document, then if the Document is less than one quarter of the entire aggregate, the Document's Cover Texts may be placed on covers that surround only the Document within the aggregate. Otherwise they must appear on covers around the whole aggregate. TRANSLATION =========== Translation is considered a kind of modification, so you may distribute translations of the Document under the terms of section 4. Replacing Invariant Sections with translations requires special permission from their copyright holders, but you may include translations of some or all Invariant Sections in addition to the original versions of these Invariant Sections. You may include a translation of this License provided that you also include the original English version of this License. In case of a disagreement between the translation and the original English version of this License, the original English version will prevail. TERMINATION =========== You may not copy, modify, sublicense, or distribute the Document except as expressly provided for under this License. Any other attempt to copy, modify, sublicense or distribute the Document is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance. FUTURE REVISIONS OF THIS LICENSE ================================ The Free Software Foundation may publish new, revised versions of the GNU Free Documentation License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. See http://www.gnu.org/copyleft/. Each version of the License is given a distinguishing version number. If the Document specifies that a particular numbered version of this License 'or any later version' applies to it, you have the option of following the terms and conditions either of that specified version or of any later version that has been published (not as a draft) by the Free Software Foundation. If the Document does not specify a version number of this License, you may choose any version ever published (not as a draft) by the Free Software Foundation. ADDENDUM: How to use this License for your documents ==================================================== To use this License in a document you have written, include a copy of the License in the document and put the following copyright and license notices just after the title page:: Copyright (c) YEAR YOUR NAME. Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.1 or any later version published by the Free Software Foundation; with the Invariant Sections being LIST THEIR TITLES, with the Front-Cover Texts being LIST, and with the Back-Cover Texts being LIST. A copy of the license is included in the section entitled 'GNU Free Documentation License'. If you have no Invariant Sections, write 'with no Invariant Sections' instead of saying which ones are invariant. If you have no Front-Cover Texts, write 'no Front-Cover Texts' instead of 'Front-Cover Texts being LIST'; likewise for Back-Cover Texts. If your document contains nontrivial examples of program code, we recommend releasing these examples in parallel under your choice of free software license, such as the GNU General Public License, to permit their use in free software. gtkada-24.0.0/docs/gtkada_ug/memory.rst000066400000000000000000000021701446021174000177470ustar00rootroot00000000000000.. _Memory_management: ***************** Memory management ***************** GtkAda takes care of almost all the memory management for you. Here is a brief overview of how this works, you'll have to check the sources if you want more detailed information. Gtk+ (the C library) does its own memory management through reference counting, i.e. any widget is destroyed when it is no longer referenced anywhere in the application. In GtkAda itself, a 'user_data' is associated with each object allocated by a `Gtk_New` procedure. A 'destroy' callback is also associated, to be called when the object to which the user_data belongs is destroyed. Thus, every time a C object is destroyed, the equivalent Ada structure is also destroyed (see `Gtk.Free_User_Data`). Concerning widgets containing children, every container holds a reference to its children, whose reference counting is thus different from 0 (and generally 1). When the container is destroyed, the reference of all its children and grand-children is decremented, and they are destroyed in turn if needed. So the deallocation of a widget hierarchy is also performed automatically. gtkada-24.0.0/docs/gtkada_ug/new_widgets.rst000066400000000000000000000021431446021174000207560ustar00rootroot00000000000000.. _Binding_new_widgets: ******************* Binding new widgets ******************* GtkAda comes with a Perl script to help you create a binding to a C widget (this is the script we have used ourselves). This will not fully automate the process, although it should really speed things up. You will probably need less than 15 min to create a new binding once you will get used to the way GtkAda works. Note that your C file should have the same format as is used by Gtk+ itself. To get started on a new binding, launch the script :file:`contrib/binding.pl` as follows:: $ touch gtk-button.ads $ binding.pl ../include/gtk/gtkbutton.h > temporary This dumps several kind of information on the standard output: * List of subprograms defined in the :file:`.h` file. Their documentation is also added, since binding.pl will parse the :file:`.c` file as appropriate. * List of properties and signals for the widget * Tentative bodies for the subprograms These will often need adjustements, but provide a good start You can also use this script to update existing bindings:: $ binding.pl ../include/gtk/*.h gtkada-24.0.0/docs/gtkada_ug/object_oriented.rst000066400000000000000000000344111446021174000216010ustar00rootroot00000000000000.. _Object-oriented_features: ************************ Object-oriented features ************************ GtkAda has been designed from the beginning to provide a full object oriented layer over gtk+. This means that features such as type extension and dynamic dispatching are made available through the standard Ada language. This section will describe how things work, how you can extend existing widgets, and even how to create your own widgets. .. _General_description_of_the_tagged_types: General description of the tagged types ======================================= Why should I use object-oriented programming ? ---------------------------------------------- Every widget in the `Gtk.*` packages in GtkAda is a tagged type with a number of primitive subprograms that are inherited by all of its children. Tagged types in Ada make it possible to perform safe, automatic type conversions without using explicit casts (such as is necessary when coding in C). It is also possible for the compiler to verify whether or not these type conversions are valid. Most errors are found at compile time, which leads to a safer and more robust application. As a further example, imagine a table that has been populated by some widgets. It is possible to query for this table's children and operate on these widgets without knowing details about their type, their creator, and so on--the tagged objects that are returned contain all the information necessary. It becomes possible to use dynamic dispatching without ever having to cast to a known type. Modifying a standard widget to draw itself differently or display different data is easy using tagged types. Simply create a new type that extends the current one (see the section :ref:`Using_tagged_types_to_extend_Gtk_widgets` below. Creating a new reusable widget from scratch is also possible. Create a new tagged type and specify properties of the widget--such as how it is to draw itself and how it should react to events. See the section :ref:`Creating_new_widgets_in_Ada` below. Object oriented programming through the use of Ada tagged types makes GtkAda a very powerful, flexible, and safe tool for designing graphical interfaces. Type conversions from C to Ada widgets -------------------------------------- There are three kinds of widgets that you can use with GtkAda: * *Ada widgets*: These are widgets that are written directly in Ada, using the object oriented features of GtkAda * *Standard widgets*: These are the widgets that are part of the standard gtk+ and GtkAda distributions. This include all the basic widgets you need to build advanced interfaces. * *third party C widgets* These are widgets that were created in C, and for which you (or someone else) created an Ada binding. This is most probably the kind of widgets you will have if you want to use third party widgets. GtkAda will always be able to find and/or create a valid tagged type in the first two cases, no matter if you explicitly created the widget or if it was created automatically by gtk+. For instance, if you created a widget in Ada, put it in a table, and later on extracted it from the table, then you will still have the same widget. In the third case (third party C widgets), GtkAda is not, by default, able to create the corresponding Ada type. The case of third party C widgets is a little bit trickier. Since GtkAda does not know anything about them when it is built, it can't magically convert the C widgets to Ada widgets. This is your job to teach GtkAda how to do the conversion. We thus provide a 'hook' function which you need to modify. This function is defined in the package **Glib.Type_Conversion**. This function takes a string with the name of the C widget (ex/ "GtkButton"), and should return a newly allocated pointer. If you don't know this type either, simply return **null**. .. _Using_tagged_types_to_extend_Gtk_widgets: Using tagged types to extend Gtk widgets ======================================== .. highlight:: ada With this toolkit, it's possible to associate your own data with existing widgets simply by creating new types. This section will show you a simple example, but you should rather read the source code in the :file:`testgtk/` directory where we used this feature instead of using `user_data` as is used in the C version::: type My_Button_Record is new Gtk_Button_Record with record -- whatever data you want to associate with your button end record; type My_Button is access all My_Button_Record'Class; With the above statements, your new type is defined. Every function available for `Gtk_Button` is also available for `My_Button`. Of course, as with every tagged type in Ada, you can create your own primitive functions with the following prototype:: procedure My_Primitive_Func (Myb : access My_Button_Record); To instanciate an object of type `My_Button` in your application, do the following:: declare Myb : My_Button; begin Myb := new My_Button_Record; Initialize (Myb); -- from Gtk.Button end; The first line creates the Ada type, whereas the `Initialize` call actually creates the C widget and associates it with the Ada type. .. _Creating_new_widgets_in_Ada: Creating new widgets in Ada =========================== With GtkAda, you can create widgets directly in Ada. These new widgets can be used directly, as if they were part of gtk itself. Creating new widgets is a way to create reuseable components. You can apply to them the same functions as you would for any other widget, such as `Show`, `Hide`, and so on. This section will explain how to create two types of widgets: composite widgets and widgets created from scratch. Two examples are provided with GtkAda, in the directories :file:`examples/composite_widget` and :file:`examples/base_widget`. Please also refer to the gtk+ tutorial, which describes the basic mechanisms that you need to know to create a widget. .. _Creating_composite_widgets: Creating composite widgets -------------------------- A composite widget is a widget that does not do much by itself. Rather, this is a collection of subwidgets grouped into a more general entity. For instance, among the standard widgets, `Gtk_File_Selection` and `Gtk_Font_Selection` belong to this category. The good news is that there is nothing special to know. Just create a new tagged type, extending one of the standard widgets (or even another of your own widgets), provide a `Gtk_New` function that allocates memory for this widget, and call the `Initialize` function that does the actual creation of the widget and the subwidgets. There is only one thing to do: `Initialize` should call the parent class's `Initialize` function, to create the underlying C widget. The example directory :file:`examples/composite_widget` reimplements the `Gtk_Dialog` widget as written in C by the creators of gtk+. .. _Creating_widgets_from_scratch: Creating widgets from scratch ----------------------------- Creating a working widget from scratch requires a certain level of familiary with the GtkAda signal mechanism and entails much work with low level signals. This is therefore not an activity recommended for novice GtkAda programmers. Creating a widget from scratch is what you want to do if your widget should be drawn in a special way, should create and emit new signals, or otherwise perform differently than pre-existing widgets. The example we give in :file:`examples/base_widget` is a small target on which the user can click, and that sends one of two signals: "bullseye" or "missed", depending on where the user has clicked. See also the example in :file:`examples/tutorial/gtkdial` for a more complex widget, that implements a gauge where the user can move the arrow to select a new value. Since we are creating a totally new widget from scratch, with potentially its own signals, we need to do slightly more work. In particular, we need to provide a function ``Get_Type`` similar to what all the predefined widgets provide:: with Glib.Properties.Creation; use Glib.Properties.Creation; with Glib.Objects; use Glib.Objects; with Gtk.Scrollable; with System; package body My_Widgets is type My_Widget_Record is new Gtk_Button_Record with record ... end record; type My_Widget is access all My_Widget_Record'Class; Klass : aliased Ada_GObject_Class := Uninitialized_Class; PROP_H_ADJ : constant Property_Id := 1; PROP_V_ADJ : constant Property_Id := 2; -- internal identifier for our widget properties procedure Class_Init (Self : GObject_Class); pragma Convention (C, Class_Init); procedure Class_Init (Self : GObject_Class) is begin -- Set properties handler Set_Properties_Handlers (Self, Prop_Set'Access, Prop_Get'Access); -- Override inherited properties Override_Property (Self, PROP_H_ADJ, "hadjustment"); Override_Property (Self, PROP_V_ADJ, "vadjustment"); -- Install some custom style properties Install_Style_Property (Self, Gnew_Int (...)); -- Override some the inherited methods (how to draw the widget) Set_Default_Draw_Handler (Self, On_Draw'Access); -- Override the primitives to compute the widget size Set_Default_Get_Preferred_Width (Self, ...); end Class_Init; function Get_Type return GType is Info : access GInterface_Info; begin if Initialize_Class_Record (Ancestor => Gtk.Button.Get_Type, Class_Record => Klass'Access, Type_Name => "My_Widget", Class_Init => Class_Init) begin -- Add interfaces if needed Info := new GInterface_Info'(null, null, System.Address); Add_Interface (Klass, Gtk.Scrollable.Get_Type, Info); end if; return Klass.The_Type; end Get_Type; end My_Widgets; You should also create the usual functions ``Gtk_New`` and ``Initialize``:: procedure Gtk_New (Self : out My_Widget) is begin Self := new My_Widget_Record; -- create the Ada wrapper Initialize (Self); end Gtk_New; procedure Initialize (Self : not null access My_Widget_Record'Class) is begin G_New (Self, Get_Type); -- allocate the C widget, unless done -- Initialize parent fields. Gtk.Button.Initialize (Self); -- Initialization of the Ada types Self.Field1 := ...; end Initialize; In the above example, the new part is the ``Get_Type`` subprogram. It takes three or four arguments: * `Ancestor` This is the GType for the ancestor that is being extended. * `Signals` This is an array of string access containing the name of the signals you want to create. For instance, you could create Signals with:: Signals : Gtkada.Types.Chars_Ptr_Array := "bullseye" + "missed"; This will create two signals, named "bullseye" and "missed", whose callbacks' arguments can be specified with the fourth parameter. * `Class_Record` Every widget in C is associated with three records: - An instance of `GType`, which is a unique identifier (integer) for all the class of widgets defined in the framework. This description also contains the name of the class, its parent type, the list of interfaces it inherits, and all the signals is defines. These `GType` are often created early on when an application is launched, and provide the basic introspection capabilities in a gtk+ application. In Ada, this type is created by the function `Get_Type` in the example above (which is why we need to add the interface in that function). - An instance of `GObject_Class`, which contains implementation details for the class, defines the default signal handlers (how to draw a widget of the class, how to handle size negociation,...), and defines any number of properties that can be configured on the widget (properties are a generic interface to access the components of a composite widget, as well as some of its behavior -- they can be modified through introspection for instance in a GUI builder). Such a type is created automatically by gtk+ just before it creates the first instance of that widget type. It will then immediately call the `Class_Init` function that might have been passed to `Glib.Object.Initialize_Class_Record`. At that point, you can add your own new properties, or override the default signal handlers to redirect them to your own implementation. - A class instance record; there is one such record for each widget of that type. In GtkAda, the 'instance record' is simply your tagged type and its fields. It is created when you call any of the `Gtk_New` functions. * `Parameters` This fourth argument is in fact optional, and is used to specify which kind of parameters each new signal is expecting. By default (ie if you don't give any value for this parameter), all the signals won't expect any argument, except of course a possible user_data. However, you can decide for instance that the first signal ("bullseye") should in fact take a second argument (say a Gint), and that "missed" will take two parameters (two Gints). `Parameters` should thus contain a value of:: (1 => (1 => Gtk_Type_Int, 2 => Gtk_Type_None), 2 => (1 => Gtk_Type_Int, 2 => Gtk_Type_Int)); Due to the way arrays are handled in Ada, each component must have the same number of signals. However, if you specify a type of `Gtk_Type_None`, this will in fact be considered as no argument. Thus, the first signal above has only one parameter. Note also that to be able to emit a signal such a the second one, ie with multiple arguments, you will have to extend the packages defined in Gtk.Handlers. By default, the provided packages can only emit up to one argument (and only for a few specific types). Creating your own `Emit_By_Name` subprograms should not be hard if you look at what is done in :file:`gtk-marshallers.adb`. Basically, something like:: procedure Emit_With_Two_Ints (Object : access Widget_Type'Class; Name : String; Arg1 : Gint; Arg2 : Gint); pragma Import (C, Emit_With_Two_Ints, "gtk_signal_emit_by_name"); Emit_With_Two_Ints (Gtk.Get_Object (Your_Widget), "missed" & ASCII.NUL, 1, 2); will emit the "missed" signal with the two parameters 1 and 2. gtkada-24.0.0/docs/gtkada_ug/reporting_bugs.rst000066400000000000000000000040551446021174000214740ustar00rootroot00000000000000.. _How_to_report_bugs: ****************** How to report bugs ****************** GtkAda is a mature, stable toolkit that is heavily and widely used on a variety of platforms. We test GtkAda using an Ada version of the :file:`testgtk.c` file found in the gtk+ distribution. For code examples that demonstrate the use of this toolkit, look within the :file:`testgtk/` directory. There are two kinds of problems you can encounter: * If the gtk library itself was compiled with warnings turned on, you may get some warning messages, mainly because of types problems. These warnings should not appear, as we have tried to be as type safe as possible in this package. To know exactly where the problem is, compile your program with debug information, run gdb, and set a breakpoint on the function `g_log`. Then run your program as usual, using the `run` command. Then send us the result of the `where` command. Here is a summary:: $ gprbuild -Pyour_project.gpr -g $ gdb (gdb) break main (gdb) run (gdb) break g_log (gdb) continue .... (gdb) where * In some (hopefully) rare cases, you can even get a segmentation fault within gtk. That means there is definitly something wrong either in your program or in the toolkit. Please check your program carefully and, if you think this is a problem in GtkAda itself, send us an e-mail. If you are a supported user of GNAT, send mail to `mailto:report@gnat.com `_ to report errors, otherwise send mail to the GtkAda list (`mailto:gtkada@lists.adacore.com `_) explaining exactly what your are doing, what is the expected result and what you actually get. Please include the required sources to reproduce the problem, in a format usable by `gnatchop` (basically, insert all the required sources at the end of the mail). Please try to provide as small as possible a subset of your sources. Of course, we will welcome any patch you can provide, so that this toolkit may be as useful as possible. gtkada-24.0.0/docs/gtkada_ug/resource_files.rst000066400000000000000000000027071446021174000214560ustar00rootroot00000000000000.. _Resource_files: ************** Resource files ************** Resource files let you parametrize aspects of the widgets in a GtkAda application without having to recompile it. In this file, it is possible to specify visual characteristics of widgets, such as their colors and fonts. Under X, the `xfontsel` command allows you to easily select a font. The FontSelection widget is also a simple way to select fonts. Here is an example of a resource file:: # application.rc # # resource file for "Application" # Buttons style style "button" { # BackGround Colors # Red Green Blue bg[PRELIGHT] = { 0.0, 0.75, 0.0 } # Green when the mouse is on # the button bg[ACTIVE] = { 0.75, 0.0, 0.0 } # Red on click # ForeGround Colors # Red Green Blue fg[PRELIGHT] = { 1.0, 1.0, 1.0 } # White when the mouse is on # the button fg[ACTIVE] = { 1.0, 1.0, 1.0 } # White on click } # All the buttons will have the style "button" widget_class "*GtkButton*" style "button" # Text style style "text" { font = "-adobe-courier-medium-r-normal-*-15-*-*-*-*-*-*-*" text[NORMAL] = { 0.0, 0.0, 0.0 } # black fg[NORMAL] = { 0.0, 0.0, 0.0 } # black base[NORMAL] = { 1.0, 1.0, 1.0 } # white : background color } # All Gtk_Text will have the "text" style widget_class "*GtkText" style "text" gtkada-24.0.0/docs/gtkada_ug/signals.rst000066400000000000000000000365311446021174000201070ustar00rootroot00000000000000.. _Signal_handling: *************** Signal handling *************** In GtkAda, the interaction between the interface and the core application is done via signals. Most user actions on the graphical application trigger some signals to be emitted. A signal is a message that an object wants to broadcast. It is identified by its name, and each one is associated with certain events which happen during the widget's lifetime. For instance, when the user clicks on a Gtk_Button, a 'clicked' signal is emitted by that button. More examples of signals can be found in the GtkAda reference manual. It is possible to cause the application to react to such events by *connecting* to a signal a special procedure called a *handler* or *callback*. This handler will be called every time that signal is emitted, giving the application a chance to do any processing it needs. More than one handler can be connected to the same signal on the same object; the handlers are invoked in the order they were connected. Predefined signals ================== Widgets, depending on their type, may define zero or more different signals. The signals defined for the parent widget are also automatically inherited; thus every widget answers many signals. The easiest way to find out which signals can be emitted by a widget is to look at the GtkAda reference manual. Every widget will be documented there. The GtkAda RM explains when particular signals are emitted, and the general form that their handlers should have (although you can always add a `User_Data` if you wish, see below). In general, your handlers should have the exact same profile that is documented (the GtkAda RM is automatically generated, so you can in fact find the same documentation directly in GtkAda's :file:`*.ads` files). However, if you connect to signals via the generic packages defined in :file:`Gtk.Handlers` (see below), it is valid to pass a procedure that drops all arguments except the first one, i.e. the actual widget that emitted the signal. To get a better documented code, though, we recommend to always use the full profile for your handlers. .. _Connecting_signals: Connecting signals ================== There are currently two ways to connect widgets to signal handlers. One of them is much simpler to use, although it has some limited capabilities. Connecting via the `On_*` procedures ---------------------------------------- Each widget has a number of primitive operations (including inherited ones) for all the signals it might emit. In fact, for each signal there are two `On_` procedures that can be used to easily connect to the corresponding signal:: procedure Handler (Button : access Gtk_Button_Record'Class) is begin ... end Handler; Button.On_Clicked (Handler'Access); The code above ensures that the procedure `Handler` is called whenever the button is clicked. The `On_*` procedures ensure that the profile of the handler is correct, and thus are type-safe. The type of the first parameter to the handler is always the type where the signal is defined, not the type to which the handler is connected. For instance, the "draw" signal is defined for a `Gtk_Widget`. But if you connect this signal to a `Gtk_Button`, the first paramter of the handler is always of type `access Gtk_Widget_Record'Class`. There is a second version of the `On_*` procedures, which is used to pass a different object than the one the signal is connected to. In practice, this is the version that is used more often. For instance, clicking on a toolbar button will in general affect some other widget than the button itself, and you would typically pass the main window as a parameter to the handler. Here is an example, note how the type of the first parameter is different:: procedure Handler (Win : access GObject_Record'Class) is begin ... end Handler; Button.On_Clicked (Handler'Access, Slot => Main_Window); This subprogram also ensures that the handler is automaticall disconnected if the second object is destroyed. Connecting via the `Gtk.Handlers` package ------------------------------------------ All signal handling work is performed internally using services provided by the `Gtk.Handlers` package. But this package can also be used directly by user applications. This file is collection of several generic packages that need to be instantiated before you can actually start connecting handlers to widgets. A number of predefined instantiations are provided in :file:`GtkAda.Handlers` to make it slightly easier. Compared to the previous approach based on the `On_*` procedures described above, this approach has a number of additional capabilities, at the cost of slightly more complex code: * It is possible to retrieve a handle on the Widget/Signal/Handle tuple, so that you can later on disconnect the handler, or temporarily block the signal for instance. * It is possible to pass additional user data to the handler. For instance, you could have a single handler connected to multiple check buttons. When you press any of the button, the handler is called and passes an additional integer to indicate which button was pressed. This is sometimes convenient, although it can often be avoided by creating new Ada tagged types derived from the standard GtkAda types. * You have full control over the type of the first parameter to the handler. As discussed earlier, the `On_*` subprograms force specific types (either a `GObject_Record` or the type on which the signal was defined). With the generic packages, you can avoid the often necessary type casts in the handler, although this approach does not guarantee more (or less) type safety. * A very limited number of signals do not have a corresponding `On_*` for circular dependency (or elaboration circularity) reasons. For those, you need to use the generic packages. However, we believe these signals are hardly ever used by user-level applications. A short, annotated example of connecting signals follows; a complete example can be found in create_file_selection.adb (inside the :file:`testgtk/` directory). In our example, an application opens a file selector to allow the user to select a file. GtkAda provides a high-level widget called Gtk_File_Selection which can be used in this case:: declare Window : Gtk_File_Selection; begin Gtk.File_Selection.Gtk_New (Window, Title => "Select a file"); end; When the 'OK' button is pressed, the application needs to retrieve the selected file and then close the dialog. The only information that the handler for the button press needs is which widget to operate upon. This can be achieved by the following handler:: procedure OK (Files : access Gtk_File_Selection_Record'Class) is begin -- Prints the name of the selected file. Ada.Text_IO.Put_Line ("Selected " & Get_Filename (Files)); -- Destroys the file selector dialog Destroy (Files); end Ok; We now need to connect the object we created in the first part with the new callback we just defined. `Gtk.Handlers` defines four types of generic packages, depending on the arguments one expects in the callback and whether the callback returns a value or not. Note that you can not use an arbitrary list of arguments; these depend on the signal, as explained in the previous section. In our example, since the callback does not return any value and does not handle any `User_Data` (that is, we don't pass it extra data, which will be specified at connection time), the appropriate package to use is `Gtk.Handlers.Callback`. We thus instantiate that package. Remember that generic package instantiations in GtkAda must be present in memory at all times, since they take care of freeing allocated memory when finished. GtkAda generic package instantiations must therefore always be performed at the library level, and not inside any inner block:: package Files_Cb is new Handlers.Callback (Gtk_File_Selection_Record); The `Files_Cb` package now provides a set of Connect subprograms that can be used to establish a tie between a widget and a handler. It also provides a set of other subprograms which you can use to emit the signals manually, although most of the time, the signals are simply emitted internally by GtkAda. We will not discuss the `Emit_By_Name` subprograms here. The general form of handler, as used in `Gtk.Handlers`, expects some handlers that take two or three arguments: the widget on which the signal was applied, an array of all the extra arguments sent internally by GtkAda, and possibly some user data given when the connection was made. This is the most general form of handler and it covers all the possible cases. However, it also expects the user to manually extract the needed values from the array of arguments. This is not always the most convenient solution. This is why GtkAda provides a second package related to signals, `Gtk.Marshallers`. The `Gtk.Marshallers` package provides a set of functions that can be used as callbacks directly for GtkAda, and that will call your application's handlers after extracting the required values from the array of arguments. Although this might sound somewhat complicated, in practice it simplifies the task of connecting signals. In fact, the techniques employed are similar to what is done internally by gtk+ in C. Because of the similarity of techniques, there is no overhead involved in using `Gtk.Marshallers` with Ada over the C code in gtk+. A set of functions `To_Marshaller` is found in every generic package in `Gtk.Handlers`. They each take a single argument, the name of the function you want to call, and return a handler that can be used directly in `Connect`. The connection is then done with the following piece of code:: Files_Cb.Object_Connect (Get_Ok_Button (Window), -- The object to connect to the handler "clicked", -- The name of the signal Files_Cb.To_Marshaller (Ok'Access), -- The signal handler Slot_Object => Window); Note that this can be done just after creating the widget, in the same block. As soon as it is created, a widget is ready to accept connections (although no signals will be emitted before the widget is shown on the screen). We use `To_Marshaller` since our handler does not accept the array of arguments as a parameter, and we use the special `Object_Connect` procedure. This means that the parameter to our callback (Files) will be the Slot_Object given in Object_Connect, instead of being the button itself. Compare the above code to the approach described in the first section, in particular when using Ada05 notation:: Window.Get_Ok_Button.On_Clicked (Ok'Access, Window); .. _Handling_user_data: Handling user data ================== As described above, it is possible to define some data that is that passed to the callback when it is called. This data is called user_data, and is passed to the `Connect` or `Object_Connect` subprograms. GtkAda will automatically free any memory it has allocated internally to store this user data. For instance, if you instantiated the generic package `User_Callback` with a String, it means that you want to be able to have a callback of the form:: procedure My_Callback (Widget : access Gtk_Widget_Record'Class; User_Data : String); and connect it with a call similar to:: Connect (Button, "Clicked", To_Marshaller (My_Callback'Access), User_Data => "any string"); GtkAda needs to allocate some memory to store the string (an unconstrained type). However, this memory is automatically freed when the callback is destroyed. There are a few subtleties in the use of user_data, most importantly when the user data is itself a widget. The following four examples do exactly the same thing: each creates two buttons, where clicking on the first one will destroy the second one. They all work fine the first time, while both buttons exist. However, some of them will fail if you press on the first button a second time. Complete, compilable source code for these examples can be found in the distribution's :file:`examples/user_data` directory, from which the code samples below are excerpted. First case: simple user data ---------------------------- This code will fail: even after `Button2` is destroyed, the Ada pointer continues to reference memory that has been deallocated. The second call to `Destroy` will fail with a Storage_Error:: package User_Callback is new Gtk.Handlers.User_Callback (Gtk_Widget_Record, Gtk_Widget); procedure My_Destroy2 (Button : access Gtk_Widget_Record'Class; Data : Gtk_Widget) is begin Destroy (Data); end My_Destroy2; begin User_Callback.Connect (Button1, "clicked", User_Callback.To_Marshaller (My_Destroy2'Access), Gtk_Widget (Button2)); end; Second case: using Object_Connect instead ----------------------------------------- One of the solutions to fix the above problem is to use `Object_Connect` instead of `Connect`. In that case, GtkAda automatically takes care of disconnecting the callback when either of the two widgets is destroyed:: procedure My_Destroy (Button : access Gtk_Widget_Record'Class) is begin Destroy (Button); end My_Destroy; begin Widget_Callback.Object_Connect (Button1, "clicked", Widget_Callback.To_Marshaller (My_Destroy'Access), Button2); end; Third case: manually disconnecting the callback ----------------------------------------------- Using `Object_Connect` is not always possible. In that case, one of the possibilities is to store the `Id` of the callback, and properly disconnect it when appropriate. This is the most complex method, and very often is not applicable, since you cannot know for sure when the callback is no longer needed:: type My_Data3 is record Button, Object : Gtk_Widget; Id : Handler_Id; end record; type My_Data3_Access is access My_Data3; package User_Callback3 is new Gtk.Handlers.User_Callback (Gtk_Widget_Record, My_Data3_Access); procedure My_Destroy3 (Button : access Gtk_Widget_Record'Class; Data : My_Data3_Access) is begin Destroy (Data.Button); Disconnect (Data.Object, Data.Id); end My_Destroy3; Id : Handler_Id; begin Data3 := new My_Data3' (Object => Gtk_Widget (Button1), Button => Gtk_Widget (Button2), Id => (Null_Signal_Id, null)); Id := User_Callback3.Connect (Button1, "clicked", User_Callback3.To_Marshaller (My_Destroy3'Access), Data3); Data3.Id := Id; end; Fourth case: setting a watch on a specific widget ------------------------------------------------- GtkAda provides a function `Add_Watch`, that will automatically disconnect a callback when a given widget is destroyed. This is the function used internally by `Object_Connect`. In the example below, the callback is automatically disconnected whenever `Button2` is destroyed:: procedure My_Destroy2 (Button : access Gtk_Widget_Record'Class; Data : Gtk_Widget) is begin Destroy (Data); end My_Destroy2; Id : Handler_Id; begin Id := User_Callback.Connect (Button1, "clicked", User_Callback.To_Marshaller (My_Destroy2'Access), Gtk_Widget (Button2)); Add_Watch (Id, Button2); end; gtkada-24.0.0/docs/gtkada_ug/system_dependencies.rst000066400000000000000000000033341446021174000224740ustar00rootroot00000000000000.. _System_package_dependencies: *************************** System Package Dependencies *************************** On Linux, GtkAda requires a set of system development packages to be installed. This set depends on the Linux distibution. The following sections provide lists of packages which need to be installed on particular distributions. The installation procedure of GtkAda will fail if some of packages are missing. Red Hat Enterprise Linux 7 & 8 ------------------------------ * glibc-devel * glibc-headers * kernel-headers * libX11-devel * libXau-devel * libXcomposite-devel * libXcursor-devel * libXdamage-devel * libXext-devel * libXfixes-devel * libXi-devel * libXinerama-devel * libXrandr-devel * libXrender-devel * libuuid-devel * libxcb-devel * xorg-x11-proto-devel Ubunbu 18.04 & 20.04 -------------------- * libc6-dev * libdrm-dev * libegl1-mesa-dev * libgl1-mesa-dev * libgles1 * libglvnd-core-dev * libglvnd-dev * libopengl0 * libpthread-stubs0-dev * libwayland-dev * libx11-dev * libx11-xcb-dev * libxau-dev * libxcb-dri2-0-dev * libxcb-dri3-dev * libxcb-glx0-dev * libxcb-present-dev * libxcb-randr0-dev * libxcb-render0-dev * libxcb-shape0-dev * libxcb-shm0-dev * libxcb-sync-dev * libxcb-xfixes0-dev * libxcb1-dev * libxcomposite-dev * libxcursor-dev * libxdamage-dev * libxdmcp-dev * libxext-dev * libxfixes-dev * libxi-dev * libxinerama-dev * libxrandr-dev * libxrender-dev * libxshmfence-dev * libxxf86vm-dev * mesa-common-dev * uuid-dev * x11proto-composite-dev * x11proto-core-dev * x11proto-damage-dev * x11proto-dev * x11proto-fixes-dev * x11proto-input-dev * x11proto-randr-dev * x11proto-xext-dev * x11proto-xf86vidmode-dev * x11proto-xinerama-dev gtkada-24.0.0/docs/gtkada_ug/tasking.rst000066400000000000000000000044731446021174000201070ustar00rootroot00000000000000.. _Tasking_with_GtkAda: ******************* Tasking with GtkAda ******************* Note that Gtk+ under Windows does not interact properly with threads, so the only safe approach under this operating system is to perform all your Gtk+ calls in the same task. On other platforms, the Glib library can be used in a task-safe mode by calling `Gdk.Threads.G_Init` and `Gdk.Threads.Init` before making any other Glib/Gdk calls. Gdk routines may then be called simultaneously by multiple tasks, thanks to task-safe construction of Gdk's internal data structures. However, Gdk objects such as hash tables are not automatically protected, so it is the application's responsibility to prevent simultaneous access to user-defined objects (e.g. by using protected objects). When Gdk is initialized to be task-safe, GtkAda becomes task aware. There is a single global lock that you must acquire with `Gdk.Threads.Enter` before making any Gdk/Gtk call, and which you must release with `Gdk.Threads.Leave` afterwards. `Gtk.Main.Main` should be called with the lock acquired (see example below), ensuring that all the functions executed in the task that started the main loop do not need to protect themselves again. Beware that the GtkAda main loop (`Gtk.Main.Main`) can only be be run inside one specific task. In other words, you cannot call `Gtk.Main.Main` from any task other than the one that started the outer level main loop. Note that `Gdk.Threads` assumes that you are using a tasking run time that maps Ada tasks to native threads. .. highlight:: ada A minimal main program for a tasking GtkAda application looks like:: with Gdk.Threads; with Gtk.Main; with Gtk.Enums; use Gtk.Enums; with Gtk.Window; use Gtk.Window; procedure GtkAda_With_Tasks is Window : Gtk_Window; begin Gdk.Threads.G_Init; Gdk.Threads.Init; Gtk.Main.Init; Gtk_New (Window, Window_Toplevel); Show (Window); Gdk.Threads.Enter; Gtk.Main.Main; Gdk.Threads.Leave; end GtkAda_With_Tasks; Callbacks require a bit of attention. Callbacks from GtkAda (signals) are made within the GtkAda lock. However, callbacks from Glib (timeouts, IO callbacks, and idle functions) are made outside of the GtkAda lock. So, within a signal handler you do not need to call `Gdk.Threads.Enter`, but within the other types of callbacks, you do. gtkada-24.0.0/docs/gtkada_ug/transition.rst000066400000000000000000001004201446021174000206260ustar00rootroot00000000000000.. _Transitioning_from_GtkAda_2_to_GtkAda_3: *************************************** Transitioning from GtkAda 2 to GtkAda 3 *************************************** General ======= GtkAda 3.x is a binding to the C library gtk+ 3.x. This is a major release, with several incompatible changes. Most of those incompatibilities are due to major changes in the C library. Mostly, the gtk+ developers have performed a general cleanup, removing old types and subprograms that were rarely used and belong to more specialized libraries. They have also made significant changes in the internals of the library. A lot of these changes should not impact typical user code, although they will if you are writting your own container widgets. The gtk+ developers have documented various things that will likely need to be changed in user applications. The page at http://developer.gnome.org/gtk3/3.3/gtk-migrating-2-to-3.html provides a migration guide. Its code samples are in C, but should be applicable to Ada quite easily. GtkAda itself has also undergone its own changes. One of the most significants is that most of the binding is now automatically generated from XML files provided by the gtk+ developers. This ensures that the binding is much more complete than it was before, and will be much easier to evolve when new releases of gtk+ are made available. It also means that users can, theoritically at least, automatically bind a number of libraries from the gtk+/GNOME ecosystem. The automatic generation relies on XML files, called GIR files from their ``.gir`` extension. If you wish to parse other files, you should likely modify the toplevel Makefile (the ``generate`` target), as well as the file :file:`contrib/data.py` to list which types should be bound. We do not necessarily encourage you to generate your own bindings, and this generation is likely to be more than just modifying one or two files... Interfaces ---------- One other advantage of the automatic generation is that it allows us to provide more advanced feature in the binding. For instance, gtk+ has the notion of interfaces (which play a similar role to Ada05 interfaces). In GtkAda interfaces no longer require an explicit "with" of the interface package, and a cast to the interface type (with "-" and "+"). Instead, each package now contains the list of subprograms inherited from the various interfaces. So basically, all subprograms inherited from an interface become available as primitive operations in the types that implement the interface. We also expect to simplify the handling of signals and signal handlers. Ada 2012 -------- GtkAda 3 makes use of Ada 2012 and requires GtkAda applications to be compiled in Ada 2012 mode (e.g. using the -gnat2012 switch). This makes it possible to use the object-dotted notation when calling primitive operations. For instance, the following code:: Gtk.Window.Set_Default_Size (Window, 800, 600); can be replaced with:: Window.Set_Default_Size (800, 600); Pango ===== Pango.Font ---------- The type ``Pango_Font_Metrics`` is now declared in its own package ``Pango.Font_Metrics.`` The type ``Pango_Font_Face`` is now declared in its own package ``Pango.Font_Face.`` The type ``Pango_Font_Family`` is now declared in its own package ``Pango.Font_Family.`` The type ``Pango_Language`` is now declared in its own package ``Pango.Language.`` Glib ==== Glib.Object ----------- ``Initialize_Class_Record``'s profile was changed to follow more closely what is done for C applications. The previous implementation prevented applications from implementing interfaces because some internal gtk+ data had to be initialized too early. See ``glib-object.ads`` for an extensive documentation. Glib.G_Icon ----------- This type is now a ``GType_Interface.`` Instead of using ``Null_G_Icon,`` use ``Glib.Types.Null_Interface.`` Gdk === Gdk.Bitmap ---------- This package has been removed: ``Cairo`` packages should be used for drawing, and ``Gdk.Pixbuf`` for representing image data in memory. Gdk.Color --------- ``Alloc`` no longer exists, and is not necessary since all drawing is now done internally using ``Cairo`` which directly manipulates red/green/blue. Gdk.Cursor ---------- The ``Gdk_New`` function working on ``Gdk_Pixmap`` has been removed. Use ``Gdk.Pixbuf.Gdk_New_From_Pixbuf`` to create a cursor from a pixbuf. The ``Gdk_New`` function working on a ``String`` has also been removed. A ``Gdk_Cursor`` is now derived from a ``Glib.Object.`` This has little impact on programs, except that ``Null_Cursor`` can be replaced simply by "null". ``Destroy`` was removed, and should be replaced with ``Unref.`` Gdk.Dnd ------- The functions for handling ``Drag_Contexts`` have been moved to new package ``Gdk.Drag_Contexts.`` The ``Gdk_Drag_Context`` itself now inherits from ``GObject,`` which means that it no longer requires its own ``Ref/Unref`` functions. ``Drag_Find_Window`` has been removed, use ``Drag_Find_Window_For_Screen`` instead. ``Drag_Get_Protocol`` has been replaced with ``Drag_Context_Get_Protocol.`` Gdk.Drawable ------------ All ``Draw_*`` subprograms have been removed: use ``Cairo`` for low-level drawing. The type ``Gdk_Drawable`` no longer exists. Gdk.Event --------- A lot of the getters (and all of the setters) were removed. Instead, the ``Gdk_Event`` type fields can now be edited directly. This is slightly more efficient, and more importantly better documents which fields are valid for which event types. The APIs to ``Get_Message_Type,`` ``Set_Message_Type,`` ``Get_Data,`` and ``Set_Data`` have been removed without replacement. ``Get_Graphics_Expose`` and ``Send_Client_Message`` have been removed with no replacement. ``Deep_Copy`` was removed. It is now possible to simply use ":-" on the record type itself. ``Get`` and ``Peek`` are now functions instead of procedures with a single out parameter. ``Is_Created`` has been removed (you can compare with null) ``Send_Client_Message_To_All`` has been removed (deprecated in gtk+) ``Allocate`` has been removed. ``Instead,`` users should directly use ``Gdk.Event.Gdk_New`` and set the appropriate fields. ``Get_X`` and ``Get_Y`` were replaced by ``Get_Coords.`` ``Get_X_Root`` and ``Get_Y_Root`` were replaced by ``Get_Root_Coords`` ``Get_Button,`` ``Get_State,`` ``Get_Key_Val`` and ``Get_Keycode`` were kept (so you do not have to directly access the field of ``Gdk_Event).`` ``However,`` they no longer raise an exception if you pass them an invalid event type, but return an out-of-range value. Gdk.Font -------- This package has been removed: use ``Pango.Font`` for fonts manipulation, ``Cairo.Font_Face`` and ``Cairo.Font_Options`` for text rendering. Gdk.GC ------ This package has been removed: ``Cairo`` packages should be used for drawing. Gdk.Image --------- This package has been removed: use a ``Gdk.Pixbuf`` instead. Gdk.Main -------- ``Set_Locale`` functions are no longer needed and have been removed. Functions ``Set_Use_Xshm`` and ``Get_Use_Xshm`` have been removed. Gdk.Pixbuf ---------- ``Render_Threshold_Alpha,`` ``Render_To_Drawable,`` ``Render_To_Drawable_Alpha,`` ``Render_Pixmap_And_Mask,`` ``Render_Pixmap_And_Mask_For_Colormap`` have been removed. Use APIs provided by ``Gdk.Cairo`` to draw a pixbuf on a ``Gdk_Drawable.`` ``Get_From_Drawable`` has been removed, use ``Get_From_Surface`` or ``Get_From_Window.`` Gdk.Pixmap ---------- This package has been removed: ``Cairo`` packages should be used for drawing, and ``Gdk.Pixbuf`` for representing image data in memory. Gdk.Region ---------- This package has been removed and replaced with ``Cairo_Region.`` Gdk.RGB ------- This package is deprecated in gtk3. Use ``Pixmaps/Cairo`` for drawing, and use ``Gdk.Pixbuf`` for offscreen image manipulation and rendering to drawables. Instead of ``Gdk.Rgb.Get_Cmap,`` use ``Gtk.Widget.Get_Default_Colormap.`` Gdk.Window ---------- A ``Gdk_Window`` now derives from ``GObject.`` This is mostly transparent for applications, unless you are passing a ``Gdk_Window`` directly to C code, in which case you must use ``Get_Object()`` on it. ``Copy_Area`` and ``Set_Back_Pixmap`` have been removed: use ``Gdk_Drawable`` and ``Gdk.Cairo`` functions instead. ``Clear_Area`` and ``Clear_Area_E`` were removed. Use ``Cairo`` for all drawings. ``Get_Desk_Relative_Origin:`` this function has been removed without a replacement. ``Get_Toplevels`` has been removed, use ``Gtk.Window.List_Toplevels`` instead. ``Set_Hints`` has been removed. Depending on what you are trying to do, use ``Gtk.Window.Resize,`` ``Gtk.Window.Set_Size_Request,`` ``Gtk.Window.Move,`` ``Gtk.Window.Parse_Geometry,`` and ``Gtk.Window.Set_Geometry_Hints.`` ``Window_At_Pointer`` was renamed to ``At_Pointer.`` ``Get_Origin`` is now a procedure, because the return value had no meaning anyway. ``Get_Geometry:`` no longer returns the color depth of the window, which is no longer relevant to gtk+. The first parameter of the various methods was renamed "``Self"`` instead of "window" to avoid a number of cases where we would end up with duplicate parameter names. Gdk.Window_Attr --------------- Parameter "``Colormap"`` has been removed from procedure ``Gdk_New.`` This parameter is no longer needed. ``Set_Colormap`` and ``Get_Colormap`` should no longer be needed and have been removed as well. Gtk === .. highlight:: ada Gtk.Action ---------- ``Block_Activate_From,`` ``Unblock_Activate_From,`` ``Connect_Proxy,`` ``Disconnect_Proxy:`` these obsolete subprograms have been removed without a replacement. ``Get_Action`` has been removed without a replacement. ``Convert`` has been removed, use ``Glib.Object.Get_User_Data`` instead. Gtk.Aspect_Frame ---------------- ``Direct`` accessors ``Get_Xalign,`` ``Get_Yalign`` and ``Get_Ratio`` have been removed: use the corresponding properties instead. Gtk.Assistant ------------- The values in ``Gtk_Assistant_Page_Type`` were renamed for consistency, removing their ``Gtk_`` prefix. The package ``Generic_Assistant_Functions`` has been renamed to ``Set_Forward_Page_Func_User_Data.`` Gtk.Builder ----------- ``Add_From_File`` now returns a ``Guint`` and the error as a parameter. ``Get_Widget`` has been removed (use ``Get_Object`` instead, and cast to the appropriate type) Gtk.Button_Box -------------- ``Set_Child_Size`` was removed. Equivalent behavior can only be done by changing the theme properties child-min-width and child-min-height. Gtk.Cell_Layout --------------- ``Get_Cell_Renderers`` has been renamed to ``Get_Cells.`` Gtk.Cell_Renderer ----------------- The ``Render`` subprogram is now called with a ``Cairo_Context`` rather than a ``Gdk_Window.`` Gtk.Cell_View ------------- ``Get_Cell_Renderers`` is obsolete, use the ``Gtk.Cell_Layout`` interface and ``Gtk.Cell_Layout.Get_Cells.`` Gtk.Clist --------- This widget has been removed: use a ``Gtk.Tree_View`` instead. Gtk.Container ------------- Procedure ``Propagate_Expose`` has been removed and will be replaced with ``Propagate_Draw.`` ``Class_Find_Child_Property,`` ``Class_list_Child_Properties`` and ``Class_Install_Child_Property`` are no longer bound. ``Children`` was removed (use ``Get_Children`` instead). Gtk.Color_Button ---------------- The function ``Get_Color`` returning ``Gdk.Color.Gdk_Color`` is now a procedure with an out parameter. Gtk.Color_Selection ------------------- ``Get_Color`` and ``Set_Color`` have been removed: use ``Get_Current_Color`` and ``Set_Current_Color`` instead. Gtk.Color_Selection_Dialog -------------------------- Subprogram ``Get_Colorsel`` has been renamed ``Get_Color_Selection,`` to match the ``Gtk+`` naming. ``Get_OK_Button,`` ``Get_Cancel_Button,`` ``Get_Help_Button`` have been removed. Instead, use:: Gtk_Button (Glib.Properties.Get_Property (Dialog, Ok_Button_Property)), Gtk_Button (Glib.Properties.Get_Property (Dialog, Cancel_Button_Property)), Gtk_Button (Glib.Properties.Get_Property (Dialog, Help_Button_Property)) Gtk.Combo --------- This widget has been removed: use a ``Gtk.Combo_Box`` instead. Gtk.Combo_Box ------------- The "text only" variant has been moved to the new package ``Gtk.Combo_Box_Text.`` Gtk.Combo_Box_Entry ------------------- This widget has been removed: use a ``Gtk.Combo_Box`` instead. Gtk.Clipboard ------------- The base type is now a ``GObject_Record`` instead of an opaque type: use the ``GObject`` facilities for lifecycle management. There are now separate "``User_Data"`` generic version for callback-based methods. Gtk.Ctree --------- This widget has been removed: use a ``Gtk.Tree_View`` instead. Gtk.Curve --------- This widget has been removed, with no direct replacement. Use drawing functionality from ``Cairo`` instead. Gtk.Dialog ---------- Subprogram ``Get_Vbox`` was replaced with ``Get_Content_Area.`` Subprogram ``Set_Has_Separator`` has been removed: use the corresponding flag in the call to ``Gtk_New/Initialize`` instead. Gtk.Dnd ------- ``Source_Set_Icon`` has been removed: use ``Source_Set_Icon_Pixbuf`` instead. ``Set_Icon_Pixmap`` has been removed: use ``Set_Icon_Pixbuf`` instead. Obsolete ``Set_Default_Icon`` working on ``Gdk.Pixmap`` has been removed without a replacement. Gtk.Editable ------------ The type representing a ``Gtk_Editable_Record`` has been changed from a ``Widget`` (which is a ``GObject)`` to an interface (a ``System.Address).`` Therefore the ``Gtk_Editable_Record`` type has been eliminated. User code referencing only the ``Gtk_Editable`` type should function unchanged. Code using the tag as a test before converting a widget to a ``Gtk.Editable`` can now work using the ``Implements_Editable`` package. For instance, if ``Widget`` is a ``GObject_Record,`` the following code:: if Widget.all in Gtk_Editable_Record'Class then Cut_Clipboard (Gtk_Editable (Widget)); becomes:: if Is_A (Widget.Get_Type, Gtk.Editable.Get_Type) then Cut_Clipboard`` (+Widget); where the function "+" is defined by instantiating ``Implements_Editable``:: package Implements_Editable is new Glib.Types.Implements (Gtk.Editable.Gtk_Editable, GObject_Record, GObject); function "+" (Widget : access GObject_Record'Class) return Gtk.Editable.Gtk_Editable renames Implements_Editable.To_Interface; The ``Select_Region`` subprogram parameter name ``The_End`` has been normalized to ``End_Pos``. Gtk.Entry_Completion -------------------- The "match-selected" and "cursor-on-match" signals were erroneously given the internal filter model instead of the users model. This oversight has been fixed in GTK+ 3; if you have handlers for these signals, they will likely need slight adjustments. Gtk.Enums --------- The following types were removed:: ``GtkAnchorType`` ``GtkCurveType`` ``GtkMetricType`` ``GtkGridLines`` ``GtkUpdateType`` ``GtkVisibility`` ``GtkSideType`` ``GtkMatchType`` ``GtkPreviewType`` ``GtkSubmenuDirection`` ``GtkSubmenuPlacement`` ``GtkTreeViewMode`` ``Gtk_Icon_Size`` is no longer an enumeration type, but an integer, so that new sizes can be defined through ``Gtk.Icon_Factory.Icon_Size_Register``. Gtk.File_Chooser_Button ----------------------- Subprograms ``Gtk_New_With_Backend`` and ``Initialize_With_Backend`` have been removed: use ``Gtk_New`` and ``Initialize`` instead. Gtk.File_Chooser_Dialog ----------------------- Subprograms ``Gtk_New_With_Backend`` and ``Initialize_With_Backend`` have been removed: use ``Gtk_New`` and ``Initialize`` instead. Gtk.File_Chooser_Widget ----------------------- Subprograms ``Gtk_New_With_Backend`` and ``Initialize_With_Backend`` have been removed: use ``Gtk_New`` and ``Initialize`` instead. Gtk.File_Selection ------------------ This package has been replaced by ``Gtk.File_Chooser.`` You may also use ``Gtkada.File_Selection`` for a simple interface to the ``Gtk.File_Chooser.`` Gtk.Fixed --------- Subprograms ``Set_Has_Windows`` and ``Get_Has_Windows`` are now in ``Gtk.Widget.`` Gtk.Gamma_Curve --------------- This widget has been removed without any replacement. Gtk.GC ------ This package has been removed: ``Cairo`` packages should be used for drawing. Gtk.GEntry ---------- The names for ``Gtk_Entry_Record`` parameters have been normalized across the board to "``The_Entry".`` ``Append_Text`` has been removed: use ``Set_Text`` and ``Get_Text`` instead. Gtk.GRange ---------- ``Set_Update_Policy`` has been removed, with no replacement. If you require delayed updates, you will need to code it yourself. Gtk.Handle_Box -------------- This package is now marked as deprecated in C, and is likely to be removed in future versions of gtk+, so we encourage you to stop using it as well. Gtk.HRuler ---------- This widget has been removed without any replacement. Gtk.Icon_Factory ---------------- ``Gtk_Icon_Set`` and ``Gtk_Icon_Source`` have been moved to their own packages. ``Functions`` ``Gtk_New`` are now procedures. Gtk.Image --------- The subprograms working with ``Gdk_Pixmap`` have been removed, use the variants working on ``Gdk_Pixbuf`` instead. Gtk.Image_Menu_Item ------------------- All controlling parameters were renamed to ``Self``. There was no consistency before. ``Gtk_New_From_Stock`` now requires an ``Accel_Group`` parameter, which can be set to null. Gtk.Input_Dialog ---------------- This package is no longer part of gtk+, so this binding has been removed without replacement. Gtk.Item -------- This obsolete package has been removed with no replacement. Gtk.Item_Factory ---------------- This obsolete package has been removed in favor of ``Gtk.UI_Manager.`` Gtk.Layout ---------- ``Get_Width`` and ``Get_Height`` have been removed, use ``Get_Size`` instead. Gtk.Link_Button --------------- All widget parameter names have been normalized to "``Self".`` The ``Set_Uri_Hook`` function has been eliminated, and along with it the ``Uri_Func`` type and the ``Generic_Uri_Hook`` package. ``Register`` a callback for the button's "clicked" signal instead. Gtk.List_Item ------------- This widget has been removed: use a ``Gtk.Tree_View`` instead. Gtk.Main -------- ``Do_Event`` was renamed ``Main_Do_Event.`` ``Grab_Add`` and ``Grab_Removed`` are available in ``Gtk.Widget`` (as was already the case with gtk2). The ``Quit`` package has been removed without replacement. The ``Idle`` and ``Timeout`` handling been removed: use equivalent functions in package ``Glib.Main`` instead. Gtk.Menu -------- ``User_Menu_Popup`` has been replaced by ``Popup_User_Data.`` The version of ``Popup`` was took an access to ``C_Gtk_Menu_Positon_Func`` has been removed. If you need to pass ``User_Data`` to the callback, you need to instantiate the package ``Popup_User_Data.`` Note that in this package the position of the ``Data`` parameter has changed. Gtk.Menu_Item ------------- For subprogram ``Set_Right_Justified,`` the parameter "``Justify"`` has been renamed to "``Right_Justified".`` The obsolete procedures ``Remove_Submenu,`` ``Set_Right_Justify,`` and ``Right_Justify`` have been removed. Instead, use ``Set_Submenu``, ``Set_Right_Justified,`` or ``Set_Right_Justified`` with ``Justify-True,`` respectively. Calling ``Gtk_New`` with one ``Menu_Item`` argument has the same effect now as before. However, from this version on, if a ``Label`` argument exists (even if set to ""), a ``Gtk_Label`` child will be created with the given value. Gtk.Menu_Tool_Button -------------------- ``Set_Arrow_Tooltip`` has been removed, use ``Set_Arrow_Tooltip_Markup`` or ``Set_Arrow_Tooltip_Text`` instead. Gtk.Notebook ------------ ``Get_Children`` has been removed: call ``Gtk.Container.Get_Children`` instead. ``Set_Tab_Label_Packing`` has been removed (this is left under control of the theme). ``Set_Page`` has been removed, use ``Set_Current_Page`` instead. ``Insert_Page`` now returns the number of the page that has been inserted. Gtk.List -------- This package has been removed: use a ``Gtk_Tree_View`` instead. Gtk.Object ---------- ``Gtk.Object`` has been removed in gtk+-3. The following subprograms and declarations are now in ``Gtk.Widget``:: ``Flags`` ``Unset_Flags`` ``Floating`` ``In_Destruction_Is_Set`` ``Signal_Destroy`` The subprogram ``Gtk.Object.Sink`` has been removed: use ``Glib.Object.Ref_Sink`` instead. Gtk.Old_Editable ---------------- This obsolescent API has been removed, use ``Gtk.Editable`` where relevant. Gtk.Option_Menu --------------- ``Gtk.Option_Menu`` has been removed. Using ``Gtk.Combo_Box`` instead is recommended. Gtk.Pixmap ---------- This widget has been removed and is generally replaced with a ``Gtk.Image.`` Gtk.Preview ----------- This widget has been removed without replacement. Gtk.Print_Operation ------------------- ``Get_Status`` was renames to ``Get_Status_String`` when it returns a string, to match the gtk+ API. Gtk.Progress ------------ This widget has been removed without any replacement. Gtk.Progress_Bar ---------------- This widget is now derived from ``Gtk.Widget`` directly, rather than from ``Gtk.Progress`` (which has been removed). The enumeration type ``Gtk_Progress_Bar_Orientation`` has been removed, and this widget now implements the ``Gtk_Orientable`` interface. To fully achieve the same functionality as the GtkAda 2.x ``Get_Orientation/`` ``Set_Orientation`` subprograms, it is now necessary to call ``Get_Orientation/Set_Orientation`` along with ``Get_Inverted/Set_Inverted.`` Procedure ``Set_Pulse_Step's`` "``Step"`` parameter has been renamed to "``Formal."`` ``Set_Ellipsize`` and ``Get_Ellipsize`` parameter names have been normalized from "``Pbar"`` to "``Progress_Bar".`` If you intend to show text over the progress bar, you need to call ``Set_Text`` as before, but also call ``Set_Show_Text(True)``. Gtk.Rc ------ This package is now mostly obsolete. The gtk+ library no longer supports the :file:`*.rc` files, since it uses CSS-like files instead. Gtk.Recent_Manager ------------------ The type ``Gtk_Recent_Info`` is now bound in its own package. Gtk.Ruler --------- This widget has been removed without any replacement. Gtk.Settings ------------ ``Properties`` are now named with the suffix "_Property". For instance, ``Gtk_Theme_Name`` is now ``Gtk_Theme_Name_Property.`` Gtk.Scale_Button ---------------- This package now conforms to the API conventions practiced throughout the rest of the toolkit. ``Gtk_New`` is implemented as a procedure rather than as a function, and the use of ``GNAT.Strings.String_List`` replaces ``Gtkada.Types.Chars_Ptr_Array`` throughout. Gtk.Selection ------------- This package has been renamed ``Gtk.Selection_Data,`` for homogeneity with the naming conventions. ``Gtk.Selection.Selection_Data`` is now called ``Gtk.Selection_Data.Gtk_Selection_Data.`` Handling of ``Target_Lists`` has been moved to the new package ``Gtk.Target_List,`` along with ``Target_Entry_Array.`` The type ``Gtk_Target_Entry`` has been moved to the new package ``Gtk.Target_Entry.`` The way of obtaining the selection data from callbacks using the ``Args/GValues`` approach has changed, from:: Data : constant Gtk.Selection.Selection_Data :- Gtk.Selection.Selection_Data (Get_Proxy (Nth (Args, 2))); to:: Data : constant Gtk.Selection_Data.Gtk_Selection_Data :- From_Object (Get_Address (Nth (Args, 2))); The type ``Target_Flags`` has been moved to ``Gtk.Enums.Gtk_Target_Flags.`` The flag corresponding to ``Target_No_Constraint`` has been removed: use the value 0 instead. Gtk.Scrolled_Window ------------------- ``Set_Policy's`` parameters were renamed to ``Hscrollbar_Policy`` and ``Vscrollbar_Policy`` instead of ``H_Scrollbar_Policy`` and ``V_Scrollbar_Policy.`` Gtk.Socket / Gtk.Plug --------------------- The binding for these two packages was removed. They are not portable across platforms, and require access to the low-level X11 window ID, for which we do not provide a binding. Gtk.Status_Icon --------------- ``Status_Icon`` widget parameter names have been normalized to "``Status_Icon".`` ``Get_Blinking`` and ``Set_Blinking`` have been removed, it is no longer possible to make the status icon blink. Gtk.Style --------- All functions based on ``Gdk.GC`` or ``Gdk.Pixmap`` have been removed. This package is deprecated (but not removed yet) in gtk3 Use functions in ``Gtk.Style_Context`` instead. A number of drawing functions have been removed: use the ``Paint_*`` functions instead. ``Replace`` a call to ``Get_Font`` with:: with Gtk.Style_Context; use Gtk.Style_Context; Get_Style_Context (Widget).Get_Font (Gtk_State_Flags_Normal); Gtk.Text -------- This obsolescent API has been removed: use a ``Gtk.Text_View/Gtk.Text_Buffer`` instead. Gtk.Text_Attributes ------------------- ``Set_Fg_Stipple,`` ``Get_Fg_Stipple,`` ``Set_Bg_Stipple,`` ``Get_Bg_Stipple`` have been removed without a replacement. Gtk.Text_View ------------- The functions ``Get/Set_Disable_Scroll_On_Focus`` have no effect in recent versions of gtk+ and have been removed. Gtk.Tree_Dnd ------------ This package was removed, and its contents split into ``Gtk.Tree_Drag_Source`` and ``Gtk.Tree_Drag_Source.`` The ```Drag_Dest_``` and ```Drag_Source_``` prefixes were removed from the subprogram, so for instance ``Drag_Dest_Drag_Data_Received`` has become ``Drag_Data_Received.`` Gtk.Tree_Model -------------- A ``Gtk_Tree_Model`` is now an interface (implemented by ``Gtk_List_Store`` and ``Gtk_Tree_Store),`` no longer a tagged type. It means that in callbacks that receive a ``Gtk_Tree_Model`` parameter, you can no longer cast this parameter to a ``Gtk_Tree_Store`` for instance. ``Instead,`` you need to do the following:: -- Model is the parameter, of type Gtk_Tree_Model Tree : constant Gtk_Tree_Store :- Gtk_Tree_Store (-Model); ``Gtk_New,`` for a ``Gtk_Tree_Path,`` are now procedures instead of functions, to follow the usual GtkAda convention. ``Gtk_Tree_Row_Reference`` has been moved to its own package ``Gtk.Tree_Row_Reference.`` ``Gtk_New`` and ``Gtk_New_First`` (for a tree path) now take a "out" parameter, for consistency with the rest of the API. Gtk.Tree_View_Column -------------------- ``Get_Cell_Renderers`` is obsolete, use the ``Gtk.Cell_Layout`` interface and ``Gtk.Cell_Layout.Get_Cells.`` Gtk.Tips_Query -------------- This obsolete package has been removed. Gtk.Tool_Item ------------- ``Set_Tooltip`` has been removed: use ``Set_Tooltip_Text`` and ``Set_Tooltip_Markup`` instead. Gtk.Toolbar ----------- All ``Gtk_Toolbar`` widget parameter names have been normalized to "``Toolbar".`` ``Subprograms`` ``Append_*,`` ``Prepend_*`` and ``Insert_*`` have been removed: use ``Insert`` instead. ``Subprograms`` ``Get_Tooltips/Set_Tooltips`` have been removed. Use the ``Gtk_Enable_Tooltips`` property instead. Gtk.Tooltips ------------ The package ``Gtk.Tooltips`` has been removed, in favor of ``Gtk.Tooltip.`` For creating simple tooltips on all GtkAda widgets, the easiest is to use ``Gtk.Widget.Set_Tooltip_Text`` or ``Gtk.Set_Tooltip_Markup.`` See the example in testgtk/create_tooltip.adb. Gtk.Tree_View ------------- ``Procedure`` ``Create_Row_Drag_Icon`` now returns a ``Cairo_Surface.`` ``Get_Hadjustment,`` ``Set_Hadjustment,`` ``Get_Vadjustment,`` ``Set_Vadjustment`` have been removed: use the equivalent properties. ``Widget_To_Tree_Coords`` and ``Tree_To_Widget_Coords`` have been removed: use ``Convert_Widget_To_Tree_Coords`` and ``Convert_Tree_To_Widget_Coords.`` Gtk.VRuler ---------- This widget has been removed without any replacement. Gtk.Widget ---------- The old ``Draw`` function no longer exists, and should be replaced with calls to ``Queue_Draw_Area.`` ``However,`` a new ``Draw`` function was added with a different profile and different semantic. Function```Get_Snapshot`` has been removed. ``Draw`` should be used instead. ``Hide_All`` has been removed: use ``Hide`` instead. ``Set_Extension_Events`` and ``End_Extension_Events`` are no longer needed and have been removed. ``Set_Colormap`` and ``Get_Colormap`` are no longer needed and have been removed. ``Set_Scroll_Adjustments`` has been removed without a replacement. ``Shape_Combine_Mask,`` ``Input_Shape_Combine_Mask`` and ``Reset_Shapes`` have been removed without replacements. ``Set_Uposition`` has been removed: use the properties of the containing widget to fix the position of contained widgets. The functions in ``Gtk.Window,`` for instance ``Gtk.Window.Move,`` should be used for top-level widgets. ``Set_USize`` has been removed: use ``Set_Size_Request`` instead. ``Size_Request`` is now obsolescent. The recommend replacement is to use ``Get_Preferred_Width`` and ``Get_Preferred_Height.`` ``Set_Default_Colormap,`` ``Get_Default_Colormap,`` ``Push_Colormap`` and ``Pop_Colormap`` were removed. They are no longer needed, since all drawing is done through ``Cairo`` which doesn't use a colormap but directly the red/green/blue components. ``Queue_Clear`` and ``Queue_Clear_Area`` have been removed, call ``Queue_Draw`` and ``Queue_Draw_Area`` instead. The signal "expose_event" no longer exists. It has been replaced with the "draw" signal which provides a preconfigured ``Cairo_Context`` suitable for the drawing (including the clip area that is used to speed up the rendering). ``Activate`` is now a function. ``Child_Focus:`` removed default value for ``Direction`` parameter (was ``Dir_Tab_Forward)`` ``Get_Allocation_Height`` and ``Get_Allocation_Width`` are now named ``Get_Allocated_Height`` and ``Get_Allocated_Width.`` ``Get_Allocation_X`` and ``Get_Allocation_Y`` were removed, and can be accessed through ``Get_Allocation.X`` and ``Get_Allocation.Y`` instead. A lot of flags (``Can_Focus,`` ``Can_Default,...)`` now have explicit setters and getters. This removed a number of subprograms, like:: ``Double_Buffered_Is_Set`` (see ``Get_Double_Buffered)`` ``Can_Focus_Is_Set`` (see ``Get_Can_Focus)`` ``Mapped_Is_Set`` (see ``Get_Mapped)`` ``Realized_Is_Set`` (see ``Get_Realized)`` ``Has_Default_Is_Set`` (see ``Has_Default)`` ``Has_Focus_Is_Set`` (see ``Has_Focus)`` ``Has_Grab_Is_Set`` (see ``Has_Grab)`` ``Rc_Style_Is_Set`` (see ``Has_Rc_Style)`` ``In_Destruction_Is_Set`` (see ``In_Destruction)`` ``Drawable_Is_Set`` (see ``Is_Drawable)`` ``No_Window_Is_Set`` (see ``Has_Window)`` ``Size_Allocate`` now takes an "in out" parameter for the allocation ``Set_Flags`` was renamed ``Set_State_Flags`` ``Unset_Flags`` was renamed ``Unset_State_Flags`` ``Flags`` and ``Flag_Is_Set`` must be replaced with a call to ``Get_State_Flags`` ``Get_Child_Requisition`` is now a procedure with an in out parameter. It is obsolescent. ``Default_Motion_Notify_Event`` was removed. ``Has_Default_Motion_Notify_Handler`` was removed. ``Get_Default_Visual`` was removed. ``Restore_Default_Style`` was removed (use ``Set_Style`` with a null parameter instead). ``Class_Find_Style_Property,`` ``Class_List_Style_Properties`` and ``Class_Install_Style_Property`` were removed. ``They`` are mostly of interest when writting theme engines. ``Class_Path`` and ``Path`` were replaced with ``Get_Path.`` ``Allow_Shrink_Property`` and ``Allow_Grow_Property`` have been removed: use ``Get_Hexpand`` and ``Get_Vexpand`` instead. ``Render_Icon`` has been replaced by ``Render_Icon_Pixbuf.`` Gtk.Window ---------- ``Set_Has_Frame,`` ``Get_Has_Frame,`` ``Set_Frame_Dimensions,`` ``Get_Frame_Dimensions:`` these special-purpose subprograms have been removed without replacement. ``Get_Gravity,`` ``Set_Gravity:`` these have been removed, use the property ``Gravity_Property`` instead. ``Resize`` no longer accepts parameters set to -1 to indicate the preferred size of the window. This was a GtkAda extension, which can be achieved using ``Get_Preferred_Size`` and passing the result to ``Size.`` ``Group_Add_Window`` was renamed to ``Add_Window.`` ``Group_Remove_Window`` was renamed to ``Remove_Window.`` ``Group_List_Windows`` was renames to ``List_Windows.`` ``Initialize`` now has the same default value for its ``The_Type`` parameter as ``Gtk_New.`` GtkAda ====== Gtkada.MDI ---------- ``Set_Dnd_Message`` no longer has a special handling for "#", which was used to indicate whether the window would be preserved or hidden when changing perspectives. Instead, a different color is used to highlight the target area (and this highlighting is now done using transparency). Gtkada.Properties ----------------- This package has been removed. It used to provide a dialog allowing you to view and edit the properties of widgets in your application, live. This is now provided directly by third parties through the GtkParasite tool. See http://code.google.com/p/gtkparasite/ Gnome ===== Gnome.App_Bar ------------- Subprogram ``Appbar_Get_Progress`` has been removed without replacement. Gnome.Gentry ------------ This package has been removed without replacement. gtkada-24.0.0/docs/texi2html000077500000000000000000002161651446021174000156400ustar00rootroot00000000000000#!/usr/bin/perl 'di '; 'ig 00 '; #+############################################################################## # # # File: texi2html # # # # Description: Program to transform most Texinfo documents to HTML # # # #-############################################################################## # From @(#)texi2html 1.52 01/05/98 Written (mainly) by Lionel Cons, Lionel.Cons@cern.ch # $Id$ # This version of texi2html is currently maintained at # ftp://ftp.cs.umb.edu/pub/tex/texi2html by kb@cs.umb.edu. # The man page for this program is included at the end of this file and can be # viewed using the command 'nroff -man texi2html'. # Please read the copyright at the end of the man page. #+++############################################################################ # # # Constants # # # #---############################################################################ $DEBUG_TOC = 1; $DEBUG_INDEX = 2; $DEBUG_BIB = 4; $DEBUG_GLOSS = 8; $DEBUG_DEF = 16; $DEBUG_HTML = 32; $DEBUG_USER = 64; $DEBUG_L2H = 128; $BIBRE = '\[[\w\/-]+\]'; # RE for a bibliography reference $FILERE = '[\/\w.+-]+'; # RE for a file name $VARRE = '[^\s\{\}]+'; # RE for a variable name $NODERE = '[^@{}:\'`",]+'; # RE for a node name $NODESRE = '[^@{}:\'`"]+'; # RE for a list of node names $XREFRE = '[^@{}]+'; # RE for a xref (should use NODERE) $ERROR = "***"; # prefix for errors and warnings $THISVERSION = "1.56k"; $THISPROG = "texi2html $THISVERSION"; # program name and version $HOMEPAGE = "http://wwwinfo.cern.ch/dis/texi2html/"; # program home page $TODAY = &pretty_date; # like "20 September 1993" $SPLITTAG = "\n"; # tag to know where to split $PROTECTTAG = "_ThisIsProtected_"; # tag to recognize protected sections $html2_doctype = ''; ($USER = (getpwuid ($<))[6]) =~ s/,.*//; # Who am i # # language dependent constants # #$LDC_SEE = 'see'; #$LDC_SECTION = 'section'; #$LDC_IN = 'in'; #$LDC_TOC = 'Table of Contents'; #$LDC_GOTO = 'Go to the'; #$LDC_FOOT = 'Footnotes'; # TODO: @def* shortcuts # # pre-defined indices # %predefined_index = ( 'cp', 'c', 'fn', 'f', 'vr', 'v', 'ky', 'k', 'pg', 'p', 'tp', 't', ); # # valid indices # %valid_index = ( 'c', 1, 'f', 1, 'v', 1, 'k', 1, 'p', 1, 't', 1, ); # # texinfo section names to level # %sec2level = ( 'top', 0, 'chapter', 1, 'unnumbered', 1, 'majorheading', 1, 'chapheading', 1, 'appendix', 1, 'section', 2, 'unnumberedsec', 2, 'heading', 2, 'appendixsec', 2, 'appendixsection', 2, 'subsection', 3, 'unnumberedsubsec', 3, 'subheading', 3, 'appendixsubsec', 3, 'subsubsection', 4, 'unnumberedsubsubsec', 4, 'subsubheading', 4, 'appendixsubsubsec', 4, ); # # accent map, TeX command to ISO name # %accent_map = ( '"', 'uml', '~', 'tilde', '^', 'circ', '`', 'grave', '\'', 'acute', ); # # texinfo "simple things" (@foo) to HTML ones # %simple_map = ( # cf. makeinfo.c "*", "
    ", # HTML+ " ", " ", "\t", " ", "-", "­", # soft hyphen "\n", "\n", "|", "", 'tab', '<\/TD>', # spacing commands ":", "", "!", "!", "?", "?", ".", ".", "-", "", ); # # texinfo "things" (@foo{}) to HTML ones # %things_map = ( 'TeX', 'TeX', 'br', '

    ', # paragraph break 'bullet', '*', 'copyright', '(C)', 'dots', '...', 'equiv', '==', 'error', 'error-->', 'expansion', '==>', 'minus', '-', 'point', '-!-', 'print', '-|', 'result', '=>', 'today', $TODAY, ); # # texinfo styles (@foo{bar}) to HTML ones # %style_map = ( 'asis', '', 'b', 'B', 'cite', 'CITE', 'code', 'CODE', 'ctrl', '&do_ctrl', # special case 'dfn', 'EM', # DFN tag is illegal in the standard 'dmn', '', # useless 'email', '&do_email', # insert a clickable email address 'emph', 'EM', 'file', '"TT', # will put quotes, cf. &apply_style 'i', 'I', 'kbd', 'KBD', 'key', 'KBD', 'math', '&do_math', 'r', '', # unsupported 'samp', '"SAMP', # will put quotes, cf. &apply_style 'sc', '&do_sc', # special case 'strong', 'STRONG', 't', 'TT', 'titlefont', '', # useless 'uref', '&do_uref', # insert a clickable URL 'url', '&do_url', # insert a clickable URL 'var', 'VAR', 'w', '', # unsupported ); # # texinfo format (@foo/@end foo) to HTML ones # %format_map = ( 'display', 'PRE', 'example', 'PRE', 'format', 'PRE', 'lisp', 'PRE', 'quotation', 'BLOCKQUOTE', 'smallexample', 'PRE', 'smalllisp', 'PRE', # lists 'itemize', 'UL', 'enumerate', 'OL', # poorly supported 'flushleft', 'PRE', 'flushright', 'PRE', ); # # texinfo definition shortcuts to real ones # %def_map = ( # basic commands 'deffn', 0, 'defvr', 0, 'deftypefn', 0, 'deftypevr', 0, 'defcv', 0, 'defop', 0, 'deftp', 0, # basic x commands 'deffnx', 0, 'defvrx', 0, 'deftypefnx', 0, 'deftypevrx', 0, 'defcvx', 0, 'defopx', 0, 'deftpx', 0, # shortcuts 'defun', 'deffn Function', 'defmac', 'deffn Macro', 'defspec', 'deffn {Special Form}', 'defvar', 'defvr Variable', 'defopt', 'defvr {User Option}', 'deftypefun', 'deftypefn Function', 'deftypevar', 'deftypevr Variable', 'defivar', 'defcv {Instance Variable}', 'defmethod', 'defop Method', # x shortcuts 'defunx', 'deffnx Function', 'defmacx', 'deffnx Macro', 'defspecx', 'deffnx {Special Form}', 'defvarx', 'defvrx Variable', 'defoptx', 'defvrx {User Option}', 'deftypefunx', 'deftypefnx Function', 'deftypevarx', 'deftypevrx Variable', 'defivarx', 'defcvx {Instance Variable}', 'defmethodx', 'defopx Method', ); # # things to skip # %to_skip = ( # comments 'c', 1, 'comment', 1, 'ifnothtml', 1, 'ifnottex', 1, # useless 'detailmenu', 1, 'direntry', 1, 'contents', 1, 'shortcontents', 1, 'summarycontents', 1, 'footnotestyle', 1, 'end ifclear', 1, 'end ifset', 1, 'titlepage', 1, 'end titlepage', 1, # unsupported commands (formatting) 'afourpaper', 1, 'cropmarks', 1, 'finalout', 1, 'headings', 1, 'sp', 1, 'need', 1, 'page', 1, 'setchapternewpage', 1, 'everyheading', 1, 'everyfooting', 1, 'evenheading', 1, 'evenfooting', 1, 'oddheading', 1, 'oddfooting', 1, 'smallbook', 1, 'vskip', 1, 'filbreak', 1, 'paragraphindent', 1, # unsupported formats 'cartouche', 1, 'end cartouche', 1, 'group', 1, 'end group', 1, ); #+++############################################################################ # # # Argument parsing, initialisation # # # #---############################################################################ %value = (); # hold texinfo variables, see also -D $use_bibliography = 1; $use_acc = 0; $debug = 0; $doctype = ''; $check = 0; $expandinfo = 0; $use_glossary = 0; $INVISIBLE_MARK = ''; $use_iso = 0; @include_dirs = (); $show_menu = 0; $number_sections = 0; $split_node = 0; $split_chapter = 0; $monolithic = 0; $verbose = 0; $usage = < tag -expandinfo : use \@ifinfo sections, not \@iftex -glossary : handle a glossary -invisible name : use 'name' as an invisible anchor -Dname : define name like with \@set -I dir : search also for files in 'dir' -menu : handle menus -monolithic : output only one file including ToC -number : number sections -split_chapter : split on main sections -split_node : split on nodes -l2h : use latex2html for \@math, \@tex, and \@sc -l2h_latex2html prog: use 'prog' as latex2html program (default: 'latex2html') -l2h_tmp dir : use 'dir' as temp dir for latex2html -l2h_keep : keep temporary files generated by l2h extension -l2h_skip : skip latex2html run (needs temporary files) -init_file 'file' : use 'file' for texi2html and latex2html initialization -usage : print usage instructions -verbose : verbose output To check converted files: $0 -check [-verbose] files EOT while (@ARGV && $ARGV[0] =~ /^-/) { $_ = shift(@ARGV); if (/^-acc$/) { $use_acc = 1; next; } if (/^-body$/) { $T2H_BODYTEXT = shift (@ARGV); next; } if (/^-d(ebug)?(\d+)?$/) { $debug = $2 || shift(@ARGV); next; } if (/^-doctype$/) { $doctype = shift(@ARGV); next; } if (/^-c(heck)?$/) { $check = 1; next; } if (/^-e(xpandinfo)?$/) { $expandinfo = 1; next; } if (/^-g(lossary)?$/) { $use_glossary = 1; next; } if (/^-i(nvisible)?$/) { $INVISIBLE_MARK = shift(@ARGV); next; } if (/^-iso$/) { $use_iso = 1; next; } if (/^-D(.+)?$/) { $value{$1 || shift(@ARGV)} = 1; next; } if (/^-I(.+)?$/) { push(@include_dirs, $1 || shift(@ARGV)); next; } if (/^-m(enu)?$/) { $show_menu = 1; next; } if (/^-mono(lithic)?$/) { $monolithic = 1; next; } if (/^-n(umber)?$/) { $number_sections = 1; next; } if (/^-s(plit)?_?(n(ode)?|c(hapter)?)?$/) { if ($2 =~ /^n/) { $split_node = 1; } else { $split_chapter = 1; } next; } if (/^-v(erbose)?$/) { $verbose = 1; next; } if (/^-init_file$/) { $init_file = shift(@ARGV); if (-f $init_file) { print "# reading initialization file from $init_file\n" if ($verbose); require($init_file); } else { print "$ERROR Error: can't read init file $int_file\n"; $init_file = ''; } next; } # l2h stuff if (/^-l2h$/) { $l2h = 1; next; } if (/^-l2h_latex2html$/) { $l2h_latex2html = shift(@ARGV); next; } if (/^-l2h_skip$/) { $l2h_skip = 1; next; } if (/^-l2h_tmp$/) { $l2h_tmp = shift(@ARGV); next; } if (/^-l2h_keep$/) { $l2h_keep = 1; next; } die $usage; } if ($check) { die $usage unless @ARGV > 0; ✓ exit; } if (($split_node || $split_chapter) && $monolithic) { warn "Can't use -monolithic with -split, -monolithic ignored.\n"; $monolithic = 0; } if ($expandinfo) { $to_skip{'ifinfo'}++; $to_skip{'end ifinfo'}++; $to_skip{'ifnottex'}++; $to_skip{'end ifnottex'}++; } else { $to_skip{'iftex'}++; $to_skip{'end iftex'}++; } $INVISIBLE_MARK = '' if $INVISIBLE_MARK eq 'xbm'; die $usage unless @ARGV == 1; $docu = shift(@ARGV); if ($docu =~ /.*\//) { chop($docu_dir = $&); $docu_name = $'; } else { $docu_dir = '.'; $docu_name = $docu; } unshift(@include_dirs, $docu_dir); $docu_name =~ s/\.te?x(i|info)?$//; # basename of the document $docu_doc = "$docu_name.html"; # document's contents if ($monolithic) { $docu_toc = $docu_foot = $docu_doc; } else { $docu_toc = "${docu_name}_toc.html"; # document's table of contents $docu_stoc = "${docu_name}_stoc.html"; # document's short table of contents $docu_foot = "${docu_name}_foot.html"; # document's footnotes } # # variables # $value{'html'} = 1; # predefine html (the output format) $value{'texi2html'} = $THISVERSION; # predefine texi2html (the translator) # _foo: internal to track @foo foreach ('_author', '_title', '_subtitle', '_settitle', '_setfilename') { $value{$_} = ''; # prevent -w warnings } %node2sec = (); # node to section name %node2href = (); # node to HREF %node2next = (); # node to next %node2prev = (); # node to prev %node2up = (); # node to up %bib2href = (); # bibliography reference to HREF %gloss2href = (); # glossary term to HREF @sections = (); # list of sections %tag2pro = (); # protected sections # # initial indexes # $bib_num = 0; $foot_num = 0; $gloss_num = 0; $idx_num = 0; $sec_num = 0; $doc_num = 0; $html_num = 0; # # can I use ISO8879 characters? (HTML+) # if ($use_iso) { $things_map{'bullet'} = "•"; $things_map{'copyright'} = "©"; $things_map{'dots'} = "…"; $things_map{'equiv'} = "≡"; $things_map{'expansion'} = "→"; $things_map{'point'} = "∗"; $things_map{'result'} = "⇒"; } # # read texi2html extensions (if any) # $extensions = 'texi2html.ext'; # extensions in working directory if (-f $extensions) { print "# reading extensions from $extensions\n" if $verbose; require($extensions); } ($progdir = $0) =~ s/[^\/]+$//; if ($progdir && ($progdir ne './')) { $extensions = "${progdir}texi2html.ext"; # extensions in texi2html directory if (-f $extensions) { print "# reading extensions from $extensions\n" if $verbose; require($extensions); } } # # read init file (if any) # if ($init_file && -f $init_file) { print "# reading initialization file from $init_file\n" if ($verbose); require($init_file); } print "# reading from $docu\n" if $verbose; ######################################################################### # # latex2html stuff # # latex2html conversions consist of three stages: # 1) ToLatex: Put "latex" code into a latex file # 2) ToHtml: Use latex2html to generate corresponding html code and images # 3) FromHtml: Extract generated code and images from latex2html run # ########################## # default settings # # defaults for files and names sub l2h_Init { local($root) = @_; return 0 unless ($root); $l2h_name = "${root}_l2h"; $l2h_latex_file = "${l2h_name}.tex"; $l2h_latex2html = "latex2html" unless ($l2h_latex2html); # destination dir -- generated images are put there, should be the same # as dir of enclosing html document -- $l2h_html_file = "${l2h_name}.html"; $l2h_prefix = "${l2h_name}_"; return 1; } ########################## # # First stage: Generation of Latex file # Initialize with: l2h_InitToLatex # Add content with: l2h_ToLatex($text) --> HTML placeholder comment # Finish with: l2h_FinishToLatex # $l2h_latex_preample = <$l2h_latex_file")) { warn "$ERROR Error l2h: Can't open latex file '$latex_file' for writing\n"; return 0; } print "# l2h: use ${l2h_latex_file} as latex file\n" if ($verbose); print L2H_LATEX $l2h_latex_preample; } $l2h_latex_count = 0; $l2h_to_latex_count = 0; return 1; } # print text (1st arg) into latex file (if not already there), return # HTML commentary which can be later on replaced by the latex2html # generated text sub l2h_ToLatex { local($text) = @_; local($count); chomp($text); $l2h_to_latex_count++; unless ($count = $l2h_to_latex{$text}) { $count = $l2h_latex_count; $l2h_latex_count++; $l2h_to_latex{$text} = $count; unless ($l2h_skip) { print L2H_LATEX "\\begin{rawhtml}\n"; print L2H_LATEX "\n"; print L2H_LATEX "\\end{rawhtml}\n"; print L2H_LATEX "$text\n"; print L2H_LATEX "\\begin{rawhtml}\n"; print L2H_LATEX "\n"; print L2H_LATEX "\\end{rawhtml}\n"; } } return ""; } # print closing into latex file and close it sub l2h_FinishToLatex { local ($reused); $reused = $l2h_to_latex_count - $l2h_latex_count; unless ($l2h_skip) { print L2H_LATEX $l2h_latex_closing; close(L2H_LATEX); } print "# l2h: finished to latex ($l2h_latex_count contents, $reused reused)\n" if ($verbose); return 1; } ################################### # Second stage: Use latex2html to generate corresponding html code and images # # l2h_ToHtml([$l2h_latex_file, [$l2h_html_dir]]): # Call latex2html on $l2h_latex_file # Put images (prefixed with $l2h_name."_") and html file(s) in $l2h_html_dir # Return 1, on success # 0, otherwise # sub l2h_ToHtml { local($call, $ext, $root, $dotbug); if ($l2h_skip) { print "# l2h: skipping latex2html run\n" if ($verbose); return 1; } # Check for dot in directory where dvips will work if ($l2h_tmp) { if ($l2h_tmp =~ /\./) { warn "$ERROR Warning l2h: l2h_tmp dir contains a dot. Use /tmp, insted\n"; $dotbug = 1; } } else { if (&getcwd =~ /\./) { warn "$ERROR Warning l2h: current dir contains a dot. Use /tmp as l2h_tmp dir \n"; $dotbug = 1; } } # fix it, if necessary and hope that it works $l2h_tmp = "/tmp" if ($dotbug); $call = $l2h_latex2html; # use init file, if specified $call = $call . " -init_file " . $init_file if ($init_file && -f $init_file); # use l2h_tmp, if specified $call = $call . " -tmp $l2h_tmp" if ($l2h_tmp); # options we want to be sure of $call = $call ." -address 0 -info 0 -split 0 -no_navigation -no_auto_link"; $call = $call ." -no_subdir -prefix ${l2h_prefix} $l2h_latex_file"; print "# l2h: executing '$call'\n" if ($verbose); if (system($call)) { warn "l2h ***Error: '${call}' did not succeed\n"; return 0; } else { print "# l2h: latex2html finished successfully\n" if ($verbose); return 1; } } # this is directly pasted over from latex2html sub getcwd { local($_) = `pwd`; die "'pwd' failed (out of memory?)\n" unless length; chop; $_; } ########################## # Third stage: Extract generated contents from latex2html run # Initialize with: l2h_InitFromHtml # open $l2h_html_file for reading # reads in contents into array indexed by numbers # return 1, on success -- 0, otherwise # Extract Html code with: l2h_FromHtml($text) # replaces in $text all previosuly inserted comments by generated html code # returns (possibly changed) $text # Finish with: l2h_FinishFromHtml # closes $l2h_html_dir/$l2h_name.".html" sub l2h_InitFromHtml { local($h_line, $h_content, $count); if (! open(L2H_HTML, "<${l2h_html_file}")) { print "$ERROR Error l2h: Can't open ${l2h_html_file} for reading\n"; return 0; } print "# l2h: use ${l2h_html_file} as html file\n" if ($verbose); $l2h_html_count = 0; while ($h_line = ) { if ($h_line =~ /^/) { $count = $1; $h_content = ""; while ($h_line = ) { if ($h_line =~ /^/) { chomp($h_content); $l2h_from_html[$count] = $h_content; $l2h_html_count++; $h_content = ''; last; } $h_content = $h_content.$h_line; } if ($hcontent) { print "$ERROR Warning l2h: l2h_end $l2h_name $count not found\n" if ($verbose); close(L2H_HTML); return 0; } } } print "# l2h: Got $l2h_html_count of $l2h_latex_count html contents\n" if ($verbose); close(L2H_HTML); return 1; } sub l2h_FromHtml { local($text) = @_; local($done, $to_do, $count); $to_do = $text; while ($to_do =~ /([^\000]*)([^\000]*)/) { $to_do = $1; $count = $2; $done = $3.$done; $done = "".$done if ($debug & $DEBUG_L2H); $done = &l2h_ExtractFromHtml($count) . $done; $done = "".$done if ($debug & $DEBUG_L2H); } return $to_do.$done; } sub l2h_ExtractFromHtml { local($count) = @_; return $l2h_from_html[$count] if ($l2h_from_html[$count]); if ($count >= 0 && $count < $l2h_latex_count) { # now we are in trouble local($l_l2h, $_); $l2h_extract_error++; print "$ERROR l2h: can't extract content $count from html\n" if ($verbose); # try simple (ordinary) substition (without l2h) $l_l2h = $l2h; $l2h = 0; $_ = $l2h_to_latex{$count}; $_ = &substitute_style($_); &unprotect_texi; $_ = "" . $_ if ($debug & $DEBUG_L2H); $l2h = $l_l2h; return $_; } else { # now we have been incorrectly called $l2h_range_error++; print "$ERROR l2h: Request of $count content which is out of valide range [0,$l2h_latex_count)\n"; return "" if ($debug & $DEBUG_L2H); return ""; } } sub l2h_FinishFromHtml { if ($verbose) { if ($l2h_extract_error + $l2h_range_error) { print "# l2h: finished from html ($l2h_extract_error extract and $l2h_range_error errors)\n"; } else { print "# l2h: finished from html (no errors)\n"; } } } sub l2h_Finish { return 1 if ($l2h_keep); print "# l2h: removing temorary files generated by l2h extension\n"; unlink ($l2h_latex_file); unlink ($l2h_html_file); return 1; } #+++############################################################################ # # # Pass 1: read source, handle command, variable, simple substitution # # # #---############################################################################ @lines = (); # whole document @toc_lines = (); # table of contents @stoc_lines = (); # table of contents $toplevel = 0; # top level seen in hierarchy $curlevel = 0; # current level in TOC $node = ''; # current node name $node_next = ''; # current node next name $node_prev = ''; # current node prev name $node_up = ''; # current node up name $in_table = 0; # am I inside a table $table_type = ''; # type of table ('', 'f', 'v', 'multi') @tables = (); # nested table support $in_bibliography = 0; # am I inside a bibliography $in_glossary = 0; # am I inside a glossary $in_top = 0; # am I inside the top node $in_pre = 0; # am I inside a preformatted section $in_list = 0; # am I inside a list $in_html = 0; # am I inside an HTML section $first_line = 1; # is it the first line $dont_html = 0; # don't protect HTML on this line $split_num = 0; # split index $deferred_ref = ''; # deferred reference for indexes @html_stack = (); # HTML elements stack $html_element = ''; # current HTML element $anchorid = 0; # Identifier of the current @anchor &html_reset; # init l2h $l2h = &l2h_Init($docu_name) if ($l2h); $l2h = &l2h_InitToLatex if ($l2h); # build code for simple substitutions # the maps used (%simple_map and %things_map) MUST be aware of this # watch out for regexps, / and escaped characters! $subst_code = ''; foreach (keys(%simple_map)) { ($re = $_) =~ s/(\W)/\\$1/g; # protect regexp chars $subst_code .= "s/\\\@$re/$simple_map{$_}/g;\n"; } foreach (keys(%things_map)) { $subst_code .= "s/\\\@$_\\{\\}/$things_map{$_}/g;\n"; } if ($use_acc) { # accentuated characters foreach (keys(%accent_map)) { if ($_ eq "`") { $subst_code .= "s/$;3"; } elsif ($_ eq "'") { $subst_code .= "s/$;4"; } else { $subst_code .= "s/\\\@\\$_"; } $subst_code .= "([aeiou])/&\${1}$accent_map{$_};/gi;\n"; } } eval("sub simple_substitutions { $subst_code }"); &init_input; while ($_ = &next_line) { # # remove \input on the first lines only # if ($first_line) { next if /^\\input/; $first_line = 0; } # # parse texinfo tags # $tag = ''; $end_tag = ''; if (/^\s*\@end\s+(\w+)\b/) { $end_tag = $1; } elsif (/^\s*\@(\w+)\b/) { $tag = $1; } # # handle @ifhtml / @end ifhtml # if ($in_html) { if ($end_tag eq 'ifhtml') { $in_html = 0; } else { $tag2pro{$in_html} .= $_; } next; } elsif ($tag eq 'ifhtml') { $in_html = $PROTECTTAG . ++$html_num; push(@lines, $in_html); next; } elsif ($tag eq 'ifnothtml') { &skip_until($tag); next; } # # try to skip the line # if ($end_tag) { next if $to_skip{"end $end_tag"}; } elsif ($tag) { next if $to_skip{$tag}; last if $tag eq 'bye'; } if ($in_top) { # parsing the top node if ($tag eq 'node' || $tag eq 'include' || $sec2level{$tag}) { # no more in top $in_top = 0; } else { # skip it next; } } # # try to remove inlined comments # syntax from tex-mode.el comment-start-skip # s/((^|[^\@])(\@\@)*)\@c(omment)? .*/$1/; # non-@ substitutions cf. texinfmt.el unless ($in_pre) { s/``/\"/g; s/''/\"/g; s/([\w ])---([\w ])/$1--$2/g; } # # analyze the tag # if ($tag) { # skip lines &skip_until($tag), next if $tag eq 'ignore'; if ($expandinfo) { &skip_until($tag), next if $tag eq 'iftex'; } else { &skip_until($tag), next if $tag eq 'ifinfo'; } if ($tag eq 'tex') { # add to latex2html file if ($l2h && ! $in_pre) { # add space to the end -- tex(i2dvi) does this, as well push(@lines, &l2h_ToLatex(&string_until($tag) . " ")); } else { &skip_until($tag); } next; } &skip_until($tag), next if $tag eq 'tex'; # handle special tables if ($tag =~ /^(|f|v|multi)table$/) { $table_type = $1; $tag = 'table'; } # special cases if ($tag eq 'top' || ($tag eq 'node' && /^\@node\s+top\s*,/i)) { $in_top = 1; @lines = (); # ignore all lines before top (title page garbage) next; } elsif ($tag eq 'node') { $in_top = 0; warn "$ERROR Bad node line: $_" unless $_ =~ /^\@node\s$NODESRE$/o; $_ = &protect_html($_); # if node contains '&' for instance s/^\@node\s+//; ($node, $node_next, $node_prev, $node_up) = split(/,/); &normalise_node($node); &normalise_node($node_next); &normalise_node($node_prev); &normalise_node($node_up); if ($split_node) { &next_doc; push(@lines, $SPLITTAG) if $split_num++; push(@sections, $node); } next; } elsif ($tag eq 'include') { if (/^\@include\s+($FILERE)\s*$/o) { $file = $1; unless (-e $file) { foreach $dir (@include_dirs) { $file = "$dir/$1"; last if -e $file; } } if (-e $file) { &open($file); print "# including $file\n" if $verbose; } else { warn "$ERROR Can't find $file, skipping"; } } else { warn "$ERROR Bad include line: $_"; } next; } elsif ($tag eq 'ifclear') { if (/^\@ifclear\s+($VARRE)\s*$/o) { next unless defined($value{$1}); &skip_until($tag); } else { warn "$ERROR Bad ifclear line: $_"; } next; } elsif ($tag eq 'ifset') { if (/^\@ifset\s+($VARRE)\s*$/o) { next if defined($value{$1}); &skip_until($tag); } else { warn "$ERROR Bad ifset line: $_"; } next; } elsif ($tag eq 'menu') { unless ($show_menu) { &skip_until($tag); next; } &html_push_if($tag); push(@lines, &html_debug("\n", __LINE__)); } elsif ($format_map{$tag}) { $in_pre = 1 if $format_map{$tag} eq 'PRE'; &html_push_if($format_map{$tag}); push(@lines, &html_debug("\n", __LINE__)); $in_list++ if $format_map{$tag} eq 'UL' || $format_map{$tag} eq 'OL' ; push(@lines, &debug("<$format_map{$tag}>\n", __LINE__)); next; } elsif ($tag eq 'table') { if (/^\s*\@(|f|v|multi)table\s+\@(\w+)/) { $in_table = $2; unshift(@tables, join($;, $table_type, $in_table)); if ($table_type eq "multi") { # don#t use borders -- gets confused by empty cells push(@lines, &debug("\n", __LINE__)); &html_push_if('TABLE'); } else { push(@lines, &debug("
    \n", __LINE__)); &html_push_if('DL'); } push(@lines, &html_debug("\n", __LINE__)); } else { warn "$ERROR Bad table line: $_"; } next; } elsif ($tag eq 'synindex' || $tag eq 'syncodeindex') { if (/^\@$tag\s+(\w)\w\s+(\w)\w\s*$/) { eval("*${1}index = *${2}index"); } else { warn "$ERROR Bad syn*index line: $_"; } next; } elsif ($tag eq 'sp') { push(@lines, &debug("

    \n", __LINE__)); next; } elsif ($tag eq 'setref') { &protect_html; # if setref contains '&' for instance if (/^\@$tag\s*{($NODERE)}\s*$/) { $setref = $1; $setref =~ s/\s+/ /g; # normalize $setref =~ s/ $//; $node2sec{$setref} = $name; $node2href{$setref} = "$docu_doc#$docid"; } else { warn "$ERROR Bad setref line: $_"; } next; } elsif ($tag eq 'anchor') { if (/\@$tag\s*{($NODERE)}/) { $setref = $1; $setref =~ s/\s+/ /g; # normalize $setref =~ s/ $//; $node2sec{$setref} = $setref; # text to print in the .html $node2href{$setref} = "$docu_doc#$docid" . "_$anchorid"; # How to reference the anchor push (@lines, &anchor("$docid" . "_$anchorid", '','', 0)); $anchorid ++; } else { warn "$ERROR Bad anchor line: $_"; } next; } elsif ($tag eq 'defindex' || $tag eq 'defcodeindex') { if (/^\@$tag\s+(\w\w)\s*$/) { $valid_index{$1} = 1; } else { warn "$ERROR Bad defindex line: $_"; } next; } elsif ($tag eq 'lowersections') { local ($sec, $level); while (($sec, $level) = each %sec2level) { $sec2level{$sec} = $level + 1; } next; } elsif ($tag eq 'raisesections') { local ($sec, $level); while (($sec, $level) = each %sec2level) { $sec2level{$sec} = $level - 1; } next; } elsif (defined($def_map{$tag})) { if ($def_map{$tag}) { s/^\@$tag\s+//; $tag = $def_map{$tag}; $_ = "\@$tag $_"; $tag =~ s/\s.*//; } } elsif (defined($user_sub{$tag})) { s/^\@$tag\s+//; $sub = $user_sub{$tag}; print "# user $tag = $sub, arg: $_" if $debug & $DEBUG_USER; if (defined(&$sub)) { chop($_); &$sub($_); } else { warn "$ERROR Bad user sub for $tag: $sub\n"; } next; } if (defined($def_map{$tag})) { s/^\@$tag\s+//; if ($tag =~ /x$/) { # extra definition line $tag = $`; $is_extra = 1; } else { $is_extra = 0; } while (/\{([^\{\}]*)\}/) { # this is a {} construct ($before, $contents, $after) = ($`, $1, $'); # protect spaces $contents =~ s/\s+/$;9/g; # restore $_ protecting {} $_ = "$before$;7$contents$;8$after"; } @args = split(/\s+/, &protect_html($_)); foreach (@args) { s/$;9/ /g; # unprotect spaces s/$;7/\{/g; # ... { s/$;8/\}/g; # ... } } $type = shift(@args); $type =~ s/^\{(.*)\}$/$1/; print "# def ($tag): {$type} ", join(', ', @args), "\n" if $debug & $DEBUG_DEF; $type .= ':'; # it's nicer like this $name = shift(@args); $name =~ s/^\{(.*)\}$/$1/; if ($is_extra) { $_ = &debug("

    ", __LINE__); } else { $_ = &debug("
    \n
    ", __LINE__); } if ($tag eq 'deffn' || $tag eq 'defvr' || $tag eq 'deftp') { $_ .= "$type $name"; $_ .= " @args" if @args; } elsif ($tag eq 'deftypefn' || $tag eq 'deftypevr' || $tag eq 'defcv' || $tag eq 'defop') { $ftype = $name; $name = shift(@args); $name =~ s/^\{(.*)\}$/$1/; $_ .= "$type $ftype $name"; $_ .= " @args" if @args; } else { warn "$ERROR Unknown definition type: $tag\n"; $_ .= "$type $name"; $_ .= " @args" if @args; } $_ .= &debug("\n
    ", __LINE__); $name = &unprotect_html($name); if ($tag eq 'deffn' || $tag eq 'deftypefn') { unshift(@input_spool, "\@findex $name\n"); } elsif ($tag eq 'defop') { unshift(@input_spool, "\@findex $name on $ftype\n"); } elsif ($tag eq 'defvr' || $tag eq 'deftypevr' || $tag eq 'defcv') { unshift(@input_spool, "\@vindex $name\n"); } else { unshift(@input_spool, "\@tindex $name\n"); } $dont_html = 1; } } elsif ($end_tag) { if ($format_map{$end_tag}) { $in_pre = 0 if $format_map{$end_tag} eq 'PRE'; $in_list-- if $format_map{$end_tag} eq 'UL' || $format_map{$end_tag} eq 'OL' ; &html_pop_if('LI', 'P'); &html_pop_if(); push(@lines, &debug("\n", __LINE__)); push(@lines, &html_debug("\n", __LINE__)); } elsif ($end_tag =~ /^(|f|v|multi)table$/) { unless (@tables) { warn "$ERROR \@end $end_tag without \@*table\n"; next; } ($table_type, $in_table) = split($;, shift(@tables)); unless ($1 eq $table_type) { warn "$ERROR \@end $end_tag without matching \@$end_tag\n"; next; } if ($table_type eq "multi") { push(@lines, "
    \n"); &html_pop_if('TR'); } else { push(@lines, "\n"); &html_pop_if('DD'); } &html_pop_if(); if (@tables) { ($table_type, $in_table) = split($;, $tables[0]); } else { $in_table = 0; } } elsif (defined($def_map{$end_tag})) { push(@lines, &debug("\n", __LINE__)); } elsif ($end_tag eq 'menu') { &html_pop_if(); push(@lines, $_); # must keep it for pass 2 } next; } # # misc things # # protect texi and HTML things &protect_texi; $_ = &protect_html($_) unless $dont_html; $dont_html = 0; # substitution (unsupported things) s/^\@center\s+//g; s/^\@exdent\s+//g; s/\@noindent\s+//g; s/\@refill\s+//g; # other substitutions &simple_substitutions; s/\@value{($VARRE)}/$value{$1}/eg; s/\@footnote\{/\@footnote$docu_doc\{/g; # mark footnotes, cf. pass 4 # # analyze the tag again # if ($tag) { if (defined($sec2level{$tag}) && $sec2level{$tag} > 0) { if (/^\@$tag\s+(.+)$/) { $name = $1; $name =~ s/\s+$//; $level = $sec2level{$tag}; $name = &update_sec_num($tag, $level) . " $name" if $number_sections && $tag !~ /^unnumbered/; if ($tag =~ /heading$/) { push(@lines, &html_debug("\n", __LINE__)); if ($html_element ne 'body') { # We are in a nice pickle here. We are trying to get a H? heading # even though we are not in the body level. So, we convert it to a # nice, bold, line by itself. $_ = &debug("\n\n

    $name\n\n", __LINE__); } else { $_ = &debug("$name\n", __LINE__); &html_push_if('body'); } print "# heading, section $name, level $level\n" if $debug & $DEBUG_TOC; } else { if ($split_chapter) { unless ($toplevel) { # first time we see a "section" unless ($level == 1) { warn "$ERROR The first section found is not of level 1: $_"; warn "$ERROR I'll split on sections of level $level...\n"; } $toplevel = $level; } if ($level == $toplevel) { &next_doc; push(@lines, $SPLITTAG) if $split_num++; push(@sections, $name); } } $sec_num++; $docid = "SEC$sec_num"; $tocid = "TOC$sec_num"; # check biblio and glossary $in_bibliography = ($name =~ /^([A-Z]|\d+)?(\.\d+)*\s*bibliography$/i); $in_glossary = ($name =~ /^([A-Z]|\d+)?(\.\d+)*\s*glossary$/i); # check node if ($node) { if ($node2sec{$node}) { warn "$ERROR Duplicate node found: $node\n"; } else { $node2sec{$node} = $name; $node2href{$node} = "$docu_doc#$docid"; $node2next{$node} = $node_next; $node2prev{$node} = $node_prev; $node2up{$node} = $node_up; print "# node $node, section $name, level $level\n" if $debug & $DEBUG_TOC; } $node = ''; $node_next = ''; $node_prev = ''; $node_next = ''; } else { print "# no node, section $name, level $level\n" if $debug & $DEBUG_TOC; } # update TOC while ($level > $curlevel) { $curlevel++; push(@toc_lines, "

      \n"); } while ($level < $curlevel) { $curlevel--; push(@toc_lines, "
    \n"); } $_ = &anchor($tocid, "$docu_doc#$docid", $name, 1); $_ = &substitute_style($_); push(@stoc_lines, $_) if ($level == 1); push(@toc_lines, "
  • " . $_ ."
    • "); # update DOC push(@lines, &html_debug("\n", __LINE__)); &html_reset; # $_ = "".&anchor($docid, "$docu_toc#$tocid", $name)."\n"; # obachman: Don't use href $_ = "".&anchor($docid, '', $name)."\n"; $_ = &debug($_, __LINE__); push(@lines, &html_debug("\n", __LINE__)); } # update DOC foreach $line (split(/\n+/, $_)) { push(@lines, "$line\n"); } next; } else { warn "$ERROR Bad section line: $_"; } } else { # track variables $value{$1} = $2, next if /^\@set\s+($VARRE)\s+(.*)$/o; delete $value{$1}, next if /^\@clear\s+($VARRE)\s*$/o; # store things $value{'_setfilename'} = $1, next if /^\@setfilename\s+(.*)$/; $value{'_settitle'} = $1, next if /^\@settitle\s+(.*)$/; $value{'_author'} .= "$1\n", next if /^\@author\s+(.*)$/; $value{'_subtitle'} .= "$1\n", next if /^\@subtitle\s+(.*)$/; $value{'_title'} .= "$1\n", next if /^\@title\s+(.*)$/; # index if (/^\@(..?)index\s+/) { unless ($valid_index{$1}) { warn "$ERROR Undefined index command: $_"; next; } $id = 'IDX' . ++$idx_num; $index = $1 . 'index'; $what = &substitute_style($'); $what =~ s/\s+$//; print "# found $index for '$what' id $id\n" if $debug & $DEBUG_INDEX; eval(<\n", __LINE__)); push(@lines, &anchor($id, '', $INVISIBLE_MARK, !$in_pre)); &html_push('P'); } elsif ($html_element eq 'DL' || $html_element eq 'UL' || $html_element eq 'OL' ) { $deferred_ref .= &anchor($id, '', $INVISIBLE_MARK, !$in_pre) . " "; } next; } # list item if (/^\s*\@itemx?\s+/) { $what = $'; $what =~ s/\s+$//; if ($in_bibliography && $use_bibliography) { if ($what =~ /^$BIBRE$/o) { $id = 'BIB' . ++$bib_num; $bib2href{$what} = "$docu_doc#$id"; print "# found bibliography for '$what' id $id\n" if $debug & $DEBUG_BIB; $what = &anchor($id, '', $what); } } elsif ($in_glossary && $use_glossary) { $id = 'GLOSS' . ++$gloss_num; $entry = $what; $entry =~ tr/A-Z/a-z/ unless $entry =~ /^[A-Z\s]+$/; $gloss2href{$entry} = "$docu_doc#$id"; print "# found glossary for '$entry' id $id\n" if $debug & $DEBUG_GLOSS; $what = &anchor($id, '', $what); } &html_pop_if('P'); if ($html_element eq 'DL' || $html_element eq 'DD') { if ($things_map{$in_table} && !$what) { # special case to allow @table @bullet for instance push(@lines, &debug("
    $things_map{$in_table}\n", __LINE__)); } else { push(@lines, &debug("
    \@$in_table\{$what\}\n", __LINE__)); } push(@lines, "
    "); &html_push('DD') unless $html_element eq 'DD'; if ($table_type) { # add also an index unshift(@input_spool, "\@${table_type}index $what\n"); } } elsif ($html_element eq 'TABLE') { push(@lines, &debug("$what\n", __LINE__)); &html_push('TR'); } elsif ($html_element eq 'TR') { push(@lines, &debug("\n", __LINE__)); push(@lines, &debug("$what\n", __LINE__)); } else { push(@lines, &debug("
  • $what\n", __LINE__)); &html_push('LI') unless $html_element eq 'LI'; } push(@lines, &html_debug("\n", __LINE__)); if ($deferred_ref) { push(@lines, &debug("$deferred_ref\n", __LINE__)); $deferred_ref = ''; } next; } elsif (/^\@tab\s+(.*)$/) { push(@lines, "$1\n"); next; } } } # paragraph separator if ($_ eq "\n") { next if $#lines >= 0 && $lines[$#lines] eq "\n"; if ($html_element eq 'P') { push(@lines, "\n"); $_ = &debug("\n", __LINE__); &html_pop; } } elsif ($html_element eq 'body' || $html_element eq 'BLOCKQUOTE') { push(@lines, "

    \n"); &html_push('P'); $_ = &debug($_, __LINE__); } # otherwise push(@lines, $_); } # finish TOC $level = 0; while ($level < $curlevel) { $curlevel--; push(@toc_lines, "\n"); } print "# end of pass 1\n" if $verbose; #+++############################################################################ # # # Pass 2/3: handle style, menu, index, cross-reference # # # #---############################################################################ @lines2 = (); # whole document (2nd pass) @lines3 = (); # whole document (3rd pass) $in_menu = 0; # am I inside a menu while (@lines) { $_ = shift(@lines); # # special case (protected sections) # if (/^$PROTECTTAG/o) { push(@lines2, $_); next; } # # menu # $in_menu = 1, push(@lines2, &debug("

      \n", __LINE__)), next if /^\@menu\b/; $in_menu = 0, push(@lines2, &debug("
    \n", __LINE__)), next if /^\@end\s+menu\b/; if ($in_menu) { if (/^\*\s+($NODERE)::/o) { $descr = $'; chop($descr); &menu_entry($1, $1, $descr); } elsif (/^\*\s+(.+):\s+([^\t,\.\n]+)[\t,\.\n]/) { $descr = $'; chop($descr); &menu_entry($1, $2, $descr); } elsif (/^\*/) { warn "$ERROR Bad menu line: $_"; } else { # description continued? push(@lines2, $_); } next; } # # printindex # # obachman: replace ^\@printindex by \@printindex, otherwise # generation in debug mode fails if (/\@printindex\s+(\w\w)\b/) { local($index, *ary, @keys, $key, $letter, $last_letter, @refs); if ($predefined_index{$1}) { $index = $predefined_index{$1} . 'index'; } else { $index = $1 . 'index'; } eval("*ary = *$index"); @keys = keys(%ary); foreach $key (@keys) { $_ = $key; 1 while s/<(\w+)>\`(.*)\'<\/\1>/$2/; # remove HTML tags with quotes 1 while s/<(\w+)>(.*)<\/\1>/$2/; # remove HTML tags $_ = &unprotect_html($_); &unprotect_texi; tr/A-Z/a-z/; # lowercase $key2alpha{$key} = $_; print "# index $key sorted as $_\n" if $key ne $_ && $debug & $DEBUG_INDEX; } push(@lines2, "Jump to:\n"); $last_letter = undef; foreach $key (sort byalpha @keys) { $letter = substr($key2alpha{$key}, 0, 1); $letter = substr($key2alpha{$key}, 0, 2) if $letter eq $;; if (!defined($last_letter) || $letter ne $last_letter) { push(@lines2, "-\n") if defined($last_letter); push(@lines2, "" . &protect_html($letter) . "\n"); $last_letter = $letter; } } push(@lines2, "

    \n"); $last_letter = undef; foreach $key (sort byalpha @keys) { $letter = substr($key2alpha{$key}, 0, 1); $letter = substr($key2alpha{$key}, 0, 2) if $letter eq $;; if (!defined($last_letter) || $letter ne $last_letter) { push(@lines2, "\n") if defined($last_letter); push(@lines2, "

    " . &protect_html($letter) . "

    \n"); push(@lines2, "\n"); $last_letter = $letter; } @refs = (); foreach (split(/$;/, $ary{$key})) { push(@refs, &anchor('', $_, $key, 0)); } push(@lines2, "
  • " . join(", ", @refs) . "\n"); } push(@lines2, "
    • \n") if defined($last_letter); next; } # # simple style substitutions # $_ = &substitute_style($_); # # xref # while (/\@(x|px|info|)ref{($XREFRE)(}?)/o) { # note: Texinfo may accept other characters ($type, $nodes, $full) = ($1, $2, $3); ($before, $after) = ($`, $'); if (! $full && $after) { warn "$ERROR Bad xref (no ending } on line): $_"; $_ = "$before$;0${type}ref\{$nodes$after"; next; # while xref } if ($type eq 'x') { $type = 'See '; } elsif ($type eq 'px') { $type = 'see '; } elsif ($type eq 'info') { $type = 'See Info'; } else { $type = ''; } unless ($full) { $next = shift(@lines); $next = &substitute_style($next); chop($nodes); # remove final newline if ($next =~ /\}/) { # split on 2 lines $nodes .= " $`"; $after = $'; } else { $nodes .= " $next"; $next = shift(@lines); $next = &substitute_style($next); chop($nodes); if ($next =~ /\}/) { # split on 3 lines $nodes .= " $`"; $after = $'; } else { warn "$ERROR Bad xref (no ending }): $_"; $_ = "$before$;0xref\{$nodes$after"; unshift(@lines, $next); next; # while xref } } } $nodes =~ s/\s+/ /g; # remove useless spaces @args = split(/\s*,\s*/, $nodes); $node = $args[0]; # the node is always the first arg &normalise_node($node); $sec = $node2sec{$node}; if (@args == 5) { # reference to another manual $sec = $args[2] || $node; $man = $args[4] || $args[3]; $_ = "${before}${type}section `$sec' in \@cite{$man}$after"; } elsif ($type =~ /Info/) { # inforef warn "$ERROR Wrong number of arguments: $_" unless @args == 3; ($nn, $_, $in) = @args; $_ = "${before}${type} file `$in', node `$nn'$after"; } elsif ($sec) { $href = $node2href{$node}; $_ = "${before}${type}section " . &anchor('', $href, $sec) . $after; } else { warn "$ERROR Undefined node ($node): $_"; $_ = "$before$;0xref{$nodes}$after"; } } if (/^\@image\s*{/) { s/\@image\s*{//; my (@args) = split (/,/); my $base = $args[0]; my $image; if (-r "$base.jpg") { $image = "$base.jpg"; } elsif (-r "$base.png") { $image = "$base.png"; } elsif (-r "$base.gif") { $image = "$base.gif"; } else { warn "$ERROR no image file for $base: $_"; } $_ = "\"$base\""; } # # try to guess bibliography references or glossary terms # unless (/^/) { $done .= $pre . &anchor('', $href, $what); } else { $done .= "$pre$what"; } $_ = $post; } $_ = $done . $_; } if ($use_glossary) { $done = ''; while (/\b\w+\b/) { ($pre, $what, $post) = ($`, $&, $'); $entry = $what; $entry =~ tr/A-Z/a-z/ unless $entry =~ /^[A-Z\s]+$/; $href = $gloss2href{$entry}; if (defined($href) && $post !~ /^[^<]*<\/A>/) { $done .= $pre . &anchor('', $href, $what); } else { $done .= "$pre$what"; } $_ = $post; } $_ = $done . $_; } } # otherwise push(@lines2, $_); } print "# end of pass 2\n" if $verbose; # # split style substitutions # while (@lines2) { $_ = shift(@lines2); # # special case (protected sections) # if (/^$PROTECTTAG/o) { push(@lines3, $_); next; } # # split style substitutions # $old = ''; while ($old ne $_) { $old = $_; if (/\@(\w+)\{/) { ($before, $style, $after) = ($`, $1, $'); if (defined($style_map{$style})) { $_ = $after; $text = ''; $after = ''; $failed = 1; while (@lines2) { if (/\}/) { $text .= $`; $after = $'; $failed = 0; last; } else { $text .= $_; $_ = shift(@lines2); } } if ($failed) { die "* Bad syntax (\@$style) after: $before\n"; } else { $text = &apply_style($style, $text); $_ = "$before$text$after"; } } } } # otherwise push(@lines3, $_); } print "# end of pass 3\n" if $verbose; #+++############################################################################ # # # Pass 4: foot notes, final cleanup # # # #---############################################################################ @foot_lines = (); # footnotes @doc_lines = (); # final document $end_of_para = 0; # true if last line is

    while (@lines3) { $_ = shift(@lines3); # # special case (protected sections) # if (/^$PROTECTTAG/o) { push(@doc_lines, $_); $end_of_para = 0; next; } # # footnotes # while (/\@footnote([^\{\s]+)\{/) { ($before, $d, $after) = ($`, $1, $'); $_ = $after; $text = ''; $after = ''; $failed = 1; while (@lines3) { if (/\}/) { $text .= $`; $after = $'; $failed = 0; last; } else { $text .= $_; $_ = shift(@lines3); } } if ($failed) { die "* Bad syntax (\@footnote) after: $before\n"; } else { $foot_num++; $docid = "DOCF$foot_num"; $footid = "FOOT$foot_num"; $foot = "($foot_num)"; push(@foot_lines, "

    " . &anchor($footid, "$d#$docid", $foot) . "

    \n"); $text = "

    $text" unless $text =~ /^\s*

    /; push(@foot_lines, "$text\n"); $_ = $before . &anchor($docid, "$docu_foot#$footid", $foot) . $after; } } # # remove unnecessary

    # if (/^\s*

    \s*$/) { next if $end_of_para++; } else { $end_of_para = 0; } # otherwise push(@doc_lines, $_); } print "# end of pass 4\n" if $verbose; #+++############################################################################ # # # Pass 5: print things # # # #---############################################################################ $l2h = &l2h_FinishToLatex if ($l2h); $l2h = &l2h_ToHtml if ($l2h); $l2h = &l2h_InitFromHtml if ($l2h); $header = < EOT $full_title = $value{'_title'} || $value{'_settitle'} || "Untitled Document"; $title = $value{'_settitle'} || $full_title; $_ = &substitute_style($full_title); &unprotect_texi; s/\n$//; # rmv last \n (if any) $full_title = "

    " . join("

    \n

    ", split(/\n/, $_)) . "

    \n"; # # print ToC # if (!$monolithic && @toc_lines) { if (open(FILE, "> $docu_toc")) { print "# creating $docu_toc...\n" if $verbose; &print_toplevel_header("$title - Table of Contents"); &print_ruler; &print(*toc_lines, FILE); &print_toplevel_footer; close(FILE); } else { warn "$ERROR Can't write to $docu_toc: $!\n"; } } # # print sToC # if (!$monolithic && @stoc_lines) { if (open(FILE, "> $docu_stoc")) { print "# creating $docu_stoc...\n" if $verbose; &print_toplevel_header("$title - Short Table of Contents"); &print_ruler; print FILE "
      \n"; foreach $stoc (@stoc_lines) { $stoc = "
    • $stoc
      • \n"; } &print(*stoc_lines, FILE); print FILE "
    \n"; &print_toplevel_footer; close(FILE); } else { warn "$ERROR Can't write to $docu_toc: $!\n"; } } # # print footnotes # if (!$monolithic && @foot_lines) { if (open(FILE, "> $docu_foot")) { print "# creating $docu_foot...\n" if $verbose; &print_toplevel_header("$title - Footnotes"); &print_ruler; &print(*foot_lines, FILE); &print_toplevel_footer; close(FILE); } else { warn "$ERROR Can't write to $docu_foot: $!\n"; } } # # print document # sub clean_name { local ($_); $_ = &remove_style($_[0]); &unprotect_texi; return $_; } sub clean_href { local($href) = @_; $href =~ s/(.*)#.*$/$1/; return $href; } sub default_top_navigation { return &default_navigation . "

    \n"; } sub default_bottom_navigation { local($navigation); return "

    \n" . &default_navigation. "\n"; } sub default_navigation { local($navigation); $navigation .= " [" . &anchor('', ($T2H_CONTENT_HREF ne $T2H_THIS_HREF ? $T2H_CONTENT_HREF : ''), "Contents") . "]  "; $navigation .= " [" . &anchor('', ($T2H_BACK_HREF ne $T2H_THIS_HREF ? $T2H_BACK_HREF : ''), "Back") . "]  "; $navigation .= " [" . &anchor('', ($T2H_PREV_HREF ne $T2H_THIS_HREF ? $T2H_PREV_HREF : ''), "Prev") . "]  "; $navigation .= " [" . &anchor('', ($T2H_UP_HREF ne $T2H_THIS_HREF ? $T2H_UP_HREF : ''), "Up") . "]  "; $navigation .= " [" . &anchor('', ($T2H_NEXT_HREF ne $T2H_THIS_HREF ? $T2H_NEXT_HREF : ''), "Next") . "]  "; $navigation .= " [" . &anchor('', ($T2H_FORWARD_HREF ne $T2H_THIS_HREF ? $T2H_FORWARD_HREF : ''), "Forward"). "]  ";; return $navigation; } if ($split_chapter || $split_node) { # split $doc_num = 0; $last_num = scalar(@sections); $T2H_FIRST_HREF = &doc_href(1); $T2H_FIRST = &clean_name($sections[1]); $T2H_LAST_HREF = &doc_href($last_num); $T2H_LAST = &clean_name($sections[$last_num -1]); $T2H_CONTENT_HREF = $docu_toc; $T2H_THIS = ''; $T2H_THIS_HREF = ''; $T2H_FORWARD = &clean_name($sections[0]); $T2H_FORWARD_HREF = &doc_href(1); while ($section = shift(@sections)) { &next_doc; $T2H_BACK = $T2H_THIS; $T2H_BACK_HREF = $T2H_THIS_HREF; $T2H_THIS = $T2H_FORWARD; $T2H_THIS_HREF = $T2H_FORWARD_HREF; $T2H_FORWARD = &clean_name($sections[1]) if ($doc_num < $last_num); $T2H_FORWARD_HREF = &doc_href($doc_num + 1) if ($doc_num < $last_num); $T2H_PREV = &clean_name($node2prev{$section}); $T2H_PREV_HREF = &clean_href($node2href{$node2prev{$section}}); $T2H_NEXT = &clean_name($node2next{$section}); $T2H_NEXT_HREF = &clean_href($node2href{$node2next{$section}}); $T2H_UP = &clean_name($node2up{$section}); $T2H_UP_HREF = &clean_href($node2href{$node2up{$section}}); if (open(FILE, "> $docu_doc")) { print "# creating $docu_doc...\n" if $verbose; &print_header("$title - $section"); if (defined(&t2h_custom_top_navigation)) { $navigation = &t2h_custom_top_navigation; } else { $navigation = &default_top_navigation; } print FILE $navigation; @tmp_lines = (); while (@doc_lines) { $_ = shift(@doc_lines); last if ($_ eq $SPLITTAG); push(@tmp_lines, $_); } &print(*tmp_lines, FILE); if (defined(&t2h_custom_bottom_navigation)) { $navigation = &t2h_custom_bottom_navigation; } else { $navigation = &default_bottom_navigation; } print FILE $navigation; &print_footer; close(FILE); } else { warn "$ERROR Can't write to $docu_doc: $!\n"; } } } else { # not split if (open(FILE, "> $docu_doc")) { print "# creating $docu_doc...\n" if $verbose; if ($monolithic || !@toc_lines) { &print_toplevel_header($title); } else { &print_header($title); print FILE $full_title; } if ($monolithic && @toc_lines) { &print_ruler; print FILE "

    Table of Contents

    \n"; &print(*toc_lines, FILE); } &print_ruler; &print(*doc_lines, FILE); if ($monolithic && @foot_lines) { &print_ruler; print FILE "

    Footnotes

    \n"; &print(*foot_lines, FILE); } if ($monolithic || !@toc_lines) { &print_toplevel_footer; } else { &print_footer; } close(FILE); } else { warn "$ERROR Can't write to $docu_doc: $!\n"; } } &l2h_FinishFromHtml if ($l2h); &l2h_Finish if($l2h); print "# that's all folks\n" if $verbose; #+++############################################################################ # # # Low level functions # # # #---############################################################################ sub update_sec_num { local($name, $level) = @_; my $ret; $level--; # here we start at 0 if ($name =~ /^appendix/) { # appendix style if (defined(@appendix_sec_num)) { &incr_sec_num($level, @appendix_sec_num); } else { @appendix_sec_num = ('A', 0, 0, 0); } $ret = join('.', @appendix_sec_num[0..$level]); } else { # normal style if (defined(@normal_sec_num)) { &incr_sec_num($level, @normal_sec_num); } else { @normal_sec_num = (1, 0, 0, 0); } $ret = join('.', @normal_sec_num[0..$level]); } $ret .= "." if $level == 0; return $ret; } sub incr_sec_num { local($level, $l); $level = shift(@_); $_[$level]++; foreach $l ($level+1 .. 3) { $_[$l] = 0; } } sub check { local($_, %seen, %context, $before, $match, $after); while (<>) { if (/\@(\*|\.|\:|\@|\{|\})/) { $seen{$&}++; $context{$&} .= "> $_" if $verbose; $_ = "$`XX$'"; redo; } if (/\@(\w+)/) { ($before, $match, $after) = ($`, $&, $'); if ($before =~ /\b[\w-]+$/ && $after =~ /^[\w-.]*\b/) { # e-mail address $seen{'e-mail address'}++; $context{'e-mail address'} .= "> $_" if $verbose; } else { $seen{$match}++; $context{$match} .= "> $_" if $verbose; } $match =~ s/^\@/X/; $_ = "$before$match$after"; redo; } } foreach (sort(keys(%seen))) { if ($verbose) { print "$_\n"; print $context{$_}; } else { print "$_ ($seen{$_})\n"; } } } sub open { local($name) = @_; ++$fh_name; if (open($fh_name, $name)) { unshift(@fhs, $fh_name); } else { warn "$ERROR Can't read file $name: $!\n"; } } sub init_input { @fhs = (); # hold the file handles to read @input_spool = (); # spooled lines to read $fh_name = 'FH000'; &open($docu); } sub next_line { local($fh, $line); if (@input_spool) { $line = shift(@input_spool); return($line); } while (@fhs) { $fh = $fhs[0]; $line = <$fh>; return($line) if $line; close($fh); shift(@fhs); } return(undef); } # used in pass 1, use &next_line sub skip_until { local($tag) = @_; local($_); while ($_ = &next_line) { return if /^\@end\s+$tag\s*$/; } die "* Failed to find '$tag' after: " . $lines[$#lines]; } # used in pass 1 for l2h use &next_line sub string_until { local($tag) = @_; local($_, $string); while ($_ = &next_line) { return $string if /^\@end\s+$tag\s*$/; # $_ =~ s/hbox/mbox/g; $string = $string.$_; } die "* Failed to find '$tag' after: " . $lines[$#lines]; } # # HTML stacking to have a better HTML output # sub html_reset { @html_stack = ('html'); $html_element = 'body'; } sub html_push { local($what) = @_; push(@html_stack, $html_element); $html_element = $what; } sub html_push_if { local($what) = @_; push(@html_stack, $html_element) if ($html_element && $html_element ne 'P'); $html_element = $what; } sub html_pop { $html_element = pop(@html_stack); } sub html_pop_if { local($elt); if (@_) { foreach $elt (@_) { if ($elt eq $html_element) { $html_element = pop(@html_stack) if @html_stack; last; } } } else { $html_element = pop(@html_stack) if @html_stack; } } sub html_debug { local($what, $line) = @_; return("$what") if $debug & $DEBUG_HTML; return($what); } # to debug the output... sub debug { local($what, $line) = @_; return("$what") if $debug & $DEBUG_HTML; return($what); } sub normalise_node { $_[0] =~ s/\s+/ /g; $_[0] =~ s/ $//; $_[0] =~ s/^ //; } sub menu_entry { local($entry, $node, $descr) = @_; local($href); &normalise_node($node); $href = $node2href{$node}; if ($href) { $descr =~ s/^\s+//; $descr = ": $descr" if $descr; push(@lines2, "
  • " . &anchor('', $href, $entry) . "$descr\n"); } else { warn "$ERROR Undefined node ($node): $_"; } } sub do_ctrl { "^$_[0]" } sub do_email { local($addr, $text) = split(/,\s*/, $_[0]); $text = $addr unless $text; &anchor('', "mailto:$addr", $text); } sub do_sc { # l2h does this much better return &l2h_ToLatex("{\\sc ".&unprotect_html($_[0])."}") if ($l2h); return "\U$_[0]\E"; } sub do_math { return &l2h_ToLatex("\$".&unprotect_html($_[0])."\$") if ($l2h); return "".$text.""; } sub do_uref { local($url, $text) = split(/,\s*/, $_[0]); $text = $url unless $text; &anchor('', $url, $text); } sub do_url { &anchor('', $_[0], $_[0]) } sub apply_style { local($texi_style, $text) = @_; local($style); $style = $style_map{$texi_style}; if (defined($style)) { # known style if ($style =~ /^\"/) { # add quotes $style = $'; $text = "\`$text\'"; } if ($style =~ /^\&/) { # custom $style = $'; $text = &$style($text); } elsif ($style) { # good style $text = "<$style>$text"; } else { # no style } } else { # unknown style $text = undef; } return($text); } # remove Texinfo styles sub remove_style { local($_) = @_; s/\@\w+{([^\{\}]+)}/$1/g; return($_); } sub substitute_style { local($_) = @_; local($changed, $done, $style, $text); $changed = 1; while ($changed) { $changed = 0; $done = ''; while (/\@(\w+){([^\{\}]+)}/) { $text = &apply_style($1, $2); if ($text) { $_ = "$`$text$'"; $changed = 1; } else { $done .= "$`\@$1"; $_ = "{$2}$'"; } } $_ = $done . $_; } return($_); } sub anchor { local($name, $href, $text, $newline) = @_; local($result); $result = "

    \n"; } sub print_header { local($_); # clean the title $_ = &remove_style($_[0]); &unprotect_texi; # print the header if ($doctype eq 'html2') { print FILE $html2_doctype; } elsif ($doctype) { print FILE $doctype; } print FILE < $header $_ EOT } sub print_toplevel_header { local($_); &print_header; # pass given arg... print FILE $full_title; if ($value{'_subtitle'}) { $value{'_subtitle'} =~ s/\n+$//; foreach (split(/\n/, $value{'_subtitle'})) { $_ = &substitute_style($_); &unprotect_texi; print FILE "

    $_

    \n"; } } if ($value{'_author'}) { $value{'_author'} =~ s/\n+$//; foreach (split(/\n/, $value{'_author'})) { $_ = &substitute_style($_); &unprotect_texi; s/[\w.-]+\@[\w.-]+/    $&<\/A>/g; print FILE "
    $_
    \n"; } } print FILE "

    \n"; } sub print_footer { local($_) = $T2H_ADDRESS; if ((defined &custom_address)&&($_)) { print FILE join('', &custom_address($_) , "\n\n\n"); } elsif($_) { print FILE "

    \n$_\n
    " . "\n\n\n"; } else { print FILE "\n\n\n" } } sub print_toplevel_footer { &print_ruler; print FILE <texi2html     $value{texi2html}. EOT &print_footer; } sub protect_texi { # protect @ { } ` ' s/\@\@/$;0/go; s/\@\{/$;1/go; s/\@\}/$;2/go; s/\@\`/$;3/go; s/\@\'/$;4/go; } sub protect_html { local($what) = @_; # protect & < > $what =~ s/\&/\&\#38;/g; $what =~ s/\/\&\#62;/g; # but recognize some HTML things $what =~ s/\&\#60;\/A\&\#62;/<\/A>/g; # $what =~ s/\&\#60;A ([^\&]+)\&\#62;//g; # $what =~ s/\&\#60;IMG ([^\&]+)\&\#62;//g; # return($what); } sub unprotect_texi { s/$;0/\@/go; s/$;1/\{/go; s/$;2/\}/go; s/$;3/\`/go; s/$;4/\'/go; } sub unprotect_html { local($what) = @_; $what =~ s/\&\#38;/\&/g; $what =~ s/\&\#60;/\/g; return($what); } sub byalpha { $key2alpha{$a} cmp $key2alpha{$b}; } ############################################################################## # These next few lines are legal in both Perl and nroff. .00 ; # finish .ig 'di \" finish diversion--previous line must be blank .nr nl 0-1 \" fake up transition to first page again .nr % 0 \" start at page 1 '; __END__ ############# From here on it's a standard manual page ############ .TH TEXI2HTML 1 "01/05/98" .AT 3 .SH NAME texi2html \- a Texinfo to HTML converter .SH SYNOPSIS .B texi2html [options] file .PP .B texi2html -check [-verbose] files .SH DESCRIPTION .I Texi2html converts the given Texinfo file to a set of HTML files. It tries to handle most of the Texinfo commands. It creates hypertext links for cross-references, footnotes... .PP It also tries to add links from a reference to its corresponding entry in the bibliography (if any). It may also handle a glossary (see the .B \-glossary option). .PP .I Texi2html may furthermore use latex2html to generate HTML (code and/or images) for @math and @iftex tags (see the .B \-l2h option). .PP .I Texi2html creates several files depending on the contents of the Texinfo file and on the chosen options (see FILES). .PP The HTML files created by .I texi2html are closer to TeX than to Info, that's why .SH OPTIONS .TP 12 .B \-check Check the given file and give the list of all things that may be Texinfo commands. This may be used to check the output of .I texi2html to find the Texinfo commands that have been left in the HTML file. .TP .B \-expandinfo Expand @ifinfo sections, not @iftex ones. .TP .B \-glossary Use the section named 'Glossary' to build a list of terms and put links in the HTML document from each term toward its definition. .TP .B \-invisible \fIname\fP Use \fIname\fP to create invisible destination anchors for index links (you can for instance use the invisible.xbm file shipped with this program). This is a workaround for a known bug of many WWW browsers, including netscape. .TP .B \-I \fIdir\fP Look also in \fIdir\fP to find included files. .TP .B \-menu Show the Texinfo menus; by default they are ignored. .TP .B \-monolithic Output only one file, including the table of contents and footnotes. .TP .B \-number Number the sections. .TP .B \-split_chapter Split the output into several HTML files (one per main section: chapter, appendix...). .TP .B \-split_node Split the output into several HTML files (one per node). .TP .B \-l2h Use latex2html for content of @math and @tex tags. Content must be such that both, latex and tex, can translate it correctly. I.e., no tex-only constructs must be used. .TP .B \-l2h_latex2html \fIprog\fP Use \fIprog\fP as latex2html program (default \fIlatex2html\fP). Program must be executable. .TP .B \-l2h_init \fIfile\fP Use \fIfile\fP as latex2html init file. \fIfile\fP should be used to specify in which way latex2html handles mathematical expressions and formulas. Note that latex2html locates (and uses) init-files in the following order (provided they exist): (1) global init file (usually in latex2html source dir) (2) $HOME/.latex2html_init (3) ./.latex2html_init (4) init file given on command line. .TP .B \-l2h_dir \fIdir\fP Use \fIdir\fP as tmp dir for latex2html. This directory (resp. its path) must not contain a dot (i.e., a "."). .TP .B \-l2h_keep Keep temporary files which were generated to run latex2html. .TP .B \-l2h_skip Do not really run latex2html. Use (kept) files of previous runs, instead. .TP .B \-usage Print usage instructions, listing the current available command-line options. .TP .B \-verbose Give a verbose output. Can be used with the .B \-check option. .PP .SH FILES By default .I texi2html creates the following files (foo being the name of the Texinfo file): .TP 16 .B foo_toc.html The table of contents. .TP .B foo.html The document's contents. .TP .B foo_foot.html The footnotes (if any). .TP .B foo_l2h_img* Images generated by latex2html (if any). .PP When used with the .B \-split option, it creates several files (one per chapter or node), named .B foo_n.html (n being the index of the chapter or node), instead of the single .B foo.html file. .PP When used with the .B \-monolithic option, it creates only one file: .B foo.html .SH VARIABLES .I texi2html predefines the following variables: \fBhtml\fP, \fBtexi2html\fP. .SH ADDITIONAL COMMANDS .I texi2html implements the following non-Texinfo commands (maybe they are in Texinfo now...): .TP 16 .B @ifhtml This indicates the start of an HTML section, this section will passed through without any modification. .TP .B @end ifhtml This indicates the end of an HTML section. .SH VERSION This is \fItexi2html\fP version 1.56k, 1999-02-20. .PP The latest version of \fItexi2html\fP and \fIlatex22html\fPcan be found in WWW, cf. URLs http://wwwinfo.cern.ch/dis/texi2html/ .br http://texinfo.org/texi2html/ .br http://www-dsed.llnl.gov/files/programs/unix/latex2html .br .SH AUTHOR The main author is Lionel Cons, CERN IT/DIS/OSE, Lionel.Cons@cern.ch. Many other people around the net contributed to this program. .SH COPYRIGHT This program is the intellectual property of the European Laboratory for Particle Physics (known as CERN). No guarantee whatsoever is provided by CERN. No liability whatsoever is accepted for any loss or damage of any kind resulting from any defect or inaccuracy in this information or code. .PP CERN, 1211 Geneva 23, Switzerland .SH "SEE ALSO" GNU Texinfo Documentation Format, HyperText Markup Language (HTML), World Wide Web (WWW). .SH BUGS This program does not understand all Texinfo commands (yet). A row of a mutlicolumn table has to be in one line. .PP TeX specific commands (normally enclosed in @iftex) will be passed over unmodified, unless latex2html is enabled. .ex gtkada-24.0.0/doinstall000077500000000000000000000114601446021174000147500ustar00rootroot00000000000000#!/bin/sh current_dir="`/bin/pwd`" begin_message() { clear cat </dev/null`" if [ "$default_dir" != "" -a "$default_dir" != "." -a "$default_dir" != "/usr/bin" ]; then default_dir="`cd "$default_dir/.."; pwd`" cat </dev/null; then echo "GtkAda cannot be installed in a path that contains spaces." echo "Please enter another directory." basedir="" else if [ "$basedir" = "" ]; then basedir="$default_dir" fi if echo "$basedir" | egrep "^[/~]" >/dev/null; then true else basedir="`pwd`"/"$basedir" fi fi done # Suppress the final / in basedir basedir="`echo "$basedir" | sed -e 's/\/$//'`" # Check that we have permission to write in $basedir if test -d "$basedir"; then if test -w "$basedir"; then if [ -x "$basedir/bin/gtkada" ]; then echo " $basedir/bin/gtkada found." printf " Do you want to overwrite existing installation [Y/n] ? " read x if [ "$x" = "n" -o "$x" = "N" ]; then echo "Aborting the installation process" exit fi fi else echo "You do not have permission to write in $basedir" echo "Please check whether you should be root to install in that directory." echo "Aborting the installation process" exit fi else echo "" echo " Directory $basedir does not exist." printf " Do you want to create it [Y/n] ? " read x if [ "$x" = "n" -o "$x" = "N" ]; then echo "Aborting the installation process" exit fi mkdir -p "$basedir" fi echo "" printf " Are you now ready to proceed with the installation [Y/n] ? " read x if [ "$x" = "n" -o "$x" = "N" ]; then echo "Aborting the installation process" exit fi } ################################## ## Do the actual installation ################################## install_binaries() { echo "Copying the Gtk+ binaries" cp -r "$gtk_bin_dir"/* "$basedir" echo "Setting up the environment" eval `"$basedir"/bin/gtkada-env.sh --print-only` # Update gdkpixbuf loaders cache LD_LIBRARY_PATH=$basedir/lib:$LD_LIBRARY_PATH \ GDK_PIXBUF_MODULE_FILE=$basedir/lib/gdk-pixbuf-2.0/2.10.0/loaders.cache \ GDK_PIXBUF_MODULEDIR=$basedir/lib/gdk-pixbuf-2.0/2.10.0/loaders \ $basedir/bin/gdk-pixbuf-query-loaders --update-cache # Update immodules cache LD_LIBRARY_PATH=$basedir/lib:$LD_LIBRARY_PATH \ GTK_IM_MODULE_FILE=$basedir/lib/gtk-3.0/3.0.0/immodules.cache \ GTK_PATH=$basedir/lib/gtk-3.0 \ $basedir/bin/gtk-query-immodules-3.0 --update-cache echo "Compiling GtkAda" ./configure --prefix="$basedir" && make all install 2>&1 | \ tee install.log # Test for the presence of a gtkada.gpr as check that the install succeeded if [ ! -f "$basedir/lib/gnat/gtkada.gpr" ]; then echo "" echo "An error occurred. Please see install.log.""" exit 1 fi } ## ## Write the end message ## end_message() { clear cat <, since the previous was impossible to guess by the user. Preselect the whole text when editing, so that the user can more easily change it all. NF-17-P722-028 New MDI child signals (2016-07-22) New signals have been introduced in the MDI Signal_Before_Unfloat_Child Signal_Before_Destroy_Child allowing respectively to react before a child is unfloated or destroyed. NF-17-P315-053 Make notebook tabs orientation configurable (2016-03-18) New parameter in Gtkada.MDI.Configure allows controlling the orientation of the notebook tabs. Varians are Automatic, Horizontal, Bottom_To_Top and Top_To_Bottom. NF-17-OC21-020 Additions to Float_Child and Put in Gtkada.MDI (2016-03-08) New parameters allow controlling the position of the child as it is being put in the MDI or when it is being floated. NF-17-J810-010 Improving handling of User_Data (2016-04-15) The following generic packages were modified: Gdk.Event.Handler_Set_User_Data Gtk.Action_Group.Set_Translate_Func_User_Data Gtk.File_Filter.Add_Custom_User_Data Gtk.Widget.Add_Tick_Callback_User_Data The Notify parameter was removed from the public API. Instead, GtkAda will call the Destroy procedure to release User_Data. gtkada-24.0.0/features.old000066400000000000000000000156001446021174000153470ustar00rootroot00000000000000GTKADA NEW FEATURES LIST ======================== Copyright (c) 2010-2011, AdaCore This file contains a list of new features introduced in GtkAda. An ISO date (YYYY-MM-DD) appears in parentheses after the description line. This date shows the implementation date of the feature. New features in GtkAda 17 ------------------------- OC21-020 additions to Gtkada.MDI.Float_Child and Gtkada.MDI.Put New parameters allow controlling the position of the child as it is being put in the MDI or when it is being floated. New features in GtkAda 3.14.1 ----------------------------- O916-009 Gtk.Cell_Layout.Get_Cells returns a Cell_Renderer_List (2015-09-21) This function used to return a generic Object_List, but now returns a more specialized Cell_Renderer_List, which avoids type casts in user code. O317-025 New API for Activating the application under Mac OS (2015-03-17) A new API Glib.Main.Activate_Application can be used to give the focus to the frontmost window of the executable under Mac OS X. N701-030 New API for adding fonts to an application (2015-04-20) A new package Fontconfig has been added, adding an API to add fonts to the application. N606-015 Transition to Gtk 3.14 (2015-03-06) GtkAda now supports Gtk+ 3.14.x. A number of new APIs have been introduced in existing packages. The following new packages have been introduced: Glib.Notification Gtk.Action_Bar Gtk.Event_Controller Gtk.Flow_Box Gtk.Flow_Box_Child Gtk.Gesture (and a number of Gtk.Gesture_*) Gtk.Header_Bar Gtk.List_Box Gtk.Popover Gtk.Revealer Gtk.Stack Gtk.Stack_Switcher New features in GtkAda 3.8.3 ---------------------------- N423-008 Creating signals with return types (2014-04-23) It is now possible to create new signals that return values, when you create new widgets. In particular, when a callback returns a boolean, the propagation of the signal is stopped as soon as one of the callbacks returns True. N326-016 Implementing gtk+ interfaces (2014-03-26) It is now possible to implement gtk+ interfaces (for instance Gtk_Scrollable) when you create new widgets. This required minor changes to Glib.Object.Initialize_Class_Record. N226-019 New widget Gtkada.Canvas_View (2014-03-20) This new widget is a rewrite of Gtkada.Canvas. It provides a cleaner API (clarifying confusion between the various coordinate systems for instance) and has support for creating hierarchies of basic item (text, boxes, polygons,..) to easily create more complex items. New features in GtkAda 3.8.2 ---------------------------- M731-021 Gtkada.MDI limit possible positions of children (2013-07-31) It is now possible, via a new parameter to Gtk_New, to limit whether a child can be put in the central area, on the sides, or both. M723-015 New bindings and Gtk Application enhancement (2013-07-23) New bindings for GApplicationCommandLine, in Glib.Application. New bindings for GOptionContext, GOptionGroup and GOptionEntry, in Glib.Option. New package GtkAda.Application, to support opening files from OS-specific inter-process calls (DDE on Windows, System events on OSX). New features in GtkAda 3.4.1 ---------------------------- L726-002 New On_* procedures to ease signal connection (2012-12-20) Each widget has a number of additional primitives to ease signal connection. For instance, one can use Button.On_Clicked (Handler'Access); now. See the user's guide for more information. LB30-013 New subprogram Gtk.Handlers.Set_On_Exception (2012-11-30) It was always recommended that Ada callbacks should not propagate exceptions to the C gtk+ layer. To enforce this, GtkAda now has its own internal exception handlers. But it is possible for applications to register a subprogram to call when a callback has raised an exception, presumably to log the exception in an application-specific manner (the default is to output the exception on stderr). These handlers are set automatically on signal and event callbacks, and on idle and timeout callbacks. LB20-008 Gtk_New_* as functions (2012-12-17) GtkAda now includes a function for each version of Gtk_New*_, which might be simpler to use in some contexts. In particular, local variables can now be initialized directly in their declarations. L413-025 Binding for Gtk.Recent_Chooser_Menu A new binding for Gtk.Recent_Chooser_Menu has been added. This widget shows a list of recently used resources in menu form. L125-027 Remove support for GNOME widgets (2012-01-25) These widgets were no longer support nor up-to-date with regards to the GNOME libraries themselves, so were removed. New features in GtkAda 2.24.1 ----------------------------- KC08-027 Documentation converted to Sphinx (2011-12-08) The new format provides nicer output, as well as an integrated search facility for the HTML version New features in GtkAda 2.22.0 ----------------------------- K506-019 Binding for GtkSpinner A new binding Gtk.Spinner has been added. A Gtk.Spinner is an animated widget that can be used to signal the user that some program activity is occurring. K422-015 Design changes and preparation for Gtk-3 Gtkada.MDI has been slightly changed so that MDI children now have nicer looking menubars. MDI notebooks now contain a close button that allows the user to close tabs that are not in front. The Gtkada.Canvas widget has been completely redesigned to make use of Cairo instead of Gdk. Its API should now be Gtk-3 ready. Added new Cairo bindings: Cairo.PDF, Cairo.Region, Cairo.SVG. Gdk.Window has also been completed with Cairo bindings. New package Gtkada.Style to provide Gtk.Style-like drawing primitives that use Cairo instead of Gdk. K125-039 Glade-3 GUI builder The GUI builder shipped with GtkAda has been upgraded to Glade-3. JC10-012 MDI: short titles also applies to title bars The MDI can be configured so that floating windows use a short title rather than a full title (in particular, for file names, this will generally be the base name rather than full path name). This preference now also applies to title bars for non-floating windows. JB29-030 MDI: support for independent perspectives It is now possible to configure the MDI so that the perspectives do not share the central area (as a result, no window is preserved when switching among perspectives, unless they are explicitly part of the new perspective). JB09-025 High-level API for using Glade-3 and Gtk.Builder A new package Gtkada.Builder has been introduced. This provides a high-level API for developing GtkAda applications using the Glade-3 GUI builder. JA07-018 Bindings to GTK+ printing API In addition to bindings already added as part of J510-028, additional packages have been provided so that full use of the printing API provided by GTK+ is possible. The existing printing example in testgtk has been enhanced to demonstrate how to use the new API. gtkada-24.0.0/gtk.gpr000066400000000000000000000046741446021174000143410ustar00rootroot00000000000000------------------------------------------------------------------------------ -- GtkAda - Ada95 binding for the Gimp Toolkit -- -- -- -- Copyright (C) 2015-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ abstract project Gtk is Gtk_Prefix := External ("GTK_PREFIX", Gtk'Project_Dir); Gtk_Default_Include := ("-I" & Gtk_Prefix & "/include/gtk-3.0", "-I" & Gtk_Prefix & "/include/atk-1.0", "-I" & Gtk_Prefix & "/include/cairo", "-I" & Gtk_Prefix & "/include/gdk-pixbuf-2.0", "-I" & Gtk_Prefix & "/include/glib-2.0", "-I" & Gtk_Prefix & "/lib/glib-2.0/include", "-I" & Gtk_Prefix & "/include/harfbuzz", "-I" & Gtk_Prefix & "/include/pango-1.0", "-I" & Gtk_Prefix & "/include/pixman-1", "-I" & Gtk_Prefix & "/include/libpng12"); Gtk_Default_Libs := ("-L" & Gtk_Prefix & "/lib", "-L" & Gtk_Prefix & "/bin"); GL_Default_Include := (); GL_Default_Libs := (); end Gtk; gtkada-24.0.0/gtkada_gps.gpr000066400000000000000000000040451446021174000156500ustar00rootroot00000000000000------------------------------------------------------------------------------ -- GtkAda - Ada95 binding for the Gimp Toolkit -- -- -- -- Copyright (C) 2015, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ with "testgtk/testgtk"; with "src/gtkada"; with "src/opengl/opengl"; with "src/tools/tools"; with "gtkada_shared"; with "contrib/contrib"; project GtkAda is for Source_Files use (); for Object_Dir use "src/obj"; package IDE renames GtkAda_Shared.IDE; package Documentation renames GtkAda_Shared.Documentation; end GtkAda; gtkada-24.0.0/gtkada_shared.gpr.in000066400000000000000000000112211446021174000167240ustar00rootroot00000000000000------------------------------------------------------------------------------ -- GtkAda - Ada95 binding for the Gimp Toolkit -- -- -- -- Copyright (C) 2015-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ with "gtk"; project GtkAda_Shared is type Build_Type is ("Debug", "Production"); Build : Build_Type := external ("BUILD", "@BUILD_TYPE@"); type Yes_No is ("yes", "no"); Need_Objective_C : Yes_No := "@NEED_OBJECTIVE_C@"; for Source_Files use (); type Library_Kinds is ("relocatable", "static", "static-pic"); Library_Kind : Library_Kinds := external ("LIBRARY_TYPE", "@DEFAULT_LIBRARY_TYPE@"); type So_Ext_Type is (".so", ".sl", ".dll", ".dylib"); So_Ext : So_Ext_Type := "@SO_EXT@"; Version := "@PACKAGE_VERSION@"; Gtk_Include := Gtk.Gtk_Default_Include & (@GTK_CFLAGS_GPR@); Gtk_Libs := Gtk.Gtk_Default_Libs & (@GTK_LIBS_GPR@); Adaflags := External_As_List ("ADAFLAGS", " "); Cflags := External_As_List ("CFLAGS", " "); Cppflags := External_As_List ("CPPFLAGS", " "); Ldflags := External_As_List ("LDFLAGS", " "); Objcflags := External_As_List ("OBJCFLAGS", " "); package Naming is for Body_Suffix ("Objective-C") use ".m"; end Naming; package Compiler is for Driver ("Objective-C") use "@OBJC@"; for Leading_Required_Switches ("Objective-C") use ("-c"); for PIC_Option ("Objective-C") use ("-fPIC"); for PIC_Option ("C") use ("-fPIC"); case Build is when "Debug" => for Switches ("Ada") use ("-gnatQ", "-gnatwae", "-gnatay", "-g", "-O0"); for Switches ("C") use ("-g", "-O0", "-Wformat", "-Werror=format-security"); when "Production" => for Switches ("Ada") use ("-gnatQ", "-O2", "-gnatn", "-gnatwa", "-gnaty"); for Switches ("C") use ("-O2", "-Wformat", "-Werror=format-security"); end case; for Switches ("C") use Compiler'Switches ("C") & Gtk_Include; for Switches ("Objective-C") use Compiler'Switches ("Objective-C") & Gtk_Include; for Switches ("Ada") use Compiler'Switches ("Ada") & Adaflags; for Switches ("C") use Compiler'Switches ("C") & Cflags & Cppflags; for Switches ("Objective-C") use Compiler'Switches ("Objective-C") & Objcflags & Cppflags; end Compiler; package Builder is for Switches ("Ada") use ("-m"); case Build is when "Debug" => for Global_Configuration_Pragmas use GtkAda_Shared'Project_Dir & "src/gnat_debug.adc"; when "Production" => for Global_Configuration_Pragmas use GtkAda_Shared'Project_Dir & "src/gnat.adc"; end case; end Builder; package Binder is case Build is when "Debug" => for Default_Switches ("Ada") use ("-E"); when "Production" => null; end case; end Binder; package Linker is for Leading_Switches ("Ada") use Ldflags; end Linker; package IDE is for VCS_Kind use "auto"; end IDE; package Documentation is for Documentation_Dir use "html"; end Documentation; end GtkAda_Shared; gtkada-24.0.0/install-sh000077500000000000000000000112451446021174000150360ustar00rootroot00000000000000#! /bin/sh # # install - install a program, script, or datafile # This comes from X11R5. # # Calling this script install-sh is preferred over install.sh, to prevent # `make' implicit rules from creating a file called install from it # when there is no Makefile. # # This script is compatible with the BSD install script, but was written # from scratch. # # set DOITPROG to echo to test this script # Don't use :- since 4.3BSD and earlier shells don't like it. doit="${DOITPROG-}" # put in absolute paths if you don't have them in your path; or use env. vars. mvprog="${MVPROG-mv}" cpprog="${CPPROG-cp}" chmodprog="${CHMODPROG-chmod}" chownprog="${CHOWNPROG-chown}" chgrpprog="${CHGRPPROG-chgrp}" stripprog="${STRIPPROG-strip}" rmprog="${RMPROG-rm}" mkdirprog="${MKDIRPROG-mkdir}" transformbasename="" transform_arg="" instcmd="$mvprog" chmodcmd="$chmodprog 0755" chowncmd="" chgrpcmd="" stripcmd="" rmcmd="$rmprog -f" mvcmd="$mvprog" src="" dst="" dir_arg="" while [ x"$1" != x ]; do case $1 in -c) instcmd="$cpprog" shift continue;; -d) dir_arg=true shift continue;; -m) chmodcmd="$chmodprog $2" shift shift continue;; -o) chowncmd="$chownprog $2" shift shift continue;; -g) chgrpcmd="$chgrpprog $2" shift shift continue;; -s) stripcmd="$stripprog" shift continue;; -t=*) transformarg=`echo $1 | sed 's/-t=//'` shift continue;; -b=*) transformbasename=`echo $1 | sed 's/-b=//'` shift continue;; *) if [ x"$src" = x ] then src=$1 else # this colon is to work around a 386BSD /bin/sh bug : dst=$1 fi shift continue;; esac done if [ x"$src" = x ] then echo "install: no input file specified" exit 1 else true fi if [ x"$dir_arg" != x ]; then dst=$src src="" if [ -d $dst ]; then instcmd=: else instcmd=mkdir fi else # Waiting for this to be detected by the "$instcmd $src $dsttmp" command # might cause directories to be created, which would be especially bad # if $src (and thus $dsttmp) contains '*'. if [ -f $src -o -d $src ] then true else echo "install: $src does not exist" exit 1 fi if [ x"$dst" = x ] then echo "install: no destination specified" exit 1 else true fi # If destination is a directory, append the input filename; if your system # does not like double slashes in filenames, you may need to add some logic if [ -d $dst ] then dst="$dst"/`basename $src` else true fi fi ## this sed command emulates the dirname command dstdir=`echo $dst | sed -e 's,[^/]*$,,;s,/$,,;s,^$,.,'` # Make sure that the destination directory exists. # this part is taken from Noah Friedman's mkinstalldirs script # Skip lots of stat calls in the usual case. if [ ! -d "$dstdir" ]; then defaultIFS=' ' IFS="${IFS-${defaultIFS}}" oIFS="${IFS}" # Some sh's can't handle IFS=/ for some reason. IFS='%' set - `echo ${dstdir} | sed -e 's@/@%@g' -e 's@^%@/@'` IFS="${oIFS}" pathcomp='' while [ $# -ne 0 ] ; do pathcomp="${pathcomp}${1}" shift if [ ! -d "${pathcomp}" ] ; then $mkdirprog "${pathcomp}" else true fi pathcomp="${pathcomp}/" done fi if [ x"$dir_arg" != x ] then $doit $instcmd $dst && if [ x"$chowncmd" != x ]; then $doit $chowncmd $dst; else true ; fi && if [ x"$chgrpcmd" != x ]; then $doit $chgrpcmd $dst; else true ; fi && if [ x"$stripcmd" != x ]; then $doit $stripcmd $dst; else true ; fi && if [ x"$chmodcmd" != x ]; then $doit $chmodcmd $dst; else true ; fi else # If we're going to rename the final executable, determine the name now. if [ x"$transformarg" = x ] then dstfile=`basename $dst` else dstfile=`basename $dst $transformbasename | sed $transformarg`$transformbasename fi # don't allow the sed command to completely eliminate the filename if [ x"$dstfile" = x ] then dstfile=`basename $dst` else true fi # Make a temp file name in the proper directory. dsttmp=$dstdir/#inst.$$# # Move or copy the file name to the temp name $doit $instcmd $src $dsttmp && trap "rm -f ${dsttmp}" 0 && # and set any options; do chmod last to preserve setuid bits # If any of these fail, we abort the whole thing. If we want to # ignore errors from any of these, just make sure not to ignore # errors from the above "$doit $instcmd $src $dsttmp" command. if [ x"$chowncmd" != x ]; then $doit $chowncmd $dsttmp; else true;fi && if [ x"$chgrpcmd" != x ]; then $doit $chgrpcmd $dsttmp; else true;fi && if [ x"$stripcmd" != x ]; then $doit $stripcmd $dsttmp; else true;fi && if [ x"$chmodcmd" != x ]; then $doit $chmodcmd $dsttmp; else true;fi && # Now rename the file to the real destination. $doit $rmcmd -f $dstdir/$dstfile && $doit $mvcmd $dsttmp $dstdir/$dstfile fi && exit 0 gtkada-24.0.0/known-problems-3.14000066400000000000000000000057461446021174000163260ustar00rootroot00000000000000=============================== Known problems in GtkAda 3.14.x =============================== Copyright (C) 2015-2016, AdaCore The following is a listing of known problems in GtkAda 3.14.x Each entry contains a status line stating when the problem was fixed, and on which release(s). In addition, any wavefront issued subsequent to the date specified (in ISO format YYYY-MM-DD) also contains the fix. This can be used to determine if a given release or wavefront has the fix identified in the entry. Note that older releases might or might not be affected by the problems listed in this document. Known problems fixed in GtkAda 17.0 ----------------------------------- KP-314-P411-032 Unable to launch glade Problem: The glade executable does not launch, with messages of the form Unable to load image (Failed to open file '/install/share/glade/pixmaps/plus.png': No such file or directory) Status: This was fixed in GtkAda 17.0 Workaround: Create a symlink from your GtkAda install to . KP-314-OC10-015 Memory leaks in *_foreach Problem: In some cases, gtk+ functions accept some user data, but do not provide a way to know when it can be freed. This resulted in memory leaks. In some cases, we could fix the binding by freeing the no-longer needed user data. However, some functions no longer have a binding, since that would always lead to memory leaks. Here is the full list: gtk.accel_group.find_user_data gtk.builder.connect_signals_full_user_data gtk.clipboard.request_contents_user_data gtk.clipboard.request_image_user_data gtk.clipboard.request_rich_test_user_data gtk.clipboard.request_targets_user_data gtk.clipboard.request_text_user_data gtk.clipboard.request_uris_user_data gtk.main.key_snooper_install_user_data pango.attributes.filter_user_data Status: This was fixed in GtkAda 17.0 Workaround: If you were using these functions, consider storing the user data in a new tagged type derived from the widget. Most of the time this should be applicable. KP-314-OB27-029 GtkProgressBar CSS styling not working Problem: The -GtkProgressBar-min-horizontal-bar-height and -GtkProgressBar-min-vertical-bar-width CSS properties are not taken into account with Gtk 3.14 version. Hard-coded default values are used instead to define the progress bar's size, making it thin by default. Status: This was fixed in GtkAda 17.0 Workaround: None known. KP-314-OB19-053 Wrong binding for Gtk.Tree_Store.Remove Problem: The binding for this function set Iter to null, instead of setting it to a valid iter. Status: This was fixed in GtkAda 17.0 Workaround: None known. gtkada-24.0.0/known-problems.old000066400000000000000000000150171446021174000165100ustar00rootroot00000000000000Known problems fixed in GtkAda 17.0 - OB27-029 GtkProgressBar CSS styling not working Problem: The -GtkProgressBar-min-horizontal-bar-height and -GtkProgressBar-min-vertical-bar-width CSS properties are not taken into account with Gtk 3.14 version. Hard-coded default values are used instead to define the progress bar's size, making it thin by default. Workaround: None known. - OC10-015 Memory leaks in *_foreach Problem: In some cases, gtk+ functions accept some user data, but do not provide a way to know when it can be freed. This resulted in memory leaks. In some cases, we could fix the binding by freeing the no-longer needed user data. However, some functions no longer have a binding, since that would always lead to memory leaks. Here is the full list: gtk.accel_group.find_user_data gtk.builder.connect_signals_full_user_data gtk.clipboard.request_contents_user_data gtk.clipboard.request_image_user_data gtk.clipboard.request_rich_test_user_data gtk.clipboard.request_targets_user_data gtk.clipboard.request_text_user_data gtk.clipboard.request_uris_user_data gtk.main.key_snooper_install_user_data pango.attributes.filter_user_data Workaround: If you were using these functions, consider storing the user data in a new tagged type derived from the widget. Most of the time this should be applicable. - OB19-053 Wrong binding for Gtk.Tree_Store.Remove Problem: The binding for this function set Iter to null, instead of setting it to a valid iter. Workaround: None known. Known problems fixed in GtkAda 3.8.2 - N326-016 Implementing an interface raises gtk+ warnings Problem: When you create custom widgets that implement an interface, for instance GtkScrollable, and add properties, gtk+ complains that you are modifying a class that has already been created. Workaround: The fix involves making sure that when a new GType is created for your custom widget (via Glib.Objects.Initialize_Class_Record) then the class itself is not necessarily created immediately. Unfortunately, this results in a backward incompatibility in the profile of Gtk.Widget.Set_Default_*_Handler. If you are using these function, you will need to pass a Class_Init parameter to Initialize_Class_Record, and override the default handlers in that function. See the example in glib-object.ads - MA02-035 Bad binding of glib's g_strfree_v Problem: The chars_ptr_array access was defined as "in out" which resulted in it being passed by reference by the GNAT compiler, and resulted in memory corruption (glib trying to free wrong memory adresses) Workaround: Pass the parameter as in - M625-039 Redraw problems under Windows Problem: Some items (like tree view expanders, buttons in toolbars) are not drawn or refreshed properly. Workaround: None known. Known problems fixed in GtkAda 3.4.2 - M212-027 Link errors under Windows Problem: When linking a GtkAda program under Windows, an error is raised about a missing -lgtk-win32-3.0/-lgdk-win32-3.0 Workaround: In the directory \lib\, copy libgdk-3.dll.a and libgtk-3.dll.a respectively to libgdk-win32-3.0.dll.a and libgtk-win32-3.0.dll.a. And in the directory \bin, copy libgdk-3.dll and libgtk-3.dll respectively to libgdk-win32-3.0.dll and libgtk-win32-3.0.dll. Known problems fixed in GtkAda 3.4.0 - M617-010 Incorrect binding for Gtk.Widget.Add_Accelerator Problem: The type for Key is incorrect Workaround: Replace the type with Gdk_Key_Type - M110-027 Incorrect binding for Gtk.Tree_Selection.Get_Selected Problem: The new implementation for this function is not backward compatible, and when there is no actual selection will return uninitialized values. Workaround: Use Gtk.Tree_Selection.Count_Selected_Rows to verify that there is indeed a selection before calling Get_Selected. - L615-005 Constraint Error using the GtkAda.Canvas Problem: The GtkAda.Canvas might raise a Constraint_Error when moving the mouse and a button has never been pressed. Workaround: None known. Known problems fixed in GtkAda 2.24.2 - K726-004 Support for dead keys under Windows Problem: Under windows, the dead keys for acute accent and diaeresis, followed by a space, should produce respectively an apostrophe and double quotes. Workaround: No known workaround. Known problems fixed in GtkAda 2.24.2 - KA07-026 Text alignment in Gtk_Plot_Canvas Problem: Under Windows, when displaying text in a Gtk_Plot_Canvas, the base line for digits is not aligned with the base line for text. Workaround: No known workaround. Known problems fixed in GtkAda 2.24.0 - K726-004 Support for dead keys under Windows Problem: Under windows, the dead keys for acute accent and diaeresis, followed by a space, should produce respectively an apostrophe and double quotes. Workaround: No known workaround. - K718-021 X11 resources leak in Gtk.Extra.Plot Problem: The Gtk_Plot widget causes X11 resources leak every time the plot size is changed or the axis are modified. Workaround: No known workaround. Known problems fixed in GtkAda 2.22.0 - JC10-011 Gtkada.MDI gives focus when raising a window Problem: When selecting a floating window via the /Window menu, there were a number of cases where the window was not properly raised (depending on your window manager and system). The MDI will now additionally give the text focus to that window. Workaround: Call Raise_Child manually to make sure the window was raised - JC09-041 Gtk.Widget.Get_Snapshot fails and causes crashes Problem: Calling Gtk.Widget.Get_Snapshot causes memory corruption and potentially crashes. Workaround: Fix the binding to Get_Snapshot: parameter Clip_Rect should be a Gdk.Rectangle.Gdk_Rectangle_Access rather than a Gtk.Rectangle.Gdk_Rectangle. gtkada-24.0.0/m4/000077500000000000000000000000001446021174000133475ustar00rootroot00000000000000gtkada-24.0.0/m4/add_os_specific_flags.m4000066400000000000000000000071671446021174000200760ustar00rootroot00000000000000############################################################# # # Adding some OS specific flags and parameters # ############################################################ AC_DEFUN([AM_ADD_OS_SPECIFIC_FLAGS], [ SO_EXT=.so SO_OPTS=-Wl,-soname, TARGET_LFLAGS= DEFAULT_LIBRARY_TYPE=static NEED_OBJECTIVE_C=no AC_ARG_ENABLE(static, [AC_HELP_STRING( [--disable-static], [Disable building of static libraries.]) AC_HELP_STRING( [--enable-static], [Build static libraries (default).])], [BUILD_STATIC=$enableval if test $enableval = no; then DEFAULT_LIBRARY_TYPE=relocatable fi], [BUILD_STATIC=yes]) AC_ARG_ENABLE(static_pic, [AC_HELP_STRING( [--disable-static-pic], [Disable building of static PIC libraries.]) AC_HELP_STRING( [--enable-static-pic], [Build static PIC libraries (default).])], [BUILD_STATIC_PIC=$enableval if test $enableval = yes; then DEFAULT_LIBRARY_TYPE=static-pic fi], [BUILD_STATIC_PIC=yes]) AC_ARG_ENABLE(shared, [AC_HELP_STRING( [--disable-shared], [Disable building of shared libraries (default is to build them if supported on the target)]) AC_HELP_STRING( [--enable-shared], [Build shared libraries if supported on the target and make them preselected in project files (static libraries are preselected by default])], [CAN_BUILD_SHARED=$enableval if test $enableval = yes; then DEFAULT_LIBRARY_TYPE=relocatable fi], [CAN_BUILD_SHARED=yes]) BUILD_SHARED=$CAN_BUILD_SHARED case $build_os in aix*) BUILD_SHARED=no OS_SPECIFIC_LINK_OPTIONS=-Wl,-bexpall,-berok TARGET_LFLAGS=-Wl,-bbigtoc SO_OPTS="-o " ;; hp*) SO_EXT=.sl SO_OPTS=-Wl,+h, BUILD_SHARED=no ;; *sysv4uw* | *sysv5uw*) SO_OPTS=-Wl,-h, BUILD_SHARED=no ;; *solaris*) SO_OPTS=-Wl,-h, ;; *irix*) ;; *osf*) OS_SPECIFIC_LINK_OPTIONS=-Wl,-expect_unresolved,\* ;; *mingw*) if test x$CAN_BUILD_SHARED = xyes ; then BUILD_SHARED=yes fi SO_EXT=.dll ac_tmp_GNATDIR=`which gcc | sed 's,/gcc$,,'` ac_GNATDIR=`cygpath --mixed $ac_tmp_GNATDIR` count=`cd $ac_GNATDIR; ls libgnat-*.dll | wc -l` if test $count -gt 1 ; then echo "Too many libgnat.dll, in $ac_GNATDIR" echo Found: `cd $ac_GNATDIR; ls libgnat-*.dll` exit 1 fi ac_GNATLIB=`cd $ac_GNATDIR; ls libgnat-*.dll | sed 's,lib,,;s,.dll,,'` OS_SPECIFIC_LINK_OPTIONS=-Wl,-L$ac_GNATDIR,-l$ac_GNATLIB ;; *darwin*) SO_EXT=.dylib NEED_OBJECTIVE_C=yes if test x$CAN_BUILD_SHARED = xyes ; then BUILD_SHARED=yes fi SO_OPTS="-Wl,-undefined,dynamic_lookup -dynamiclib -Wl,-dylib_install_name," LDFLAGS="-Wl,-framework,Cocoa" TARGET_LFLAGS="-Wl,-framework,Cocoa" ;; # ??? The following case has been introduced because of an elaboration # problem with the GtkAda dynamic library and GPS (see E511-010). This # is a workaround, and shall be removed as soon as the bug is fixed. *linux*) case $build_cpu in *ia64*) BUILD_SHARED=no ;; esac ;; esac if test x$BUILD_SHARED = xno ; then if test x$BUILD_STATIC_PIC = xno ; then DEFAULT_LIBRARY_TYPE=static fi fi AC_SUBST(DEFAULT_LIBRARY_TYPE) AC_SUBST(OS_SPECIFIC_LINK_OPTIONS) AC_SUBST(BUILD_STATIC) AC_SUBST(BUILD_STATIC_PIC) AC_SUBST(BUILD_SHARED) AC_SUBST(SO_EXT) AC_SUBST(SO_OPTS) AC_SUBST(TARGET_LFLAGS) AC_SUBST(NEED_OBJECTIVE_C) ] ) gtkada-24.0.0/m4/check_build_type.m4000066400000000000000000000006511446021174000171100ustar00rootroot00000000000000############################################################# # Checking for build type ############################################################# AC_DEFUN([CHECK_BUILD_TYPE], [ AC_ARG_ENABLE(build, [AC_HELP_STRING( [--enable-build=], [Default build type for the library (Debug, Production)])], BUILD_TYPE=$enableval, BUILD_TYPE=Production) AC_SUBST(BUILD_TYPE) ] ) gtkada-24.0.0/m4/gnu_gettext.m4000066400000000000000000000033241446021174000161500ustar00rootroot00000000000000############################################################# # # Macro to add for using GNU gettext # ############################################################# AC_DEFUN([AM_WITH_NLS], [AC_MSG_CHECKING([whether NLS is requested]) dnl Default is enabled NLS AC_ARG_ENABLE(nls, [ --disable-nls do not use Native Language Support], USE_NLS=$enableval, USE_NLS=yes) AC_MSG_RESULT($USE_NLS) AC_SUBST(USE_NLS) GETTEXT_INTL="False" HAVE_GETTEXT="False" dnl If we use NLS figure out what method if test "$USE_NLS" = "yes"; then AC_DEFINE(ENABLE_NLS) dnl Figure out whether gettext is available in the C or intl library. nls_cv_header_intl= nls_cv_header_libgt= AC_CACHE_CHECK([for gettext in libc], gt_cv_func_gettext_libc, [AC_TRY_LINK([extern int gettext(char*);], [return (int) gettext ("")], gt_cv_func_gettext_libc=yes, gt_cv_func_gettext_libc=no)]) if test "$gt_cv_func_gettext_libc" != "yes"; then AC_CHECK_LIB(intl, bindtextdomain, [AC_CACHE_CHECK([for gettext in libintl], gt_cv_func_gettext_libintl, [AC_CHECK_LIB(intl, gettext, gt_cv_func_gettext_libintl=yes, gt_cv_func_gettext_libintl=no)], gt_cv_func_gettext_libintl=no)]) if test "$gt_cv_func_gettext_libintl" = "yes"; then GETTEXT_INTL="True" fi fi if test "$gt_cv_func_gettext_libc" = "yes" \ || test "$gt_cv_func_gettext_libintl" = "yes"; then HAVE_GETTEXT="True" fi fi dnl Make all variables we use known to autoconf. AC_SUBST(GETTEXT_INTL) AC_SUBST(HAVE_GETTEXT) ]) AC_DEFUN([AM_GNU_GETTEXT], [AM_WITH_NLS ]) gtkada-24.0.0/m4/gtk-3.0.m4000066400000000000000000000200431446021174000146730ustar00rootroot00000000000000# Configure paths for GTK+ # Owen Taylor 1997-2001 # Version number used by aclocal, see `info automake Serials`. # Increment on every change. #serial 1 dnl AM_PATH_GTK_3_0([MINIMUM-VERSION, [ACTION-IF-FOUND [, ACTION-IF-NOT-FOUND [, MODULES]]]]) dnl Test for GTK+, and define GTK_CFLAGS and GTK_LIBS, if gthread is specified in MODULES, dnl pass to pkg-config dnl AC_DEFUN([AM_PATH_GTK_3_0], [m4_warn([obsolete], [AM_PATH_GTK_3_0 is deprecated, use PKG_CHECK_MODULES([GTK], [gtk+-3.0]) instead]) dnl Get the cflags and libraries from pkg-config dnl AC_ARG_ENABLE(gtktest, [ --disable-gtktest do not try to compile and run a test GTK+ program], , enable_gtktest=yes) min_gtk_version=ifelse([$1], [], [3.0.0], [$1]) pkg_config_args="gtk+-3.0 >= $min_gtk_version" for module in . $4 do case "$module" in gthread) pkg_config_args="$pkg_config_args gthread-2.0" ;; esac done no_gtk="" PKG_PROG_PKG_CONFIG([0.16]) if test -z "$PKG_CONFIG"; then no_gtk=yes fi AC_MSG_CHECKING(for GTK+ - version >= $min_gtk_version) if test -n "$PKG_CONFIG"; then ## don't try to run the test against uninstalled libtool libs if $PKG_CONFIG --uninstalled $pkg_config_args; then echo "Will use uninstalled version of GTK+ found in PKG_CONFIG_PATH" enable_gtktest=no fi if $PKG_CONFIG $pkg_config_args; then : else no_gtk=yes fi fi if test x"$no_gtk" = x ; then GTK_CFLAGS=`$PKG_CONFIG $pkg_config_args --cflags` GTK_LIBS=`$PKG_CONFIG $pkg_config_args --libs` gtk_config_major_version=`$PKG_CONFIG --modversion gtk+-3.0 | \ sed 's/\([[0-9]]*\).\([[0-9]]*\).\([[0-9]]*\)/\1/'` gtk_config_minor_version=`$PKG_CONFIG --modversion gtk+-3.0 | \ sed 's/\([[0-9]]*\).\([[0-9]]*\).\([[0-9]]*\)/\2/'` gtk_config_micro_version=`$PKG_CONFIG --modversion gtk+-3.0 | \ sed 's/\([[0-9]]*\).\([[0-9]]*\).\([[0-9]]*\)/\3/'` if test "x$enable_gtktest" = "xyes" ; then ac_save_CFLAGS="$CFLAGS" ac_save_LIBS="$LIBS" CFLAGS="$CFLAGS $GTK_CFLAGS" LIBS="$GTK_LIBS $LIBS" dnl dnl Now check if the installed GTK+ is sufficiently new. (Also sanity dnl checks the results of pkg-config to some extent) dnl rm -f conf.gtktest AC_TRY_RUN([ #include #include #include int main () { unsigned int major, minor, micro; fclose (fopen ("conf.gtktest", "w")); if (sscanf("$min_gtk_version", "%u.%u.%u", &major, &minor, µ) != 3) { printf("%s, bad version string\n", "$min_gtk_version"); exit(1); } if ((gtk_major_version != $gtk_config_major_version) || (gtk_minor_version != $gtk_config_minor_version) || (gtk_micro_version != $gtk_config_micro_version)) { printf("\n*** 'pkg-config --modversion gtk+-3.0' returned %d.%d.%d, but GTK+ (%d.%d.%d)\n", $gtk_config_major_version, $gtk_config_minor_version, $gtk_config_micro_version, gtk_major_version, gtk_minor_version, gtk_micro_version); printf ("*** was found! If pkg-config was correct, then it is best\n"); printf ("*** to remove the old version of GTK+. You may also be able to fix the error\n"); printf("*** by modifying your LD_LIBRARY_PATH enviroment variable, or by editing\n"); printf("*** /etc/ld.so.conf. Make sure you have run ldconfig if that is\n"); printf("*** required on your system.\n"); printf("*** If pkg-config was wrong, set the environment variable PKG_CONFIG_PATH\n"); printf("*** to point to the correct configuration files\n"); } else if ((gtk_major_version != GTK_MAJOR_VERSION) || (gtk_minor_version != GTK_MINOR_VERSION) || (gtk_micro_version != GTK_MICRO_VERSION)) { printf("*** GTK+ header files (version %d.%d.%d) do not match\n", GTK_MAJOR_VERSION, GTK_MINOR_VERSION, GTK_MICRO_VERSION); printf("*** library (version %d.%d.%d)\n", gtk_major_version, gtk_minor_version, gtk_micro_version); } else { if ((gtk_major_version > major) || ((gtk_major_version == major) && (gtk_minor_version > minor)) || ((gtk_major_version == major) && (gtk_minor_version == minor) && (gtk_micro_version >= micro))) { return 0; } else { printf("\n*** An old version of GTK+ (%u.%u.%u) was found.\n", gtk_major_version, gtk_minor_version, gtk_micro_version); printf("*** You need a version of GTK+ newer than %u.%u.%u. The latest version of\n", major, minor, micro); printf("*** GTK+ is always available from ftp://ftp.gtk.org.\n"); printf("***\n"); printf("*** If you have already installed a sufficiently new version, this error\n"); printf("*** probably means that the wrong copy of the pkg-config shell script is\n"); printf("*** being found. The easiest way to fix this is to remove the old version\n"); printf("*** of GTK+, but you can also set the PKG_CONFIG environment to point to the\n"); printf("*** correct copy of pkg-config. (In this case, you will have to\n"); printf("*** modify your LD_LIBRARY_PATH enviroment variable, or edit /etc/ld.so.conf\n"); printf("*** so that the correct libraries are found at run-time))\n"); } } return 1; } ],, no_gtk=yes,[echo $ac_n "cross compiling; assumed OK... $ac_c"]) CFLAGS="$ac_save_CFLAGS" LIBS="$ac_save_LIBS" fi fi if test "x$no_gtk" = x ; then AC_MSG_RESULT(yes (version $gtk_config_major_version.$gtk_config_minor_version.$gtk_config_micro_version)) ifelse([$2], , :, [$2]) else AC_MSG_RESULT(no) if test -z "$PKG_CONFIG"; then echo "*** A new enough version of pkg-config was not found." echo "*** See http://pkgconfig.sourceforge.net" else if test -f conf.gtktest ; then : else echo "*** Could not run GTK+ test program, checking why..." ac_save_CFLAGS="$CFLAGS" ac_save_LIBS="$LIBS" CFLAGS="$CFLAGS $GTK_CFLAGS" LIBS="$LIBS $GTK_LIBS" AC_TRY_LINK([ #include #include ], [ return ((gtk_major_version) || (gtk_minor_version) || (gtk_micro_version)); ], [ echo "*** The test program compiled, but did not run. This usually means" echo "*** that the run-time linker is not finding GTK+ or finding the wrong" echo "*** version of GTK+. If it is not finding GTK+, you'll need to set your" echo "*** LD_LIBRARY_PATH environment variable, or edit /etc/ld.so.conf to point" echo "*** to the installed location Also, make sure you have run ldconfig if that" echo "*** is required on your system" echo "***" echo "*** If you have an old version installed, it is best to remove it, although" echo "*** you may also be able to get things to work by modifying LD_LIBRARY_PATH" ], [ echo "*** The test program failed to compile or link. See the file config.log for the" echo "*** exact error that occurred. This usually means GTK+ is incorrectly installed."]) CFLAGS="$ac_save_CFLAGS" LIBS="$ac_save_LIBS" fi fi GTK_CFLAGS="" GTK_LIBS="" ifelse([$3], , :, [$3]) fi AC_SUBST(GTK_CFLAGS) AC_SUBST(GTK_LIBS) rm -f conf.gtktest ]) dnl GTK_CHECK_BACKEND(BACKEND-NAME [, MINIMUM-VERSION [, ACTION-IF-FOUND [, ACTION-IF-NOT-FOUND]]]) dnl Tests for BACKEND-NAME in the GTK targets list dnl AC_DEFUN([GTK_CHECK_BACKEND], [m4_warn([obsolete], [GTK_CHECK_BACKEND is deprecated, use PKG_CHECK_MODULES([GTK_X11], [gtk+-x11-3.0]) or similar instead]) pkg_config_args=ifelse([$1],,gtk+-3.0, gtk+-$1-3.0) min_gtk_version=ifelse([$2],,3.0.0,$2) pkg_config_args="$pkg_config_args >= $min_gtk_version" PKG_PROG_PKG_CONFIG([0.16]) AS_IF([test -z "$PKG_CONFIG"], [AC_MSG_ERROR([No pkg-config found])]) if $PKG_CONFIG $pkg_config_args ; then target_found=yes else target_found=no fi if test "x$target_found" = "xno"; then ifelse([$4],,[AC_MSG_ERROR([Backend $backend not found.])],[$4]) else ifelse([$3],,[:],[$3]) fi ]) gtkada-24.0.0/m4/path_gnat.m4000066400000000000000000000024711446021174000155620ustar00rootroot00000000000000############################################################# # # Checking for Gnat # ############################################################# conftest_ok="conftest.ok" AC_DEFUN([AM_PATH_GNAT], [ AC_PATH_PROG(GPRBUILD, gprbuild, no) AC_PATH_PROG(GPRINSTALL, gprinstall, no) if test x$GPRBUILD = xno ; then AC_MSG_ERROR(I could not find gprbuild. See the file 'INSTALL' for more details.) fi AC_MSG_CHECKING(that your gnat compiler works with a simple example) rm -f conftest.adb cat << EOF > conftest.adb with Ada.Text_IO; procedure Conftest is Conftest_Ok : Ada.Text_IO.File_Type; begin Ada.Text_IO.Create (File => Conftest_Ok, Name => "$conftest_ok"); Ada.Text_IO.Close (Conftest_Ok); end Conftest; EOF cat < conftest.gpr project Conftest is for Main use ("conftest.adb"); for Source_Files use ("conftest.adb"); end Conftest; EOF $GPRBUILD -q -P conftest.gpr > /dev/null rm -f auto.cgpr b__conftest.* if ( test ! -x conftest ) then AC_MSG_RESULT(no) AC_MSG_ERROR($GPRBUILD test failed at compile time! Check your configuration.) fi ./conftest if ( test ! -f $conftest_ok ) then AC_MSG_RESULT(no) AC_MSG_ERROR($GPRBUILD test failed at run time! Check your configuration.) fi AC_MSG_RESULT(yes) ]) gtkada-24.0.0/m4/path_gtk.m4000066400000000000000000000016321446021174000154140ustar00rootroot00000000000000############################################################# # # Configure paths for GTK+ # ############################################################# AC_DEFUN([AM_PATH_GTK], [dnl AC_REQUIRE([AM_PATH_GTK_3_0])dnl AM_PATH_GTK_3_0([3.24.24]) GTK_PREFIX=`$PKG_CONFIG gtk+-3.0 --variable=prefix` AC_SUBST(GTK_PREFIX) AM_TO_GPR($GTK_CFLAGS, GTK_CFLAGS_GPR) dnl 'gmodule-2.0' module is needed to link on Linux dnl 'fontconfig' module is needed to link on Windows PKG_CHECK_MODULES([GMODULE], "gmodule-2.0") PKG_CHECK_MODULES([FONTCONFIG], "fontconfig") GTK_LIBS="$GTK_LIBS $GMODULE_LIBS $FONTCONFIG_LIBS" dnl On windows gtk will be embedded along with gtk distrib. In that dnl case we need to adjust switches so that gtkada.gpr packaged in dnl lib/gnat is usable case $build_os in *mingw*) GTK_LIBS="-L../../lib -L../../bin $GTK_LIBS";; esac AM_TO_GPR($GTK_LIBS, GTK_LIBS_GPR) ]) gtkada-24.0.0/m4/to_gpr.m4000066400000000000000000000013021446021174000150770ustar00rootroot00000000000000########################################################################## ## Converts a list of space-separated words into a list suitable for ## inclusion in .gpr files ## $1=the list ## $2=exported name ########################################################################## AC_DEFUN([AM_TO_GPR], [ value=[$1] # Special handling on darwin for gcc 4.5 and 4.7 case "$build_os" in *darwin*) value=`echo $value | sed -e "s/-framework \([[^ ]]*\)/-Wl,-framework -Wl,\1/g"` esac output=$2 result="" for v in $value; do if test "$result" != ""; then result="$result, " fi result="$result\"$v\"" done $2=$result AC_SUBST($2) ]) gtkada-24.0.0/po/000077500000000000000000000000001446021174000134455ustar00rootroot00000000000000gtkada-24.0.0/po/.cvsignore000066400000000000000000000000351446021174000154430ustar00rootroot00000000000000Makefile gtkada.pot fr_FR.po gtkada-24.0.0/po/Makefile.in000066400000000000000000000015161446021174000155150ustar00rootroot00000000000000LANGS = fr_FR MKDIR = mkdir -p CP=cp MV=mv INSTALL = @INSTALL@ INSTALL_PROGRAM = @INSTALL_PROGRAM@ INSTALL_DATA = @INSTALL_DATA@ prefix = @prefix@ localedir = $(prefix)/share/locale all: static: ## Refresh all translations by extracting the strings from the current sources refresh: ./build_skeleton.pl > gtkada.pot ${foreach lang,${LANGS}, \ if [ -f ${lang}.po ]; then true; else ${CP} gtkada.pot ${lang}.po; fi; \ msgmerge --no-wrap --update ${lang}.po gtkada.pot} ## Install the translation files $(LANGS): -msgfmt -o $@.gmo $@.po --statistics --check-header --check-format --check-domain $(MKDIR) $(localedir)/$@/LC_MESSAGES -$(INSTALL_DATA) $@.gmo $(localedir)/$@/LC_MESSAGES/gtkada.mo install: $(LANGS) clean: -$(RM) *.gmo mostlyclean: clean distclean: mostlyclean -$(RM) Makefile maintainer-clean: distclean gtkada-24.0.0/po/README000066400000000000000000000002661446021174000143310ustar00rootroot00000000000000This directory provides the necessary setup to create your own translation files for applications based on GtkAda. See gtkada-intl.ads for more information on internationalization. gtkada-24.0.0/po/build_skeleton.pl000077500000000000000000000043221446021174000170110ustar00rootroot00000000000000#!/usr/bin/env perl use strict; ## If set to 1, all translations are set as empty. Otherwise, the translation ## is the same as the message itself my ($empty_translation) = 1; my (%strings); my (@modules); my ($msg); # Find the list of modules sub analyze_dir () { my ($dir) = shift; local (*DIR); opendir (DIR, $dir); foreach (readdir (DIR)) { if (-d "$dir/$_" && $_ ne '.' && $_ ne '..') { push (@modules, "$dir/$_"); &analyze_dir ("$dir/$_"); } } close (DIR); } &analyze_dir (".."); # Parse each of their source files sub process_modules() { local (*DIR, *FILE); my ($module, $file, $contents, @matches, $str); foreach $module (@modules) { opendir (DIR, $module); while (($file = readdir(DIR))) { if ($file =~ /\.ad[bs]$/) { open (FILE, "$module/$file"); $contents = join ("", ); # Single-line strings @matches = ($contents =~ /[^"]-"([^"\n]+)"/gso); foreach $str (@matches) { ${$strings{$str}}{$file}++; # .= "$file "; } # Multi-line strings: we need to concatenate @matches = ($contents =~ /[^"]-\("([^"][^)]*)/gso); foreach $str (@matches) { $str =~ s/(ASCII\.)?LF/"\\n\"\n \""/g; $str =~ s/"\s*&\s*"//g; $str =~ s/"\s*$//g; ${$strings{$str}}{$file}++; # .= "$file "; } close (FILE); } } closedir (DIR); } } &process_modules; my ($date) = `date +'%Y-%m-%d'`; chomp ($date); print <. -- -- -- ------------------------------------------------------------------------------ -- -- A set of utilities to handle the Cairo_Font_Face type, and the Cairo -- 'toy' text API. -- -- -- 1.8.8 -- Cairo with System; with Gtkada.Types; package Cairo.Font_Face is function Reference (Font_Face : Cairo_Font_Face) return Cairo_Font_Face; -- Font_Face: a Cairo_Font_Face, (may be Null_Font_Face in which case this -- function does nothing). -- -- Increases the reference count on Font_Face by one. This prevents -- Font_Face from being destroyed until a matching call to -- Cairo.Font_Face.Destroy is made. -- -- The number of references to a Cairo_Font_Face can be get using -- Cairo.Font_Face.Get_Reference_Count. -- -- Return value: the referenced Cairo_Font_Face. procedure Destroy (Font_Face : Cairo_Font_Face); -- Font_Face: a Cairo_Font_Face -- -- Decreases the reference count on Font_Face by one. If the result -- is zero, then Font_Face and all associated resources are freed. -- See Cairo.Font_Face.Reference. function Get_Reference_Count (Font_Face : Cairo_Font_Face) return Guint; -- Font_Face: a Cairo_Font_Face -- -- Returns the current reference count of Font_Face. -- -- Return value: the current reference count of Font_Face. If the -- object is a nil object, 0 will be returned. -- -- Since: 1.4 function Status (Font_Face : Cairo_Font_Face) return Cairo_Status; -- Font_Face: a Cairo_Font_Face -- -- Checks whether an error has previously occurred for this -- font face -- -- Return value: Cairo_Status_Success or another error such as -- Cairo_Status_No_Memory. function Get_Type (Font_Face : Cairo_Font_Face) return Cairo_Font_Type; -- Font_Face: a font face -- -- This function returns the type of the backend used to create -- a font face. See Cairo_Font_Type for available types. -- -- Return value: The type of Font_Face. -- -- Since: 1.2 function Get_User_Data (Font_Face : Cairo_Font_Face; Key : access Cairo_User_Data_Key) return System.Address; -- Font_Face: a Cairo_Font_Face -- Key: the address of the Cairo_User_Data_Key the user data was -- attached to -- -- Return user data previously attached to Font_Face using the specified -- key. If no user data has been attached with the given key this -- function returns System.Null_Address. -- -- Return value: the user data previously attached or System.Null_Address. function Set_User_Data (Font_Face : Cairo_Font_Face; Key : access Cairo_User_Data_Key; User_Data : System.Address; Destroy : Cairo_Destroy_Func) return Cairo_Status; -- Font_Face: a Cairo_Font_Face -- Key: the address of a Cairo_User_Data_Key to attach the user data to -- User_Data: the user data to attach to the font face -- Destroy: a Cairo_Destroy_Func which will be called when the -- font face is destroyed or when new user data is attached using the -- same key. -- -- Attach user data to Font_Face. To remove user data from a font face, -- call this function with the key that was used to set it and -- System.Null_Address for data. -- -- Return value: Cairo_Status_Success or Cairo_Status_No_Memory if a -- slot could not be allocated for the user data. function Toy_Font_Face_Create (Family : Gtkada.Types.Chars_Ptr; Slant : Cairo_Font_Slant; Weight : Cairo_Font_Weight) return Cairo_Font_Face; -- Family: a font Family name, encoded in UTF-8 -- Slant: the Slant for the font -- Weight: the Weight for the font -- -- Creates a font face from a triplet of family, slant, and weight. -- These font faces are used in implementation of the the Cairo_Context -- "toy" font API. -- -- If Family is the zero-length string "", the platform-specific default -- family is assumed. The default family then can be queried using -- Toy_Font_Face_Get_Family. -- -- The Cairo_Select_Font_Face function uses this to create font faces. -- See that function for limitations of toy font faces. -- -- Return value: a newly created Cairo_Font_Face. Free with -- Cairo.Font_Face.Destroy when you are done using it. -- -- Since: 1.8 function Toy_Font_Face_Get_Family (Font_Face : Cairo_Font_Face) return Gtkada.Types.Chars_Ptr; -- Font_Face: A toy font face -- -- Gets the familly name of a toy font. -- -- Return value: The family name. This string is owned by the font face -- and remains valid as long as the font face is alive (referenced). -- -- Since: 1.8 function Toy_Font_Face_Get_Slant (Font_Face : Cairo_Font_Face) return Cairo_Font_Slant; -- Font_Face: A toy font face -- -- Gets the slant a toy font. -- -- Return value: The slant value -- -- Since: 1.8 function Toy_Font_Face_Get_Weight (Font_Face : Cairo_Font_Face) return Cairo_Font_Weight; -- Font_Face: A toy font face -- -- Gets the weight a toy font. -- -- Return value: The weight value -- -- Since: 1.8 private pragma Import (C, Reference, "cairo_font_face_reference"); pragma Import (C, Destroy, "cairo_font_face_destroy"); pragma Import (C, Get_Reference_Count, "cairo_font_face_get_reference_count"); pragma Import (C, Status, "cairo_font_face_status"); pragma Import (C, Get_Type, "cairo_font_face_get_type"); pragma Import (C, Get_User_Data, "cairo_font_face_get_user_data"); pragma Import (C, Set_User_Data, "cairo_font_face_set_user_data"); pragma Import (C, Toy_Font_Face_Create, "cairo_toy_font_face_create"); pragma Import (C, Toy_Font_Face_Get_Family, "cairo_toy_font_face_get_family"); pragma Import (C, Toy_Font_Face_Get_Slant, "cairo_toy_font_face_get_slant"); pragma Import (C, Toy_Font_Face_Get_Weight, "cairo_toy_font_face_get_weight"); end Cairo.Font_Face; gtkada-24.0.0/src/cairo-font_options.adb000066400000000000000000000041771446021174000201130ustar00rootroot00000000000000------------------------------------------------------------------------------ -- GtkAda - Ada95 binding for Gtk+/Gnome -- -- -- -- Copyright (C) 2010-2018, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ package body Cairo.Font_Options is ----------- -- Equal -- ----------- function Equal (Options : Cairo_Font_Options; Other : Cairo_Font_Options) return Boolean is function Internal (Options, Other : Cairo_Font_Options) return Gboolean; pragma Import (C, Internal, "cairo_font_options_equal"); begin return Internal (Options, Other) /= 0; end Equal; end Cairo.Font_Options; gtkada-24.0.0/src/cairo-font_options.ads000066400000000000000000000211141446021174000201220ustar00rootroot00000000000000------------------------------------------------------------------------------ -- GtkAda - Ada95 binding for Gtk+/Gnome -- -- -- -- Copyright (C) 2010-2018, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ -- -- A set of utilities to manipulate font options. -- -- -- 1.8.8 -- Cairo package Cairo.Font_Options is function Create return Cairo_Font_Options; -- Allocates a new font options object with all options initialized -- to default values. -- -- Return value: a newly allocated Cairo_Font_Options. Free with -- Cairo.Font_Options.Destroy. If memory cannot be allocated, then a -- special error object is returned where all operations on the object do -- nothing. You can check for this with Cairo.Font_Options.Status. function Copy (Original : Cairo_Font_Options) return Cairo_Font_Options; -- Original: a Cairo_Font_Options -- -- Allocates a new font options object copying the option values from -- original. -- -- Return value: a newly allocated Cairo_Font_Options. Free with -- Cairo.Font_Options.Destroy. If memory cannot be allocated, then a -- special error object is returned where all operations on the object do -- nothing. You can check for this with Cairo.Font_Options.Status. procedure Destroy (Options : Cairo_Font_Options); -- Options: a Cairo_Font_Options -- -- Destroys a Cairo_Font_Options object created with -- Cairo.Font_Options.Create or Cairo.Font_Options.Copy. function Status (Options : Cairo_Font_Options) return Cairo_Status; -- Options: a Cairo_Font_Options -- -- Checks whether an error has previously occurred for this -- font options object -- -- Return value: Cairo_Status_Success or Cairo_Status_No_Memory procedure Merge (Options : Cairo_Font_Options; Other : Cairo_Font_Options); -- Options: a Cairo_Font_Options -- Other: anOther Cairo_Font_Options -- -- Merges non-default options from other into options, replacing -- existing values. This operation can be thought of as somewhat -- similar to compositing other onto options with the operation -- of Cairo_Operation_Over. function Equal (Options : Cairo_Font_Options; Other : Cairo_Font_Options) return Boolean; -- Options: a Cairo_Font_Options -- Other: another Cairo_Font_Options -- -- Compares two font options objects for equality. -- -- Return value: True if all fields of the two font options objects match. -- Note that this function will return False if either object is in -- error. function Hash (Options : Cairo_Font_Options) return Gulong; -- Options: a Cairo_Font_Options -- -- Compute a hash for the font options object; this value will -- be useful when storing an object containing a Cairo_Font_Options -- in a hash table. -- -- Return value: the hash value for the font options object. -- The return value can be cast to a 32-bit type if a -- 32-bit hash value is needed. procedure Set_Antialias (Options : Cairo_Font_Options; Antialias : Cairo_Antialias); -- Options: a Cairo_Font_Options -- Antialias: the new Antialiasing mode -- -- Sets the antialiasing mode for the font options object. This -- specifies the type of antialiasing to do when rendering text. function Get_Antialias (Options : Cairo_Font_Options) return Cairo_Antialias; -- Options: a Cairo_Font_Options -- -- Gets the antialiasing mode for the font options object. -- -- Return value: the antialiasing mode procedure Set_Subpixel_Order (Options : Cairo_Font_Options; Subpixel_Order : Cairo_Subpixel_Order); -- Options: a Cairo_Font_Options -- Subpixel_Order: the new subpixel order -- -- Sets the subpixel order for the font options object. The subpixel -- order specifies the order of color elements within each pixel on -- the display device when rendering with an antialiasing mode of -- Cairo_Antialias_Subpixel. See the documentation for -- Cairo_Subpixel_Order for full details. function Get_Subpixel_Order (Options : Cairo_Font_Options) return Cairo_Subpixel_Order; -- Options: a Cairo_Font_Options -- -- Gets the subpixel order for the font options object. -- See the documentation for Cairo_Subpixel_Order for full details. -- -- Return value: the subpixel order for the font options object procedure Set_Hint_Style (Options : Cairo_Font_Options; Hint_Style : Cairo_Hint_Style); -- Options: a Cairo_Font_Options -- Hint_Style: the new hint style -- -- Sets the hint style for font outlines for the font options object. -- This controls whether to fit font outlines to the pixel grid, -- and if so, whether to optimize for fidelity or contrast. -- See the documentation for Cairo_Hint_Style for full details. function Get_Hint_Style (Options : Cairo_Font_Options) return Cairo_Hint_Style; -- Options: a Cairo_Font_Options -- -- Gets the hint style for font outlines for the font options object. -- See the documentation for Cairo_Hint_Style for full details. -- -- Return value: the hint style for the font options object procedure Set_Hint_Metrics (Options : Cairo_Font_Options; Hint_Metrics : Cairo_Hint_Metrics); -- Options: a Cairo_Font_Options -- Hint_Metrics: the new metrics hinting mode -- -- Sets the metrics hinting mode for the font options object. This -- controls whether metrics are quantized to integer values in -- device units. -- See the documentation for Cairo_Hint_Metrics for full details. function Get_Hint_Metrics (Options : Cairo_Font_Options) return Cairo_Hint_Metrics; -- Options: a Cairo_Font_Options -- -- Gets the metrics hinting mode for the font options object. -- See the documentation for Cairo_Hint_Metrics for full details. -- -- Return value: the metrics hinting mode for the font options object private pragma Import (C, Create, "cairo_font_options_create"); pragma Import (C, Copy, "cairo_font_options_copy"); pragma Import (C, Destroy, "cairo_font_options_destroy"); pragma Import (C, Status, "cairo_font_options_status"); pragma Import (C, Merge, "cairo_font_options_merge"); pragma Import (C, Hash, "cairo_font_options_hash"); pragma Import (C, Set_Antialias, "cairo_font_options_set_antialias"); pragma Import (C, Get_Antialias, "cairo_font_options_get_antialias"); pragma Import (C, Set_Subpixel_Order, "cairo_font_options_set_subpixel_order"); pragma Import (C, Get_Subpixel_Order, "cairo_font_options_get_subpixel_order"); pragma Import (C, Set_Hint_Style, "cairo_font_options_set_hint_style"); pragma Import (C, Get_Hint_Style, "cairo_font_options_get_hint_style"); pragma Import (C, Set_Hint_Metrics, "cairo_font_options_set_hint_metrics"); pragma Import (C, Get_Hint_Metrics, "cairo_font_options_get_hint_metrics"); end Cairo.Font_Options; gtkada-24.0.0/src/cairo-image_surface.adb000066400000000000000000000066101446021174000201560ustar00rootroot00000000000000------------------------------------------------------------------------------ -- GtkAda - Ada95 binding for Gtk+/Gnome -- -- -- -- Copyright (C) 2010-2018, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ package body Cairo.Image_Surface is ---------------------------- -- Create_For_Data_ARGB32 -- ---------------------------- function Create_For_Data_ARGB32 (Data : ARGB32_Array_Access; Width : Gint; Height : Gint) return Cairo_Surface is Stride : constant Gint := Cairo_Format_Stride_For_Width (Format => Cairo_Format_ARGB32, Width => Width); begin return Create_For_Data_Generic (Data (Data'First)'Address, Cairo_Format_ARGB32, Width, Height, Stride); end Create_For_Data_ARGB32; --------------------------- -- Create_For_Data_RGB24 -- --------------------------- function Create_For_Data_RGB24 (Data : RGB24_Array_Access; Width : Gint; Height : Gint) return Cairo_Surface is Stride : constant Gint := Cairo_Format_Stride_For_Width (Format => Cairo_Format_RGB24, Width => Width); begin return Create_For_Data_Generic (Data (Data'First)'Address, Cairo_Format_RGB24, Width, Height, Stride); end Create_For_Data_RGB24; ------------------------ -- Create_For_Data_A8 -- ------------------------ function Create_For_Data_A8 (Data : Byte_Array_Access; Width : Gint; Height : Gint) return Cairo_Surface is Stride : constant Gint := Cairo_Format_Stride_For_Width (Format => Cairo_Format_A8, Width => Width); begin return Create_For_Data_Generic (Data (Data'First)'Address, Cairo_Format_A8, Width, Height, Stride); end Create_For_Data_A8; end Cairo.Image_Surface; gtkada-24.0.0/src/cairo-image_surface.ads000066400000000000000000000263731446021174000202070ustar00rootroot00000000000000------------------------------------------------------------------------------ -- GtkAda - Ada95 binding for Gtk+/Gnome -- -- -- -- Copyright (C) 2010-2018, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ -- -- Image surfaces provide the ability to render to memory buffers either -- allocated by Cairo or by the calling code. The supported image formats are -- those defined in Cairo_Format. -- -- -- 1.8.8 -- Cairo package Cairo.Image_Surface is -- Cairo_Format is used to identify the memory format of -- image data. -- -- New entries may be added in future versions. type Cairo_Format is (Cairo_Format_ARGB32, -- Each pixel is a 32-bit quantity, with -- alpha in the upper 8 bits, then red, then green, then blue. -- The 32-bit quantities are stored native-endian. Pre-multiplied -- alpha is used. (That is, 50 transparent red is 0x80800000, -- not 0x80ff0000.) Cairo_Format_RGB24, -- Each pixel is a 32-bit quantity, with -- the upper 8 bits unused. Red, Green, and Blue are stored -- in the remaining 24 bits in that order. Cairo_Format_A8, -- Each pixel is a 8-bit quantity holding an alpha value. Cairo_Format_A1, -- Each pixel is a 1-bit quantity holding -- an alpha value. Pixels are packed together into 32-bit -- quantities. The ordering of the bits matches the -- endianess of the platform. On a big-endian machine, the -- first pixel is in the uppermost bit, on a little-endian -- machine the first pixel is in the least-significant bit. CAIRO_FORMAT_RGB16_565_Deprecated_Do_Not_Use -- This value is deprecated ); pragma Convention (C, Cairo_Format); type Byte is range 0 .. 255; type ARGB32_Data is record Alpha : Byte; Red : Byte; Green : Byte; Blue : Byte; end record; -- One pixel in ARGB32 format type RGB24_Data is record Red : Byte; Green : Byte; Blue : Byte; end record; -- One pixel in RGB24 format type ARGB32_Array is array (Natural range <>) of ARGB32_Data; type ARGB32_Array_Access is access ARGB32_Array; type RGB24_Array is array (Natural range <>) of RGB24_Data; type RGB24_Array_Access is access RGB24_Array; type Byte_Array is array (Natural range <>) of Byte; type Byte_Array_Access is access Byte_Array; function Create (Format : Cairo_Format; Width : Gint; Height : Gint) return Cairo_Surface; -- Format: Format of pixels in the surface to create -- Width: Width of the surface, in pixels -- Height: Height of the surface, in pixels -- -- Creates an image surface of the specified format and -- dimensions. Initially the surface contents are all -- 0. (Specifically, within each pixel, each color or alpha channel -- belonging to format will be 0. The contents of bits within a pixel, -- but not belonging to the given format are undefined). -- -- Return value: a pointer to the newly created surface. The caller -- owns the surface and should call Cairo.Surface.Destroy when done -- with it. -- -- This function always returns a valid pointer, but it will return a -- pointer to a "nil" surface if an error such as out of memory -- occurs. You can use Cairo.Surface.Status to check for this. function Cairo_Format_Stride_For_Width (Format : Cairo_Format; Width : Gint) return Gint; -- Format: A Cairo_Format value -- Width: The desired Width of an image surface to be created. -- -- This function provides a stride value that will respect all -- alignment requirements of the accelerated image-rendering code -- within cairo. -- -- Return value: the appropriate stride to use given the desired -- format and width, or -1 if either the format is invalid or the width -- too large. -- -- Since: 1.6 function Create_For_Data_Generic (Data : System.Address; Format : Cairo_Format; Width : Gint; Height : Gint; Stride : Gint) return Cairo_Surface; -- Data: a pointer to a buffer supplied by the application in which -- to write contents. This pointer must be suitably aligned for any -- kind of variable, (for example, a pointer returned by malloc). -- Format: the Format of pixels in the buffer -- Width: the Width of the image to be stored in the buffer -- Height: the Height of the image to be stored in the buffer -- Stride: the number of bytes between the start of rows in the -- buffer as allocated. This value should always be computed by -- Cairo_Format_Stride_For_Width before allocating the data -- buffer. -- -- This function is a low-level binding to the C function: see also -- Create_For_Data_[ARGB32|RGB24|A8|A1] -- -- Creates an image surface for the provided pixel data. The output -- buffer must be kept around until the Cairo_Surface is destroyed -- or Cairo.Surface.Finish is called on the surface. The initial -- contents of data will be used as the initial image contents; you -- must explicitly clear the buffer, using, for example, -- Cairo.Rectangle and Cairo.Fill if you want it cleared. -- -- Note that the stride may be larger than Width*bytes_per_pixel to provide -- proper alignment for each pixel and row. This alignment is required to -- allow high-performance rendering within cairo. The correct way to obtain -- a legal stride value is to call Cairo_Format_Stride_For_Width with the -- desired format and maximum image width value, and the use the resulting -- stride value to allocate the data and to create the image surface. See -- Cairo_Format_Stride_For_Width for example code. -- -- Return value: a pointer to the newly created surface. The caller -- owns the surface and should call Cairo.Surface.Destroy when done -- with it. -- -- This function always returns a valid pointer, but it will return a -- pointer to a "nil" surface in the case of an error such as out of -- memory or an invalid stride value. In case of invalid stride value -- the error status of the returned surface will be -- Cairo_Status_Invalid_Stride. You can use -- Cairo.Surface.Status to check for this. -- -- See Cairo.Surface.Set_User_Data for a means of attaching a -- destroy-notification fallback to the surface if necessary. function Create_For_Data_ARGB32 (Data : ARGB32_Array_Access; Width : Gint; Height : Gint) return Cairo_Surface; -- Same as above, working on ARGB32 format. function Create_For_Data_RGB24 (Data : RGB24_Array_Access; Width : Gint; Height : Gint) return Cairo_Surface; -- Same as above, working on RGB24 format. function Create_For_Data_A8 (Data : Byte_Array_Access; Width : Gint; Height : Gint) return Cairo_Surface; -- Same as above, working on A8 format. function Get_Data_Generic (Surface : Cairo_Surface) return System.Address; -- Surface: a Cairo_Image_Surface -- -- Get a pointer to the data of the image surface, for direct -- inspection or modification. -- -- Return value: a pointer to the image data of this surface or -- System.Null_Address if surface is not an image surface, or if -- Cairo.Surface.Finish has been called. -- -- Since: 1.2 function Get_Format (Surface : Cairo_Surface) return Cairo_Format; -- Surface: a Cairo_Image_Surface -- -- Get the format of the surface. -- -- Return value: the format of the surface -- -- Since: 1.2 function Get_Width (Surface : Cairo_Surface) return Gint; -- Surface: a Cairo_Image_Surface -- -- Get the width of the image surface in pixels. -- -- Return value: the width of the surface in pixels. function Get_Height (Surface : Cairo_Surface) return Gint; -- Surface: a Cairo_Image_Surface -- -- Get the height of the image surface in pixels. -- -- Return value: the height of the surface in pixels. function Get_Stride (Surface : Cairo_Surface) return Gint; -- Surface: a Cairo_Image_Surface -- -- Get the stride of the image surface in bytes -- -- Return value: the stride of the image surface in bytes (or 0 if -- surface is not an image surface). The stride is the distance in -- bytes from the beginning of one row of the image data to the -- beginning of the next row. -- -- Since: 1.2 private for Byte'Size use 8; -- Representation working with all endiannesses BOP : constant := System.Bit_Order'Pos (System.Default_Bit_Order); NBOP : constant := 1 - BOP; for ARGB32_Data use record Alpha at BOP * 3 + NBOP * 0 range 0 .. 7; Red at BOP * 2 + NBOP * 1 range 0 .. 7; Green at BOP * 1 + NBOP * 2 range 0 .. 7; Blue at BOP * 0 + NBOP * 3 range 0 .. 7; end record; for RGB24_Data use record Red at BOP * 2 + NBOP * 1 range 0 .. 7; Green at BOP * 1 + NBOP * 2 range 0 .. 7; Blue at BOP * 0 + NBOP * 3 range 0 .. 7; end record; for RGB24_Data'Size use 32; pragma Import (C, Create, "cairo_image_surface_create"); pragma Import (C, Cairo_Format_Stride_For_Width, "cairo_format_stride_for_width"); pragma Import (C, Create_For_Data_Generic, "cairo_image_surface_create_for_data"); pragma Import (C, Get_Data_Generic, "cairo_image_surface_get_data"); pragma Import (C, Get_Format, "cairo_image_surface_get_format"); pragma Import (C, Get_Width, "cairo_image_surface_get_width"); pragma Import (C, Get_Height, "cairo_image_surface_get_height"); pragma Import (C, Get_Stride, "cairo_image_surface_get_stride"); end Cairo.Image_Surface; gtkada-24.0.0/src/cairo-matrix.ads000066400000000000000000000210051446021174000167040ustar00rootroot00000000000000------------------------------------------------------------------------------ -- GtkAda - Ada95 binding for Gtk+/Gnome -- -- -- -- Copyright (C) 2010-2018, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ -- -- Generic matrix operations. -- -- -- 1.8.8 -- Cairo package Cairo.Matrix is procedure Init (Matrix : access Cairo_Matrix; Xx : Gdouble; Yx : Gdouble; Xy : Gdouble; Yy : Gdouble; X0 : Gdouble; Y0 : Gdouble); -- Matrix: a Cairo_Matrix -- Xx: Xx component of the affine transformation -- Yx: Yx component of the affine transformation -- Xy: Xy component of the affine transformation -- Yy: Yy component of the affine transformation -- X0: X translation component of the affine transformation -- Y0: Y translation component of the affine transformation -- -- Sets matrix to be the affine transformation given by -- Xx, Yx, Xy, Yy, X0, Y0. The transformation is given -- by: -- -- X_new = Xx * X + Xy * Y + X0; -- Y_new = Yx * X + Yy * Y + Y0; procedure Init_Identity (Matrix : access Cairo_Matrix); -- Matrix: a Cairo_Matrix -- -- Modifies matrix to be an identity transformation. procedure Init_Translate (Matrix : access Cairo_Matrix; Tx : Gdouble; Ty : Gdouble); -- Matrix: a Cairo_Matrix -- Tx: amount to translate in the X direction -- Ty: amount to translate in the Y direction -- -- Initializes matrix to a transformation that translates by Tx and -- Ty in the X and Y dimensions, respectively. procedure Init_Scale (Matrix : access Cairo_Matrix; Sx : Gdouble; Sy : Gdouble); -- Matrix: a Cairo_Matrix -- Sx: scale factor in the X direction -- Sy: scale factor in the Y direction -- -- Initializes matrix to a transformation that scales by Sx and Sy -- in the X and Y dimensions, respectively. procedure Init_Rotate (Matrix : access Cairo_Matrix; Radians : Gdouble); -- Matrix: a Cairo_Matrix -- Radians: angle of rotation, in Radians. The direction of rotation -- is defined such that positive angles rotate in the direction from -- the positive X axis toward the positive Y axis. With the default -- axis orientation of cairo, positive angles rotate in a clockwise -- direction. -- -- Initialized matrix to a transformation that rotates by radians. procedure Translate (Matrix : access Cairo_Matrix; Tx : Gdouble; Ty : Gdouble); -- Matrix: a Cairo_Matrix -- Tx: amount to translate in the X direction -- Ty: amount to translate in the Y direction -- -- Applies a translation by Tx, Ty to the transformation in -- matrix. The effect of the new transformation is to first translate -- the coordinates by Tx and Ty, then apply the original transformation -- to the coordinates. procedure Scale (Matrix : access Cairo_Matrix; Sx : Gdouble; Sy : Gdouble); -- Matrix: a Cairo_Matrix -- Sx: scale factor in the X direction -- Sy: scale factor in the Y direction -- -- Applies scaling by Sx, Sy to the transformation in matrix. The -- effect of the new transformation is to first scale the coordinates -- by Sx and Sy, then apply the original transformation to the coordinates. procedure Rotate (Matrix : access Cairo_Matrix; Radians : Gdouble); -- Matrix: a Cairo_Matrix -- Radians: angle of rotation, in Radians. The direction of rotation -- is defined such that positive angles rotate in the direction from -- the positive X axis toward the positive Y axis. With the default -- axis orientation of cairo, positive angles rotate in a clockwise -- direction. -- -- Applies rotation by radians to the transformation in matrix. The effect -- of the new transformation is to first rotate the coordinates by radians, -- then apply the original transformation to the coordinates. function Invert (Matrix : access Cairo_Matrix) return Cairo_Status; -- Matrix: a Cairo_Matrix -- -- Changes matrix to be the inverse of its original value. Not -- all transformation matrices have inverses; if the matrix -- collapses points together (it is "degenerate"), -- then it has no inverse and this function will fail. -- -- Returns: If matrix has an inverse, modifies matrix to -- be the inverse matrix and returns Cairo_Status_Success. Otherwise, -- returns Cairo_Status_Invalid_Matrix. procedure Multiply (Result : access Cairo_Matrix; A : access Cairo_Matrix; B : access Cairo_Matrix); -- Result: a Cairo_Matrix in which to store the Result -- A: a Cairo_Matrix -- B: a Cairo_Matrix -- -- Multiplies the affine transformations in a and b together -- and stores the result in result. The effect of the resulting -- transformation is to first apply the transformation in a to the -- coordinates and then apply the transformation in b to the -- coordinates. -- -- It is allowable for result to be identical to either a or b. procedure Transform_Distance (Matrix : access Cairo_Matrix; Dx : access Gdouble; Dy : access Gdouble); -- Matrix: a Cairo_Matrix -- Dx: X component of a distance vector. An in/out parameter -- Dy: Y component of a distance vector. An in/out parameter -- -- Transforms the distance vector (Dx,Dy) by matrix. This is -- similar to Cairo.Matrix.Transform_Point except that the translation -- components of the transformation are ignored. The calculation of -- the returned vector is as follows: -- -- Dx2 = Dx1 * A + Dy1 * C; -- Dy2 = Dx1 * B + Dy1 * D; -- -- Affine transformations are position invariant, so the same vector -- always transforms to the same vector. If (X1,Y1) transforms -- to (X2,Y2) then (X1+Dx1,Y1+Dy1) will transform to -- (X1+Dx2,Y1+Dy2) for all values of X1 and X2. procedure Transform_Point (Matrix : access Cairo_Matrix; X : access Gdouble; Y : access Gdouble); -- Matrix: a Cairo_Matrix -- X: X position. An in/out parameter -- Y: Y position. An in/out parameter -- -- Transforms the point (X, Y) by matrix. private pragma Import (C, Init, "cairo_matrix_init"); pragma Import (C, Init_Identity, "cairo_matrix_init_identity"); pragma Import (C, Init_Translate, "cairo_matrix_init_translate"); pragma Import (C, Init_Scale, "cairo_matrix_init_scale"); pragma Import (C, Init_Rotate, "cairo_matrix_init_rotate"); pragma Import (C, Translate, "cairo_matrix_translate"); pragma Import (C, Scale, "cairo_matrix_scale"); pragma Import (C, Rotate, "cairo_matrix_rotate"); pragma Import (C, Invert, "cairo_matrix_invert"); pragma Import (C, Multiply, "cairo_matrix_multiply"); pragma Import (C, Transform_Distance, "cairo_matrix_transform_distance"); pragma Import (C, Transform_Point, "cairo_matrix_transform_point"); end Cairo.Matrix; gtkada-24.0.0/src/cairo-pattern.ads000066400000000000000000000645351446021174000170740ustar00rootroot00000000000000------------------------------------------------------------------------------ -- GtkAda - Ada95 binding for Gtk+/Gnome -- -- -- -- Copyright (C) 2010-2018, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ -- -- A Cairo_Pattern is the paintbrush with which cairo draws. The primary use -- of patterns is as the source for all cairo drawing operations. -- -- A cairo pattern is created by using one of the many constructors, of the -- form Cairo_Pattern.Create_ or implicitly through -- Cairo.Set_Source_ subprograms. -- -- -- 1.8.8 -- Cairo with System; package Cairo.Pattern is -------------------------------- -- Pattern creation functions -- -------------------------------- -- Cairo_Pattern_Type is used to describe the type of a given pattern. -- -- The type of a pattern is determined by the function used to create -- it. The Cairo.Pattern.Create_Rgb and Cairo.Pattern.Create_Rgba -- functions create Solid patterns. The remaining -- Cairo.Pattern.Create_<> functions map to pattern types in obvious -- ways. -- -- The pattern type can be queried with Cairo.Pattern.Get_Type -- -- Most Cairo_Pattern functions can be called with a pattern of any type, -- (though trying to change the extend or filter for a solid pattern will -- have no effect). A notable exception is Cairo.Pattern.Add_Color_Stop_Rgb -- and Cairo.Pattern.Add_Color_Stop_Rgba which must only be called with -- gradient patterns (either Linear or Radial). Otherwise the pattern will -- be shutdown and put into an error state. -- -- New entries may be added in future versions. -- -- Since: 1.2 type Cairo_Pattern_Type is (Cairo_Pattern_Type_Solid, -- The pattern is a solid (uniform) color. It may be opaque or -- translucent. Cairo_Pattern_Type_Surface, -- The pattern is a based on a surface (an image). Cairo_Pattern_Type_Linear, -- The pattern is a linear gradient. Cairo_Pattern_Type_Radial -- The pattern is a radial gradient. ); pragma Convention (C, Cairo_Pattern_Type); -- Cairo_extend is used to describe how pattern color/alpha will be -- determined for areas "outside" the pattern's natural area, (for -- example, outside the surface bounds or outside the gradient -- geometry). -- -- The default extend mode is CAIRO_EXTEND_NONE for surface patterns -- and CAIRO_EXTEND_PAD for gradient patterns. -- -- New entries may be added in future versions. type Cairo_Extend is (Cairo_Extend_None, -- Pixels outside of the source pattern are fully transparent Cairo_Extend_Repeat, -- The pattern is tiled by repeating Cairo_Extend_Reflect, -- The pattern is tiled by reflecting at the edges (Implemented for -- surface patterns since 1.6) Cairo_Extend_Pad -- Pixels outside of the pattern copy -- the closest pixel from the source (Since 1.2; but only -- implemented for surface patterns since 1.6) ); pragma Convention (C, Cairo_Extend); -- Cairo_filter is used to indicate what filtering should be -- applied when reading pixel values from patterns. See -- Cairo.Pattern.Set_Source for indicating the desired filter to be -- used with a particular pattern. type Cairo_Filter is (Cairo_Filter_Fast, -- A high-performance filter, with quality similar to -- Cairo_Filter_Nearest Cairo_Filter_Good, -- A reasonable-performance filter, with quality similar to -- Cairo_Filter_Bilinear Cairo_Filter_Best, -- The highest-quality available, performance may -- not be suitable for interactive use. Cairo_Filter_Nearest, -- Nearest-neighbor filtering Cairo_Filter_Bilinear, -- Linear interpolation in two dimensions Cairo_Filter_Gaussian -- This filter value is currently unimplemented, and should not be used -- in current code. ); pragma Convention (C, Cairo_Filter); function Create_Rgb (Red : Gdouble; Green : Gdouble; Blue : Gdouble) return Cairo_Pattern; -- Red: Red component of the color -- Green: Green component of the color -- Blue: Blue component of the color -- -- Creates a new Cairo_Pattern corresponding to an opaque color. The -- color components are floating point numbers in the range 0 to 1. -- If the values passed in are outside that range, they will be -- clamped. -- -- Return value: the newly created Cairo_Pattern if successful, or -- an error pattern in case of no memory. The caller owns the -- returned object and should call Cairo.Pattern.Destroy when -- finished with it. -- -- This function will always return a valid pointer, but if an error -- occurred the pattern status will be set to an error. To inspect -- the status of a pattern use Cairo.Pattern.Status. function Create_Rgba (Red : Gdouble; Green : Gdouble; Blue : Gdouble; Alpha : Gdouble) return Cairo_Pattern; -- Red: Red component of the color -- Green: Green component of the color -- Blue: Blue component of the color -- Alpha: Alpha component of the color -- -- Creates a new Cairo_Pattern corresponding to a translucent color. -- The color components are floating point numbers in the range 0 to -- 1. If the values passed in are outside that range, they will be -- clamped. -- -- Return value: the newly created Cairo_Pattern if successful, or -- an error pattern in case of no memory. The caller owns the -- returned object and should call Cairo.Pattern.Destroy when -- finished with it. -- -- This function will always return a valid pointer, but if an error -- occurred the pattern status will be set to an error. To inspect -- the status of a pattern use Cairo.Pattern.Status. function Create_For_Surface (Surface : Cairo_Surface) return Cairo_Pattern; -- Surface: the Surface -- -- Create a new Cairo_Pattern for the given surface. -- -- Return value: the newly created Cairo_Pattern if successful, or -- an error pattern in case of no memory. The caller owns the -- returned object and should call Cairo.Pattern.Destroy when -- finished with it. -- -- This function will always return a valid pointer, but if an error -- occurred the pattern status will be set to an error. To inspect -- the status of a pattern use Cairo.Pattern.Status. function Create_Linear (X0 : Gdouble; Y0 : Gdouble; X1 : Gdouble; Y1 : Gdouble) return Cairo_Pattern; -- X0: x coordinate of the start point -- Y0: y coordinate of the start point -- X1: x coordinate of the end point -- Y1: y coordinate of the end point -- -- Create a new linear gradient Cairo_Pattern along the line defined -- by (X0, Y0) and (X1, Y1). Before using the gradient pattern, a -- number of color stops should be defined using -- Cairo.Pattern.Add_Color_Stop_Rgb or -- Cairo.Pattern.Add_Color_Stop_Rgba. -- -- Note: The coordinates here are in pattern space. For a new pattern, -- pattern space is identical to user space, but the relationship -- between the spaces can be changed with Cairo.Pattern.Set_Matrix. -- -- Return value: the newly created Cairo_Pattern if successful, or -- an error pattern in case of no memory. The caller owns the -- returned object and should call Cairo.Pattern.Destroy when -- finished with it. -- -- This function will always return a valid pointer, but if an error -- occurred the pattern status will be set to an error. To inspect -- the status of a pattern use Cairo.Pattern.Status. function Create_Radial (Cx0 : Gdouble; Cy0 : Gdouble; Radius0 : Gdouble; Cx1 : Gdouble; Cy1 : Gdouble; Radius1 : Gdouble) return Cairo_Pattern; -- Cx0: X coordinate for the center of the start circle -- Cy0: Y coordinate for the center of the start circle -- Radius0: radius of the start circle -- Cx1: X coordinate for the center of the end circle -- Cy1: Y coordinate for the center of the end circle -- Radius1: radius of the end circle -- -- Creates a new radial gradient Cairo_Pattern between the two circles -- defined by (Cx0, Cy0, Radius0) and (Cx1, Cy1, Radius1). Before using the -- gradient pattern, a number of color stops should be defined using -- Cairo.Pattern.Add_Color_Stop_Rgb or Cairo.Pattern.Add_Color_Stop_Rgba. -- -- Note: The coordinates here are in pattern space. For a new pattern, -- pattern space is identical to user space, but the relationship -- between the spaces can be changed with Cairo.Pattern.Set_Matrix. -- -- Return value: the newly created Cairo_Pattern if successful, or -- an error pattern in case of no memory. The caller owns the -- returned object and should call Cairo.Pattern.Destroy when -- finished with it. -- -- This function will always return a valid pointer, but if an error -- occurred the pattern status will be set to an error. To inspect -- the status of a pattern use Cairo.Pattern.Status. function Reference (Pattern : Cairo_Pattern) return Cairo_Pattern; -- Pattern: a Cairo_Pattern -- -- Increases the reference count on pattern by one. This prevents -- pattern from being destroyed until a matching call to -- Cairo.Pattern.Destroy is made. -- -- The number of references to a Cairo_Pattern can be get using -- Cairo.Pattern.Get_Reference_Count. -- -- Return value: the referenced Cairo_Pattern. procedure Destroy (Pattern : Cairo_Pattern); -- Pattern: a Cairo_Pattern -- -- Decreases the reference count on pattern by one. If the result is -- zero, then pattern and all associated resources are freed. See -- Cairo.Pattern.Reference. function Get_Reference_Count (Pattern : Cairo_Pattern) return Guint; -- Pattern: a Cairo_Pattern -- -- Returns the current reference count of pattern. -- -- Return value: the current reference count of pattern. If the -- object is a nil object, 0 will be returned. -- -- Since: 1.4 function Status (Pattern : Cairo_Pattern) return Cairo_Status; -- Pattern: a Cairo_Pattern -- -- Checks whether an error has previously occurred for this -- pattern. -- -- Return value: Cairo_Status_Success, Cairo_Status_No_Memory, or -- Cairo_Status_Pattern_Type_Mismatch. function Get_User_Data (Pattern : Cairo_Pattern; Key : access Cairo_User_Data_Key) return System.Address; -- Pattern: a Cairo_Pattern -- Key: the address of the Cairo_User_Data_Key the user data was -- attached to -- -- Return user data previously attached to pattern using the -- specified key. If no user data has been attached with the given -- key this function returns System.Null_Address. -- -- Return value: the user data previously attached or System.Null_Address. -- -- Since: 1.4 function Set_User_Data (Pattern : Cairo_Pattern; Key : access Cairo_User_Data_Key; User_Data : System.Address; Destroy : Cairo_Destroy_Func) return Cairo_Status; -- Pattern: a Cairo_Pattern -- Key: the address of a Cairo_User_Data_Key to attach the user data to -- User_Data: the user data to attach to the Cairo_Pattern -- Destroy: a Cairo_Destroy_Func which will be called when the -- Cairo_Context is destroyed or when new user data is attached using the -- same key. -- -- Attach user data to pattern. To remove user data from a surface, -- call this function with the key that was used to set it and Null_Address -- for data. -- -- Return value: Cairo_Status_Success or Cairo_Status_No_Memory if a -- slot could not be allocated for the user data. -- -- Since: 1.4 function Get_Type (Pattern : Cairo_Pattern) return Cairo_Pattern_Type; -- Pattern: a Cairo_Pattern -- -- This function returns the type a pattern. -- See Cairo_Pattern_Type for available types. -- -- Return value: The type of pattern. -- -- Since: 1.2 procedure Add_Color_Stop_Rgb (Pattern : Cairo_Pattern; Offset : Gdouble; Red : Gdouble; Green : Gdouble; Blue : Gdouble); -- Pattern: a Cairo_Pattern -- Offset: an Offset in the range [0.0 .. 1.0] -- Red: Red component of color -- Green: Green component of color -- Blue: Blue component of color -- -- Adds an opaque color stop to a gradient pattern. The offset -- specifies the location along the gradient's control vector. For -- example, a linear gradient's control vector is from (X0,Y0) to -- (X1,Y1) while a radial gradient's control vector is from any point -- on the start circle to the corresponding point on the end circle. -- -- The color is specified in the same way as in Cairo.Set_Source_Rgb. -- -- If two (or more) stops are specified with identical offset values, -- they will be sorted according to the order in which the stops are -- added, (stops added earlier will compare less than stops added -- later). This can be useful for reliably making sharp color -- transitions instead of the typical blend. -- -- -- Note: If the pattern is not a gradient pattern, (eg. a linear or -- radial pattern), then the pattern will be put into an error status -- with a status of Cairo_Status_Pattern_Type_Mismatch. procedure Add_Color_Stop_Rgba (Pattern : Cairo_Pattern; Offset : Gdouble; Red : Gdouble; Green : Gdouble; Blue : Gdouble; Alpha : Gdouble); -- Pattern: a Cairo_Pattern -- Offset: an Offset in the range [0.0 .. 1.0] -- Red: Red component of color -- Green: Green component of color -- Blue: Blue component of color -- Alpha: Alpha component of color -- -- Adds a translucent color stop to a gradient pattern. The offset -- specifies the location along the gradient's control vector. For -- example, a linear gradient's control vector is from (x0,y0) to -- (x1,y1) while a radial gradient's control vector is from any point -- on the start circle to the corresponding point on the end circle. -- -- The color is specified in the same way as in Cairo_Set_Source_Rgba. -- -- If two (or more) stops are specified with identical offset values, -- they will be sorted according to the order in which the stops are -- added, (stops added earlier will compare less than stops added -- later). This can be useful for reliably making sharp color -- transitions instead of the typical blend. -- -- Note: If the pattern is not a gradient pattern, (eg. a linear or -- radial pattern), then the pattern will be put into an error status -- with a status of Cairo_Status_Pattern_Type_Mismatch. procedure Set_Matrix (Pattern : Cairo_Pattern; Matrix : access Cairo_Matrix); -- Pattern: a Cairo_Pattern -- Matrix: a Cairo_Matrix -- -- Sets the pattern's transformation matrix to matrix. This matrix is -- a transformation from user space to pattern space. -- -- When a pattern is first created it always has the identity matrix -- for its transformation matrix, which means that pattern space is -- initially identical to user space. -- -- Important: Please note that the direction of this transformation -- matrix is from user space to pattern space. This means that if you -- imagine the flow from a pattern to user space (and on to device -- space), then coordinates in that flow will be transformed by the -- inverse of the pattern matrix. -- -- For example, if you want to make a pattern appear twice as large as -- it does by default the correct code to use is: -- -- Cairo.Matrix.Init_Scale (Matrix, 0.5, 0.5); -- Cairo.Pattern.Set_Matrix (Pattern, Matrix); -- -- Meanwhile, using values of 2.0 rather than 0.5 in the code above -- would cause the pattern to appear at half of its default size. -- -- Also, please note the discussion of the user-space locking -- semantics of Cairo_Set_Source. procedure Get_Matrix (Pattern : Cairo_Pattern; Matrix : access Cairo_Matrix); -- Pattern: a Cairo_Pattern -- Matrix: return value for the Matrix -- -- Stores the pattern's transformation matrix into matrix. procedure Set_Extend (Pattern : Cairo_Pattern; Extend : Cairo_Extend); -- Pattern: a Cairo_Pattern -- Extend: a Cairo_Extend describing how the area outside of the -- pattern will be drawn -- -- Sets the mode to be used for drawing outside the area of a pattern. -- See Cairo_Extend for details on the semantics of each extend -- strategy. -- -- The default extend mode is Cairo_Extend_None for surface patterns -- and Cairo_Extend_PAd for gradient patterns. function Get_Extend (Pattern : Cairo_Pattern) return Cairo_Extend; -- Pattern: a Cairo_Pattern -- -- Gets the current extend mode for a pattern. See Cairo_Extend -- for details on the semantics of each extend strategy. -- -- Return value: the current extend strategy used for drawing the -- pattern. procedure Set_Filter (Pattern : Cairo_Pattern; Filter : Cairo_Filter); -- Pattern: a Cairo_Pattern -- Filter: a Cairo_Filter describing the Filter to use for resizing -- the pattern -- -- Sets the filter to be used for resizing when using this pattern. -- See Cairo_Filter for details on each filter. -- -- Note that you might want to control filtering even when you do not -- have an explicit Cairo_Pattern object, (for example when using -- Cairo_Set_Source_Surface). In these cases, it is convenient to -- use Cairo_Get_Source to get access to the pattern that cairo -- creates implicitly. For example: -- -- Cairo_Set_Source_Surface (Cr, Image, X, Y); -- Cairo.Pattern.Set_Filter (Cairo_Get_Source (Cr), Cairo_Filter_Nearest); function Get_Filter (Pattern : Cairo_Pattern) return Cairo_Filter; -- Pattern: a Cairo_Pattern -- -- Gets the current filter for a pattern. See Cairo_Filter -- for details on each filter. -- -- Return value: the current filter used for resizing the pattern. function Get_Rgba (Pattern : Cairo_Pattern; Red : access Gdouble; Green : access Gdouble; Blue : access Gdouble; Alpha : access Gdouble) return Cairo_Status; -- Pattern: a Cairo_Pattern -- Red: return value for Red component of color, or null -- Green: return value for Green component of color, or null -- Blue: return value for Blue component of color, or null -- Alpha: return value for Alpha component of color, or null -- -- Gets the solid color for a solid color pattern. -- -- Return value: Cairo_Status_Success, or -- Cairo_Status_Pattern_Type_Mismatch if the pattern is not a solid -- color pattern. -- -- Since: 1.4 function Get_Surface (Pattern : Cairo_Pattern; Surface : Cairo_Surface) return Cairo_Status; -- Pattern: a Cairo_Pattern -- Surface: return value for Surface of pattern, or null -- -- Gets the surface of a surface pattern. The reference returned in -- surface is owned by the pattern; the caller should call -- Cairo.Surface.Reference if the surface is to be retained. -- -- Return value: Cairo_Status_Success, or -- Cairo_Status_Pattern_Type_Mismatch if the pattern is not a surface -- pattern. -- -- Since: 1.4 function Get_Color_Stop_Rgba (Pattern : Cairo_Pattern; Index : Gint; Offset : access Gdouble; Red : access Gdouble; Green : access Gdouble; Blue : access Gdouble; Alpha : access Gdouble) return Cairo_Status; -- Pattern: a Cairo_Pattern -- Index: Index of the stop to return data for -- Offset: return value for the Offset of the stop, or null -- Red: return value for Red component of color, or null -- Green: return value for Green component of color, or null -- Blue: return value for Blue component of color, or null -- Alpha: return value for Alpha component of color, or null -- -- Gets the color and offset information at the given index for a -- gradient pattern. Values of index are 0 to 1 less than the number -- returned by Cairo.Pattern.Get_Color_Stop_Count. -- -- Return value: Cairo_Status_Success, or Cairo_Status_Invalid_Index -- if index is not valid for the given pattern. If the pattern is -- not a gradient pattern, Cairo_Status_Pattern_Type_Mismatch is -- returned. -- -- Since: 1.4 function Get_Color_Stop_Count (Pattern : Cairo_Pattern; Count : access Gint) return Cairo_Status; -- Pattern: a Cairo_Pattern -- Count: return value for the number of color stops, or NULL -- -- Gets the number of color stops specified in the given gradient -- pattern. -- -- Return value: Cairo_Status_Success, or -- Cairo_Status_Pattern_Type_Mismatch if pattern is not a gradient -- pattern. -- -- Since: 1.4 function Get_Linear_Points (Pattern : Cairo_Pattern; X0 : access Gdouble; Y0 : access Gdouble; X1 : access Gdouble; Y1 : access Gdouble) return Cairo_Status; -- Pattern: a Cairo_Pattern -- X0: return value for the x coordinate of the first point, or null -- Y0: return value for the y coordinate of the first point, or null -- X1: return value for the x coordinate of the second point, or null -- Y1: return value for the y coordinate of the second point, or null -- -- Gets the gradient endpoints for a linear gradient. -- -- Return value: Cairo_Status_Success, or -- Cairo_Status_Pattern_Type_Mismatch if pattern is not a linear -- gradient pattern. -- -- Since: 1.4 function Get_Radial_Circles (Pattern : Cairo_Pattern; X0 : access Gdouble; Y0 : access Gdouble; R0 : access Gdouble; X1 : access Gdouble; Y1 : access Gdouble; R1 : access Gdouble) return Cairo_Status; -- Pattern: a Cairo_Pattern -- X0: return value for the x coordinate of the center of the first -- circle, or null -- Y0: return value for the y coordinate of the center of the first -- circle, or null -- R0: return value for the radius of the first circle, or null -- X1: return value for the x coordinate of the center of the second -- circle, or null -- Y1: return value for the y coordinate of the center of the second -- circle, or null -- R1: return value for the radius of the second circle, or null -- -- Gets the gradient endpoint circles for a radial gradient, each -- specified as a center coordinate and a radius. -- -- Return value: Cairo_Status_Success, or -- Cairo_Status_Pattern_Type_Mismatch if pattern is not a radial -- gradient pattern. -- -- Since: 1.4 private pragma Import (C, Create_Rgb, "cairo_pattern_create_rgb"); pragma Import (C, Create_Rgba, "cairo_pattern_create_rgba"); pragma Import (C, Create_For_Surface, "cairo_pattern_create_for_surface"); pragma Import (C, Create_Linear, "cairo_pattern_create_linear"); pragma Import (C, Create_Radial, "cairo_pattern_create_radial"); pragma Import (C, Reference, "cairo_pattern_reference"); pragma Import (C, Destroy, "cairo_pattern_destroy"); pragma Import (C, Get_Reference_Count, "cairo_pattern_get_reference_count"); pragma Import (C, Status, "cairo_pattern_status"); pragma Import (C, Get_User_Data, "cairo_pattern_get_user_data"); pragma Import (C, Set_User_Data, "cairo_pattern_set_user_data"); pragma Import (C, Get_Type, "cairo_pattern_get_type"); pragma Import (C, Add_Color_Stop_Rgb, "cairo_pattern_add_color_stop_rgb"); pragma Import (C, Add_Color_Stop_Rgba, "cairo_pattern_add_color_stop_rgba"); pragma Import (C, Set_Matrix, "cairo_pattern_set_matrix"); pragma Import (C, Get_Matrix, "cairo_pattern_get_matrix"); pragma Import (C, Set_Extend, "cairo_pattern_set_extend"); pragma Import (C, Get_Extend, "cairo_pattern_get_extend"); pragma Import (C, Set_Filter, "cairo_pattern_set_filter"); pragma Import (C, Get_Filter, "cairo_pattern_get_filter"); pragma Import (C, Get_Rgba, "cairo_pattern_get_rgba"); pragma Import (C, Get_Surface, "cairo_pattern_get_surface"); pragma Import (C, Get_Color_Stop_Rgba, "cairo_pattern_get_color_stop_rgba"); pragma Import (C, Get_Color_Stop_Count, "cairo_pattern_get_color_stop_count"); pragma Import (C, Get_Linear_Points, "cairo_pattern_get_linear_points"); pragma Import (C, Get_Radial_Circles, "cairo_pattern_get_radial_circles"); end Cairo.Pattern; gtkada-24.0.0/src/cairo-pdf.adb000066400000000000000000000044201446021174000161320ustar00rootroot00000000000000------------------------------------------------------------------------------ -- GtkAda - Ada95 binding for Gtk+/Gnome -- -- -- -- Copyright (C) 2011-2018, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ package body Cairo.PDF is ------------ -- Create -- ------------ function Create (Filename : String; Width_In_Points : Gdouble; Height_In_Points : Gdouble) return Cairo_Surface is function Internal (Filename : System.Address; W, H : Gdouble) return Cairo_Surface; pragma Import (C, Internal, "cairo_pdf_surface_create"); C_Str : constant String := Filename & ASCII.NUL; begin return Internal (C_Str (C_Str'First)'Address, Width_In_Points, Height_In_Points); end Create; end Cairo.PDF; gtkada-24.0.0/src/cairo-pdf.ads000066400000000000000000000054271446021174000161630ustar00rootroot00000000000000------------------------------------------------------------------------------ -- GtkAda - Ada95 binding for Gtk+/Gnome -- -- -- -- Copyright (C) 2011-2018, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ package Cairo.PDF is function Create (Filename : String; Width_In_Points : Gdouble; Height_In_Points : Gdouble) return Cairo_Surface; -- Creates a PDF surface of the specified size in points to be written to -- filename. -- -- filename : -- a filename for the PDF output (must be writable), NULL may be used to -- specify no output. This will generate a PDF surface that may be queried -- and used as a source, without generating a temporary file. -- width_in_points: -- width of the surface, in points (1 point == 1/72.0 inch) -- height_in_points: -- height of the surface, in points (1 point == 1/72.0 inch) -- Returns: -- a pointer to the newly created surface. The caller owns the surface and -- should call cairo_surface_destroy() when done with it. This function -- always returns a valid pointer, but it will return a pointer to a "nil" -- surface if an error such as out of memory occurs. You can use -- cairo_surface_status() to check for this. -- -- Since 1.2 end Cairo.PDF; gtkada-24.0.0/src/cairo-png.adb000066400000000000000000000055761446021174000161620ustar00rootroot00000000000000------------------------------------------------------------------------------ -- GtkAda - Ada95 binding for Gtk+/Gnome -- -- -- -- Copyright (C) 2010-2018, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ package body Cairo.Png is ------------------ -- Write_To_Png -- ------------------ function Write_To_Png (Surface : Cairo_Surface; Filename : String) return Cairo_Status is function C_Cairo_Surface_Write_To_Png (Surface : Cairo_Surface; Filename : System.Address) return Cairo_Status; pragma Import (C, C_Cairo_Surface_Write_To_Png, "cairo_surface_write_to_png"); S : constant String := Filename & ASCII.NUL; begin return C_Cairo_Surface_Write_To_Png (Surface, S (S'First)'Address); end Write_To_Png; --------------------- -- Create_From_Png -- --------------------- function Create_From_Png (Filename : String) return Cairo_Surface is function C_Cairo_Image_Surface_Create_From_Png (Filename : System.Address) return Cairo_Surface; pragma Import (C, C_Cairo_Image_Surface_Create_From_Png, "cairo_image_surface_create_from_png"); S : constant String := Filename & ASCII.NUL; begin return C_Cairo_Image_Surface_Create_From_Png (S (S'First)'Address); end Create_From_Png; end Cairo.Png; gtkada-24.0.0/src/cairo-png.ads000066400000000000000000000064601446021174000161740ustar00rootroot00000000000000------------------------------------------------------------------------------ -- GtkAda - Ada95 binding for Gtk+/Gnome -- -- -- -- Copyright (C) 2010-2018, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ -- -- Reading and writing PNG images. -- -- -- 1.8.8 -- Cairo package Cairo.Png is function Write_To_Png (Surface : Cairo_Surface; Filename : String) return Cairo_Status; -- Surface: a Cairo_Surface with pixel contents -- Filename: the name of a file to write to -- -- Writes the contents of surface to a new file filename as a PNG -- image. -- -- Return value: Cairo_Status_Success if the PNG file was written -- successfully. Otherwise, Cairo_Status_No_Memory if memory could not -- be allocated for the operation or -- Cairo_Status_Surface_Type_Mismatch if the surface does not have -- pixel contents, or Cairo_Status_Write_Error if an I/O error occurs -- while attempting to write the file. function Create_From_Png (Filename : String) return Cairo_Surface; -- Filename: name of PNG file to load -- -- Creates a new image surface and initializes the contents to the -- given PNG file. -- -- Return value: a new Cairo_Surface initialized with the contents -- of the PNG file, or a "nil" surface if any error occurred. A nil -- surface can be checked for with Cairo.Surface.Status (Surface) which -- may return one of the following values: -- -- Cairo_Status_No_Memory -- Cairo_Status_File_Not_Found -- Cairo_Status_Read_Error -- -- Alternatively, you can allow errors to propagate through the drawing -- operations and check the status on the context upon completion -- using Cairo_Status. end Cairo.Png; gtkada-24.0.0/src/cairo-region.adb000066400000000000000000000053341446021174000166510ustar00rootroot00000000000000------------------------------------------------------------------------------ -- GtkAda - Ada95 binding for Gtk+/Gnome -- -- -- -- Copyright (C) 2011-2018, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ package body Cairo.Region is ----------- -- Equal -- ----------- function "=" (A, B : Cairo_Region) return Boolean is function Internal (A, B : Cairo_Region) return Gboolean; pragma Import (C, Internal, "cairo_region_equal"); begin return Internal (A, B) /= 0; end "="; -------------- -- Is_Empty -- -------------- function Is_Empty (Region : Cairo_Region) return Boolean is function Internal (Region : Cairo_Region) return Gboolean; pragma Import (C, Internal, "cairo_region_is_empty"); begin return Internal (Region) /= 0; end Is_Empty; -------------------- -- Contains_Point -- -------------------- function Contains_Point (Region : Cairo_Region; X : Gint; Y : Gint) return Boolean is function Internal (R : Cairo_Region; X, Y : Gint) return Gboolean; pragma Import (C, Internal, "cairo_region_contains_point"); begin return Internal (Region, X, Y) /= 0; end Contains_Point; end Cairo.Region; gtkada-24.0.0/src/cairo-region.ads000066400000000000000000000226631446021174000166760ustar00rootroot00000000000000------------------------------------------------------------------------------ -- GtkAda - Ada95 binding for Gtk+/Gnome -- -- -- -- Copyright (C) 2011-2018, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ -- Regions -- Representing a pixel-aligned area -- -- Bindings to the Cairo 2D graphics library. -- Regions are a simple graphical data type representing an area of integer- -- aligned rectangles. Thay are often used on raster surfaces to track areas -- of interest, such as change or clip areas. -- -- -- 1.10 -- Cairo package Cairo.Region is type Cairo_Region is private; -- A Cairo_Region represents a set of integer-aligned rectangles. -- -- It allows set-theoretical operations like Union and Intersect to be -- performed on them. -- -- Memory management of Cairo_Region is done with Reference and -- Destroy. -- -- Since: 1.10 Null_Region : constant Cairo_Region; type Cairo_Rectangle_Int is record X, Y, Width, Height : aliased Gint; end record; type Cairo_Region_Overlap is (Cairo_Region_Overlap_In, -- Completely inside region Cairo_Region_Overlap_Out, -- Completely outside region Cairo_Region_Overlap_Part -- Partly inside region ); -- Used as the return value for Contains_Rectangle. pragma Convention (C, Cairo_Region_Overlap); function Create return Cairo_Region; -- Allocates a new empty region object. -- -- Returns: A newly allocated Cairo_Region. Free with Destroy. This -- function always returns a valid Cairo_Region; if memory cannot be -- allocated, then a special error object is returned where all operations -- on the object do nothing. You can check for this with Status. function Create_Rectangle (Rectangle : access Cairo_Rectangle_Int) return Cairo_Region; -- Allocates a new region object containing Rectangle. -- -- Returns: A newly allocated Cairo_Region. Free with Destroy. This -- function always returns a valid Cairo_Region; if memory cannot be -- allocated, then a special error object is returned where all operations -- on the object do nothing. You can check for this with Status. function Copy (Original : Cairo_Region) return Cairo_Region; -- Allocates a new Cairo_Region object copying the area from Original. -- -- Returns: A newly allocated Cairo_Region. Free with Destroy. This -- function always returns a valid Cairo_Region; if memory cannot be -- allocated, then a special error object is returned where all operations -- on the object do nothing. You can check for this with Status. function Reference (Region : Cairo_Region) return Cairo_Region; -- Increases the reference count on Region by one. This prefents Region -- from being destroyed until a matching call to Destroy is made. procedure Destroy (Region : Cairo_Region); -- Destroys a Cairo_Region object created with Create, Copy or -- Create_Rectangle. function "=" (A, B : Cairo_Region) return Boolean; -- Compares whether A is equivalent to B. Null_Region as an argument is -- equal to itself, but not to any non-Null_Region region. function Status (Region : Cairo_Region) return Cairo_Status; -- Checks whether an error has occured for this region object. -- -- Returns: Cairo_Status_Success or Cairo_Status_No_Memory procedure Get_Extents (Region : Cairo_Region; Extents : out Cairo_Rectangle_Int); -- Gets the bounding rectangle of Region as a Cairo_Rectangle_Int function Num_Rectangles (Region : Cairo_Region) return Gint; -- Returns the number of rectangle contained in Region procedure Get_Rectangle (Region : Cairo_Region; Nth : Gint; Rectangle : out Cairo_Rectangle_Int); -- Stores the Nth rectangle from the region in Rectangle. function Is_Empty (Region : Cairo_Region) return Boolean; -- Checks whether Region is empty. function Contains_Rectangle (Region : Cairo_Region; Rectangle : access Cairo_Rectangle_Int) return Cairo_Region_Overlap; -- Checks whether Rectangle is inside, outside or partially contained in -- Region function Contains_Point (Region : Cairo_Region; X : Gint; Y : Gint) return Boolean; -- Checks whether (X,Y) is contained in Region. procedure Translate (Region : Cairo_Region; dX : Gint; dY : Gint); -- Translates Region by (dX,dY). function Subtract (Dst : Cairo_Region; Other : Cairo_Region) return Cairo_Status; -- Subtracts Other from Dst and places the result in Dst. -- -- Returns: Cairo_Status_Success or Cairo_Status_No_Memory. function Subtract_Rectangle (Dst : Cairo_Region; Rectangle : access Cairo_Rectangle_Int) return Cairo_Status; -- Subtracts Rectangle from Dst and places the result in Dst. -- -- Returns: Cairo_Status_Success or Cairo_Status_No_Memory. function Intersect (Dst : Cairo_Region; Other : Cairo_Region) return Cairo_Status; -- Computes the intersection of Dst with Other and places the result in Dst -- -- Returns: Cairo_Status_Success or Cairo_Status_No_Memory. function Intersect_Rectangle (Dst : Cairo_Region; Rectangle : access Cairo_Rectangle_Int) return Cairo_Status; -- Computes the intersection of Dst with Rectangle and places the result in -- Dst. -- -- Returns: Cairo_Status_Success or Cairo_Status_No_Memory. function Union (Dst : Cairo_Region; Other : Cairo_Region) return Cairo_Status; -- Computes the union of Dst with Other and places the result in Dst. -- -- Returns: Cairo_Status_Success or Cairo_Status_No_Memory. function Union_Rectangle (Dst : Cairo_Region; Rectangle : access Cairo_Rectangle_Int) return Cairo_Status; -- Computes the union of Dst with Rectangle and places the result in Dst. -- -- Returns: Cairo_Status_Success or Cairo_Status_No_Memory. function Do_Xor (Dst : Cairo_Region; Other : Cairo_Region) return Cairo_Status; -- Computes the exclusive difference of Dst with Other and places the -- result in Dst. -- -- Returns: Cairo_Status_Success or Cairo_Status_No_Memory. function Xor_Rectangle (Dst : Cairo_Region; Rectangle : access Cairo_Rectangle_Int) return Cairo_Status; -- Computes the exclusive difference of Dst with Rectangle and places the -- result in Dst. -- -- Returns: Cairo_Status_Success or Cairo_Status_No_Memory. private pragma Convention (C, Cairo_Rectangle_Int); type Cairo_Region is new System.Address; Null_Region : constant Cairo_Region := Cairo_Region (System.Null_Address); pragma Import (C, Create, "cairo_region_create"); pragma Import (C, Create_Rectangle, "cairo_region_create_rectangle"); pragma Import (C, Copy, "cairo_region_copy"); pragma Import (C, Reference, "cairo_region_reference"); pragma Import (C, Destroy, "cairo_region_destroy"); pragma Import (C, Status, "cairo_region_status"); pragma Import (C, Get_Extents, "cairo_region_get_extents"); pragma Import (C, Num_Rectangles, "cairo_region_num_rectangles"); pragma Import (C, Get_Rectangle, "cairo_region_get_rectangle"); pragma Import (C, Contains_Rectangle, "cairo_region_contains_rectangle"); pragma Import (C, Translate, "cairo_region_translate"); pragma Import (C, Subtract, "cairo_region_subtract"); pragma Import (C, Subtract_Rectangle, "cairo_region_subtract_rectangle"); pragma Import (C, Intersect, "cairo_region_intersect"); pragma Import (C, Intersect_Rectangle, "cairo_region_intersect_rectangle"); pragma Import (C, Union, "cairo_region_union"); pragma Import (C, Union_Rectangle, "cairo_region_union_rectangle"); pragma Import (C, Do_Xor, "cairo_region_xor"); pragma Import (C, Xor_Rectangle, "cairo_region_xor_rectangle"); pragma Inline ("="); pragma Inline (Is_Empty); end Cairo.Region; gtkada-24.0.0/src/cairo-scaled_font.ads000066400000000000000000000221761446021174000176730ustar00rootroot00000000000000------------------------------------------------------------------------------ -- GtkAda - Ada95 binding for Gtk+/Gnome -- -- -- -- Copyright (C) 2010-2018, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ -- -- Utilities for manipulating font faces. -- -- -- 1.8.8 -- Cairo with Gtkada.Types; package Cairo.Scaled_Font is function Reference (Scaled_Font : Cairo_Scaled_Font) return Cairo_Scaled_Font; -- Scaled_Font: a Cairo.Scaled_Font.T, (may be null in which case -- this function does nothing) -- -- Increases the reference count on scaled_font by one. This prevents -- scaled_font from being destroyed until a matching call to -- Cairo.Scaled_Font.Destroy is made. -- -- The number of references to a Cairo_Scaled_Font can be get using -- Cairo.Scaled_Font.Get_Reference_Count. -- -- Returns: the referenced Cairo_Scaled_Font procedure Destroy (Scaled_Font : Cairo_Scaled_Font); -- Scaled_Font: a Cairo_Scaled_Font -- -- Decreases the reference count on font by one. If the result -- is zero, then font and all associated resources are freed. -- See Cairo.Scaled_Font.Reference. function Get_Reference_Count (Scaled_Font : Cairo_Scaled_Font) return Guint; -- Scaled_Font: a Cairo_Scaled_Font -- -- Returns the current reference count of scaled_font. -- -- Return value: the current reference count of scaled_font. If the -- object is a nil object, 0 will be returned. -- -- Since: 1.4 function Status (Scaled_Font : Cairo_Scaled_Font) return Cairo_Status; -- Scaled_Font: a Cairo_Scaled_Font -- -- Checks whether an error has previously occurred for this -- scaled_font. -- -- Return value: Cairo_Status_Success or another error such as -- Cairo_Status_No_Memory. function Get_Type (Scaled_Font : Cairo_Scaled_Font) return Cairo_Font_Type; -- Scaled_Font: a Cairo_Scaled_Font -- -- This function returns the type of the backend used to create -- a scaled font. See Cairo_Font_Type for available types. -- -- Return value: The type of scaled_font. -- -- Since: 1.2 procedure Extents (Scaled_Font : Cairo_Scaled_Font; Extents : access Cairo_Font_Extents); -- Scaled_Font: a Cairo_Scaled_Font -- Extents: a Cairo_Font_Extents which to store the retrieved Extents. -- -- Gets the metrics for a Cairo_Scaled_Font. procedure Text_Extents (Scaled_Font : Cairo_Scaled_Font; Utf8 : Gtkada.Types.Chars_Ptr; Extents : access Cairo_Text_Extents); -- Scaled_Font: a Cairo_Scaled_Font -- Utf8: a NUL-terminated string of text, encoded in UTF-8 -- Extents: a Cairo_Text_Extents which to store the retrieved Extents. -- -- Gets the extents for a string of text. The extents describe a -- user-space rectangle that encloses the "inked" portion of the text -- drawn at the origin (0,0) (as it would be drawn by Cairo_Show_Text -- if the cairo graphics state were set to the same font_face, -- font_matrix, ctm, and font_options as scaled_font). Additionally, -- the x_advance and y_advance values indicate the amount by which the -- current point would be advanced by Cairo_Show_Text. -- -- Note that whitespace characters do not directly contribute to the -- size of the rectangle (extents.width and extents.height). They do -- contribute indirectly by changing the position of non-whitespace -- characters. In particular, trailing whitespace characters are -- likely to not affect the size of the rectangle, though they will -- affect the x_advance and y_advance values. -- -- Since: 1.2 procedure Glyph_Extents (Scaled_Font : Cairo_Scaled_Font; Glyphs : access Cairo_Glyph; Num_Glyphs : Gint; Extents : access Cairo_Text_Extents); -- Scaled_Font: a Cairo_Scaled_Font -- Glyphs: an array of glyph IDs with X and Y offsets. -- Num_Glyphs: the number of glyphs in the glyphs array -- Extents: a Cairo_Text_Extents which to store the retrieved Extents. -- -- Gets the extents for an array of glyphs. The extents describe a -- user-space rectangle that encloses the "inked" portion of the -- glyphs, (as they would be drawn by Cairo.Show_Glyphs if the cairo -- graphics state were set to the same Font_Face, Font_Matrix, Ctm, -- and Font_Options as Scaled_Font). Additionally, the x_advance and -- Y_Advance values indicate the amount by which the current point -- would be advanced by Cairo.Show_Glyphs. -- -- Note that whitespace glyphs do not contribute to the size of the -- rectangle (extents.width and extents.height). function Get_Font_Face (Scaled_Font : Cairo_Scaled_Font) return Cairo_Font_Face; -- Scaled_Font: a Cairo_Scaled_Font -- -- Gets the font face that this scaled font was created for. -- -- Return value: The Cairo_Font_Face with which Scaled_Font was -- created. -- -- Since: 1.2 procedure Get_Font_Matrix (Scaled_Font : Cairo_Scaled_Font; Font_Matrix : access Cairo_Matrix); -- Scaled_Font: a Cairo_Scaled_Font -- Font_Matrix: return value for the matrix -- -- Stores the font matrix with which Scaled_Font was created into -- matrix. -- -- Since: 1.2 procedure Get_Ctm (Scaled_Font : Cairo_Scaled_Font; Ctm : access Cairo_Matrix); -- Scaled_Font: a Cairo_Scaled_Font -- Ctm: return value for the CTM -- -- Stores the CTM with which Scaled_Font was created into Ctm. -- -- Since: 1.2 procedure Get_Scale_Matrix (Scaled_Font : Cairo_Scaled_Font; Scale_Matrix : access Cairo_Matrix); -- Scaled_Font: a Cairo_Scaled_Font -- Scale_Matrix: return value for the matrix -- -- Stores the scale matrix of scaled_font into matrix. -- The scale matrix is product of the font matrix and the ctm -- associated with the scaled font, and hence is the matrix mapping from -- font space to device space. -- -- Since: 1.8 procedure Get_Font_Options (Scaled_Font : Cairo_Scaled_Font; Options : Cairo_Font_Options); -- Scaled_Font: a Cairo_Scaled_Font -- Options: return value for the font Options -- -- Stores the font options with which scaled_font was created into -- options. -- -- Since: 1.2 private pragma Import (C, Reference, "cairo_scaled_font_reference"); pragma Import (C, Destroy, "cairo_scaled_font_destroy"); pragma Import (C, Get_Reference_Count, "cairo_scaled_font_get_reference_count"); pragma Import (C, Status, "cairo_scaled_font_status"); pragma Import (C, Get_Type, "cairo_scaled_font_get_type"); pragma Import (C, Extents, "cairo_scaled_font_extents"); pragma Import (C, Text_Extents, "cairo_scaled_font_text_extents"); pragma Import (C, Glyph_Extents, "cairo_scaled_font_glyph_extents"); pragma Import (C, Get_Font_Face, "cairo_scaled_font_get_font_face"); pragma Import (C, Get_Font_Matrix, "cairo_scaled_font_get_font_matrix"); pragma Import (C, Get_Ctm, "cairo_scaled_font_get_ctm"); pragma Import (C, Get_Scale_Matrix, "cairo_scaled_font_get_scale_matrix"); pragma Import (C, Get_Font_Options, "cairo_scaled_font_get_font_options"); -- Not bound : -- pragma Import (C, Text_To_Glyphs, "cairo_scaled_font_text_to_glyphs"); -- pragma Import (C, Create, "cairo_scaled_font_create"); -- pragma Import (C, Get_User_Data, "cairo_scaled_font_get_user_data"); -- pragma Import (C, Set_User_Data, "cairo_scaled_font_set_user_data"); end Cairo.Scaled_Font; gtkada-24.0.0/src/cairo-surface.adb000066400000000000000000000042141446021174000170120ustar00rootroot00000000000000------------------------------------------------------------------------------ -- GtkAda - Ada95 binding for Gtk+/Gnome -- -- -- -- Copyright (C) 2010-2018, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ package body Cairo.Surface is -------------------------- -- Has_Show_Text_Glyphs -- -------------------------- function Has_Show_Text_Glyphs (Surface : Cairo_Surface) return Boolean is function Internal (Surface : Cairo_Surface) return Gboolean; pragma Import (C, Internal, "cairo_surface_has_show_text_glyphs"); begin return Internal (Surface) /= 0; end Has_Show_Text_Glyphs; end Cairo.Surface; gtkada-24.0.0/src/cairo-surface.ads000066400000000000000000000430041446021174000170330ustar00rootroot00000000000000------------------------------------------------------------------------------ -- GtkAda - Ada95 binding for Gtk+/Gnome -- -- -- -- Copyright (C) 2010-2018, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ -- -- A Cairo_Surface is the abstract type representing all different drawing -- targets that cairo can render to. The actual drawings are performed using a -- Cairo_Context. -- -- -- 1.8.8 -- Cairo with System; package Cairo.Surface is -------------------------- -- Surface manipulation -- -------------------------- type Cairo_Surface_Type is (Cairo_Surface_Type_Image, Cairo_Surface_Type_Pdf, Cairo_Surface_Type_Ps, Cairo_Surface_Type_Xlib, Cairo_Surface_Type_Xcb, Cairo_Surface_Type_Glitz, Cairo_Surface_Type_Quartz, Cairo_Surface_Type_Win32, Cairo_Surface_Type_Beos, Cairo_Surface_Type_Directfb, Cairo_Surface_Type_Svg, Cairo_Surface_Type_Os2, Cairo_Surface_Type_Win32_Printing, Cairo_Surface_Type_Quartz_Image); pragma Convention (C, Cairo_Surface_Type); -- Cairo_Surface_Type is used to describe the type of a given -- surface. The surface types are also known as "backends" or "surface -- backends" within cairo. -- -- The type of a surface is determined by the function used to create -- it, which will generally be of the form -- Cairo._Surface_Create, -- (though see Cairo.Surface.Create_Similar as well). -- -- The surface type can be queried with Cairo.Surface.Get_Type -- -- The various Cairo_surface functions can be used with surfaces of -- any type, but some backends also provide type-specific functions -- that must only be called with a surface of the appropriate -- type. These functions have names that begin with -- Cairo._Surface.* such as -- Cairo.Image_Surface.Get_Width. -- -- The behavior of calling a type-specific function with a surface of -- the wrong type is undefined. -- -- New entries may be added in future versions. -- -- Since: 1.2 function Create_Similar (Other : Cairo_Surface; Content : Cairo_Content; Width : Gint; Height : Gint) return Cairo_Surface; -- Other: an existing surface used to select the backend of the new surface -- Content: the Content for the new surface -- Width: Width of the new surface, (in device-space units) -- Height: Height of the new surface (in device-space units) -- -- Create a new surface that is as compatible as possible with an -- existing surface. For example the new surface will have the same -- fallback resolution and font options as other. Generally, the new -- surface will also use the same backend as other, unless that is -- not possible for some reason. The type of the returned surface may -- be examined with Cairo.Surface.Get_Type. -- -- Initially the surface contents are all 0 (transparent if contents -- have transparency, black otherwise.) -- -- Return value: a pointer to the newly allocated surface. The caller -- owns the surface and should call Cairo.Surface.Destroy when done -- with it. -- -- This function always returns a valid pointer, but it will return a -- pointer to a "nil" surface if other is already in an error state -- or any other error occurs. function Reference (Surface : Cairo_Surface) return Cairo_Surface; -- Surface: a Cairo_Surface -- -- Increases the reference count on surface by one. This prevents -- surface from being destroyed until a matching call to -- Cairo.Surface.Destroy is made. -- -- The number of references to a Cairo_Surface can be get using -- Cairo.Surface.Get_Reference_Count. -- -- Return value: the referenced Cairo_Surface. procedure Finish (Surface : Cairo_Surface); -- Surface: the Cairo_Surface to finish -- -- This function finishes the surface and drops all references to -- external resources. For example, for the Xlib backend it means -- that cairo will no longer access the drawable, which can be freed. -- After calling Cairo.Surface.Finish the only valid operations on a -- surface are getting and setting user, referencing and -- destroying, and flushing and finishing it. -- Further drawing to the surface will not affect the -- surface but will instead trigger a Cairo_Status_Surface_Finished -- error. -- -- When the last call to Cairo.Surface.Destroy decreases the -- reference count to zero, cairo will call Cairo.Surface.Finish if -- it hasn't been called already, before freeing the resources -- associated with the surface. procedure Destroy (Surface : Cairo_Surface); -- Surface: a Cairo_Surface -- -- Decreases the reference count on surface by one. If the result is -- zero, then surface and all associated resources are freed. See -- Cairo.Surface.Reference. function Get_Reference_Count (Surface : Cairo_Surface) return Guint; -- Surface: a Cairo_Surface -- -- Returns the current reference count of surface. -- -- Return value: the current reference count of surface. If the -- object is a nil object, 0 will be returned. -- -- Since: 1.4 function Status (Surface : Cairo_Surface) return Cairo_Status; -- Surface: a Cairo_Surface -- -- Checks whether an error has previously occurred for this -- surface. -- -- Return value: Cairo_Status_Success, Cairo_Status_Null_Pointer, -- Cairo_Status_No_Memory, Cairo_Status_Read_Error, -- Cairo_Status_Invalid_Content, Cairo_Status_Invalid_Format, or -- Cairo_Status_Invalid_Visual. function Get_Type (Surface : Cairo_Surface) return Cairo_Surface_Type; -- Surface: a Cairo_Surface -- -- This function returns the type of the backend used to create -- a surface. See Cairo_Surface_Type for available types. -- -- Return value: The type of surface. -- -- Since: 1.2 function Get_Content (Surface : Cairo_Surface) return Cairo_Content; -- Surface: a Cairo_Surface -- -- This function returns the content type of surface which indicates -- whether the surface contains color and/or alpha information. See -- Cairo_Content. -- -- Return value: The content type of surface. -- -- Since: 1.2 function Get_User_Data (Surface : Cairo_Surface; Key : access Cairo_User_Data_Key) return System.Address; -- Surface: a Cairo_Surface -- Key: the address of the Cairo_User_Data_Key the user data was -- attached to -- -- Return user data previously attached to surface using the specified -- key. If no user data has been attached with the given key this -- function returns null. -- -- Return value: the user data previously attached or null. function Set_User_Data (Surface : Cairo_Surface; Key : access Cairo_User_Data_Key; User_Data : System.Address; Destroy : Cairo_Destroy_Func) return Cairo_Status; -- Surface: a Cairo_Surface -- Key: the address of a Cairo_User_Data_Key to attach the user data to -- User_Data: the user data to attach to the surface -- Destroy: a Cairo_Destroy_Func which will be called when the -- surface is destroyed or when new user data is attached using the -- same key. -- -- Attach user data to surface. To remove user data from a surface, -- call this function with the key that was used to set it and null -- for data. -- -- Return value: Cairo_Status_Success or Cairo_Status_No_Memory if a -- slot could not be allocated for the user data. procedure Get_Font_Options (Surface : Cairo_Surface; Options : access Cairo_Font_Options); -- Surface: a Cairo_Surface -- Options: a Cairo_Font_Options object into which to store -- the retrieved options. All existing values are overwritten -- -- Retrieves the default font rendering options for the surface. -- This allows display surfaces to report the correct subpixel order -- for rendering on them, print surfaces to disable hinting of -- metrics and so forth. The result can then be used with -- Cairo.Scaled_Font.Create. procedure Flush (Surface : Cairo_Surface); -- Surface: a Cairo_Surface -- -- Do any pending drawing for the surface and also restore any -- temporary modification's cairo has made to the surface's -- state. This function must be called before switching from -- drawing on the surface with cairo to drawing on it directly -- with native APIs. If the surface doesn't support direct access, -- then this function does nothing. procedure Mark_Dirty (Surface : Cairo_Surface); -- Surface: a Cairo_Surface -- -- Tells cairo that drawing has been done to surface using means other -- than cairo, and that cairo should reread any cached areas. Note -- that you must call Cairo.Surface.Flush before doing such drawing. procedure Mark_Dirty_Rectangle (Surface : Cairo_Surface; X : Gint; Y : Gint; Width : Gint; Height : Gint); -- Surface: a Cairo_Surface -- X: X coordinate of dirty rectangle -- Y: Y coordinate of dirtY rectangle -- Width: Width of dirty rectangle -- Height: Height of dirty rectangle -- -- Like Cairo.Surface.Mark_Dirty, but drawing has been done only to -- the specified rectangle, so that cairo can retain cached contents -- for other parts of the surface. -- -- Any cached clip set on the surface will be reset by this function, -- to make sure that future cairo calls have the clip set that they -- expect. procedure Set_Device_Offset (Surface : Cairo_Surface; X_Offset : Gdouble; Y_Offset : Gdouble); -- Surface: a Cairo_Surface -- X_Offset: the offset in the X direction, in device units -- Y_Offset: the offset in the Y direction, in device units -- -- Sets an offset that is added to the device coordinates determined -- by the CTM when drawing to surface. One use case for this function -- is when we want to create a Cairo_Surface that redirects drawing -- for a portion of an onscreen surface to an offscreen surface in a -- way that is completely invisible to the user of the cairo -- API. Setting a transformation via Cairo.Translate isn't -- sufficient to do this, since functions like -- Cairo.Device_To_User will expose the hidden offset. -- -- Note that the offset affects drawing to the surface as well as -- using the surface in a source pattern. procedure Get_Device_Offset (Surface : Cairo_Surface; X_Offset : access Gdouble; Y_Offset : access Gdouble); -- Surface: a Cairo_Surface -- X_Offset: the offset in the X direction, in device units -- Y_Offset: the offset in the Y direction, in device units -- -- This function returns the previous device offset set by -- Cairo.Surface.Set_Device_Offset. -- -- Since: 1.2 procedure Set_Fallback_Resolution (Surface : Cairo_Surface; X_Pixels_Per_Inch : Gdouble; Y_Pixels_Per_Inch : Gdouble); -- Surface: a Cairo_Surface -- X_Pixels_Per_Inch: horizontal setting for pixels per inch -- Y_Pixels_Per_Inch: vertical setting for pixels per inch -- -- Set the horizontal and vertical resolution for image fallbacks. -- -- When certain operations aren't supported natively by a backend, -- cairo will fallback by rendering operations to an image and then -- overlaying that image onto the output. For backends that are -- natively vector-oriented, this function can be used to set the -- resolution used for these image fallbacks, (larger values will -- result in more detailed images, but also larger file sizes). -- -- Some examples of natively vector-oriented backends are the ps, pdf, -- and svg backends. -- -- For backends that are natively raster-oriented, image fallbacks are -- still possible, but they are always performed at the native -- device resolution. So this function has no effect on those -- backends. -- -- Note: The fallback resolution only takes effect at the time of -- completing a page (with Cairo.Show_Page or Cairo.Copy_Page) so -- there is currently no way to have more than one fallback resolution -- in effect on a single page. -- -- The default fallback resoultion is 300 pixels per inch in both -- dimensions. -- -- Since: 1.2 procedure Get_Fallback_Resolution (Surface : Cairo_Surface; X_Pixels_Per_Inch : access Gdouble; Y_Pixels_Per_Inch : access Gdouble); -- Surface: a Cairo_Surface -- X_Pixels_Per_Inch: horizontal pixels per inch -- Y_Pixels_Per_Inch: vertical pixels per inch -- -- This function returns the previous fallback resolution set by -- Cairo.Surface.Set_Fallback_Resolution, or default fallback -- resolution if never set. -- -- Since: 1.8 procedure Copy_Page (Surface : Cairo_Surface); -- Surface: a Cairo_Surface -- -- Emits the current page for backends that support multiple pages, -- but doesn't clear it, so that the contents of the current page will -- be retained for the next page. Use Cairo.Surface.Show_Page if you -- want to get an empty page after the emission. -- -- There is a convenience function for this that takes a Cairo_Context, -- namely Cairo.Copy_Page. -- -- Since: 1.6 procedure Show_Page (Surface : Cairo_Surface); -- Surface: a Cairo_Surface -- -- Emits and clears the current page for backends that support multiple -- pages. Use Cairo.Surface.Copy_Page if you don't want to clear the page. -- -- There is a convenience function for this that takes a Cairo_Context, -- namely Cairo_Show_Page. -- -- Since: 1.6 function Has_Show_Text_Glyphs (Surface : Cairo_Surface) return Boolean; -- Surface: a Cairo_Surface -- -- Returns whether the surface supports -- sophisticated Cairo_Show_Text_Glyphs operations. That is, -- whether it actually uses the provided text and cluster data -- to a Cairo_Show_Text_Glyphs call. -- -- Note: Even if this function returns FALSE, a -- Cairo_Show_Text_Glyphs operation targeted at surface will -- still succeed. It just will -- act like a Cairo_Show_Glyphs operation. Users can use this -- function to avoid computing UTF-8 text and cluster mapping if the -- target surface does not use it. -- -- Return value: TRUE if surface supports -- Cairo_Show_Text_Glyphs, FALSE otherwise -- -- Since: 1.8 private pragma Import (C, Create_Similar, "cairo_surface_create_similar"); pragma Import (C, Reference, "cairo_surface_reference"); pragma Import (C, Finish, "cairo_surface_finish"); pragma Import (C, Destroy, "cairo_surface_destroy"); pragma Import (C, Get_Reference_Count, "cairo_surface_get_reference_count"); pragma Import (C, Status, "cairo_surface_status"); pragma Import (C, Get_Type, "cairo_surface_get_type"); pragma Import (C, Get_Content, "cairo_surface_get_content"); pragma Import (C, Get_User_Data, "cairo_surface_get_user_data"); pragma Import (C, Set_User_Data, "cairo_surface_set_user_data"); pragma Import (C, Get_Font_Options, "cairo_surface_get_font_options"); pragma Import (C, Flush, "cairo_surface_flush"); pragma Import (C, Mark_Dirty, "cairo_surface_mark_dirty"); pragma Import (C, Mark_Dirty_Rectangle, "cairo_surface_mark_dirty_rectangle"); pragma Import (C, Set_Device_Offset, "cairo_surface_set_device_offset"); pragma Import (C, Get_Device_Offset, "cairo_surface_get_device_offset"); pragma Import (C, Set_Fallback_Resolution, "cairo_surface_set_fallback_resolution"); pragma Import (C, Get_Fallback_Resolution, "cairo_surface_get_fallback_resolution"); pragma Import (C, Copy_Page, "cairo_surface_copy_page"); pragma Import (C, Show_Page, "cairo_surface_show_page"); end Cairo.Surface; gtkada-24.0.0/src/cairo-svg.adb000066400000000000000000000044131446021174000161620ustar00rootroot00000000000000------------------------------------------------------------------------------ -- GtkAda - Ada95 binding for Gtk+/Gnome -- -- -- -- Copyright (C) 2011-2018, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ package body Cairo.SVG is ------------ -- Create -- ------------ function Create (Filename : String; Width_In_Point : Gdouble; Height_In_Point : Gdouble) return Cairo_Surface is function C_Internal (Filename : System.Address; W, H : Gdouble) return Cairo_Surface; pragma Import (C, C_Internal, "cairo_svg_surface_create"); S : constant String := Filename & ASCII.NUL; begin return C_Internal (S (S'First)'Address, Width_In_Point, Height_In_Point); end Create; end Cairo.SVG; gtkada-24.0.0/src/cairo-svg.ads000066400000000000000000000071451446021174000162100ustar00rootroot00000000000000------------------------------------------------------------------------------ -- GtkAda - Ada95 binding for Gtk+/Gnome -- -- -- -- Copyright (C) 2011-2018, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ package Cairo.SVG is function Create (Filename : String; Width_In_Point : Gdouble; Height_In_Point : Gdouble) return Cairo_Surface; -- Creates a SVG surface of the specified size in points to be written to -- filename. -- -- The SVG surface backend recognizes the following MIME types for the data -- attached to a surface (see Cairo.Surface.Set_Mime_Data) when it is -- used as a source pattern for drawing on this surface: -- CAIRO_MIME_TYPE_JPEG, CAIRO_MIME_TYPE_PNG, CAIRO_MIME_TYPE_URI. If any -- of them is specified, the SVG backend emits a href with the content of -- MIME data instead of a surface snapshot (PNG, Base64-encoded) in the -- corresponding image tag. -- -- The unofficial MIME type CAIRO_MIME_TYPE_URI is examined first. If -- present, the URI is emitted as is: assuring the correctness of URI is -- left to the client code. -- If CAIRO_MIME_TYPE_URI is not present, but CAIRO_MIME_TYPE_JPEG or -- CAIRO_MIME_TYPE_PNG is specified, the corresponding data is -- Base64-encoded and emitted. -- -- filename : -- a filename for the SVG output (must be writable), NULL may be used to -- specify no output. This will generate a SVG surface that may be queried -- and used as a source, without generating a temporary file. -- width_in_points : -- width of the surface, in points (1 point == 1/72.0 inch) -- height_in_points : -- height of the surface, in points (1 point == 1/72.0 inch) -- Returns : -- a pointer to the newly created surface. The caller owns the surface and -- should call Cairo.Surface.Destroy when done with it. This function -- always returns a valid pointer, but it will return a pointer to a "nil" -- surface if an error such as out of memory occurs. You can use -- Cairo.Surface.Status to check for this. -- -- Since 1.2 end Cairo.SVG; gtkada-24.0.0/src/cairo.adb000066400000000000000000000133451446021174000153710ustar00rootroot00000000000000------------------------------------------------------------------------------ -- GtkAda - Ada95 binding for Gtk+/Gnome -- -- -- -- Copyright (C) 2010-2018, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ package body Cairo is ----------------- -- Get_Context -- ----------------- function Get_Context (Value : Glib.Values.GValue) return Cairo_Context is begin return Cairo_Context (Glib.Values.Get_Address (Value)); end Get_Context; -------------- -- Set_Dash -- -------------- procedure Set_Dash (Cr : Cairo_Context; Dashes : Dash_Array; Offset : Gdouble) is procedure C_Set_Dash (Cr : Cairo_Context; Dashes : System.Address; Num_Dashes : Gint; Offset : Gdouble); pragma Import (C, C_Set_Dash, "cairo_set_dash"); Len : constant Natural := Dashes'Length; begin if Len = 0 then C_Set_Dash (Cr, System.Null_Address, 0, Offset); else C_Set_Dash (Cr, Dashes (Dashes'First)'Address, Dashes'Length, Offset); end if; end Set_Dash; -------------- -- Get_Dash -- -------------- procedure Get_Dash (Cr : Cairo_Context; Dashes : out Dash_Array_Access; Offset : out Gdouble) is procedure C_Get_Dash (Cr : Cairo_Context; Dashes : System.Address; Offset : access Gdouble); pragma Import (C, C_Get_Dash, "cairo_get_dash"); Count : constant Integer := Integer (Get_Dash_Count (Cr)); G : aliased Gdouble; begin if Count = 0 then Offset := 0.0; Dashes := null; return; end if; Dashes := new Dash_Array (1 .. Count); C_Get_Dash (Cr, Dashes (Dashes'First)'Address, G'Access); Offset := G; end Get_Dash; ---------------------- -- Select_Font_Face -- ---------------------- procedure Select_Font_Face (Cr : Cairo_Context; Family : String; Slant : Cairo_Font_Slant; Weight : Cairo_Font_Weight) is procedure C_Select_Font_Face (Cr : Cairo_Context; Family : System.Address; Slant : Cairo_Font_Slant; Weight : Cairo_Font_Weight); pragma Import (C, C_Select_Font_Face, "cairo_select_font_face"); Tmp : constant String := Family & ASCII.NUL; begin C_Select_Font_Face (Cr, Tmp'Address, Slant, Weight); end Select_Font_Face; --------------- -- Show_Text -- --------------- procedure Show_Text (Cr : Cairo_Context; Utf8 : String) is procedure C_Show_Text (Cr : Cairo_Context; Utf8 : System.Address); pragma Import (C, C_Show_Text, "cairo_show_text"); Tmp : constant String := Utf8 & ASCII.NUL; begin C_Show_Text (Cr, Tmp'Address); end Show_Text; --------------- -- Text_Path -- --------------- procedure Text_Path (Cr : Cairo_Context; Utf8 : String) is procedure C_Text_Path (Cr : Cairo_Context; Utf8 : System.Address); pragma Import (C, C_Text_Path, "cairo_text_path"); Tmp : constant String := Utf8 & ASCII.NUL; begin C_Text_Path (Cr, Tmp'Address); end Text_Path; --------------- -- In_Stroke -- --------------- function In_Stroke (Cr : Cairo_Context; X : Gdouble; Y : Gdouble) return Boolean is function Internal (C : Cairo_Context; X, Y : Gdouble) return Gboolean; pragma Import (C, Internal, "cairo_in_stroke"); begin return Internal (Cr, X, Y) /= 0; end In_Stroke; ------------- -- In_Fill -- ------------- function In_Fill (Cr : Cairo_Context; X : Gdouble; Y : Gdouble) return Boolean is function Internal (C : Cairo_Context; X, Y : Gdouble) return Gboolean; pragma Import (C, Internal, "cairo_in_fill"); begin return Internal (Cr, X, Y) /= 0; end In_Fill; ----------------------- -- Has_Current_Point -- ----------------------- function Has_Current_Point (Cr : Cairo_Context) return Boolean is function Internal (Cr : Cairo_Context) return Gboolean; pragma Import (C, Internal, "cairo_has_current_point"); begin return Internal (Cr) /= 0; end Has_Current_Point; end Cairo; gtkada-24.0.0/src/cairo.ads000066400000000000000000003472301446021174000154150ustar00rootroot00000000000000------------------------------------------------------------------------------ -- GtkAda - Ada95 binding for Gtk+/Gnome -- -- -- -- Copyright (C) 2010-2018, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ -- -- Bindings to the Cairo 2D graphics library. -- The Cairo_Context is the main object used when drawing with cairo. To draw -- with Cairo, you create a Context, set the target surface, and drawing -- options for the Cairo_Context, create shapes with functions like Move_To -- and Line_To, and then draw shapes with Stroke or Fill. -- -- All drawing in Cairo is done on a Cairo_Context. -- -- Drawing on on-screen Gtk widgets should be done in a callback to the -- "expose" event: -- -- When the widget has been created, connect a drawing function: -- -- -- declare -- Area : Gtk_Drawing_Area; -- -- package Event_Cb is new Gtk.Handlers.Return_Callback -- (Gtk_Drawing_Area_Record, Boolean); -- begin -- Gtk_New (Area); -- Event_Cb.Connect (Area, "expose_event", -- Event_Cb.To_Marshaller (Expose_Cb'Access)); -- end; -- -- -- In the callback, first get the context of the drawable on which you -- need to draw, using Gdk.Cairo.Create. Then do the drawing operations, and -- release the memory allocated to Cr using Cairo.Destroy. -- -- In addition to drawing on on-screen widgets, drawing can also be done using -- the same Cairo calls to pixbufs (see Gdk.Cairo) to memory -- (see Cairo.Image_Surface), and to PNG or PDF files (see Cairo.Png and -- Cairo.Pdf). -- -- Code samples demonstrating how to use various functionalities of Cairo -- can be found in the testcairo example, shipped with GtkAda. -- -- -- 1.8.8 -- Cairo with Ada.Unchecked_Deallocation; with System; with Gtkada.Types; with Glib; use Glib; with Glib.Values; package Cairo is type Cairo_Context is private; -- A Cairo_Context contains the current state of the rendering device, -- including coordinates of yet to be drawn shapes. -- -- Cairo contexts, as Cairo_Context objects are named, are central to -- cairo and all drawing with cairo is always done to a Cairo_Context -- object. -- -- Memory management of Cairo_Context is done with subprograms -- Reference and Destroy, see below. function Get_Context (Value : Glib.Values.GValue) return Cairo_Context; -- Support for callbacks that receive a Cairo_Context as parameter. type Cairo_Surface is private; -- A Cairo_Surface represents an image, either as the destination -- of a drawing operation or as source when drawing onto another -- surface. To draw to a Cairo_Surface, create a cairo context -- with the surface as the target, using Create. -- -- There are different subtypes of Cairo_Surface for -- different drawing backends; for example, Cairo.Image_Surface.Create -- creates a bitmap image in memory. -- The type of a surface can be queried with Cairo.Surface.Get_Type. -- -- Memory management of Cairo_Surface is done with -- Cairo.Surface.Reference and Cairo.Surface.Destroy. type Cairo_Matrix is record Xx : aliased Gdouble; Yx : aliased Gdouble; Xy : aliased Gdouble; Yy : aliased Gdouble; X0 : aliased Gdouble; Y0 : aliased Gdouble; end record; -- Xx: Xx component of the affine transformation -- Yx: Yx component of the affine transformation -- Xy: Xy component of the affine transformation -- Yy: Yy component of the affine transformation -- X0: X translation component of the affine transformation -- Y0: Y translation component of the affine transformation -- -- A Cairo_Matrix holds an affine transformation, such as a scale, -- rotation, shear, or a combination of those. The transformation of -- a point (X, Y) is given by: -- -- X_New = Xx * X + Xy * Y + X0; -- Y_New = Yx * X + Yy * Y + Y0; pragma Convention (C_Pass_By_Copy, Cairo_Matrix); type Cairo_Matrix_Access is access Cairo_Matrix; procedure Unchecked_Free is new Ada.Unchecked_Deallocation (Cairo_Matrix, Cairo_Matrix_Access); type Cairo_Format is ( Format_Invalid, Format_ARGB32, Format_RGB24, Format_A8, Format_A1, Format_RGB16_565, Format_RGB30); for Cairo_Format use ( Format_Invalid => -1, Format_ARGB32 => 0, Format_RGB24 => 1, Format_A8 => 2, Format_A1 => 3, Format_RGB16_565 => 4, Format_RGB30 => 5); -- Used to identify the memory format of image data -- -- Format_ARGB32: each pixel is a 32-bit quantity, with -- alpha in the upper 8 bits, then red, then green, then blue. -- The 32-bit quantities are stored native-endian. Pre-multiplied -- alpha is used. (That is, 50% transparent red is 0x80800000, -- not 0x80ff0000.) (Since 1.0) -- Format_RGB_24: each pixel is a 32-bit quantity, with -- the upper 8 bits unused. Red, Green, and Blue are stored -- in the remaining 24 bits in that order. (Since 1.0) -- Format_A8: each pixel is a 8-bit quantity holding -- an alpha value. (Since 1.0) -- Format_A1: each pixel is a 1-bit quantity holding -- an alpha value. Pixels are packed together into 32-bit -- quantities. The ordering of the bits matches the -- endianess of the platform. On a big-endian machine, the -- first pixel is in the uppermost bit, on a little-endian -- machine the first pixel is in the least-significant bit. (Since 1.0) -- Format_RGB16_565: each pixel is a 16-bit quantity -- with red in the upper 5 bits, then green in the middle -- 6 bits, and blue in the lower 5 bits. (Since 1.2) -- Format_RGB30: like RGB24 but with 10bpc. (Since 1.12) type Cairo_Pattern is private; -- A Cairo_Pattern represents a source when drawing onto a -- surface. There are different subtypes of Cairo_Pattern, -- for different types of sources; for example, -- Cairo.Pattern.Create_Rgb creates a pattern for a solid -- opaque color. -- -- Other than various Cairo.Pattern.Create_ -- functions, some of the pattern types can be implicitly created -- using various Set_Source_ functions; for example Set_Source_Rgb. -- -- The type of a pattern can be queried with Cairo.Pattern.Get_Type. -- -- Memory management of Cairo_Pattern is done with -- Cairo.Pattern.Reference and Cairo.Pattern.Destroy. type Cairo_Destroy_Func is access procedure (Arg1 : System.Address); -- Data: The Data element being destroyed. -- -- Cairo_destroy_func the type of function which is called when a -- data element is destroyed. It is passed the pointer to the data -- element and should free any memory and resources allocated for it. type Cairo_User_Data_Key is record Unused : aliased Gint; end record; -- Unused: not used; ignore. -- -- Cairo_User_Data_Key is used for attaching user data to cairo -- data structures. The actual contents of the struct is never used, -- and there is no need to initialize the object; only the unique -- address of a Cairo_User_Data_Key object is used. Typically, you -- would just use the address of a static Cairo_User_Data_Key object. pragma Convention (C_Pass_By_Copy, Cairo_User_Data_Key); -- Cairo_Status is used to indicate errors that can occur when -- using Cairo. In some cases it is returned directly by functions. -- but when using Cairo_T, the last error, if any, is stored in -- the context and can be retrieved with Cairo_Status. -- -- New entries may be added in future versions. Use -- Cairo_Status_To_String -- to get a human-readable representation of an error message. type Cairo_Status is ( Cairo_Status_Success, -- no error has occurred Cairo_Status_No_Memory, -- out of memory Cairo_Status_Invalid_Restore, -- Cairo_Restore called without matching Cairo_Save Cairo_Status_Invalid_Pop_Group, -- no saved group to pop Cairo_Status_No_Current_Point, -- no current point defined Cairo_Status_Invalid_Matrix, -- invalid matrix (not invertible) Cairo_Status_Invalid_Status, -- invalid value for an input Cairo_status Cairo_Status_Null_Pointer, -- NULL pointer Cairo_Status_Invalid_String, -- input string not valid UTF-8 Cairo_Status_Invalid_Path_Data, -- input path data not valid Cairo_Status_Read_Error, -- error while reading from input stream Cairo_Status_Write_Error, -- error while writing to output stream Cairo_Status_Surface_Finished, -- target surface has been finished Cairo_Status_Surface_Type_Mismatch, -- the surface type is not appropriate for the operation Cairo_Status_Pattern_Type_Mismatch, -- the pattern type is not appropriate for the operation Cairo_Status_Invalid_Content, -- invalid value for an input Cairo_content Cairo_Status_Invalid_Format, -- invalid value for an input Cairo_format Cairo_Status_Invalid_Visual, -- invalid value for an input Visual* Cairo_Status_File_Not_Found, -- file not found Cairo_Status_Invalid_Dash, -- invalid value for a dash setting Cairo_Status_Invalid_Dsc_Comment, -- invalid value for a DSC comment (Since 1.2) Cairo_Status_Invalid_Index, -- invalid index passed to getter (Since 1.4) Cairo_Status_Clip_Not_Representable, -- clip region not representable in desired format (Since 1.4) Cairo_Status_Temp_File_Error, -- error creating or writing to a temporary file (Since 1.6) Cairo_Status_Invalid_Stride, -- invalid value for stride (Since 1.6) Cairo_Status_Font_Type_Mismatch, -- the font type is not appropriate for the operation (Since 1.8) Cairo_Status_User_Font_Immutable, -- the user-font is immutable (Since 1.8) Cairo_Status_User_Font_Error, -- error occurred in a user-font callback function (Since 1.8) Cairo_Status_Negative_Count, -- negative number used where it is not allowed (Since 1.8) Cairo_Status_Invalid_Clusters, -- input clusters do not represent the accompanying text and glyph -- array (Since 1.8) Cairo_Status_Invalid_Slant, -- invalid value for an input Cairo_Font_Slant (Since 1.8) Cairo_Status_Invalid_Weight -- invalid value for an input Cairo_Font_Weight (Since 1.8) ); subtype Cairo_Content is Guint; -- Cairo_content is used to describe the content that a surface will -- contain, whether color information, alpha information (translucence -- vs. opacity), or both. -- -- Note: The large values here are designed to keep Cairo_Content -- values distinct from Cairo_Format values so that the -- implementation can detect the error if users confuse the two types. Cairo_Content_Color : constant Cairo_Content := 4096; -- The surface will hold color content only. Cairo_Content_Alpha : constant Cairo_Content := 8192; -- CAIRO_CONTENT_ALPHA: The surface will hold alpha content only. Cairo_Content_Color_Alpha : constant Cairo_Content := 12288; -- CAIRO_CONTENT_COLOR_ALPHA: The surface will hold color and alpha -- content. function Create (Target : Cairo_Surface) return Cairo_Context; -- Target: Target surface for the context -- -- Creates a new Cairo_Context with all graphics state parameters set to -- default values and with target as a target surface. The target -- surface should be constructed with a backend-specific function such -- as Cairo.Image_Surface.Create. -- -- This function references target, so you can immediately -- call Cairo.Surface.Destroy on it if you don't need to -- maintain a separate reference to it. -- -- Return value: a newly allocated Cairo_Context with a reference -- count of 1. The initial reference count should be released -- with Destroy when you are done using the Cairo_Context. -- This function never returns NULL. If memory cannot be -- allocated, a special Cairo_Context object will be returned on -- which Status returns Cairo_Status_No_Memory. -- You can use this object normally, but no drawing will -- be done. function Reference (Cr : Cairo_Context) return Cairo_Context; -- Cr: a Cairo_Context -- -- Increases the reference count on cr by one. This prevents -- cr from being destroyed until a matching call to Destroy -- is made. -- -- The number of references to a Cairo_Context can be retrieved using -- Get_Reference_Count. -- -- Return value: the referenced Cairo_Context. procedure Destroy (Cr : Cairo_Context); pragma Import (C, Destroy, "cairo_destroy"); -- Cr: a Cairo_Context -- -- Decreases the reference count on cr by one. If the result -- is zero, then cr and all associated resources are freed. -- See Reference. procedure Surface_Destroy (Surface : Cairo_Surface); pragma Import (C, Surface_Destroy, "cairo_surface_destroy"); -- Free the memory used by the surface function Get_Reference_Count (Cr : Cairo_Context) return Guint; -- Cr: a Cairo_Context -- -- Returns the current reference count of cr. -- -- Return value: the current reference count of cr. If the -- object is a nil object, 0 will be returned. -- -- Since: 1.4 function Get_User_Data (Cr : Cairo_Context; Key : access Cairo_User_Data_Key) return System.Address; -- Cr: a Cairo_Context -- Key: the address of the Cairo_User_Data_Key the user data was -- attached to -- -- Return user data previously attached to cr using the specified -- key. If no user data has been attached with the given key this -- function returns NULL. -- -- Return value: the user data previously attached or NULL. -- -- Since: 1.4 function Set_User_Data (Cr : Cairo_Context; Key : access Cairo_User_Data_Key; User_Data : System.Address; Destroy : Cairo_Destroy_Func) return Cairo_Status; -- Cr: a Cairo_Context -- Key: the address of a Cairo_User_Data_Key to attach the user data to -- User_Data: the user data to attach to the Cairo_Context -- Destroy: a Cairo_Destroy_Func which will be called when the -- Cairo_Context is destroyed or when new user data is attached using the -- same key. -- -- Attach user data to cr. To remove user data from a surface, -- call this function with the key that was used to set it and NULL -- for data. -- -- Return value: CAIRO_STATUS_SUCCESS or CAIRO_STATUS_NO_MEMORY if a -- slot could not be allocated for the user data. -- -- Since: 1.4 procedure Save (Cr : Cairo_Context); -- Cr: a Cairo_Context -- -- Makes a copy of the current state of cr and saves it -- on an internal stack of saved states for cr. When -- Cairo_Restore is called, cr will be restored to -- the saved state. Multiple calls to Cairo_Save and -- Cairo_Restore can be nested; each call to Cairo_Restore -- restores the state from the matching paired Cairo_Save. -- -- It isn't necessary to clear all saved states before -- a Cairo_Context is freed. If the reference count of a Cairo_Context -- drops to zero in response to a call to Cairo_Destroy, -- any saved states will be freed along with the Cairo_Context. procedure Restore (Cr : Cairo_Context); -- Cr: a Cairo_Context -- -- Restores cr to the state saved by a preceding call to -- Cairo_Save and removes that state from the stack of -- saved states. procedure Push_Group (Cr : Cairo_Context); -- Cr: a cairo context -- -- Temporarily redirects drawing to an intermediate surface known as a -- group. The redirection lasts until the group is completed by a call -- to Pop_Group or Pop_Group_To_Source. -- -- These calls provide the result of any drawing to the group as a pattern, -- (either as an explicit object, or set as the source pattern). -- -- This group functionality can be convenient for performing -- intermediate compositing. One common use of a group is to render -- objects as opaque within the group, (so that they occlude each -- other), and then blend the result with translucence onto the -- destination. -- -- Groups can be nested arbitrarily deep by making balanced calls to -- Push_Group/Pop_Group. Each call pushes/pops the new target group -- onto/from a stack. -- -- The Push_Group function calls Save so that any changes to the graphics -- state will not be visible outside the group, (the pop_group functions -- call Restore). -- -- By default the intermediate group will have a content type of -- Cairo_Content_Color_Alphe. Other content types can be chosen for -- the group by using Push_Group_With_Content instead. -- -- As an example, here is how one might fill and stroke a path with -- translucence, but without any portion of the fill being visible -- under the stroke: -- -- Push_Group (Cr); -- Set_Source (Cr, Fill_Pattern); -- Fill_Preserve (Cr); -- Set_Source (Cr, Stroke_Pattern); -- Stroke (Cr); -- Pop_Group_To_Source (Cr); -- Paint_With_Alpha (Cr, Alpha); -- -- Since: 1.2 procedure Push_Group_With_Content (Cr : Cairo_Context; Content : Cairo_Content); -- Cr: a cairo context -- Content: a Cairo_Content indicating the type of group that -- will be created -- -- Temporarily redirects drawing to an intermediate surface known as a -- group. The redirection lasts until the group is completed by a call to -- Pop_Group or Pop_Group_To_Source. These calls provide the result of any -- drawing to the group as a pattern, (either as an explicit object, or set -- as the source pattern). -- -- The group will have a content type of content. The ability to control -- this content type is the only distinction between this function and -- Push_Group which you should see for a more detailed description of group -- rendering. -- -- Since: 1.2 function Pop_Group (Cr : Cairo_Context) return Cairo_Pattern; -- Cr: a cairo context -- -- Terminates the redirection begun by a call to Push_Group or -- Push_Group_With_Content and returns a new pattern containing the results -- of all drawing operations performed to the group. -- -- The Pop_Group function calls Restore, (balancing a call to Save by the -- Push_Group function), so that any changes to the graphics state will not -- be visible outside the group. -- -- Return value: a newly created (surface) pattern containing the -- results of all drawing operations performed to the group. The -- caller owns the returned object and should call -- Cairo.Pattern.Destroy when finished with it. -- -- Since: 1.2 procedure Pop_Group_To_Source (Cr : Cairo_Context); -- Cr: a cairo context -- -- Terminates the redirection begun by a call to Push_Group or -- Push_Group_With_Content and installs the resulting pattern as the source -- pattern in the given cairo context. -- -- The behavior of this function is equivalent to the sequence of -- operations: -- -- declare -- Group: Cairo_Pattern := Pop_Group (Cr); -- begin -- Set_Source (Cr, Group); -- Cairo.Pattern.Destroy (Group); -- end; -- -- but is more convenient as their is no need for a variable to store -- the short-lived pointer to the pattern. -- -- The Pop_Group function calls Restore, (balancing a call to Save by the -- push_group function), so that any changes to the graphics state will not -- be visible outside the group. -- -- Since: 1.2 -- Cairo_operator is used to set the compositing operator for all cairo -- drawing operations. -- -- The default operator is Cairo_Operator_Over. -- -- The operators marked as "unbounded" modify their destination even -- outside of the mask layer (that is, their effect is not bound by the -- mask layer). However, their effect can still be limited by way of -- clipping. -- -- To keep things simple, the operator descriptions here document the -- behavior for when both source and destination are either fully -- transparent or fully opaque. The actual implementation works for -- translucent layers too. -- -- For a more detailed explanation of the effects of each operator, -- including the mathematical definitions, see -- http://cairographics.org/operators/ type Cairo_Operator is (Cairo_Operator_Clear, -- clear destination layer (bounded) Cairo_Operator_Source, -- replace destination layer (bounded) Cairo_Operator_Over, -- draw source layer on top of destination layer (bounded) Cairo_Operator_In, -- draw source where there was destination content (unbounded) Cairo_Operator_Out, -- draw source where there was no destination content (unbounded) Cairo_Operator_Atop, -- draw source on top of destination content and only there Cairo_Operator_Dest, -- ignore the source Cairo_Operator_Dest_Over, -- draw destination on top of source Cairo_Operator_Dest_In, -- leave destination only where there was source content (unbounded) Cairo_Operator_Dest_Out, -- leave destination only where there was no source content Cairo_Operator_Dest_Atop, -- leave destination on top of source content and only there (unbounded) Cairo_Operator_Xor, -- source and destination are shown where there is only one of them Cairo_Operator_Add, -- source and destination layers are accumulated Cairo_Operator_Saturate -- like over, but assuming source and dest are disjoint geometries ); procedure Set_Operator (Cr : Cairo_Context; Op : Cairo_Operator); -- Cr: a Cairo_Context -- Op: a compositing Operator, specified as a Cairo_Operator -- -- Sets the compositing operator to be used for all drawing -- operations. See Cairo_Operator for details on the semantics of -- each available compositing operator. -- -- The default operator is Cairo_Operator_Over. function Pattern_Create_Rgb (Red, Green, Blue : Gdouble) return Cairo_Pattern; pragma Import (C, Pattern_Create_Rgb, "cairo_pattern_create_rgb"); function Pattern_Create_Rgba (Red, Green, Blue, Alpha : Gdouble) return Cairo_Pattern; pragma Import (C, Pattern_Create_Rgba, "cairo_pattern_create_rgba"); function Pattern_Create_For_Surface (Surface : Cairo_Surface) return Cairo_Pattern; pragma Import (C, Pattern_Create_For_Surface, "cairo_pattern_create_for_surface"); function Pattern_Create_Linear (X0, Y0, X1, Y1 : Gdouble) return Cairo_Pattern; pragma Import (C, Pattern_Create_Linear, "cairo_pattern_create_linear"); -- See Pattern_Add_Color_Stop to specify the colors function Pattern_Create_Radial (Cx0, Cy0, Radius0, Cx1, Cy1, Radius1 : Gdouble) return Cairo_Pattern; pragma Import (C, Pattern_Create_Radial, "cairo_pattern_create_radial"); procedure Pattern_Destroy (Pattern : Cairo_Pattern); pragma Import (C, Pattern_Destroy, "cairo_pattern_destroy"); procedure Pattern_Add_Color_Stop_Rgb (Pattern : Cairo_Pattern; Offset : Gdouble; Red, Green, Blue : Gdouble); pragma Import (C, Pattern_Add_Color_Stop_Rgb, "cairo_pattern_add_color_stop_rgb"); procedure Pattern_Add_Color_Stop_Rgba (Pattern : Cairo_Pattern; Offset : Gdouble; Red, Green, Blue, Alpha : Gdouble); pragma Import (C, Pattern_Add_Color_Stop_Rgba, "cairo_pattern_add_color_stop_rgba"); procedure Set_Source (Cr : Cairo_Context; Source : Cairo_Pattern); -- Cr: a cairo context -- Source: a Cairo_Pattern to be used as the Source for -- subsequent drawing operations. -- -- Sets the source pattern within Cr to source. This pattern -- will then be used for any subsequent drawing operation until a new -- source pattern is set. -- -- Note: The pattern's transformation matrix will be locked to the user -- space in effect at the time of Set_Source. This means that further -- modifications of the current transformation matrix will not affect the -- source pattern. See Cairo.Pattern.Set_Matrix. -- -- The default source pattern is a solid pattern that is opaque black, -- (that is, it is equivalent to Set_Source_Rgb (Cr, 0.0, 0.0, 0.0)). subtype Color_Range is Gdouble range 0.0 .. 1.0; procedure Set_Source_Rgb (Cr : Cairo_Context; Red : Color_Range; Green : Color_Range; Blue : Color_Range); -- Cr : a cairo context -- Red : Red component of color -- Green : Green component of color -- Blue : Blue component of color -- -- Sets the source pattern within Cr to an opaque color. This opaque -- color will then be used for any subsequent drawing operation until -- a new source pattern is set. -- -- The color components are floating point numbers in the range 0 to -- 1. If the values passed in are outside that range, they will be -- clamped. -- -- The default source pattern is opaque black, (that is, it is -- equivalent to Set_Source_Rgb (Cr, 0.0, 0.0, 0.0)). procedure Set_Source_Rgba (Cr : Cairo_Context; Red : Color_Range; Green : Color_Range; Blue : Color_Range; Alpha : Color_Range); -- Cr : a cairo context -- Red : Red component of color -- Green : Green component of color -- Blue : Blue component of color -- Alpha : Alpha component of color -- -- Sets the source pattern within Cr to a translucent color. This -- color will then be used for any subsequent drawing operation until -- a new source pattern is set. -- -- The color and alpha components are floating point numbers in the -- range 0 to 1. If the values passed in are outside that range, they -- will be clamped. -- -- The default source pattern is opaque black, (that is, it is -- equivalent to Set_Source_Rgba (Cr, 0.0, 0.0, 0.0, 1.0)). procedure Set_Source_Surface (Cr : Cairo_Context; Surface : Cairo_Surface; X : Gdouble; Y : Gdouble); -- Cr : a cairo context -- Surface : a Surface to be used to set the source pattern -- X : User-space X coordinate for surface origin -- Y : User-space Y coordinate for surface origin -- -- This is a convenience function for creating a pattern from surface -- and setting it as the source in Cr with Set_Source. -- -- The X and Y parameters give the user-space coordinate at which -- the surface origin should appear. (The surface origin is its -- upper-left corner before any transformation has been applied.) The -- X and Y patterns are negated and then set as translation values -- in the pattern matrix. -- -- Other than the initial translation pattern matrix, as described -- above, all other pattern attributes, (such as its extend mode), are -- set to the default values as in Cairo.Pattern.Create_For_Surface. -- The resulting pattern can be queried with Get_Source so that these -- attributes can be modified if desired, (eg. to create a -- repeating pattern with Cairo.Pattern.Set_Extend). procedure Set_Tolerance (Cr : Cairo_Context; Tolerance : Gdouble); -- Cr: a Cairo_Context -- Tolerance: the Tolerance, in device units (typically pixels) -- -- Sets the tolerance used when converting paths into trapezoids. -- Curved segments of the path will be subdivided until the maximum -- deviation between the original path and the polygonal approximation -- is less than tolerance. The default value is 0.1. A larger -- value will give better performance, a smaller value, better -- appearance. (Reducing the value from the default value of 0.1 -- is unlikely to improve appearance significantly.) The accuracy of paths -- within Cairo is limited by the precision of its internal arithmetic, and -- the prescribed tolerance is restricted to the smallest -- representable internal value. -- Specifies the type of antialiasing to do when rendering text or shapes. type Cairo_Antialias is ( Cairo_Antialias_Default, -- Use the default antialiasing for the subsystem and target device Cairo_Antialias_None, -- Use a bilevel alpha mask Cairo_Antialias_Gray, -- Perform single-color antialiasing (using shades of gray for black -- text on a white background, for example). Cairo_Antialias_Subpixel -- Perform antialiasing by taking advantage of the order of subpixel -- elements on devices such as LCD panels ); procedure Set_Antialias (Cr : Cairo_Context; Antialias : Cairo_Antialias); -- Cr: a Cairo_Context -- Antialias: the new Antialiasing mode -- -- Set the antialiasing mode of the rasterizer used for drawing shapes. -- This value is a hint, and a particular backend may or may not support -- a particular value. At the current time, no backend supports -- Cairo_Antialias_Subpixel when drawing shapes. -- -- Note that this option does not affect text rendering, instead see -- Cairo.Font_Options.Set_Antialias. -- Cairo_Fill_Rule is used to select how paths are filled. For both -- fill rules, whether or not a point is included in the fill is -- determined by taking a ray from that point to infinity and looking -- at intersections with the path. The ray can be in any direction, -- as long as it doesn't pass through the end point of a segment -- or have a tricky intersection such as intersecting tangent to the path. -- (Note that filling is not actually implemented in this way. This -- is just a description of the rule that is applied.) -- -- The default fill rule is Cairo_Fill_Rule_Winding. -- -- New entries may be added in future versions. type Cairo_Fill_Rule is (Cairo_Fill_Rule_Winding, -- If the path crosses the ray from left-to-right, counts +1. If the -- path crosses the ray from right to left, counts -1. (Left and right -- are determined from the perspective of looking along the ray from -- the starting point). If the total count is non-zero, the point will -- be filled. Cairo_Fill_Rule_Even_Odd -- Counts the total number of -- intersections, without regard to the orientation of the contour. If -- the total number of intersections is odd, the point will be filled. ); procedure Set_Fill_Rule (Cr : Cairo_Context; Fill_Rule : Cairo_Fill_Rule); -- Cr: a Cairo_Context -- Fill_Rule: a fill rule -- -- Set the current fill rule within the cairo context. The fill rule is -- used to determine which regions are inside or outside a complex -- (potentially self-intersecting) path. The current fill rule affects both -- Fill and Clip. See Cairo_Fill_Rule for details on the semantics of each -- available fill rule. -- -- The default fill rule is Cairo_Fill_Rule_Winding. procedure Set_Line_Width (Cr : Cairo_Context; Width : Gdouble); -- Cr: a Cairo_Context -- Width: a line Width -- -- Sets the current line width within the cairo context. The line -- width value specifies the diameter of a pen that is circular in -- user space, (though device-space pen may be an ellipse in general -- due to scaling/shear/rotation of the CTM). -- -- Note: When the description above refers to user space and CTM it -- refers to the user space and CTM in effect at the time of the -- stroking operation, not the user space and CTM in effect at the -- time of the call to Set_Line_Width. The simplest usage -- makes both of these spaces identical. That is, if there is no -- change to the CTM between a call to Set_Line_Width and the -- stroking operation, then one can just pass user-space values to -- Set_Line_Width and ignore this note. -- -- As with the other stroke parameters, the current line width is examined -- by Stroke, Stroke_Extents, and Stroke_To_Path, but does not have any -- effect during path construction. -- -- The default line width value is 2.0. type Cairo_Line_Cap is (Cairo_Line_Cap_Butt, -- start(stop) the line exactly at the start(end) point Cairo_Line_Cap_Round, -- use a round ending, the center of the circle is the end point Cairo_Line_Cap_Square -- use squared ending, the center of the square is the end point ); -- Specifies how to render the endpoints of the path when stroking. -- -- The default line cap style is Cairo_Line_Cap_Butt. procedure Set_Line_Cap (Cr : Cairo_Context; Line_Cap : Cairo_Line_Cap); -- Cr: a cairo context -- Line_Cap: a line cap style -- -- Sets the current line cap style within the cairo context. See -- Cairo_Line_Cap for details about how the available line cap -- styles are drawn. -- -- As with the other stroke parameters, the current line cap style is -- examined by Stroke, Stroke_Extents, and Stroke_To_Path, but does not -- have any effect during path construction. -- -- The default line cap style is Cairo_Line_Cap_Butt. type Cairo_Line_Join is (Cairo_Line_Join_Miter, -- use a sharp (angled) corner, see Set_Miter_Limit Cairo_Line_Join_Round, -- use a rounded join, the center of the circle is the joint point Cairo_Line_Join_Bevel -- use a cut-off join, the join is cut off at half the line width from -- the joint point ); -- Specifies how to render the junction of two lines when stroking. -- -- The default line join style is Cairo_Line_Join_Miter. procedure Set_Line_Join (Cr : Cairo_Context; Line_Join : Cairo_Line_Join); -- Cr: a cairo context -- Line_Join: a line join style -- -- Sets the current line join style within the cairo context. See -- Cairo_Line_Join for details about how the available line join styles are -- drawn. -- -- As with the other stroke parameters, the current line join style is -- examined by Stroke, Stroke_Extents, and Stroke_To_Path, but does -- not have any effect during path construction. -- -- The default line join style is Cairo_Line_Join_Miter. type Dash_Array is array (Natural range <>) of Gdouble; No_Dashes : constant Dash_Array (1 .. 0) := (others => 0.0); procedure Set_Dash (Cr : Cairo_Context; Dashes : Dash_Array; Offset : Gdouble); -- Cr: a cairo context -- Dashes: an array specifying alternate lengths of on and off stroke -- portions -- Offset: an Offset into the dash pattern at which the stroke should start -- -- Sets the dash pattern to be used by Stroke. A dash pattern -- is specified by dashes, an array of positive values. Each value -- provides the length of alternate "on" and "off" portions of the -- stroke. The offset specifies an offset into the pattern at which -- the stroke begins. -- -- Each "on" segment will have caps applied as if the segment were a -- separate sub-path. In particular, it is valid to use an "on" length -- of 0.0 with Cairo_Line_Cap_Round or Cairo_Line_Cap_Square in order -- to distributed dots or squares along a path. -- -- Note: The length values are in user-space units as evaluated at the -- time of stroking. This is not necessarily the same as the user -- space at the time of Set_Dash. -- -- If the array is No_Dashes, dashing is disabled. -- -- If the array contains only one element symmetric pattern is assumed with -- alternating on and off portions of the size specified by the single -- value in dashes. -- -- If any value in dashes is negative, or if all values are 0, then -- cr will be put into an error state with a status of -- Cairo_Status_Invalid_Dash. procedure Set_Miter_Limit (Cr : Cairo_Context; Limit : Gdouble); -- Cr: a cairo context -- Limit: miter Limit to set -- -- Sets the current miter limit within the cairo context. -- -- If the current line join style is set to Cairo_Line_Join_Miter -- (see Cairo_Set_Line_Join), the miter limit is used to determine -- whether the lines should be joined with a bevel instead of a miter. -- Cairo divides the length of the miter by the line width. -- If the result is greater than the miter limit, the style is -- converted to a bevel. -- -- As with the other stroke parameters, the current line miter limit is -- examined by Stroke, Stroke_Extents, and Stroke_To_Path, but does not -- have any effect during path construction. -- -- The default miter limit value is 10.0, which will convert joins -- with interior angles less than 11 degrees to bevels instead of -- miters. For reference, a miter limit of 2.0 makes the miter cutoff -- at 60 degrees, and a miter limit of 1.414 makes the cutoff at 90 -- degrees. -- -- A miter limit for a desired angle can be computed as: miter limit = -- 1/sin(angle/2) procedure Translate (Cr : Cairo_Context; Tx : Gdouble; Ty : Gdouble); -- Cr: a cairo context -- Tx: amount to translate in the X direction -- Ty: amount to translate in the Y direction -- -- Modifies the current transformation matrix (CTM) by translating the -- user-space origin by (tx, ty). This offset is interpreted as a -- user-space coordinate according to the CTM in place before the new -- call to Translate. In other words, the translation of the -- user-space origin takes place after any existing transformation. procedure Scale (Cr : Cairo_Context; Sx : Gdouble; Sy : Gdouble); -- Cr: a cairo context -- Sx: scale factor for the X dimension -- Sy: scale factor for the Y dimension -- -- Modifies the current transformation matrix (CTM) by scaling the X -- and Y user-space axes by sx and sy respectively. The scaling of -- the axes takes place after any existing transformation of user -- space. procedure Rotate (Cr : Cairo_Context; Angle : Gdouble); -- Cr: a cairo context -- Angle: Angle (in radians) by which the user-space axes will be -- rotated -- -- Modifies the current transformation matrix (CTM) by rotating the -- user-space axes by angle radians. The rotation of the axes takes -- places after any existing transformation of user space. The -- rotation direction for positive angles is from the positive X axis -- toward the positive Y axis. procedure Transform (Cr : Cairo_Context; Matrix : access Cairo_Matrix); -- Cr: a cairo context -- Matrix: a transformation to be applied to the user-space axes -- -- Modifies the current transformation matrix (CTM) by applying -- matrix as an additional transformation. The new transformation of -- user space takes place after any existing transformation. procedure Set_Matrix (Cr : Cairo_Context; Matrix : access Cairo_Matrix); -- Cr: a cairo context -- Matrix: a transformation Matrix from user space to device space -- -- Modifies the current transformation matrix (CTM) by setting it -- equal to matrix. procedure Identity_Matrix (Cr : Cairo_Context); -- Cr: a cairo context -- -- Resets the current transformation matrix (CTM) by setting it equal -- to the identity matrix. That is, the user-space and device-space -- axes will be aligned and one user-space unit will transform to one -- device-space unit. procedure User_To_Device (Cr : Cairo_Context; X : access Gdouble; Y : access Gdouble); -- Cr: a cairo context -- X: X value of coordinate (in/out parameter) -- Y: Y value of coordinate (in/out parameter) -- -- Transform a coordinate from user space to device space by -- multiplying the given point by the current transformation matrix -- (CTM). procedure User_To_Device_Distance (Cr : Cairo_Context; Dx : access Gdouble; Dy : access Gdouble); -- Cr: a cairo context -- Dx: X component of a distance vector (in/out parameter) -- Dy: Y component of a distance vector (in/out parameter) -- -- Transform a distance vector from user space to device space. This -- function is similar to User_To_Device except that the translation -- components of the CTM will be ignored when transforming (Dx,Dy). procedure Device_To_User (Cr : Cairo_Context; X : access Gdouble; Y : access Gdouble); -- Cr: a cairo -- X: X value of coordinate (in/out parameter) -- Y: Y value of coordinate (in/out parameter) -- -- Transform a coordinate from device space to user space by -- multiplying the given point by the inverse of the current -- transformation matrix (CTM). procedure Device_To_User_Distance (Cr : Cairo_Context; Dx : access Gdouble; Dy : access Gdouble); -- Cr: a cairo context -- Dx: X component of a distance vector (in/out parameter) -- Dy: Y component of a distance vector (in/out parameter) -- -- Transform a distance vector from device space to user space. This -- function is similar to Device_To_User except that the -- translation components of the inverse CTM will be ignored when -- transforming (Dx,dy). ------------------- -- Path creation -- ------------------- procedure New_Path (Cr : Cairo_Context); -- Cr: a cairo context -- -- Clears the current path. After this call there will be no path and -- no current point. procedure Move_To (Cr : Cairo_Context; X : Gdouble; Y : Gdouble); -- Cr: a cairo context -- X: the X coordinate of the new position -- Y: the Y coordinate of the new position -- -- Begin a new sub-path. After this call the current point will be (X, Y). procedure New_Sub_Path (Cr : Cairo_Context); -- Cr: a cairo context -- -- Begin a new sub-path. Note that the existing path is not -- affected. After this call there will be no current point. -- -- In many cases, this call is not needed since new sub-paths are -- frequently started with Move_To. -- -- A call to New_Sub_Path is particularly useful when -- beginning a new sub-path with one of the Arc calls. This -- makes things easier as it is no longer necessary to manually -- compute the arc's initial coordinates for a call to -- Move_To. -- -- Since: 1.2 procedure Line_To (Cr : Cairo_Context; X : Gdouble; Y : Gdouble); -- Cr: a cairo context -- X: the X coordinate of the end of the new line -- Y: the Y coordinate of the end of the new line -- -- Adds a line to the path from the current point to position (X, Y) -- in user-space coordinates. After this call the current point -- will be (X, Y). -- -- If there is no current point before the call to Line_To -- this function will behave as Move_To (Cr, X, Y). procedure Curve_To (Cr : Cairo_Context; X1 : Gdouble; Y1 : Gdouble; X2 : Gdouble; Y2 : Gdouble; X3 : Gdouble; Y3 : Gdouble); -- Cr: a cairo context -- X1: the X coordinate of the first control point -- Y1: the Y coordinate of the first control point -- X2: the X coordinate of the second control point -- Y2: the Y coordinate of the second control point -- X3: the X coordinate of the end of the curve -- Y3: the Y coordinate of the end of the curve -- -- Adds a cubic Bézier spline to the path from the current point to -- position (X3, Y3) in user-space coordinates, using (X1, Y1) and -- (X2, Y2) as the control points. After this call the current point -- will be (X3, Y3). -- -- If there is no current point before the call to Curve_To -- this function will behave as if preceded by a call to -- Move_To (Cr, X1, Y1). procedure Arc (Cr : Cairo_Context; Xc : Gdouble; Yc : Gdouble; Radius : Gdouble; Angle1 : Gdouble; Angle2 : Gdouble); -- Cr: a cairo context -- Xc: X position of the center of the arc -- Yc: Y position of the center of the arc -- Radius: the Radius of the arc -- Angle1: the start angle, in radians -- Angle2: the end angle, in radians -- -- Adds a circular arc of the given radius to the current path. The -- arc is centered at (Xc, Yc), begins at Angle1 and proceeds in -- the direction of increasing angles to end at Angle2. If Angle2 is -- less than Angle1 it will be progressively increased by 2*M_PI -- until it is greater than Angle1. -- -- If there is a current point, an initial line segment will be added -- to the path to connect the current point to the beginning of the -- arc. If this initial line is undesired, it can be avoided by -- calling New_Sub_Path before calling Arc. -- -- Angles are measured in radians. An angle of 0.0 is in the direction -- of the positive X axis (in user space). An angle of M_PI/2.0 radians -- (90 degrees) is in the direction of the positive Y axis (in -- user space). Angles increase in the direction from the positive X -- axis toward the positive Y axis. So with the default transformation -- matrix, angles increase in a clockwise direction. -- -- (To convert from degrees to radians, use degrees * (Pi / 180.0)) -- -- This function gives the arc in the direction of increasing angles; -- see Cairo_Arc_Negative to get the arc in the direction of -- decreasing angles. -- -- The arc is circular in user space. To achieve an elliptical arc, -- you can scale the current transformation matrix by different -- amounts in the X and Y directions. For example, to draw an ellipse -- in the box given by X, Y, Width, Height: -- -- Cairo_Save (Cr); -- Cairo_Translate (Cr, X + Width / 2.0, Y + Height / 2.0); -- Cairo_Scale (Cr, Width / 2.0, Height / 2.0); -- Cairo_Arc (Cr, 0.0, 0.0, 1.0, 0.0, 2 * Pi); -- Cairo_Restore (Cr); procedure Arc_Negative (Cr : Cairo_Context; Xc : Gdouble; Yc : Gdouble; Radius : Gdouble; Angle1 : Gdouble; Angle2 : Gdouble); -- Cr: a cairo context -- Xc: X position of the center of the arc -- Yc: Y position of the center of the arc -- Radius: the Radius of the arc -- Angle1: the start angle, in radians -- Angle2: the end angle, in radians -- -- Adds a circular arc of the given radius to the current path. The -- arc is centered at (Xc, Yc), begins at Angle1 and proceeds in -- the direction of decreasing angles to end at Angle2. If Angle2 is -- greater than Angle1 it will be progressively decreased by 2*Pi -- until it is less than Angle1. -- -- See Arc for more details. This function differs only in the -- direction of the arc between the two angles. procedure Rel_Move_To (Cr : Cairo_Context; Dx : Gdouble; Dy : Gdouble); -- Cr: a cairo context -- Dx: the X offset -- Dy: the Y offset -- -- Begin a new sub-path. After this call the current point will offset -- by (X, Y). -- -- Given a current point of (X, Y), Rel_Move_To (Cr, Dx, Dy) -- is logically equivalent to Move_To (Cr, X + Dx, Y + Dy). -- -- It is an error to call this function with no current point. Doing -- so will cause cr to shutdown with a status of -- Cairo_Status_No_Current_Point. procedure Rel_Line_To (Cr : Cairo_Context; Dx : Gdouble; Dy : Gdouble); -- Cr: a cairo context -- Dx: the X offset to the end of the new line -- Dy: the Y offset to the end of the new line -- -- Relative-coordinate version of Line_To. Adds a line to the -- path from the current point to a point that is offset from the -- current point by (Dx, Dy) in user space. After this call the -- current point will be offset by (Dx, Dy). -- -- Given a current point of (X, Y), Rel_Line_To (Cr, Dx, Dy) -- is logically equivalent to Cairo_Line_To(Cr, X + Dx, Y + Dy). -- -- It is an error to call this function with no current point. Doing -- so will cause cr to shutdown with a status of -- Cairo_Status_No_Current_Point. procedure Rel_Curve_To (Cr : Cairo_Context; Dx1 : Gdouble; Dy1 : Gdouble; Dx2 : Gdouble; Dy2 : Gdouble; Dx3 : Gdouble; Dy3 : Gdouble); -- Cr: a cairo context -- Dx1: the X offset to the first control point -- Dy1: the Y offset to the first control point -- Dx2: the X offset to the second control point -- Dy2: the Y offset to the second control point -- Dx3: the X offset to the end of the curve -- Dy3: the Y offset to the end of the curve -- -- Relative-coordinate version of Cairo_Curve_To. All offsets are -- relative to the current point. Adds a cubic Bézier spline to the -- path from the current point to a point offset from the current -- point by (Dx3, Dy3), using points offset by (Dx1, Dy1) and -- (Dx2, Dy2) as the control points. After this call the current -- point will be offset by (Dx3, Dy3). -- -- Given a current point of (X, Y), Cairo_Rel_Curve_To(Cr, Dx1, -- Dy1, Dx2, Dy2, Dx3, Dy3) is logically equivalent to -- Cairo_Curve_To(Cr, X+Dx1, Y+Dy1, X+Dx2, Y+Dy2, X+Dx3, Y+Dy3). -- -- It is an error to call this function with no current point. Doing -- so will cause cr to shutdown with a status of -- Cairo_Status_No_Current_Point. procedure Rectangle (Cr : Cairo_Context; X : Gdouble; Y : Gdouble; Width : Gdouble; Height : Gdouble); -- Cr: a cairo context -- X: the X coordinate of the top left corner of the rectangle -- Y: the Y coordinate to the top left corner of the rectangle -- Width: the Width of the rectangle -- Height: the Height of the rectangle -- -- Adds a closed sub-path rectangle of the given size to the current -- path at position (X, Y) in user-space coordinates. -- -- This function is logically equivalent to: -- -- Move_To (Cr, x, Y); -- Rel_Line_To (Cr, Width, 0); -- Rel_Line_To (Cr, 0, Height); -- Rel_Line_To (Cr, -Width, 0); -- Close_Path (Cr); procedure Close_Path (Cr : Cairo_Context); -- Cr: a cairo context -- -- Adds a line segment to the path from the current point to the -- beginning of the current sub-path, (the most recent point passed to -- Move_To), and closes this sub-path. After this call the -- current point will be at the joined endpoint of the sub-path. -- -- The behavior of Close_Path is distinct from simply calling -- Line_To with the equivalent coordinate in the case of -- stroking. When a closed sub-path is stroked, there are no caps on -- the ends of the sub-path. Instead, there is a line join connecting -- the final and initial segments of the sub-path. -- -- If there is no current point before the call to Close_Path, -- this function will have no effect. -- -- Note: As of cairo version 1.2.4 any call to Close_Path will -- place an explicit MOVE_TO element into the path immediately after -- the CLOSE_PATH element, (which can be seen in Copy_Path for -- example). This can simplify path processing in some cases as it may -- not be necessary to save the "last move_to point" during processing -- as the MOVE_TO immediately after the CLOSE_PATH will provide that -- point. procedure Path_Extents (Cr : Cairo_Context; X1 : access Gdouble; Y1 : access Gdouble; X2 : access Gdouble; Y2 : access Gdouble); -- Cr: a cairo context -- X1: left of the resulting extents -- Y1: top of the resulting extents -- X2: right of the resulting extents -- Y2: bottom of the resulting extents -- -- Computes a bounding box in user-space coordinates covering the -- points on the current path. If the current path is empty, returns -- an empty rectangle ((0,0), (0,0)). Stroke parameters, fill rule, -- surface dimensions and clipping are not taken into account. -- -- Contrast with Fill_Extents and Stroke_Extents which -- return the extents of only the area that would be "inked" by -- the corresponding drawing operations. -- -- The result of Path_Extents is defined as equivalent to the -- limit of Stroke_Extents with Cairo_Line_Cap_Round as the -- line width approaches 0.0, (but never reaching the empty-rectangle -- returned by Cairo_Stroke_Extents for a line width of 0.0). -- -- Specifically, this means that zero-area sub-paths such as -- Move_To;Line_To segments, (even degenerate cases where the coordinates -- to both calls are identical), will be considered as contributing to the -- extents. However, a lone Move_To will not contribute to the results of -- Path_Extents. -- -- Since: 1.6 -------------- -- Painting -- -------------- procedure Paint (Cr : Cairo_Context); -- Cr: a cairo context -- -- A drawing operator that paints the current source everywhere within -- the current clip region. procedure Paint_With_Alpha (Cr : Cairo_Context; Alpha : Gdouble); -- Cr: a cairo context -- Alpha: Alpha value, between 0 (transparent) and 1 (opaque) -- -- A drawing operator that paints the current source everywhere within the -- current clip region using a mask of constant alpha value alpha. The -- effect is similar to Paint, but the drawing is faded out using the alpha -- value. procedure Mask (Cr : Cairo_Context; Pattern : Cairo_Pattern); -- Cr: a cairo context -- Pattern: a Cairo_Pattern -- -- A drawing operator that paints the current source using the alpha -- channel of pattern as a mask. (Opaque areas of pattern are painted with -- the source, transparent areas are not painted.) procedure Mask_Surface (Cr : Cairo_Context; Surface : Cairo_Surface; Surface_X : Gdouble; Surface_Y : Gdouble); -- Cr: a cairo context -- Surface: a Cairo_Surface -- Surface_X: X coordinate at which to place the origin of surface -- Surface_Y: Y coordinate at which to place the origin of surface -- -- A drawing operator that paints the current source -- using the alpha channel of surface as a mask. (Opaque -- areas of surface are painted with the source, transparent -- areas are not painted.) procedure Stroke (Cr : Cairo_Context); -- Cr: a cairo context -- -- A drawing operator that strokes the current path according to the -- current line width, line join, line cap, and dash settings. After -- Cairo_Stroke, the current path will be cleared from the cairo -- context. See Set_Line_Width, Set_Line_Join, Set_Line_Cap, Set_Dash, -- and Stroke_Preserve. -- -- Note: Degenerate segments and sub-paths are treated specially and -- provide a useful result. These can result in two different -- situations: -- -- 1. Zero-length "on" segments set in Set_Dash. If the cap -- style is Cairo_Line_Cap_Round or Cairo_Line_Cap_Square then these -- segments will be drawn as circular dots or squares respectively. In -- the case of Cairo_Line_Cap_Square, the orientation of the squares -- is determined by the direction of the underlying path. -- -- 2. A sub-path created by Cairo_Move_To followed by either a -- Cairo_Close_Path or one or more calls to Cairo_Line_To to the -- same coordinate as the Cairo_Move_To. If the cap style is -- Cairo_Line_Cap_Round then these sub-paths will be drawn as circular -- dots. Note that in the case of Cairo_Line_Cap_Square a degenerate -- sub-path will not be drawn at all, (since the correct orientation -- is indeterminate). -- -- In no case will a cap style of Cairo_Line_Cap_Butt cause anything -- to be drawn in the case of either degenerate segments or sub-paths. procedure Stroke_Preserve (Cr : Cairo_Context); -- Cr: a cairo context -- -- A drawing operator that strokes the current path according to the -- current line width, line join, line cap, and dash settings. Unlike -- Cairo_Stroke, Cairo_Stroke_Preserve preserves the path within the -- cairo context. -- -- See Set_Line_Width, Set_Line_Join, Set_Line_Cap, Set_Dash, and -- Stroke_Preserve. procedure Fill (Cr : Cairo_Context); -- Cr: a cairo context -- -- A drawing operator that fills the current path according to the -- current fill rule, (each sub-path is implicitly closed before being -- filled). After Fill, the current path will be cleared from -- the cairo context. See Set_Fill_Rule and Fill_Preserve. procedure Fill_Preserve (Cr : Cairo_Context); -- Cr: a cairo context -- -- A drawing operator that fills the current path according to the -- current fill rule, (each sub-path is implicitly closed before being -- filled). Unlike Fill, Fill_Preserve preserves the path within the -- cairo context. -- -- See Set_Fill_Rule and Fill. procedure Copy_Page (Cr : Cairo_Context); -- Cr: a cairo context -- -- Emits the current page for backends that support multiple pages, but -- doesn't clear it, so, the contents of the current page will be retained -- for the next page too. Use Show_Page if you want to get an -- empty page after the emission. -- -- This is a convenience function that simply calls -- Cairo.Surface.Copy_Page on Cr's target. procedure Show_Page (Cr : Cairo_Context); -- Cr: a cairo context -- -- Emits and clears the current page for backends that support multiple -- pages. Use Copy_Page if you don't want to clear the page. -- -- This is a convenience function that simply calls -- Cairo.Surface.Show_Page on cr's target. ------------------------ -- Insideness testing -- ------------------------ function In_Stroke (Cr : Cairo_Context; X : Gdouble; Y : Gdouble) return Boolean; -- Cr: a cairo context -- X: X coordinate of the point to test -- Y: Y coordinate of the point to test -- -- Tests whether the given point is inside the area that would be -- affected by a Stroke operation given the current path and -- stroking parameters. Surface dimensions and clipping are not taken -- into account. -- -- See Stroke, Set_Line_Width, Set_Line_Join, -- Set_Line_Cap, Set_Dash, and Stroke_Preserve. -- -- Return value: A non-zero value if the point is inside, or zero if -- outside. function In_Fill (Cr : Cairo_Context; X : Gdouble; Y : Gdouble) return Boolean; -- Cr: a cairo context -- X: X coordinate of the point to test -- Y: Y coordinate of the point to test -- -- Tests whether the given point is inside the area that would be -- affected by a Fill operation given the current path and -- filling parameters. Surface dimensions and clipping are not taken -- into account. -- -- See Fill, Set_Fill_Rule and Fill_Preserve. -- -- Return value: A non-zero value if the point is inside, or zero if -- outside. ------------------------- -- Rectangular extents -- ------------------------- procedure Stroke_Extents (Cr : Cairo_Context; X1 : access Gdouble; Y1 : access Gdouble; X2 : access Gdouble; Y2 : access Gdouble); -- Cr: a cairo context -- X1: left of the resulting extents -- Y1: top of the resulting extents -- X2: right of the resulting extents -- Y2: bottom of the resulting extents -- -- Computes a bounding box in user coordinates covering the area that -- would be affected, (the "inked" area), by a Stroke -- operation given the current path and stroke parameters. -- If the current path is empty, returns an empty rectangle ((0,0), (0,0)). -- Surface dimensions and clipping are not taken into account. -- -- Note that if the line width is set to exactly zero, then -- Stroke_Extents will return an empty rectangle. Contrast with -- Path_Extents which can be used to compute the non-empty -- bounds as the line width approaches zero. -- -- Note that Stroke_Extents must necessarily do more work to -- compute the precise inked areas in light of the stroke parameters, -- so Path_Extents may be more desirable for sake of -- performance if non-inked path extents are desired. -- -- See Stroke, Set_Line_Width, Set_Line_Join, Set_Line_Cap, Set_Dash, and -- Stroke_Preserve. procedure Fill_Extents (Cr : Cairo_Context; X1 : access Gdouble; Y1 : access Gdouble; X2 : access Gdouble; Y2 : access Gdouble); -- Cr: a cairo context -- X1: left of the resulting extents -- Y1: top of the resulting extents -- X2: right of the resulting extents -- Y2: bottom of the resulting extents -- -- Computes a bounding box in user coordinates covering the area that -- would be affected, (the "inked" area), by a Fill operation -- given the current path and fill parameters. If the current path is -- empty, returns an empty rectangle ((0,0), (0,0)). Surface -- dimensions and clipping are not taken into account. -- -- Contrast with Path_Extents, which is similar, but returns -- non-zero extents for some paths with no inked area, (such as a -- simple line segment). -- -- Note that Fill_Extents must necessarily do more work to -- compute the precise inked areas in light of the fill rule, so -- Path_Extents may be more desirable for sake of performance -- if the non-inked path extents are desired. -- -- See Fill, Set_Fill_Rule and Fill_Preserve. -------------- -- Clipping -- -------------- procedure Reset_Clip (Cr : Cairo_Context); -- Cr: a cairo context -- -- Reset the current clip region to its original, unrestricted -- state. That is, set the clip region to an infinitely large shape -- containing the target surface. Equivalently, if infinity is too -- hard to grasp, one can imagine the clip region being reset to the -- exact bounds of the target surface. -- -- Note that code meant to be reusable should not call -- Reset_Clip as it will cause results unexpected by higher-level code -- which calls Clip. Consider using Save and Restore around Clip as a more -- robust means of temporarily restricting the clip region. procedure Clip (Cr : Cairo_Context); -- Cr: a cairo context -- -- Establishes a new clip region by intersecting the current clip -- region with the current path as it would be filled by Fill -- and according to the current fill rule (see Set_Fill_Rule). -- -- After Clip, the current path will be cleared from the cairo -- context. -- -- The current clip region affects all drawing operations by -- effectively masking out any changes to the surface that are outside -- the current clip region. -- -- Calling Clip can only make the clip region smaller, never -- larger. But the current clip is part of the graphics state, so a -- temporary restriction of the clip region can be achieved by -- calling Clip within a Save/Restore -- pair. The only other means of increasing the size of the clip -- region is Reset_Clip. procedure Clip_Preserve (Cr : Cairo_Context); -- Cr: a cairo context -- -- Establishes a new clip region by intersecting the current clip -- region with the current path as it would be filled by Fill -- and according to the current fill rule (see Set_Fill_Rule). -- -- Unlike Clip, Clip_Preserve preserves the path within -- the cairo context. -- -- The current clip region affects all drawing operations by -- effectively masking out any changes to the surface that are outside -- the current clip region. -- -- Calling Clip_Preserve can only make the clip region smaller, never -- larger. But the current clip is part of the graphics state, so a -- temporary restriction of the clip region can be achieved by -- calling Clip_Preserve within a Save/Restore -- pair. The only other means of increasing the size of the clip -- region is Reset_Clip. procedure Clip_Extents (Cr : Cairo_Context; X1 : out Gdouble; Y1 : out Gdouble; X2 : out Gdouble; Y2 : out Gdouble); -- Cr: a cairo context -- X1: left of the resulting extents -- Y1: top of the resulting extents -- X2: right of the resulting extents -- Y2: bottom of the resulting extents -- -- Computes a bounding box in user coordinates covering the area inside the -- current clip. -- -- Since: 1.4 type Cairo_Rectangle is record X : aliased Gdouble; Y : aliased Gdouble; Width : aliased Gdouble; Height : aliased Gdouble; end record; -- X: X coordinate of the left side of the rectangle -- Y: Y coordinate of the the top side of the rectangle -- Width: Width of the rectangle -- Height: Height of the rectangle -- -- A data structure for holding a rectangle. -- -- Since: 1.4 type Cairo_Rectangle_Array is array (Natural) of Cairo_Rectangle; type Cairo_Rectangle_Array_Access is access all Cairo_Rectangle_Array; type Cairo_Rectangle_List is record Status : aliased Cairo_Status; Rectangles : Cairo_Rectangle_Array_Access; -- Warning: for efficiency reasons, Rectangles is a direct mapping to -- the C structure. Therefore, there is no bounds checking on this -- array, user needs to make sure only to access data between indexes 0 -- and Num_Rectanges-1. Num_Rectangles : aliased Gint; end record; -- Status: Error Status of the rectangle list -- Rectangles: Array containing the Rectangles -- Num_Rectangles: Number of rectangles in this list -- -- A data structure for holding a Dynamically allocated -- array of rectangles. -- -- Since: 1.4 pragma Convention (C_Pass_By_Copy, Cairo_Rectangle_List); type Cairo_Rectangle_List_Access is access all Cairo_Rectangle_List; function Copy_Clip_Rectangle_List (Cr : Cairo_Context) return Cairo_Rectangle_List_Access; -- Cr: a cairo context -- -- Gets the current clip region as a list of rectangles in user -- coordinates. -- Never returns NULL. -- -- The status in the list may be Cairo_Status_Clip_Not_Representable to -- indicate that the clip region cannot be represented as a list of -- user-space rectangles. The status may have other values to indicate -- other errors. -- -- Returns: the current clip region as a list of rectangles in user -- coordinates, -- which should be destroyed using Rectangle_List_Destroy. -- -- Since: 1.4 procedure Rectangle_List_Destroy (Rectangle_List : access Cairo_Rectangle_List); -- Rectangle_List: a rectangle list, as obtained from Copy_Clip_Rectangles -- -- Unconditionally frees Rectangle_List and all associated -- references. After this call, the Rectangle_List pointer must not -- be dereferenced. -- -- Since: 1.4 ------------------------- -- Font/Text functions -- ------------------------- type Cairo_Scaled_Font is private; -- A Cairo_Scaled_Font is a font scaled to a particular size and device -- resolution. A Cairo_Scaled_Font is most useful for low-level font -- usage where a library or application wants to cache a reference -- to a scaled font to speed up the computation of metrics. -- -- There are various types of scaled fonts, depending on the font backend -- they use. The type of a scaled font can be queried using -- Cairo.Scaled_Font.Get_Type. -- -- Memory management of Cairo_Scaled_Font is done with -- Cairo.Scaled_Font.Reference and Cairo.Scaled_Font.Destroy. type Cairo_Font_Face is private; -- A Cairo_Font_Face specifies all aspects of a font other -- than the size or font matrix (a font matrix is used to distort -- a font by sheering it or scaling it unequally in the two -- directions) . A font face can be set on a Cairo_Context by using -- Set_Font_Face; the size and font matrix are set with -- Set_Font_Size and Set_Font_Matrix. -- -- There are various types of font faces, depending on the font backend -- they use. The type of a font face can be queried using -- Cairo.Font_Face.Get_Type. -- -- Memory management of Cairo_Font_Face is done with -- Cairo.Font_Face.Reference and Cairo.Font_Face.Destroy. -- -- The Cairo_glyph structure holds information about a single glyph when -- drawing or measuring text. A font is (in simple terms) a collection of -- shapes used to draw text. A glyph is one of these shapes. There can be -- multiple glyphs for a single character (alternates to be used in -- different contexts, for example), or a glyph can be a ligature of -- multiple characters. Cairo doesn't expose any way of converting input -- text into glyphs, so in order to use the Cairo interfaces that take -- arrays of glyphs, you must directly access the appropriate underlying -- font system. -- -- Note that the offsets given by X and Y are not cumulative. When -- drawing or measuring text, each glyph is individually positioned -- with respect to the overall origin type Cairo_Glyph is record Index : aliased Gulong; -- Glyph Index in the font. The exact interpretation of the -- glyph index depends on the font technology being used. X : aliased Gdouble; -- The offset in the X direction between the origin used for -- drawing or measuring the string and the origin of this glyph. Y : aliased Gdouble; -- The offset in the Y direction between the origin used for drawing or -- measuring the string and the origin of this glyph. end record; pragma Convention (C_Pass_By_Copy, Cairo_Glyph); type Cairo_Text_Cluster is record Num_Bytes : aliased Gint; -- The number of bytes of UTF-8 text covered by cluster Num_Glyphs : aliased Gint; -- The number of glyphs covered by cluster end record; -- The Cairo_text_cluster structure holds information about a single text -- cluster. A text cluster is a minimal mapping of some glyphs -- corresponding to some UTF-8 text. -- -- For a cluster to be valid, both num_bytes and num_glyphs should -- be non-negative, and at least one should be non-zero. -- Note that clusters with zero glyphs are not as well supported as -- normal clusters. For example, PDF rendering applications typically -- ignore those clusters when PDF text is being selected. -- -- See Show_Text_Glyphs for how clusters are used in advanced -- text operations. -- -- Since: 1.8 pragma Convention (C_Pass_By_Copy, Cairo_Text_Cluster); subtype Cairo_Text_Cluster_Flags is Guint; -- Specifies properties of a text cluster mapping. -- -- Since: 1.8 Cairo_Text_Cluster_Flag_Backward : constant Cairo_Text_Cluster_Flags := 1; -- The clusters in the cluster array map to glyphs in the glyph array from -- end to start. type Cairo_Text_Extents is record X_Bearing : aliased Gdouble; -- The horizontal distance from the origin to the -- leftmost part of the glyphs as drawn. Positive if the -- glyphs lie entirely to the right of the origin. Y_Bearing : aliased Gdouble; -- The vertical distance from the origin to the -- topmost part of the glyphs as drawn. Positive only if the -- glyphs lie completely below the origin; will usually be -- negative. Width : aliased Gdouble; -- Width of the glyphs as drawn Height : aliased Gdouble; -- Height of the glyphs as drawn X_Advance : aliased Gdouble; -- Distance to advance in the X direction after drawing these glyphs Y_Advance : aliased Gdouble; -- Distance to advance in the Y direction -- after drawing these glyphs. Will typically be zero except -- for vertical text layout as found in East-Asian languages. end record; -- The Cairo_text_extents structure stores the extents of a single glyph -- or a string of glyphs in user-space coordinates. Because text extents -- are in user-space coordinates, they are mostly, but not entirely, -- independent of the current transformation matrix. If you call -- Scale (Cr, 2.0, 2.0), text will be drawn twice as big, but the reported -- text extents will not be doubled. They will change slightly due to -- hinting (so you can't assume that metrics are independent of the -- transformation matrix), but otherwise will remain unchanged. pragma Convention (C_Pass_By_Copy, Cairo_Text_Extents); type Cairo_Font_Extents is record Ascent : aliased Gdouble; -- The distance that the font extends above the baseline. -- Note that this is not always exactly equal to the maximum -- of the extents of all the glyphs in the font, but rather -- is picked to express the font designer's intent as to -- how the font should align with elements above it. Descent : aliased Gdouble; -- The distance that the font extends below the baseline. -- This value is positive for typical fonts that include -- portions below the baseline. Note that this is not always -- exactly equal to the maximum of the extents of all the -- glyphs in the font, but rather is picked to express the -- font designer's intent as to how the the font should -- align with elements below it. Height : aliased Gdouble; -- The recommended vertical distance between baselines when -- setting consecutive lines of text with the font. This -- is greater than ascent+descent by a -- quantity known as the line spacing or external leading. When space is -- at a premium, most fonts can be set with only a distance of -- ascent+descent between lines. Max_X_Advance : aliased Gdouble; -- The maximum distance in the X direction that -- the the origin is advanced for any glyph in the font. Max_Y_Advance : aliased Gdouble; -- The maximum distance in the Y direction that -- the the origin is advanced for any glyph in the font. -- this will be zero for normal fonts used for horizontal -- writing. (The scripts of East Asia are sometimes written -- vertically.) end record; -- The Cairo_font_extents structure stores metric information for -- a font. Values are given in the current user-space coordinate -- system. -- -- Because font metrics are in user-space coordinates, they are -- mostly, but not entirely, independent of the current transformation -- matrix. If you call Scale (Cr, 2.0, 2.0), text will be drawn twice as -- big, but the reported text extents will not be doubled. They will -- change slightly due to hinting (so you can't assume that metrics are -- independent of the transformation matrix), but otherwise will remain -- unchanged. pragma Convention (C_Pass_By_Copy, Cairo_Font_Extents); type Cairo_Font_Slant is ( Cairo_Font_Slant_Normal, Cairo_Font_Slant_Italic, Cairo_Font_Slant_Oblique); -- Specifies variants of a font face based on their slant. pragma Convention (C, Cairo_Font_Slant); type Cairo_Font_Weight is ( Cairo_Font_Weight_Normal, Cairo_Font_Weight_Bold); -- Specifies variants of a font face based on their weight. pragma Convention (C, Cairo_Font_Weight); type Cairo_Subpixel_Order is (Cairo_Subpixel_Order_Default, -- Use the default subpixel order for the target device Cairo_Subpixel_Order_Rgb, -- Subpixel elements are arranged horizontally with red at the left Cairo_Subpixel_Order_Bgr, -- Subpixel elements are arranged horizontally with blue at the left Cairo_Subpixel_Order_Vrgb, -- Subpixel elements are arranged vertically with red at the top Cairo_Subpixel_Order_Vbgr -- Subpixel elements are arranged vertically with blue at the top ); -- The subpixel order specifies the order of color elements within -- each pixel on the display device when rendering with an -- antialiasing mode of CAIRO_ANTIALIAS_SUBPIXEL. pragma Convention (C, Cairo_Subpixel_Order); type Cairo_Hint_Style is (Cairo_Hint_Style_Default, -- Use the default hint style for font backend and target device Cairo_Hint_Style_None, -- Do not hint outlines Cairo_Hint_Style_Slight, -- Hint outlines slightly to improve contrast while retaining good -- fidelity to the original shapes. Cairo_Hint_Style_Medium, -- Hint outlines with medium strength giving a compromise between -- fidelity to the original shapes and contrast Cairo_Hint_Style_Full -- Hint outlines to maximize contrast ); -- Specifies the type of hinting to do on font outlines. Hinting -- is the process of fitting outlines to the pixel grid in order -- to improve the appearance of the result. Since hinting outlines -- involves distorting them, it also reduces the faithfulness -- to the original outline shapes. Not all of the outline hinting -- styles are supported by all font backends. -- -- New entries may be added in future versions. pragma Convention (C, Cairo_Hint_Style); type Cairo_Hint_Metrics is (Cairo_Hint_Metrics_Default, -- Hint metrics in the default manner for the font backend and target -- device Cairo_Hint_Metrics_Off, -- Do not hint font metrics Cairo_Hint_Metrics_On -- Hint font metrics ); -- Specifies whether to hint font metrics; hinting font metrics -- means quantizing them so that they are integer values in -- device space. Doing this improves the consistency of -- letter and line spacing, however it also means that text -- will be laid out differently at different zoom factors. pragma Convention (C, Cairo_Hint_Metrics); type Cairo_Font_Options is private; -- An opaque structure holding all options that are used when -- rendering fonts. -- -- Individual features of a Cairo_Font_Options can be set or -- accessed using functions named -- Cairo.Font_Options.Set_ and -- Cairo.Font_Options.Get_, like -- Cairo.Font_Options.Set_Antialias and -- Cairo.Font_Options.Get_Antialias. -- -- New features may be added to a Cairo_font_options in the -- future. For this reason, Cairo.Font_Options.Copy, -- Cairo.Font_Options.Equal, Cairo.Font_Options.Merge, and -- Cairo.Font_Options.Hash should be used to copy, check -- for equality, merge, or compute a hash value of -- Cairo_Font_Options objects. -- This interface is for dealing with text as text, not caring about the -- font object inside the the Cairo_Context. procedure Select_Font_Face (Cr : Cairo_Context; Family : String; Slant : Cairo_Font_Slant; Weight : Cairo_Font_Weight); -- Cr: a Cairo_Context -- Family: a font Family name, encoded in UTF-8 -- Slant: the Slant for the font -- Weight: the Weight for the font -- -- Note: The Select_Font_Face function call is part of what -- the cairo designers call the "toy" text API. It is convenient for -- short demos and simple programs, but it is not expected to be -- adequate for serious text-using applications. -- -- Selects a family and style of font from a simplified description as -- a family name, slant and weight. Cairo provides no operation to -- list available family names on the system (this is a "toy", -- remember), but the standard CSS2 generic family names, ("serif", -- "sans-serif", "cursive", "fantasy", "monospace"), are likely to -- work as expected. -- -- It is expected that most applications will need to use a more -- comprehensive font handling and text layout library, (for example, -- pango), in conjunction with cairo. -- -- If text is drawn without a call to Select_Font_Face, (nor -- Set_Font_Face nor Set_Scaled_Font), the default -- family is platform-specific, but is essentially "sans-serif". -- Default slant is Cairo_Font_Slant_Normal, and default weight is -- Cairo_Font_Weight_Normal. -- -- This function is equivalent to a call to -- Cairo.Font_Face.Toy_Font_Face_Create followed by Set_Font_Face. procedure Set_Font_Size (Cr : Cairo_Context; Size : Gdouble); -- Cr: a Cairo_Context -- Size: the new font Size, in user space units -- -- Sets the current font matrix to a scale by a factor of size, replacing -- any font matrix previously set with Set_Font_Size or -- Set_Font_Matrix. This results in a font size of size user space -- units. (More precisely, this matrix will result in the font's -- em-square being a size by size square in user space.) -- -- If text is drawn without a call to Set_Font_Size, (nor Set_Font_Matrix -- nor Set_Scaled_Font), the default font size is 10.0. procedure Set_Font_Matrix (Cr : Cairo_Context; Matrix : access Cairo_Matrix); -- Cr: a Cairo_Context -- Matrix: a Cairo_Matrix describing a transform to be applied to -- the current font. -- -- Sets the current font matrix to matrix. The font matrix gives a -- transformation from the design space of the font (in this space, -- the em-square is 1 unit by 1 unit) to user space. Normally, a -- simple scale is used (see Set_Font_Size), but a more -- complex font matrix can be used to shear the font -- or stretch it unequally along the two axes procedure Get_Font_Matrix (Cr : Cairo_Context; Matrix : access Cairo_Matrix); -- Cr: a Cairo_Context -- Matrix: return value for the Matrix -- -- Stores the current font matrix into matrix. See Set_Font_Matrix. procedure Set_Font_Options (Cr : Cairo_Context; Options : Cairo_Font_Options); -- Cr: a Cairo_Context -- Options: font Options to use -- -- Sets a set of custom font rendering options for the Cairo_Context. -- Rendering options are derived by merging these options with the -- options derived from underlying surface; if the value in options -- has a default value (like Cairo_Antialias_Default), then the value -- from the surface is used. procedure Get_Font_Options (Cr : Cairo_Context; Options : Cairo_Font_Options); -- Cr: a Cairo_Context -- Options: a Cairo_Font_Options object into which to store -- the retrieved options. All existing values are overwritten -- -- Retrieves font rendering options set via Set_Font_Options. -- Note that the returned options do not include any options derived -- from the underlying surface; they are literally the options -- passed to Set_Font_Options. procedure Set_Font_Face (Cr : Cairo_Context; Font_Face : Cairo_Font_Face); -- Cr: a Cairo_Context -- Font_Face: a Cairo_Font_Face, or Null_Font_Face to restore to the -- default font -- -- Replaces the current Cairo_Font_Face object in the Cairo_Context with -- font_face. The replaced font face in the Cairo_Context will be -- destroyed if there are no other references to it. function Get_Font_Face (Cr : Cairo_Context) return Cairo_Font_Face; -- Cr: a Cairo_Context -- -- Gets the current font face for a Cairo_Context. -- -- Return value: the current font face. This object is owned by -- cairo. To keep a reference to it, you must call -- Cairo.Font_Face.Reference. -- -- This function never returns Null_Font_Face. If memory cannot be -- allocated, a special "nil" Cairo_Font_Face object will be returned on -- which Cairo.Font_Face.Status returns Cairo_Status_No_Memory. Using this -- nil object will cause its error state to propagate to other objects it -- is passed to, (for example, calling Set_Font_Face with a nil font -- will trigger an error that will shutdown the Cairo_Context object). procedure Set_Scaled_Font (Cr : Cairo_Context; Scaled_Font : access Cairo_Scaled_Font); -- Cr: a Cairo_Context -- Scaled_Font: a Cairo_Scaled_Font -- -- Replaces the current font face, font matrix, and font options in -- the Cairo_Context with those of the Cairo_Scaled_Font. Except for -- some translation, the current CTM of the Cairo_Context should be the -- same as that of the Cairo_Scaled_Font, which can be accessed -- using Cairo.Scaled_Font.Get_Ctm. -- -- Since: 1.2 function Get_Scaled_Font (Cr : Cairo_Context) return Cairo_Scaled_Font; -- Cr: a Cairo_Context -- -- Gets the current scaled font for a Cairo_Context. -- -- Return value: the current scaled font. This object is owned by -- cairo. To keep a reference to it, you must call -- Cairo.Scaled_Font.Reference. -- -- This function never returns Null_Font_Face. If memory cannot be -- allocated, a special "nil" Cairo_Scaled_Font object will be returned on -- which Cairo.Font_Face.Status returns Cairo_Status_No_Memory. Using this -- nil object will cause its error state to propagate to other objects it -- is passed to, (for example, calling Set_Font_Face with a nil font -- will trigger an error that will shutdown the Cairo_Context object). -- -- Since: 1.4 procedure Show_Text (Cr : Cairo_Context; Utf8 : String); -- Cr: a cairo context -- Utf8: a NUL-terminated string of text encoded in UTF-8, or Null_Ptr -- -- A drawing operator that generates the shape from a string of UTF-8 -- characters, rendered according to the current Font_Face, Font_Size -- (Font_Matrix), and Font_Options. -- -- This function first computes a set of glyphs for the string of -- text. The first glyph is placed so that its origin is at the -- current point. The origin of each subsequent glyph is offset from -- that of the previous glyph by the advance values of the previous -- glyph. -- -- After this call the current point is moved to the origin of where -- the next glyph would be placed in this same progression. That is, -- the current point will be at the origin of the final glyph offset -- by its advance values. This allows for easy display of a single -- logical string with multiple calls to Show_Text. -- -- Note: The Show_Text function call is part of what the cairo -- designers call the "toy" text API. It is convenient for short demos -- and simple programs, but it is not expected to be adequate for -- serious text-using applications. See Show_Glyphs for the -- "real" text display API in cairo. procedure Show_Glyphs (Cr : Cairo_Context; Glyphs : access Cairo_Glyph; Num_Glyphs : Gint); -- Cr: a cairo context -- Glyphs: array of Glyphs to show -- Num_Glyphs: number of glyphs to show -- -- A drawing operator that generates the shape from an array of glyphs, -- rendered according to the current font face, font size -- (font matrix), and font options. procedure Text_Path (Cr : Cairo_Context; Utf8 : String); -- Cr: a cairo context -- Utf8: a NUL-terminated string of text encoded in UTF-8, or Null_Ptr -- -- Adds closed paths for text to the current path. The generated -- path if filled, achieves an effect similar to that of -- Show_Text. -- -- Text conversion and positioning is done similar to Show_Text. -- -- Like Show_Text, After this call the current point is -- moved to the origin of where the next glyph would be placed in -- this same progression. That is, the current point will be at -- the origin of the final glyph offset by its advance values. -- This allows for chaining multiple calls to to Cairo_Text_Path -- without having to set current point in between. -- -- Note: The Text_Path function call is part of what the cairo -- designers call the "toy" text API. It is convenient for short demos -- and simple programs, but it is not expected to be adequate for -- serious text-using applications. See Glyph_Path for the -- "real" text path API in cairo. procedure Text_Extents (Cr : Cairo_Context; Utf8 : Gtkada.Types.Chars_Ptr; Extents : access Cairo_Text_Extents); -- Cr: a Cairo_Context -- Utf8: a NUL-terminated string of text encoded in UTF-8, or Null_Ptr -- Extents: a Cairo_Text_Extents object into which the results -- will be stored -- -- Gets the extents for a string of text. The extents describe a -- user-space rectangle that encloses the "inked" portion of the text, -- (as it would be drawn by Show_Text). Additionally, the -- x_advance and y_advance values indicate the amount by which the -- current point would be advanced by Cairo_Show_Text. -- -- Note that whitespace characters do not directly contribute to the -- size of the rectangle (extents.width and extents.height). They do -- contribute indirectly by changing the position of non-whitespace -- characters. In particular, trailing whitespace characters are -- likely to not affect the size of the rectangle, though they will -- affect the x_advance and y_advance values. procedure Glyph_Extents (Cr : Cairo_Context; Glyphs : access Cairo_Glyph; Num_Glyphs : Gint; Extents : access Cairo_Text_Extents); -- Cr: a Cairo_Context -- Glyphs: an array of Cairo_Glyph objects -- Num_Glyphs: the number of elements in glyphs -- Extents: a Cairo_Text_Extents object into which the results -- will be stored -- -- Gets the extents for an array of glyphs. The extents describe a -- user-space rectangle that encloses the "inked" portion of the -- glyphs, (as they would be drawn by Show_Glyphs). -- Additionally, the X_Advance and Y_Advance values indicate the -- amount by which the current point would be advanced by -- Show_Glyphs. -- -- Note that whitespace glyphs do not contribute to the size of the -- rectangle (Extents.Width and Extents.Height). procedure Font_Extents (Cr : Cairo_Context; Extents : access Cairo_Font_Extents); -- Cr: a Cairo_Context -- Extents: a Cairo_Font_Extents object into which the results -- will be stored. -- -- Gets the font extents for the currently selected font. type Cairo_Font_Type is (Cairo_Font_Type_Toy, -- The font was created using cairo's toy font api (Since: 1.8) Cairo_Font_Type_Ft, -- The font is of type FreeType Cairo_Font_Type_Win32, -- The font is of type Win32 Cairo_Font_Type_Quartz, -- The font is of type Quartz (Since: 1.6) Cairo_Font_Type_User -- The font was create using cairo's user font api ); -- Cairo_font_type is used to describe the type of a given font -- face or scaled font. The font types are also known as "font -- backends" within Cairo. -- -- The type of a font face is determined by the function used to -- create it, which will generally be of the form -- _Font_Face_Create. The font face type -- can be queried -- with Cairo.Font_Face.Get_Type -- -- The various Cairo_Font_Face functions can be used with a font face -- of any type. -- -- The type of a scaled font is determined by the type of the font -- face passed to Cairo.Scaled_Font.Create. The scaled font type can -- be queried with Cairo.Scaled_Font.Get_Type -- -- The various Cairo_scaled_font functions can be used with scaled -- fonts of any type, but some font backends also provide -- type-specific functions that must only be called with a scaled font -- of the appropriate type. These functions have names that begin with -- _Scaled_Font such as Ft_Scaled_Font_Lock_Face. -- -- The behavior of calling a type-specific function with a scaled font -- of the wrong type is undefined. -- -- New entries may be added in future versions. -- -- Since: 1.2 pragma Convention (C, Cairo_Font_Type); --------------------- -- Query functions -- --------------------- function Get_Operator (Cr : Cairo_Context) return Cairo_Operator; -- Cr: a cairo context -- -- Gets the current compositing operator for a cairo context. -- -- Return value: the current compositing operator. function Get_Source (Cr : Cairo_Context) return Cairo_Pattern; -- Cr: a cairo context -- -- Gets the current source pattern for Cr. -- -- Return value: the current source pattern. This object is owned by -- cairo. To keep a reference to it, you must call -- Cairo.Pattern.Reference. function Get_Tolerance (Cr : Cairo_Context) return Gdouble; -- Cr: a cairo context -- -- Gets the current tolerance value, as set by Set_Tolerance. -- -- Return value: the current tolerance value. function Get_Antialias (Cr : Cairo_Context) return Cairo_Antialias; -- Cr: a cairo context -- -- Gets the current shape antialiasing mode, as set by Set_Antialias. -- -- Return value: the current shape antialiasing mode. function Has_Current_Point (Cr : Cairo_Context) return Boolean; -- Cr: a cairo context -- -- Returns whether a current point is defined on the current path. -- See Get_Current_Point for details on the current point. -- -- Return value: whether a current point is defined. -- -- Since: 1.6 procedure Get_Current_Point (Cr : Cairo_Context; X : access Gdouble; Y : access Gdouble); -- Cr: a cairo context -- X: return value for X coordinate of the current point -- Y: return value for Y coordinate of the current point -- -- Gets the current point of the current path, which is -- conceptually the final point reached by the path so far. -- -- The current point is returned in the user-space coordinate -- system. If there is no defined current point or if cr is in an -- error status, X and Y will both be set to 0.0. It is possible to -- check this in advance with Has_Current_Point. -- -- Most path construction functions alter the current point. See the -- following for details on how they affect the current point: -- New_Path, New_Sub_Path, Append_Path, Close_Path, Move_To, Line_To, -- Curve_To, Rel_Move_To, Rel_Line_To, Rel_Curve_To, Arc, Arc_Negative, -- Rectangle, Text_Path, Glyph_Path, Stroke_To_Path. -- -- Some functions use and alter the current point but do not otherwise -- change current path: Show_Text. -- -- Some functions unset the current path and as a result, current point: -- Fill, Stroke. function Get_Fill_Rule (Cr : Cairo_Context) return Cairo_Fill_Rule; -- Cr: a cairo context -- -- Gets the current fill rule, as set by Set_Fill_Rule. -- -- Return value: the current fill rule. function Get_Line_Width (Cr : Cairo_Context) return Gdouble; -- Cr: a cairo context -- -- This function returns the current line width value exactly as set by -- Set_Line_Width. Note that the value is unchanged even if -- the CTM has changed between the calls to Set_Line_Width and -- Get_Line_Width. -- -- Return value: the current line width. function Get_Line_Cap (Cr : Cairo_Context) return Cairo_Line_Cap; -- Cr: a cairo context -- -- Gets the current line cap style, as set by Set_Line_Cap. -- -- Return value: the current line cap style. function Get_Line_Join (Cr : Cairo_Context) return Cairo_Line_Join; -- Cr: a cairo context -- -- Gets the current line join style, as set by Set_Line_Join. -- -- Return value: the current line join style. function Get_Miter_Limit (Cr : Cairo_Context) return Gdouble; -- Cr: a cairo context -- -- Gets the current miter limit, as set by Set_Miter_Limit. -- -- Return value: the current miter limit. function Get_Dash_Count (Cr : Cairo_Context) return Gint; -- Cr: a Cairo_Context -- -- This function returns the length of the dash array in cr (0 if dashing -- is not currently in effect). -- -- See also Set_Dash and Get_Dash. -- -- Return value: the length of the dash array, or 0 if no dash array set. -- -- Since: 1.4 type Dash_Array_Access is access all Dash_Array; procedure Get_Dash (Cr : Cairo_Context; Dashes : out Dash_Array_Access; Offset : out Gdouble); -- Cr: a Cairo_Context -- Dashes: return value for the dash array, or null -- Offset: return value for the current dash Offset, or null -- -- Gets the current dash array. -- -- Since: 1.4 procedure Get_Matrix (Cr : Cairo_Context; Matrix : access Cairo_Matrix); -- Cr: a cairo context -- Matrix: return value for the Matrix -- -- Stores the current transformation matrix (CTM) into matrix. function Get_Target (Cr : Cairo_Context) return Cairo_Surface; -- Cr: a cairo context -- -- Gets the target surface for the cairo context as passed to Create. -- -- This function will always return a valid pointer, but the result -- can be a "nil" surface if cr is already in an error state, -- (ie. Cairo_Status /= Cairo_Status_Success). -- A nil surface is indicated by -- Cairo.Surface.Status/= Cairo_Status_Success. -- -- Return value: the target surface. This object is owned by cairo. To -- keep a reference to it, you must call Cairo.Surface.Reference. function Get_Group_Target (Cr : Cairo_Context) return Cairo_Surface; -- Cr: a cairo context -- -- Gets the current destination surface for the context. This is either -- the original target surface as passed to Create or the target -- surface for the current group as started by the most recent call to -- Push_Group or Push_Group_With_Content. -- -- This function will always return a valid pointer, but the result -- can be a "nil" surface if cr is already in an error state, -- (ie. Cairo_Status /= Cairo_Status_Success). -- A nil surface is indicated by Cairo_Status /= Cairo_Status_Success. -- -- Return value: the target surface. This object is owned by cairo. To -- keep a reference to it, you must call Cairo.Surface.Reference. -- -- Since: 1.2 type Cairo_Path_Data_Type is (Cairo_Path_Move_To, -- A move-to operation Cairo_Path_Line_To, -- A line-to operation Cairo_Path_Curve_To, -- A curve-to operation Cairo_Path_Close_Path -- A close-path operation ); -- Cairo_path_data is used to describe the type of one portion -- of a path when represented as a Cairo_Path. -- See Cairo_Path_Data for details. pragma Convention (C, Cairo_Path_Data_Type); type Header_Type is record Path_Type : aliased Cairo_Path_Data_Type; Length : aliased Gint; end record; -- A Path header. See Cairo_Path_Data for details. type Point_Type is record X : aliased Gdouble; Y : aliased Gdouble; end record; -- A geometrical point. See Cairo_Path_Data for details. type Cairo_Path_Data (Discr : Guint := 0) is record case Discr is when 0 => Header : aliased Header_Type; when others => Point : aliased Point_Type; end case; end record; -- Cairo_path_data is used to represent the path data inside a -- Cairo_path. -- -- The data structure is designed to try to balance the demands of -- efficiency and ease-of-use. A path is represented as an array of -- Cairo_Path_Data, which is a union of headers and points. -- -- Each portion of the path is represented by one or more elements in -- the array, (one header followed by 0 or more points). The length -- value of the header is the number of array elements for the current -- portion including the header, (ie. length == 1 + of points), and -- where the number of points for each element type is as follows: -- -- Cairo_Path_Move_To: 1 point -- Cairo_Path_Line_To: 1 point -- Cairo_Path_Curve_To: 3 points -- Cairo_Path_Close_Path: 0 points -- -- The semantics and ordering of the coordinate values are consistent -- with Move_To, Line_To, Curve_To, and Close_Path. -- -- Here is sample code for iterating through a Cairo_Path: -- -- declare -- J : Gint; -- Path : Cairo_Path; -- Data : Cairo_Path_Data; -- begin -- Path = Copy_Path (Cr); -- -- J := 0; -- while J < Path.Num_Data loop -- Data := Path.Data(J); -- -- case Data.Header.Path_Type is -- -- when Cairo_Path_Move_To => -- Do_Move_To_Things (Data(1).Point.X, Data(1).Point.Y); -- -- when Cairo_Path_Line_To => -- Do_Line_To_Things (Data(1).Point.X, Data(1).Point.Y); -- -- when Cairo_Path_Curve_To => -- Do_Curve_To_Things (Data(1).Point.X, Data(1).Point.Y, -- Data(2).Point.X, Data(2).Point.Y, -- Data(3).Point.X, Data(3).Point.Y); -- -- when Cairo_Path_Curve_To => -- Do_Close_Path_Things; -- end case; -- -- J := J + Path.Data[J].Header.Length; -- end loop; -- -- Path_Destroy (Path); -- end; -- -- As of cairo 1.4, cairo does not mind if there are more elements in -- a portion of the path than needed. Such elements can be used by -- users of the cairo API to hold extra values in the path data -- structure. For this reason, it is recommended that applications -- always use Data.Header.Length to iterate over the path data, instead of -- hardcoding the number of elements for each element type. type Path_Data_Array is array (Natural) of Cairo_Path_Data; type Path_Data_Array_Access is access all Path_Data_Array; type Cairo_Path is record Status : aliased Cairo_Status; Data : Path_Data_Array_Access; -- Warning: for efficiency reasons, Data is a direct mapping to the C -- structure. Therefore, there is no bounds checking on this array, -- the user needs to make sure only to access data between indexes -- 0 and Num_Data-1. Num_Data : aliased Gint; end record; type Cairo_Path_Access is access all Cairo_Path; -- Status: the current error Status -- Data: the elements in the path -- Num_Data: the number of elements in the data array -- -- A data structure for holding a path. This data structure serves as the -- return value for Copy_Path and Copy_Path_Flat as well the input value -- for Append_Path. -- -- See Cairo_Path_Data for hints on how to iterate over the -- actual data within the path. -- -- The num_data member gives the number of elements in the data -- array. This number is larger than the number of independent path -- portions (defined in Cairo_Path_Data_Type), since the data -- includes both headers and coordinates for each portion. function Copy_Path (Cr : Cairo_Context) return Cairo_Path_Access; -- Cr: a cairo context -- -- Creates a copy of the current path and returns it to the user as a -- Cairo_Path. See Cairo_Path_Data for hints on how to iterate -- over the returned data structure. -- -- This function will always return a valid pointer, but the result -- will have no data (Data = null and Num_Data = 0), if -- either of the following conditions hold: -- -- -> If there is insufficient memory to copy the path. In this -- case Path.Status will be set to Cairo_Status_No_Memory -- -- -> If Cr is already in an error state. In this case -- Path.Status will contain the same status that -- would be returned by Status. -- -- Return value: the copy of the current path. The caller owns the -- returned object and should call Path_Destroy when finished with it. function Copy_Path_Flat (Cr : Cairo_Context) return Cairo_Path_Access; -- Cr: a cairo context -- -- Gets a flattened copy of the current path and returns it to the -- user as a Cairo_Path. See Cairo_Path_Data for hints on -- how to iterate over the returned data structure. -- -- This function is like Copy_Path except that any curves -- in the path will be approximated with piecewise-linear -- approximations, (accurate to within the current tolerance -- value). That is, the result is guaranteed to not have any elements -- of type Cairo_Path_Curve_To which will instead be replaced by a -- series of Cairo_Path_Line_To elements. -- -- This function will always return a valid pointer, but the result will -- have no data (Data = null and Num_Data = 0), if either of the following -- conditions hold: -- -- -> If there is insufficient memory to copy the path. In this -- case Path.Status will be set to Cairo_Status_No_Memory -- -- -> If Cr is already in an error state. In this case -- Path.Status will contain the same status that -- would be returned by Status. -- -- Return value: the copy of the current path. The caller owns the -- returned object and should call Path_Destroy when finished -- with it. procedure Append_Path (Cr : Cairo_Context; Path : access Cairo_Path); -- Cr: a cairo context -- Path: Path to be appended -- -- Append the path onto the current path. The path may be either the return -- value from one of Copy_Path or Copy_Path_Flat or it may be constructed -- manually. See Cairo_Path for details on how the path data structure -- should be initialized, and note that Path.Status must be initialized to -- Cairo_Status_Success. procedure Path_Destroy (Path : access Cairo_Path); -- Path: a path previously returned by either Copy_Path or Copy_Path_Flat. -- -- Immediately releases all memory associated with Path. After a call -- to Path_Destroy the Path pointer is no longer valid and should not be -- used further. -- -- Note: Path_Destroy should only be called with an access to a -- Cairo_Path returned by a cairo function. Any path that is created -- manually (ie. outside of cairo) should be destroyed manually as well. -------------------------- -- Error status queries -- -------------------------- function Status (Cr : Cairo_Context) return Cairo_Status; -- Cr: a cairo context -- -- Checks whether an error has previously occurred for this context. -- -- Returns: the current status of this context, see Cairo_Status Null_Context : constant Cairo_Context; Null_Surface : constant Cairo_Surface; Null_Pattern : constant Cairo_Pattern; Null_Scaled_Font : constant Cairo_Scaled_Font; Null_Font_Face : constant Cairo_Font_Face; Null_Font_Options : constant Cairo_Font_Options; private pragma Linker_Options ("-shared-libgcc"); pragma Convention (C, Cairo_Destroy_Func); pragma Convention (C, Cairo_Status); pragma Convention (C, Cairo_Operator); pragma Convention (C, Cairo_Antialias); pragma Convention (C, Cairo_Fill_Rule); pragma Convention (C, Cairo_Line_Cap); pragma Convention (C, Cairo_Line_Join); pragma Convention (C, Path_Data_Array_Access); pragma Convention (C_Pass_By_Copy, Cairo_Path); pragma Convention (C_Pass_By_Copy, Cairo_Rectangle); pragma Convention (C, Cairo_Rectangle_Array_Access); pragma Convention (C_Pass_By_Copy, Header_Type); pragma Convention (C_Pass_By_Copy, Point_Type); pragma Convention (C_Pass_By_Copy, Cairo_Path_Data); pragma Unchecked_Union (Cairo_Path_Data); type Cairo_Context is new System.Address; Null_Context : constant Cairo_Context := Cairo_Context (System.Null_Address); type Cairo_Surface is new System.Address; Null_Surface : constant Cairo_Surface := Cairo_Surface (System.Null_Address); type Cairo_Pattern is new System.Address; Null_Pattern : constant Cairo_Pattern := Cairo_Pattern (System.Null_Address); type Cairo_Scaled_Font is new System.Address; Null_Scaled_Font : constant Cairo_Scaled_Font := Cairo_Scaled_Font (System.Null_Address); type Cairo_Font_Face is new System.Address; Null_Font_Face : constant Cairo_Font_Face := Cairo_Font_Face (System.Null_Address); type Cairo_Font_Options is new System.Address; Null_Font_Options : constant Cairo_Font_Options := Cairo_Font_Options (System.Null_Address); pragma Import (C, Create, "cairo_create"); pragma Import (C, Reference, "cairo_reference"); pragma Import (C, Get_Reference_Count, "cairo_get_reference_count"); pragma Import (C, Get_User_Data, "cairo_get_user_data"); pragma Import (C, Set_User_Data, "cairo_set_user_data"); pragma Import (C, Save, "cairo_save"); pragma Import (C, Restore, "cairo_restore"); pragma Import (C, Push_Group, "cairo_push_group"); pragma Import (C, Push_Group_With_Content, "cairo_push_group_with_content"); pragma Import (C, Pop_Group, "cairo_pop_group"); pragma Import (C, Pop_Group_To_Source, "cairo_pop_group_to_source"); pragma Import (C, Set_Operator, "cairo_set_operator"); pragma Import (C, Set_Source, "cairo_set_source"); pragma Import (C, Set_Source_Rgb, "cairo_set_source_rgb"); pragma Import (C, Set_Source_Rgba, "cairo_set_source_rgba"); pragma Import (C, Set_Source_Surface, "cairo_set_source_surface"); pragma Import (C, Set_Tolerance, "cairo_set_tolerance"); pragma Import (C, Set_Antialias, "cairo_set_antialias"); pragma Import (C, Set_Fill_Rule, "cairo_set_fill_rule"); pragma Import (C, Set_Line_Width, "cairo_set_line_width"); pragma Import (C, Set_Line_Cap, "cairo_set_line_cap"); pragma Import (C, Set_Line_Join, "cairo_set_line_join"); pragma Import (C, Set_Miter_Limit, "cairo_set_miter_limit"); pragma Import (C, Translate, "cairo_translate"); pragma Import (C, Scale, "cairo_scale"); pragma Import (C, Rotate, "cairo_rotate"); pragma Import (C, Transform, "cairo_transform"); pragma Import (C, Set_Matrix, "cairo_set_matrix"); pragma Import (C, Identity_Matrix, "cairo_identity_matrix"); pragma Import (C, User_To_Device, "cairo_user_to_device"); pragma Import (C, User_To_Device_Distance, "cairo_user_to_device_distance"); pragma Import (C, Device_To_User, "cairo_device_to_user"); pragma Import (C, Device_To_User_Distance, "cairo_device_to_user_distance"); pragma Import (C, New_Path, "cairo_new_path"); pragma Import (C, Move_To, "cairo_move_to"); pragma Import (C, New_Sub_Path, "cairo_new_sub_path"); pragma Import (C, Line_To, "cairo_line_to"); pragma Import (C, Curve_To, "cairo_curve_to"); pragma Import (C, Arc, "cairo_arc"); pragma Import (C, Arc_Negative, "cairo_arc_negative"); pragma Import (C, Rel_Move_To, "cairo_rel_move_to"); pragma Import (C, Rel_Line_To, "cairo_rel_line_to"); pragma Import (C, Rel_Curve_To, "cairo_rel_curve_to"); pragma Import (C, Rectangle, "cairo_rectangle"); pragma Import (C, Close_Path, "cairo_close_path"); pragma Import (C, Path_Extents, "cairo_path_extents"); pragma Import (C, Paint, "cairo_paint"); pragma Import (C, Paint_With_Alpha, "cairo_paint_with_alpha"); pragma Import (C, Mask, "cairo_mask"); pragma Import (C, Mask_Surface, "cairo_mask_surface"); pragma Import (C, Stroke, "cairo_stroke"); pragma Import (C, Stroke_Preserve, "cairo_stroke_preserve"); pragma Import (C, Fill, "cairo_fill"); pragma Import (C, Fill_Preserve, "cairo_fill_preserve"); pragma Import (C, Copy_Page, "cairo_copy_page"); pragma Import (C, Show_Page, "cairo_show_page"); pragma Import (C, Stroke_Extents, "cairo_stroke_extents"); pragma Import (C, Fill_Extents, "cairo_fill_extents"); pragma Import (C, Reset_Clip, "cairo_reset_clip"); pragma Import (C, Clip, "cairo_clip"); pragma Import (C, Clip_Preserve, "cairo_clip_preserve"); pragma Import (C, Clip_Extents, "cairo_clip_extents"); pragma Import (C, Copy_Clip_Rectangle_List, "cairo_copy_clip_rectangle_list"); pragma Import (C, Rectangle_List_Destroy, "cairo_rectangle_list_destroy"); pragma Import (C, Set_Font_Size, "cairo_set_font_size"); pragma Import (C, Set_Font_Matrix, "cairo_set_font_matrix"); pragma Import (C, Get_Font_Matrix, "cairo_get_font_matrix"); pragma Import (C, Set_Font_Options, "cairo_set_font_options"); pragma Import (C, Get_Font_Options, "cairo_get_font_options"); pragma Import (C, Set_Font_Face, "cairo_set_font_face"); pragma Import (C, Get_Font_Face, "cairo_get_font_face"); pragma Import (C, Set_Scaled_Font, "cairo_set_scaled_font"); pragma Import (C, Get_Scaled_Font, "cairo_get_scaled_font"); pragma Import (C, Show_Glyphs, "cairo_show_glyphs"); -- pragma Import (C, Show_Text_Glyphs, "cairo_show_text_glyphs"); -- pragma Import (C, Glyph_Path, "cairo_glyph_path"); pragma Import (C, Text_Extents, "cairo_text_extents"); pragma Import (C, Glyph_Extents, "cairo_glyph_extents"); pragma Import (C, Font_Extents, "cairo_font_extents"); pragma Import (C, Get_Operator, "cairo_get_operator"); pragma Import (C, Get_Source, "cairo_get_source"); pragma Import (C, Get_Tolerance, "cairo_get_tolerance"); pragma Import (C, Get_Antialias, "cairo_get_antialias"); pragma Import (C, Get_Current_Point, "cairo_get_current_point"); pragma Import (C, Get_Fill_Rule, "cairo_get_fill_rule"); pragma Import (C, Get_Line_Width, "cairo_get_line_width"); pragma Import (C, Get_Line_Cap, "cairo_get_line_cap"); pragma Import (C, Get_Line_Join, "cairo_get_line_join"); pragma Import (C, Get_Miter_Limit, "cairo_get_miter_limit"); pragma Import (C, Get_Dash_Count, "cairo_get_dash_count"); pragma Import (C, Get_Matrix, "cairo_get_matrix"); pragma Import (C, Get_Target, "cairo_get_target"); pragma Import (C, Get_Group_Target, "cairo_get_group_target"); pragma Import (C, Copy_Path, "cairo_copy_path"); pragma Import (C, Copy_Path_Flat, "cairo_copy_path_flat"); pragma Import (C, Append_Path, "cairo_append_path"); pragma Import (C, Path_Destroy, "cairo_path_destroy"); pragma Import (C, Status, "cairo_status"); end Cairo; gtkada-24.0.0/src/fontconfig.adb000066400000000000000000000046711446021174000164320ustar00rootroot00000000000000------------------------------------------------------------------------------ -- GtkAda - Ada95 binding for Gtk+/Gnome -- -- -- -- Copyright (C) 2015-2018, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ with System; use System; with Gtkada.Types; use Gtkada.Types; with Interfaces.C; use Interfaces.C; package body Fontconfig is ----------------------- -- App_Font_Add_File -- ----------------------- function App_Font_Add_File (Filename : String) return Boolean is function Add_Font_File (FC_Config : System.Address; File : Gtkada.Types.Chars_Ptr) return Interfaces.C.int; pragma Import (C, Add_Font_File, "FcConfigAppFontAddFile"); Path : Gtkada.Types.Chars_Ptr := New_String (Filename); Result : Boolean; begin Result := Add_Font_File (System.Null_Address, Path) /= 0; Free (Path); return Result; end App_Font_Add_File; end Fontconfig; gtkada-24.0.0/src/fontconfig.ads000066400000000000000000000040621446021174000164450ustar00rootroot00000000000000------------------------------------------------------------------------------ -- GtkAda - Ada95 binding for Gtk+/Gnome -- -- -- -- Copyright (C) 2015-2018, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ -- A binding to a convenient Fontconfig API package Fontconfig is function App_Font_Add_File (Filename : String) return Boolean; -- Adds an application-specific font to the configuration. -- Return True if the font was added successfully. -- Filename is the full path to the font file. -- This only works on UNIX/Linux. end Fontconfig; gtkada-24.0.0/src/gdk-cairo.adb000066400000000000000000000070071446021174000161320ustar00rootroot00000000000000------------------------------------------------------------------------------ -- GtkAda - Ada95 binding for Gtk+/Gnome -- -- -- -- Copyright (C) 2010-2018, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ with Glib.Object; use Glib.Object; with System; use System; package body Gdk.Cairo is ------------ -- Create -- ------------ function Create (Window : Gdk_Window) return Cairo_Context is function Internal (S : Gdk_Window) return Cairo_Context; pragma Import (C, Internal, "gdk_cairo_create"); Cr : Cairo_Context; begin Cr := Internal (Window); return Cr; end Create; ----------------------- -- Set_Source_Pixbuf -- ----------------------- procedure Set_Source_Pixbuf (Cr : Cairo_Context; Pixbuf : Gdk_Pixbuf; Pixbuf_X : Gdouble; Pixbuf_Y : Gdouble) is procedure Internal (Cr : Cairo_Context; Pixbuf : System.Address; Pixbuf_X, Pixbuf_Y : Gdouble); pragma Import (C, Internal, "gdk_cairo_set_source_pixbuf"); begin Internal (Cr, Get_Object (Pixbuf), Pixbuf_X, Pixbuf_Y); end Set_Source_Pixbuf; ------------------------ -- Create_From_Pixbuf -- ------------------------ function Create_From_Pixbuf (Pixbuf : Gdk_Pixbuf; Scale : Gint; For_Window : Gdk.Gdk_Window := null) return Cairo_Surface is function Internal (Pixbuf : System.Address; Scale : Gint; Win : Gdk_Window) return Cairo_Surface; pragma Import (C, Internal, "gdk_cairo_surface_create_from_pixbuf"); begin return Internal (Get_Object (Pixbuf), Scale, For_Window); end Create_From_Pixbuf; --------------------- -- Set_Source_RGBA -- --------------------- procedure Set_Source_RGBA (Cr : Cairo_Context; Color : Gdk.RGBA.Gdk_RGBA) is begin Set_Source_Rgba (Cr, Color.Red, Color.Green, Color.Blue, Color.Alpha); end Set_Source_RGBA; end Gdk.Cairo; gtkada-24.0.0/src/gdk-cairo.ads000066400000000000000000000076251446021174000161610ustar00rootroot00000000000000------------------------------------------------------------------------------ -- GtkAda - Ada95 binding for Gtk+/Gnome -- -- -- -- Copyright (C) 2010-2018, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ -- -- Interfacing between Gdk and Cairo. -- -- -- 2.16.6 -- Cairo with Glib; use Glib; with Cairo; use Cairo; with Gdk.Color; use Gdk.Color; with Gdk.Pixbuf; use Gdk.Pixbuf; with Gdk.RGBA; use Gdk.RGBA; package Gdk.Cairo is function Create (Window : Gdk.Gdk_Window) return Cairo_Context; -- Creates a Cairo context for drawing to Drawable. -- -- Note that due to double-buffering, Cairo contexts created -- in a GTK+ expose event handler cannot be cached and reused -- between different expose events. -- -- Returns a newly created Cairo context. The result should be freed with -- Cairo.Destroy. procedure Set_Source_Pixbuf (Cr : Cairo_Context; Pixbuf : Gdk_Pixbuf; Pixbuf_X : Gdouble; Pixbuf_Y : Gdouble); -- Cr: a Cairo_Context -- Pixbuf: a Gdk_Pixbuf -- Pixbuf_X: X coordinate of location to place upper left corner of Pixbuf -- Pixbuf_Y: Y coordinate of location to place upper left corner of Pixbuf -- -- Sets the given pixbuf as the source pattern for the Cairo context. -- The pattern has an extend mode of CAIRO_EXTEND_NONE and is aligned -- so that the origin of Pixbuf is Pixbuf_X, Pixbuf_Y function Create_From_Pixbuf (Pixbuf : Gdk_Pixbuf; Scale : Gint; For_Window : Gdk.Gdk_Window := null) return Cairo_Surface; -- Creates an image surface with the same contents as the pixbuf. -- This is similar to the work done by Set_Source_Pixbuf, but allows you -- to specify the scale factor for the screen, i.e. adapt to high-dpi -- (Retina) screens. -- You can then use Gtk.Style_Context.Render_Icon_Surface to paint the -- surface onto a Cairo_Context, and then destroy the surface. -- See also the convenient wrapper Gtkada.Style.Draw_Pixbuf_With_Scale. procedure Set_Source_Color (Cr : Cairo_Context; Color : Gdk_Color); procedure Set_Source_RGBA (Cr : Cairo_Context; Color : Gdk.RGBA.Gdk_RGBA); -- Set the specified Color as the source of Cr. private pragma Import (C, Set_Source_Color, "gdk_cairo_set_source_color"); end Gdk.Cairo; gtkada-24.0.0/src/gdk-color.adb000066400000000000000000000153761446021174000161630ustar00rootroot00000000000000------------------------------------------------------------------------------ -- GtkAda - Ada95 binding for Gtk+/Gnome -- -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 1998-2018, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ with Glib.Generic_Properties; use Glib.Generic_Properties; pragma Elaborate_All (Glib.Generic_Properties); with System; with Gtkada.Bindings; package body Gdk.Color is function To_Address (C : Gdk_Color; Add : System.Address) return System.Address; package Color_Properties is new Generic_Internal_Boxed_Property (Gdk_Color, Gdk_Color_Type, To_Address); procedure Set_Value (Value : in out Glib.Values.GValue; Val : Gdk_Color) renames Color_Properties.Set_Value; function Get_Value (Value : Glib.Values.GValue) return Gdk_Color renames Color_Properties.Get_Value; ---------------- -- To_Address -- ---------------- function To_Address (C : Gdk_Color; Add : System.Address) return System.Address is begin if C = Null_Color then return System.Null_Address; else return Add; end if; end To_Address; ----------- -- Equal -- ----------- function Equal (Colora, Colorb : Gdk_Color) return Boolean is begin return Colora.Red = Colorb.Red and then Colora.Blue = Colorb.Blue and then Colora.Green = Colorb.Green; end Equal; ---------- -- Blue -- ---------- function Blue (Color : Gdk_Color) return Guint16 is begin return Color.Blue; end Blue; ---------- -- Copy -- ---------- procedure Copy (Source : Gdk_Color; Destination : out Gdk_Color) is type Gdk_Color_Access is access Gdk_Color; pragma Convention (C, Gdk_Color_Access); function Internal (Source : System.Address) return Gdk_Color_Access; pragma Import (C, Internal, "gdk_color_copy"); begin Destination := Internal (Source'Address).all; end Copy; ----------- -- Green -- ----------- function Green (Color : Gdk_Color) return Guint16 is begin return Color.Green; end Green; ----------- -- Parse -- ----------- function Parse (Spec : String) return Gdk_Color is function Internal (Spec : String; Color : System.Address) return Gint; pragma Import (C, Internal, "gdk_color_parse"); Color : aliased Gdk_Color; begin if Internal (Spec & ASCII.NUL, Color'Address) = 0 then raise Wrong_Color with "Invalid color: '" & Spec & "'"; end if; return Color; end Parse; --------------- -- To_String -- --------------- function To_String (Color : Gdk_Color) return String is Result : aliased String (1 .. 8); Len : Gint; function sprintf (S : System.Address; Format : String; Arg1 : Gint; Arg2 : Gint; Arg3 : Gint) return Gint; pragma Import (C, sprintf, "c_sprintf"); begin Len := sprintf (Result'Address, "#%02X%02X%02X" & ASCII.NUL, Gint (Color.Red / 256), Gint (Color.Green / 256), Gint (Color.Blue / 256)); return Result (1 .. Integer (Len)); end To_String; ----------- -- Pixel -- ----------- function Pixel (Color : Gdk_Color) return Guint32 is begin return Color.Pixel; end Pixel; --------- -- Red -- --------- function Red (Color : Gdk_Color) return Guint16 is begin return Color.Red; end Red; --------------- -- Set_Pixel -- --------------- procedure Set_Pixel (Color : in out Gdk_Color; Pixel : Guint32) is begin Color.Pixel := Pixel; end Set_Pixel; ------------- -- Set_Rgb -- ------------- procedure Set_Rgb (Color : out Gdk_Color; Red, Green, Blue : Guint16) is begin Color.Red := Red; Color.Green := Green; Color.Blue := Blue; end Set_Rgb; ------------------ -- Set_Property -- ------------------ procedure Set_Property (Object : access Glib.Object.GObject_Record'Class; Name : Property_Gdk_Color; Value : Gdk_Color) is begin Color_Properties.Set_Property (Object, Color_Properties.Property (Name), Value); end Set_Property; ------------------ -- Get_Property -- ------------------ function Get_Property (Object : access Glib.Object.GObject_Record'Class; Name : Property_Gdk_Color) return Gdk_Color is begin return Color_Properties.Get_Property (Object, Color_Properties.Property (Name)); end Get_Property; -------------- -- To_Array -- -------------- function To_Array (Colors : Gdk_Color_Unconstrained_Array; N_Colors : Gint) return Gdk_Color_Array is Result : Gdk_Color_Array (1 .. Integer (N_Colors)); begin for R in Result'Range loop Result (R) := Colors (Colors'First + R - Result'First); end loop; return Result; end To_Array; ----------------------- -- Gdk_Color_Or_Null -- ----------------------- function Gdk_Color_Or_Null (Val : System.Address) return System.Address is function Internal is new Gtkada.Bindings.Generic_To_Address_Or_Null (Gdk_Color, Null_Color, Equal); begin return Internal (Val); end Gdk_Color_Or_Null; end Gdk.Color; gtkada-24.0.0/src/gdk-color.ads000066400000000000000000000201661446021174000161750ustar00rootroot00000000000000------------------------------------------------------------------------------ -- GtkAda - Ada95 binding for Gtk+/Gnome -- -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 1998-2018, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ -- -- -- This package provides an interface to the color handling facilities in -- gtk+. It is able to handle any kind of visual (monochrome, greyscale, -- color with different depths, ...), but provides a common and easy -- interface for all of them. -- -- Getting the Red/Green/Blue components can be done through Parse, and is -- actually recommended, since the exact color generally depends on the -- visual your application is running on. -- -- -- 1.3.6 -- Gdk, the low-level API with Glib; use Glib; with Glib.Object; with Glib.Values; package Gdk.Color is type Gdk_Color is private; -- A color to be displayed on the screen. -- Currently, GtkAda only supports the RGB standard, ie each color is -- set by its red, green and blue components. -- An extra field (Pixel) is the internal representation of the color, -- which is set once the color has been allocated. type Gdk_Color_Array is array (Natural range <>) of Gdk_Color; -- An array of colors. type Gdk_Color_Unconstrained_Array is array (Natural) of Gdk_Color; pragma Convention (C, Gdk_Color_Unconstrained_Array); -- An array of colors as returned by C. This is only useful in a few -- low-level subprograms that also pass the size as argument function To_Array (Colors : Gdk_Color_Unconstrained_Array; N_Colors : Gint) return Gdk_Color_Array; -- Return a version of Colors easier to use in Ada. Null_Color : constant Gdk_Color; -- No color. For most functions, this will select the default color in the -- context, although this exact specification depends on the function you -- want to use. Wrong_Color : exception; -- Exception raised when some functions below could not find or allocate -- a color on the user's system. function Gdk_Color_Type return Glib.GType; -- Return the internal gtk+ types associated with a color --------------------------------------------- -- Setting/Getting the fields of Gdk_Color -- --------------------------------------------- procedure Set_Rgb (Color : out Gdk_Color; Red, Green, Blue : Guint16); -- Modify the fields of the color. -- You then have to allocate the color with one of the Alloc* functions -- above. procedure Set_Pixel (Color : in out Gdk_Color; Pixel : Guint32); -- This function should almost never be used. function Red (Color : Gdk_Color) return Guint16; -- Return the Red field of Color. function Green (Color : Gdk_Color) return Guint16; -- Return the Green field of Color. function Blue (Color : Gdk_Color) return Guint16; -- Return the Blue field of Color. function Pixel (Color : Gdk_Color) return Guint32; -- Return the Pixel field of Color. ------------------------------------ -- Creating and Destroying colors -- ------------------------------------ procedure Copy (Source : Gdk_Color; Destination : out Gdk_Color); -- Copy the Source color to Destination. function Parse (Spec : String) return Gdk_Color; -- Parse the string Spec, and get its Red/Green/Blue components. -- The color is not allocated, and you need to call Alloc_Color. -- If the string could not be parsed to an existing color, Wrong_Color is -- raised. -- The string can be one of : -- -- - "RGB:FF/FF/FF" where the "FF" substrings are respectively the value -- of the red, green and blue components. Some other prefixes than RGB -- are defined in the X11 definition, please see some X11 documentation -- (or the man page XParseColor on unix systems). -- -- - "color_name" which can be any color name defined in the file rgb.txt -- of the user's system. You should always check that Wrong_Color was not -- raised, in case the color was not known on the user's system. This -- string is case insensitive. Color names are not supported on Windows -- systems. function Equal (Colora, Colorb : Gdk_Color) return Boolean; function "=" (Colora, Colorb : Gdk_Color) return Boolean renames Equal; -- True if the Red, Green and Blue components of both colors are equal. -- function To_String (Color : Gdk_Color) return String; -- Return the RGB values of Color under the form "#RRGGBB". -- Directly usable by Parse, see above. ---------------- -- Properties -- ---------------- -- See the package Glib.Properties for more information on how to -- use properties type Property_Gdk_Color is new Glib.Property; procedure Set_Property (Object : access Glib.Object.GObject_Record'Class; Name : Property_Gdk_Color; Value : Gdk_Color); function Get_Property (Object : access Glib.Object.GObject_Record'Class; Name : Property_Gdk_Color) return Gdk_Color; procedure Set_Value (Value : in out Glib.Values.GValue; Val : Gdk_Color); function Get_Value (Value : Glib.Values.GValue) return Gdk_Color; -- Store or retrieve a color from a value -- -- function Gdk_Color_Or_Null (Val : System.Address) return System.Address; -- Used for the GtkAda binding itself. -- Return either a Null_Address or a pointer to Val, depending on -- whether Val is the null value for the type. -- In all cases, Val is supposed to be an access to the type mentioned in -- the name of the subprogram. -- In Ada2012, these could be replaced with expression functions instead. -- private type Gdk_Color is record Pixel : Guint32; Red : Guint16; Green : Guint16; Blue : Guint16; end record; pragma Convention (C, Gdk_Color); -- The fields are to be chosen between 0 and 65535, not 0 and 255!!! Null_Color : constant Gdk_Color := (Guint32'Last, 1, 0, 0); -- Note: in the implementation of GtkAda, everytime a color is used, it -- is important to test whether this is Null_Color or not. If it is, then -- System.Null_Address should be passed to C instead of Null_Color'Address -- so that gtk+ can provide a default value for colors. pragma Import (C, Gdk_Color_Type, "gdk_color_get_type"); pragma Inline (Set_Rgb); pragma Inline (Set_Pixel); pragma Inline (Red); pragma Inline (Green); pragma Inline (Blue); pragma Inline (Pixel); pragma Inline (Set_Property); pragma Inline (Get_Property); end Gdk.Color; gtkada-24.0.0/src/gdk-display_manager.adb000066400000000000000000000043451446021174000201760ustar00rootroot00000000000000------------------------------------------------------------------------------ -- GtkAda - Ada95 binding for Gtk+/Gnome -- -- -- -- Copyright (C) 2008-2018, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ with Glib.Object; use Glib.Object; with System; package body Gdk.Display_Manager is ------------------------- -- Set_Default_Display -- ------------------------- procedure Set_Default_Display (Manager : Display_Manager; Display : Gdk_Display) is procedure Internal (Manager : Display_Manager; Display : System.Address); pragma Import (C, Internal, "gdk_display_manager_set_default_display"); begin Internal (Manager, Get_Object (Display)); end Set_Default_Display; end Gdk.Display_Manager; gtkada-24.0.0/src/gdk-display_manager.ads000066400000000000000000000043421446021174000202140ustar00rootroot00000000000000------------------------------------------------------------------------------ -- GtkAda - Ada95 binding for Gtk+/Gnome -- -- -- -- Copyright (C) 2008-2018, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ with Gdk.Display; use Gdk.Display; package Gdk.Display_Manager is type Display_Manager is new Glib.C_Proxy; function Display_Manager_Get return Display_Manager; -- Return the global Display Manager. -- This function must be called after the initial call to Gtk.Main.Init. procedure Set_Default_Display (Manager : Display_Manager; Display : Gdk_Display); -- Set Display as the default display. private pragma Import (C, Display_Manager_Get, "gdk_display_manager_get"); end Gdk.Display_Manager; gtkada-24.0.0/src/gdk-dnd.adb000066400000000000000000000202751446021174000156040ustar00rootroot00000000000000------------------------------------------------------------------------------ -- GtkAda - Ada95 binding for Gtk+/Gnome -- -- -- -- Copyright (C) 2001-2021, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ with System; with Glib.Object; use Glib.Object; with Gtk; use Gtk; package body Gdk.Dnd is ----------------- -- Drag_Status -- ----------------- procedure Drag_Status (Context : Drag_Context; Action : Drag_Action; Time : Guint32) is procedure Internal (Context : System.Address; Action : Gint; Time : Guint32); pragma Import (C, Internal, "gdk_drag_status"); begin Internal (Get_Object (Context), Drag_Action'Pos (Action), Time); end Drag_Status; ---------------- -- Drop_Reply -- ---------------- procedure Drop_Reply (Context : Drag_Context; Ok : Boolean; Time : Guint32) is procedure Internal (Context : System.Address; Ok : Gint; Time : Guint32); pragma Import (C, Internal, "gdk_drop_reply"); begin Internal (Get_Object (Context), Boolean'Pos (Ok), Time); end Drop_Reply; ----------------- -- Drop_Finish -- ----------------- procedure Drop_Finish (Context : Drag_Context; Success : Boolean; Time : Guint32) is procedure Internal (Context : System.Address; Success : Gint; Time : Guint32); pragma Import (C, Internal, "gdk_drop_finish"); begin Internal (Get_Object (Context), Boolean'Pos (Success), Time); end Drop_Finish; ------------------------ -- Drag_Get_Selection -- ------------------------ function Drag_Get_Selection (Context : Drag_Context) return Gdk_Atom is function Internal (Context : System.Address) return Gdk_Atom; pragma Import (C, Internal, "gdk_drag_get_selection"); begin return Internal (Get_Object (Context)); end Drag_Get_Selection; ---------------- -- Drag_Begin -- ---------------- function Drag_Begin (Window : Gdk.Gdk_Window; Targets : Gtk.Target_List.Gtk_Target_List) return Drag_Context is function Internal (Window : Gdk_Window; Targets : System.Address) return System.Address; pragma Import (C, Internal, "gdk_drag_begin"); Stub : Gdk.Drag_Contexts.Drag_Context_Record; begin return Drag_Context (Get_User_Data (Internal (Window, Targets.Get_Object), Stub)); end Drag_Begin; ----------------------- -- Drag_Get_Protocol -- ----------------------- function Drag_Context_Get_Protocol (Context : Drag_Context; Protocol : Drag_Protocol) return Drag_Protocol is function Internal (Context : System.Address; Protocol : Drag_Protocol) return Drag_Protocol; pragma Import (C, Internal, "gdk_drag_context_get_protocol"); begin return Internal (Get_Object (Context), Protocol); end Drag_Context_Get_Protocol; ---------------------- -- Drag_Find_Window -- ---------------------- procedure Drag_Find_Window_For_Screen (Context : Drag_Context; Drag_Window : Gdk.Gdk_Window; Screen : Gdk.Screen.Gdk_Screen; X_Root : Gint; Y_Root : Gint; Dest_Window : Gdk.Gdk_Window; Protocol : Drag_Protocol) is procedure Internal (Context : System.Address; Drag_Window : Gdk_Window; Screen : System.Address; X_Root : Gint; Y_Root : Gint; Dest_Window : Gdk_Window; Protocol : Drag_Protocol); pragma Import (C, Internal, "gdk_drag_find_window_for_screen"); begin Internal (Get_Object (Context), Drag_Window, Get_Object (Screen), X_Root, Y_Root, Dest_Window, Protocol); end Drag_Find_Window_For_Screen; ----------------- -- Drag_Motion -- ----------------- function Drag_Motion (Context : Drag_Context; Dest_Window : Gdk.Gdk_Window; Protocol : Drag_Protocol; X_Root : Gint; Y_Root : Gint; Suggested_Action : Drag_Action; Possible_Actions : Drag_Action; Time : Guint32) return Boolean is function Internal (Context : System.Address; Dest_Window : Gdk_Window; Protocol : Gint; X_Root : Gint; Y_Root : Gint; Suggested_Action : Gint; Possible_Actions : Gint; Time : Guint32) return Gint; pragma Import (C, Internal, "gdk_drag_motion"); begin return Boolean'Val (Internal (Get_Object (Context), Dest_Window, Drag_Protocol'Pos (Protocol), X_Root, Y_Root, Drag_Action'Pos (Suggested_Action), Drag_Action'Pos (Possible_Actions), Time)); end Drag_Motion; --------------- -- Drag_Drop -- --------------- procedure Drag_Drop (Context : Drag_Context; Time : Guint32) is procedure Internal (Context : System.Address; Time : Guint32); pragma Import (C, Internal, "gdk_drag_drop"); begin Internal (Get_Object (Context), Time); end Drag_Drop; ---------------- -- Drag_Abort -- ---------------- procedure Drag_Abort (Context : Drag_Context; Time : Guint32) is procedure Internal (Context : System.Address; Time : Guint32); pragma Import (C, Internal, "gdk_drag_abort"); begin Internal (Get_Object (Context), Time); end Drag_Abort; ----------------- -- Get_Targets -- ----------------- function Get_Targets (Context : Drag_Context) return Gdk_Atom_Array is function Targets_Count (Context : System.Address) return Guint; pragma Import (C, Targets_Count, "ada_gtk_dnd_context_targets_count"); procedure Internal (Context : System.Address; Result : Gdk_Atom_Array); pragma Import (C, Internal, "ada_gtk_dnd_context_get_targets"); Length : constant Natural := Natural (Targets_Count (Get_Object (Context))); Result : Gdk_Atom_Array (0 .. Length - 1); begin Internal (Get_Object (Context), Result); return Result; end Get_Targets; end Gdk.Dnd; gtkada-24.0.0/src/gdk-dnd.ads000066400000000000000000000074531446021174000156300ustar00rootroot00000000000000------------------------------------------------------------------------------ -- GtkAda - Ada95 binding for Gtk+/Gnome -- -- -- -- Copyright (C) 2001-2018, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ -- Gdk, the low-level API with Glib; use Glib; with Gdk.Drag_Contexts; use Gdk.Drag_Contexts; with Gdk.Types; use Gdk.Types; with Gdk.Screen; with Gtk; with Gtk.Target_List; package Gdk.Dnd is type Gdk_Atom_Array is array (Natural range <>) of Gdk.Types.Gdk_Atom; function Get_Targets (Context : Drag_Context) return Gdk_Atom_Array; -- Return the list of targets supported by this context. subtype Drag_Action is Gdk.Drag_Contexts.Gdk_Drag_Action; subtype Drag_Protocol is Gdk.Drag_Contexts.Gdk_Drag_Protocol; Action_Any : constant Drag_Action := 2 ** 8 - 1; procedure Drag_Status (Context : Drag_Context; Action : Drag_Action; Time : Guint32); procedure Drop_Reply (Context : Drag_Context; Ok : Boolean; Time : Guint32); procedure Drop_Finish (Context : Drag_Context; Success : Boolean; Time : Guint32); -- Clean up from the drag, and display snapback, if necessary. function Drag_Get_Selection (Context : Drag_Context) return Gdk_Atom; function Drag_Begin (Window : Gdk.Gdk_Window; Targets : Gtk.Target_List.Gtk_Target_List) return Drag_Context; function Drag_Context_Get_Protocol (Context : Drag_Context; Protocol : Drag_Protocol) return Drag_Protocol; -- Return which drag protocol is recognized by a given context. procedure Drag_Find_Window_For_Screen (Context : Drag_Context; Drag_Window : Gdk.Gdk_Window; Screen : Gdk.Screen.Gdk_Screen; X_Root : Gint; Y_Root : Gint; Dest_Window : Gdk.Gdk_Window; Protocol : Drag_Protocol); function Drag_Motion (Context : Drag_Context; Dest_Window : Gdk.Gdk_Window; Protocol : Drag_Protocol; X_Root : Gint; Y_Root : Gint; Suggested_Action : Drag_Action; Possible_Actions : Drag_Action; Time : Guint32) return Boolean; procedure Drag_Drop (Context : Drag_Context; Time : Guint32); procedure Drag_Abort (Context : Drag_Context; Time : Guint32); end Gdk.Dnd; gtkada-24.0.0/src/gdk-input.ads000066400000000000000000000070001446021174000162060ustar00rootroot00000000000000------------------------------------------------------------------------------ -- GtkAda - Ada95 binding for Gtk+/Gnome -- -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 1998-2018, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ -- This package provides low level handling of file descriptors in the -- GtkAda event loop. Note that this package is currently not supported -- under Windows. -- Gdk, the low-level API with Gdk.Event; with Gdk.Types; with Glib; package Gdk.Input is procedure Init; procedure Gdk_Exit; procedure Set_Extension_Events (Window : Gdk.Gdk_Window; Mask : Gdk.Event.Gdk_Event_Mask; Mode : Gdk.Types.Gdk_Extension_Mode); -- ??? Check that Mask is indeed of type GdkEventMask. -- The C code defines it as Gint... generic type Data_Type (<>) is private; package Input_Add is type Data_Access is access all Data_Type; pragma Convention (C, Data_Access); type Gdk_Input_Function is access procedure (Data : Data_Access; Source : Glib.Gint; Condition : Gdk.Types.Gdk_Input_Condition); function Add (Source : Glib.Gint; Condition : Gdk.Types.Gdk_Input_Condition; Func : Gdk_Input_Function; Data : Data_Access) return Glib.Gint; private pragma Import (C, Add, "gdk_input_add"); end Input_Add; procedure Remove (Tag : Glib.Gint); -- to bind: gdk_input_motion_events -- This returns the list of past motion events in the window, between two -- times. This might give a finer granularity than getting the -- Motion_Events themselves, and might be more efficient. -- Not supported by all XServers though. private pragma Import (C, Init, "gdk_input_init"); pragma Import (C, Gdk_Exit, "gdk_input_exit"); pragma Import (C, Set_Extension_Events, "gdk_input_set_extension_events"); pragma Import (C, Remove, "gdk_input_remove"); end Gdk.Input; gtkada-24.0.0/src/gdk-keyval.adb000066400000000000000000000065451446021174000163360ustar00rootroot00000000000000------------------------------------------------------------------------------ -- GtkAda - Ada95 binding for Gtk+/Gnome -- -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 1998-2018, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ with Gtkada.Types; with Glib; use Glib; package body Gdk.Keyval is -------------- -- Is_Lower -- -------------- function Is_Lower (Keyval : Gdk.Types.Gdk_Key_Type) return Boolean is function Internal (Keyval : Gdk.Types.Gdk_Key_Type) return Gboolean; pragma Import (C, Internal, "gdk_keyval_is_lower"); begin return Internal (Keyval) /= 0; end Is_Lower; -------------- -- Is_Upper -- -------------- function Is_Upper (Keyval : Gdk.Types.Gdk_Key_Type) return Boolean is function Internal (Keyval : Gdk.Types.Gdk_Key_Type) return Gboolean; pragma Import (C, Internal, "gdk_keyval_is_upper"); begin return Internal (Keyval) /= 0; end Is_Upper; --------------- -- From_Name -- --------------- function From_Name (Keyval_Name : String) return Gdk.Types.Gdk_Key_Type is function Internal (Keyval_Name : String) return Gdk.Types.Gdk_Key_Type; pragma Import (C, Internal, "gdk_keyval_from_name"); begin return Internal (Keyval_Name & ASCII.NUL); end From_Name; ---------- -- Name -- ---------- function Name (Keyval : Gdk.Types.Gdk_Key_Type) return String is function Internal (Keyval : Gdk.Types.Gdk_Key_Type) return Gtkada.Types.Chars_Ptr; pragma Import (C, Internal, "gdk_keyval_name"); use type Gtkada.Types.Chars_Ptr; P : constant Gtkada.Types.Chars_Ptr := Internal (Keyval); begin if P = Gtkada.Types.Null_Ptr then return ""; else return Gtkada.Types.Value (P); end if; end Name; end Gdk.Keyval; gtkada-24.0.0/src/gdk-keyval.ads000066400000000000000000000057761446021174000163640ustar00rootroot00000000000000------------------------------------------------------------------------------ -- GtkAda - Ada95 binding for Gtk+/Gnome -- -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 1998-2018, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ -- 1.3.6 -- Gdk, the low-level API with Glib; with Gdk.Types; package Gdk.Keyval is type Gdk_Keymap is private; function Get_Type return Glib.GType; function Name (Keyval : Gdk.Types.Gdk_Key_Type) return String; function From_Name (Keyval_Name : String) return Gdk.Types.Gdk_Key_Type; function To_Upper (Keyval : Gdk.Types.Gdk_Key_Type) return Gdk.Types.Gdk_Key_Type; function To_Lower (Keyval : Gdk.Types.Gdk_Key_Type) return Gdk.Types.Gdk_Key_Type; function Is_Upper (Keyval : Gdk.Types.Gdk_Key_Type) return Boolean; function Is_Lower (Keyval : Gdk.Types.Gdk_Key_Type) return Boolean; function To_Unicode (Keyval : Gdk.Types.Gdk_Key_Type) return Glib.Gunichar; private pragma Import (C, To_Upper, "gdk_keyval_to_upper"); pragma Import (C, To_Lower, "gdk_keyval_to_lower"); pragma Import (C, Get_Type, "gdk_keymap_get_type"); pragma Import (C, To_Unicode, "gdk_keyval_to_unicode"); type Gdk_Keymap is new Glib.C_Proxy; end Gdk.Keyval; -- missing: -- gdk_keymap_lookup_key -- gdk_keymap_translate_keyboard_state -- gdk_keymap_get_entries_for_keyval -- gdk_keymap_get_entries_for_keycode -- gdk_keyval_convert_case -- gdk_unicode_to_keyval gtkada-24.0.0/src/gdk-main.adb000066400000000000000000000117451446021174000157650ustar00rootroot00000000000000------------------------------------------------------------------------------ -- GtkAda - Ada95 binding for the Gimp Toolkit -- -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 1998-2018, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ with Gdk.Types; use Gdk.Types; with System; with Interfaces.C; with Gtkada.Types; use Gtkada.Types; package body Gdk.Main is ---------- -- Init -- ---------- procedure Init is gnat_argc : Interfaces.C.int; pragma Import (C, gnat_argc); gnat_argv : System.Address; pragma Import (C, gnat_argv); procedure Internal (argc : System.Address; argv : System.Address); pragma Import (C, Internal, "gdk_init"); begin Internal (gnat_argc'Address, gnat_argv'Address); end Init; ----------------- -- Get_Display -- ----------------- function Get_Display return String is function Internal return Chars_Ptr; pragma Import (C, Internal, "gdk_get_display"); Result : constant Chars_Ptr := Internal; begin if Result = Null_Ptr then return ""; else return Value (Internal); end if; end Get_Display; ------------------- -- Keyboard_Grab -- ------------------- function Keyboard_Grab (Window : Gdk.Gdk_Window; Owner_Events : Boolean := True; Time : Guint32 := 0) return Gdk_Grab_Status is function Internal (Window : Gdk_Window; Owner_Events : Gint; Time : Guint32) return Gint; pragma Import (C, Internal, "gdk_keyboard_grab"); begin return Gdk_Grab_Status'Val (Internal (Window, To_Gint (Owner_Events), Time)); end Keyboard_Grab; --------------------- -- Keyboard_Ungrab -- --------------------- procedure Keyboard_Ungrab (Time : Guint32 := 0) is procedure Internal (Time : Guint32); pragma Import (C, Internal, "gdk_keyboard_ungrab"); begin Internal (Time); end Keyboard_Ungrab; ------------------ -- Pointer_Grab -- ------------------ function Pointer_Grab (Window : Gdk.Gdk_Window; Owner_Events : Boolean := True; Event_Mask : Gdk.Event.Gdk_Event_Mask; Confine_To : Gdk.Gdk_Window := null; Cursor : Gdk.Gdk_Cursor := null; Time : Guint32 := 0) return Gdk_Grab_Status is function Internal (Window : Gdk_Window; Owner_Events : Gint; Event_Mask : Gint; Confine_To : Gdk_Window; Cursor : Gdk_Cursor; Time : Guint32) return Gint; pragma Import (C, Internal, "gdk_pointer_grab"); begin return Gdk_Grab_Status'Val (Internal (Window, To_Gint (Owner_Events), Gint (Event_Mask), Confine_To, Cursor, Time)); end Pointer_Grab; ------------------------ -- Pointer_Is_Grabbed -- ------------------------ function Pointer_Is_Grabbed return Boolean is function Internal return Gint; pragma Import (C, Internal, "gdk_pointer_is_grabbed"); begin return Internal /= 0; end Pointer_Is_Grabbed; -------------------- -- Pointer_Ungrab -- -------------------- procedure Pointer_Ungrab (Time : Guint32 := 0) is procedure Internal (Time : Guint32); pragma Import (C, Internal, "gdk_pointer_ungrab"); begin Internal (Time); end Pointer_Ungrab; end Gdk.Main; gtkada-24.0.0/src/gdk-main.ads000066400000000000000000000125231446021174000160010ustar00rootroot00000000000000------------------------------------------------------------------------------ -- GtkAda - Ada95 binding for Gtk+/Gnome -- -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 1998-2018, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ -- -- This package provides routines to handle initialization and set up of the -- Gdk library. -- -- 1.3.6 -- Gdk, the low-level API with Glib; use Glib; with Gdk.Event; with Gdk.Types; package Gdk.Main is procedure Init; -- Initialize the library for use. -- The command line arguments are modified to reflect any arguments -- which were not handled. (Such arguments should either -- be handled by the application or dismissed). procedure Gdk_Exit (Error_Code : Gint); -- Restore the library to an un-itialized state and exits -- the program using the "exit" system call. -- Error_Code is the error value to pass to "exit". -- Allocated structures are freed and the program exits cleanly. -- This function is deprecated. function Get_Display return String; -- Return the name of the display. function Pointer_Grab (Window : Gdk.Gdk_Window; Owner_Events : Boolean := True; Event_Mask : Gdk.Event.Gdk_Event_Mask; Confine_To : Gdk.Gdk_Window := null; Cursor : Gdk.Gdk_Cursor := null; Time : Guint32 := 0) return Gdk.Types.Gdk_Grab_Status; -- Grab the pointer to a specific window. -- - Window is the window which will receive the grab -- - Owner_Events specifies whether events will be reported as is, -- or relative to Window -- - Event_Mask masks only interesting events -- - Confine_To limits the cursor movement to the specified window -- - Cursor changes the cursor for the duration of the grab -- - Time specifies the time -- Requires a corresponding call to Pointer_Ungrab -- -- This is obsolescent in gtk-3, use Gdk.Device.Grab instead procedure Pointer_Ungrab (Time : Guint32 := 0); -- Release any pointer grab. function Pointer_Is_Grabbed return Boolean; -- Tell wether there is an active pointer grab in effect. function Keyboard_Grab (Window : Gdk.Gdk_Window; Owner_Events : Boolean := True; Time : Guint32 := 0) return Gdk.Types.Gdk_Grab_Status; -- Grab the keyboard to a specific window. -- - Window is the window which will receive the grab -- - Owner_Events specifies whether events will be reported as is, -- or relative to Window -- - Time specifies the time -- Requires a corresponding call to Keyboard_Ungrab procedure Keyboard_Ungrab (Time : Guint32 := 0); -- Release any keyboard grab. function Screen_Width return Gint; -- Return the width of the screen. function Screen_Height return Gint; -- Return the height of the screen. function Screen_Width_MM return Gint; -- Return the width of the screen in millimeters. function Screen_Height_MM return Gint; -- Return the height of the screen in millimeters. procedure Flush; -- Flush the queue of graphic events and then wait -- until all requests have been received and processed. procedure Beep; -- Emit a beep. procedure Set_Double_Click_Time (Msec : Guint); private pragma Import (C, Gdk_Exit, "gdk_exit"); pragma Import (C, Screen_Width, "gdk_screen_width"); pragma Import (C, Screen_Height, "gdk_screen_height"); pragma Import (C, Screen_Width_MM, "gdk_screen_width_mm"); pragma Import (C, Screen_Height_MM, "gdk_screen_height_mm"); pragma Import (C, Set_Double_Click_Time, "gdk_set_double_click_time"); pragma Import (C, Flush, "gdk_flush"); pragma Import (C, Beep, "gdk_beep"); end Gdk.Main; -- missing: -- gdk_wcstombs -- gdk_mbstowcs gtkada-24.0.0/src/gdk-pixbuf.adb000066400000000000000000000656211446021174000163400ustar00rootroot00000000000000------------------------------------------------------------------------------ -- GtkAda - Ada95 binding for Gtk+/Gnome -- -- -- -- Copyright (C) 2000-2018, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ with Gdk.Display; use Gdk.Display; with Glib.Object; use Glib.Object; with Ada.Unchecked_Deallocation; package body Gdk.Pixbuf is type Proxy_Data is record Pixels : Guchar_Array_Access; -- Access to the Ada allocated memory used by Gdk_New_From_Data. -- Strictly, this is not necessary, as this access could be -- built from the Pixels parameter of the destroy callback. -- However, it's not possible to easily and portably convert an -- Address to an access to unconstrained array. end record; pragma Convention (C, Proxy_Data); -- Closure data attached to a pixbuf created from user data. type Proxy_Data_Access is access Proxy_Data; pragma Convention (C, Proxy_Data_Access); procedure Free is new Ada.Unchecked_Deallocation (Object => Proxy_Data, Name => Proxy_Data_Access); procedure Destroy_Pixels (Pixels : System.Address; Data : Proxy_Data_Access); pragma Convention (C, Destroy_Pixels); -- Low level, C compatible, callback called when the reference -- count of a pixbuf (that was created from user data) reaches 0. --------------- -- Add_Alpha -- --------------- function Add_Alpha (Pixbuf : Gdk_Pixbuf; Substitute_Color : Boolean := False; Red : Guchar := 0; Green : Guchar := 0; Blue : Guchar := 0) return Gdk_Pixbuf is function Internal (Pixbuf : System.Address; Substitute_Color : Gboolean; Red : Guchar; Green : Guchar; Blue : Guchar) return System.Address; pragma Import (C, Internal, "gdk_pixbuf_add_alpha"); begin return Convert (Internal (Get_Object (Pixbuf), Boolean'Pos (Substitute_Color), Red, Green, Blue)); end Add_Alpha; --------------- -- Composite -- --------------- procedure Composite (Src : Gdk_Pixbuf; Dest : Gdk_Pixbuf; Dest_X : Gint; Dest_Y : Gint; Dest_Width : Gint; Dest_Height : Gint; Offset_X : Gdouble := 0.0; Offset_Y : Gdouble := 0.0; Scale_X : Gdouble := 1.0; Scale_Y : Gdouble := 1.0; Inter_Type : Gdk_Interp_Type := Interp_Bilinear; Overall_Alpha : Alpha_Range := 128) is procedure Internal (Src : System.Address; Dest : System.Address; Dest_X : Gint; Dest_Y : Gint; Dest_Width : Gint; Dest_Height : Gint; Offset_X : Gdouble := 0.0; Offset_Y : Gdouble := 0.0; Scale_X : Gdouble := 1.0; Scale_Y : Gdouble := 1.0; Inter_Type : Gdk_Interp_Type := Interp_Bilinear; Overall_Alpha : Alpha_Range := 128); pragma Import (C, Internal, "gdk_pixbuf_composite"); begin Internal (Get_Object (Src), Get_Object (Dest), Dest_X, Dest_Y, Dest_Width, Dest_Height, Offset_X, Offset_Y, Scale_X, Scale_Y, Inter_Type, Overall_Alpha); end Composite; --------------------- -- Composite_Color -- --------------------- procedure Composite_Color (Src : Gdk_Pixbuf; Dest : Gdk_Pixbuf; Dest_X : Gint; Dest_Y : Gint; Dest_Width : Gint; Dest_Height : Gint; Offset_X : Gdouble := 0.0; Offset_Y : Gdouble := 0.0; Scale_X : Gdouble := 1.0; Scale_Y : Gdouble := 1.0; Inter_Type : Gdk_Interp_Type := Interp_Bilinear; Overall_Alpha : Alpha_Range := 128; Check_X : Gint := 0; Check_Y : Gint := 0; Check_Size : Gint := 0; Color1 : Guint32 := 0; Color2 : Guint32 := 0) is procedure Internal (Src : System.Address; Dest : System.Address; Dest_X : Gint; Dest_Y : Gint; Dest_Width : Gint; Dest_Height : Gint; Offset_X : Gdouble; Offset_Y : Gdouble; Scale_X : Gdouble; Scale_Y : Gdouble; Inter_Type : Gdk_Interp_Type; Overall_Alpha : Alpha_Range; Check_X : Gint; Check_Y : Gint; Check_Size : Gint; Color1 : Guint32; Color2 : Guint32); pragma Import (C, Internal, "gdk_pixbuf_composite_color"); begin Internal (Get_Object (Src), Get_Object (Dest), Dest_X, Dest_Y, Dest_Width, Dest_Height, Offset_X, Offset_Y, Scale_X, Scale_Y, Inter_Type, Overall_Alpha, Check_X, Check_Y, Check_Size, Color1, Color2); end Composite_Color; ---------------------------- -- Composite_Color_Simple -- ---------------------------- function Composite_Color_Simple (Src : Gdk_Pixbuf; Dest_Width : Gint; Dest_Height : Gint; Inter_Type : Gdk_Interp_Type := Interp_Bilinear; Overall_Alpha : Alpha_Range := 128; Color1 : Guint32 := 0; Color2 : Guint32 := 0) return Gdk_Pixbuf is function Internal (Src : System.Address; Dest_Width : Gint; Dest_Height : Gint; Inter_Type : Gdk_Interp_Type := Interp_Bilinear; Overall_Alpha : Alpha_Range := 128; Color1 : Guint32 := 0; Color2 : Guint32 := 0) return System.Address; pragma Import (C, Internal, "gdk_pixbuf_composite_color_simple"); begin return Convert (Internal (Get_Object (Src), Dest_Width, Dest_Height, Inter_Type, Overall_Alpha, Color1, Color2)); end Composite_Color_Simple; ------------- -- Convert -- ------------- function Convert (P : System.Address) return Gdk_Pixbuf is use type System.Address; Stub : Gdk_Pixbuf_Record; begin if P = System.Null_Address then return null; else return Gdk_Pixbuf (Get_User_Data (P, Stub)); end if; end Convert; ---------- -- Copy -- ---------- function Copy (Pixbuf : Gdk_Pixbuf) return Gdk_Pixbuf is function Internal (Pixbuf : System.Address) return System.Address; pragma Import (C, Internal, "gdk_pixbuf_copy"); begin return Convert (Internal (Get_Object (Pixbuf))); end Copy; --------------- -- Copy_Area -- --------------- procedure Copy_Area (Src_Pixbuf : Gdk_Pixbuf; Src_X : Gint; Src_Y : Gint; Width : Gint; Height : Gint; Dest_Pixbuf : Gdk_Pixbuf; Dest_X : Gint; Dest_Y : Gint) is procedure Internal (Src_Pixbuf : System.Address; Src_X : Gint; Src_Y : Gint; Width : Gint; Height : Gint; Dest_Pixbuf : System.Address; Dest_X : Gint; Dest_Y : Gint); pragma Import (C, Internal, "gdk_pixbuf_copy_area"); begin Internal (Get_Object (Src_Pixbuf), Src_X, Src_Y, Width, Height, Get_Object (Dest_Pixbuf), Dest_X, Dest_Y); end Copy_Area; -------------------- -- Destroy_Pixels -- -------------------- procedure Destroy_Pixels (Pixels : System.Address; Data : Proxy_Data_Access) is pragma Unreferenced (Pixels); Tmp : Proxy_Data_Access := Data; begin Free (Data.Pixels); Free (Tmp); end Destroy_Pixels; ---------- -- Fill -- ---------- procedure Fill (Pixbuf : Gdk_Pixbuf; Pixel : Guint32) is procedure Internal (Pixbuf : System.Address; Pixel : Guint32); pragma Import (C, Internal, "gdk_pixbuf_fill"); begin Internal (Get_Object (Pixbuf), Pixel); end Fill; ------------- -- Gdk_New -- ------------- function Gdk_New (Colorspace : Gdk_Colorspace := Colorspace_RGB; Has_Alpha : Boolean := False; Bits_Per_Sample : Gint := 8; Width : Gint; Height : Gint) return Gdk_Pixbuf is function Internal (Colorspace : Gdk_Colorspace; Has_Alpha : Gboolean; Bits_Per_Sample : Gint; Width : Gint; Height : Gint) return System.Address; pragma Import (C, Internal, "gdk_pixbuf_new"); begin return Convert (Internal (Colorspace, Boolean'Pos (Has_Alpha), Bits_Per_Sample, Width, Height)); end Gdk_New; ----------------------- -- Gdk_New_From_Data -- ----------------------- function Gdk_New_From_Data (Data : Guchar_Array_Access; Colorspace : Gdk_Colorspace := Colorspace_RGB; Has_Alpha : Boolean := False; Bits_Per_Sample : Gint := 8; Width : Gint; Height : Gint; Rowstride : Gint; Auto_Destroy_Data : Boolean := True) return Gdk_Pixbuf is function Internal (Data : System.Address; Colorspace : Gdk_Colorspace; Has_Alpha : Gboolean; Bits_Per_Sample : Gint; Width : Gint; Height : Gint; Row_Stride : Gint; Destroy_Fn : System.Address; Destroy_Fn_Data : Proxy_Data_Access) return System.Address; pragma Import (C, Internal, "gdk_pixbuf_new_from_data"); begin if Auto_Destroy_Data then return Convert (Internal (Data.all'Address, Colorspace, Boolean'Pos (Has_Alpha), Bits_Per_Sample, Width, Height, Rowstride, Destroy_Pixels'Address, new Proxy_Data'(Pixels => Data))); else return Convert (Internal (Data.all'Address, Colorspace, Boolean'Pos (Has_Alpha), Bits_Per_Sample, Width, Height, Rowstride, System.Null_Address, null)); end if; end Gdk_New_From_Data; ----------------------- -- Gdk_New_From_File -- ----------------------- procedure Gdk_New_From_File (Pixbuf : out Gdk_Pixbuf; Filename : String; Error : out GError) is function Internal (Filename : String; Error : access GError) return System.Address; pragma Import (C, Internal, "ada_gdk_pixbuf_new_from_file"); Err : aliased GError; begin Pixbuf := Convert (Internal (Filename & ASCII.NUL, Err'Access)); Error := Err; end Gdk_New_From_File; ----------------------- -- Gdk_New_From_File -- ----------------------- procedure Gdk_New_From_File (Animation : out Gdk_Pixbuf_Animation; Filename : String; Error : out GError) is function Internal (Filename : String; Error : access GError) return Gdk_Pixbuf_Animation; pragma Import (C, Internal, "ada_gdk_pixbuf_animation_new_from_file"); Err : aliased GError; begin Animation := Internal (Filename & ASCII.NUL, Err'Access); Error := Err; end Gdk_New_From_File; --------------------------- -- Gdk_New_From_Xpm_Data -- --------------------------- function Gdk_New_From_Xpm_Data (Data : Gtkada.Types.Chars_Ptr_Array) return Gdk_Pixbuf is function Internal (Data : Gtkada.Types.Chars_Ptr_Array) return System.Address; pragma Import (C, Internal, "gdk_pixbuf_new_from_xpm_data"); begin return Convert (Internal (Data)); end Gdk_New_From_Xpm_Data; ----------------------- -- Gdk_New_Subpixbuf -- ----------------------- function Gdk_New_Subpixbuf (Src_Pixbuf : Gdk_Pixbuf; Src_X : Gint; Src_Y : Gint; Width : Gint; Height : Gint) return Gdk_Pixbuf is function Internal (Src_Pixbuf : System.Address; Src_X : Gint; Src_Y : Gint; Width : Gint; Height : Gint) return System.Address; pragma Import (C, Internal, "gdk_pixbuf_new_subpixbuf"); begin return Convert (Internal (Get_Object (Src_Pixbuf), Src_X, Src_Y, Width, Height)); end Gdk_New_Subpixbuf; ------------------------- -- Get_Bits_Per_Sample -- ------------------------- function Get_Bits_Per_Sample (Pixbuf : Gdk_Pixbuf) return Gint is function Internal (Pixbuf : System.Address) return Gint; pragma Import (C, Internal, "gdk_pixbuf_get_bits_per_sample"); begin return Internal (Get_Object (Pixbuf)); end Get_Bits_Per_Sample; -------------------- -- Get_Colorspace -- -------------------- function Get_Colorspace (Pixbuf : Gdk_Pixbuf) return Gdk_Colorspace is function Internal (Pixbuf : System.Address) return Gdk_Colorspace; pragma Import (C, Internal, "gdk_pixbuf_get_colorspace"); begin return Internal (Get_Object (Pixbuf)); end Get_Colorspace; --------------------- -- Get_From_Window -- --------------------- function Get_From_Window (Window : Gdk_Window; Src_X : Gint; Src_Y : Gint; Width : Gint; Height : Gint) return Gdk_Pixbuf is function Internal (Window : Gdk_Window; Src_X : Gint; Src_Y : Gint; Width : Gint; Height : Gint) return System.Address; pragma Import (C, Internal, "gdk_pixbuf_get_from_window"); begin return Convert (Internal (Window, Src_X, Src_Y, Width, Height)); end Get_From_Window; ---------------------- -- Get_From_Surface -- ---------------------- function Get_From_Surface (Surface : Cairo.Cairo_Surface; Src_X : Gint; Src_Y : Gint; Width : Gint; Height : Gint) return Gdk_Pixbuf is function Internal (Surface : Cairo.Cairo_Surface; Src_X : Gint; Src_Y : Gint; Width : Gint; Height : Gint) return System.Address; pragma Import (C, Internal, "gdk_pixbuf_get_from_surface"); begin return Convert (Internal (Surface, Src_X, Src_Y, Width, Height)); end Get_From_Surface; ------------------- -- Get_Has_Alpha -- ------------------- function Get_Has_Alpha (Pixbuf : Gdk_Pixbuf) return Boolean is function Internal (Pixbuf : System.Address) return Gboolean; pragma Import (C, Internal, "gdk_pixbuf_get_has_alpha"); begin return Internal (Get_Object (Pixbuf)) /= 0; end Get_Has_Alpha; ---------------- -- Get_Height -- ---------------- function Get_Height (Pixbuf : Gdk_Pixbuf) return Gint is function Internal (Pixbuf : System.Address) return Gint; pragma Import (C, Internal, "gdk_pixbuf_get_height"); begin return Internal (Get_Object (Pixbuf)); end Get_Height; ---------------- -- Get_Height -- ---------------- function Get_Height (Animation : Gdk_Pixbuf_Animation) return Gint is function Internal (Animation : Gdk_Pixbuf_Animation) return Gint; pragma Import (C, Internal, "gdk_pixbuf_animation_get_height"); begin return Internal (Animation); end Get_Height; --------------- -- Get_Image -- --------------- function Get_Image (Cursor : Gdk.Gdk_Cursor) return Gdk_Pixbuf is function Internal (Cursor : Gdk.Gdk_Cursor) return System.Address; pragma Import (C, Internal, "gdk_cursor_get_image"); begin return Convert (Internal (Cursor)); end Get_Image; -------------------- -- Get_N_Channels -- -------------------- function Get_N_Channels (Pixbuf : Gdk_Pixbuf) return Gint is function Internal (Pixbuf : System.Address) return Gint; pragma Import (C, Internal, "gdk_pixbuf_get_n_channels"); begin return Internal (Get_Object (Pixbuf)); end Get_N_Channels; ---------------- -- Get_Pixbuf -- ---------------- function Get_Pixbuf (Iter : Gdk_Pixbuf_Animation_Iter) return Gdk_Pixbuf is function Internal (Iter : Gdk_Pixbuf_Animation_Iter) return System.Address; pragma Import (C, Internal, "gdk_pixbuf_animation_iter_get_pixbuf"); begin return Convert (Internal (Iter)); end Get_Pixbuf; ---------------- -- Get_Pixels -- ---------------- function Get_Pixels (Pixbuf : Gdk_Pixbuf) return Rgb_Buffer_Access is function Internal (Pixbuf : System.Address) return Rgb_Buffer_Access; pragma Import (C, Internal, "gdk_pixbuf_get_pixels"); begin return Internal (Get_Object (Pixbuf)); end Get_Pixels; ------------------- -- Get_Rowstride -- ------------------- function Get_Rowstride (Pixbuf : Gdk_Pixbuf) return Gint is function Internal (Pixbuf : System.Address) return Gint; pragma Import (C, Internal, "gdk_pixbuf_get_rowstride"); begin return Internal (Get_Object (Pixbuf)); end Get_Rowstride; ---------------------- -- Get_Static_Image -- ---------------------- function Get_Static_Image (Animation : Gdk_Pixbuf_Animation) return Gdk_Pixbuf is function Internal (Animation : Gdk_Pixbuf_Animation) return System.Address; pragma Import (C, Internal, "gdk_pixbuf_animation_get_static_image"); begin return Convert (Internal (Animation)); end Get_Static_Image; --------------- -- Get_Width -- --------------- function Get_Width (Pixbuf : Gdk_Pixbuf) return Gint is function Internal (Pixbuf : System.Address) return Gint; pragma Import (C, Internal, "gdk_pixbuf_get_width"); begin return Internal (Get_Object (Pixbuf)); end Get_Width; --------------- -- Get_Width -- --------------- function Get_Width (Animation : Gdk_Pixbuf_Animation) return Gint is function Internal (Animation : Gdk_Pixbuf_Animation) return Gint; pragma Import (C, Internal, "gdk_pixbuf_animation_get_width"); begin return Internal (Animation); end Get_Width; --------- -- Ref -- --------- procedure Ref (Animation : Gdk_Pixbuf_Animation) is procedure Internal (Pixbuf : Gdk_Pixbuf_Animation); pragma Import (C, Internal, "gdk_pixbuf_animation_ref"); begin Internal (Animation); end Ref; procedure Ref (Iter : Gdk_Pixbuf_Animation_Iter) is procedure Internal (Iter : Gdk_Pixbuf_Animation_Iter); pragma Import (C, Internal, "g_object_ref"); begin Internal (Iter); end Ref; --------------------------- -- Saturate_And_Pixelate -- --------------------------- procedure Saturate_And_Pixelate (Src : Gdk_Pixbuf; Dest : Gdk_Pixbuf; Saturation : Gfloat; Pixelate : Boolean := True) is procedure Internal (Src : System.Address; Dest : System.Address; Saturation : Gfloat; Pixelate : Gboolean); pragma Import (C, Internal, "gdk_pixbuf_saturate_and_pixelate"); begin Internal (Get_Object (Src), Get_Object (Dest), Saturation, Boolean'Pos (Pixelate)); end Saturate_And_Pixelate; ---------- -- Save -- ---------- procedure Save (Pixbuf : Gdk_Pixbuf; Filename : String; Format : File_Format; Error : out GError; Quality : Image_Quality := Image_Quality'Last; Depth : Integer := 32) is procedure Internal (Pixbuf : System.Address; Filename : String; Format : String; Error : out GError; Term : System.Address := System.Null_Address); procedure Internal (Pixbuf : System.Address; Filename : String; Format : String; Error : out GError; Key : String; Value : String); pragma Import (C, Internal, "ada_gdk_pixbuf_save"); begin Error := null; case Format is when JPEG => Internal (Get_Object (Pixbuf), Filename & ASCII.NUL, "jpeg" & ASCII.NUL, Error, "quality" & ASCII.NUL, Image_Quality'Image (Quality) & ASCII.NUL); when PNG => Internal (Get_Object (Pixbuf), Filename & ASCII.NUL, "png" & ASCII.NUL, Error); when ICO => Internal (Get_Object (Pixbuf), Filename & ASCII.NUL, "ico" & ASCII.NUL, Error, "depth" & ASCII.NUL, Integer'Image (Depth)); when BMP => Internal (Get_Object (Pixbuf), Filename & ASCII.NUL, "bmp" & ASCII.NUL, Error); end case; end Save; ----------- -- Scale -- ----------- procedure Scale (Src : Gdk_Pixbuf; Dest : Gdk_Pixbuf; Dest_X : Gint; Dest_Y : Gint; Dest_Width : Gint; Dest_Height : Gint; Offset_X : Gdouble := 0.0; Offset_Y : Gdouble := 0.0; Scale_X : Gdouble := 1.0; Scale_Y : Gdouble := 1.0; Inter_Type : Gdk_Interp_Type := Interp_Bilinear) is procedure Internal (Src : System.Address; Dest : System.Address; Dest_X : Gint; Dest_Y : Gint; Dest_Width : Gint; Dest_Height : Gint; Offset_X : Gdouble := 0.0; Offset_Y : Gdouble := 0.0; Scale_X : Gdouble := 1.0; Scale_Y : Gdouble := 1.0; Inter_Type : Gdk_Interp_Type); pragma Import (C, Internal, "gdk_pixbuf_scale"); begin Internal (Get_Object (Src), Get_Object (Dest), Dest_X, Dest_Y, Dest_Width, Dest_Height, Offset_X, Offset_Y, Scale_X, Scale_Y, Inter_Type); end Scale; ------------------ -- Scale_Simple -- ------------------ function Scale_Simple (Src : Gdk_Pixbuf; Dest_Width : Gint; Dest_Height : Gint; Inter_Type : Gdk_Interp_Type := Interp_Bilinear) return Gdk_Pixbuf is function Internal (Src : System.Address; Dest_Width : Gint; Dest_Height : Gint; Inter_Type : Gdk_Interp_Type) return System.Address; pragma Import (C, Internal, "gdk_pixbuf_scale_simple"); begin return Convert (Internal (Get_Object (Src), Dest_Width, Dest_Height, Inter_Type)); end Scale_Simple; ----------- -- Unref -- ----------- procedure Unref (Animation : Gdk_Pixbuf_Animation) is procedure Internal (Pixbuf : Gdk_Pixbuf_Animation); pragma Import (C, Internal, "gdk_pixbuf_animation_unref"); begin Internal (Animation); end Unref; procedure Unref (Iter : Gdk_Pixbuf_Animation_Iter) is procedure Internal (Iter : Gdk_Pixbuf_Animation_Iter); pragma Import (C, Internal, "g_object_unref"); begin Internal (Iter); end Unref; --------------------- -- Is_Static_Image -- --------------------- function Is_Static_Image (Animation : Gdk_Pixbuf_Animation) return Boolean is function Internal (Animation : Gdk_Pixbuf_Animation) return Gboolean; pragma Import (C, Internal, "gdk_pixbuf_animation_is_static_image"); begin return Internal (Animation) /= 0; end Is_Static_Image; -------------------------------- -- On_Currently_Loading_Frame -- -------------------------------- function On_Currently_Loading_Frame (Iter : Gdk_Pixbuf_Animation_Iter) return Boolean is function Internal (Animation : Gdk_Pixbuf_Animation_Iter) return Gboolean; pragma Import (C, Internal, "gdk_pixbuf_animation_iter_on_currently_loading_frame"); begin return Internal (Iter) /= 0; end On_Currently_Loading_Frame; ------------- -- Advance -- ------------- function Advance (Iter : Gdk_Pixbuf_Animation_Iter; Current_Timer : GTime_Val_Access := null) return Boolean is function Internal (Iter : Gdk_Pixbuf_Animation_Iter; Current_Timer : GTime_Val_Access) return Gboolean; pragma Import (C, Internal, "gdk_pixbuf_animation_iter_advance"); begin return Internal (Iter, Current_Timer) /= 0; end Advance; ------------------------- -- Gdk_New_From_Pixbuf -- ------------------------- procedure Gdk_New_From_Pixbuf (Cursor : out Gdk.Gdk_Cursor; Display : Gdk.Display.Gdk_Display := Gdk.Display.Get_Default; Pixbuf : Gdk_Pixbuf; X : Glib.Gint; Y : Glib.Gint) is function Internal (D : System.Address; P : System.Address; X, Y : Gint) return Gdk_Cursor; pragma Import (C, Internal, "gdk_cursor_new_from_pixbuf"); begin Cursor := Internal (Get_Object (Display), Get_Object (Pixbuf), X, Y); end Gdk_New_From_Pixbuf; end Gdk.Pixbuf; gtkada-24.0.0/src/gdk-pixbuf.ads000066400000000000000000000625051446021174000163570ustar00rootroot00000000000000------------------------------------------------------------------------------ -- GtkAda - Ada95 binding for Gtk+/Gnome -- -- -- -- Copyright (C) 2000-2018, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ -- -- This object provides image manipulation routines. -- -- The following image formats are known, but some depend on external -- libraries for the proper loading of files (indicated with * in the list): -- PNG*, JPEG*, TIFF*, GIF, XPM, PNM, Sun raster file (ras), ico, -- bmp. -- -- With this package, you can load images from file, display them on the -- screen, re-scale them and compose them with other images. -- All the functions fully support alpha channels (opacity). -- -- Different filters are provided, depending on the quality of output you -- expect and the speed you need. -- -- 1.3.11 -- Gdk, the low-level API -- create_pixbuf.adb with System; with Cairo; with Glib; use Glib; with Glib.Error; use Glib.Error; with Glib.Object; with Gdk.Display; with Gtkada.Types; package Gdk.Pixbuf is type Gdk_Pixbuf_Record is new Glib.Object.GObject_Record with private; type Gdk_Pixbuf is access all Gdk_Pixbuf_Record'Class; -- A very efficient client-side pixmap. -- This type can be adapted to all the possible screen depths (number of -- bits per pixel), and the algorithms are extremely efficient. -- You can also load a pixbuf directly from an external file in one of -- the standard image formats. Null_Pixbuf : constant Gdk_Pixbuf := null; type Gdk_Pixbuf_Animation is new Glib.C_Proxy; -- Type used for animations. type Gdk_Pixbuf_Animation_Iter is new Glib.C_Proxy; -- Type used to iterate through an animation. type Alpha_Mode is (Alpha_Bilevel, Alpha_Full); -- Alpha compositing mode. -- This indicates how the alpha channel (for opacity) is handled when -- rendering. pragma Convention (C, Alpha_Mode); type Gdk_Colorspace is (Colorspace_RGB); -- Type of the image. -- The only possible value is currently RGB, but extensions will -- exist with CMYK, Gray, Lab, ... pragma Convention (C, Gdk_Colorspace); type Gdk_Interp_Type is (Interp_Nearest, -- Nearest neighbor. It is the fastest and lowest quality. Interp_Tiles, -- Accurate simulation of the Postscript image operator -- without any interpolation enabled; each pixel is rendered as a tiny -- parallelogram of solid color, the edges of which are implemented -- with anti-aliasing. It resembles nearest neighbor for enlargement, -- and bilinear for reduction. Interp_Bilinear, -- Bilinear interpolation. For enlargement, it is equivalent to -- point-sampling the ideal bilinear-interpolated image. For reduction, -- it is equivalent to laying down small tiles and integrating over the -- coverage area. Interp_Hyper -- Filter_Hyper is the highest quality reconstruction function. It is -- derived from the hyperbolic filters in Wolberg's "Digital Image -- Warping," and is formally defined as the hyperbolic-filter sampling -- the ideal hyperbolic-filter interpolated image (the filter is -- designed to be idempotent for 1:1 pixel mapping). It is the slowest -- and highest quality. ); -- Interpolation methods. pragma Convention (C, Gdk_Interp_Type); ------------ -- Errors -- ------------ -- Errors defined in the Pixbuf_Error domain: Corrupt_Image : constant := 0; -- image data hosed Insufficient_Memory : constant := 1; -- no mem to load image Bad_Option : constant := 2; -- bad option passed to save routine Unknown_Type : constant := 3; -- unsupported image type Unsupported_Operation : constant := 4; -- unsupported operation (load, save) for image type Failed : constant := 5; -- Operation failed. type File_Format is (JPEG, PNG, ICO, BMP); -- Possible formats when saving a file. type Image_Quality is range 0 .. 100; -- For a JPEG image only, quality of the image in percentage. type Alpha_Range is range 0 .. 255; -- Valid values for alpha parameters. pragma Convention (C, Alpha_Range); type Gdk_Rgb_Dither is (Dither_None, Dither_Normal, Dither_Max); -- The three kinds of dithering that are implemented in this package: -- - Dither_None: No dithering will be done -- - Dither_Normal: Specifies dithering on 8 bit displays, but not 16-bit. -- Usually the best choice. -- - Dither_Max: Specifies dithering on every kind of display for Gdk_Rgb_Dither'Size use Glib.Gint'Size; type Rgb_Record is record Red, Green, Blue : Glib.Guchar; end record; pragma Convention (C, Rgb_Record); -- This is the buffer that will contain the image. You can manipulate each -- byte in it independantly, although there is no high level routine -- to draw lines, circles, ... -- Once you are done drawing into this buffer, you can copy it to any -- drawable on the screen, *if* the widget was created with the correct -- visual and colormap (see above). type Unchecked_Rgb_Buffer is array (Glib.Guint) of Rgb_Record; pragma Convention (C, Unchecked_Rgb_Buffer); type Rgb_Buffer_Access is access all Unchecked_Rgb_Buffer; pragma Convention (C, Rgb_Buffer_Access); -- Type used By Get_Pixels to return an array with no -- bound checks that is compatible with C (also known as a flat array). -------------- -- Get_Type -- -------------- function Get_Type return Glib.GType; -- Return the internal value associated with a Gdk_Pixbuf. -------------------------- -- Accessing the fields -- -------------------------- function Get_Colorspace (Pixbuf : Gdk_Pixbuf) return Gdk_Colorspace; -- Query the color space of a pixbuf. function Get_N_Channels (Pixbuf : Gdk_Pixbuf) return Gint; -- Number of channels in the image. function Get_Has_Alpha (Pixbuf : Gdk_Pixbuf) return Boolean; -- Return True if the image has an alpha channel (opacity information). function Get_Bits_Per_Sample (Pixbuf : Gdk_Pixbuf) return Gint; -- Number of bits per color sample. function Get_Pixels (Pixbuf : Gdk_Pixbuf) return Rgb_Buffer_Access; -- Return a pointer to the pixel data of the image. function Get_Width (Pixbuf : Gdk_Pixbuf) return Gint; -- Return the width of the image in pixels. function Get_Height (Pixbuf : Gdk_Pixbuf) return Gint; -- Return the height of the image in pixels. function Get_Rowstride (Pixbuf : Gdk_Pixbuf) return Gint; -- Return the number of bytes between rows in the image data. -------------- -- Creating -- -------------- function Gdk_New (Colorspace : Gdk_Colorspace := Colorspace_RGB; Has_Alpha : Boolean := False; Bits_Per_Sample : Gint := 8; Width : Gint; Height : Gint) return Gdk_Pixbuf; -- Create a blank pixbuf with an optimal row stride and a new buffer. -- The buffer is allocated, but not cleared. -- The reference counting is initialized to 1. function Copy (Pixbuf : Gdk_Pixbuf) return Gdk_Pixbuf; -- Copy a pixbuf. function Gdk_New_Subpixbuf (Src_Pixbuf : Gdk_Pixbuf; Src_X : Gint; Src_Y : Gint; Width : Gint; Height : Gint) return Gdk_Pixbuf; -- Create a pixbuf which points to the pixels of another pixbuf procedure Gdk_New_From_File (Pixbuf : out Gdk_Pixbuf; Filename : String; Error : out GError); -- Load an image from file. function Gdk_New_From_Data (Data : Guchar_Array_Access; Colorspace : Gdk_Colorspace := Colorspace_RGB; Has_Alpha : Boolean := False; Bits_Per_Sample : Gint := 8; Width : Gint; Height : Gint; Rowstride : Gint; Auto_Destroy_Data : Boolean := True) return Gdk_Pixbuf; -- Create a pixbuf out of in-memory image data. -- Currently only RGB images with 8 bits per sample are supported. -- Width and Height must be > 0. -- Rowstride is the distance in bytes between row starts. -- A typical value is 4*Width when there is an Alpha channel. -- If Auto_Destroy_Data is true, passed data will be automatically -- freed when the reference count of the pixbuf reaches 1. -- Otherwise, data is never freed. function Gdk_New_From_Xpm_Data (Data : Gtkada.Types.Chars_Ptr_Array) return Gdk_Pixbuf; -- Create an image from a XPM data. procedure Fill (Pixbuf : Gdk_Pixbuf; Pixel : Guint32); -- Fill pixbuf with a given pixel value. procedure Save (Pixbuf : Gdk_Pixbuf; Filename : String; Format : File_Format; Error : out GError; Quality : Image_Quality := Image_Quality'Last; Depth : Integer := 32); -- Save pixbuf to a file. -- Quality is only taken into account for JPEG images. -- Depth is only taken into account for ICO images and can take the values -- 16, 24 or 32. -- Error is set to null on success, and set to a GError otherwise. function Add_Alpha (Pixbuf : Gdk_Pixbuf; Substitute_Color : Boolean := False; Red : Guchar := 0; Green : Guchar := 0; Blue : Guchar := 0) return Gdk_Pixbuf; -- Add an alpha channel. -- Return a newly allocated image copied from Pixbuf, but with an -- extra alpha channel. -- If Pixbuf already had an alpha channel, the two images have exactly -- the same contents. -- If Substitute_Color is True, the color (Red, Green, Blue) is -- substituted for zero opacity. -- If Substitute_Color is False, Red, Green and Blue are ignored, and a -- new color is created with zero opacity. procedure Copy_Area (Src_Pixbuf : Gdk_Pixbuf; Src_X : Gint; Src_Y : Gint; Width : Gint; Height : Gint; Dest_Pixbuf : Gdk_Pixbuf; Dest_X : Gint; Dest_Y : Gint); -- Copy a rectangular area from Src_pixbuf to Dest_pixbuf. -- Conversion of pixbuf formats is done automatically. procedure Saturate_And_Pixelate (Src : Gdk_Pixbuf; Dest : Gdk_Pixbuf; Saturation : Gfloat; Pixelate : Boolean := True); -- Brighten/darken and optionally make it pixelated-looking. --------------- -- Rendering -- --------------- function Get_From_Window (Window : Gdk_Window; Src_X : Gint; Src_Y : Gint; Width : Gint; Height : Gint) return Gdk_Pixbuf; function Get_From_Surface (Surface : Cairo.Cairo_Surface; Src_X : Gint; Src_Y : Gint; Width : Gint; Height : Gint) return Gdk_Pixbuf; -- Transfers image data from a Gdk_Window and converts it to an RGB(A) -- representation inside a Gdk_Pixbuf. In other words, copies -- image data from a server-side drawable to a client-side RGB(A) buffer. -- This allows you to efficiently read individual pixels on the client -- side. -- -- This function will create an RGB pixbuf with 8 bits per channel with -- the same size specified by the Width and Height arguments. The pixbuf -- will contain an alpha channel if the window contains one. -- -- If the window is off the screen, then there is no image data in the -- obscured/offscreen regions to be placed in the pixbuf. The contents -- of portions of the pixbuf corresponding to the offscreen region are -- undefined. -- -- If the window you're obtaining data from is partially obscured by other -- windows, then the contents of the pixbuf areas corresponding to the -- obscured regions are undefined. -- -- If the window is not mapped (typically because it's iconified/minimized -- or not on the current workspace), then Null_Pixbuf will be returned. -- -- If memory can't be allocated for the return value, Null_Pixbuf -- will be returned instead. -- -- (In short, there are several ways this function can fail, and if it -- fails it returns Null_Pixbuf; so check the return value.) -- -- Return value: (transfer full): A newly-created pixbuf with a reference -- count of 1, or Null_Pixbuf on error ------------- -- Scaling -- ------------- procedure Scale (Src : Gdk_Pixbuf; Dest : Gdk_Pixbuf; Dest_X : Gint; Dest_Y : Gint; Dest_Width : Gint; Dest_Height : Gint; Offset_X : Gdouble := 0.0; Offset_Y : Gdouble := 0.0; Scale_X : Gdouble := 1.0; Scale_Y : Gdouble := 1.0; Inter_Type : Gdk_Interp_Type := Interp_Bilinear); -- Transform the source image by scaling by Scale_x and Scale_y then -- translating by Offset_x and Offset_y. -- The image is then rendered in the rectangle (Dest_x, Dest_y, -- Dest_width, Dest_height) of the resulting image onto the destination -- drawable replacing the previous contents. procedure Composite (Src : Gdk_Pixbuf; Dest : Gdk_Pixbuf; Dest_X : Gint; Dest_Y : Gint; Dest_Width : Gint; Dest_Height : Gint; Offset_X : Gdouble := 0.0; Offset_Y : Gdouble := 0.0; Scale_X : Gdouble := 1.0; Scale_Y : Gdouble := 1.0; Inter_Type : Gdk_Interp_Type := Interp_Bilinear; Overall_Alpha : Alpha_Range := 128); -- Transform the source image by scaling by Scale_X and Scale_Y then -- translating by Offset_X and Offset_Y, then composite the rectangle -- (Dest_X, Dest_Y, Dest_Width, Dest_Height) of the resulting image onto -- the destination drawable. procedure Composite_Color (Src : Gdk_Pixbuf; Dest : Gdk_Pixbuf; Dest_X : Gint; Dest_Y : Gint; Dest_Width : Gint; Dest_Height : Gint; Offset_X : Gdouble := 0.0; Offset_Y : Gdouble := 0.0; Scale_X : Gdouble := 1.0; Scale_Y : Gdouble := 1.0; Inter_Type : Gdk_Interp_Type := Interp_Bilinear; Overall_Alpha : Alpha_Range := 128; Check_X : Gint := 0; Check_Y : Gint := 0; Check_Size : Gint := 0; Color1 : Guint32 := 0; Color2 : Guint32 := 0); -- Transform the source image by scaling by Scale_x and Scale_y then -- translating by Offset_x and Offset_y, then composites the rectangle -- (Dest_X, Dest_Y, Dest_Width, Dest_Height) of the resulting image with -- a checkboard of the colors Color1 and Color2 and renders it onto the -- destination drawable. -- The origin of checkboard is at (Check_x, Check_y) -- Color1 is the color at the upper left of the check. function Scale_Simple (Src : Gdk_Pixbuf; Dest_Width : Gint; Dest_Height : Gint; Inter_Type : Gdk_Interp_Type := Interp_Bilinear) return Gdk_Pixbuf; -- Scale the Src image to Dest_width x Dest_height and render the result -- into a new pixbuf. function Composite_Color_Simple (Src : Gdk_Pixbuf; Dest_Width : Gint; Dest_Height : Gint; Inter_Type : Gdk_Interp_Type := Interp_Bilinear; Overall_Alpha : Alpha_Range := 128; Color1 : Guint32 := 0; Color2 : Guint32 := 0) return Gdk_Pixbuf; -- Scale Src to Dest_width x Dest_height and composite the result with -- a checkboard of colors Color1 and Color2 and render the result into -- a new pixbuf. ----------------------- -- Animation support -- ----------------------- function Get_Type_Animation return Glib.GType; -- Return the internal value associated with a Gdk_Pixbuf_Animation. procedure Gdk_New_From_File (Animation : out Gdk_Pixbuf_Animation; Filename : String; Error : out GError); -- Create a new animation by loading it from a file. -- The file format is detected automatically. If the file's format does not -- support multi-frame images, then an animation with a single frame will -- be created. Possible errors are in the Pixbuf_Error and GFile_Error -- domains. -- On return, Animation is a newly created animation with a reference count -- of 1, or null if any of several error conditions ocurred: the file could -- not be opened, there was no loader for the file's format, there was not -- enough memory to allocate the image buffer, or the image file contained -- invalid data. procedure Ref (Animation : Gdk_Pixbuf_Animation); -- Increment the reference counting on the animation. procedure Unref (Animation : Gdk_Pixbuf_Animation); -- Decrement the reference counting on the animation. function Get_Width (Animation : Gdk_Pixbuf_Animation) return Gint; -- Return the width of the bounding box of a pixbuf animation. function Get_Height (Animation : Gdk_Pixbuf_Animation) return Gint; -- Return the height of the bounding box of a pixbuf animation. function Is_Static_Image (Animation : Gdk_Pixbuf_Animation) return Boolean; -- If you load a file with Gdk_New_From_File and it turns out to be a -- plain, unanimated image, then this function will return True. -- Use Get_Static_Image to retrieve the image. function Get_Static_Image (Animation : Gdk_Pixbuf_Animation) return Gdk_Pixbuf; -- If an animation is really just a plain image (has only one frame), -- this function returns that image. If the animation is an animation, -- this function returns a reasonable thing to display as a static -- unanimated image, which might be the first frame, or something more -- sophisticated. If an animation hasn't loaded any frames yet, this -- function will return null. function Get_Iter (Animation : Gdk_Pixbuf_Animation; Start_Time : GTime_Val_Access := null) return Gdk_Pixbuf_Animation_Iter; -- Get an iterator for displaying an animation. The iterator provides -- the frames that should be displayed at a given time. -- It should be freed after use with Unref. -- -- Start_Time would normally come from G_Get_Current_Time, and marks the -- beginning of animation playback. After creating an iterator, you should -- immediately display the pixbuf returned by Get_Pixbuf. Then, you should -- install a timeout (with Timeout_Add) or by some other mechanism to -- ensure that you'll update the image after Get_Delay_Time milliseconds. -- Each time the image is updated, you should reinstall the timeout with -- the new, possibly-changed delay time. -- -- As a shortcut, if Start_Time is equal to null, the result of -- G_Get_Current_Time will be used automatically. -- -- To update the image (i.e. possibly change the result of Get_Pixbuf to a -- new frame of the animation), call Advance. -- -- If you're using Gdk_Pixbuf_Loader, in addition to updating the image -- after the delay time, you should also update it whenever you -- receive the area_updated signal and On_Currently_Loading_Frame returns -- True. In this case, the frame currently being fed into the loader -- has received new data, so needs to be refreshed. The delay time for -- a frame may also be modified after an area_updated signal, for -- example if the delay time for a frame is encoded in the data after -- the frame itself. So your timeout should be reinstalled after any -- area_updated signal. -- -- A delay time of -1 is possible, indicating "infinite." --------------- -- Iterators -- --------------- function Get_Type_Animation_Iter return Glib.GType; -- Return the internal value associated with a Gdk_Pixbuf_Animation_Iter. procedure Ref (Iter : Gdk_Pixbuf_Animation_Iter); -- Increment the reference counting on the iterator. procedure Unref (Iter : Gdk_Pixbuf_Animation_Iter); -- Decrement the reference counting on the iterator. function Get_Delay_Time (Iter : Gdk_Pixbuf_Animation_Iter) return Gint; -- Return the number of milliseconds the current pixbuf should be displayed -- or -1 if the current pixbuf should be displayed forever. Timeout_Add -- conveniently takes a timeout in milliseconds, so you can use a timeout -- to schedule the next update. function Get_Pixbuf (Iter : Gdk_Pixbuf_Animation_Iter) return Gdk_Pixbuf; -- Return the current pixbuf which should be displayed. -- The pixbuf will be the same size as the animation itself (Get_Width, -- Get_Height). This pixbuf should be displayed for Get_Delay_Time -- milliseconds. The caller of this function does not own a reference to -- the returned pixbuf; the returned pixbuf will become invalid when the -- iterator advances to the next frame, which may happen anytime you call -- Advance. Copy the pixbuf to keep it (don't just add a reference), as it -- may get recycled as you advance the iterator. function On_Currently_Loading_Frame (Iter : Gdk_Pixbuf_Animation_Iter) return Boolean; -- Used to determine how to respond to the area_updated signal on -- Gdk_Pixbuf_Loader when loading an animation. area_updated is emitted -- for an area of the frame currently streaming in to the loader. So if -- you're on the currently loading frame, you need to redraw the screen for -- the updated area. function Advance (Iter : Gdk_Pixbuf_Animation_Iter; Current_Timer : GTime_Val_Access := null) return Boolean; -- Possibly advance an animation to a new frame. -- Chooses the frame based on the start time passed to Get_Iter. -- -- Current_Time would normally come from G_Get_Current_Time, and -- must be greater than or equal to the time passed to Get_Iter, -- and must increase or remain unchanged each time Get_Pixbuf is -- called. That is, you can't go backward in time; animations only -- play forward. -- -- As a shortcut, pass null for the current time and G_Get_Current_Time -- will be invoked on your behalf. So you only need to explicitly pass -- Current_Time if you're doing something odd like playing the animation -- at double speed. -- -- If this function returns False, there's no need to update the animation -- display, assuming the display had been rendered prior to advancing; -- if True, you need to call Get_Pixbuf and update the display with the new -- pixbuf. ------------- -- Cursors -- ------------- procedure Gdk_New_From_Pixbuf (Cursor : out Gdk.Gdk_Cursor; Display : Gdk.Display.Gdk_Display := Gdk.Display.Get_Default; Pixbuf : Gdk_Pixbuf; X : Glib.Gint; Y : Glib.Gint); -- Create a cursor from a pixbuf. -- Not all GDK backends support RGBA cursors. If they are not supported, -- a monochrome approximation will be displayed. -- The functions gdk.display.supports_cursor_alpha and -- gdk.display.supports_cursor_color can be used to determine whether RGBA -- cursors are supported; -- gdk.display.get_default_cursor_size and -- gdk.display.get_maximal_cursor_size give information about cursor sizes. -- On the X backend, support for RGBA cursors requires a sufficently new -- version of the X Render extension. function Get_Image (Cursor : Gdk.Gdk_Cursor) return Gdk_Pixbuf; -- Return the image stored in the cursor -- function Convert (P : System.Address) return Gdk_Pixbuf; -- private type Gdk_Pixbuf_Record is new Glib.Object.GObject_Record with null record; pragma Import (C, Get_Type, "gdk_pixbuf_get_type"); pragma Import (C, Get_Type_Animation, "gdk_pixbuf_animation_get_type"); pragma Import (C, Get_Type_Animation_Iter, "gdk_pixbuf_animation_iter_get_type"); pragma Import (C, Get_Iter, "gdk_pixbuf_animation_get_iter"); pragma Import (C, Get_Delay_Time, "gdk_pixbuf_animation_iter_get_delay_time"); end Gdk.Pixbuf; gtkada-24.0.0/src/gdk-property.adb000066400000000000000000000137451446021174000167270ustar00rootroot00000000000000------------------------------------------------------------------------------ -- GtkAda - Ada95 binding for Gtk+/Gnome -- -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 1998-2018, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ with Glib.Object; use Glib.Object; with Interfaces.C.Pointers; with Gtkada.Types; package body Gdk.Property is ------------------------ -- Local declarations -- ------------------------ type Local_Guchar_Array is array (Natural range <>) of aliased Guchar; package Guchars_Ptr is new Interfaces.C.Pointers (Index => Natural, Element => Guchar, Element_Array => Local_Guchar_Array, Default_Terminator => 0); procedure C_Free (P : Guchars_Ptr.Pointer); pragma Import (C, C_Free, "free"); function To_Guchar_Array (Value : Local_Guchar_Array) return Guchar_Array; pragma Inline (To_Guchar_Array); ----------------- -- Atom_Intern -- ----------------- function Atom_Intern (Atom_Name : String; Only_If_Exists : Boolean := True) return Gdk.Types.Gdk_Atom is function Internal (Atom_Name : String; Only_If_Exists : Gint) return Gdk.Types.Gdk_Atom; pragma Import (C, Internal, "gdk_atom_intern"); begin return Internal (Atom_Name & ASCII.NUL, To_Gint (Only_If_Exists)); end Atom_Intern; --------------- -- Atom_Name -- --------------- function Atom_Name (Atom : Gdk.Types.Gdk_Atom) return String is function Internal (Atom : Gdk.Types.Gdk_Atom) return Gtkada.Types.Chars_Ptr; pragma Import (C, Internal, "gdk_atom_name"); begin return Gtkada.Types.Value (Internal (Atom)); end Atom_Name; ------------ -- Change -- ------------ procedure Change (Window : Gdk.Gdk_Window; Property : Gdk.Types.Gdk_Atom; The_Type : Gdk.Types.Gdk_Atom; Format : Gint; Mode : Gdk_Prop_Mode; Data : Guchar_Array) is procedure Internal (Window : Gdk.Gdk_Window; Property : Gdk.Types.Gdk_Atom; The_Type : Gdk.Types.Gdk_Atom; Format : Gint; Mode : Gdk_Prop_Mode; Data : Guchar_Array; Nelements : Gint); pragma Import (C, Internal, "gdk_property_change"); begin Internal (Window, Property, The_Type, Format, Mode, Data, Data'Length); end Change; --------- -- Get -- --------- procedure Get (Window : Gdk.Gdk_Window; Property : Gdk.Types.Gdk_Atom; The_Type : Gdk.Types.Gdk_Atom; Offset : Gulong; Length : Gulong; Pdelete : Boolean; Actual_Property_Type : out Gdk.Types.Gdk_Atom; Actual_Format : out Gint; Data : out Guchar_Array_Access; Success : out Boolean) is procedure Internal (Window : Gdk_Window; Property : Gdk.Types.Gdk_Atom; The_Type : Gdk.Types.Gdk_Atom; Offset : Gulong; Length : Gulong; Pdelete : Gint; Actual_Property_Type : out Gdk.Types.Gdk_Atom; Actual_Format : out Gint; Actual_Length : out Gint; Data : out Guchars_Ptr.Pointer; Success : out Gint); pragma Import (C, Internal, "ada_gdk_property_get"); Actual_Length : Gint; Tmp_Success : Gint; Tmp_Result : Guchars_Ptr.Pointer; begin Internal (Window, Property, The_Type, Offset, Length, Boolean'Pos (Pdelete), Actual_Property_Type, Actual_Format, Actual_Length, Tmp_Result, Tmp_Success); Success := Boolean'Val (Tmp_Success); Data := new Guchar_Array' (To_Guchar_Array (Guchars_Ptr.Value (Ref => Tmp_Result, Length => Interfaces.C.ptrdiff_t (Actual_Length)))); C_Free (Tmp_Result); end Get; ----------------------- -- To_Guchar_Array -- ----------------------- function To_Guchar_Array (Value : Local_Guchar_Array) return Guchar_Array is Result : Guchar_Array (Value'Range); begin for Index in Value'Range loop Result (Index) := Value (Index); end loop; return Result; end To_Guchar_Array; end Gdk.Property; gtkada-24.0.0/src/gdk-property.ads000066400000000000000000000065551446021174000167510ustar00rootroot00000000000000------------------------------------------------------------------------------ -- GtkAda - Ada95 binding for Gtk+/Gnome -- -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 1998-2018, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ -- 1.3.6 -- Gdk, the low-level API with Glib; use Glib; with Gdk.Types; package Gdk.Property is type Gdk_Prop_Mode is (Prop_Mode_Replace, Prop_Mode_Prepend, Prop_Mode_Append); pragma Convention (C, Gdk_Prop_Mode); function Atom_Intern (Atom_Name : String; Only_If_Exists : Boolean := True) return Gdk.Types.Gdk_Atom; -- Convert from a string to an atom function Atom_Name (Atom : Gdk.Types.Gdk_Atom) return String; -- Convert from an atom to a string procedure Get (Window : Gdk.Gdk_Window; Property : Gdk.Types.Gdk_Atom; The_Type : Gdk.Types.Gdk_Atom; Offset : Gulong; Length : Gulong; Pdelete : Boolean; Actual_Property_Type : out Gdk.Types.Gdk_Atom; Actual_Format : out Gint; Data : out Guchar_Array_Access; Success : out Boolean); procedure Change (Window : Gdk.Gdk_Window; Property : Gdk.Types.Gdk_Atom; The_Type : Gdk.Types.Gdk_Atom; Format : Gint; Mode : Gdk_Prop_Mode; Data : Guchar_Array); procedure Delete (Window : Gdk.Gdk_Window; Property : Gdk.Types.Gdk_Atom); private pragma Import (C, Delete, "gdk_property_delete"); end Gdk.Property; -- missing: -- gdk_text_property_to_text_list -- gdk_text_property_to_utf8_list -- gdk_utf8_to_string_target -- gdk_utf8_to_compound_text -- gdk_free_text_list -- gdk_string_to_compound_text -- gdk_free_compound_text gtkada-24.0.0/src/gdk-rectangle.adb000066400000000000000000000046041446021174000170010ustar00rootroot00000000000000------------------------------------------------------------------------------ -- GtkAda - Ada95 binding for Gtk+/Gnome -- -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 1998-2018, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ with System; package body Gdk.Rectangle is --------------- -- Intersect -- --------------- procedure Intersect (Src1 : Gdk_Rectangle; Src2 : Gdk_Rectangle; Dest : out Gdk_Rectangle; Intersect : out Boolean) is function Internal (Src1, Src2 : Gdk_Rectangle; Dest : System.Address) return Gint; pragma Import (C, Internal, "gdk_rectangle_intersect"); Dest_Rec : aliased Gdk_Rectangle; begin Intersect := Internal (Src1, Src2, Dest_Rec'Address) /= 0; Dest := Dest_Rec; end Intersect; end Gdk.Rectangle; gtkada-24.0.0/src/gdk-rectangle.ads000066400000000000000000000053661446021174000170300ustar00rootroot00000000000000------------------------------------------------------------------------------ -- GtkAda - Ada95 binding for Gtk+/Gnome -- -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 1998-2018, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ -- Gdk, the low-level API with Glib; use Glib; with Cairo.Region; use Cairo.Region; package Gdk.Rectangle is subtype Gdk_Rectangle is Cairo_Rectangle_Int; type Gdk_Rectangle_Access is access all Gdk_Rectangle; pragma Convention (C, Gdk_Rectangle_Access); type Gdk_Rectangle_Array is array (Natural range <>) of Gdk_Rectangle; -- This type is used by Gdk.Region. Full_Area : constant Gdk_Rectangle; -- The constant above can be used in Gtk.Widget.Draw when you want to -- redraw the whole widget procedure Intersect (Src1 : Gdk_Rectangle; Src2 : Gdk_Rectangle; Dest : out Gdk_Rectangle; Intersect : out Boolean); procedure Union (Src1 : Gdk_Rectangle; Src2 : Gdk_Rectangle; Dest : out Gdk_Rectangle); private Full_Area : constant Gdk_Rectangle := (Gint'First, Gint'First, Gint'Last, Gint'Last); pragma Import (C, Union, "gdk_rectangle_union"); end Gdk.Rectangle; gtkada-24.0.0/src/gdk-threads.ads000066400000000000000000000061631446021174000165120ustar00rootroot00000000000000------------------------------------------------------------------------------ -- GtkAda - Ada95 binding for Gtk+/Gnome -- -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 1998-2018, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ -- -- -- This package provides simple primitives to write multi-threaded -- applications with GtkAda. See the GtkAda User's Guide for more details -- (section Tasking with GtkAda). -- -- -- 1.3.6 -- Gdk, the low-level API with System; package Gdk.Threads is procedure G_Init (Vtable : System.Address := System.Null_Address); -- Initialize the Glib internal threading support. -- This procedure must be called before any call to Enter or Leave. -- The parameter Vtable should never be used for now. procedure Init; -- Initialize the Gdk internal threading support. -- This function must be called after G_Init and before any call to -- Enter or Leave. procedure Enter; -- Take the GtkAda global lock. -- See the GtkAda User's Guide for more details (section Tasking with -- GtkAda). procedure Leave; -- Release the GtkAda global lock. -- See the GtkAda User's Guide for more details (section Tasking with -- GtkAda). private pragma Linker_Options ("-lgthread-2.0"); -- This is needed to resolve g_thread_init pragma Import (C, G_Init, "g_thread_init"); pragma Import (C, Init, "gdk_threads_init"); pragma Import (C, Enter, "gdk_threads_enter"); pragma Import (C, Leave, "gdk_threads_leave"); end Gdk.Threads; gtkada-24.0.0/src/gdk-types-keysyms.ads000066400000000000000000003040721446021174000177260ustar00rootroot00000000000000------------------------------------------------------------------------------ -- GtkAda - Ada95 binding for the Gimp Toolkit -- -- -- -- Copyright (C) 1998-2018, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ -- Gdk, the low-level API package Gdk.Types.Keysyms is GDK_VoidSymbol : constant Gdk_Key_Type := 16#FFFFFF#; GDK_BackSpace : constant Gdk_Key_Type := 16#FF08#; GDK_Tab : constant Gdk_Key_Type := 16#FF09#; GDK_Linefeed : constant Gdk_Key_Type := 16#FF0A#; GDK_Clear : constant Gdk_Key_Type := 16#FF0B#; GDK_Return : constant Gdk_Key_Type := 16#FF0D#; GDK_Pause : constant Gdk_Key_Type := 16#FF13#; GDK_Scroll_Lock : constant Gdk_Key_Type := 16#FF14#; GDK_Sys_Req : constant Gdk_Key_Type := 16#FF15#; GDK_Escape : constant Gdk_Key_Type := 16#FF1B#; GDK_Delete : constant Gdk_Key_Type := 16#FFFF#; GDK_Multi_Key : constant Gdk_Key_Type := 16#FF20#; GDK_Kanji : constant Gdk_Key_Type := 16#FF21#; GDK_Muhenkan : constant Gdk_Key_Type := 16#FF22#; GDK_Henkan_Mode : constant Gdk_Key_Type := 16#FF23#; GDK_Henkan : constant Gdk_Key_Type := 16#FF23#; GDK_Romaji : constant Gdk_Key_Type := 16#FF24#; GDK_Hiragana : constant Gdk_Key_Type := 16#FF25#; GDK_Katakana : constant Gdk_Key_Type := 16#FF26#; GDK_Hiragana_Katakana : constant Gdk_Key_Type := 16#FF27#; GDK_Zenkaku : constant Gdk_Key_Type := 16#FF28#; GDK_Hankaku : constant Gdk_Key_Type := 16#FF29#; GDK_Zenkaku_Hankaku : constant Gdk_Key_Type := 16#FF2A#; GDK_Touroku : constant Gdk_Key_Type := 16#FF2B#; GDK_Massyo : constant Gdk_Key_Type := 16#FF2C#; GDK_Kana_Lock : constant Gdk_Key_Type := 16#FF2D#; GDK_Kana_Shift : constant Gdk_Key_Type := 16#FF2E#; GDK_Eisu_Shift : constant Gdk_Key_Type := 16#FF2F#; GDK_Eisu_Toggle : constant Gdk_Key_Type := 16#FF30#; GDK_Home : constant Gdk_Key_Type := 16#FF50#; GDK_Left : constant Gdk_Key_Type := 16#FF51#; GDK_Up : constant Gdk_Key_Type := 16#FF52#; GDK_Right : constant Gdk_Key_Type := 16#FF53#; GDK_Down : constant Gdk_Key_Type := 16#FF54#; GDK_Prior : constant Gdk_Key_Type := 16#FF55#; GDK_Page_Up : constant Gdk_Key_Type := 16#FF55#; GDK_Next : constant Gdk_Key_Type := 16#FF56#; GDK_Page_Down : constant Gdk_Key_Type := 16#FF56#; GDK_End : constant Gdk_Key_Type := 16#FF57#; GDK_Begin : constant Gdk_Key_Type := 16#FF58#; GDK_Select : constant Gdk_Key_Type := 16#FF60#; GDK_Print : constant Gdk_Key_Type := 16#FF61#; GDK_Execute : constant Gdk_Key_Type := 16#FF62#; GDK_Insert : constant Gdk_Key_Type := 16#FF63#; GDK_Undo : constant Gdk_Key_Type := 16#FF65#; GDK_Redo : constant Gdk_Key_Type := 16#FF66#; GDK_Menu : constant Gdk_Key_Type := 16#FF67#; GDK_Find : constant Gdk_Key_Type := 16#FF68#; GDK_Cancel : constant Gdk_Key_Type := 16#FF69#; GDK_Help : constant Gdk_Key_Type := 16#FF6A#; GDK_Break : constant Gdk_Key_Type := 16#FF6B#; GDK_Mode_Switch : constant Gdk_Key_Type := 16#FF7E#; GDK_Script_Switch : constant Gdk_Key_Type := 16#FF7E#; GDK_Num_Lock : constant Gdk_Key_Type := 16#FF7F#; GDK_KP_Space : constant Gdk_Key_Type := 16#FF80#; GDK_KP_Tab : constant Gdk_Key_Type := 16#FF89#; GDK_KP_Enter : constant Gdk_Key_Type := 16#FF8D#; GDK_KP_F1 : constant Gdk_Key_Type := 16#FF91#; GDK_KP_F2 : constant Gdk_Key_Type := 16#FF92#; GDK_KP_F3 : constant Gdk_Key_Type := 16#FF93#; GDK_KP_F4 : constant Gdk_Key_Type := 16#FF94#; GDK_KP_Home : constant Gdk_Key_Type := 16#FF95#; GDK_KP_Left : constant Gdk_Key_Type := 16#FF96#; GDK_KP_Up : constant Gdk_Key_Type := 16#FF97#; GDK_KP_Right : constant Gdk_Key_Type := 16#FF98#; GDK_KP_Down : constant Gdk_Key_Type := 16#FF99#; GDK_KP_Prior : constant Gdk_Key_Type := 16#FF9A#; GDK_KP_Page_Up : constant Gdk_Key_Type := 16#FF9A#; GDK_KP_Next : constant Gdk_Key_Type := 16#FF9B#; GDK_KP_Page_Down : constant Gdk_Key_Type := 16#FF9B#; GDK_KP_End : constant Gdk_Key_Type := 16#FF9C#; GDK_KP_Begin : constant Gdk_Key_Type := 16#FF9D#; GDK_KP_Insert : constant Gdk_Key_Type := 16#FF9E#; GDK_KP_Delete : constant Gdk_Key_Type := 16#FF9F#; GDK_KP_Equal : constant Gdk_Key_Type := 16#FFBD#; GDK_KP_Multiply : constant Gdk_Key_Type := 16#FFAA#; GDK_KP_Add : constant Gdk_Key_Type := 16#FFAB#; GDK_KP_Separator : constant Gdk_Key_Type := 16#FFAC#; GDK_KP_Subtract : constant Gdk_Key_Type := 16#FFAD#; GDK_KP_Decimal : constant Gdk_Key_Type := 16#FFAE#; GDK_KP_Divide : constant Gdk_Key_Type := 16#FFAF#; GDK_KP_0 : constant Gdk_Key_Type := 16#FFB0#; GDK_KP_1 : constant Gdk_Key_Type := 16#FFB1#; GDK_KP_2 : constant Gdk_Key_Type := 16#FFB2#; GDK_KP_3 : constant Gdk_Key_Type := 16#FFB3#; GDK_KP_4 : constant Gdk_Key_Type := 16#FFB4#; GDK_KP_5 : constant Gdk_Key_Type := 16#FFB5#; GDK_KP_6 : constant Gdk_Key_Type := 16#FFB6#; GDK_KP_7 : constant Gdk_Key_Type := 16#FFB7#; GDK_KP_8 : constant Gdk_Key_Type := 16#FFB8#; GDK_KP_9 : constant Gdk_Key_Type := 16#FFB9#; GDK_F1 : constant Gdk_Key_Type := 16#FFBE#; GDK_F2 : constant Gdk_Key_Type := 16#FFBF#; GDK_F3 : constant Gdk_Key_Type := 16#FFC0#; GDK_F4 : constant Gdk_Key_Type := 16#FFC1#; GDK_F5 : constant Gdk_Key_Type := 16#FFC2#; GDK_F6 : constant Gdk_Key_Type := 16#FFC3#; GDK_F7 : constant Gdk_Key_Type := 16#FFC4#; GDK_F8 : constant Gdk_Key_Type := 16#FFC5#; GDK_F9 : constant Gdk_Key_Type := 16#FFC6#; GDK_F10 : constant Gdk_Key_Type := 16#FFC7#; GDK_F11 : constant Gdk_Key_Type := 16#FFC8#; GDK_L1 : constant Gdk_Key_Type := 16#FFC8#; GDK_F12 : constant Gdk_Key_Type := 16#FFC9#; GDK_L2 : constant Gdk_Key_Type := 16#FFC9#; GDK_F13 : constant Gdk_Key_Type := 16#FFCA#; GDK_L3 : constant Gdk_Key_Type := 16#FFCA#; GDK_F14 : constant Gdk_Key_Type := 16#FFCB#; GDK_L4 : constant Gdk_Key_Type := 16#FFCB#; GDK_F15 : constant Gdk_Key_Type := 16#FFCC#; GDK_L5 : constant Gdk_Key_Type := 16#FFCC#; GDK_F16 : constant Gdk_Key_Type := 16#FFCD#; GDK_L6 : constant Gdk_Key_Type := 16#FFCD#; GDK_F17 : constant Gdk_Key_Type := 16#FFCE#; GDK_L7 : constant Gdk_Key_Type := 16#FFCE#; GDK_F18 : constant Gdk_Key_Type := 16#FFCF#; GDK_L8 : constant Gdk_Key_Type := 16#FFCF#; GDK_F19 : constant Gdk_Key_Type := 16#FFD0#; GDK_L9 : constant Gdk_Key_Type := 16#FFD0#; GDK_F20 : constant Gdk_Key_Type := 16#FFD1#; GDK_L10 : constant Gdk_Key_Type := 16#FFD1#; GDK_F21 : constant Gdk_Key_Type := 16#FFD2#; GDK_R1 : constant Gdk_Key_Type := 16#FFD2#; GDK_F22 : constant Gdk_Key_Type := 16#FFD3#; GDK_R2 : constant Gdk_Key_Type := 16#FFD3#; GDK_F23 : constant Gdk_Key_Type := 16#FFD4#; GDK_R3 : constant Gdk_Key_Type := 16#FFD4#; GDK_F24 : constant Gdk_Key_Type := 16#FFD5#; GDK_R4 : constant Gdk_Key_Type := 16#FFD5#; GDK_F25 : constant Gdk_Key_Type := 16#FFD6#; GDK_R5 : constant Gdk_Key_Type := 16#FFD6#; GDK_F26 : constant Gdk_Key_Type := 16#FFD7#; GDK_R6 : constant Gdk_Key_Type := 16#FFD7#; GDK_F27 : constant Gdk_Key_Type := 16#FFD8#; GDK_R7 : constant Gdk_Key_Type := 16#FFD8#; GDK_F28 : constant Gdk_Key_Type := 16#FFD9#; GDK_R8 : constant Gdk_Key_Type := 16#FFD9#; GDK_F29 : constant Gdk_Key_Type := 16#FFDA#; GDK_R9 : constant Gdk_Key_Type := 16#FFDA#; GDK_F30 : constant Gdk_Key_Type := 16#FFDB#; GDK_R10 : constant Gdk_Key_Type := 16#FFDB#; GDK_F31 : constant Gdk_Key_Type := 16#FFDC#; GDK_R11 : constant Gdk_Key_Type := 16#FFDC#; GDK_F32 : constant Gdk_Key_Type := 16#FFDD#; GDK_R12 : constant Gdk_Key_Type := 16#FFDD#; GDK_F33 : constant Gdk_Key_Type := 16#FFDE#; GDK_R13 : constant Gdk_Key_Type := 16#FFDE#; GDK_F34 : constant Gdk_Key_Type := 16#FFDF#; GDK_R14 : constant Gdk_Key_Type := 16#FFDF#; GDK_F35 : constant Gdk_Key_Type := 16#FFE0#; GDK_R15 : constant Gdk_Key_Type := 16#FFE0#; GDK_Shift_L : constant Gdk_Key_Type := 16#FFE1#; GDK_Shift_R : constant Gdk_Key_Type := 16#FFE2#; GDK_Control_L : constant Gdk_Key_Type := 16#FFE3#; GDK_Control_R : constant Gdk_Key_Type := 16#FFE4#; GDK_Caps_Lock : constant Gdk_Key_Type := 16#FFE5#; GDK_Shift_Lock : constant Gdk_Key_Type := 16#FFE6#; GDK_Meta_L : constant Gdk_Key_Type := 16#FFE7#; GDK_Meta_R : constant Gdk_Key_Type := 16#FFE8#; GDK_Alt_L : constant Gdk_Key_Type := 16#FFE9#; GDK_Alt_R : constant Gdk_Key_Type := 16#FFEA#; GDK_Super_L : constant Gdk_Key_Type := 16#FFEB#; GDK_Super_R : constant Gdk_Key_Type := 16#FFEC#; GDK_Hyper_L : constant Gdk_Key_Type := 16#FFED#; GDK_Hyper_R : constant Gdk_Key_Type := 16#FFEE#; GDK_ISO_Lock : constant Gdk_Key_Type := 16#FE01#; GDK_ISO_Level2_Latch : constant Gdk_Key_Type := 16#FE02#; GDK_ISO_Level3_Shift : constant Gdk_Key_Type := 16#FE03#; GDK_ISO_Level3_Latch : constant Gdk_Key_Type := 16#FE04#; GDK_ISO_Level3_Lock : constant Gdk_Key_Type := 16#FE05#; GDK_ISO_Group_Shift : constant Gdk_Key_Type := 16#FF7E#; GDK_ISO_Group_Latch : constant Gdk_Key_Type := 16#FE06#; GDK_ISO_Group_Lock : constant Gdk_Key_Type := 16#FE07#; GDK_ISO_Next_Group : constant Gdk_Key_Type := 16#FE08#; GDK_ISO_Next_Group_Lock : constant Gdk_Key_Type := 16#FE09#; GDK_ISO_Prev_Group : constant Gdk_Key_Type := 16#FE0A#; GDK_ISO_Prev_Group_Lock : constant Gdk_Key_Type := 16#FE0B#; GDK_ISO_First_Group : constant Gdk_Key_Type := 16#FE0C#; GDK_ISO_First_Group_Lock : constant Gdk_Key_Type := 16#FE0D#; GDK_ISO_Last_Group : constant Gdk_Key_Type := 16#FE0E#; GDK_ISO_Last_Group_Lock : constant Gdk_Key_Type := 16#FE0F#; GDK_ISO_Left_Tab : constant Gdk_Key_Type := 16#FE20#; GDK_ISO_Move_Line_Up : constant Gdk_Key_Type := 16#FE21#; GDK_ISO_Move_Line_Down : constant Gdk_Key_Type := 16#FE22#; GDK_ISO_Partial_Line_Up : constant Gdk_Key_Type := 16#FE23#; GDK_ISO_Partial_Line_Down : constant Gdk_Key_Type := 16#FE24#; GDK_ISO_Partial_Space_Left : constant Gdk_Key_Type := 16#FE25#; GDK_ISO_Partial_Space_Right : constant Gdk_Key_Type := 16#FE26#; GDK_ISO_Set_Margin_Left : constant Gdk_Key_Type := 16#FE27#; GDK_ISO_Set_Margin_Right : constant Gdk_Key_Type := 16#FE28#; GDK_ISO_Release_Margin_Left : constant Gdk_Key_Type := 16#FE29#; GDK_ISO_Release_Margin_Right : constant Gdk_Key_Type := 16#FE2A#; GDK_ISO_Release_Both_Margins : constant Gdk_Key_Type := 16#FE2B#; GDK_ISO_Fast_Cursor_Left : constant Gdk_Key_Type := 16#FE2C#; GDK_ISO_Fast_Cursor_Right : constant Gdk_Key_Type := 16#FE2D#; GDK_ISO_Fast_Cursor_Up : constant Gdk_Key_Type := 16#FE2E#; GDK_ISO_Fast_Cursor_Down : constant Gdk_Key_Type := 16#FE2F#; GDK_ISO_Continuous_Underline : constant Gdk_Key_Type := 16#FE30#; GDK_ISO_Discontinuous_Underline : constant Gdk_Key_Type := 16#FE31#; GDK_ISO_Emphasize : constant Gdk_Key_Type := 16#FE32#; GDK_ISO_Center_Object : constant Gdk_Key_Type := 16#FE33#; GDK_ISO_Enter : constant Gdk_Key_Type := 16#FE34#; GDK_Dead_Grave : constant Gdk_Key_Type := 16#FE50#; GDK_Dead_Acute : constant Gdk_Key_Type := 16#FE51#; GDK_Dead_Circumflex : constant Gdk_Key_Type := 16#FE52#; GDK_Dead_Tilde : constant Gdk_Key_Type := 16#FE53#; GDK_Dead_Macron : constant Gdk_Key_Type := 16#FE54#; GDK_Dead_Breve : constant Gdk_Key_Type := 16#FE55#; GDK_Dead_Abovedot : constant Gdk_Key_Type := 16#FE56#; GDK_Dead_Diaeresis : constant Gdk_Key_Type := 16#FE57#; GDK_Dead_Abovering : constant Gdk_Key_Type := 16#FE58#; GDK_Dead_Doubleacute : constant Gdk_Key_Type := 16#FE59#; GDK_Dead_Caron : constant Gdk_Key_Type := 16#FE5A#; GDK_Dead_Cedilla : constant Gdk_Key_Type := 16#FE5B#; GDK_Dead_Ogonek : constant Gdk_Key_Type := 16#FE5C#; GDK_Dead_Iota : constant Gdk_Key_Type := 16#FE5D#; GDK_Dead_Voiced_Sound : constant Gdk_Key_Type := 16#FE5E#; GDK_Dead_Semivoiced_Sound : constant Gdk_Key_Type := 16#FE5F#; GDK_First_Virtual_Screen : constant Gdk_Key_Type := 16#FED0#; GDK_Prev_Virtual_Screen : constant Gdk_Key_Type := 16#FED1#; GDK_Next_Virtual_Screen : constant Gdk_Key_Type := 16#FED2#; GDK_Last_Virtual_Screen : constant Gdk_Key_Type := 16#FED4#; GDK_Terminate_Server : constant Gdk_Key_Type := 16#FED5#; GDK_Pointer_Left : constant Gdk_Key_Type := 16#FEE0#; GDK_Pointer_Right : constant Gdk_Key_Type := 16#FEE1#; GDK_Pointer_Up : constant Gdk_Key_Type := 16#FEE2#; GDK_Pointer_Down : constant Gdk_Key_Type := 16#FEE3#; GDK_Pointer_UpLeft : constant Gdk_Key_Type := 16#FEE4#; GDK_Pointer_UpRight : constant Gdk_Key_Type := 16#FEE5#; GDK_Pointer_DownLeft : constant Gdk_Key_Type := 16#FEE6#; GDK_Pointer_DownRight : constant Gdk_Key_Type := 16#FEE7#; GDK_Pointer_Button_Dflt : constant Gdk_Key_Type := 16#FEE8#; GDK_Pointer_Button1 : constant Gdk_Key_Type := 16#FEE9#; GDK_Pointer_Button2 : constant Gdk_Key_Type := 16#FEEA#; GDK_Pointer_Button3 : constant Gdk_Key_Type := 16#FEEB#; GDK_Pointer_Button4 : constant Gdk_Key_Type := 16#FEEC#; GDK_Pointer_Button5 : constant Gdk_Key_Type := 16#FEED#; GDK_Pointer_DblClick_Dflt : constant Gdk_Key_Type := 16#FEEE#; GDK_Pointer_DblClick1 : constant Gdk_Key_Type := 16#FEEF#; GDK_Pointer_DblClick2 : constant Gdk_Key_Type := 16#FEF0#; GDK_Pointer_DblClick3 : constant Gdk_Key_Type := 16#FEF1#; GDK_Pointer_DblClick4 : constant Gdk_Key_Type := 16#FEF2#; GDK_Pointer_DblClick5 : constant Gdk_Key_Type := 16#FEF3#; GDK_Pointer_Drag_Dflt : constant Gdk_Key_Type := 16#FEF4#; GDK_Pointer_Drag1 : constant Gdk_Key_Type := 16#FEF5#; GDK_Pointer_Drag2 : constant Gdk_Key_Type := 16#FEF6#; GDK_Pointer_Drag3 : constant Gdk_Key_Type := 16#FEF7#; GDK_Pointer_Drag4 : constant Gdk_Key_Type := 16#FEF8#; GDK_Pointer_EnableKeys : constant Gdk_Key_Type := 16#FEF9#; GDK_Pointer_Accelerate : constant Gdk_Key_Type := 16#FEFA#; GDK_Pointer_DfltBtnNext : constant Gdk_Key_Type := 16#FEFB#; GDK_Pointer_DfltBtnPrev : constant Gdk_Key_Type := 16#FEFC#; GDK_3270_Duplicate : constant Gdk_Key_Type := 16#FD01#; GDK_3270_FieldMark : constant Gdk_Key_Type := 16#FD02#; GDK_3270_Right2 : constant Gdk_Key_Type := 16#FD03#; GDK_3270_Left2 : constant Gdk_Key_Type := 16#FD04#; GDK_3270_BackTab : constant Gdk_Key_Type := 16#FD05#; GDK_3270_EraseEOF : constant Gdk_Key_Type := 16#FD06#; GDK_3270_EraseInput : constant Gdk_Key_Type := 16#FD07#; GDK_3270_Reset : constant Gdk_Key_Type := 16#FD08#; GDK_3270_Quit : constant Gdk_Key_Type := 16#FD09#; GDK_3270_PA1 : constant Gdk_Key_Type := 16#FD0A#; GDK_3270_PA2 : constant Gdk_Key_Type := 16#FD0B#; GDK_3270_PA3 : constant Gdk_Key_Type := 16#FD0C#; GDK_3270_Test : constant Gdk_Key_Type := 16#FD0D#; GDK_3270_Attn : constant Gdk_Key_Type := 16#FD0E#; GDK_3270_CursorBlink : constant Gdk_Key_Type := 16#FD0F#; GDK_3270_AltCursor : constant Gdk_Key_Type := 16#FD10#; GDK_3270_KeyClick : constant Gdk_Key_Type := 16#FD11#; GDK_3270_Jump : constant Gdk_Key_Type := 16#FD12#; GDK_3270_Ident : constant Gdk_Key_Type := 16#FD13#; GDK_3270_Rule : constant Gdk_Key_Type := 16#FD14#; GDK_3270_Copy : constant Gdk_Key_Type := 16#FD15#; GDK_3270_Play : constant Gdk_Key_Type := 16#FD16#; GDK_3270_Setup : constant Gdk_Key_Type := 16#FD17#; GDK_3270_Record : constant Gdk_Key_Type := 16#FD18#; GDK_3270_ChangeScreen : constant Gdk_Key_Type := 16#FD19#; GDK_3270_DeleteWord : constant Gdk_Key_Type := 16#FD1A#; GDK_3270_ExSelect : constant Gdk_Key_Type := 16#FD1B#; GDK_3270_CursorSelect : constant Gdk_Key_Type := 16#FD1C#; GDK_3270_PrintScreen : constant Gdk_Key_Type := 16#FD1D#; GDK_3270_Enter : constant Gdk_Key_Type := 16#FD1E#; GDK_space : constant Gdk_Key_Type := 16#0020#; GDK_exclam : constant Gdk_Key_Type := 16#0021#; GDK_quotedbl : constant Gdk_Key_Type := 16#0022#; GDK_numbersign : constant Gdk_Key_Type := 16#0023#; GDK_dollar : constant Gdk_Key_Type := 16#0024#; GDK_percent : constant Gdk_Key_Type := 16#0025#; GDK_ampersand : constant Gdk_Key_Type := 16#0026#; GDK_apostrophe : constant Gdk_Key_Type := 16#0027#; GDK_quoteright : constant Gdk_Key_Type := 16#0027#; GDK_parenleft : constant Gdk_Key_Type := 16#0028#; GDK_parenright : constant Gdk_Key_Type := 16#0029#; GDK_asterisk : constant Gdk_Key_Type := 16#002a#; GDK_plus : constant Gdk_Key_Type := 16#002b#; GDK_comma : constant Gdk_Key_Type := 16#002c#; GDK_minus : constant Gdk_Key_Type := 16#002d#; GDK_period : constant Gdk_Key_Type := 16#002e#; GDK_slash : constant Gdk_Key_Type := 16#002f#; GDK_0 : constant Gdk_Key_Type := 16#0030#; GDK_1 : constant Gdk_Key_Type := 16#0031#; GDK_2 : constant Gdk_Key_Type := 16#0032#; GDK_3 : constant Gdk_Key_Type := 16#0033#; GDK_4 : constant Gdk_Key_Type := 16#0034#; GDK_5 : constant Gdk_Key_Type := 16#0035#; GDK_6 : constant Gdk_Key_Type := 16#0036#; GDK_7 : constant Gdk_Key_Type := 16#0037#; GDK_8 : constant Gdk_Key_Type := 16#0038#; GDK_9 : constant Gdk_Key_Type := 16#0039#; GDK_colon : constant Gdk_Key_Type := 16#003a#; GDK_semicolon : constant Gdk_Key_Type := 16#003b#; GDK_less : constant Gdk_Key_Type := 16#003c#; GDK_equal : constant Gdk_Key_Type := 16#003d#; GDK_greater : constant Gdk_Key_Type := 16#003e#; GDK_question : constant Gdk_Key_Type := 16#003f#; GDK_at : constant Gdk_Key_Type := 16#0040#; GDK_A : constant Gdk_Key_Type := 16#0041#; GDK_B : constant Gdk_Key_Type := 16#0042#; GDK_C : constant Gdk_Key_Type := 16#0043#; GDK_D : constant Gdk_Key_Type := 16#0044#; GDK_E : constant Gdk_Key_Type := 16#0045#; GDK_F : constant Gdk_Key_Type := 16#0046#; GDK_G : constant Gdk_Key_Type := 16#0047#; GDK_H : constant Gdk_Key_Type := 16#0048#; GDK_I : constant Gdk_Key_Type := 16#0049#; GDK_J : constant Gdk_Key_Type := 16#004a#; GDK_K : constant Gdk_Key_Type := 16#004b#; GDK_L : constant Gdk_Key_Type := 16#004c#; GDK_M : constant Gdk_Key_Type := 16#004d#; GDK_N : constant Gdk_Key_Type := 16#004e#; GDK_O : constant Gdk_Key_Type := 16#004f#; GDK_P : constant Gdk_Key_Type := 16#0050#; GDK_Q : constant Gdk_Key_Type := 16#0051#; GDK_R : constant Gdk_Key_Type := 16#0052#; GDK_S : constant Gdk_Key_Type := 16#0053#; GDK_T : constant Gdk_Key_Type := 16#0054#; GDK_U : constant Gdk_Key_Type := 16#0055#; GDK_V : constant Gdk_Key_Type := 16#0056#; GDK_W : constant Gdk_Key_Type := 16#0057#; GDK_X : constant Gdk_Key_Type := 16#0058#; GDK_Y : constant Gdk_Key_Type := 16#0059#; GDK_Z : constant Gdk_Key_Type := 16#005a#; GDK_bracketleft : constant Gdk_Key_Type := 16#005b#; GDK_backslash : constant Gdk_Key_Type := 16#005c#; GDK_bracketright : constant Gdk_Key_Type := 16#005d#; GDK_asciicircum : constant Gdk_Key_Type := 16#005e#; GDK_underscore : constant Gdk_Key_Type := 16#005f#; GDK_grave : constant Gdk_Key_Type := 16#0060#; GDK_quoteleft : constant Gdk_Key_Type := 16#0060#; GDK_LC_a : constant Gdk_Key_Type := 16#0061#; GDK_LC_b : constant Gdk_Key_Type := 16#0062#; GDK_LC_c : constant Gdk_Key_Type := 16#0063#; GDK_LC_d : constant Gdk_Key_Type := 16#0064#; GDK_LC_e : constant Gdk_Key_Type := 16#0065#; GDK_LC_f : constant Gdk_Key_Type := 16#0066#; GDK_LC_g : constant Gdk_Key_Type := 16#0067#; GDK_LC_h : constant Gdk_Key_Type := 16#0068#; GDK_LC_i : constant Gdk_Key_Type := 16#0069#; GDK_LC_j : constant Gdk_Key_Type := 16#006a#; GDK_LC_k : constant Gdk_Key_Type := 16#006b#; GDK_LC_l : constant Gdk_Key_Type := 16#006c#; GDK_LC_m : constant Gdk_Key_Type := 16#006d#; GDK_LC_n : constant Gdk_Key_Type := 16#006e#; GDK_LC_o : constant Gdk_Key_Type := 16#006f#; GDK_LC_p : constant Gdk_Key_Type := 16#0070#; GDK_LC_q : constant Gdk_Key_Type := 16#0071#; GDK_LC_r : constant Gdk_Key_Type := 16#0072#; GDK_LC_s : constant Gdk_Key_Type := 16#0073#; GDK_LC_t : constant Gdk_Key_Type := 16#0074#; GDK_LC_u : constant Gdk_Key_Type := 16#0075#; GDK_LC_v : constant Gdk_Key_Type := 16#0076#; GDK_LC_w : constant Gdk_Key_Type := 16#0077#; GDK_LC_x : constant Gdk_Key_Type := 16#0078#; GDK_LC_y : constant Gdk_Key_Type := 16#0079#; GDK_LC_z : constant Gdk_Key_Type := 16#007a#; GDK_braceleft : constant Gdk_Key_Type := 16#007b#; GDK_bar : constant Gdk_Key_Type := 16#007c#; GDK_braceright : constant Gdk_Key_Type := 16#007d#; GDK_asciitilde : constant Gdk_Key_Type := 16#007e#; GDK_nobreakspace : constant Gdk_Key_Type := 16#00a0#; GDK_exclamdown : constant Gdk_Key_Type := 16#00a1#; GDK_cent : constant Gdk_Key_Type := 16#00a2#; GDK_sterling : constant Gdk_Key_Type := 16#00a3#; GDK_currency : constant Gdk_Key_Type := 16#00a4#; GDK_yen : constant Gdk_Key_Type := 16#00a5#; GDK_brokenbar : constant Gdk_Key_Type := 16#00a6#; GDK_section : constant Gdk_Key_Type := 16#00a7#; GDK_diaeresis : constant Gdk_Key_Type := 16#00a8#; GDK_copyright : constant Gdk_Key_Type := 16#00a9#; GDK_ordfeminine : constant Gdk_Key_Type := 16#00aa#; GDK_guillemotleft : constant Gdk_Key_Type := 16#00ab#; GDK_notsign : constant Gdk_Key_Type := 16#00ac#; GDK_hyphen : constant Gdk_Key_Type := 16#00ad#; GDK_registered : constant Gdk_Key_Type := 16#00ae#; GDK_macron : constant Gdk_Key_Type := 16#00af#; GDK_degree : constant Gdk_Key_Type := 16#00b0#; GDK_plusminus : constant Gdk_Key_Type := 16#00b1#; GDK_twosuperior : constant Gdk_Key_Type := 16#00b2#; GDK_threesuperior : constant Gdk_Key_Type := 16#00b3#; GDK_acute : constant Gdk_Key_Type := 16#00b4#; GDK_mu : constant Gdk_Key_Type := 16#00b5#; GDK_paragraph : constant Gdk_Key_Type := 16#00b6#; GDK_periodcentered : constant Gdk_Key_Type := 16#00b7#; GDK_cedilla : constant Gdk_Key_Type := 16#00b8#; GDK_onesuperior : constant Gdk_Key_Type := 16#00b9#; GDK_masculine : constant Gdk_Key_Type := 16#00ba#; GDK_guillemotright : constant Gdk_Key_Type := 16#00bb#; GDK_onequarter : constant Gdk_Key_Type := 16#00bc#; GDK_onehalf : constant Gdk_Key_Type := 16#00bd#; GDK_threequarters : constant Gdk_Key_Type := 16#00be#; GDK_questiondown : constant Gdk_Key_Type := 16#00bf#; GDK_Agrave : constant Gdk_Key_Type := 16#00c0#; GDK_Aacute : constant Gdk_Key_Type := 16#00c1#; GDK_Acircumflex : constant Gdk_Key_Type := 16#00c2#; GDK_Atilde : constant Gdk_Key_Type := 16#00c3#; GDK_Adiaeresis : constant Gdk_Key_Type := 16#00c4#; GDK_Aring : constant Gdk_Key_Type := 16#00c5#; GDK_AE : constant Gdk_Key_Type := 16#00c6#; GDK_Ccedilla : constant Gdk_Key_Type := 16#00c7#; GDK_Egrave : constant Gdk_Key_Type := 16#00c8#; GDK_Eacute : constant Gdk_Key_Type := 16#00c9#; GDK_Ecircumflex : constant Gdk_Key_Type := 16#00ca#; GDK_Ediaeresis : constant Gdk_Key_Type := 16#00cb#; GDK_Igrave : constant Gdk_Key_Type := 16#00cc#; GDK_Iacute : constant Gdk_Key_Type := 16#00cd#; GDK_Icircumflex : constant Gdk_Key_Type := 16#00ce#; GDK_Idiaeresis : constant Gdk_Key_Type := 16#00cf#; GDK_ETH : constant Gdk_Key_Type := 16#00d0#; GDK_Ntilde : constant Gdk_Key_Type := 16#00d1#; GDK_Ograve : constant Gdk_Key_Type := 16#00d2#; GDK_Oacute : constant Gdk_Key_Type := 16#00d3#; GDK_Ocircumflex : constant Gdk_Key_Type := 16#00d4#; GDK_Otilde : constant Gdk_Key_Type := 16#00d5#; GDK_Odiaeresis : constant Gdk_Key_Type := 16#00d6#; GDK_multiply : constant Gdk_Key_Type := 16#00d7#; GDK_Ooblique : constant Gdk_Key_Type := 16#00d8#; GDK_Ugrave : constant Gdk_Key_Type := 16#00d9#; GDK_Uacute : constant Gdk_Key_Type := 16#00da#; GDK_Ucircumflex : constant Gdk_Key_Type := 16#00db#; GDK_Udiaeresis : constant Gdk_Key_Type := 16#00dc#; GDK_Yacute : constant Gdk_Key_Type := 16#00dd#; GDK_THORN : constant Gdk_Key_Type := 16#00de#; GDK_ssharp : constant Gdk_Key_Type := 16#00df#; GDK_LC_agrave : constant Gdk_Key_Type := 16#00e0#; GDK_LC_aacute : constant Gdk_Key_Type := 16#00e1#; GDK_LC_acircumflex : constant Gdk_Key_Type := 16#00e2#; GDK_LC_atilde : constant Gdk_Key_Type := 16#00e3#; GDK_LC_adiaeresis : constant Gdk_Key_Type := 16#00e4#; GDK_LC_aring : constant Gdk_Key_Type := 16#00e5#; GDK_LC_ae : constant Gdk_Key_Type := 16#00e6#; GDK_LC_ccedilla : constant Gdk_Key_Type := 16#00e7#; GDK_LC_egrave : constant Gdk_Key_Type := 16#00e8#; GDK_LC_eacute : constant Gdk_Key_Type := 16#00e9#; GDK_LC_ecircumflex : constant Gdk_Key_Type := 16#00ea#; GDK_LC_ediaeresis : constant Gdk_Key_Type := 16#00eb#; GDK_LC_igrave : constant Gdk_Key_Type := 16#00ec#; GDK_LC_iacute : constant Gdk_Key_Type := 16#00ed#; GDK_LC_icircumflex : constant Gdk_Key_Type := 16#00ee#; GDK_LC_idiaeresis : constant Gdk_Key_Type := 16#00ef#; GDK_LC_eth : constant Gdk_Key_Type := 16#00f0#; GDK_LC_ntilde : constant Gdk_Key_Type := 16#00f1#; GDK_LC_ograve : constant Gdk_Key_Type := 16#00f2#; GDK_LC_oacute : constant Gdk_Key_Type := 16#00f3#; GDK_LC_ocircumflex : constant Gdk_Key_Type := 16#00f4#; GDK_LC_otilde : constant Gdk_Key_Type := 16#00f5#; GDK_LC_odiaeresis : constant Gdk_Key_Type := 16#00f6#; GDK_division : constant Gdk_Key_Type := 16#00f7#; GDK_oslash : constant Gdk_Key_Type := 16#00f8#; GDK_LC_ugrave : constant Gdk_Key_Type := 16#00f9#; GDK_LC_uacute : constant Gdk_Key_Type := 16#00fa#; GDK_LC_ucircumflex : constant Gdk_Key_Type := 16#00fb#; GDK_LC_udiaeresis : constant Gdk_Key_Type := 16#00fc#; GDK_LC_yacute : constant Gdk_Key_Type := 16#00fd#; GDK_LC_thorn : constant Gdk_Key_Type := 16#00fe#; GDK_ydiaeresis : constant Gdk_Key_Type := 16#00ff#; GDK_Aogonek : constant Gdk_Key_Type := 16#01a1#; GDK_breve : constant Gdk_Key_Type := 16#01a2#; GDK_Lstroke : constant Gdk_Key_Type := 16#01a3#; GDK_Lcaron : constant Gdk_Key_Type := 16#01a5#; GDK_Sacute : constant Gdk_Key_Type := 16#01a6#; GDK_Scaron : constant Gdk_Key_Type := 16#01a9#; GDK_Scedilla : constant Gdk_Key_Type := 16#01aa#; GDK_Tcaron : constant Gdk_Key_Type := 16#01ab#; GDK_Zacute : constant Gdk_Key_Type := 16#01ac#; GDK_Zcaron : constant Gdk_Key_Type := 16#01ae#; GDK_Zabovedot : constant Gdk_Key_Type := 16#01af#; GDK_LC_aogonek : constant Gdk_Key_Type := 16#01b1#; GDK_ogonek : constant Gdk_Key_Type := 16#01b2#; GDK_LC_lstroke : constant Gdk_Key_Type := 16#01b3#; GDK_LC_lcaron : constant Gdk_Key_Type := 16#01b5#; GDK_LC_sacute : constant Gdk_Key_Type := 16#01b6#; GDK_caron : constant Gdk_Key_Type := 16#01b7#; GDK_LC_scaron : constant Gdk_Key_Type := 16#01b9#; GDK_LC_scedilla : constant Gdk_Key_Type := 16#01ba#; GDK_LC_tcaron : constant Gdk_Key_Type := 16#01bb#; GDK_LC_zacute : constant Gdk_Key_Type := 16#01bc#; GDK_doubleacute : constant Gdk_Key_Type := 16#01bd#; GDK_LC_zcaron : constant Gdk_Key_Type := 16#01be#; GDK_LC_zabovedot : constant Gdk_Key_Type := 16#01bf#; GDK_Racute : constant Gdk_Key_Type := 16#01c0#; GDK_Abreve : constant Gdk_Key_Type := 16#01c3#; GDK_Lacute : constant Gdk_Key_Type := 16#01c5#; GDK_Cacute : constant Gdk_Key_Type := 16#01c6#; GDK_Ccaron : constant Gdk_Key_Type := 16#01c8#; GDK_Eogonek : constant Gdk_Key_Type := 16#01ca#; GDK_Ecaron : constant Gdk_Key_Type := 16#01cc#; GDK_Dcaron : constant Gdk_Key_Type := 16#01cf#; GDK_Dstroke : constant Gdk_Key_Type := 16#01d0#; GDK_Nacute : constant Gdk_Key_Type := 16#01d1#; GDK_Ncaron : constant Gdk_Key_Type := 16#01d2#; GDK_Odoubleacute : constant Gdk_Key_Type := 16#01d5#; GDK_Rcaron : constant Gdk_Key_Type := 16#01d8#; GDK_Uring : constant Gdk_Key_Type := 16#01d9#; GDK_Udoubleacute : constant Gdk_Key_Type := 16#01db#; GDK_Tcedilla : constant Gdk_Key_Type := 16#01de#; GDK_LC_racute : constant Gdk_Key_Type := 16#01e0#; GDK_LC_abreve : constant Gdk_Key_Type := 16#01e3#; GDK_LC_lacute : constant Gdk_Key_Type := 16#01e5#; GDK_LC_cacute : constant Gdk_Key_Type := 16#01e6#; GDK_LC_ccaron : constant Gdk_Key_Type := 16#01e8#; GDK_LC_eogonek : constant Gdk_Key_Type := 16#01ea#; GDK_LC_ecaron : constant Gdk_Key_Type := 16#01ec#; GDK_LC_dcaron : constant Gdk_Key_Type := 16#01ef#; GDK_LC_dstroke : constant Gdk_Key_Type := 16#01f0#; GDK_LC_nacute : constant Gdk_Key_Type := 16#01f1#; GDK_LC_ncaron : constant Gdk_Key_Type := 16#01f2#; GDK_LC_odoubleacute : constant Gdk_Key_Type := 16#01f5#; GDK_LC_udoubleacute : constant Gdk_Key_Type := 16#01fb#; GDK_LC_rcaron : constant Gdk_Key_Type := 16#01f8#; GDK_LC_uring : constant Gdk_Key_Type := 16#01f9#; GDK_LC_tcedilla : constant Gdk_Key_Type := 16#01fe#; GDK_abovedot : constant Gdk_Key_Type := 16#01ff#; GDK_Hstroke : constant Gdk_Key_Type := 16#02a1#; GDK_Hcircumflex : constant Gdk_Key_Type := 16#02a6#; GDK_Iabovedot : constant Gdk_Key_Type := 16#02a9#; GDK_Gbreve : constant Gdk_Key_Type := 16#02ab#; GDK_Jcircumflex : constant Gdk_Key_Type := 16#02ac#; GDK_LC_hstroke : constant Gdk_Key_Type := 16#02b1#; GDK_LC_hcircumflex : constant Gdk_Key_Type := 16#02b6#; GDK_idotless : constant Gdk_Key_Type := 16#02b9#; GDK_LC_gbreve : constant Gdk_Key_Type := 16#02bb#; GDK_LC_jcircumflex : constant Gdk_Key_Type := 16#02bc#; GDK_Cabovedot : constant Gdk_Key_Type := 16#02c5#; GDK_Ccircumflex : constant Gdk_Key_Type := 16#02c6#; GDK_Gabovedot : constant Gdk_Key_Type := 16#02d5#; GDK_Gcircumflex : constant Gdk_Key_Type := 16#02d8#; GDK_Ubreve : constant Gdk_Key_Type := 16#02dd#; GDK_Scircumflex : constant Gdk_Key_Type := 16#02de#; GDK_LC_cabovedot : constant Gdk_Key_Type := 16#02e5#; GDK_LC_ccircumflex : constant Gdk_Key_Type := 16#02e6#; GDK_LC_gabovedot : constant Gdk_Key_Type := 16#02f5#; GDK_LC_gcircumflex : constant Gdk_Key_Type := 16#02f8#; GDK_LC_ubreve : constant Gdk_Key_Type := 16#02fd#; GDK_LC_scircumflex : constant Gdk_Key_Type := 16#02fe#; GDK_kra : constant Gdk_Key_Type := 16#03a2#; GDK_kappa : constant Gdk_Key_Type := 16#03a2#; GDK_Rcedilla : constant Gdk_Key_Type := 16#03a3#; GDK_Itilde : constant Gdk_Key_Type := 16#03a5#; GDK_Lcedilla : constant Gdk_Key_Type := 16#03a6#; GDK_Emacron : constant Gdk_Key_Type := 16#03aa#; GDK_Gcedilla : constant Gdk_Key_Type := 16#03ab#; GDK_Tslash : constant Gdk_Key_Type := 16#03ac#; GDK_LC_rcedilla : constant Gdk_Key_Type := 16#03b3#; GDK_LC_itilde : constant Gdk_Key_Type := 16#03b5#; GDK_LC_lcedilla : constant Gdk_Key_Type := 16#03b6#; GDK_LC_emacron : constant Gdk_Key_Type := 16#03ba#; GDK_LC_gcedilla : constant Gdk_Key_Type := 16#03bb#; GDK_LC_tslash : constant Gdk_Key_Type := 16#03bc#; GDK_ENG : constant Gdk_Key_Type := 16#03bd#; GDK_LC_eng : constant Gdk_Key_Type := 16#03bf#; GDK_Amacron : constant Gdk_Key_Type := 16#03c0#; GDK_Iogonek : constant Gdk_Key_Type := 16#03c7#; GDK_Eabovedot : constant Gdk_Key_Type := 16#03cc#; GDK_Imacron : constant Gdk_Key_Type := 16#03cf#; GDK_Ncedilla : constant Gdk_Key_Type := 16#03d1#; GDK_Omacron : constant Gdk_Key_Type := 16#03d2#; GDK_Kcedilla : constant Gdk_Key_Type := 16#03d3#; GDK_Uogonek : constant Gdk_Key_Type := 16#03d9#; GDK_Utilde : constant Gdk_Key_Type := 16#03dd#; GDK_Umacron : constant Gdk_Key_Type := 16#03de#; GDK_LC_amacron : constant Gdk_Key_Type := 16#03e0#; GDK_LC_iogonek : constant Gdk_Key_Type := 16#03e7#; GDK_LC_eabovedot : constant Gdk_Key_Type := 16#03ec#; GDK_LC_imacron : constant Gdk_Key_Type := 16#03ef#; GDK_LC_ncedilla : constant Gdk_Key_Type := 16#03f1#; GDK_LC_omacron : constant Gdk_Key_Type := 16#03f2#; GDK_LC_kcedilla : constant Gdk_Key_Type := 16#03f3#; GDK_LC_uogonek : constant Gdk_Key_Type := 16#03f9#; GDK_LC_utilde : constant Gdk_Key_Type := 16#03fd#; GDK_LC_umacron : constant Gdk_Key_Type := 16#03fe#; GDK_overline : constant Gdk_Key_Type := 16#047e#; GDK_kana_fullstop : constant Gdk_Key_Type := 16#04a1#; GDK_kana_openingbracket : constant Gdk_Key_Type := 16#04a2#; GDK_kana_closingbracket : constant Gdk_Key_Type := 16#04a3#; GDK_kana_comma : constant Gdk_Key_Type := 16#04a4#; GDK_kana_conjunctive : constant Gdk_Key_Type := 16#04a5#; GDK_kana_middledot : constant Gdk_Key_Type := 16#04a5#; GDK_kana_WO : constant Gdk_Key_Type := 16#04a6#; GDK_kana_LC_a : constant Gdk_Key_Type := 16#04a7#; GDK_kana_LC_i : constant Gdk_Key_Type := 16#04a8#; GDK_kana_LC_u : constant Gdk_Key_Type := 16#04a9#; GDK_kana_LC_e : constant Gdk_Key_Type := 16#04aa#; GDK_kana_LC_o : constant Gdk_Key_Type := 16#04ab#; GDK_kana_LC_ya : constant Gdk_Key_Type := 16#04ac#; GDK_kana_LC_yu : constant Gdk_Key_Type := 16#04ad#; GDK_kana_LC_yo : constant Gdk_Key_Type := 16#04ae#; GDK_kana_LC_tsu : constant Gdk_Key_Type := 16#04af#; GDK_kana_LC_tu : constant Gdk_Key_Type := 16#04af#; GDK_prolongedsound : constant Gdk_Key_Type := 16#04b0#; GDK_kana_a : constant Gdk_Key_Type := 16#04b1#; GDK_kana_i : constant Gdk_Key_Type := 16#04b2#; GDK_kana_u : constant Gdk_Key_Type := 16#04b3#; GDK_kana_e : constant Gdk_Key_Type := 16#04b4#; GDK_kana_o : constant Gdk_Key_Type := 16#04b5#; GDK_kana_KA : constant Gdk_Key_Type := 16#04b6#; GDK_kana_KI : constant Gdk_Key_Type := 16#04b7#; GDK_kana_KU : constant Gdk_Key_Type := 16#04b8#; GDK_kana_KE : constant Gdk_Key_Type := 16#04b9#; GDK_kana_KO : constant Gdk_Key_Type := 16#04ba#; GDK_kana_SA : constant Gdk_Key_Type := 16#04bb#; GDK_kana_SHI : constant Gdk_Key_Type := 16#04bc#; GDK_kana_SU : constant Gdk_Key_Type := 16#04bd#; GDK_kana_SE : constant Gdk_Key_Type := 16#04be#; GDK_kana_SO : constant Gdk_Key_Type := 16#04bf#; GDK_kana_TA : constant Gdk_Key_Type := 16#04c0#; GDK_kana_CHI : constant Gdk_Key_Type := 16#04c1#; GDK_kana_TI : constant Gdk_Key_Type := 16#04c1#; GDK_kana_tsu : constant Gdk_Key_Type := 16#04c2#; GDK_kana_tu : constant Gdk_Key_Type := 16#04c2#; GDK_kana_TE : constant Gdk_Key_Type := 16#04c3#; GDK_kana_TO : constant Gdk_Key_Type := 16#04c4#; GDK_kana_NA : constant Gdk_Key_Type := 16#04c5#; GDK_kana_NI : constant Gdk_Key_Type := 16#04c6#; GDK_kana_NU : constant Gdk_Key_Type := 16#04c7#; GDK_kana_NE : constant Gdk_Key_Type := 16#04c8#; GDK_kana_NO : constant Gdk_Key_Type := 16#04c9#; GDK_kana_HA : constant Gdk_Key_Type := 16#04ca#; GDK_kana_HI : constant Gdk_Key_Type := 16#04cb#; GDK_kana_FU : constant Gdk_Key_Type := 16#04cc#; GDK_kana_HU : constant Gdk_Key_Type := 16#04cc#; GDK_kana_HE : constant Gdk_Key_Type := 16#04cd#; GDK_kana_HO : constant Gdk_Key_Type := 16#04ce#; GDK_kana_MA : constant Gdk_Key_Type := 16#04cf#; GDK_kana_MI : constant Gdk_Key_Type := 16#04d0#; GDK_kana_MU : constant Gdk_Key_Type := 16#04d1#; GDK_kana_ME : constant Gdk_Key_Type := 16#04d2#; GDK_kana_MO : constant Gdk_Key_Type := 16#04d3#; GDK_kana_ya : constant Gdk_Key_Type := 16#04d4#; GDK_kana_yu : constant Gdk_Key_Type := 16#04d5#; GDK_kana_yo : constant Gdk_Key_Type := 16#04d6#; GDK_kana_RA : constant Gdk_Key_Type := 16#04d7#; GDK_kana_RI : constant Gdk_Key_Type := 16#04d8#; GDK_kana_RU : constant Gdk_Key_Type := 16#04d9#; GDK_kana_RE : constant Gdk_Key_Type := 16#04da#; GDK_kana_RO : constant Gdk_Key_Type := 16#04db#; GDK_kana_WA : constant Gdk_Key_Type := 16#04dc#; GDK_kana_N : constant Gdk_Key_Type := 16#04dd#; GDK_voicedsound : constant Gdk_Key_Type := 16#04de#; GDK_semivoicedsound : constant Gdk_Key_Type := 16#04df#; GDK_kana_switch : constant Gdk_Key_Type := 16#FF7E#; GDK_Arabic_comma : constant Gdk_Key_Type := 16#05ac#; GDK_Arabic_semicolon : constant Gdk_Key_Type := 16#05bb#; GDK_Arabic_Question_Mark : constant Gdk_Key_Type := 16#05bf#; GDK_Arabic_hamza : constant Gdk_Key_Type := 16#05c1#; GDK_Arabic_maddaonalef : constant Gdk_Key_Type := 16#05c2#; GDK_Arabic_hamzaonalef : constant Gdk_Key_Type := 16#05c3#; GDK_Arabic_hamzaonwaw : constant Gdk_Key_Type := 16#05c4#; GDK_Arabic_hamzaunderalef : constant Gdk_Key_Type := 16#05c5#; GDK_Arabic_hamzaonyeh : constant Gdk_Key_Type := 16#05c6#; GDK_Arabic_alef : constant Gdk_Key_Type := 16#05c7#; GDK_Arabic_beh : constant Gdk_Key_Type := 16#05c8#; GDK_Arabic_tehmarbuta : constant Gdk_Key_Type := 16#05c9#; GDK_Arabic_teh : constant Gdk_Key_Type := 16#05ca#; GDK_Arabic_theh : constant Gdk_Key_Type := 16#05cb#; GDK_Arabic_jeem : constant Gdk_Key_Type := 16#05cc#; GDK_Arabic_hah : constant Gdk_Key_Type := 16#05cd#; GDK_Arabic_khah : constant Gdk_Key_Type := 16#05ce#; GDK_Arabic_dal : constant Gdk_Key_Type := 16#05cf#; GDK_Arabic_thal : constant Gdk_Key_Type := 16#05d0#; GDK_Arabic_ra : constant Gdk_Key_Type := 16#05d1#; GDK_Arabic_zain : constant Gdk_Key_Type := 16#05d2#; GDK_Arabic_seen : constant Gdk_Key_Type := 16#05d3#; GDK_Arabic_sheen : constant Gdk_Key_Type := 16#05d4#; GDK_Arabic_sad : constant Gdk_Key_Type := 16#05d5#; GDK_Arabic_dad : constant Gdk_Key_Type := 16#05d6#; GDK_Arabic_tah : constant Gdk_Key_Type := 16#05d7#; GDK_Arabic_zah : constant Gdk_Key_Type := 16#05d8#; GDK_Arabic_ain : constant Gdk_Key_Type := 16#05d9#; GDK_Arabic_ghain : constant Gdk_Key_Type := 16#05da#; GDK_Arabic_tatweel : constant Gdk_Key_Type := 16#05e0#; GDK_Arabic_feh : constant Gdk_Key_Type := 16#05e1#; GDK_Arabic_qaf : constant Gdk_Key_Type := 16#05e2#; GDK_Arabic_kaf : constant Gdk_Key_Type := 16#05e3#; GDK_Arabic_lam : constant Gdk_Key_Type := 16#05e4#; GDK_Arabic_meem : constant Gdk_Key_Type := 16#05e5#; GDK_Arabic_noon : constant Gdk_Key_Type := 16#05e6#; GDK_Arabic_ha : constant Gdk_Key_Type := 16#05e7#; GDK_Arabic_heh : constant Gdk_Key_Type := 16#05e7#; GDK_Arabic_waw : constant Gdk_Key_Type := 16#05e8#; GDK_Arabic_alefmaksura : constant Gdk_Key_Type := 16#05e9#; GDK_Arabic_yeh : constant Gdk_Key_Type := 16#05ea#; GDK_Arabic_fathatan : constant Gdk_Key_Type := 16#05eb#; GDK_Arabic_dammatan : constant Gdk_Key_Type := 16#05ec#; GDK_Arabic_kasratan : constant Gdk_Key_Type := 16#05ed#; GDK_Arabic_fatha : constant Gdk_Key_Type := 16#05ee#; GDK_Arabic_damma : constant Gdk_Key_Type := 16#05ef#; GDK_Arabic_kasra : constant Gdk_Key_Type := 16#05f0#; GDK_Arabic_shadda : constant Gdk_Key_Type := 16#05f1#; GDK_Arabic_sukun : constant Gdk_Key_Type := 16#05f2#; GDK_Arabic_switch : constant Gdk_Key_Type := 16#FF7E#; GDK_Serbian_LC_dje : constant Gdk_Key_Type := 16#06a1#; GDK_Macedonia_LC_gje : constant Gdk_Key_Type := 16#06a2#; GDK_Cyrillic_LC_io : constant Gdk_Key_Type := 16#06a3#; GDK_Ukrainian_LC_ie : constant Gdk_Key_Type := 16#06a4#; GDK_Ukranian_LC_je : constant Gdk_Key_Type := 16#06a4#; GDK_Macedonia_LC_dse : constant Gdk_Key_Type := 16#06a5#; GDK_Ukrainian_LC_i : constant Gdk_Key_Type := 16#06a6#; GDK_Ukranian_LC_i : constant Gdk_Key_Type := 16#06a6#; GDK_Ukrainian_LC_yi : constant Gdk_Key_Type := 16#06a7#; GDK_Ukranian_LC_yi : constant Gdk_Key_Type := 16#06a7#; GDK_Cyrillic_LC_je : constant Gdk_Key_Type := 16#06a8#; GDK_Serbian_LC_je : constant Gdk_Key_Type := 16#06a8#; GDK_Cyrillic_LC_lje : constant Gdk_Key_Type := 16#06a9#; GDK_Serbian_LC_lje : constant Gdk_Key_Type := 16#06a9#; GDK_Cyrillic_LC_nje : constant Gdk_Key_Type := 16#06aa#; GDK_Serbian_LC_nje : constant Gdk_Key_Type := 16#06aa#; GDK_Serbian_LC_tshe : constant Gdk_Key_Type := 16#06ab#; GDK_Macedonia_LC_kje : constant Gdk_Key_Type := 16#06ac#; GDK_Byelorussian_LC_shortu : constant Gdk_Key_Type := 16#06ae#; GDK_Cyrillic_LC_dzhe : constant Gdk_Key_Type := 16#06af#; GDK_Serbian_LC_dze : constant Gdk_Key_Type := 16#06af#; GDK_numerosign : constant Gdk_Key_Type := 16#06b0#; GDK_Serbian_dje : constant Gdk_Key_Type := 16#06b1#; GDK_Macedonia_gje : constant Gdk_Key_Type := 16#06b2#; GDK_Cyrillic_io : constant Gdk_Key_Type := 16#06b3#; GDK_Ukrainian_ie : constant Gdk_Key_Type := 16#06b4#; GDK_Ukranian_je : constant Gdk_Key_Type := 16#06b4#; GDK_Macedonia_dse : constant Gdk_Key_Type := 16#06b5#; GDK_Ukrainian_i : constant Gdk_Key_Type := 16#06b6#; GDK_Ukranian_i : constant Gdk_Key_Type := 16#06b6#; GDK_Ukrainian_yi : constant Gdk_Key_Type := 16#06b7#; GDK_Ukranian_yi : constant Gdk_Key_Type := 16#06b7#; GDK_Cyrillic_je : constant Gdk_Key_Type := 16#06b8#; GDK_Serbian_je : constant Gdk_Key_Type := 16#06b8#; GDK_Cyrillic_lje : constant Gdk_Key_Type := 16#06b9#; GDK_Serbian_lje : constant Gdk_Key_Type := 16#06b9#; GDK_Cyrillic_nje : constant Gdk_Key_Type := 16#06ba#; GDK_Serbian_nje : constant Gdk_Key_Type := 16#06ba#; GDK_Serbian_tshe : constant Gdk_Key_Type := 16#06bb#; GDK_Macedonia_kje : constant Gdk_Key_Type := 16#06bc#; GDK_Byelorussian_shortu : constant Gdk_Key_Type := 16#06be#; GDK_Cyrillic_dzhe : constant Gdk_Key_Type := 16#06bf#; GDK_Serbian_dze : constant Gdk_Key_Type := 16#06bf#; GDK_Cyrillic_LC_yu : constant Gdk_Key_Type := 16#06c0#; GDK_Cyrillic_LC_a : constant Gdk_Key_Type := 16#06c1#; GDK_Cyrillic_LC_be : constant Gdk_Key_Type := 16#06c2#; GDK_Cyrillic_LC_tse : constant Gdk_Key_Type := 16#06c3#; GDK_Cyrillic_LC_de : constant Gdk_Key_Type := 16#06c4#; GDK_Cyrillic_LC_ie : constant Gdk_Key_Type := 16#06c5#; GDK_Cyrillic_LC_ef : constant Gdk_Key_Type := 16#06c6#; GDK_Cyrillic_LC_ghe : constant Gdk_Key_Type := 16#06c7#; GDK_Cyrillic_LC_ha : constant Gdk_Key_Type := 16#06c8#; GDK_Cyrillic_LC_i : constant Gdk_Key_Type := 16#06c9#; GDK_Cyrillic_LC_shorti : constant Gdk_Key_Type := 16#06ca#; GDK_Cyrillic_LC_ka : constant Gdk_Key_Type := 16#06cb#; GDK_Cyrillic_LC_el : constant Gdk_Key_Type := 16#06cc#; GDK_Cyrillic_LC_em : constant Gdk_Key_Type := 16#06cd#; GDK_Cyrillic_LC_en : constant Gdk_Key_Type := 16#06ce#; GDK_Cyrillic_LC_o : constant Gdk_Key_Type := 16#06cf#; GDK_Cyrillic_LC_pe : constant Gdk_Key_Type := 16#06d0#; GDK_Cyrillic_LC_ya : constant Gdk_Key_Type := 16#06d1#; GDK_Cyrillic_LC_er : constant Gdk_Key_Type := 16#06d2#; GDK_Cyrillic_LC_es : constant Gdk_Key_Type := 16#06d3#; GDK_Cyrillic_LC_te : constant Gdk_Key_Type := 16#06d4#; GDK_Cyrillic_LC_u : constant Gdk_Key_Type := 16#06d5#; GDK_Cyrillic_LC_zhe : constant Gdk_Key_Type := 16#06d6#; GDK_Cyrillic_LC_ve : constant Gdk_Key_Type := 16#06d7#; GDK_Cyrillic_LC_softsign : constant Gdk_Key_Type := 16#06d8#; GDK_Cyrillic_LC_yeru : constant Gdk_Key_Type := 16#06d9#; GDK_Cyrillic_LC_ze : constant Gdk_Key_Type := 16#06da#; GDK_Cyrillic_LC_sha : constant Gdk_Key_Type := 16#06db#; GDK_Cyrillic_LC_e : constant Gdk_Key_Type := 16#06dc#; GDK_Cyrillic_LC_shcha : constant Gdk_Key_Type := 16#06dd#; GDK_Cyrillic_LC_che : constant Gdk_Key_Type := 16#06de#; GDK_Cyrillic_LC_hardsign : constant Gdk_Key_Type := 16#06df#; GDK_Cyrillic_yu : constant Gdk_Key_Type := 16#06e0#; GDK_Cyrillic_a : constant Gdk_Key_Type := 16#06e1#; GDK_Cyrillic_be : constant Gdk_Key_Type := 16#06e2#; GDK_Cyrillic_tse : constant Gdk_Key_Type := 16#06e3#; GDK_Cyrillic_de : constant Gdk_Key_Type := 16#06e4#; GDK_Cyrillic_ie : constant Gdk_Key_Type := 16#06e5#; GDK_Cyrillic_ef : constant Gdk_Key_Type := 16#06e6#; GDK_Cyrillic_ghe : constant Gdk_Key_Type := 16#06e7#; GDK_Cyrillic_ha : constant Gdk_Key_Type := 16#06e8#; GDK_Cyrillic_i : constant Gdk_Key_Type := 16#06e9#; GDK_Cyrillic_shorti : constant Gdk_Key_Type := 16#06ea#; GDK_Cyrillic_ka : constant Gdk_Key_Type := 16#06eb#; GDK_Cyrillic_el : constant Gdk_Key_Type := 16#06ec#; GDK_Cyrillic_em : constant Gdk_Key_Type := 16#06ed#; GDK_Cyrillic_en : constant Gdk_Key_Type := 16#06ee#; GDK_Cyrillic_o : constant Gdk_Key_Type := 16#06ef#; GDK_Cyrillic_pe : constant Gdk_Key_Type := 16#06f0#; GDK_Cyrillic_ya : constant Gdk_Key_Type := 16#06f1#; GDK_Cyrillic_er : constant Gdk_Key_Type := 16#06f2#; GDK_Cyrillic_es : constant Gdk_Key_Type := 16#06f3#; GDK_Cyrillic_te : constant Gdk_Key_Type := 16#06f4#; GDK_Cyrillic_u : constant Gdk_Key_Type := 16#06f5#; GDK_Cyrillic_zhe : constant Gdk_Key_Type := 16#06f6#; GDK_Cyrillic_ve : constant Gdk_Key_Type := 16#06f7#; GDK_Cyrillic_softsign : constant Gdk_Key_Type := 16#06f8#; GDK_Cyrillic_yeru : constant Gdk_Key_Type := 16#06f9#; GDK_Cyrillic_ze : constant Gdk_Key_Type := 16#06fa#; GDK_Cyrillic_sha : constant Gdk_Key_Type := 16#06fb#; GDK_Cyrillic_e : constant Gdk_Key_Type := 16#06fc#; GDK_Cyrillic_shcha : constant Gdk_Key_Type := 16#06fd#; GDK_Cyrillic_che : constant Gdk_Key_Type := 16#06fe#; GDK_Cyrillic_hardsign : constant Gdk_Key_Type := 16#06ff#; GDK_Greek_ALPHAaccent : constant Gdk_Key_Type := 16#07a1#; GDK_Greek_EPSILONaccent : constant Gdk_Key_Type := 16#07a2#; GDK_Greek_ETAaccent : constant Gdk_Key_Type := 16#07a3#; GDK_Greek_IOTAaccent : constant Gdk_Key_Type := 16#07a4#; GDK_Greek_IOTAdiaeresis : constant Gdk_Key_Type := 16#07a5#; GDK_Greek_OMICRONaccent : constant Gdk_Key_Type := 16#07a7#; GDK_Greek_UPSILONaccent : constant Gdk_Key_Type := 16#07a8#; GDK_Greek_UPSILONdieresis : constant Gdk_Key_Type := 16#07a9#; GDK_Greek_OMEGAaccent : constant Gdk_Key_Type := 16#07ab#; GDK_Greek_accentdieresis : constant Gdk_Key_Type := 16#07ae#; GDK_Greek_horizbar : constant Gdk_Key_Type := 16#07af#; GDK_Greek_LC_alphaaccent : constant Gdk_Key_Type := 16#07b1#; GDK_Greek_LC_epsilonaccent : constant Gdk_Key_Type := 16#07b2#; GDK_Greek_LC_etaaccent : constant Gdk_Key_Type := 16#07b3#; GDK_Greek_LC_iotaaccent : constant Gdk_Key_Type := 16#07b4#; GDK_Greek_iotadieresis : constant Gdk_Key_Type := 16#07b5#; GDK_Greek_iotaaccentdieresis : constant Gdk_Key_Type := 16#07b6#; GDK_Greek_LC_omicronaccent : constant Gdk_Key_Type := 16#07b7#; GDK_Greek_LC_upsilonaccent : constant Gdk_Key_Type := 16#07b8#; GDK_Greek_LC_upsilondieresis : constant Gdk_Key_Type := 16#07b9#; GDK_Greek_upsilonaccentdieresis : constant Gdk_Key_Type := 16#07ba#; GDK_Greek_LC_omegaaccent : constant Gdk_Key_Type := 16#07bb#; GDK_Greek_ALPHA : constant Gdk_Key_Type := 16#07c1#; GDK_Greek_BETA : constant Gdk_Key_Type := 16#07c2#; GDK_Greek_GAMMA : constant Gdk_Key_Type := 16#07c3#; GDK_Greek_DELTA : constant Gdk_Key_Type := 16#07c4#; GDK_Greek_EPSILON : constant Gdk_Key_Type := 16#07c5#; GDK_Greek_ZETA : constant Gdk_Key_Type := 16#07c6#; GDK_Greek_ETA : constant Gdk_Key_Type := 16#07c7#; GDK_Greek_THETA : constant Gdk_Key_Type := 16#07c8#; GDK_Greek_IOTA : constant Gdk_Key_Type := 16#07c9#; GDK_Greek_KAPPA : constant Gdk_Key_Type := 16#07ca#; GDK_Greek_LAMDA : constant Gdk_Key_Type := 16#07cb#; GDK_Greek_LAMBDA : constant Gdk_Key_Type := 16#07cb#; GDK_Greek_MU : constant Gdk_Key_Type := 16#07cc#; GDK_Greek_NU : constant Gdk_Key_Type := 16#07cd#; GDK_Greek_XI : constant Gdk_Key_Type := 16#07ce#; GDK_Greek_OMICRON : constant Gdk_Key_Type := 16#07cf#; GDK_Greek_PI : constant Gdk_Key_Type := 16#07d0#; GDK_Greek_RHO : constant Gdk_Key_Type := 16#07d1#; GDK_Greek_SIGMA : constant Gdk_Key_Type := 16#07d2#; GDK_Greek_TAU : constant Gdk_Key_Type := 16#07d4#; GDK_Greek_UPSILON : constant Gdk_Key_Type := 16#07d5#; GDK_Greek_PHI : constant Gdk_Key_Type := 16#07d6#; GDK_Greek_CHI : constant Gdk_Key_Type := 16#07d7#; GDK_Greek_PSI : constant Gdk_Key_Type := 16#07d8#; GDK_Greek_OMEGA : constant Gdk_Key_Type := 16#07d9#; GDK_Greek_LC_alpha : constant Gdk_Key_Type := 16#07e1#; GDK_Greek_LC_beta : constant Gdk_Key_Type := 16#07e2#; GDK_Greek_LC_gamma : constant Gdk_Key_Type := 16#07e3#; GDK_Greek_LC_delta : constant Gdk_Key_Type := 16#07e4#; GDK_Greek_LC_epsilon : constant Gdk_Key_Type := 16#07e5#; GDK_Greek_LC_zeta : constant Gdk_Key_Type := 16#07e6#; GDK_Greek_LC_eta : constant Gdk_Key_Type := 16#07e7#; GDK_Greek_LC_theta : constant Gdk_Key_Type := 16#07e8#; GDK_Greek_LC_iota : constant Gdk_Key_Type := 16#07e9#; GDK_Greek_LC_kappa : constant Gdk_Key_Type := 16#07ea#; GDK_Greek_LC_lamda : constant Gdk_Key_Type := 16#07eb#; GDK_Greek_LC_lambda : constant Gdk_Key_Type := 16#07eb#; GDK_Greek_LC_mu : constant Gdk_Key_Type := 16#07ec#; GDK_Greek_LC_nu : constant Gdk_Key_Type := 16#07ed#; GDK_Greek_LC_xi : constant Gdk_Key_Type := 16#07ee#; GDK_Greek_LC_omicron : constant Gdk_Key_Type := 16#07ef#; GDK_Greek_LC_pi : constant Gdk_Key_Type := 16#07f0#; GDK_Greek_LC_rho : constant Gdk_Key_Type := 16#07f1#; GDK_Greek_LC_sigma : constant Gdk_Key_Type := 16#07f2#; GDK_Greek_finalsmallsigma : constant Gdk_Key_Type := 16#07f3#; GDK_Greek_LC_tau : constant Gdk_Key_Type := 16#07f4#; GDK_Greek_LC_upsilon : constant Gdk_Key_Type := 16#07f5#; GDK_Greek_LC_phi : constant Gdk_Key_Type := 16#07f6#; GDK_Greek_LC_chi : constant Gdk_Key_Type := 16#07f7#; GDK_Greek_LC_psi : constant Gdk_Key_Type := 16#07f8#; GDK_Greek_LC_omega : constant Gdk_Key_Type := 16#07f9#; GDK_Greek_switch : constant Gdk_Key_Type := 16#FF7E#; GDK_leftradical : constant Gdk_Key_Type := 16#08a1#; GDK_topleftradical : constant Gdk_Key_Type := 16#08a2#; GDK_horizconnector : constant Gdk_Key_Type := 16#08a3#; GDK_topintegral : constant Gdk_Key_Type := 16#08a4#; GDK_botintegral : constant Gdk_Key_Type := 16#08a5#; GDK_vertconnector : constant Gdk_Key_Type := 16#08a6#; GDK_topleftsqbracket : constant Gdk_Key_Type := 16#08a7#; GDK_botleftsqbracket : constant Gdk_Key_Type := 16#08a8#; GDK_toprightsqbracket : constant Gdk_Key_Type := 16#08a9#; GDK_botrightsqbracket : constant Gdk_Key_Type := 16#08aa#; GDK_topleftparens : constant Gdk_Key_Type := 16#08ab#; GDK_botleftparens : constant Gdk_Key_Type := 16#08ac#; GDK_toprightparens : constant Gdk_Key_Type := 16#08ad#; GDK_botrightparens : constant Gdk_Key_Type := 16#08ae#; GDK_leftmiddlecurlybrace : constant Gdk_Key_Type := 16#08af#; GDK_rightmiddlecurlybrace : constant Gdk_Key_Type := 16#08b0#; GDK_topleftsummation : constant Gdk_Key_Type := 16#08b1#; GDK_botleftsummation : constant Gdk_Key_Type := 16#08b2#; GDK_topvertsummationconnector : constant Gdk_Key_Type := 16#08b3#; GDK_botvertsummationconnector : constant Gdk_Key_Type := 16#08b4#; GDK_toprightsummation : constant Gdk_Key_Type := 16#08b5#; GDK_botrightsummation : constant Gdk_Key_Type := 16#08b6#; GDK_rightmiddlesummation : constant Gdk_Key_Type := 16#08b7#; GDK_lessthanequal : constant Gdk_Key_Type := 16#08bc#; GDK_notequal : constant Gdk_Key_Type := 16#08bd#; GDK_greaterthanequal : constant Gdk_Key_Type := 16#08be#; GDK_integral : constant Gdk_Key_Type := 16#08bf#; GDK_therefore : constant Gdk_Key_Type := 16#08c0#; GDK_variation : constant Gdk_Key_Type := 16#08c1#; GDK_infinity : constant Gdk_Key_Type := 16#08c2#; GDK_nabla : constant Gdk_Key_Type := 16#08c5#; GDK_approximate : constant Gdk_Key_Type := 16#08c8#; GDK_similarequal : constant Gdk_Key_Type := 16#08c9#; GDK_ifonlyif : constant Gdk_Key_Type := 16#08cd#; GDK_implies : constant Gdk_Key_Type := 16#08ce#; GDK_identical : constant Gdk_Key_Type := 16#08cf#; GDK_radical : constant Gdk_Key_Type := 16#08d6#; GDK_includedin : constant Gdk_Key_Type := 16#08da#; GDK_includes : constant Gdk_Key_Type := 16#08db#; GDK_intersection : constant Gdk_Key_Type := 16#08dc#; GDK_union : constant Gdk_Key_Type := 16#08dd#; GDK_logicaland : constant Gdk_Key_Type := 16#08de#; GDK_logicalor : constant Gdk_Key_Type := 16#08df#; GDK_partialderivative : constant Gdk_Key_Type := 16#08ef#; GDK_function : constant Gdk_Key_Type := 16#08f6#; GDK_leftarrow : constant Gdk_Key_Type := 16#08fb#; GDK_uparrow : constant Gdk_Key_Type := 16#08fc#; GDK_rightarrow : constant Gdk_Key_Type := 16#08fd#; GDK_downarrow : constant Gdk_Key_Type := 16#08fe#; GDK_blank : constant Gdk_Key_Type := 16#09df#; GDK_soliddiamond : constant Gdk_Key_Type := 16#09e0#; GDK_checkerboard : constant Gdk_Key_Type := 16#09e1#; GDK_ht : constant Gdk_Key_Type := 16#09e2#; GDK_ff : constant Gdk_Key_Type := 16#09e3#; GDK_cr : constant Gdk_Key_Type := 16#09e4#; GDK_lf : constant Gdk_Key_Type := 16#09e5#; GDK_nl : constant Gdk_Key_Type := 16#09e8#; GDK_vt : constant Gdk_Key_Type := 16#09e9#; GDK_lowrightcorner : constant Gdk_Key_Type := 16#09ea#; GDK_uprightcorner : constant Gdk_Key_Type := 16#09eb#; GDK_upleftcorner : constant Gdk_Key_Type := 16#09ec#; GDK_lowleftcorner : constant Gdk_Key_Type := 16#09ed#; GDK_crossinglines : constant Gdk_Key_Type := 16#09ee#; GDK_horizlinescan1 : constant Gdk_Key_Type := 16#09ef#; GDK_horizlinescan3 : constant Gdk_Key_Type := 16#09f0#; GDK_horizlinescan5 : constant Gdk_Key_Type := 16#09f1#; GDK_horizlinescan7 : constant Gdk_Key_Type := 16#09f2#; GDK_horizlinescan9 : constant Gdk_Key_Type := 16#09f3#; GDK_leftt : constant Gdk_Key_Type := 16#09f4#; GDK_rightt : constant Gdk_Key_Type := 16#09f5#; GDK_bott : constant Gdk_Key_Type := 16#09f6#; GDK_topt : constant Gdk_Key_Type := 16#09f7#; GDK_vertbar : constant Gdk_Key_Type := 16#09f8#; GDK_emspace : constant Gdk_Key_Type := 16#0aa1#; GDK_enspace : constant Gdk_Key_Type := 16#0aa2#; GDK_em3space : constant Gdk_Key_Type := 16#0aa3#; GDK_em4space : constant Gdk_Key_Type := 16#0aa4#; GDK_digitspace : constant Gdk_Key_Type := 16#0aa5#; GDK_punctspace : constant Gdk_Key_Type := 16#0aa6#; GDK_thinspace : constant Gdk_Key_Type := 16#0aa7#; GDK_hairspace : constant Gdk_Key_Type := 16#0aa8#; GDK_emdash : constant Gdk_Key_Type := 16#0aa9#; GDK_endash : constant Gdk_Key_Type := 16#0aaa#; GDK_signifblank : constant Gdk_Key_Type := 16#0aac#; GDK_ellipsis : constant Gdk_Key_Type := 16#0aae#; GDK_doubbaselinedot : constant Gdk_Key_Type := 16#0aaf#; GDK_onethird : constant Gdk_Key_Type := 16#0ab0#; GDK_twothirds : constant Gdk_Key_Type := 16#0ab1#; GDK_onefifth : constant Gdk_Key_Type := 16#0ab2#; GDK_twofifths : constant Gdk_Key_Type := 16#0ab3#; GDK_threefifths : constant Gdk_Key_Type := 16#0ab4#; GDK_fourfifths : constant Gdk_Key_Type := 16#0ab5#; GDK_onesixth : constant Gdk_Key_Type := 16#0ab6#; GDK_fivesixths : constant Gdk_Key_Type := 16#0ab7#; GDK_careof : constant Gdk_Key_Type := 16#0ab8#; GDK_figdash : constant Gdk_Key_Type := 16#0abb#; GDK_leftanglebracket : constant Gdk_Key_Type := 16#0abc#; GDK_decimalpoint : constant Gdk_Key_Type := 16#0abd#; GDK_rightanglebracket : constant Gdk_Key_Type := 16#0abe#; GDK_marker : constant Gdk_Key_Type := 16#0abf#; GDK_oneeighth : constant Gdk_Key_Type := 16#0ac3#; GDK_threeeighths : constant Gdk_Key_Type := 16#0ac4#; GDK_fiveeighths : constant Gdk_Key_Type := 16#0ac5#; GDK_seveneighths : constant Gdk_Key_Type := 16#0ac6#; GDK_trademark : constant Gdk_Key_Type := 16#0ac9#; GDK_signaturemark : constant Gdk_Key_Type := 16#0aca#; GDK_trademarkincircle : constant Gdk_Key_Type := 16#0acb#; GDK_leftopentriangle : constant Gdk_Key_Type := 16#0acc#; GDK_rightopentriangle : constant Gdk_Key_Type := 16#0acd#; GDK_emopencircle : constant Gdk_Key_Type := 16#0ace#; GDK_emopenrectangle : constant Gdk_Key_Type := 16#0acf#; GDK_leftsinglequotemark : constant Gdk_Key_Type := 16#0ad0#; GDK_rightsinglequotemark : constant Gdk_Key_Type := 16#0ad1#; GDK_leftdoublequotemark : constant Gdk_Key_Type := 16#0ad2#; GDK_rightdoublequotemark : constant Gdk_Key_Type := 16#0ad3#; GDK_prescription : constant Gdk_Key_Type := 16#0ad4#; GDK_minutes : constant Gdk_Key_Type := 16#0ad6#; GDK_seconds : constant Gdk_Key_Type := 16#0ad7#; GDK_latincross : constant Gdk_Key_Type := 16#0ad9#; GDK_hexagram : constant Gdk_Key_Type := 16#0ada#; GDK_filledrectbullet : constant Gdk_Key_Type := 16#0adb#; GDK_filledlefttribullet : constant Gdk_Key_Type := 16#0adc#; GDK_filledrighttribullet : constant Gdk_Key_Type := 16#0add#; GDK_emfilledcircle : constant Gdk_Key_Type := 16#0ade#; GDK_emfilledrect : constant Gdk_Key_Type := 16#0adf#; GDK_enopencircbullet : constant Gdk_Key_Type := 16#0ae0#; GDK_enopensquarebullet : constant Gdk_Key_Type := 16#0ae1#; GDK_openrectbullet : constant Gdk_Key_Type := 16#0ae2#; GDK_opentribulletup : constant Gdk_Key_Type := 16#0ae3#; GDK_opentribulletdown : constant Gdk_Key_Type := 16#0ae4#; GDK_openstar : constant Gdk_Key_Type := 16#0ae5#; GDK_enfilledcircbullet : constant Gdk_Key_Type := 16#0ae6#; GDK_enfilledsqbullet : constant Gdk_Key_Type := 16#0ae7#; GDK_filledtribulletup : constant Gdk_Key_Type := 16#0ae8#; GDK_filledtribulletdown : constant Gdk_Key_Type := 16#0ae9#; GDK_leftpointer : constant Gdk_Key_Type := 16#0aea#; GDK_rightpointer : constant Gdk_Key_Type := 16#0aeb#; GDK_club : constant Gdk_Key_Type := 16#0aec#; GDK_diamond : constant Gdk_Key_Type := 16#0aed#; GDK_heart : constant Gdk_Key_Type := 16#0aee#; GDK_maltesecross : constant Gdk_Key_Type := 16#0af0#; GDK_dagger : constant Gdk_Key_Type := 16#0af1#; GDK_doubledagger : constant Gdk_Key_Type := 16#0af2#; GDK_checkmark : constant Gdk_Key_Type := 16#0af3#; GDK_ballotcross : constant Gdk_Key_Type := 16#0af4#; GDK_musicalsharp : constant Gdk_Key_Type := 16#0af5#; GDK_musicalflat : constant Gdk_Key_Type := 16#0af6#; GDK_malesymbol : constant Gdk_Key_Type := 16#0af7#; GDK_femalesymbol : constant Gdk_Key_Type := 16#0af8#; GDK_telephone : constant Gdk_Key_Type := 16#0af9#; GDK_telephonerecorder : constant Gdk_Key_Type := 16#0afa#; GDK_phonographcopyright : constant Gdk_Key_Type := 16#0afb#; GDK_caret : constant Gdk_Key_Type := 16#0afc#; GDK_singlelowquotemark : constant Gdk_Key_Type := 16#0afd#; GDK_doublelowquotemark : constant Gdk_Key_Type := 16#0afe#; GDK_cursor : constant Gdk_Key_Type := 16#0aff#; GDK_leftcaret : constant Gdk_Key_Type := 16#0ba3#; GDK_rightcaret : constant Gdk_Key_Type := 16#0ba6#; GDK_downcaret : constant Gdk_Key_Type := 16#0ba8#; GDK_upcaret : constant Gdk_Key_Type := 16#0ba9#; GDK_overbar : constant Gdk_Key_Type := 16#0bc0#; GDK_downtack : constant Gdk_Key_Type := 16#0bc2#; GDK_upshoe : constant Gdk_Key_Type := 16#0bc3#; GDK_downstile : constant Gdk_Key_Type := 16#0bc4#; GDK_underbar : constant Gdk_Key_Type := 16#0bc6#; GDK_jot : constant Gdk_Key_Type := 16#0bca#; GDK_quad : constant Gdk_Key_Type := 16#0bcc#; GDK_uptack : constant Gdk_Key_Type := 16#0bce#; GDK_circle : constant Gdk_Key_Type := 16#0bcf#; GDK_upstile : constant Gdk_Key_Type := 16#0bd3#; GDK_downshoe : constant Gdk_Key_Type := 16#0bd6#; GDK_rightshoe : constant Gdk_Key_Type := 16#0bd8#; GDK_leftshoe : constant Gdk_Key_Type := 16#0bda#; GDK_lefttack : constant Gdk_Key_Type := 16#0bdc#; GDK_righttack : constant Gdk_Key_Type := 16#0bfc#; GDK_hebrew_doublelowline : constant Gdk_Key_Type := 16#0cdf#; GDK_hebrew_aleph : constant Gdk_Key_Type := 16#0ce0#; GDK_hebrew_bet : constant Gdk_Key_Type := 16#0ce1#; GDK_hebrew_beth : constant Gdk_Key_Type := 16#0ce1#; GDK_hebrew_gimel : constant Gdk_Key_Type := 16#0ce2#; GDK_hebrew_gimmel : constant Gdk_Key_Type := 16#0ce2#; GDK_hebrew_dalet : constant Gdk_Key_Type := 16#0ce3#; GDK_hebrew_daleth : constant Gdk_Key_Type := 16#0ce3#; GDK_hebrew_he : constant Gdk_Key_Type := 16#0ce4#; GDK_hebrew_waw : constant Gdk_Key_Type := 16#0ce5#; GDK_hebrew_zain : constant Gdk_Key_Type := 16#0ce6#; GDK_hebrew_zayin : constant Gdk_Key_Type := 16#0ce6#; GDK_hebrew_chet : constant Gdk_Key_Type := 16#0ce7#; GDK_hebrew_het : constant Gdk_Key_Type := 16#0ce7#; GDK_hebrew_tet : constant Gdk_Key_Type := 16#0ce8#; GDK_hebrew_teth : constant Gdk_Key_Type := 16#0ce8#; GDK_hebrew_yod : constant Gdk_Key_Type := 16#0ce9#; GDK_hebrew_finalkaph : constant Gdk_Key_Type := 16#0cea#; GDK_hebrew_kaph : constant Gdk_Key_Type := 16#0ceb#; GDK_hebrew_lamed : constant Gdk_Key_Type := 16#0cec#; GDK_hebrew_finalmem : constant Gdk_Key_Type := 16#0ced#; GDK_hebrew_mem : constant Gdk_Key_Type := 16#0cee#; GDK_hebrew_finalnun : constant Gdk_Key_Type := 16#0cef#; GDK_hebrew_nun : constant Gdk_Key_Type := 16#0cf0#; GDK_hebrew_samech : constant Gdk_Key_Type := 16#0cf1#; GDK_hebrew_samekh : constant Gdk_Key_Type := 16#0cf1#; GDK_hebrew_ayin : constant Gdk_Key_Type := 16#0cf2#; GDK_hebrew_finalpe : constant Gdk_Key_Type := 16#0cf3#; GDK_hebrew_pe : constant Gdk_Key_Type := 16#0cf4#; GDK_hebrew_finalzade : constant Gdk_Key_Type := 16#0cf5#; GDK_hebrew_finalzadi : constant Gdk_Key_Type := 16#0cf5#; GDK_hebrew_zade : constant Gdk_Key_Type := 16#0cf6#; GDK_hebrew_zadi : constant Gdk_Key_Type := 16#0cf6#; GDK_hebrew_qoph : constant Gdk_Key_Type := 16#0cf7#; GDK_hebrew_kuf : constant Gdk_Key_Type := 16#0cf7#; GDK_hebrew_resh : constant Gdk_Key_Type := 16#0cf8#; GDK_hebrew_shin : constant Gdk_Key_Type := 16#0cf9#; GDK_hebrew_taw : constant Gdk_Key_Type := 16#0cfa#; GDK_hebrew_taf : constant Gdk_Key_Type := 16#0cfa#; GDK_Hebrew_switch : constant Gdk_Key_Type := 16#FF7E#; GDK_Thai_kokai : constant Gdk_Key_Type := 16#0da1#; GDK_Thai_khokhai : constant Gdk_Key_Type := 16#0da2#; GDK_Thai_khokhuat : constant Gdk_Key_Type := 16#0da3#; GDK_Thai_khokhwai : constant Gdk_Key_Type := 16#0da4#; GDK_Thai_khokhon : constant Gdk_Key_Type := 16#0da5#; GDK_Thai_khorakhang : constant Gdk_Key_Type := 16#0da6#; GDK_Thai_ngongu : constant Gdk_Key_Type := 16#0da7#; GDK_Thai_chochan : constant Gdk_Key_Type := 16#0da8#; GDK_Thai_choching : constant Gdk_Key_Type := 16#0da9#; GDK_Thai_chochang : constant Gdk_Key_Type := 16#0daa#; GDK_Thai_soso : constant Gdk_Key_Type := 16#0dab#; GDK_Thai_chochoe : constant Gdk_Key_Type := 16#0dac#; GDK_Thai_yoying : constant Gdk_Key_Type := 16#0dad#; GDK_Thai_dochada : constant Gdk_Key_Type := 16#0dae#; GDK_Thai_topatak : constant Gdk_Key_Type := 16#0daf#; GDK_Thai_thothan : constant Gdk_Key_Type := 16#0db0#; GDK_Thai_thonangmontho : constant Gdk_Key_Type := 16#0db1#; GDK_Thai_thophuthao : constant Gdk_Key_Type := 16#0db2#; GDK_Thai_nonen : constant Gdk_Key_Type := 16#0db3#; GDK_Thai_dodek : constant Gdk_Key_Type := 16#0db4#; GDK_Thai_totao : constant Gdk_Key_Type := 16#0db5#; GDK_Thai_thothung : constant Gdk_Key_Type := 16#0db6#; GDK_Thai_thothahan : constant Gdk_Key_Type := 16#0db7#; GDK_Thai_thothong : constant Gdk_Key_Type := 16#0db8#; GDK_Thai_nonu : constant Gdk_Key_Type := 16#0db9#; GDK_Thai_bobaimai : constant Gdk_Key_Type := 16#0dba#; GDK_Thai_popla : constant Gdk_Key_Type := 16#0dbb#; GDK_Thai_phophung : constant Gdk_Key_Type := 16#0dbc#; GDK_Thai_fofa : constant Gdk_Key_Type := 16#0dbd#; GDK_Thai_phophan : constant Gdk_Key_Type := 16#0dbe#; GDK_Thai_fofan : constant Gdk_Key_Type := 16#0dbf#; GDK_Thai_phosamphao : constant Gdk_Key_Type := 16#0dc0#; GDK_Thai_moma : constant Gdk_Key_Type := 16#0dc1#; GDK_Thai_yoyak : constant Gdk_Key_Type := 16#0dc2#; GDK_Thai_rorua : constant Gdk_Key_Type := 16#0dc3#; GDK_Thai_ru : constant Gdk_Key_Type := 16#0dc4#; GDK_Thai_loling : constant Gdk_Key_Type := 16#0dc5#; GDK_Thai_lu : constant Gdk_Key_Type := 16#0dc6#; GDK_Thai_wowaen : constant Gdk_Key_Type := 16#0dc7#; GDK_Thai_sosala : constant Gdk_Key_Type := 16#0dc8#; GDK_Thai_sorusi : constant Gdk_Key_Type := 16#0dc9#; GDK_Thai_sosua : constant Gdk_Key_Type := 16#0dca#; GDK_Thai_hohip : constant Gdk_Key_Type := 16#0dcb#; GDK_Thai_lochula : constant Gdk_Key_Type := 16#0dcc#; GDK_Thai_oang : constant Gdk_Key_Type := 16#0dcd#; GDK_Thai_honokhuk : constant Gdk_Key_Type := 16#0dce#; GDK_Thai_paiyannoi : constant Gdk_Key_Type := 16#0dcf#; GDK_Thai_saraa : constant Gdk_Key_Type := 16#0dd0#; GDK_Thai_maihanakat : constant Gdk_Key_Type := 16#0dd1#; GDK_Thai_saraaa : constant Gdk_Key_Type := 16#0dd2#; GDK_Thai_saraam : constant Gdk_Key_Type := 16#0dd3#; GDK_Thai_sarai : constant Gdk_Key_Type := 16#0dd4#; GDK_Thai_saraii : constant Gdk_Key_Type := 16#0dd5#; GDK_Thai_saraue : constant Gdk_Key_Type := 16#0dd6#; GDK_Thai_sarauee : constant Gdk_Key_Type := 16#0dd7#; GDK_Thai_sarau : constant Gdk_Key_Type := 16#0dd8#; GDK_Thai_sarauu : constant Gdk_Key_Type := 16#0dd9#; GDK_Thai_phinthu : constant Gdk_Key_Type := 16#0dda#; GDK_Thai_Maihanakat_Maitho : constant Gdk_Key_Type := 16#0dde#; GDK_Thai_baht : constant Gdk_Key_Type := 16#0ddf#; GDK_Thai_sarae : constant Gdk_Key_Type := 16#0de0#; GDK_Thai_saraae : constant Gdk_Key_Type := 16#0de1#; GDK_Thai_sarao : constant Gdk_Key_Type := 16#0de2#; GDK_Thai_saraaimaimuan : constant Gdk_Key_Type := 16#0de3#; GDK_Thai_saraaimaimalai : constant Gdk_Key_Type := 16#0de4#; GDK_Thai_lakkhangyao : constant Gdk_Key_Type := 16#0de5#; GDK_Thai_maiyamok : constant Gdk_Key_Type := 16#0de6#; GDK_Thai_maitaikhu : constant Gdk_Key_Type := 16#0de7#; GDK_Thai_maiek : constant Gdk_Key_Type := 16#0de8#; GDK_Thai_maitho : constant Gdk_Key_Type := 16#0de9#; GDK_Thai_maitri : constant Gdk_Key_Type := 16#0dea#; GDK_Thai_maichattawa : constant Gdk_Key_Type := 16#0deb#; GDK_Thai_thanthakhat : constant Gdk_Key_Type := 16#0dec#; GDK_Thai_nikhahit : constant Gdk_Key_Type := 16#0ded#; GDK_Thai_leksun : constant Gdk_Key_Type := 16#0df0#; GDK_Thai_leknung : constant Gdk_Key_Type := 16#0df1#; GDK_Thai_leksong : constant Gdk_Key_Type := 16#0df2#; GDK_Thai_leksam : constant Gdk_Key_Type := 16#0df3#; GDK_Thai_leksi : constant Gdk_Key_Type := 16#0df4#; GDK_Thai_lekha : constant Gdk_Key_Type := 16#0df5#; GDK_Thai_lekhok : constant Gdk_Key_Type := 16#0df6#; GDK_Thai_lekchet : constant Gdk_Key_Type := 16#0df7#; GDK_Thai_lekpaet : constant Gdk_Key_Type := 16#0df8#; GDK_Thai_lekkao : constant Gdk_Key_Type := 16#0df9#; GDK_Hangul : constant Gdk_Key_Type := 16#ff31#; GDK_Hangul_Start : constant Gdk_Key_Type := 16#ff32#; GDK_Hangul_End : constant Gdk_Key_Type := 16#ff33#; GDK_Hangul_Hanja : constant Gdk_Key_Type := 16#ff34#; GDK_Hangul_Jamo : constant Gdk_Key_Type := 16#ff35#; GDK_Hangul_Romaja : constant Gdk_Key_Type := 16#ff36#; GDK_Hangul_Codeinput : constant Gdk_Key_Type := 16#ff37#; GDK_Hangul_Jeonja : constant Gdk_Key_Type := 16#ff38#; GDK_Hangul_Banja : constant Gdk_Key_Type := 16#ff39#; GDK_Hangul_PreHanja : constant Gdk_Key_Type := 16#ff3a#; GDK_Hangul_PostHanja : constant Gdk_Key_Type := 16#ff3b#; GDK_Hangul_SingleCandidate : constant Gdk_Key_Type := 16#ff3c#; GDK_Hangul_MultipleCandidate : constant Gdk_Key_Type := 16#ff3d#; GDK_Hangul_PreviousCandidate : constant Gdk_Key_Type := 16#ff3e#; GDK_Hangul_Special : constant Gdk_Key_Type := 16#ff3f#; GDK_Hangul_switch : constant Gdk_Key_Type := 16#FF7E#; GDK_Hangul_Kiyeog : constant Gdk_Key_Type := 16#0ea1#; GDK_Hangul_SsangKiyeog : constant Gdk_Key_Type := 16#0ea2#; GDK_Hangul_KiyeogSios : constant Gdk_Key_Type := 16#0ea3#; GDK_Hangul_Nieun : constant Gdk_Key_Type := 16#0ea4#; GDK_Hangul_NieunJieuj : constant Gdk_Key_Type := 16#0ea5#; GDK_Hangul_NieunHieuh : constant Gdk_Key_Type := 16#0ea6#; GDK_Hangul_Dikeud : constant Gdk_Key_Type := 16#0ea7#; GDK_Hangul_SsangDikeud : constant Gdk_Key_Type := 16#0ea8#; GDK_Hangul_Rieul : constant Gdk_Key_Type := 16#0ea9#; GDK_Hangul_RieulKiyeog : constant Gdk_Key_Type := 16#0eaa#; GDK_Hangul_RieulMieum : constant Gdk_Key_Type := 16#0eab#; GDK_Hangul_RieulPieub : constant Gdk_Key_Type := 16#0eac#; GDK_Hangul_RieulSios : constant Gdk_Key_Type := 16#0ead#; GDK_Hangul_RieulTieut : constant Gdk_Key_Type := 16#0eae#; GDK_Hangul_RieulPhieuf : constant Gdk_Key_Type := 16#0eaf#; GDK_Hangul_RieulHieuh : constant Gdk_Key_Type := 16#0eb0#; GDK_Hangul_Mieum : constant Gdk_Key_Type := 16#0eb1#; GDK_Hangul_Pieub : constant Gdk_Key_Type := 16#0eb2#; GDK_Hangul_SsangPieub : constant Gdk_Key_Type := 16#0eb3#; GDK_Hangul_PieubSios : constant Gdk_Key_Type := 16#0eb4#; GDK_Hangul_Sios : constant Gdk_Key_Type := 16#0eb5#; GDK_Hangul_SsangSios : constant Gdk_Key_Type := 16#0eb6#; GDK_Hangul_Ieung : constant Gdk_Key_Type := 16#0eb7#; GDK_Hangul_Jieuj : constant Gdk_Key_Type := 16#0eb8#; GDK_Hangul_SsangJieuj : constant Gdk_Key_Type := 16#0eb9#; GDK_Hangul_Cieuc : constant Gdk_Key_Type := 16#0eba#; GDK_Hangul_Khieuq : constant Gdk_Key_Type := 16#0ebb#; GDK_Hangul_Tieut : constant Gdk_Key_Type := 16#0ebc#; GDK_Hangul_Phieuf : constant Gdk_Key_Type := 16#0ebd#; GDK_Hangul_Hieuh : constant Gdk_Key_Type := 16#0ebe#; GDK_Hangul_A : constant Gdk_Key_Type := 16#0ebf#; GDK_Hangul_AE : constant Gdk_Key_Type := 16#0ec0#; GDK_Hangul_YA : constant Gdk_Key_Type := 16#0ec1#; GDK_Hangul_YAE : constant Gdk_Key_Type := 16#0ec2#; GDK_Hangul_EO : constant Gdk_Key_Type := 16#0ec3#; GDK_Hangul_E : constant Gdk_Key_Type := 16#0ec4#; GDK_Hangul_YEO : constant Gdk_Key_Type := 16#0ec5#; GDK_Hangul_YE : constant Gdk_Key_Type := 16#0ec6#; GDK_Hangul_O : constant Gdk_Key_Type := 16#0ec7#; GDK_Hangul_WA : constant Gdk_Key_Type := 16#0ec8#; GDK_Hangul_WAE : constant Gdk_Key_Type := 16#0ec9#; GDK_Hangul_OE : constant Gdk_Key_Type := 16#0eca#; GDK_Hangul_YO : constant Gdk_Key_Type := 16#0ecb#; GDK_Hangul_U : constant Gdk_Key_Type := 16#0ecc#; GDK_Hangul_WEO : constant Gdk_Key_Type := 16#0ecd#; GDK_Hangul_WE : constant Gdk_Key_Type := 16#0ece#; GDK_Hangul_WI : constant Gdk_Key_Type := 16#0ecf#; GDK_Hangul_YU : constant Gdk_Key_Type := 16#0ed0#; GDK_Hangul_EU : constant Gdk_Key_Type := 16#0ed1#; GDK_Hangul_YI : constant Gdk_Key_Type := 16#0ed2#; GDK_Hangul_I : constant Gdk_Key_Type := 16#0ed3#; GDK_Hangul_J_Kiyeog : constant Gdk_Key_Type := 16#0ed4#; GDK_Hangul_J_SsangKiyeog : constant Gdk_Key_Type := 16#0ed5#; GDK_Hangul_J_KiyeogSios : constant Gdk_Key_Type := 16#0ed6#; GDK_Hangul_J_Nieun : constant Gdk_Key_Type := 16#0ed7#; GDK_Hangul_J_NieunJieuj : constant Gdk_Key_Type := 16#0ed8#; GDK_Hangul_J_NieunHieuh : constant Gdk_Key_Type := 16#0ed9#; GDK_Hangul_J_Dikeud : constant Gdk_Key_Type := 16#0eda#; GDK_Hangul_J_Rieul : constant Gdk_Key_Type := 16#0edb#; GDK_Hangul_J_RieulKiyeog : constant Gdk_Key_Type := 16#0edc#; GDK_Hangul_J_RieulMieum : constant Gdk_Key_Type := 16#0edd#; GDK_Hangul_J_RieulPieub : constant Gdk_Key_Type := 16#0ede#; GDK_Hangul_J_RieulSios : constant Gdk_Key_Type := 16#0edf#; GDK_Hangul_J_RieulTieut : constant Gdk_Key_Type := 16#0ee0#; GDK_Hangul_J_RieulPhieuf : constant Gdk_Key_Type := 16#0ee1#; GDK_Hangul_J_RieulHieuh : constant Gdk_Key_Type := 16#0ee2#; GDK_Hangul_J_Mieum : constant Gdk_Key_Type := 16#0ee3#; GDK_Hangul_J_Pieub : constant Gdk_Key_Type := 16#0ee4#; GDK_Hangul_J_PieubSios : constant Gdk_Key_Type := 16#0ee5#; GDK_Hangul_J_Sios : constant Gdk_Key_Type := 16#0ee6#; GDK_Hangul_J_SsangSios : constant Gdk_Key_Type := 16#0ee7#; GDK_Hangul_J_Ieung : constant Gdk_Key_Type := 16#0ee8#; GDK_Hangul_J_Jieuj : constant Gdk_Key_Type := 16#0ee9#; GDK_Hangul_J_Cieuc : constant Gdk_Key_Type := 16#0eea#; GDK_Hangul_J_Khieuq : constant Gdk_Key_Type := 16#0eeb#; GDK_Hangul_J_Tieut : constant Gdk_Key_Type := 16#0eec#; GDK_Hangul_J_Phieuf : constant Gdk_Key_Type := 16#0eed#; GDK_Hangul_J_Hieuh : constant Gdk_Key_Type := 16#0eee#; GDK_Hangul_RieulYeorinHieuh : constant Gdk_Key_Type := 16#0eef#; GDK_Hangul_SunkyeongeumMieum : constant Gdk_Key_Type := 16#0ef0#; GDK_Hangul_SunkyeongeumPieub : constant Gdk_Key_Type := 16#0ef1#; GDK_Hangul_PanSios : constant Gdk_Key_Type := 16#0ef2#; GDK_Hangul_KkogjiDalrinIeung : constant Gdk_Key_Type := 16#0ef3#; GDK_Hangul_SunkyeongeumPhieuf : constant Gdk_Key_Type := 16#0ef4#; GDK_Hangul_YeorinHieuh : constant Gdk_Key_Type := 16#0ef5#; GDK_Hangul_AraeA : constant Gdk_Key_Type := 16#0ef6#; GDK_Hangul_AraeAE : constant Gdk_Key_Type := 16#0ef7#; GDK_Hangul_J_PanSios : constant Gdk_Key_Type := 16#0ef8#; GDK_Hangul_J_KkogjiDalrinIeung : constant Gdk_Key_Type := 16#0ef9#; GDK_Hangul_J_YeorinHieuh : constant Gdk_Key_Type := 16#0efa#; GDK_Korean_Won : constant Gdk_Key_Type := 16#0eff#; end Gdk.Types.Keysyms; gtkada-24.0.0/src/gdk-types.ads000066400000000000000000000327731446021174000162320ustar00rootroot00000000000000------------------------------------------------------------------------------ -- GtkAda - Ada95 binding for Gtk+/Gnome -- -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 1998-2018, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ -- Gdk, the low-level API with Glib; use Glib; with Glib.Generic_Properties; use Glib.Generic_Properties; pragma Elaborate_All (Glib.Generic_Properties); package Gdk.Types is Current_Time : constant Guint32 := 0; -- Represents the current time in timestamps stored in events type Gdk_Point is record X : Gint; Y : Gint; end record; pragma Convention (C, Gdk_Point); type Gdk_Points_Array is array (Positive range <>) of Gdk_Point; pragma Convention (C, Gdk_Points_Array); type Gdk_Segment is record X1 : Gint; Y1 : Gint; X2 : Gint; Y2 : Gint; end record; pragma Convention (C, Gdk_Segment); type Gdk_Segments_Array is array (Positive range <>) of Gdk_Segment; pragma Convention (C, Gdk_Segments_Array); -- See at the end of the package a list of all the types that -- have not been "bound". type Gdk_Atom is new C_Proxy; -- This type represents a property of the X-server, that can be -- manipulated through functions in Gdk.Property. They have an associated -- name, that can be printed, as well as a value whose type may vary. -- See the program xlsatoms on any X-Window machine to list all the atoms -- known by the Xserver. Gdk_None : constant Gdk_Atom := null; -- No atom constant. type Gdk_Atom_Array is array (Natural range <>) of Gdk_Atom; type Gdk_Axis_Use is (Axis_Ignore, Axis_X, Axis_Y, Axis_Pressure, Axis_X_Tilt, Axis_Y_Tilt, Axis_Last); pragma Convention (C, Gdk_Axis_Use); type Gdk_Byte_Order is (Lsb_First, Msb_First); pragma Convention (C, Gdk_Byte_Order); type Gdk_Extension_Mode is (Extension_Events_None, Extension_Events_All, Extension_Events_Cursor); pragma Convention (C, Gdk_Extension_Mode); type Gdk_IC_Attributes_Type is new Guint; Ic_Style : constant Gdk_IC_Attributes_Type; Ic_Client_Window : constant Gdk_IC_Attributes_Type; Ic_Focus_Window : constant Gdk_IC_Attributes_Type; Ic_Filter_Events : constant Gdk_IC_Attributes_Type; Ic_Spot_Location : constant Gdk_IC_Attributes_Type; Ic_Line_Spacing : constant Gdk_IC_Attributes_Type; Ic_Cursor : constant Gdk_IC_Attributes_Type; Ic_Preedit_Fontset : constant Gdk_IC_Attributes_Type; Ic_Preedit_Area : constant Gdk_IC_Attributes_Type; Ic_Preedit_Area_Needed : constant Gdk_IC_Attributes_Type; Ic_Preedit_Foreground : constant Gdk_IC_Attributes_Type; Ic_Preedit_Background : constant Gdk_IC_Attributes_Type; Ic_Preedit_Pixmap : constant Gdk_IC_Attributes_Type; Ic_Preedit_Colormap : constant Gdk_IC_Attributes_Type; Ic_Status_Fontset : constant Gdk_IC_Attributes_Type; Ic_Status_Area : constant Gdk_IC_Attributes_Type; Ic_Status_Area_Needed : constant Gdk_IC_Attributes_Type; Ic_Status_Foreground : constant Gdk_IC_Attributes_Type; Ic_Status_Background : constant Gdk_IC_Attributes_Type; Ic_Status_Pixmap : constant Gdk_IC_Attributes_Type; Ic_Status_Colormap : constant Gdk_IC_Attributes_Type; Ic_All_Req : constant Gdk_IC_Attributes_Type; Ic_Preedit_Area_Req : constant Gdk_IC_Attributes_Type; Ic_Preedit_Position_Req : constant Gdk_IC_Attributes_Type; Ic_Status_Area_Req : constant Gdk_IC_Attributes_Type; type Gdk_IM_Style is new Guint; Im_Preedit_Area : constant Gdk_IM_Style; Im_Preedit_Callbacks : constant Gdk_IM_Style; Im_Preedit_Position : constant Gdk_IM_Style; Im_Preedit_Nothing : constant Gdk_IM_Style; Im_Preedit_None : constant Gdk_IM_Style; Im_Preedit_Mask : constant Gdk_IM_Style; Im_Status_Area : constant Gdk_IM_Style; Im_Status_Callbacks : constant Gdk_IM_Style; Im_Status_Nothing : constant Gdk_IM_Style; Im_Status_None : constant Gdk_IM_Style; Im_Status_Mask : constant Gdk_IM_Style; type Gdk_Input_Condition is (Input_Read, Input_Write, Input_Exception); pragma Convention (C, Gdk_Input_Condition); type Gdk_Input_Mode is (Mode_Disabled, Mode_Screen, Mode_Window); pragma Convention (C, Gdk_Input_Mode); type Gdk_Input_Source is (Source_Mouse, Source_Pen, Source_Eraser, Source_Cursor, Source_Keyboard, Source_Touchscreen, Source_Touchpad); pragma Convention (C, Gdk_Input_Source); type Gdk_Grab_Status is (Grab_Success, -- successfully grabbed Grab_Already_Grabbed, -- resource actively grabbed by another client Grab_Invalid_Time, -- resource grabbed more recently than the -- specified time Grab_Not_Viewable, -- grab window or confine_to_window are not -- viewable Grab_Frozen); -- resource is frozen by an active grab of -- another client -- Indicates the success or reason of failure for a grab attempt type Gdk_Grab_Ownership is (Ownership_None, Ownership_Window, Ownership_Application); -- Defines how device grabs interact with other devices: -- None: all other devices' events are allowed -- Window: other devices' events are blocked for the grab window -- Application: other devices' events are blocked for the whole app. type Gdk_Key_Type is new Guint; -- see Gdk.Types.Keysyms for key type constants type Gdk_Modifier_Type is new Guint; Shift_Mask : constant Gdk_Modifier_Type; Lock_Mask : constant Gdk_Modifier_Type; Control_Mask : constant Gdk_Modifier_Type; Mod1_Mask : constant Gdk_Modifier_Type; Mod2_Mask : constant Gdk_Modifier_Type; Mod3_Mask : constant Gdk_Modifier_Type; Mod4_Mask : constant Gdk_Modifier_Type; Mod5_Mask : constant Gdk_Modifier_Type; Button1_Mask : constant Gdk_Modifier_Type; Button2_Mask : constant Gdk_Modifier_Type; Button3_Mask : constant Gdk_Modifier_Type; Button4_Mask : constant Gdk_Modifier_Type; Button5_Mask : constant Gdk_Modifier_Type; Super_Mask : constant Gdk_Modifier_Type; Hyper_Mask : constant Gdk_Modifier_Type; Meta_Mask : constant Gdk_Modifier_Type; Release_Mask : constant Gdk_Modifier_Type; Modifier_Mask : constant Gdk_Modifier_Type; function Primary_Mod_Mask return Gdk_Modifier_Type; type Gdk_Modifier_Intent is (Primary_Accelerator, Context_Menu, Extend_Selection, Modify_Selection, No_Text_Input, Shift_Group); -- This enum is used with gdk_keymap_get_modifier_mask() and -- gdk_get_modifier_mask() in order to determine what modifiers the -- currently used windowing system backend uses for particular -- purposes. For example, on X11/Windows, the Control key is used for -- invoking menu shortcuts (accelerators), whereas on Apple computers -- it's the Command key (which correspond to %GDK_CONTROL_MASK and -- GDK_MOD2_MASK, respectively). subtype Gdk_WChar is Standard.Wide_Character; subtype Gdk_WString is Standard.Wide_String; -- Gdk does not define a Gdk_WString type, but uses pointers -- to Gdk_WChar instead. ---------------- -- Properties -- ---------------- -- The following packages and types are used to represent properties of -- the given type. They are used in the packages that use these properties package Extension_Mode_Properties is new Generic_Internal_Discrete_Property (Gdk_Extension_Mode); type Property_Gdk_Extension_Mode is new Extension_Mode_Properties.Property; private ------------------------- -- Private constants -- ------------------------- Ic_Style : constant Gdk_IC_Attributes_Type := 2 ** 0; Ic_Client_Window : constant Gdk_IC_Attributes_Type := 2 ** 1; Ic_Focus_Window : constant Gdk_IC_Attributes_Type := 2 ** 2; Ic_Filter_Events : constant Gdk_IC_Attributes_Type := 2 ** 3; Ic_Spot_Location : constant Gdk_IC_Attributes_Type := 2 ** 4; Ic_Line_Spacing : constant Gdk_IC_Attributes_Type := 2 ** 5; Ic_Cursor : constant Gdk_IC_Attributes_Type := 2 ** 6; Ic_Preedit_Fontset : constant Gdk_IC_Attributes_Type := 2 ** 10; Ic_Preedit_Area : constant Gdk_IC_Attributes_Type := 2 ** 11; Ic_Preedit_Area_Needed : constant Gdk_IC_Attributes_Type := 2 ** 12; Ic_Preedit_Foreground : constant Gdk_IC_Attributes_Type := 2 ** 13; Ic_Preedit_Background : constant Gdk_IC_Attributes_Type := 2 ** 14; Ic_Preedit_Pixmap : constant Gdk_IC_Attributes_Type := 2 ** 15; Ic_Preedit_Colormap : constant Gdk_IC_Attributes_Type := 2 ** 16; Ic_Status_Fontset : constant Gdk_IC_Attributes_Type := 2 ** 21; Ic_Status_Area : constant Gdk_IC_Attributes_Type := 2 ** 22; Ic_Status_Area_Needed : constant Gdk_IC_Attributes_Type := 2 ** 23; Ic_Status_Foreground : constant Gdk_IC_Attributes_Type := 2 ** 24; Ic_Status_Background : constant Gdk_IC_Attributes_Type := 2 ** 25; Ic_Status_Pixmap : constant Gdk_IC_Attributes_Type := 2 ** 26; Ic_Status_Colormap : constant Gdk_IC_Attributes_Type := 2 ** 27; Ic_All_Req : constant Gdk_IC_Attributes_Type := Ic_Style or Ic_Client_Window; Ic_Preedit_Area_Req : constant Gdk_IC_Attributes_Type := Ic_Preedit_Area or Ic_Preedit_Fontset; Ic_Preedit_Position_Req : constant Gdk_IC_Attributes_Type := Ic_Preedit_Area or Ic_Spot_Location or Ic_Preedit_Fontset; Ic_Status_Area_Req : constant Gdk_IC_Attributes_Type := Ic_Status_Area or Ic_Status_Fontset; Im_Preedit_Area : constant Gdk_IM_Style := 16#0001#; Im_Preedit_Callbacks : constant Gdk_IM_Style := 16#0002#; Im_Preedit_Position : constant Gdk_IM_Style := 16#0004#; Im_Preedit_Nothing : constant Gdk_IM_Style := 16#0008#; Im_Preedit_None : constant Gdk_IM_Style := 16#0010#; Im_Preedit_Mask : constant Gdk_IM_Style := 16#001F#; Im_Status_Area : constant Gdk_IM_Style := 16#0100#; Im_Status_Callbacks : constant Gdk_IM_Style := 16#0200#; Im_Status_Nothing : constant Gdk_IM_Style := 16#0400#; Im_Status_None : constant Gdk_IM_Style := 16#0800#; Im_Status_Mask : constant Gdk_IM_Style := 16#0F00#; Shift_Mask : constant Gdk_Modifier_Type := 2 ** 0; Lock_Mask : constant Gdk_Modifier_Type := 2 ** 1; Control_Mask : constant Gdk_Modifier_Type := 2 ** 2; Mod1_Mask : constant Gdk_Modifier_Type := 2 ** 3; Mod2_Mask : constant Gdk_Modifier_Type := 2 ** 4; Mod3_Mask : constant Gdk_Modifier_Type := 2 ** 5; Mod4_Mask : constant Gdk_Modifier_Type := 2 ** 6; Mod5_Mask : constant Gdk_Modifier_Type := 2 ** 7; Button1_Mask : constant Gdk_Modifier_Type := 2 ** 8; Button2_Mask : constant Gdk_Modifier_Type := 2 ** 9; Button3_Mask : constant Gdk_Modifier_Type := 2 ** 10; Button4_Mask : constant Gdk_Modifier_Type := 2 ** 11; Button5_Mask : constant Gdk_Modifier_Type := 2 ** 12; Super_Mask : constant Gdk_Modifier_Type := 2 ** 26; Hyper_Mask : constant Gdk_Modifier_Type := 2 ** 27; Meta_Mask : constant Gdk_Modifier_Type := 2 ** 28; Release_Mask : constant Gdk_Modifier_Type := 2 ** 30; Modifier_Mask : constant Gdk_Modifier_Type := 16#5C001FFF#; pragma Import (C, Primary_Mod_Mask, "ada_gdk_get_default_modifier"); ------------------------------ -- Representation clauses -- ------------------------------ for Gdk_Input_Condition use (Input_Read => 2 ** 0, Input_Write => 2 ** 1, Input_Exception => 2 ** 2); end Gdk.Types; -- The following types were not bound because it did not seem -- to be necessary (yet). -- -- + GdkColorContextMode -- + GdkCrossingMode -- + GdkFilterReturn -- + GdkFontType -- + GdkNotifyType -- + GdkPropertyState -- + GdkStatus gtkada-24.0.0/src/gdk-visual.adb000066400000000000000000000131171446021174000163370ustar00rootroot00000000000000------------------------------------------------------------------------------ -- GtkAda - Ada95 binding for Gtk+/Gnome -- -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 1998-2018, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ with Interfaces.C.Pointers; package body Gdk.Visual is type Aliased_Gint_Array is array (Natural range <>) of aliased Gint; package Gint_Ptr is new Interfaces.C.Pointers (Index => Natural, Element => Gint, Element_Array => Aliased_Gint_Array, Default_Terminator => 0); type Aliased_Visual_Type_Array is array (Natural range <>) of aliased Gdk_Visual_Type; package Visual_Type_Ptr is new Interfaces.C.Pointers (Index => Natural, Element => Gdk_Visual_Type, Element_Array => Aliased_Visual_Type_Array, Default_Terminator => Visual_Static_Gray); -------------- -- Get_Best -- -------------- function Get_Best return Gdk_Visual is function Internal return Gdk_Visual; pragma Import (C, Internal, "gdk_visual_get_best"); begin return Internal; end Get_Best; procedure Get_Best (Visual : out Gdk_Visual) is begin Visual := Get_Best; end Get_Best; function Get_Best (Depth : Gint) return Gdk_Visual is function Internal (Depth : Gint) return Gdk_Visual; pragma Import (C, Internal, "gdk_visual_get_best_with_depth"); begin return Internal (Depth); end Get_Best; function Get_Best (Visual_Type : Gdk_Visual_Type) return Gdk_Visual is function Internal (Visual_Type : Gdk_Visual_Type) return Gdk_Visual; pragma Import (C, Internal, "gdk_visual_get_best_with_type"); begin return Internal (Visual_Type); end Get_Best; function Get_Best (Depth : Gint; Visual_Type : Gdk_Visual_Type) return Gdk_Visual is function Internal (Depth : Gint; Visual_Type : Gdk_Visual_Type) return Gdk_Visual; pragma Import (C, Internal, "gdk_visual_get_best_with_both"); begin return Internal (Depth, Visual_Type); end Get_Best; ------------------ -- List_Visuals -- ------------------ function List_Visuals return Gdk_Visual_List.Glist is function Internal return System.Address; pragma Import (C, Internal, "gdk_list_visuals"); Result : Gdk_Visual_List.Glist; begin Gdk_Visual_List.Set_Object (Result, Internal); return Result; end List_Visuals; ------------------ -- Query_Depths -- ------------------ function Query_Depths return Gint_Array is procedure Internal (Depths : out Gint_Ptr.Pointer; Count : out Gint); pragma Import (C, Internal, "gdk_query_depths"); Internal_Result : Gint_Ptr.Pointer; Count : Gint; begin Internal (Internal_Result, Count); declare Temp : constant Aliased_Gint_Array := Gint_Ptr.Value (Ref => Internal_Result, Length => Interfaces.C.ptrdiff_t (Count)); Result : Gint_Array (1 .. Temp'Length); begin for Index in Temp'Range loop Result (Result'First + Index - Temp'First) := Temp (Index); end loop; return Result; end; end Query_Depths; ------------------------ -- Query_Visual_Types -- ------------------------ function Query_Visual_Types return Gdk_Visual_Type_Array is procedure Internal (Visual_Type : out Visual_Type_Ptr.Pointer; Count : out Gint); pragma Import (C, Internal, "gdk_query_visual_types"); Internal_Result : Visual_Type_Ptr.Pointer; Count : Gint; begin Internal (Internal_Result, Count); declare Temp : constant Aliased_Visual_Type_Array := Visual_Type_Ptr.Value (Ref => Internal_Result, Length => Interfaces.C.ptrdiff_t (Count)); Result : Gdk_Visual_Type_Array (1 .. Temp'Length); begin for Index in Temp'Range loop Result (Result'First + Index - Temp'First) := Temp (Index); end loop; return Result; end; end Query_Visual_Types; end Gdk.Visual; gtkada-24.0.0/src/gdk-visual.ads000066400000000000000000000073751446021174000163710ustar00rootroot00000000000000------------------------------------------------------------------------------ -- GtkAda - Ada95 binding for Gtk+/Gnome -- -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 1998-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ -- 1.3.6 -- Gdk, the low-level API with Glib; use Glib; with Glib.Glist; pragma Elaborate_All (Glib.Glist); with System; with Ada.Unchecked_Conversion; package Gdk.Visual is subtype Gdk_Visual is Gdk.Gdk_Visual; Null_Visual : constant Gdk_Visual; -- This type is not private because we need the full declaration -- to instanciate Glib.Glist.Generic_List with it. type Gdk_Visual_Type is (Visual_Static_Gray, Visual_Grayscale, Visual_Static_Color, Visual_Pseudo_Color, Visual_True_Color, Visual_Direct_Color); pragma Convention (C, Gdk_Visual_Type); type Gdk_Visual_Type_Array is array (Natural range <>) of Gdk_Visual_Type; function Get_Type return Glib.GType; -- Return the internal value associated with Gdk_Visual. function Get_Best_Depth return Gint; function Get_Best_Type return Gdk_Visual_Type; function Get_System return Gdk_Visual; function Get_Best return Gdk_Visual; procedure Get_Best (Visual : out Gdk_Visual); function Get_Best (Depth : Gint) return Gdk_Visual; function Get_Best (Visual_Type : Gdk_Visual_Type) return Gdk_Visual; function Get_Best (Depth : Gint; Visual_Type : Gdk_Visual_Type) return Gdk_Visual; function Query_Depths return Gint_Array; function Query_Visual_Types return Gdk_Visual_Type_Array; function Convert is new Ada.Unchecked_Conversion (Gdk_Visual, System.Address); function Convert is new Ada.Unchecked_Conversion (System.Address, Gdk_Visual); package Gdk_Visual_List is new Glib.Glist.Generic_List (Gdk_Visual); function List_Visuals return Gdk_Visual_List.Glist; private Null_Visual : constant Gdk_Visual := null; pragma Import (C, Get_Type, "gdk_visual_get_type"); pragma Import (C, Get_Best_Depth, "gdk_visual_get_best_depth"); pragma Import (C, Get_Best_Type, "gdk_visual_get_best_type"); pragma Import (C, Get_System, "gdk_visual_get_system"); end Gdk.Visual; gtkada-24.0.0/src/gdk-window_attr.adb000066400000000000000000000161171446021174000174000ustar00rootroot00000000000000------------------------------------------------------------------------------ -- GtkAda - Ada95 binding for Gtk+/Gnome -- -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 1998-2018, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ with Gtkada.Types; with Glib; use Glib; package body Gdk.Window_Attr is ------------- -- Destroy -- ------------- procedure Destroy (Window_Attr : in out Gdk_Window_Attr) is procedure Internal (Window_Attr : Gdk_Window_Attr); pragma Import (C, Internal, "ada_gdk_window_attr_destroy"); begin Internal (Window_Attr); Window_Attr := Null_Window_Attr; end Destroy; ------------- -- Gdk_New -- ------------- procedure Gdk_New (Window_Attr : out Gdk_Window_Attr; Title : UTF8_String := ""; Event_Mask : Gdk.Event.Gdk_Event_Mask := 0; X, Y : Glib.Gint := 0; Width : Glib.Gint := 0; Height : Glib.Gint := 0; Wclass : Gdk.Window.Gdk_Window_Class := Gdk.Window.Input_Output; Visual : Gdk.Visual.Gdk_Visual := null; Window_Type : Gdk.Window.Gdk_Window_Type := Gdk.Window.Window_Root; Cursor : Gdk.Gdk_Cursor := null; Wmclass_Name : String := ""; Wmclass_Class : String := ""; Override_Redirect : Boolean := True) is function Internal return Gdk_Window_Attr; pragma Import (C, Internal, "ada_gdk_window_attr_new"); begin Window_Attr := Internal; Set_Title (Window_Attr, Title); Set_Event_Mask (Window_Attr, Event_Mask); Set_X (Window_Attr, X); Set_Y (Window_Attr, Y); Set_Width (Window_Attr, Width); Set_Height (Window_Attr, Height); Set_Window_Class (Window_Attr, Wclass); Set_Visual (Window_Attr, Visual); Set_Window_Type (Window_Attr, Window_Type); Set_Cursor (Window_Attr, Cursor); Set_Wmclass_Name (Window_Attr, Wmclass_Name); Set_Wmclass_Class (Window_Attr, Wmclass_Class); Set_Override_Redirect (Window_Attr, Override_Redirect); end Gdk_New; --------------------------- -- Get_Override_Redirect -- --------------------------- function Get_Override_Redirect (Window_Attr : Gdk_Window_Attr) return Boolean is function Internal (Window_Attr : Gdk_Window_Attr) return Glib.Gboolean; pragma Import (C, Internal, "ada_gdk_window_attr_get_override_redirect"); begin return Internal (Window_Attr) /= 0; end Get_Override_Redirect; --------------- -- Get_Title -- --------------- function Get_Title (Window_Attr : Gdk_Window_Attr) return UTF8_String is function Internal (Window_Attr : Gdk_Window_Attr) return Gtkada.Types.Chars_Ptr; pragma Import (C, Internal, "ada_gdk_window_attr_get_title"); begin return Gtkada.Types.Value (Internal (Window_Attr)); end Get_Title; ----------------------- -- Get_Wmclass_Class -- ----------------------- function Get_Wmclass_Class (Window_Attr : Gdk_Window_Attr) return String is function Internal (Window_Attr : Gdk_Window_Attr) return Gtkada.Types.Chars_Ptr; pragma Import (C, Internal, "ada_gdk_window_attr_get_wmclass_class"); begin return Gtkada.Types.Value (Internal (Window_Attr)); end Get_Wmclass_Class; ---------------------- -- Get_Wmclass_Name -- ---------------------- function Get_Wmclass_Name (Window_Attr : Gdk_Window_Attr) return String is function Internal (Window_Attr : Gdk_Window_Attr) return Gtkada.Types.Chars_Ptr; pragma Import (C, Internal, "ada_gdk_window_attr_get_wmclass_name"); begin return Gtkada.Types.Value (Internal (Window_Attr)); end Get_Wmclass_Name; --------------------------- -- Set_Override_Redirect -- --------------------------- procedure Set_Override_Redirect (Window_Attr : Gdk_Window_Attr; Override_Redirect : Boolean) is procedure Internal (Window_Attr : Gdk_Window_Attr; Override_Redirect : Glib.Gboolean); pragma Import (C, Internal, "ada_gdk_window_attr_set_override_redirect"); begin Internal (Window_Attr, Boolean'Pos (Override_Redirect)); end Set_Override_Redirect; --------------- -- Set_Title -- --------------- procedure Set_Title (Window_Attr : Gdk_Window_Attr; Title : UTF8_String) is procedure Internal (Window_Attr : Gdk_Window_Attr; Title : UTF8_String); pragma Import (C, Internal, "ada_gdk_window_attr_set_title"); begin Internal (Window_Attr, Title & ASCII.NUL); end Set_Title; ----------------------- -- Set_Wmclass_Class -- ----------------------- procedure Set_Wmclass_Class (Window_Attr : Gdk_Window_Attr; Wmclass_Class : String) is procedure Internal (Window_Attr : Gdk_Window_Attr; Wmclass_Class : String); pragma Import (C, Internal, "ada_gdk_window_attr_set_wmclass_class"); begin Internal (Window_Attr, Wmclass_Class & ASCII.NUL); end Set_Wmclass_Class; ---------------------- -- Set_Wmclass_Name -- ---------------------- procedure Set_Wmclass_Name (Window_Attr : Gdk_Window_Attr; Wmclass_Name : String) is procedure Internal (Window_Attr : Gdk_Window_Attr; Wmclass_Name : String); pragma Import (C, Internal, "ada_gdk_window_attr_set_wmclass_name"); begin Internal (Window_Attr, Wmclass_Name & ASCII.NUL); end Set_Wmclass_Name; end Gdk.Window_Attr; gtkada-24.0.0/src/gdk-window_attr.ads000066400000000000000000000167641446021174000174310ustar00rootroot00000000000000------------------------------------------------------------------------------ -- GtkAda - Ada95 binding for Gtk+/Gnome -- -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 1998-2018, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ -- Gdk, the low-level API with Gdk.Event; with Gdk.Visual; with Gdk.Window; with Glib; package Gdk.Window_Attr is subtype Gdk_Window_Attr is Gdk.Gdk_Window_Attr; Null_Window_Attr : constant Gdk_Window_Attr; -- This record describes the initial attributes for a window. Most of -- them can be changed later on, but it is more efficient to set them -- right from the start. -- You usually need to do the following when initializing such a -- structure: -- Window_Attr.Visual := Get_Visual (Window); -- Window_Attr.Colormap := Get_Colormap (Window); -- Window_Attr.Event_Mask := Get_Events (Window) or Exposure_Mask; procedure Gdk_New (Window_Attr : out Gdk_Window_Attr; Title : Glib.UTF8_String := ""; Event_Mask : Gdk.Event.Gdk_Event_Mask := 0; X, Y : Glib.Gint := 0; Width : Glib.Gint := 0; Height : Glib.Gint := 0; Wclass : Gdk.Window.Gdk_Window_Class := Gdk.Window.Input_Output; Visual : Gdk.Visual.Gdk_Visual := null; Window_Type : Gdk.Window.Gdk_Window_Type := Gdk.Window.Window_Root; Cursor : Gdk.Gdk_Cursor := null; Wmclass_Name : String := ""; Wmclass_Class : String := ""; Override_Redirect : Boolean := True); -- Creates a new Gdk_Window_Attr structure. -- It is your responsability to free the visual, colormap, cursor,... field -- when they are no longer needed. procedure Destroy (Window_Attr : in out Gdk_Window_Attr); procedure Set_Title (Window_Attr : Gdk_Window_Attr; Title : Glib.UTF8_String); function Get_Title (Window_Attr : Gdk_Window_Attr) return Glib.UTF8_String; procedure Set_Event_Mask (Window_Attr : Gdk_Window_Attr; Event_Mask : Gdk.Event.Gdk_Event_Mask); function Get_Event_Mask (Window_Attr : Gdk_Window_Attr) return Gdk.Event.Gdk_Event_Mask; procedure Set_X (Window_Attr : Gdk_Window_Attr; X : Glib.Gint); function Get_X (Window_Attr : Gdk_Window_Attr) return Glib.Gint; procedure Set_Y (Window_Attr : Gdk_Window_Attr; Y : Glib.Gint); function Get_Y (Window_Attr : Gdk_Window_Attr) return Glib.Gint; procedure Set_Width (Window_Attr : Gdk_Window_Attr; Width : Glib.Gint); function Get_Width (Window_Attr : Gdk_Window_Attr) return Glib.Gint; procedure Set_Height (Window_Attr : Gdk_Window_Attr; Height : Glib.Gint); function Get_Height (Window_Attr : Gdk_Window_Attr) return Glib.Gint; procedure Set_Window_Class (Window_Attr : Gdk_Window_Attr; Wclass : Gdk.Window.Gdk_Window_Class); function Get_Window_Class (Window_Attr : Gdk_Window_Attr) return Gdk.Window.Gdk_Window_Class; procedure Set_Visual (Window_Attr : Gdk_Window_Attr; Visual : Gdk.Visual.Gdk_Visual); function Get_Visual (Window_Attr : Gdk_Window_Attr) return Gdk.Visual.Gdk_Visual; procedure Set_Window_Type (Window_Attr : Gdk_Window_Attr; Window_Type : Gdk.Window.Gdk_Window_Type); function Get_Window_Type (Window_Attr : Gdk_Window_Attr) return Gdk.Window.Gdk_Window_Type; procedure Set_Cursor (Window_Attr : Gdk_Window_Attr; Cursor : Gdk.Gdk_Cursor); function Get_Cursor (Window_Attr : Gdk_Window_Attr) return Gdk.Gdk_Cursor; procedure Set_Wmclass_Name (Window_Attr : Gdk_Window_Attr; Wmclass_Name : String); function Get_Wmclass_Name (Window_Attr : Gdk_Window_Attr) return String; procedure Set_Wmclass_Class (Window_Attr : Gdk_Window_Attr; Wmclass_Class : String); function Get_Wmclass_Class (Window_Attr : Gdk_Window_Attr) return String; procedure Set_Override_Redirect (Window_Attr : Gdk_Window_Attr; Override_Redirect : Boolean); function Get_Override_Redirect (Window_Attr : Gdk_Window_Attr) return Boolean; -- An override redirect window is not under the control of the window -- manager. This means it won't have a titlebar, won't be minimizable, etc. -- It will be entirely under the control of the application. The window -- manager can't see the override redirect window at all. -- -- Override redirect should only be used for short-lived temporary windows, -- such as popup menus. #GtkMenu uses an override redirect window in its -- implementation, for example private Null_Window_Attr : constant Gdk_Window_Attr := null; pragma Import (C, Get_Cursor, "ada_gdk_window_attr_get_cursor"); pragma Import (C, Get_Event_Mask, "ada_gdk_window_attr_get_event_mask"); pragma Import (C, Get_Height, "ada_gdk_window_attr_get_height"); pragma Import (C, Get_Visual, "ada_gdk_window_attr_get_visual"); pragma Import (C, Get_Width, "ada_gdk_window_attr_get_width"); pragma Import (C, Get_Window_Class, "ada_gdk_window_attr_get_wclass"); pragma Import (C, Get_Window_Type, "ada_gdk_window_attr_get_window_type"); pragma Import (C, Get_X, "ada_gdk_window_attr_get_x"); pragma Import (C, Get_Y, "ada_gdk_window_attr_get_y"); pragma Import (C, Set_Cursor, "ada_gdk_window_attr_set_cursor"); pragma Import (C, Set_Event_Mask, "ada_gdk_window_attr_set_event_mask"); pragma Import (C, Set_Height, "ada_gdk_window_attr_set_height"); pragma Import (C, Set_Visual, "ada_gdk_window_attr_set_visual"); pragma Import (C, Set_Width, "ada_gdk_window_attr_set_width"); pragma Import (C, Set_Window_Class, "ada_gdk_window_attr_set_wclass"); pragma Import (C, Set_Window_Type, "ada_gdk_window_attr_set_window_type"); pragma Import (C, Set_X, "ada_gdk_window_attr_set_x"); pragma Import (C, Set_Y, "ada_gdk_window_attr_set_y"); end Gdk.Window_Attr; gtkada-24.0.0/src/gdk.ads000066400000000000000000000051211446021174000150530ustar00rootroot00000000000000------------------------------------------------------------------------------ -- GtkAda - Ada95 binding for Gtk+/Gnome -- -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 1998-2018, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ -- -- -- This is the top level package of the Gdk hierarchy. -- It provides the type definitions used to access underlying C structures. -- -- -- Gdk, the low-level API with Glib; pragma Warnings (Off); with System; pragma Warnings (On); package Gdk is -- A Gdk_Window, in gtk+, is really a GObject. That means it comes with -- reference counting. Changing this in GtkAda would break a lot of code -- though, so we only bind it as a C_Proxy, but provide Gdk.Window.Ref -- and Gdk.Window.Unref to access the reference counting support. type Gdk_Window is new Glib.C_Proxy; type Gdk_Cursor is new Glib.C_Proxy; -- private type in C type Gdk_Visual is new Glib.C_Proxy; -- private type in C type Gdk_Window_Attr is new Glib.C_Proxy; end Gdk; gtkada-24.0.0/src/generated/000077500000000000000000000000001446021174000155545ustar00rootroot00000000000000gtkada-24.0.0/src/generated/.gitignore000066400000000000000000000000001446021174000175320ustar00rootroot00000000000000gtkada-24.0.0/src/generated/gdk-cursor.adb000066400000000000000000000173621446021174000203150ustar00rootroot00000000000000------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ pragma Style_Checks (Off); pragma Warnings (Off, "*is already use-visible*"); pragma Warnings(Off); -- might be unused with Gtkada.Types; use Gtkada.Types; pragma Warnings(On); package body Gdk.Cursor is -------------------- -- Gdk_Cursor_New -- -------------------- function Gdk_Cursor_New (Cursor_Type : Gdk_Cursor_Type) return Gdk_Cursor is function Internal (Cursor_Type : Gdk_Cursor_Type) return Gdk_Cursor; pragma Import (C, Internal, "gdk_cursor_new"); Self : Gdk_Cursor; begin Self := Internal (Cursor_Type); return Self; end Gdk_Cursor_New; -------------------------------- -- Gdk_Cursor_New_For_Display -- -------------------------------- function Gdk_Cursor_New_For_Display (Display : not null access Gdk.Display.Gdk_Display_Record'Class; Cursor_Type : Gdk_Cursor_Type) return Gdk_Cursor is function Internal (Display : System.Address; Cursor_Type : Gdk_Cursor_Type) return Gdk_Cursor; pragma Import (C, Internal, "gdk_cursor_new_for_display"); Self : Gdk_Cursor; begin Self := Internal (Get_Object (Display), Cursor_Type); return Self; end Gdk_Cursor_New_For_Display; ------------------------------ -- Gdk_Cursor_New_From_Name -- ------------------------------ function Gdk_Cursor_New_From_Name (Display : not null access Gdk.Display.Gdk_Display_Record'Class; Name : UTF8_String) return Gdk_Cursor is function Internal (Display : System.Address; Name : Gtkada.Types.Chars_Ptr) return Gdk_Cursor; pragma Import (C, Internal, "gdk_cursor_new_from_name"); Tmp_Name : Gtkada.Types.Chars_Ptr := New_String (Name); Tmp_Return : Gdk_Cursor; Self : Gdk_Cursor; begin Tmp_Return := Internal (Get_Object (Display), Tmp_Name); Free (Tmp_Name); Self := Tmp_Return; return Self; end Gdk_Cursor_New_From_Name; --------------------------------- -- Gdk_Cursor_New_From_Surface -- --------------------------------- function Gdk_Cursor_New_From_Surface (Display : not null access Gdk.Display.Gdk_Display_Record'Class; Surface : Cairo.Cairo_Surface; X : Gdouble; Y : Gdouble) return Gdk_Cursor is function Internal (Display : System.Address; Surface : Cairo.Cairo_Surface; X : Gdouble; Y : Gdouble) return Gdk_Cursor; pragma Import (C, Internal, "gdk_cursor_new_from_surface"); Self : Gdk_Cursor; begin Self := Internal (Get_Object (Display), Surface, X, Y); return Self; end Gdk_Cursor_New_From_Surface; ------------- -- Gdk_New -- ------------- procedure Gdk_New (Self : out Gdk_Cursor; Cursor_Type : Gdk_Cursor_Type) is function Internal (Cursor_Type : Gdk_Cursor_Type) return Gdk_Cursor; pragma Import (C, Internal, "gdk_cursor_new"); begin Self := Internal (Cursor_Type); end Gdk_New; ------------------------- -- Gdk_New_For_Display -- ------------------------- procedure Gdk_New_For_Display (Self : out Gdk_Cursor; Display : not null access Gdk.Display.Gdk_Display_Record'Class; Cursor_Type : Gdk_Cursor_Type) is function Internal (Display : System.Address; Cursor_Type : Gdk_Cursor_Type) return Gdk_Cursor; pragma Import (C, Internal, "gdk_cursor_new_for_display"); begin Self := Internal (Get_Object (Display), Cursor_Type); end Gdk_New_For_Display; ----------------------- -- Gdk_New_From_Name -- ----------------------- procedure Gdk_New_From_Name (Self : out Gdk_Cursor; Display : not null access Gdk.Display.Gdk_Display_Record'Class; Name : UTF8_String) is function Internal (Display : System.Address; Name : Gtkada.Types.Chars_Ptr) return Gdk_Cursor; pragma Import (C, Internal, "gdk_cursor_new_from_name"); Tmp_Name : Gtkada.Types.Chars_Ptr := New_String (Name); Tmp_Return : Gdk_Cursor; begin Tmp_Return := Internal (Get_Object (Display), Tmp_Name); Free (Tmp_Name); Self := Tmp_Return; end Gdk_New_From_Name; -------------------------- -- Gdk_New_From_Surface -- -------------------------- procedure Gdk_New_From_Surface (Self : out Gdk_Cursor; Display : not null access Gdk.Display.Gdk_Display_Record'Class; Surface : Cairo.Cairo_Surface; X : Gdouble; Y : Gdouble) is function Internal (Display : System.Address; Surface : Cairo.Cairo_Surface; X : Gdouble; Y : Gdouble) return Gdk_Cursor; pragma Import (C, Internal, "gdk_cursor_new_from_surface"); begin Self := Internal (Get_Object (Display), Surface, X, Y); end Gdk_New_From_Surface; ----------------- -- Get_Display -- ----------------- function Get_Display (Self : Gdk.Gdk_Cursor) return Gdk.Display.Gdk_Display is function Internal (Self : Gdk.Gdk_Cursor) return System.Address; pragma Import (C, Internal, "gdk_cursor_get_display"); Stub_Gdk_Display : Gdk.Display.Gdk_Display_Record; begin return Gdk.Display.Gdk_Display (Get_User_Data (Internal (Self), Stub_Gdk_Display)); end Get_Display; ----------------- -- Get_Surface -- ----------------- procedure Get_Surface (Self : Gdk.Gdk_Cursor; X_Hot : out Gdouble; Y_Hot : out Gdouble; Surface : out Cairo.Cairo_Surface) is function Internal (Self : Gdk.Gdk_Cursor; Acc_X_Hot : access Gdouble; Acc_Y_Hot : access Gdouble) return Cairo.Cairo_Surface; pragma Import (C, Internal, "gdk_cursor_get_surface"); Acc_X_Hot : aliased Gdouble; Acc_Y_Hot : aliased Gdouble; Tmp_Return : Cairo.Cairo_Surface; begin Tmp_Return := Internal (Self, Acc_X_Hot'Access, Acc_Y_Hot'Access); X_Hot := Acc_X_Hot; Y_Hot := Acc_Y_Hot; Surface := Tmp_Return; end Get_Surface; end Gdk.Cursor; gtkada-24.0.0/src/generated/gdk-cursor.ads000066400000000000000000000366101446021174000203330ustar00rootroot00000000000000------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ -- -- A Gdk.Gdk_Cursor represents a cursor. Its contents are private. -- -- pragma Warnings (Off, "*is already use-visible*"); with Cairo; use Cairo; with Gdk.Display; use Gdk.Display; with Glib; use Glib; with Glib.Generic_Properties; use Glib.Generic_Properties; with Glib.Object; use Glib.Object; with Glib.Properties; use Glib.Properties; package Gdk.Cursor is type Gdk_Cursor_Type is ( Blank_Cursor, Cursor_Is_Pixmap, X_Cursor, Arrow, Based_Arrow_Down, Based_Arrow_Up, Boat, Bogosity, Bottom_Left_Corner, Bottom_Right_Corner, Bottom_Side, Bottom_Tee, Box_Spiral, Center_Ptr, Circle, Clock, Coffee_Mug, Cross, Cross_Reverse, Crosshair, Diamond_Cross, Dot, Dotbox, Double_Arrow, Draft_Large, Draft_Small, Draped_Box, Exchange, Fleur, Gobbler, Gumby, Hand1, Hand2, Heart, Icon, Iron_Cross, Left_Ptr, Left_Side, Left_Tee, Leftbutton, Ll_Angle, Lr_Angle, Man, Middlebutton, Mouse, Pencil, Pirate, Plus, Question_Arrow, Right_Ptr, Right_Side, Right_Tee, Rightbutton, Rtl_Logo, Sailboat, Sb_Down_Arrow, Sb_H_Double_Arrow, Sb_Left_Arrow, Sb_Right_Arrow, Sb_Up_Arrow, Sb_V_Double_Arrow, Shuttle, Sizing, Spider, Spraycan, Star, Target, Tcross, Top_Left_Arrow, Top_Left_Corner, Top_Right_Corner, Top_Side, Top_Tee, Trek, Ul_Angle, Umbrella, Ur_Angle, Watch, Xterm, Last_Cursor); pragma Convention (C, Gdk_Cursor_Type); -- Predefined cursors. -- -- Note that these IDs are directly taken from the X cursor font, and many -- of these cursors are either not useful, or are not available on other -- platforms. -- -- The recommended way to create cursors is to use -- gdk_cursor_new_from_name. for Gdk_Cursor_Type use ( Blank_Cursor => -2, Cursor_Is_Pixmap => -1, X_Cursor => 0, Arrow => 2, Based_Arrow_Down => 4, Based_Arrow_Up => 6, Boat => 8, Bogosity => 10, Bottom_Left_Corner => 12, Bottom_Right_Corner => 14, Bottom_Side => 16, Bottom_Tee => 18, Box_Spiral => 20, Center_Ptr => 22, Circle => 24, Clock => 26, Coffee_Mug => 28, Cross => 30, Cross_Reverse => 32, Crosshair => 34, Diamond_Cross => 36, Dot => 38, Dotbox => 40, Double_Arrow => 42, Draft_Large => 44, Draft_Small => 46, Draped_Box => 48, Exchange => 50, Fleur => 52, Gobbler => 54, Gumby => 56, Hand1 => 58, Hand2 => 60, Heart => 62, Icon => 64, Iron_Cross => 66, Left_Ptr => 68, Left_Side => 70, Left_Tee => 72, Leftbutton => 74, Ll_Angle => 76, Lr_Angle => 78, Man => 80, Middlebutton => 82, Mouse => 84, Pencil => 86, Pirate => 88, Plus => 90, Question_Arrow => 92, Right_Ptr => 94, Right_Side => 96, Right_Tee => 98, Rightbutton => 100, Rtl_Logo => 102, Sailboat => 104, Sb_Down_Arrow => 106, Sb_H_Double_Arrow => 108, Sb_Left_Arrow => 110, Sb_Right_Arrow => 112, Sb_Up_Arrow => 114, Sb_V_Double_Arrow => 116, Shuttle => 118, Sizing => 120, Spider => 122, Spraycan => 124, Star => 126, Target => 128, Tcross => 130, Top_Left_Arrow => 132, Top_Left_Corner => 134, Top_Right_Corner => 136, Top_Side => 138, Top_Tee => 140, Trek => 142, Ul_Angle => 144, Umbrella => 146, Ur_Angle => 148, Watch => 150, Xterm => 152, Last_Cursor => 153); ---------------------------- -- Enumeration Properties -- ---------------------------- package Gdk_Cursor_Type_Properties is new Generic_Internal_Discrete_Property (Gdk_Cursor_Type); type Property_Gdk_Cursor_Type is new Gdk_Cursor_Type_Properties.Property; ------------------ -- Constructors -- ------------------ procedure Gdk_New (Self : out Gdk_Cursor; Cursor_Type : Gdk_Cursor_Type); -- Creates a new cursor from the set of builtin cursors for the default -- display. See gdk_cursor_new_for_display. -- To make the cursor invisible, use Gdk.Blank_Cursor. -- "cursor_type": cursor to create function Gdk_Cursor_New (Cursor_Type : Gdk_Cursor_Type) return Gdk_Cursor; -- Creates a new cursor from the set of builtin cursors for the default -- display. See gdk_cursor_new_for_display. -- To make the cursor invisible, use Gdk.Blank_Cursor. -- "cursor_type": cursor to create procedure Gdk_New_For_Display (Self : out Gdk_Cursor; Display : not null access Gdk.Display.Gdk_Display_Record'Class; Cursor_Type : Gdk_Cursor_Type); -- Creates a new cursor from the set of builtin cursors. -- Since: gtk+ 2.2 -- "display": the Gdk.Display.Gdk_Display for which the cursor will be -- created -- "cursor_type": cursor to create function Gdk_Cursor_New_For_Display (Display : not null access Gdk.Display.Gdk_Display_Record'Class; Cursor_Type : Gdk_Cursor_Type) return Gdk_Cursor; -- Creates a new cursor from the set of builtin cursors. -- Since: gtk+ 2.2 -- "display": the Gdk.Display.Gdk_Display for which the cursor will be -- created -- "cursor_type": cursor to create procedure Gdk_New_From_Name (Self : out Gdk_Cursor; Display : not null access Gdk.Display.Gdk_Display_Record'Class; Name : UTF8_String); -- Creates a new cursor by looking up Name in the current cursor theme. -- A recommended set of cursor names that will work across different -- platforms can be found in the CSS specification: - "none" - -- ![](default_cursor.png) "default" - ![](help_cursor.png) "help" - -- ![](pointer_cursor.png) "pointer" - ![](context_menu_cursor.png) -- "context-menu" - ![](progress_cursor.png) "progress" - -- ![](wait_cursor.png) "wait" - ![](cell_cursor.png) "cell" - -- ![](crosshair_cursor.png) "crosshair" - ![](text_cursor.png) "text" - -- ![](vertical_text_cursor.png) "vertical-text" - ![](alias_cursor.png) -- "alias" - ![](copy_cursor.png) "copy" - ![](no_drop_cursor.png) -- "no-drop" - ![](move_cursor.png) "move" - ![](not_allowed_cursor.png) -- "not-allowed" - ![](grab_cursor.png) "grab" - ![](grabbing_cursor.png) -- "grabbing" - ![](all_scroll_cursor.png) "all-scroll" - -- ![](col_resize_cursor.png) "col-resize" - ![](row_resize_cursor.png) -- "row-resize" - ![](n_resize_cursor.png) "n-resize" - -- ![](e_resize_cursor.png) "e-resize" - ![](s_resize_cursor.png) -- "s-resize" - ![](w_resize_cursor.png) "w-resize" - -- ![](ne_resize_cursor.png) "ne-resize" - ![](nw_resize_cursor.png) -- "nw-resize" - ![](sw_resize_cursor.png) "sw-resize" - -- ![](se_resize_cursor.png) "se-resize" - ![](ew_resize_cursor.png) -- "ew-resize" - ![](ns_resize_cursor.png) "ns-resize" - -- ![](nesw_resize_cursor.png) "nesw-resize" - ![](nwse_resize_cursor.png) -- "nwse-resize" - ![](zoom_in_cursor.png) "zoom-in" - -- ![](zoom_out_cursor.png) "zoom-out" -- Since: gtk+ 2.8 -- "display": the Gdk.Display.Gdk_Display for which the cursor will be -- created -- "name": the name of the cursor function Gdk_Cursor_New_From_Name (Display : not null access Gdk.Display.Gdk_Display_Record'Class; Name : UTF8_String) return Gdk_Cursor; -- Creates a new cursor by looking up Name in the current cursor theme. -- A recommended set of cursor names that will work across different -- platforms can be found in the CSS specification: - "none" - -- ![](default_cursor.png) "default" - ![](help_cursor.png) "help" - -- ![](pointer_cursor.png) "pointer" - ![](context_menu_cursor.png) -- "context-menu" - ![](progress_cursor.png) "progress" - -- ![](wait_cursor.png) "wait" - ![](cell_cursor.png) "cell" - -- ![](crosshair_cursor.png) "crosshair" - ![](text_cursor.png) "text" - -- ![](vertical_text_cursor.png) "vertical-text" - ![](alias_cursor.png) -- "alias" - ![](copy_cursor.png) "copy" - ![](no_drop_cursor.png) -- "no-drop" - ![](move_cursor.png) "move" - ![](not_allowed_cursor.png) -- "not-allowed" - ![](grab_cursor.png) "grab" - ![](grabbing_cursor.png) -- "grabbing" - ![](all_scroll_cursor.png) "all-scroll" - -- ![](col_resize_cursor.png) "col-resize" - ![](row_resize_cursor.png) -- "row-resize" - ![](n_resize_cursor.png) "n-resize" - -- ![](e_resize_cursor.png) "e-resize" - ![](s_resize_cursor.png) -- "s-resize" - ![](w_resize_cursor.png) "w-resize" - -- ![](ne_resize_cursor.png) "ne-resize" - ![](nw_resize_cursor.png) -- "nw-resize" - ![](sw_resize_cursor.png) "sw-resize" - -- ![](se_resize_cursor.png) "se-resize" - ![](ew_resize_cursor.png) -- "ew-resize" - ![](ns_resize_cursor.png) "ns-resize" - -- ![](nesw_resize_cursor.png) "nesw-resize" - ![](nwse_resize_cursor.png) -- "nwse-resize" - ![](zoom_in_cursor.png) "zoom-in" - -- ![](zoom_out_cursor.png) "zoom-out" -- Since: gtk+ 2.8 -- "display": the Gdk.Display.Gdk_Display for which the cursor will be -- created -- "name": the name of the cursor procedure Gdk_New_From_Surface (Self : out Gdk_Cursor; Display : not null access Gdk.Display.Gdk_Display_Record'Class; Surface : Cairo.Cairo_Surface; X : Gdouble; Y : Gdouble); -- Creates a new cursor from a cairo image surface. -- Not all GDK backends support RGBA cursors. If they are not supported, a -- monochrome approximation will be displayed. The functions -- Gdk.Display.Supports_Cursor_Alpha and Gdk.Display.Supports_Cursor_Color -- can be used to determine whether RGBA cursors are supported; -- Gdk.Display.Get_Default_Cursor_Size and -- Gdk.Display.Get_Maximal_Cursor_Size give information about cursor sizes. -- On the X backend, support for RGBA cursors requires a sufficently new -- version of the X Render extension. -- Since: gtk+ 3.10 -- "display": the Gdk.Display.Gdk_Display for which the cursor will be -- created -- "surface": the cairo image surface containing the cursor pixel data -- "x": the horizontal offset of the "hotspot" of the cursor -- "y": the vertical offset of the "hotspot" of the cursor function Gdk_Cursor_New_From_Surface (Display : not null access Gdk.Display.Gdk_Display_Record'Class; Surface : Cairo.Cairo_Surface; X : Gdouble; Y : Gdouble) return Gdk_Cursor; -- Creates a new cursor from a cairo image surface. -- Not all GDK backends support RGBA cursors. If they are not supported, a -- monochrome approximation will be displayed. The functions -- Gdk.Display.Supports_Cursor_Alpha and Gdk.Display.Supports_Cursor_Color -- can be used to determine whether RGBA cursors are supported; -- Gdk.Display.Get_Default_Cursor_Size and -- Gdk.Display.Get_Maximal_Cursor_Size give information about cursor sizes. -- On the X backend, support for RGBA cursors requires a sufficently new -- version of the X Render extension. -- Since: gtk+ 3.10 -- "display": the Gdk.Display.Gdk_Display for which the cursor will be -- created -- "surface": the cairo image surface containing the cursor pixel data -- "x": the horizontal offset of the "hotspot" of the cursor -- "y": the vertical offset of the "hotspot" of the cursor function Get_Type return Glib.GType; pragma Import (C, Get_Type, "gdk_cursor_get_type"); ------------- -- Methods -- ------------- function Get_Cursor_Type (Self : Gdk.Gdk_Cursor) return Gdk_Cursor_Type; pragma Import (C, Get_Cursor_Type, "gdk_cursor_get_cursor_type"); -- Returns the cursor type for this cursor. -- Since: gtk+ 2.22 function Get_Display (Self : Gdk.Gdk_Cursor) return Gdk.Display.Gdk_Display; -- Returns the display on which the Gdk.Gdk_Cursor is defined. -- Since: gtk+ 2.2 procedure Get_Surface (Self : Gdk.Gdk_Cursor; X_Hot : out Gdouble; Y_Hot : out Gdouble; Surface : out Cairo.Cairo_Surface); -- Returns a cairo image surface with the image used to display the -- cursor. -- Note that depending on the capabilities of the windowing system and on -- the cursor, GDK may not be able to obtain the image data. In this case, -- null is returned. -- Since: gtk+ 3.10 -- "x_hot": Location to store the hotspot x position, or null -- "y_hot": Location to store the hotspot y position, or null ---------------------- -- GtkAda additions -- ---------------------- procedure Ref (Self : Gdk.Gdk_Cursor); pragma Import (C, Ref, "g_object_ref"); procedure Unref (Self : Gdk.Gdk_Cursor); pragma Import (C, Unref, "g_object_unref"); ---------------- -- Properties -- ---------------- -- The following properties are defined for this widget. See -- Glib.Properties for more information on properties) Cursor_Type_Property : constant Glib.Properties.Property_Boxed; -- Type: Cursor_Type Display_Property : constant Glib.Properties.Property_Boxed; -- Type: Display private Display_Property : constant Glib.Properties.Property_Boxed := Glib.Properties.Build ("display"); Cursor_Type_Property : constant Glib.Properties.Property_Boxed := Glib.Properties.Build ("cursor-type"); end Gdk.Cursor; gtkada-24.0.0/src/generated/gdk-device.adb000066400000000000000000000506211446021174000202320ustar00rootroot00000000000000------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ pragma Style_Checks (Off); pragma Warnings (Off, "*is already use-visible*"); with Ada.Unchecked_Conversion; with Glib.Type_Conversion_Hooks; use Glib.Type_Conversion_Hooks; with Glib.Values; use Glib.Values; with Gtk.Arguments; use Gtk.Arguments; with Gtkada.Bindings; use Gtkada.Bindings; with Gtkada.Types; use Gtkada.Types; package body Gdk.Device is function Convert (R : Gdk.Device.Gdk_Device) return System.Address is begin return Get_Object (R); end Convert; function Convert (R : System.Address) return Gdk.Device.Gdk_Device is Stub : Gdk.Device.Gdk_Device_Record;begin return Gdk.Device.Gdk_Device (Glib.Object.Get_User_Data (R, Stub)); end Convert; procedure Set_Source_Device (Event : Gdk.Event.Gdk_Event; Device : not null access Gdk_Device_Record) is procedure Internal (Event : Gdk.Event.Gdk_Event; D : System.Address); pragma Import (C, Internal, "gdk_event_set_source_device"); begin Internal (Event, Get_Object (Device)); end Set_Source_Device; procedure Set_Device (Event : Gdk.Event.Gdk_Event; Device : not null access Gdk_Device_Record) is procedure Internal (Event : Gdk.Event.Gdk_Event; D : System.Address); pragma Import (C, Internal, "gdk_event_set_device"); begin Internal (Event, Get_Object (Device)); end Set_Device; procedure Get_Window_At_Position (Self : not null access Gdk_Device_Record; Win_X : out Gint; Win_Y : out Gint; Window : out Gdk.Gdk_Window) is function Internal (Self : System.Address; Acc_Win_X : access Gint; Acc_Win_Y : access Gint) return Gdk.Gdk_Window; pragma Import (C, Internal, "gdk_device_get_window_at_position"); Acc_Win_X : aliased Gint; Acc_Win_Y : aliased Gint; begin Window := Internal (Get_Object (Self), Acc_Win_X'Access, Acc_Win_Y'Access); Win_X := Acc_Win_X; Win_Y := Acc_Win_Y; end Get_Window_At_Position; package Type_Conversion_Gdk_Device is new Glib.Type_Conversion_Hooks.Hook_Registrator (Get_Type'Access, Gdk_Device_Record); pragma Unreferenced (Type_Conversion_Gdk_Device); --------------------------- -- Get_Associated_Device -- --------------------------- function Get_Associated_Device (Self : not null access Gdk_Device_Record) return Gdk_Device is function Internal (Self : System.Address) return System.Address; pragma Import (C, Internal, "gdk_device_get_associated_device"); Stub_Gdk_Device : Gdk_Device_Record; begin return Gdk.Device.Gdk_Device (Get_User_Data (Internal (Get_Object (Self)), Stub_Gdk_Device)); end Get_Associated_Device; -------------- -- Get_Axes -- -------------- function Get_Axes (Self : not null access Gdk_Device_Record) return Gdk_Axis_Flags is function Internal (Self : System.Address) return Gdk_Axis_Flags; pragma Import (C, Internal, "gdk_device_get_axes"); begin return Internal (Get_Object (Self)); end Get_Axes; ------------------ -- Get_Axis_Use -- ------------------ function Get_Axis_Use (Self : not null access Gdk_Device_Record; Index : Guint) return Gdk_Axis_Use is function Internal (Self : System.Address; Index : Guint) return Gdk_Axis_Use; pragma Import (C, Internal, "gdk_device_get_axis_use"); begin return Internal (Get_Object (Self), Index); end Get_Axis_Use; --------------------- -- Get_Device_Type -- --------------------- function Get_Device_Type (Self : not null access Gdk_Device_Record) return Gdk_Device_Type is function Internal (Self : System.Address) return Gdk_Device_Type; pragma Import (C, Internal, "gdk_device_get_device_type"); begin return Internal (Get_Object (Self)); end Get_Device_Type; ----------------- -- Get_Display -- ----------------- function Get_Display (Self : not null access Gdk_Device_Record) return Gdk.Display.Gdk_Display is function Internal (Self : System.Address) return System.Address; pragma Import (C, Internal, "gdk_device_get_display"); Stub_Gdk_Display : Gdk.Display.Gdk_Display_Record; begin return Gdk.Display.Gdk_Display (Get_User_Data (Internal (Get_Object (Self)), Stub_Gdk_Display)); end Get_Display; -------------------- -- Get_Has_Cursor -- -------------------- function Get_Has_Cursor (Self : not null access Gdk_Device_Record) return Boolean is function Internal (Self : System.Address) return Glib.Gboolean; pragma Import (C, Internal, "gdk_device_get_has_cursor"); begin return Internal (Get_Object (Self)) /= 0; end Get_Has_Cursor; --------------------------- -- Get_Last_Event_Window -- --------------------------- function Get_Last_Event_Window (Self : not null access Gdk_Device_Record) return Gdk.Gdk_Window is function Internal (Self : System.Address) return Gdk.Gdk_Window; pragma Import (C, Internal, "gdk_device_get_last_event_window"); begin return Internal (Get_Object (Self)); end Get_Last_Event_Window; -------------- -- Get_Mode -- -------------- function Get_Mode (Self : not null access Gdk_Device_Record) return Gdk_Input_Mode is function Internal (Self : System.Address) return Gdk_Input_Mode; pragma Import (C, Internal, "gdk_device_get_mode"); begin return Internal (Get_Object (Self)); end Get_Mode; ---------------- -- Get_N_Axes -- ---------------- function Get_N_Axes (Self : not null access Gdk_Device_Record) return Glib.Gint is function Internal (Self : System.Address) return Glib.Gint; pragma Import (C, Internal, "gdk_device_get_n_axes"); begin return Internal (Get_Object (Self)); end Get_N_Axes; ---------------- -- Get_N_Keys -- ---------------- function Get_N_Keys (Self : not null access Gdk_Device_Record) return Glib.Gint is function Internal (Self : System.Address) return Glib.Gint; pragma Import (C, Internal, "gdk_device_get_n_keys"); begin return Internal (Get_Object (Self)); end Get_N_Keys; -------------- -- Get_Name -- -------------- function Get_Name (Self : not null access Gdk_Device_Record) return UTF8_String is function Internal (Self : System.Address) return Gtkada.Types.Chars_Ptr; pragma Import (C, Internal, "gdk_device_get_name"); begin return Gtkada.Bindings.Value_Allowing_Null (Internal (Get_Object (Self))); end Get_Name; ------------------------- -- Get_Position_Double -- ------------------------- procedure Get_Position_Double (Self : not null access Gdk_Device_Record; Screen : out Gdk.Screen.Gdk_Screen; X : out Gdouble; Y : out Gdouble) is procedure Internal (Self : System.Address; Screen : out System.Address; X : out Gdouble; Y : out Gdouble); pragma Import (C, Internal, "gdk_device_get_position_double"); Tmp_Screen : aliased System.Address; Stub_Gdk_Screen : Gdk.Screen.Gdk_Screen_Record; begin Internal (Get_Object (Self), Tmp_Screen, X, Y); Screen := Gdk.Screen.Gdk_Screen (Get_User_Data (Tmp_Screen, Stub_Gdk_Screen)); end Get_Position_Double; -------------------- -- Get_Product_Id -- -------------------- function Get_Product_Id (Self : not null access Gdk_Device_Record) return UTF8_String is function Internal (Self : System.Address) return Gtkada.Types.Chars_Ptr; pragma Import (C, Internal, "gdk_device_get_product_id"); begin return Gtkada.Bindings.Value_Allowing_Null (Internal (Get_Object (Self))); end Get_Product_Id; -------------- -- Get_Seat -- -------------- function Get_Seat (Self : not null access Gdk_Device_Record) return Glib.Object.GObject is function Internal (Self : System.Address) return System.Address; pragma Import (C, Internal, "gdk_device_get_seat"); Stub_GObject : Glib.Object.GObject_Record; begin return Get_User_Data (Internal (Get_Object (Self)), Stub_GObject); end Get_Seat; ---------------- -- Get_Source -- ---------------- function Get_Source (Self : not null access Gdk_Device_Record) return Gdk_Input_Source is function Internal (Self : System.Address) return Gdk_Input_Source; pragma Import (C, Internal, "gdk_device_get_source"); begin return Internal (Get_Object (Self)); end Get_Source; --------------- -- Get_State -- --------------- procedure Get_State (Self : not null access Gdk_Device_Record; Window : Gdk.Gdk_Window; Axes : Gdouble_Array; Mask : out Gdk.Types.Gdk_Modifier_Type) is procedure Internal (Self : System.Address; Window : Gdk.Gdk_Window; Axes : System.Address; Mask : out Gdk.Types.Gdk_Modifier_Type); pragma Import (C, Internal, "gdk_device_get_state"); begin Internal (Get_Object (Self), Window, Axes (Axes'First)'Address, Mask); end Get_State; ------------------- -- Get_Vendor_Id -- ------------------- function Get_Vendor_Id (Self : not null access Gdk_Device_Record) return UTF8_String is function Internal (Self : System.Address) return Gtkada.Types.Chars_Ptr; pragma Import (C, Internal, "gdk_device_get_vendor_id"); begin return Gtkada.Bindings.Value_Allowing_Null (Internal (Get_Object (Self))); end Get_Vendor_Id; ----------------------------------- -- Get_Window_At_Position_Double -- ----------------------------------- function Get_Window_At_Position_Double (Self : not null access Gdk_Device_Record; Win_X : access Gdouble; Win_Y : access Gdouble) return Gdk.Gdk_Window is function Internal (Self : System.Address; Acc_Win_X : access Gdouble; Acc_Win_Y : access Gdouble) return Gdk.Gdk_Window; pragma Import (C, Internal, "gdk_device_get_window_at_position_double"); Acc_Win_X : aliased Gdouble; Acc_Win_Y : aliased Gdouble; Tmp_Return : Gdk.Gdk_Window; begin Tmp_Return := Internal (Get_Object (Self), Acc_Win_X'Access, Acc_Win_Y'Access); if Win_X /= null then Win_X.all := Acc_Win_X; end if; if Win_Y /= null then Win_Y.all := Acc_Win_Y; end if; return Tmp_Return; end Get_Window_At_Position_Double; ---------- -- Grab -- ---------- function Grab (Self : not null access Gdk_Device_Record; Window : Gdk.Gdk_Window; Grab_Ownership : Gdk_Grab_Ownership; Owner_Events : Boolean; Event_Mask : Gdk.Event.Gdk_Event_Mask; Cursor : Gdk.Gdk_Cursor; Time : Guint32) return Gdk_Grab_Status is function Internal (Self : System.Address; Window : Gdk.Gdk_Window; Grab_Ownership : Gdk_Grab_Ownership; Owner_Events : Glib.Gboolean; Event_Mask : Gdk.Event.Gdk_Event_Mask; Cursor : Gdk.Gdk_Cursor; Time : Guint32) return Gdk_Grab_Status; pragma Import (C, Internal, "gdk_device_grab"); begin return Internal (Get_Object (Self), Window, Grab_Ownership, Boolean'Pos (Owner_Events), Event_Mask, Cursor, Time); end Grab; ------------------ -- Set_Axis_Use -- ------------------ procedure Set_Axis_Use (Self : not null access Gdk_Device_Record; Index : Guint; GUse : Gdk_Axis_Use) is procedure Internal (Self : System.Address; Index : Guint; GUse : Gdk_Axis_Use); pragma Import (C, Internal, "gdk_device_set_axis_use"); begin Internal (Get_Object (Self), Index, GUse); end Set_Axis_Use; ------------- -- Set_Key -- ------------- procedure Set_Key (Self : not null access Gdk_Device_Record; Index : Guint; Keyval : Guint; Modifiers : Gdk.Types.Gdk_Modifier_Type) is procedure Internal (Self : System.Address; Index : Guint; Keyval : Guint; Modifiers : Gdk.Types.Gdk_Modifier_Type); pragma Import (C, Internal, "gdk_device_set_key"); begin Internal (Get_Object (Self), Index, Keyval, Modifiers); end Set_Key; -------------- -- Set_Mode -- -------------- function Set_Mode (Self : not null access Gdk_Device_Record; Mode : Gdk_Input_Mode) return Boolean is function Internal (Self : System.Address; Mode : Gdk_Input_Mode) return Glib.Gboolean; pragma Import (C, Internal, "gdk_device_set_mode"); begin return Internal (Get_Object (Self), Mode) /= 0; end Set_Mode; ------------ -- Ungrab -- ------------ procedure Ungrab (Self : not null access Gdk_Device_Record; Time : Guint32) is procedure Internal (Self : System.Address; Time : Guint32); pragma Import (C, Internal, "gdk_device_ungrab"); begin Internal (Get_Object (Self), Time); end Ungrab; ---------- -- Warp -- ---------- procedure Warp (Self : not null access Gdk_Device_Record; Screen : not null access Gdk.Screen.Gdk_Screen_Record'Class; X : Glib.Gint; Y : Glib.Gint) is procedure Internal (Self : System.Address; Screen : System.Address; X : Glib.Gint; Y : Glib.Gint); pragma Import (C, Internal, "gdk_device_warp"); begin Internal (Get_Object (Self), Get_Object (Screen), X, Y); end Warp; use type System.Address; function Cb_To_Address is new Ada.Unchecked_Conversion (Cb_Gdk_Device_GObject_Void, System.Address); function Address_To_Cb is new Ada.Unchecked_Conversion (System.Address, Cb_Gdk_Device_GObject_Void); function Cb_To_Address is new Ada.Unchecked_Conversion (Cb_GObject_GObject_Void, System.Address); function Address_To_Cb is new Ada.Unchecked_Conversion (System.Address, Cb_GObject_GObject_Void); procedure Connect (Object : access Gdk_Device_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_Gdk_Device_GObject_Void; After : Boolean); procedure Connect_Slot (Object : access Gdk_Device_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_GObject_GObject_Void; After : Boolean; Slot : access Glib.Object.GObject_Record'Class := null); procedure Marsh_GObject_GObject_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address); pragma Convention (C, Marsh_GObject_GObject_Void); procedure Marsh_Gdk_Device_GObject_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address); pragma Convention (C, Marsh_Gdk_Device_GObject_Void); ------------- -- Connect -- ------------- procedure Connect (Object : access Gdk_Device_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_Gdk_Device_GObject_Void; After : Boolean) is begin Unchecked_Do_Signal_Connect (Object => Object, C_Name => C_Name, Marshaller => Marsh_Gdk_Device_GObject_Void'Access, Handler => Cb_To_Address (Handler),-- Set in the closure After => After); end Connect; ------------------ -- Connect_Slot -- ------------------ procedure Connect_Slot (Object : access Gdk_Device_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_GObject_GObject_Void; After : Boolean; Slot : access Glib.Object.GObject_Record'Class := null) is begin Unchecked_Do_Signal_Connect (Object => Object, C_Name => C_Name, Marshaller => Marsh_GObject_GObject_Void'Access, Handler => Cb_To_Address (Handler),-- Set in the closure Slot_Object => Slot, After => After); end Connect_Slot; -------------------------------- -- Marsh_GObject_GObject_Void -- -------------------------------- procedure Marsh_GObject_GObject_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address) is pragma Unreferenced (Return_Value, N_Params, Invocation_Hint, User_Data); H : constant Cb_GObject_GObject_Void := Address_To_Cb (Get_Callback (Closure)); Obj : constant Glib.Object.GObject := Glib.Object.Convert (Get_Data (Closure)); begin H (Obj, Unchecked_To_Object (Params, 1)); exception when E : others => Process_Exception (E); end Marsh_GObject_GObject_Void; ----------------------------------- -- Marsh_Gdk_Device_GObject_Void -- ----------------------------------- procedure Marsh_Gdk_Device_GObject_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address) is pragma Unreferenced (Return_Value, N_Params, Invocation_Hint, User_Data); H : constant Cb_Gdk_Device_GObject_Void := Address_To_Cb (Get_Callback (Closure)); Obj : constant Gdk_Device := Gdk_Device (Unchecked_To_Object (Params, 0)); begin H (Obj, Unchecked_To_Object (Params, 1)); exception when E : others => Process_Exception (E); end Marsh_Gdk_Device_GObject_Void; --------------------- -- On_Tool_Changed -- --------------------- procedure On_Tool_Changed (Self : not null access Gdk_Device_Record; Call : Cb_Gdk_Device_GObject_Void; After : Boolean := False) is begin Connect (Self, "tool-changed" & ASCII.NUL, Call, After); end On_Tool_Changed; --------------------- -- On_Tool_Changed -- --------------------- procedure On_Tool_Changed (Self : not null access Gdk_Device_Record; Call : Cb_GObject_GObject_Void; Slot : not null access Glib.Object.GObject_Record'Class; After : Boolean := False) is begin Connect_Slot (Self, "tool-changed" & ASCII.NUL, Call, After, Slot); end On_Tool_Changed; end Gdk.Device; gtkada-24.0.0/src/generated/gdk-device.ads000066400000000000000000000560461446021174000202620ustar00rootroot00000000000000------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ -- -- The Gdk.Device.Gdk_Device object represents a single input device, such as -- a keyboard, a mouse, a touchpad, etc. -- -- See the Gdk.Device_Manager.Gdk_Device_Manager documentation for more -- information about the various kinds of master and slave devices, and their -- relationships. -- -- pragma Warnings (Off, "*is already use-visible*"); with Gdk.Display; use Gdk.Display; with Gdk.Event; use Gdk.Event; with Gdk.Screen; use Gdk.Screen; with Gdk.Types; use Gdk.Types; with Glib; use Glib; with Glib.Generic_Properties; use Glib.Generic_Properties; with Glib.Glist; use Glib.Glist; with Glib.Object; use Glib.Object; with Glib.Properties; use Glib.Properties; package Gdk.Device is type Gdk_Device_Record is new GObject_Record with null record; type Gdk_Device is access all Gdk_Device_Record'Class; type Gdk_Device_Type is ( Gdk_Device_Type_Master, Gdk_Device_Type_Slave, Gdk_Device_Type_Floating); pragma Convention (C, Gdk_Device_Type); -- Indicates the device type. See [above][GdkDeviceManager.description] -- for more information about the meaning of these device types. type Gdk_Axis_Flags is mod 2 ** Integer'Size; pragma Convention (C, Gdk_Axis_Flags); -- Flags describing the current capabilities of a device/tool. Gdk_Axis_Flag_X : constant Gdk_Axis_Flags := 2; Gdk_Axis_Flag_Y : constant Gdk_Axis_Flags := 4; Gdk_Axis_Flag_Pressure : constant Gdk_Axis_Flags := 8; Gdk_Axis_Flag_Xtilt : constant Gdk_Axis_Flags := 16; Gdk_Axis_Flag_Ytilt : constant Gdk_Axis_Flags := 32; Gdk_Axis_Flag_Wheel : constant Gdk_Axis_Flags := 64; Gdk_Axis_Flag_Distance : constant Gdk_Axis_Flags := 128; Gdk_Axis_Flag_Rotation : constant Gdk_Axis_Flags := 256; Gdk_Axis_Flag_Slider : constant Gdk_Axis_Flags := 512; function Convert (R : Gdk.Device.Gdk_Device) return System.Address; function Convert (R : System.Address) return Gdk.Device.Gdk_Device; package Device_List is new Generic_List (Gdk.Device.Gdk_Device); ---------------------------- -- Enumeration Properties -- ---------------------------- package Gdk_Device_Type_Properties is new Generic_Internal_Discrete_Property (Gdk_Device_Type); type Property_Gdk_Device_Type is new Gdk_Device_Type_Properties.Property; package Gdk_Axis_Flags_Properties is new Generic_Internal_Discrete_Property (Gdk_Axis_Flags); type Property_Gdk_Axis_Flags is new Gdk_Axis_Flags_Properties.Property; ------------------ -- Constructors -- ------------------ function Get_Type return Glib.GType; pragma Import (C, Get_Type, "gdk_device_get_type"); ------------- -- Methods -- ------------- function Get_Associated_Device (Self : not null access Gdk_Device_Record) return Gdk_Device; -- Returns the associated device to Device, if Device is of type -- Gdk.Device.Gdk_Device_Type_Master, it will return the paired pointer or -- keyboard. -- If Device is of type Gdk.Device.Gdk_Device_Type_Slave, it will return -- the master device to which Device is attached to. -- If Device is of type Gdk.Device.Gdk_Device_Type_Floating, null will be -- returned, as there is no associated device. -- Since: gtk+ 3.0 function Get_Axes (Self : not null access Gdk_Device_Record) return Gdk_Axis_Flags; -- Returns the axes currently available on the device. -- Since: gtk+ 3.22 function Get_Axis_Use (Self : not null access Gdk_Device_Record; Index : Guint) return Gdk_Axis_Use; -- Returns the axis use for Index_. -- Since: gtk+ 2.20 -- "index_": the index of the axis. procedure Set_Axis_Use (Self : not null access Gdk_Device_Record; Index : Guint; GUse : Gdk_Axis_Use); -- Specifies how an axis of a device is used. -- "index_": the index of the axis -- "use": specifies how the axis is used function Get_Device_Type (Self : not null access Gdk_Device_Record) return Gdk_Device_Type; -- Returns the device type for Device. -- Since: gtk+ 3.0 function Get_Display (Self : not null access Gdk_Device_Record) return Gdk.Display.Gdk_Display; -- Returns the Gdk.Display.Gdk_Display to which Device pertains. -- Since: gtk+ 3.0 function Get_Has_Cursor (Self : not null access Gdk_Device_Record) return Boolean; -- Determines whether the pointer follows device motion. This is not -- meaningful for keyboard devices, which don't have a pointer. -- Since: gtk+ 2.20 function Get_Last_Event_Window (Self : not null access Gdk_Device_Record) return Gdk.Gdk_Window; -- Gets information about which window the given pointer device is in, -- based on events that have been received so far from the display server. -- If another application has a pointer grab, or this application has a -- grab with owner_events = False, null may be returned even if the pointer -- is physically over one of this application's windows. -- Since: gtk+ 3.12 function Get_Mode (Self : not null access Gdk_Device_Record) return Gdk_Input_Mode; -- Determines the mode of the device. -- Since: gtk+ 2.20 function Set_Mode (Self : not null access Gdk_Device_Record; Mode : Gdk_Input_Mode) return Boolean; -- Sets a the mode of an input device. The mode controls if the device is -- active and whether the device's range is mapped to the entire screen or -- to a single window. -- Note: This is only meaningful for floating devices, master devices (and -- slaves connected to these) drive the pointer cursor, which is not -- limited by the input mode. -- "mode": the input mode. function Get_N_Axes (Self : not null access Gdk_Device_Record) return Glib.Gint; -- Returns the number of axes the device currently has. -- Since: gtk+ 3.0 function Get_N_Keys (Self : not null access Gdk_Device_Record) return Glib.Gint; -- Returns the number of keys the device currently has. -- Since: gtk+ 2.24 function Get_Name (Self : not null access Gdk_Device_Record) return UTF8_String; -- Determines the name of the device. -- Since: gtk+ 2.20 procedure Get_Position_Double (Self : not null access Gdk_Device_Record; Screen : out Gdk.Screen.Gdk_Screen; X : out Gdouble; Y : out Gdouble); -- Gets the current location of Device in double precision. As a slave -- device's coordinates are those of its master pointer, this function may -- not be called on devices of type Gdk.Device.Gdk_Device_Type_Slave, -- unless there is an ongoing grab on them. See Gdk.Device.Grab. -- Since: gtk+ 3.10 -- "screen": location to store the Gdk.Screen.Gdk_Screen the Device is on, -- or null. -- "x": location to store root window X coordinate of Device, or null. -- "y": location to store root window Y coordinate of Device, or null. function Get_Product_Id (Self : not null access Gdk_Device_Record) return UTF8_String; -- Returns the product ID of this device, or null if this information -- couldn't be obtained. This ID is retrieved from the device, and is thus -- constant for it. See Gdk.Device.Get_Vendor_Id for more information. -- Since: gtk+ 3.16 function Get_Seat (Self : not null access Gdk_Device_Record) return Glib.Object.GObject; -- Returns the Gdk.Seat.Gdk_Seat the device belongs to. -- Since: gtk+ 3.20 function Get_Source (Self : not null access Gdk_Device_Record) return Gdk_Input_Source; -- Determines the type of the device. -- Since: gtk+ 2.20 procedure Get_State (Self : not null access Gdk_Device_Record; Window : Gdk.Gdk_Window; Axes : Gdouble_Array; Mask : out Gdk.Types.Gdk_Modifier_Type); -- Gets the current state of a pointer device relative to Window. As a -- slave device's coordinates are those of its master pointer, this -- function may not be called on devices of type -- Gdk.Device.Gdk_Device_Type_Slave, unless there is an ongoing grab on -- them. See Gdk.Device.Grab. -- "window": a Gdk.Gdk_Window. -- "axes": an array of doubles to store the values of the axes of Device -- in, or null. -- "mask": location to store the modifiers, or null. function Get_Vendor_Id (Self : not null access Gdk_Device_Record) return UTF8_String; -- Returns the vendor ID of this device, or null if this information -- couldn't be obtained. This ID is retrieved from the device, and is thus -- constant for it. -- This function, together with Gdk.Device.Get_Product_Id, can be used to -- eg. compose Gsettings.Gsettings paths to store settings for this device. -- |[ static GSettings * get_device_settings -- (GdkDevice *device) { const gchar *vendor, *product; GSettings -- *settings; GdkDevice *device; gchar *path; -- vendor = gdk_device_get_vendor_id (device); product = -- gdk_device_get_product_id (device); -- path = g_strdup_printf ("/org/example/app/devices/%s:%s/", vendor, -- product); settings = g_settings_new_with_path (DEVICE_SCHEMA, path); -- g_free (path); -- return settings; } ]| -- Since: gtk+ 3.16 function Get_Window_At_Position_Double (Self : not null access Gdk_Device_Record; Win_X : access Gdouble; Win_Y : access Gdouble) return Gdk.Gdk_Window; -- Obtains the window underneath Device, returning the location of the -- device in Win_X and Win_Y in double precision. Returns null if the -- window tree under Device is not known to GDK (for example, belongs to -- another application). -- As a slave device coordinates are those of its master pointer, This -- function may not be called on devices of type -- Gdk.Device.Gdk_Device_Type_Slave, unless there is an ongoing grab on -- them, see Gdk.Device.Grab. -- Since: gtk+ 3.0 -- "win_x": return location for the X coordinate of the device location, -- relative to the window origin, or null. -- "win_y": return location for the Y coordinate of the device location, -- relative to the window origin, or null. function Grab (Self : not null access Gdk_Device_Record; Window : Gdk.Gdk_Window; Grab_Ownership : Gdk_Grab_Ownership; Owner_Events : Boolean; Event_Mask : Gdk.Event.Gdk_Event_Mask; Cursor : Gdk.Gdk_Cursor; Time : Guint32) return Gdk_Grab_Status; pragma Obsolescent (Grab); -- Grabs the device so that all events coming from this device are passed -- to this application until the device is ungrabbed with -- Gdk.Device.Ungrab, or the window becomes unviewable. This overrides any -- previous grab on the device by this client. -- Note that Device and Window need to be on the same display. -- Device grabs are used for operations which need complete control over -- the given device events (either pointer or keyboard). For example in -- GTK+ this is used for Drag and Drop operations, popup menus and such. -- Note that if the event mask of an X window has selected both button -- press and button release events, then a button press event will cause an -- automatic pointer grab until the button is released. X does this -- automatically since most applications expect to receive button press and -- release events in pairs. It is equivalent to a pointer grab on the -- window with Owner_Events set to True. -- If you set up anything at the time you take the grab that needs to be -- cleaned up when the grab ends, you should handle the -- Gdk.Event.Gdk_Event_Grab_Broken events that are emitted when the grab -- ends unvoluntarily. -- Since: gtk+ 3.0 -- Deprecated since 3.20., 1 -- "window": the Gdk.Gdk_Window which will own the grab (the grab window) -- "grab_ownership": specifies the grab ownership. -- "owner_events": if False then all device events are reported with -- respect to Window and are only reported if selected by Event_Mask. If -- True then pointer events for this application are reported as normal, -- but pointer events outside this application are reported with respect to -- Window and only if selected by Event_Mask. In either mode, unreported -- events are discarded. -- "event_mask": specifies the event mask, which is used in accordance -- with Owner_Events. -- "cursor": the cursor to display while the grab is active if the device -- is a pointer. If this is null then the normal cursors are used for -- Window and its descendants, and the cursor for Window is used elsewhere. -- "time_": the timestamp of the event which led to this pointer grab. -- This usually comes from the Gdk.Event.Gdk_Event struct, though -- GDK_CURRENT_TIME can be used if the time isn't known. procedure Set_Key (Self : not null access Gdk_Device_Record; Index : Guint; Keyval : Guint; Modifiers : Gdk.Types.Gdk_Modifier_Type); -- Specifies the X key event to generate when a macro button of a device -- is pressed. -- "index_": the index of the macro button to set -- "keyval": the keyval to generate -- "modifiers": the modifiers to set procedure Ungrab (Self : not null access Gdk_Device_Record; Time : Guint32); pragma Obsolescent (Ungrab); -- Release any grab on Device. -- Since: gtk+ 3.0 -- Deprecated since 3.20., 1 -- "time_": a timestap (e.g. GDK_CURRENT_TIME). procedure Warp (Self : not null access Gdk_Device_Record; Screen : not null access Gdk.Screen.Gdk_Screen_Record'Class; X : Glib.Gint; Y : Glib.Gint); -- Warps Device in Display to the point X,Y on the screen Screen, unless -- the device is confined to a window by a grab, in which case it will be -- moved as far as allowed by the grab. Warping the pointer creates events -- as if the user had moved the mouse instantaneously to the destination. -- Note that the pointer should normally be under the control of the user. -- This function was added to cover some rare use cases like keyboard -- navigation support for the color picker in the -- Gtk.Color_Selection_Dialog.Gtk_Color_Selection_Dialog. -- Since: gtk+ 3.0 -- "screen": the screen to warp Device to. -- "x": the X coordinate of the destination. -- "y": the Y coordinate of the destination. ---------------------- -- GtkAda additions -- ---------------------- procedure Get_Window_At_Position (Self : not null access Gdk_Device_Record; Win_X : out Gint; Win_Y : out Gint; Window : out Gdk.Gdk_Window); -- Obtains the window underneath Device, returning the location of the -- device in Win_X and Win_Y. Returns null if the window tree under Device -- is not known to GDK (for example, belongs to another application). -- As a slave device coordinates are those of its master pointer, This -- function may not be called on devices of type -- Gdk.Device.Gdk_Device_Type_Slave, unless there is an ongoing grab on -- them, see Gdk.Device.Grab. -- Since: gtk+ 3.0 -- "win_x": return location for the X coordinate of the device location, -- relative to the window origin, or null. -- "win_y": return location for the Y coordinate of the device location, -- relative to the window origin, or null. procedure Set_Device (Event : Gdk.Event.Gdk_Event; Device : not null access Gdk_Device_Record); -- Sets the device for Event to Device. The event must -- have been allocated by GTK+, for instance, by gdk_event_copy(). procedure Set_Source_Device (Event : Gdk.Event.Gdk_Event; Device : not null access Gdk_Device_Record); -- Sets the slave device for Event to Device. -- The event must have been allocated by GTK+, -- for instance by gdk_event_copy(). ---------------- -- Properties -- ---------------- -- The following properties are defined for this widget. See -- Glib.Properties for more information on properties) Associated_Device_Property : constant Glib.Properties.Property_Boxed; -- Type: Device -- Associated pointer or keyboard with this device, if any. Devices of -- type GDK_DEVICE_TYPE_MASTER always come in keyboard/pointer pairs. Other -- device types will have a null associated device. Axes_Property : constant Glib.Properties.Property_Boxed; -- Type: Axis_Flags -- The axes currently available for this device. Device_Manager_Property : constant Glib.Properties.Property_Boxed; -- Type: Device_Manager -- The Gdk.Device_Manager.Gdk_Device_Manager the Gdk.Device.Gdk_Device -- pertains to. Display_Property : constant Glib.Properties.Property_Boxed; -- Type: Display -- The Gdk.Display.Gdk_Display the Gdk.Device.Gdk_Device pertains to. Has_Cursor_Property : constant Glib.Properties.Property_Boolean; -- Whether the device is represented by a cursor on the screen. Devices of -- type Gdk.Device.Gdk_Device_Type_Master will have True here. Input_Mode_Property : constant Glib.Properties.Property_Boxed; -- Type: Input_Mode Input_Source_Property : constant Glib.Properties.Property_Boxed; -- Type: Input_Source -- Source type for the device. N_Axes_Property : constant Glib.Properties.Property_Uint; -- Number of axes in the device. Name_Property : constant Glib.Properties.Property_String; -- The device name. Num_Touches_Property : constant Glib.Properties.Property_Uint; -- The maximal number of concurrent touches on a touch device. Will be 0 -- if the device is not a touch device or if the number of touches is -- unknown. Product_Id_Property : constant Glib.Properties.Property_String; -- Product ID of this device, see Gdk.Device.Get_Product_Id. Seat_Property : constant Glib.Properties.Property_Boxed; -- Type: Seat -- Gdk.Seat.Gdk_Seat of this device. The_Type_Property : constant Glib.Properties.Property_Boxed; -- Type: Device_Type -- Device role in the device manager. Tool_Property : constant Glib.Properties.Property_Boxed; -- Type: Device_Tool Vendor_Id_Property : constant Glib.Properties.Property_String; -- Vendor ID of this device, see Gdk.Device.Get_Vendor_Id. ------------- -- Signals -- ------------- Signal_Changed : constant Glib.Signal_Name := "changed"; -- The ::changed signal is emitted either when the Gdk.Device.Gdk_Device -- has changed the number of either axes or keys. For example In X this -- will normally happen when the slave device routing events through the -- master device changes (for example, user switches from the USB mouse to -- a tablet), in that case the master device will change to reflect the new -- slave device axes and keys. -- procedure Handler (Self : access Gdk_Device_Record'Class) type Cb_Gdk_Device_GObject_Void is not null access procedure (Self : access Gdk_Device_Record'Class; Tool : not null access Glib.Object.GObject_Record'Class); type Cb_GObject_GObject_Void is not null access procedure (Self : access Glib.Object.GObject_Record'Class; Tool : not null access Glib.Object.GObject_Record'Class); Signal_Tool_Changed : constant Glib.Signal_Name := "tool-changed"; procedure On_Tool_Changed (Self : not null access Gdk_Device_Record; Call : Cb_Gdk_Device_GObject_Void; After : Boolean := False); procedure On_Tool_Changed (Self : not null access Gdk_Device_Record; Call : Cb_GObject_GObject_Void; Slot : not null access Glib.Object.GObject_Record'Class; After : Boolean := False); -- The ::tool-changed signal is emitted on pen/eraser Gdk_Devices whenever -- tools enter or leave proximity. private Vendor_Id_Property : constant Glib.Properties.Property_String := Glib.Properties.Build ("vendor-id"); Tool_Property : constant Glib.Properties.Property_Boxed := Glib.Properties.Build ("tool"); The_Type_Property : constant Glib.Properties.Property_Boxed := Glib.Properties.Build ("type"); Seat_Property : constant Glib.Properties.Property_Boxed := Glib.Properties.Build ("seat"); Product_Id_Property : constant Glib.Properties.Property_String := Glib.Properties.Build ("product-id"); Num_Touches_Property : constant Glib.Properties.Property_Uint := Glib.Properties.Build ("num-touches"); Name_Property : constant Glib.Properties.Property_String := Glib.Properties.Build ("name"); N_Axes_Property : constant Glib.Properties.Property_Uint := Glib.Properties.Build ("n-axes"); Input_Source_Property : constant Glib.Properties.Property_Boxed := Glib.Properties.Build ("input-source"); Input_Mode_Property : constant Glib.Properties.Property_Boxed := Glib.Properties.Build ("input-mode"); Has_Cursor_Property : constant Glib.Properties.Property_Boolean := Glib.Properties.Build ("has-cursor"); Display_Property : constant Glib.Properties.Property_Boxed := Glib.Properties.Build ("display"); Device_Manager_Property : constant Glib.Properties.Property_Boxed := Glib.Properties.Build ("device-manager"); Axes_Property : constant Glib.Properties.Property_Boxed := Glib.Properties.Build ("axes"); Associated_Device_Property : constant Glib.Properties.Property_Boxed := Glib.Properties.Build ("associated-device"); end Gdk.Device; gtkada-24.0.0/src/generated/gdk-device_manager.adb000066400000000000000000000104661446021174000217270ustar00rootroot00000000000000------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ pragma Style_Checks (Off); pragma Warnings (Off, "*is already use-visible*"); with Glib.Type_Conversion_Hooks; use Glib.Type_Conversion_Hooks; package body Gdk.Device_Manager is function Get_Device_Manager (Self : not null access Gdk.Display.Gdk_Display_Record'Class) return Gdk.Device_Manager.Gdk_Device_Manager is function Internal (Self : System.Address) return System.Address; pragma Import (C, Internal, "gdk_display_get_device_manager"); Stub_Gdk_Device_Manager : Gdk.Device_Manager.Gdk_Device_Manager_Record; begin return Gdk.Device_Manager.Gdk_Device_Manager (Get_User_Data (Internal (Get_Object (Self)), Stub_Gdk_Device_Manager)); end Get_Device_Manager; package Type_Conversion_Gdk_Device_Manager is new Glib.Type_Conversion_Hooks.Hook_Registrator (Get_Type'Access, Gdk_Device_Manager_Record); pragma Unreferenced (Type_Conversion_Gdk_Device_Manager); ------------------------ -- Get_Client_Pointer -- ------------------------ function Get_Client_Pointer (Self : not null access Gdk_Device_Manager_Record) return Gdk.Device.Gdk_Device is function Internal (Self : System.Address) return System.Address; pragma Import (C, Internal, "gdk_device_manager_get_client_pointer"); Stub_Gdk_Device : Gdk.Device.Gdk_Device_Record; begin return Gdk.Device.Gdk_Device (Get_User_Data (Internal (Get_Object (Self)), Stub_Gdk_Device)); end Get_Client_Pointer; ----------------- -- Get_Display -- ----------------- function Get_Display (Self : not null access Gdk_Device_Manager_Record) return Gdk.Display.Gdk_Display is function Internal (Self : System.Address) return System.Address; pragma Import (C, Internal, "gdk_device_manager_get_display"); Stub_Gdk_Display : Gdk.Display.Gdk_Display_Record; begin return Gdk.Display.Gdk_Display (Get_User_Data (Internal (Get_Object (Self)), Stub_Gdk_Display)); end Get_Display; ------------------ -- List_Devices -- ------------------ function List_Devices (Self : not null access Gdk_Device_Manager_Record; The_Type : Gdk.Device.Gdk_Device_Type) return Gdk.Device.Device_List.Glist is function Internal (Self : System.Address; The_Type : Gdk.Device.Gdk_Device_Type) return System.Address; pragma Import (C, Internal, "gdk_device_manager_list_devices"); Tmp_Return : Gdk.Device.Device_List.Glist; begin Gdk.Device.Device_List.Set_Object (Tmp_Return, Internal (Get_Object (Self), The_Type)); return Tmp_Return; end List_Devices; end Gdk.Device_Manager; gtkada-24.0.0/src/generated/gdk-device_manager.ads000066400000000000000000000276761446021174000217630ustar00rootroot00000000000000------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ -- -- In addition to a single pointer and keyboard for user interface input, GDK -- contains support for a variety of input devices, including graphics -- tablets, touchscreens and multiple pointers/keyboards interacting -- simultaneously with the user interface. Such input devices often have -- additional features, such as sub-pixel positioning information and -- additional device-dependent information. -- -- In order to query the device hierarchy and be aware of changes in the -- device hierarchy (such as virtual devices being created or removed, or -- physical devices being plugged or unplugged), GDK provides -- Gdk.Device_Manager.Gdk_Device_Manager. -- -- By default, and if the platform supports it, GDK is aware of multiple -- keyboard/pointer pairs and multitouch devices. This behavior can be changed -- by calling gdk_disable_multidevice before Gdk.Display.Open. There should -- rarely be a need to do that though, since GDK defaults to a compatibility -- mode in which it will emit just one enter/leave event pair for all devices -- on a window. To enable per-device enter/leave events and other -- multi-pointer interaction features, Gdk.Window.Set_Support_Multidevice must -- be called on Gdk_Windows (or Gtk.Widget.Set_Support_Multidevice on -- widgets). window. See the Gdk.Window.Set_Support_Multidevice documentation -- for more information. -- -- On X11, multi-device support is implemented through XInput 2. Unless -- gdk_disable_multidevice is called, the XInput 2 -- Gdk.Device_Manager.Gdk_Device_Manager implementation will be used as the -- input source. Otherwise either the core or XInput 1 implementations will be -- used. -- -- For simple applications that don't have any special interest in input -- devices, the so-called "client pointer" provides a reasonable approximation -- to a simple setup with a single pointer and keyboard. The device that has -- been set as the client pointer can be accessed via -- Gdk.Device_Manager.Get_Client_Pointer. -- -- Conceptually, in multidevice mode there are 2 device types. Virtual -- devices (or master devices) are represented by the pointer cursors and -- keyboard foci that are seen on the screen. Physical devices (or slave -- devices) represent the hardware that is controlling the virtual devices, -- and thus have no visible cursor on the screen. -- -- Virtual devices are always paired, so there is a keyboard device for every -- pointer device. Associations between devices may be inspected through -- Gdk.Device.Get_Associated_Device. -- -- There may be several virtual devices, and several physical devices could -- be controlling each of these virtual devices. Physical devices may also be -- "floating", which means they are not attached to any virtual device. -- -- # Master and slave devices -- -- |[ carlosSacarino:~$ xinput list ⎡ Virtual core pointer id=2 [master -- pointer (3)] ⎜ ↳ Virtual core XTEST pointer id=4 [slave pointer (2)] ⎜ ↳ -- Wacom ISDv4 E6 Pen stylus id=10 [slave pointer (2)] ⎜ ↳ Wacom ISDv4 E6 -- Finger touch id=11 [slave pointer (2)] ⎜ ↳ SynPS/2 Synaptics TouchPad id=13 -- [slave pointer (2)] ⎜ ↳ TPPS/2 IBM TrackPoint id=14 [slave pointer (2)] ⎜ ↳ -- Wacom ISDv4 E6 Pen eraser id=16 [slave pointer (2)] ⎣ Virtual core keyboard -- id=3 [master keyboard (2)] ↳ Virtual core XTEST keyboard id=5 [slave -- keyboard (3)] ↳ Power Button id=6 [slave keyboard (3)] ↳ Video Bus id=7 -- [slave keyboard (3)] ↳ Sleep Button id=8 [slave keyboard (3)] ↳ Integrated -- Camera id=9 [slave keyboard (3)] ↳ AT Translated Set 2 keyboard id=12 -- [slave keyboard (3)] ↳ ThinkPad Extra Buttons id=15 [slave keyboard (3)] ]| -- -- By default, GDK will automatically listen for events coming from all -- master devices, setting the Gdk.Device.Gdk_Device for all events coming -- from input devices. Events containing device information are -- GDK_MOTION_NOTIFY, GDK_BUTTON_PRESS, GDK_2_BUTTON_PRESS, -- GDK_3_BUTTON_PRESS, GDK_BUTTON_RELEASE, GDK_SCROLL, GDK_KEY_PRESS, -- GDK_KEY_RELEASE, GDK_ENTER_NOTIFY, GDK_LEAVE_NOTIFY, GDK_FOCUS_CHANGE, -- GDK_PROXIMITY_IN, GDK_PROXIMITY_OUT, GDK_DRAG_ENTER, GDK_DRAG_LEAVE, -- GDK_DRAG_MOTION, GDK_DRAG_STATUS, GDK_DROP_START, GDK_DROP_FINISHED and -- GDK_GRAB_BROKEN. When dealing with an event on a master device, it is -- possible to get the source (slave) device that the event originated from -- via gdk_event_get_source_device. -- -- On a standard session, all physical devices are connected by default to -- the "Virtual Core Pointer/Keyboard" master devices, hence routing all -- events through these. This behavior is only modified by device grabs, where -- the slave device is temporarily detached for as long as the grab is held, -- and more permanently by user modifications to the device hierarchy. -- -- On certain application specific setups, it may make sense to detach a -- physical device from its master pointer, and mapping it to an specific -- window. This can be achieved by the combination of Gdk.Device.Grab and -- Gdk.Device.Set_Mode. -- -- In order to listen for events coming from devices other than a virtual -- device, Gdk.Window.Set_Device_Events must be called. Generally, this -- function can be used to modify the event mask for any given device. -- -- Input devices may also provide additional information besides X/Y. For -- example, graphics tablets may also provide pressure and X/Y tilt -- information. This information is device-dependent, and may be queried -- through gdk_device_get_axis. In multidevice mode, virtual devices will -- change axes in order to always represent the physical device that is -- routing events through it. Whenever the physical device changes, the -- Gdk.Device.Gdk_Device:n-axes property will be notified, and -- gdk_device_list_axes will return the new device axes. -- -- Devices may also have associated "keys" or macro buttons. Such keys can be -- globally set to map into normal X keyboard events. The mapping is set using -- Gdk.Device.Set_Key. -- -- In GTK+ 3.20, a new Gdk.Seat.Gdk_Seat object has been introduced that -- supersedes Gdk.Device_Manager.Gdk_Device_Manager and should be preferred in -- newly written code. -- -- pragma Warnings (Off, "*is already use-visible*"); with Gdk.Device; use Gdk.Device; with Gdk.Display; use Gdk.Display; with Glib; use Glib; with Glib.Object; use Glib.Object; with Glib.Properties; use Glib.Properties; package Gdk.Device_Manager is type Gdk_Device_Manager_Record is new GObject_Record with null record; type Gdk_Device_Manager is access all Gdk_Device_Manager_Record'Class; ------------------ -- Constructors -- ------------------ function Get_Type return Glib.GType; pragma Import (C, Get_Type, "gdk_device_manager_get_type"); ------------- -- Methods -- ------------- function Get_Client_Pointer (Self : not null access Gdk_Device_Manager_Record) return Gdk.Device.Gdk_Device; pragma Obsolescent (Get_Client_Pointer); -- Returns the client pointer, that is, the master pointer that acts as -- the core pointer for this application. In X11, window managers may -- change this depending on the interaction pattern under the presence of -- several pointers. -- You should use this function seldomly, only in code that isn't -- triggered by a Gdk.Event.Gdk_Event and there aren't other means to get a -- meaningful Gdk.Device.Gdk_Device to operate on. -- Since: gtk+ 3.0 -- Deprecated since 3.20, 1 function Get_Display (Self : not null access Gdk_Device_Manager_Record) return Gdk.Display.Gdk_Display; -- Gets the Gdk.Display.Gdk_Display associated to Device_Manager. -- Since: gtk+ 3.0 function List_Devices (Self : not null access Gdk_Device_Manager_Record; The_Type : Gdk.Device.Gdk_Device_Type) return Gdk.Device.Device_List.Glist; pragma Obsolescent (List_Devices); -- Returns the list of devices of type Type currently attached to -- Device_Manager. -- Since: gtk+ 3.0 -- Deprecated since 3.20, 1 -- "type": device type to get. ---------------------- -- GtkAda additions -- ---------------------- function Get_Device_Manager (Self : not null access Gdk.Display.Gdk_Display_Record'Class) return Gdk.Device_Manager.Gdk_Device_Manager; -- Returns the Gdk.Device_Manager.Gdk_Device_Manager associated to -- Display. -- Since: gtk+ 3.0 ---------------- -- Properties -- ---------------- -- The following properties are defined for this widget. See -- Glib.Properties for more information on properties) Display_Property : constant Glib.Properties.Property_Boxed; -- Type: Display ------------- -- Signals -- ------------- Signal_Device_Added : constant Glib.Signal_Name := "device-added"; -- The ::device-added signal is emitted either when a new master pointer -- is created, or when a slave (Hardware) input device is plugged in. -- procedure Handler -- (Self : access Gdk_Device_Manager_Record'Class; -- Device : Device) Signal_Device_Changed : constant Glib.Signal_Name := "device-changed"; -- The ::device-changed signal is emitted whenever a device has changed in -- the hierarchy, either slave devices being disconnected from their master -- device or connected to another one, or master devices being added or -- removed a slave device. -- -- If a slave device is detached from all master devices -- (gdk_device_get_associated_device returns null), its -- Gdk.Device.Gdk_Device_Type will change to -- Gdk.Device.Gdk_Device_Type_Floating, if it's attached, it will change to -- Gdk.Device.Gdk_Device_Type_Slave. -- procedure Handler -- (Self : access Gdk_Device_Manager_Record'Class; -- Device : Device) Signal_Device_Removed : constant Glib.Signal_Name := "device-removed"; -- The ::device-removed signal is emitted either when a master pointer is -- removed, or when a slave (Hardware) input device is unplugged. -- procedure Handler -- (Self : access Gdk_Device_Manager_Record'Class; -- Device : Device) private Display_Property : constant Glib.Properties.Property_Boxed := Glib.Properties.Build ("display"); end Gdk.Device_Manager; gtkada-24.0.0/src/generated/gdk-device_tool.adb000066400000000000000000000063431446021174000212710ustar00rootroot00000000000000------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ pragma Style_Checks (Off); pragma Warnings (Off, "*is already use-visible*"); with Glib.Type_Conversion_Hooks; use Glib.Type_Conversion_Hooks; package body Gdk.Device_Tool is package Type_Conversion_Gdk_Device_Tool is new Glib.Type_Conversion_Hooks.Hook_Registrator (Get_Type'Access, Gdk_Device_Tool_Record); pragma Unreferenced (Type_Conversion_Gdk_Device_Tool); --------------------- -- Get_Hardware_Id -- --------------------- function Get_Hardware_Id (Self : not null access Gdk_Device_Tool_Record) return Guint64 is function Internal (Self : System.Address) return Guint64; pragma Import (C, Internal, "gdk_device_tool_get_hardware_id"); begin return Internal (Get_Object (Self)); end Get_Hardware_Id; ---------------- -- Get_Serial -- ---------------- function Get_Serial (Self : not null access Gdk_Device_Tool_Record) return Guint64 is function Internal (Self : System.Address) return Guint64; pragma Import (C, Internal, "gdk_device_tool_get_serial"); begin return Internal (Get_Object (Self)); end Get_Serial; ------------------- -- Get_Tool_Type -- ------------------- function Get_Tool_Type (Self : not null access Gdk_Device_Tool_Record) return Gdk_Device_Tool_Type is function Internal (Self : System.Address) return Gdk_Device_Tool_Type; pragma Import (C, Internal, "gdk_device_tool_get_tool_type"); begin return Internal (Get_Object (Self)); end Get_Tool_Type; end Gdk.Device_Tool; gtkada-24.0.0/src/generated/gdk-device_tool.ads000066400000000000000000000123211446021174000213030ustar00rootroot00000000000000------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ pragma Warnings (Off, "*is already use-visible*"); with Glib; use Glib; with Glib.Generic_Properties; use Glib.Generic_Properties; with Glib.Object; use Glib.Object; with Glib.Properties; use Glib.Properties; package Gdk.Device_Tool is type Gdk_Device_Tool_Record is new GObject_Record with null record; type Gdk_Device_Tool is access all Gdk_Device_Tool_Record'Class; type Gdk_Device_Tool_Type is ( Gdk_Device_Tool_Type_Unknown, Gdk_Device_Tool_Type_Pen, Gdk_Device_Tool_Type_Eraser, Gdk_Device_Tool_Type_Brush, Gdk_Device_Tool_Type_Pencil, Gdk_Device_Tool_Type_Airbrush, Gdk_Device_Tool_Type_Mouse, Gdk_Device_Tool_Type_Lens); pragma Convention (C, Gdk_Device_Tool_Type); -- Indicates the specific type of tool being used being a tablet. Such as -- an airbrush, pencil, etc. ---------------------------- -- Enumeration Properties -- ---------------------------- package Gdk_Device_Tool_Type_Properties is new Generic_Internal_Discrete_Property (Gdk_Device_Tool_Type); type Property_Gdk_Device_Tool_Type is new Gdk_Device_Tool_Type_Properties.Property; ------------------ -- Constructors -- ------------------ function Get_Type return Glib.GType; pragma Import (C, Get_Type, "gdk_device_tool_get_type"); ------------- -- Methods -- ------------- function Get_Hardware_Id (Self : not null access Gdk_Device_Tool_Record) return Guint64; -- Gets the hardware ID of this tool, or 0 if it's not known. When -- non-zero, the identificator is unique for the given tool model, meaning -- that two identical tools will share the same Hardware_Id, but will have -- different serial numbers (see Gdk.Device_Tool.Get_Serial). -- This is a more concrete (and device specific) method to identify a -- Gdk.Device_Tool.Gdk_Device_Tool than Gdk.Device_Tool.Get_Tool_Type, as a -- tablet may support multiple devices with the same -- Gdk.Device_Tool.Gdk_Device_Tool_Type, but having different hardware -- identificators. -- Since: gtk+ 3.22 function Get_Serial (Self : not null access Gdk_Device_Tool_Record) return Guint64; -- Gets the serial of this tool, this value can be used to identify a -- physical tool (eg. a tablet pen) across program executions. -- Since: gtk+ 3.22 function Get_Tool_Type (Self : not null access Gdk_Device_Tool_Record) return Gdk_Device_Tool_Type; -- Gets the Gdk.Device_Tool.Gdk_Device_Tool_Type of the tool. -- Since: gtk+ 3.22 ---------------- -- Properties -- ---------------- -- The following properties are defined for this widget. See -- Glib.Properties for more information on properties) Axes_Property : constant Glib.Properties.Property_Boxed; -- Type: Axis_Flags Hardware_Id_Property : constant Glib.Properties.Property_Uint; -- Type: Guint64 Serial_Property : constant Glib.Properties.Property_Uint; -- Type: Guint64 Tool_Type_Property : constant Glib.Properties.Property_Boxed; -- Type: Device_Tool_Type private Tool_Type_Property : constant Glib.Properties.Property_Boxed := Glib.Properties.Build ("tool-type"); Serial_Property : constant Glib.Properties.Property_Uint := Glib.Properties.Build ("serial"); Hardware_Id_Property : constant Glib.Properties.Property_Uint := Glib.Properties.Build ("hardware-id"); Axes_Property : constant Glib.Properties.Property_Boxed := Glib.Properties.Build ("axes"); end Gdk.Device_Tool; gtkada-24.0.0/src/generated/gdk-display.adb000066400000000000000000001113161446021174000204370ustar00rootroot00000000000000------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ pragma Style_Checks (Off); pragma Warnings (Off, "*is already use-visible*"); with Ada.Unchecked_Conversion; with Glib.Type_Conversion_Hooks; use Glib.Type_Conversion_Hooks; with Glib.Values; use Glib.Values; with Gtk.Arguments; use Gtk.Arguments; with Gtkada.Bindings; use Gtkada.Bindings; pragma Warnings(Off); -- might be unused with Gtkada.Types; use Gtkada.Types; pragma Warnings(On); package body Gdk.Display is procedure Store_Clipboard (Display : not null access Gdk_Display_Record; Clipboard_Window : Gdk_Window; Time : Guint32; Targets : Gdk.Types.Gdk_Atom_Array) is procedure Internal (Display : System.Address; Clipboard_Window : Gdk_Window; Time : Guint32; Targets : System.Address; N_Targets : Gint); pragma Import (C, Internal, "gdk_display_store_clipboard"); begin Internal (Get_Object (Display), Clipboard_Window, Time, Targets (Targets'First)'Address, Targets'Length); end Store_Clipboard; procedure Get_Window_At_Pointer (Display : access Gdk_Display_Record; Win_X : out Gint; Win_Y : out Gint; Win : out Gdk_Window) is function Internal (Display : System.Address; Win_X : access Gint; Win_Y : access Gint) return Gdk_Window; pragma Import (C, Internal, "gdk_display_get_window_at_pointer"); X, Y : aliased Gint; begin Win := Internal (Get_Object (Display), X'Access, Y'Access); Win_X := X; Win_Y := Y; end Get_Window_At_Pointer; package Type_Conversion_Gdk_Display is new Glib.Type_Conversion_Hooks.Hook_Registrator (Get_Type'Access, Gdk_Display_Record); pragma Unreferenced (Type_Conversion_Gdk_Display); ---------- -- Beep -- ---------- procedure Beep (Self : not null access Gdk_Display_Record) is procedure Internal (Self : System.Address); pragma Import (C, Internal, "gdk_display_beep"); begin Internal (Get_Object (Self)); end Beep; ----------- -- Close -- ----------- procedure Close (Self : not null access Gdk_Display_Record) is procedure Internal (Self : System.Address); pragma Import (C, Internal, "gdk_display_close"); begin Internal (Get_Object (Self)); end Close; ----------- -- Flush -- ----------- procedure Flush (Self : not null access Gdk_Display_Record) is procedure Internal (Self : System.Address); pragma Import (C, Internal, "gdk_display_flush"); begin Internal (Get_Object (Self)); end Flush; ----------------------------- -- Get_Default_Cursor_Size -- ----------------------------- function Get_Default_Cursor_Size (Self : not null access Gdk_Display_Record) return Guint is function Internal (Self : System.Address) return Guint; pragma Import (C, Internal, "gdk_display_get_default_cursor_size"); begin return Internal (Get_Object (Self)); end Get_Default_Cursor_Size; ----------------------- -- Get_Default_Group -- ----------------------- function Get_Default_Group (Self : not null access Gdk_Display_Record) return Gdk.Gdk_Window is function Internal (Self : System.Address) return Gdk.Gdk_Window; pragma Import (C, Internal, "gdk_display_get_default_group"); begin return Internal (Get_Object (Self)); end Get_Default_Group; ---------------------- -- Get_Default_Seat -- ---------------------- function Get_Default_Seat (Self : not null access Gdk_Display_Record) return Glib.Object.GObject is function Internal (Self : System.Address) return System.Address; pragma Import (C, Internal, "gdk_display_get_default_seat"); Stub_GObject : Glib.Object.GObject_Record; begin return Get_User_Data (Internal (Get_Object (Self)), Stub_GObject); end Get_Default_Seat; --------------- -- Get_Event -- --------------- function Get_Event (Self : not null access Gdk_Display_Record) return Gdk.Event.Gdk_Event is function Internal (Self : System.Address) return Gdk.Event.Gdk_Event; pragma Import (C, Internal, "gdk_display_get_event"); begin return Internal (Get_Object (Self)); end Get_Event; ----------------------------- -- Get_Maximal_Cursor_Size -- ----------------------------- procedure Get_Maximal_Cursor_Size (Self : not null access Gdk_Display_Record; Width : out Guint; Height : out Guint) is procedure Internal (Self : System.Address; Width : out Guint; Height : out Guint); pragma Import (C, Internal, "gdk_display_get_maximal_cursor_size"); begin Internal (Get_Object (Self), Width, Height); end Get_Maximal_Cursor_Size; ----------------- -- Get_Monitor -- ----------------- function Get_Monitor (Self : not null access Gdk_Display_Record; Monitor_Num : Glib.Gint) return Gdk.Monitor.Gdk_Monitor is function Internal (Self : System.Address; Monitor_Num : Glib.Gint) return System.Address; pragma Import (C, Internal, "gdk_display_get_monitor"); Stub_Gdk_Monitor : Gdk.Monitor.Gdk_Monitor_Record; begin return Gdk.Monitor.Gdk_Monitor (Get_User_Data (Internal (Get_Object (Self), Monitor_Num), Stub_Gdk_Monitor)); end Get_Monitor; -------------------------- -- Get_Monitor_At_Point -- -------------------------- function Get_Monitor_At_Point (Self : not null access Gdk_Display_Record; X : Glib.Gint; Y : Glib.Gint) return Gdk.Monitor.Gdk_Monitor is function Internal (Self : System.Address; X : Glib.Gint; Y : Glib.Gint) return System.Address; pragma Import (C, Internal, "gdk_display_get_monitor_at_point"); Stub_Gdk_Monitor : Gdk.Monitor.Gdk_Monitor_Record; begin return Gdk.Monitor.Gdk_Monitor (Get_User_Data (Internal (Get_Object (Self), X, Y), Stub_Gdk_Monitor)); end Get_Monitor_At_Point; --------------------------- -- Get_Monitor_At_Window -- --------------------------- function Get_Monitor_At_Window (Self : not null access Gdk_Display_Record; Window : Gdk.Gdk_Window) return Gdk.Monitor.Gdk_Monitor is function Internal (Self : System.Address; Window : Gdk.Gdk_Window) return System.Address; pragma Import (C, Internal, "gdk_display_get_monitor_at_window"); Stub_Gdk_Monitor : Gdk.Monitor.Gdk_Monitor_Record; begin return Gdk.Monitor.Gdk_Monitor (Get_User_Data (Internal (Get_Object (Self), Window), Stub_Gdk_Monitor)); end Get_Monitor_At_Window; -------------------- -- Get_N_Monitors -- -------------------- function Get_N_Monitors (Self : not null access Gdk_Display_Record) return Glib.Gint is function Internal (Self : System.Address) return Glib.Gint; pragma Import (C, Internal, "gdk_display_get_n_monitors"); begin return Internal (Get_Object (Self)); end Get_N_Monitors; ------------------- -- Get_N_Screens -- ------------------- function Get_N_Screens (Self : not null access Gdk_Display_Record) return Glib.Gint is function Internal (Self : System.Address) return Glib.Gint; pragma Import (C, Internal, "gdk_display_get_n_screens"); begin return Internal (Get_Object (Self)); end Get_N_Screens; -------------- -- Get_Name -- -------------- function Get_Name (Self : not null access Gdk_Display_Record) return UTF8_String is function Internal (Self : System.Address) return Gtkada.Types.Chars_Ptr; pragma Import (C, Internal, "gdk_display_get_name"); begin return Gtkada.Bindings.Value_Allowing_Null (Internal (Get_Object (Self))); end Get_Name; ------------------------- -- Get_Primary_Monitor -- ------------------------- function Get_Primary_Monitor (Self : not null access Gdk_Display_Record) return Gdk.Monitor.Gdk_Monitor is function Internal (Self : System.Address) return System.Address; pragma Import (C, Internal, "gdk_display_get_primary_monitor"); Stub_Gdk_Monitor : Gdk.Monitor.Gdk_Monitor_Record; begin return Gdk.Monitor.Gdk_Monitor (Get_User_Data (Internal (Get_Object (Self)), Stub_Gdk_Monitor)); end Get_Primary_Monitor; ----------------- -- Has_Pending -- ----------------- function Has_Pending (Self : not null access Gdk_Display_Record) return Boolean is function Internal (Self : System.Address) return Glib.Gboolean; pragma Import (C, Internal, "gdk_display_has_pending"); begin return Internal (Get_Object (Self)) /= 0; end Has_Pending; --------------- -- Is_Closed -- --------------- function Is_Closed (Self : not null access Gdk_Display_Record) return Boolean is function Internal (Self : System.Address) return Glib.Gboolean; pragma Import (C, Internal, "gdk_display_is_closed"); begin return Internal (Get_Object (Self)) /= 0; end Is_Closed; --------------------- -- Keyboard_Ungrab -- --------------------- procedure Keyboard_Ungrab (Self : not null access Gdk_Display_Record; Time : Guint32) is procedure Internal (Self : System.Address; Time : Guint32); pragma Import (C, Internal, "gdk_display_keyboard_ungrab"); begin Internal (Get_Object (Self), Time); end Keyboard_Ungrab; ---------------- -- List_Seats -- ---------------- function List_Seats (Self : not null access Gdk_Display_Record) return Glib.Object.Object_Simple_List.Glist is function Internal (Self : System.Address) return System.Address; pragma Import (C, Internal, "gdk_display_list_seats"); Tmp_Return : Glib.Object.Object_Simple_List.Glist; begin Glib.Object.Object_Simple_List.Set_Object (Tmp_Return, Internal (Get_Object (Self))); return Tmp_Return; end List_Seats; ----------------------------- -- Notify_Startup_Complete -- ----------------------------- procedure Notify_Startup_Complete (Self : not null access Gdk_Display_Record; Startup_Id : UTF8_String) is procedure Internal (Self : System.Address; Startup_Id : Gtkada.Types.Chars_Ptr); pragma Import (C, Internal, "gdk_display_notify_startup_complete"); Tmp_Startup_Id : Gtkada.Types.Chars_Ptr := New_String (Startup_Id); begin Internal (Get_Object (Self), Tmp_Startup_Id); Free (Tmp_Startup_Id); end Notify_Startup_Complete; ---------------- -- Peek_Event -- ---------------- function Peek_Event (Self : not null access Gdk_Display_Record) return Gdk.Event.Gdk_Event is function Internal (Self : System.Address) return Gdk.Event.Gdk_Event; pragma Import (C, Internal, "gdk_display_peek_event"); begin return Internal (Get_Object (Self)); end Peek_Event; ------------------------ -- Pointer_Is_Grabbed -- ------------------------ function Pointer_Is_Grabbed (Self : not null access Gdk_Display_Record) return Boolean is function Internal (Self : System.Address) return Glib.Gboolean; pragma Import (C, Internal, "gdk_display_pointer_is_grabbed"); begin return Internal (Get_Object (Self)) /= 0; end Pointer_Is_Grabbed; -------------------- -- Pointer_Ungrab -- -------------------- procedure Pointer_Ungrab (Self : not null access Gdk_Display_Record; Time : Guint32) is procedure Internal (Self : System.Address; Time : Guint32); pragma Import (C, Internal, "gdk_display_pointer_ungrab"); begin Internal (Get_Object (Self), Time); end Pointer_Ungrab; --------------- -- Put_Event -- --------------- procedure Put_Event (Self : not null access Gdk_Display_Record; Event : Gdk.Event.Gdk_Event) is procedure Internal (Self : System.Address; Event : Gdk.Event.Gdk_Event); pragma Import (C, Internal, "gdk_display_put_event"); begin Internal (Get_Object (Self), Event); end Put_Event; ------------------------------------ -- Request_Selection_Notification -- ------------------------------------ function Request_Selection_Notification (Self : not null access Gdk_Display_Record; Selection : Gdk.Types.Gdk_Atom) return Boolean is function Internal (Self : System.Address; Selection : Gdk.Types.Gdk_Atom) return Glib.Gboolean; pragma Import (C, Internal, "gdk_display_request_selection_notification"); begin return Internal (Get_Object (Self), Selection) /= 0; end Request_Selection_Notification; ------------------------------- -- Set_Double_Click_Distance -- ------------------------------- procedure Set_Double_Click_Distance (Self : not null access Gdk_Display_Record; Distance : Guint) is procedure Internal (Self : System.Address; Distance : Guint); pragma Import (C, Internal, "gdk_display_set_double_click_distance"); begin Internal (Get_Object (Self), Distance); end Set_Double_Click_Distance; --------------------------- -- Set_Double_Click_Time -- --------------------------- procedure Set_Double_Click_Time (Self : not null access Gdk_Display_Record; Msec : Guint) is procedure Internal (Self : System.Address; Msec : Guint); pragma Import (C, Internal, "gdk_display_set_double_click_time"); begin Internal (Get_Object (Self), Msec); end Set_Double_Click_Time; ------------------------------------ -- Supports_Clipboard_Persistence -- ------------------------------------ function Supports_Clipboard_Persistence (Self : not null access Gdk_Display_Record) return Boolean is function Internal (Self : System.Address) return Glib.Gboolean; pragma Import (C, Internal, "gdk_display_supports_clipboard_persistence"); begin return Internal (Get_Object (Self)) /= 0; end Supports_Clipboard_Persistence; ------------------------ -- Supports_Composite -- ------------------------ function Supports_Composite (Self : not null access Gdk_Display_Record) return Boolean is function Internal (Self : System.Address) return Glib.Gboolean; pragma Import (C, Internal, "gdk_display_supports_composite"); begin return Internal (Get_Object (Self)) /= 0; end Supports_Composite; --------------------------- -- Supports_Cursor_Alpha -- --------------------------- function Supports_Cursor_Alpha (Self : not null access Gdk_Display_Record) return Boolean is function Internal (Self : System.Address) return Glib.Gboolean; pragma Import (C, Internal, "gdk_display_supports_cursor_alpha"); begin return Internal (Get_Object (Self)) /= 0; end Supports_Cursor_Alpha; --------------------------- -- Supports_Cursor_Color -- --------------------------- function Supports_Cursor_Color (Self : not null access Gdk_Display_Record) return Boolean is function Internal (Self : System.Address) return Glib.Gboolean; pragma Import (C, Internal, "gdk_display_supports_cursor_color"); begin return Internal (Get_Object (Self)) /= 0; end Supports_Cursor_Color; --------------------------- -- Supports_Input_Shapes -- --------------------------- function Supports_Input_Shapes (Self : not null access Gdk_Display_Record) return Boolean is function Internal (Self : System.Address) return Glib.Gboolean; pragma Import (C, Internal, "gdk_display_supports_input_shapes"); begin return Internal (Get_Object (Self)) /= 0; end Supports_Input_Shapes; ------------------------------------- -- Supports_Selection_Notification -- ------------------------------------- function Supports_Selection_Notification (Self : not null access Gdk_Display_Record) return Boolean is function Internal (Self : System.Address) return Glib.Gboolean; pragma Import (C, Internal, "gdk_display_supports_selection_notification"); begin return Internal (Get_Object (Self)) /= 0; end Supports_Selection_Notification; --------------------- -- Supports_Shapes -- --------------------- function Supports_Shapes (Self : not null access Gdk_Display_Record) return Boolean is function Internal (Self : System.Address) return Glib.Gboolean; pragma Import (C, Internal, "gdk_display_supports_shapes"); begin return Internal (Get_Object (Self)) /= 0; end Supports_Shapes; ---------- -- Sync -- ---------- procedure Sync (Self : not null access Gdk_Display_Record) is procedure Internal (Self : System.Address); pragma Import (C, Internal, "gdk_display_sync"); begin Internal (Get_Object (Self)); end Sync; ----------------- -- Get_Default -- ----------------- function Get_Default return Gdk_Display is function Internal return System.Address; pragma Import (C, Internal, "gdk_display_get_default"); Stub_Gdk_Display : Gdk_Display_Record; begin return Gdk.Display.Gdk_Display (Get_User_Data (Internal, Stub_Gdk_Display)); end Get_Default; ---------- -- Open -- ---------- function Open (Display_Name : UTF8_String) return Gdk_Display is function Internal (Display_Name : Gtkada.Types.Chars_Ptr) return System.Address; pragma Import (C, Internal, "gdk_display_open"); Tmp_Display_Name : Gtkada.Types.Chars_Ptr := New_String (Display_Name); Stub_Gdk_Display : Gdk_Display_Record; Tmp_Return : System.Address; begin Tmp_Return := Internal (Tmp_Display_Name); Free (Tmp_Display_Name); return Gdk.Display.Gdk_Display (Get_User_Data (Tmp_Return, Stub_Gdk_Display)); end Open; ------------------------------ -- Open_Default_Libgtk_Only -- ------------------------------ function Open_Default_Libgtk_Only return Gdk_Display is function Internal return System.Address; pragma Import (C, Internal, "gdk_display_open_default_libgtk_only"); Stub_Gdk_Display : Gdk_Display_Record; begin return Gdk.Display.Gdk_Display (Get_User_Data (Internal, Stub_Gdk_Display)); end Open_Default_Libgtk_Only; use type System.Address; function Cb_To_Address is new Ada.Unchecked_Conversion (Cb_Gdk_Display_Boolean_Void, System.Address); function Address_To_Cb is new Ada.Unchecked_Conversion (System.Address, Cb_Gdk_Display_Boolean_Void); function Cb_To_Address is new Ada.Unchecked_Conversion (Cb_GObject_Boolean_Void, System.Address); function Address_To_Cb is new Ada.Unchecked_Conversion (System.Address, Cb_GObject_Boolean_Void); function Cb_To_Address is new Ada.Unchecked_Conversion (Cb_Gdk_Display_GObject_Void, System.Address); function Address_To_Cb is new Ada.Unchecked_Conversion (System.Address, Cb_Gdk_Display_GObject_Void); function Cb_To_Address is new Ada.Unchecked_Conversion (Cb_GObject_GObject_Void, System.Address); function Address_To_Cb is new Ada.Unchecked_Conversion (System.Address, Cb_GObject_GObject_Void); function Cb_To_Address is new Ada.Unchecked_Conversion (Cb_Gdk_Display_Void, System.Address); function Address_To_Cb is new Ada.Unchecked_Conversion (System.Address, Cb_Gdk_Display_Void); function Cb_To_Address is new Ada.Unchecked_Conversion (Cb_GObject_Void, System.Address); function Address_To_Cb is new Ada.Unchecked_Conversion (System.Address, Cb_GObject_Void); procedure Connect (Object : access Gdk_Display_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_Gdk_Display_Boolean_Void; After : Boolean); procedure Connect (Object : access Gdk_Display_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_Gdk_Display_GObject_Void; After : Boolean); procedure Connect (Object : access Gdk_Display_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_Gdk_Display_Void; After : Boolean); procedure Connect_Slot (Object : access Gdk_Display_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_GObject_Boolean_Void; After : Boolean; Slot : access Glib.Object.GObject_Record'Class := null); procedure Connect_Slot (Object : access Gdk_Display_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_GObject_GObject_Void; After : Boolean; Slot : access Glib.Object.GObject_Record'Class := null); procedure Connect_Slot (Object : access Gdk_Display_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_GObject_Void; After : Boolean; Slot : access Glib.Object.GObject_Record'Class := null); procedure Marsh_GObject_Boolean_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address); pragma Convention (C, Marsh_GObject_Boolean_Void); procedure Marsh_GObject_GObject_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address); pragma Convention (C, Marsh_GObject_GObject_Void); procedure Marsh_GObject_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address); pragma Convention (C, Marsh_GObject_Void); procedure Marsh_Gdk_Display_Boolean_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address); pragma Convention (C, Marsh_Gdk_Display_Boolean_Void); procedure Marsh_Gdk_Display_GObject_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address); pragma Convention (C, Marsh_Gdk_Display_GObject_Void); procedure Marsh_Gdk_Display_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address); pragma Convention (C, Marsh_Gdk_Display_Void); ------------- -- Connect -- ------------- procedure Connect (Object : access Gdk_Display_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_Gdk_Display_Boolean_Void; After : Boolean) is begin Unchecked_Do_Signal_Connect (Object => Object, C_Name => C_Name, Marshaller => Marsh_Gdk_Display_Boolean_Void'Access, Handler => Cb_To_Address (Handler),-- Set in the closure After => After); end Connect; ------------- -- Connect -- ------------- procedure Connect (Object : access Gdk_Display_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_Gdk_Display_GObject_Void; After : Boolean) is begin Unchecked_Do_Signal_Connect (Object => Object, C_Name => C_Name, Marshaller => Marsh_Gdk_Display_GObject_Void'Access, Handler => Cb_To_Address (Handler),-- Set in the closure After => After); end Connect; ------------- -- Connect -- ------------- procedure Connect (Object : access Gdk_Display_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_Gdk_Display_Void; After : Boolean) is begin Unchecked_Do_Signal_Connect (Object => Object, C_Name => C_Name, Marshaller => Marsh_Gdk_Display_Void'Access, Handler => Cb_To_Address (Handler),-- Set in the closure After => After); end Connect; ------------------ -- Connect_Slot -- ------------------ procedure Connect_Slot (Object : access Gdk_Display_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_GObject_Boolean_Void; After : Boolean; Slot : access Glib.Object.GObject_Record'Class := null) is begin Unchecked_Do_Signal_Connect (Object => Object, C_Name => C_Name, Marshaller => Marsh_GObject_Boolean_Void'Access, Handler => Cb_To_Address (Handler),-- Set in the closure Slot_Object => Slot, After => After); end Connect_Slot; ------------------ -- Connect_Slot -- ------------------ procedure Connect_Slot (Object : access Gdk_Display_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_GObject_GObject_Void; After : Boolean; Slot : access Glib.Object.GObject_Record'Class := null) is begin Unchecked_Do_Signal_Connect (Object => Object, C_Name => C_Name, Marshaller => Marsh_GObject_GObject_Void'Access, Handler => Cb_To_Address (Handler),-- Set in the closure Slot_Object => Slot, After => After); end Connect_Slot; ------------------ -- Connect_Slot -- ------------------ procedure Connect_Slot (Object : access Gdk_Display_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_GObject_Void; After : Boolean; Slot : access Glib.Object.GObject_Record'Class := null) is begin Unchecked_Do_Signal_Connect (Object => Object, C_Name => C_Name, Marshaller => Marsh_GObject_Void'Access, Handler => Cb_To_Address (Handler),-- Set in the closure Slot_Object => Slot, After => After); end Connect_Slot; -------------------------------- -- Marsh_GObject_Boolean_Void -- -------------------------------- procedure Marsh_GObject_Boolean_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address) is pragma Unreferenced (Return_Value, N_Params, Invocation_Hint, User_Data); H : constant Cb_GObject_Boolean_Void := Address_To_Cb (Get_Callback (Closure)); Obj : constant Glib.Object.GObject := Glib.Object.Convert (Get_Data (Closure)); begin H (Obj, Unchecked_To_Boolean (Params, 1)); exception when E : others => Process_Exception (E); end Marsh_GObject_Boolean_Void; -------------------------------- -- Marsh_GObject_GObject_Void -- -------------------------------- procedure Marsh_GObject_GObject_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address) is pragma Unreferenced (Return_Value, N_Params, Invocation_Hint, User_Data); H : constant Cb_GObject_GObject_Void := Address_To_Cb (Get_Callback (Closure)); Obj : constant Glib.Object.GObject := Glib.Object.Convert (Get_Data (Closure)); begin H (Obj, Unchecked_To_Object (Params, 1)); exception when E : others => Process_Exception (E); end Marsh_GObject_GObject_Void; ------------------------ -- Marsh_GObject_Void -- ------------------------ procedure Marsh_GObject_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address) is pragma Unreferenced (Return_Value, N_Params, Params, Invocation_Hint, User_Data); H : constant Cb_GObject_Void := Address_To_Cb (Get_Callback (Closure)); Obj : constant Glib.Object.GObject := Glib.Object.Convert (Get_Data (Closure)); begin H (Obj); exception when E : others => Process_Exception (E); end Marsh_GObject_Void; ------------------------------------ -- Marsh_Gdk_Display_Boolean_Void -- ------------------------------------ procedure Marsh_Gdk_Display_Boolean_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address) is pragma Unreferenced (Return_Value, N_Params, Invocation_Hint, User_Data); H : constant Cb_Gdk_Display_Boolean_Void := Address_To_Cb (Get_Callback (Closure)); Obj : constant Gdk_Display := Gdk_Display (Unchecked_To_Object (Params, 0)); begin H (Obj, Unchecked_To_Boolean (Params, 1)); exception when E : others => Process_Exception (E); end Marsh_Gdk_Display_Boolean_Void; ------------------------------------ -- Marsh_Gdk_Display_GObject_Void -- ------------------------------------ procedure Marsh_Gdk_Display_GObject_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address) is pragma Unreferenced (Return_Value, N_Params, Invocation_Hint, User_Data); H : constant Cb_Gdk_Display_GObject_Void := Address_To_Cb (Get_Callback (Closure)); Obj : constant Gdk_Display := Gdk_Display (Unchecked_To_Object (Params, 0)); begin H (Obj, Unchecked_To_Object (Params, 1)); exception when E : others => Process_Exception (E); end Marsh_Gdk_Display_GObject_Void; ---------------------------- -- Marsh_Gdk_Display_Void -- ---------------------------- procedure Marsh_Gdk_Display_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address) is pragma Unreferenced (Return_Value, N_Params, Invocation_Hint, User_Data); H : constant Cb_Gdk_Display_Void := Address_To_Cb (Get_Callback (Closure)); Obj : constant Gdk_Display := Gdk_Display (Unchecked_To_Object (Params, 0)); begin H (Obj); exception when E : others => Process_Exception (E); end Marsh_Gdk_Display_Void; --------------- -- On_Closed -- --------------- procedure On_Closed (Self : not null access Gdk_Display_Record; Call : Cb_Gdk_Display_Boolean_Void; After : Boolean := False) is begin Connect (Self, "closed" & ASCII.NUL, Call, After); end On_Closed; --------------- -- On_Closed -- --------------- procedure On_Closed (Self : not null access Gdk_Display_Record; Call : Cb_GObject_Boolean_Void; Slot : not null access Glib.Object.GObject_Record'Class; After : Boolean := False) is begin Connect_Slot (Self, "closed" & ASCII.NUL, Call, After, Slot); end On_Closed; ---------------------- -- On_Monitor_Added -- ---------------------- procedure On_Monitor_Added (Self : not null access Gdk_Display_Record; Call : Cb_Gdk_Display_GObject_Void; After : Boolean := False) is begin Connect (Self, "monitor-added" & ASCII.NUL, Call, After); end On_Monitor_Added; ---------------------- -- On_Monitor_Added -- ---------------------- procedure On_Monitor_Added (Self : not null access Gdk_Display_Record; Call : Cb_GObject_GObject_Void; Slot : not null access Glib.Object.GObject_Record'Class; After : Boolean := False) is begin Connect_Slot (Self, "monitor-added" & ASCII.NUL, Call, After, Slot); end On_Monitor_Added; ------------------------ -- On_Monitor_Removed -- ------------------------ procedure On_Monitor_Removed (Self : not null access Gdk_Display_Record; Call : Cb_Gdk_Display_GObject_Void; After : Boolean := False) is begin Connect (Self, "monitor-removed" & ASCII.NUL, Call, After); end On_Monitor_Removed; ------------------------ -- On_Monitor_Removed -- ------------------------ procedure On_Monitor_Removed (Self : not null access Gdk_Display_Record; Call : Cb_GObject_GObject_Void; Slot : not null access Glib.Object.GObject_Record'Class; After : Boolean := False) is begin Connect_Slot (Self, "monitor-removed" & ASCII.NUL, Call, After, Slot); end On_Monitor_Removed; --------------- -- On_Opened -- --------------- procedure On_Opened (Self : not null access Gdk_Display_Record; Call : Cb_Gdk_Display_Void; After : Boolean := False) is begin Connect (Self, "opened" & ASCII.NUL, Call, After); end On_Opened; --------------- -- On_Opened -- --------------- procedure On_Opened (Self : not null access Gdk_Display_Record; Call : Cb_GObject_Void; Slot : not null access Glib.Object.GObject_Record'Class; After : Boolean := False) is begin Connect_Slot (Self, "opened" & ASCII.NUL, Call, After, Slot); end On_Opened; ------------------- -- On_Seat_Added -- ------------------- procedure On_Seat_Added (Self : not null access Gdk_Display_Record; Call : Cb_Gdk_Display_GObject_Void; After : Boolean := False) is begin Connect (Self, "seat-added" & ASCII.NUL, Call, After); end On_Seat_Added; ------------------- -- On_Seat_Added -- ------------------- procedure On_Seat_Added (Self : not null access Gdk_Display_Record; Call : Cb_GObject_GObject_Void; Slot : not null access Glib.Object.GObject_Record'Class; After : Boolean := False) is begin Connect_Slot (Self, "seat-added" & ASCII.NUL, Call, After, Slot); end On_Seat_Added; --------------------- -- On_Seat_Removed -- --------------------- procedure On_Seat_Removed (Self : not null access Gdk_Display_Record; Call : Cb_Gdk_Display_GObject_Void; After : Boolean := False) is begin Connect (Self, "seat-removed" & ASCII.NUL, Call, After); end On_Seat_Removed; --------------------- -- On_Seat_Removed -- --------------------- procedure On_Seat_Removed (Self : not null access Gdk_Display_Record; Call : Cb_GObject_GObject_Void; Slot : not null access Glib.Object.GObject_Record'Class; After : Boolean := False) is begin Connect_Slot (Self, "seat-removed" & ASCII.NUL, Call, After, Slot); end On_Seat_Removed; end Gdk.Display; gtkada-24.0.0/src/generated/gdk-display.ads000066400000000000000000000511711446021174000204620ustar00rootroot00000000000000------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ -- -- Gdk.Display.Gdk_Display objects purpose are two fold: -- -- - To manage and provide information about input devices (pointers and -- keyboards) -- -- - To manage and provide information about the available Gdk_Screens -- -- GdkDisplay objects are the GDK representation of an X Display, which can -- be described as a workstation consisting of a keyboard, a pointing device -- (such as a mouse) and one or more screens. It is used to open and keep -- track of various GdkScreen objects currently instantiated by the -- application. It is also used to access the keyboard(s) and mouse pointer(s) -- of the display. -- -- Most of the input device handling has been factored out into the separate -- Gdk.Device_Manager.Gdk_Device_Manager object. Every display has a device -- manager, which you can obtain using gdk_display_get_device_manager. -- -- pragma Warnings (Off, "*is already use-visible*"); with Gdk.Event; use Gdk.Event; with Gdk.Monitor; use Gdk.Monitor; with Gdk.Types; use Gdk.Types; with Glib; use Glib; with Glib.Object; use Glib.Object; package Gdk.Display is type Gdk_Display_Record is new GObject_Record with null record; type Gdk_Display is access all Gdk_Display_Record'Class; ------------------ -- Constructors -- ------------------ function Get_Type return Glib.GType; pragma Import (C, Get_Type, "gdk_display_get_type"); ------------- -- Methods -- ------------- procedure Beep (Self : not null access Gdk_Display_Record); -- Emits a short beep on Display -- Since: gtk+ 2.2 procedure Close (Self : not null access Gdk_Display_Record); -- Closes the connection to the windowing system for the given display, -- and cleans up associated resources. -- Since: gtk+ 2.2 procedure Flush (Self : not null access Gdk_Display_Record); -- Flushes any requests queued for the windowing system; this happens -- automatically when the main loop blocks waiting for new events, but if -- your application is drawing without returning control to the main loop, -- you may need to call this function explicitly. A common case where this -- function needs to be called is when an application is executing drawing -- commands from a thread other than the thread where the main loop is -- running. -- This is most useful for X11. On windowing systems where requests are -- handled synchronously, this function will do nothing. -- Since: gtk+ 2.4 function Get_Default_Cursor_Size (Self : not null access Gdk_Display_Record) return Guint; -- Returns the default size to use for cursors on Display. -- Since: gtk+ 2.4 function Get_Default_Group (Self : not null access Gdk_Display_Record) return Gdk.Gdk_Window; -- Returns the default group leader window for all toplevel windows on -- Display. This window is implicitly created by GDK. See -- Gdk.Window.Set_Group. -- Since: gtk+ 2.4 function Get_Default_Seat (Self : not null access Gdk_Display_Record) return Glib.Object.GObject; -- Returns the default Gdk.Seat.Gdk_Seat for this display. -- Since: gtk+ 3.20 function Get_Event (Self : not null access Gdk_Display_Record) return Gdk.Event.Gdk_Event; -- Gets the next Gdk.Event.Gdk_Event to be processed for Display, fetching -- events from the windowing system if necessary. -- Since: gtk+ 2.2 procedure Get_Maximal_Cursor_Size (Self : not null access Gdk_Display_Record; Width : out Guint; Height : out Guint); -- Gets the maximal size to use for cursors on Display. -- Since: gtk+ 2.4 -- "width": the return location for the maximal cursor width -- "height": the return location for the maximal cursor height function Get_Monitor (Self : not null access Gdk_Display_Record; Monitor_Num : Glib.Gint) return Gdk.Monitor.Gdk_Monitor; -- Gets a monitor associated with this display. -- Since: gtk+ 3.22 -- "monitor_num": number of the monitor function Get_Monitor_At_Point (Self : not null access Gdk_Display_Record; X : Glib.Gint; Y : Glib.Gint) return Gdk.Monitor.Gdk_Monitor; -- Gets the monitor in which the point (X, Y) is located, or a nearby -- monitor if the point is not in any monitor. -- Since: gtk+ 3.22 -- "x": the x coordinate of the point -- "y": the y coordinate of the point function Get_Monitor_At_Window (Self : not null access Gdk_Display_Record; Window : Gdk.Gdk_Window) return Gdk.Monitor.Gdk_Monitor; -- Gets the monitor in which the largest area of Window resides, or a -- monitor close to Window if it is outside of all monitors. -- Since: gtk+ 3.22 -- "window": a Gdk.Gdk_Window function Get_N_Monitors (Self : not null access Gdk_Display_Record) return Glib.Gint; -- Gets the number of monitors that belong to Display. -- The returned number is valid until the next emission of the -- Gdk.Display.Gdk_Display::monitor-added or -- Gdk.Display.Gdk_Display::monitor-removed signal. -- Since: gtk+ 3.22 function Get_N_Screens (Self : not null access Gdk_Display_Record) return Glib.Gint; pragma Obsolescent (Get_N_Screens); -- Gets the number of screen managed by the Display. -- Since: gtk+ 2.2 -- Deprecated since 3.10, 1 function Get_Name (Self : not null access Gdk_Display_Record) return UTF8_String; -- Gets the name of the display. -- Since: gtk+ 2.2 function Get_Primary_Monitor (Self : not null access Gdk_Display_Record) return Gdk.Monitor.Gdk_Monitor; -- Gets the primary monitor for the display. -- The primary monitor is considered the monitor where the "main desktop" -- lives. While normal application windows typically allow the window -- manager to place the windows, specialized desktop applications such as -- panels should place themselves on the primary monitor. -- Since: gtk+ 3.22 function Has_Pending (Self : not null access Gdk_Display_Record) return Boolean; -- Returns whether the display has events that are waiting to be -- processed. -- Since: gtk+ 3.0 function Is_Closed (Self : not null access Gdk_Display_Record) return Boolean; -- Finds out if the display has been closed. -- Since: gtk+ 2.22 procedure Keyboard_Ungrab (Self : not null access Gdk_Display_Record; Time : Guint32); pragma Obsolescent (Keyboard_Ungrab); -- Release any keyboard grab -- Since: gtk+ 2.2 -- Deprecated since 3.0, 1 -- "time_": a timestap (e.g GDK_CURRENT_TIME). function List_Seats (Self : not null access Gdk_Display_Record) return Glib.Object.Object_Simple_List.Glist; -- Returns the list of seats known to Display. -- Since: gtk+ 3.20 procedure Notify_Startup_Complete (Self : not null access Gdk_Display_Record; Startup_Id : UTF8_String); -- Indicates to the GUI environment that the application has finished -- loading, using a given identifier. -- GTK+ will call this function automatically for Gtk.Window.Gtk_Window -- with custom startup-notification identifier unless -- Gtk.Window.Set_Auto_Startup_Notification is called to disable that -- feature. -- Since: gtk+ 3.0 -- "startup_id": a startup-notification identifier, for which notification -- process should be completed function Peek_Event (Self : not null access Gdk_Display_Record) return Gdk.Event.Gdk_Event; -- Gets a copy of the first Gdk.Event.Gdk_Event in the Display's event -- queue, without removing the event from the queue. (Note that this -- function will not get more events from the windowing system. It only -- checks the events that have already been moved to the GDK event queue.) -- Since: gtk+ 2.2 function Pointer_Is_Grabbed (Self : not null access Gdk_Display_Record) return Boolean; pragma Obsolescent (Pointer_Is_Grabbed); -- Test if the pointer is grabbed. -- Since: gtk+ 2.2 -- Deprecated since 3.0, 1 procedure Pointer_Ungrab (Self : not null access Gdk_Display_Record; Time : Guint32); pragma Obsolescent (Pointer_Ungrab); -- Release any pointer grab. -- Since: gtk+ 2.2 -- Deprecated since 3.0, 1 -- "time_": a timestap (e.g. GDK_CURRENT_TIME). procedure Put_Event (Self : not null access Gdk_Display_Record; Event : Gdk.Event.Gdk_Event); -- Appends a copy of the given event onto the front of the event queue for -- Display. -- Since: gtk+ 2.2 -- "event": a Gdk.Event.Gdk_Event. function Request_Selection_Notification (Self : not null access Gdk_Display_Record; Selection : Gdk.Types.Gdk_Atom) return Boolean; -- Request Gdk.Event.Gdk_Event_Owner_Change events for ownership changes -- of the selection named by the given atom. -- Since: gtk+ 2.6 -- "selection": the Gdk.Types.Gdk_Atom naming the selection for which -- ownership change notification is requested procedure Set_Double_Click_Distance (Self : not null access Gdk_Display_Record; Distance : Guint); -- Sets the double click distance (two clicks within this distance count -- as a double click and result in a GDK_2_BUTTON_PRESS event). See also -- Gdk.Display.Set_Double_Click_Time. Applications should not set this, it -- is a global user-configured setting. -- Since: gtk+ 2.4 -- "distance": distance in pixels procedure Set_Double_Click_Time (Self : not null access Gdk_Display_Record; Msec : Guint); -- Sets the double click time (two clicks within this time interval count -- as a double click and result in a GDK_2_BUTTON_PRESS event). -- Applications should not set this, it is a global user-configured -- setting. -- Since: gtk+ 2.2 -- "msec": double click time in milliseconds (thousandths of a second) function Supports_Clipboard_Persistence (Self : not null access Gdk_Display_Record) return Boolean; -- Returns whether the speicifed display supports clipboard persistance; -- i.e. if it's possible to store the clipboard data after an application -- has quit. On X11 this checks if a clipboard daemon is running. -- Since: gtk+ 2.6 function Supports_Composite (Self : not null access Gdk_Display_Record) return Boolean; pragma Obsolescent (Supports_Composite); -- Returns True if Gdk.Window.Set_Composited can be used to redirect -- drawing on the window using compositing. -- Currently this only works on X11 with XComposite and XDamage extensions -- available. -- Since: gtk+ 2.12 -- Deprecated since 3.16, 1 function Supports_Cursor_Alpha (Self : not null access Gdk_Display_Record) return Boolean; -- Returns True if cursors can use an 8bit alpha channel on Display. -- Otherwise, cursors are restricted to bilevel alpha (i.e. a mask). -- Since: gtk+ 2.4 function Supports_Cursor_Color (Self : not null access Gdk_Display_Record) return Boolean; -- Returns True if multicolored cursors are supported on Display. -- Otherwise, cursors have only a forground and a background color. -- Since: gtk+ 2.4 function Supports_Input_Shapes (Self : not null access Gdk_Display_Record) return Boolean; -- Returns True if gdk_window_input_shape_combine_mask can be used to -- modify the input shape of windows on Display. -- Since: gtk+ 2.10 function Supports_Selection_Notification (Self : not null access Gdk_Display_Record) return Boolean; -- Returns whether Gdk.Event.Gdk_Event_Owner_Change events will be sent -- when the owner of a selection changes. -- Since: gtk+ 2.6 function Supports_Shapes (Self : not null access Gdk_Display_Record) return Boolean; -- Returns True if gdk_window_shape_combine_mask can be used to create -- shaped windows on Display. -- Since: gtk+ 2.10 procedure Sync (Self : not null access Gdk_Display_Record); -- Flushes any requests queued for the windowing system and waits until -- all requests have been handled. This is often used for making sure that -- the display is synchronized with the current state of the program. -- Calling Gdk.Display.Sync before gdk_error_trap_pop makes sure that any -- errors generated from earlier requests are handled before the error trap -- is removed. -- This is most useful for X11. On windowing systems where requests are -- handled synchronously, this function will do nothing. -- Since: gtk+ 2.2 ---------------------- -- GtkAda additions -- ---------------------- procedure Store_Clipboard (Display : not null access Gdk_Display_Record; Clipboard_Window : Gdk.Gdk_Window; Time : Guint32; Targets : Gdk.Types.Gdk_Atom_Array); -- Issues a request to the clipboard manager to store the clipboard data. -- On X11, this is a special program that works according to the -- freedesktop clipboard specification, available at -- http://www.freedesktop.org/Standards/clipboard-manager-spec>. -- Since: gtk+ 2.6 -- "clipboard_window": a Gdk.Gdk_Window belonging to the clipboard owner -- "time_": a timestamp -- "targets": an array of targets that should be saved, or null if all -- available targets should be saved. -- "n_targets": length of the Targets array procedure Get_Window_At_Pointer (Display : access Gdk_Display_Record; Win_X : out Glib.Gint; Win_Y : out Glib.Gint; Win : out Gdk.Gdk_Window); -- Obtains the window underneath the mouse pointer, returning the location -- of that window in Win_X, Win_Y. Returns nullif the window -- under the mouse pointer is not known to GDK (for example, belongs to -- another application). -- (Win_X, Win_Y) are relative to the origin of the window under the -- pointer. -- -- Obsolescent: use Gdk.Device.Get_Window_At_Position instead. --------------- -- Functions -- --------------- function Get_Default return Gdk_Display; -- Gets the default Gdk.Display.Gdk_Display. This is a convenience -- function for: `gdk_display_manager_get_default_display -- (gdk_display_manager_get ())`. -- Since: gtk+ 2.2 function Open (Display_Name : UTF8_String) return Gdk_Display; -- Opens a display. -- Since: gtk+ 2.2 -- "display_name": the name of the display to open function Open_Default_Libgtk_Only return Gdk_Display; pragma Obsolescent (Open_Default_Libgtk_Only); -- Opens the default display specified by command line arguments or -- environment variables, sets it as the default display, and returns it. -- gdk_parse_args must have been called first. If the default display has -- previously been set, simply returns that. An internal function that -- should not be used by applications. -- Deprecated since 3.16, 1 ------------- -- Signals -- ------------- type Cb_Gdk_Display_Boolean_Void is not null access procedure (Self : access Gdk_Display_Record'Class; Is_Error : Boolean); type Cb_GObject_Boolean_Void is not null access procedure (Self : access Glib.Object.GObject_Record'Class; Is_Error : Boolean); Signal_Closed : constant Glib.Signal_Name := "closed"; procedure On_Closed (Self : not null access Gdk_Display_Record; Call : Cb_Gdk_Display_Boolean_Void; After : Boolean := False); procedure On_Closed (Self : not null access Gdk_Display_Record; Call : Cb_GObject_Boolean_Void; Slot : not null access Glib.Object.GObject_Record'Class; After : Boolean := False); -- The ::closed signal is emitted when the connection to the windowing -- system for Display is closed. type Cb_Gdk_Display_GObject_Void is not null access procedure (Self : access Gdk_Display_Record'Class; Monitor : not null access Glib.Object.GObject_Record'Class); type Cb_GObject_GObject_Void is not null access procedure (Self : access Glib.Object.GObject_Record'Class; Monitor : not null access Glib.Object.GObject_Record'Class); Signal_Monitor_Added : constant Glib.Signal_Name := "monitor-added"; procedure On_Monitor_Added (Self : not null access Gdk_Display_Record; Call : Cb_Gdk_Display_GObject_Void; After : Boolean := False); procedure On_Monitor_Added (Self : not null access Gdk_Display_Record; Call : Cb_GObject_GObject_Void; Slot : not null access Glib.Object.GObject_Record'Class; After : Boolean := False); -- The ::monitor-added signal is emitted whenever a monitor is added. Signal_Monitor_Removed : constant Glib.Signal_Name := "monitor-removed"; procedure On_Monitor_Removed (Self : not null access Gdk_Display_Record; Call : Cb_Gdk_Display_GObject_Void; After : Boolean := False); procedure On_Monitor_Removed (Self : not null access Gdk_Display_Record; Call : Cb_GObject_GObject_Void; Slot : not null access Glib.Object.GObject_Record'Class; After : Boolean := False); -- The ::monitor-removed signal is emitted whenever a monitor is removed. type Cb_Gdk_Display_Void is not null access procedure (Self : access Gdk_Display_Record'Class); type Cb_GObject_Void is not null access procedure (Self : access Glib.Object.GObject_Record'Class); Signal_Opened : constant Glib.Signal_Name := "opened"; procedure On_Opened (Self : not null access Gdk_Display_Record; Call : Cb_Gdk_Display_Void; After : Boolean := False); procedure On_Opened (Self : not null access Gdk_Display_Record; Call : Cb_GObject_Void; Slot : not null access Glib.Object.GObject_Record'Class; After : Boolean := False); -- The ::opened signal is emitted when the connection to the windowing -- system for Display is opened. Signal_Seat_Added : constant Glib.Signal_Name := "seat-added"; procedure On_Seat_Added (Self : not null access Gdk_Display_Record; Call : Cb_Gdk_Display_GObject_Void; After : Boolean := False); procedure On_Seat_Added (Self : not null access Gdk_Display_Record; Call : Cb_GObject_GObject_Void; Slot : not null access Glib.Object.GObject_Record'Class; After : Boolean := False); -- The ::seat-added signal is emitted whenever a new seat is made known to -- the windowing system. Signal_Seat_Removed : constant Glib.Signal_Name := "seat-removed"; procedure On_Seat_Removed (Self : not null access Gdk_Display_Record; Call : Cb_Gdk_Display_GObject_Void; After : Boolean := False); procedure On_Seat_Removed (Self : not null access Gdk_Display_Record; Call : Cb_GObject_GObject_Void; Slot : not null access Glib.Object.GObject_Record'Class; After : Boolean := False); -- The ::seat-removed signal is emitted whenever a seat is removed by the -- windowing system. end Gdk.Display; gtkada-24.0.0/src/generated/gdk-drag_contexts.adb000066400000000000000000000664521446021174000216500ustar00rootroot00000000000000------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ pragma Style_Checks (Off); pragma Warnings (Off, "*is already use-visible*"); with Ada.Unchecked_Conversion; with Glib.Type_Conversion_Hooks; use Glib.Type_Conversion_Hooks; with Glib.Values; use Glib.Values; with Gtk.Arguments; use Gtk.Arguments; with Gtkada.Bindings; use Gtkada.Bindings; package body Gdk.Drag_Contexts is package Type_Conversion_Drag_Context is new Glib.Type_Conversion_Hooks.Hook_Registrator (Get_Type'Access, Drag_Context_Record); pragma Unreferenced (Type_Conversion_Drag_Context); ----------------- -- Get_Actions -- ----------------- function Get_Actions (Self : not null access Drag_Context_Record) return Gdk_Drag_Action is function Internal (Self : System.Address) return Gdk_Drag_Action; pragma Import (C, Internal, "gdk_drag_context_get_actions"); begin return Internal (Get_Object (Self)); end Get_Actions; --------------------- -- Get_Dest_Window -- --------------------- function Get_Dest_Window (Self : not null access Drag_Context_Record) return Gdk.Gdk_Window is function Internal (Self : System.Address) return Gdk.Gdk_Window; pragma Import (C, Internal, "gdk_drag_context_get_dest_window"); begin return Internal (Get_Object (Self)); end Get_Dest_Window; ---------------- -- Get_Device -- ---------------- function Get_Device (Self : not null access Drag_Context_Record) return Gdk.Device.Gdk_Device is function Internal (Self : System.Address) return System.Address; pragma Import (C, Internal, "gdk_drag_context_get_device"); Stub_Gdk_Device : Gdk.Device.Gdk_Device_Record; begin return Gdk.Device.Gdk_Device (Get_User_Data (Internal (Get_Object (Self)), Stub_Gdk_Device)); end Get_Device; --------------------- -- Get_Drag_Window -- --------------------- function Get_Drag_Window (Self : not null access Drag_Context_Record) return Gdk.Gdk_Window is function Internal (Self : System.Address) return Gdk.Gdk_Window; pragma Import (C, Internal, "gdk_drag_context_get_drag_window"); begin return Internal (Get_Object (Self)); end Get_Drag_Window; ------------------ -- Get_Protocol -- ------------------ function Get_Protocol (Self : not null access Drag_Context_Record) return Gdk_Drag_Protocol is function Internal (Self : System.Address) return Gdk_Drag_Protocol; pragma Import (C, Internal, "gdk_drag_context_get_protocol"); begin return Internal (Get_Object (Self)); end Get_Protocol; ------------------------- -- Get_Selected_Action -- ------------------------- function Get_Selected_Action (Self : not null access Drag_Context_Record) return Gdk_Drag_Action is function Internal (Self : System.Address) return Gdk_Drag_Action; pragma Import (C, Internal, "gdk_drag_context_get_selected_action"); begin return Internal (Get_Object (Self)); end Get_Selected_Action; ----------------------- -- Get_Source_Window -- ----------------------- function Get_Source_Window (Self : not null access Drag_Context_Record) return Gdk.Gdk_Window is function Internal (Self : System.Address) return Gdk.Gdk_Window; pragma Import (C, Internal, "gdk_drag_context_get_source_window"); begin return Internal (Get_Object (Self)); end Get_Source_Window; -------------------------- -- Get_Suggested_Action -- -------------------------- function Get_Suggested_Action (Self : not null access Drag_Context_Record) return Gdk_Drag_Action is function Internal (Self : System.Address) return Gdk_Drag_Action; pragma Import (C, Internal, "gdk_drag_context_get_suggested_action"); begin return Internal (Get_Object (Self)); end Get_Suggested_Action; ---------------- -- Manage_Dnd -- ---------------- function Manage_Dnd (Self : not null access Drag_Context_Record; Ipc_Window : Gdk.Gdk_Window; Actions : Gdk_Drag_Action) return Boolean is function Internal (Self : System.Address; Ipc_Window : Gdk.Gdk_Window; Actions : Gdk_Drag_Action) return Glib.Gboolean; pragma Import (C, Internal, "gdk_drag_context_manage_dnd"); begin return Internal (Get_Object (Self), Ipc_Window, Actions) /= 0; end Manage_Dnd; ---------------- -- Set_Device -- ---------------- procedure Set_Device (Self : not null access Drag_Context_Record; Device : not null access Gdk.Device.Gdk_Device_Record'Class) is procedure Internal (Self : System.Address; Device : System.Address); pragma Import (C, Internal, "gdk_drag_context_set_device"); begin Internal (Get_Object (Self), Get_Object (Device)); end Set_Device; ----------------- -- Set_Hotspot -- ----------------- procedure Set_Hotspot (Self : not null access Drag_Context_Record; Hot_X : Glib.Gint; Hot_Y : Glib.Gint) is procedure Internal (Self : System.Address; Hot_X : Glib.Gint; Hot_Y : Glib.Gint); pragma Import (C, Internal, "gdk_drag_context_set_hotspot"); begin Internal (Get_Object (Self), Hot_X, Hot_Y); end Set_Hotspot; use type System.Address; function Cb_To_Address is new Ada.Unchecked_Conversion (Cb_Drag_Context_Gdk_Drag_Action_Void, System.Address); function Address_To_Cb is new Ada.Unchecked_Conversion (System.Address, Cb_Drag_Context_Gdk_Drag_Action_Void); function Cb_To_Address is new Ada.Unchecked_Conversion (Cb_GObject_Gdk_Drag_Action_Void, System.Address); function Address_To_Cb is new Ada.Unchecked_Conversion (System.Address, Cb_GObject_Gdk_Drag_Action_Void); function Cb_To_Address is new Ada.Unchecked_Conversion (Cb_Drag_Context_Gdk_Drag_Cancel_Reason_Void, System.Address); function Address_To_Cb is new Ada.Unchecked_Conversion (System.Address, Cb_Drag_Context_Gdk_Drag_Cancel_Reason_Void); function Cb_To_Address is new Ada.Unchecked_Conversion (Cb_GObject_Gdk_Drag_Cancel_Reason_Void, System.Address); function Address_To_Cb is new Ada.Unchecked_Conversion (System.Address, Cb_GObject_Gdk_Drag_Cancel_Reason_Void); function Cb_To_Address is new Ada.Unchecked_Conversion (Cb_Drag_Context_Void, System.Address); function Address_To_Cb is new Ada.Unchecked_Conversion (System.Address, Cb_Drag_Context_Void); function Cb_To_Address is new Ada.Unchecked_Conversion (Cb_GObject_Void, System.Address); function Address_To_Cb is new Ada.Unchecked_Conversion (System.Address, Cb_GObject_Void); function Cb_To_Address is new Ada.Unchecked_Conversion (Cb_Drag_Context_Gint_Void, System.Address); function Address_To_Cb is new Ada.Unchecked_Conversion (System.Address, Cb_Drag_Context_Gint_Void); function Cb_To_Address is new Ada.Unchecked_Conversion (Cb_GObject_Gint_Void, System.Address); function Address_To_Cb is new Ada.Unchecked_Conversion (System.Address, Cb_GObject_Gint_Void); procedure Connect (Object : access Drag_Context_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_Drag_Context_Gdk_Drag_Action_Void; After : Boolean); procedure Connect (Object : access Drag_Context_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_Drag_Context_Gdk_Drag_Cancel_Reason_Void; After : Boolean); procedure Connect (Object : access Drag_Context_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_Drag_Context_Void; After : Boolean); procedure Connect (Object : access Drag_Context_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_Drag_Context_Gint_Void; After : Boolean); procedure Connect_Slot (Object : access Drag_Context_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_GObject_Gdk_Drag_Action_Void; After : Boolean; Slot : access Glib.Object.GObject_Record'Class := null); procedure Connect_Slot (Object : access Drag_Context_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_GObject_Gdk_Drag_Cancel_Reason_Void; After : Boolean; Slot : access Glib.Object.GObject_Record'Class := null); procedure Connect_Slot (Object : access Drag_Context_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_GObject_Void; After : Boolean; Slot : access Glib.Object.GObject_Record'Class := null); procedure Connect_Slot (Object : access Drag_Context_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_GObject_Gint_Void; After : Boolean; Slot : access Glib.Object.GObject_Record'Class := null); procedure Marsh_Drag_Context_Gdk_Drag_Action_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address); pragma Convention (C, Marsh_Drag_Context_Gdk_Drag_Action_Void); procedure Marsh_Drag_Context_Gdk_Drag_Cancel_Reason_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address); pragma Convention (C, Marsh_Drag_Context_Gdk_Drag_Cancel_Reason_Void); procedure Marsh_Drag_Context_Gint_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address); pragma Convention (C, Marsh_Drag_Context_Gint_Void); procedure Marsh_Drag_Context_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address); pragma Convention (C, Marsh_Drag_Context_Void); procedure Marsh_GObject_Gdk_Drag_Action_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address); pragma Convention (C, Marsh_GObject_Gdk_Drag_Action_Void); procedure Marsh_GObject_Gdk_Drag_Cancel_Reason_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address); pragma Convention (C, Marsh_GObject_Gdk_Drag_Cancel_Reason_Void); procedure Marsh_GObject_Gint_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address); pragma Convention (C, Marsh_GObject_Gint_Void); procedure Marsh_GObject_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address); pragma Convention (C, Marsh_GObject_Void); ------------- -- Connect -- ------------- procedure Connect (Object : access Drag_Context_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_Drag_Context_Gdk_Drag_Action_Void; After : Boolean) is begin Unchecked_Do_Signal_Connect (Object => Object, C_Name => C_Name, Marshaller => Marsh_Drag_Context_Gdk_Drag_Action_Void'Access, Handler => Cb_To_Address (Handler),-- Set in the closure After => After); end Connect; ------------- -- Connect -- ------------- procedure Connect (Object : access Drag_Context_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_Drag_Context_Gdk_Drag_Cancel_Reason_Void; After : Boolean) is begin Unchecked_Do_Signal_Connect (Object => Object, C_Name => C_Name, Marshaller => Marsh_Drag_Context_Gdk_Drag_Cancel_Reason_Void'Access, Handler => Cb_To_Address (Handler),-- Set in the closure After => After); end Connect; ------------- -- Connect -- ------------- procedure Connect (Object : access Drag_Context_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_Drag_Context_Void; After : Boolean) is begin Unchecked_Do_Signal_Connect (Object => Object, C_Name => C_Name, Marshaller => Marsh_Drag_Context_Void'Access, Handler => Cb_To_Address (Handler),-- Set in the closure After => After); end Connect; ------------- -- Connect -- ------------- procedure Connect (Object : access Drag_Context_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_Drag_Context_Gint_Void; After : Boolean) is begin Unchecked_Do_Signal_Connect (Object => Object, C_Name => C_Name, Marshaller => Marsh_Drag_Context_Gint_Void'Access, Handler => Cb_To_Address (Handler),-- Set in the closure After => After); end Connect; ------------------ -- Connect_Slot -- ------------------ procedure Connect_Slot (Object : access Drag_Context_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_GObject_Gdk_Drag_Action_Void; After : Boolean; Slot : access Glib.Object.GObject_Record'Class := null) is begin Unchecked_Do_Signal_Connect (Object => Object, C_Name => C_Name, Marshaller => Marsh_GObject_Gdk_Drag_Action_Void'Access, Handler => Cb_To_Address (Handler),-- Set in the closure Slot_Object => Slot, After => After); end Connect_Slot; ------------------ -- Connect_Slot -- ------------------ procedure Connect_Slot (Object : access Drag_Context_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_GObject_Gdk_Drag_Cancel_Reason_Void; After : Boolean; Slot : access Glib.Object.GObject_Record'Class := null) is begin Unchecked_Do_Signal_Connect (Object => Object, C_Name => C_Name, Marshaller => Marsh_GObject_Gdk_Drag_Cancel_Reason_Void'Access, Handler => Cb_To_Address (Handler),-- Set in the closure Slot_Object => Slot, After => After); end Connect_Slot; ------------------ -- Connect_Slot -- ------------------ procedure Connect_Slot (Object : access Drag_Context_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_GObject_Void; After : Boolean; Slot : access Glib.Object.GObject_Record'Class := null) is begin Unchecked_Do_Signal_Connect (Object => Object, C_Name => C_Name, Marshaller => Marsh_GObject_Void'Access, Handler => Cb_To_Address (Handler),-- Set in the closure Slot_Object => Slot, After => After); end Connect_Slot; ------------------ -- Connect_Slot -- ------------------ procedure Connect_Slot (Object : access Drag_Context_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_GObject_Gint_Void; After : Boolean; Slot : access Glib.Object.GObject_Record'Class := null) is begin Unchecked_Do_Signal_Connect (Object => Object, C_Name => C_Name, Marshaller => Marsh_GObject_Gint_Void'Access, Handler => Cb_To_Address (Handler),-- Set in the closure Slot_Object => Slot, After => After); end Connect_Slot; --------------------------------------------- -- Marsh_Drag_Context_Gdk_Drag_Action_Void -- --------------------------------------------- procedure Marsh_Drag_Context_Gdk_Drag_Action_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address) is pragma Unreferenced (Return_Value, N_Params, Invocation_Hint, User_Data); H : constant Cb_Drag_Context_Gdk_Drag_Action_Void := Address_To_Cb (Get_Callback (Closure)); Obj : constant Drag_Context := Drag_Context (Unchecked_To_Object (Params, 0)); begin H (Obj, Unchecked_To_Gdk_Drag_Action (Params, 1)); exception when E : others => Process_Exception (E); end Marsh_Drag_Context_Gdk_Drag_Action_Void; ---------------------------------------------------- -- Marsh_Drag_Context_Gdk_Drag_Cancel_Reason_Void -- ---------------------------------------------------- procedure Marsh_Drag_Context_Gdk_Drag_Cancel_Reason_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address) is pragma Unreferenced (Return_Value, N_Params, Invocation_Hint, User_Data); H : constant Cb_Drag_Context_Gdk_Drag_Cancel_Reason_Void := Address_To_Cb (Get_Callback (Closure)); Obj : constant Drag_Context := Drag_Context (Unchecked_To_Object (Params, 0)); begin H (Obj, Unchecked_To_Gdk_Drag_Cancel_Reason (Params, 1)); exception when E : others => Process_Exception (E); end Marsh_Drag_Context_Gdk_Drag_Cancel_Reason_Void; ---------------------------------- -- Marsh_Drag_Context_Gint_Void -- ---------------------------------- procedure Marsh_Drag_Context_Gint_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address) is pragma Unreferenced (Return_Value, N_Params, Invocation_Hint, User_Data); H : constant Cb_Drag_Context_Gint_Void := Address_To_Cb (Get_Callback (Closure)); Obj : constant Drag_Context := Drag_Context (Unchecked_To_Object (Params, 0)); begin H (Obj, Unchecked_To_Gint (Params, 1)); exception when E : others => Process_Exception (E); end Marsh_Drag_Context_Gint_Void; ----------------------------- -- Marsh_Drag_Context_Void -- ----------------------------- procedure Marsh_Drag_Context_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address) is pragma Unreferenced (Return_Value, N_Params, Invocation_Hint, User_Data); H : constant Cb_Drag_Context_Void := Address_To_Cb (Get_Callback (Closure)); Obj : constant Drag_Context := Drag_Context (Unchecked_To_Object (Params, 0)); begin H (Obj); exception when E : others => Process_Exception (E); end Marsh_Drag_Context_Void; ---------------------------------------- -- Marsh_GObject_Gdk_Drag_Action_Void -- ---------------------------------------- procedure Marsh_GObject_Gdk_Drag_Action_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address) is pragma Unreferenced (Return_Value, N_Params, Invocation_Hint, User_Data); H : constant Cb_GObject_Gdk_Drag_Action_Void := Address_To_Cb (Get_Callback (Closure)); Obj : constant Glib.Object.GObject := Glib.Object.Convert (Get_Data (Closure)); begin H (Obj, Unchecked_To_Gdk_Drag_Action (Params, 1)); exception when E : others => Process_Exception (E); end Marsh_GObject_Gdk_Drag_Action_Void; ----------------------------------------------- -- Marsh_GObject_Gdk_Drag_Cancel_Reason_Void -- ----------------------------------------------- procedure Marsh_GObject_Gdk_Drag_Cancel_Reason_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address) is pragma Unreferenced (Return_Value, N_Params, Invocation_Hint, User_Data); H : constant Cb_GObject_Gdk_Drag_Cancel_Reason_Void := Address_To_Cb (Get_Callback (Closure)); Obj : constant Glib.Object.GObject := Glib.Object.Convert (Get_Data (Closure)); begin H (Obj, Unchecked_To_Gdk_Drag_Cancel_Reason (Params, 1)); exception when E : others => Process_Exception (E); end Marsh_GObject_Gdk_Drag_Cancel_Reason_Void; ----------------------------- -- Marsh_GObject_Gint_Void -- ----------------------------- procedure Marsh_GObject_Gint_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address) is pragma Unreferenced (Return_Value, N_Params, Invocation_Hint, User_Data); H : constant Cb_GObject_Gint_Void := Address_To_Cb (Get_Callback (Closure)); Obj : constant Glib.Object.GObject := Glib.Object.Convert (Get_Data (Closure)); begin H (Obj, Unchecked_To_Gint (Params, 1)); exception when E : others => Process_Exception (E); end Marsh_GObject_Gint_Void; ------------------------ -- Marsh_GObject_Void -- ------------------------ procedure Marsh_GObject_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address) is pragma Unreferenced (Return_Value, N_Params, Params, Invocation_Hint, User_Data); H : constant Cb_GObject_Void := Address_To_Cb (Get_Callback (Closure)); Obj : constant Glib.Object.GObject := Glib.Object.Convert (Get_Data (Closure)); begin H (Obj); exception when E : others => Process_Exception (E); end Marsh_GObject_Void; ----------------------- -- On_Action_Changed -- ----------------------- procedure On_Action_Changed (Self : not null access Drag_Context_Record; Call : Cb_Drag_Context_Gdk_Drag_Action_Void; After : Boolean := False) is begin Connect (Self, "action-changed" & ASCII.NUL, Call, After); end On_Action_Changed; ----------------------- -- On_Action_Changed -- ----------------------- procedure On_Action_Changed (Self : not null access Drag_Context_Record; Call : Cb_GObject_Gdk_Drag_Action_Void; Slot : not null access Glib.Object.GObject_Record'Class; After : Boolean := False) is begin Connect_Slot (Self, "action-changed" & ASCII.NUL, Call, After, Slot); end On_Action_Changed; --------------- -- On_Cancel -- --------------- procedure On_Cancel (Self : not null access Drag_Context_Record; Call : Cb_Drag_Context_Gdk_Drag_Cancel_Reason_Void; After : Boolean := False) is begin Connect (Self, "cancel" & ASCII.NUL, Call, After); end On_Cancel; --------------- -- On_Cancel -- --------------- procedure On_Cancel (Self : not null access Drag_Context_Record; Call : Cb_GObject_Gdk_Drag_Cancel_Reason_Void; Slot : not null access Glib.Object.GObject_Record'Class; After : Boolean := False) is begin Connect_Slot (Self, "cancel" & ASCII.NUL, Call, After, Slot); end On_Cancel; --------------------- -- On_Dnd_Finished -- --------------------- procedure On_Dnd_Finished (Self : not null access Drag_Context_Record; Call : Cb_Drag_Context_Void; After : Boolean := False) is begin Connect (Self, "dnd-finished" & ASCII.NUL, Call, After); end On_Dnd_Finished; --------------------- -- On_Dnd_Finished -- --------------------- procedure On_Dnd_Finished (Self : not null access Drag_Context_Record; Call : Cb_GObject_Void; Slot : not null access Glib.Object.GObject_Record'Class; After : Boolean := False) is begin Connect_Slot (Self, "dnd-finished" & ASCII.NUL, Call, After, Slot); end On_Dnd_Finished; ----------------------- -- On_Drop_Performed -- ----------------------- procedure On_Drop_Performed (Self : not null access Drag_Context_Record; Call : Cb_Drag_Context_Gint_Void; After : Boolean := False) is begin Connect (Self, "drop-performed" & ASCII.NUL, Call, After); end On_Drop_Performed; ----------------------- -- On_Drop_Performed -- ----------------------- procedure On_Drop_Performed (Self : not null access Drag_Context_Record; Call : Cb_GObject_Gint_Void; Slot : not null access Glib.Object.GObject_Record'Class; After : Boolean := False) is begin Connect_Slot (Self, "drop-performed" & ASCII.NUL, Call, After, Slot); end On_Drop_Performed; end Gdk.Drag_Contexts; gtkada-24.0.0/src/generated/gdk-drag_contexts.ads000066400000000000000000000302541446021174000216600ustar00rootroot00000000000000------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ pragma Warnings (Off, "*is already use-visible*"); with Gdk.Device; use Gdk.Device; with Glib; use Glib; with Glib.Generic_Properties; use Glib.Generic_Properties; with Glib.Object; use Glib.Object; package Gdk.Drag_Contexts is type Drag_Context_Record is new GObject_Record with null record; type Drag_Context is access all Drag_Context_Record'Class; type Gdk_Drag_Action is mod 2 ** Integer'Size; pragma Convention (C, Gdk_Drag_Action); -- Used in Gdk.Drag_Contexts.Drag_Context to indicate what the destination -- should do with the dropped data. Action_Default : constant Gdk_Drag_Action := 1; Action_Copy : constant Gdk_Drag_Action := 2; Action_Move : constant Gdk_Drag_Action := 4; Action_Link : constant Gdk_Drag_Action := 8; Action_Private : constant Gdk_Drag_Action := 16; Action_Ask : constant Gdk_Drag_Action := 32; type Gdk_Drag_Cancel_Reason is ( Drag_Cancel_No_Target, Drag_Cancel_User_Cancelled, Drag_Cancel_Error); pragma Convention (C, Gdk_Drag_Cancel_Reason); -- Used in Gdk.Drag_Contexts.Drag_Context to the reason of a cancelled DND -- operation. type Gdk_Drag_Protocol is ( Drag_Proto_None, Drag_Proto_Motif, Drag_Proto_Xdnd, Drag_Proto_Rootwin, Drag_Proto_Win32_Dropfiles, Drag_Proto_Ole2, Drag_Proto_Local, Drag_Proto_Wayland); pragma Convention (C, Gdk_Drag_Protocol); -- Used in Gdk.Drag_Contexts.Drag_Context to indicate the protocol -- according to which DND is done. ---------------------------- -- Enumeration Properties -- ---------------------------- package Gdk_Drag_Action_Properties is new Generic_Internal_Discrete_Property (Gdk_Drag_Action); type Property_Gdk_Drag_Action is new Gdk_Drag_Action_Properties.Property; package Gdk_Drag_Cancel_Reason_Properties is new Generic_Internal_Discrete_Property (Gdk_Drag_Cancel_Reason); type Property_Gdk_Drag_Cancel_Reason is new Gdk_Drag_Cancel_Reason_Properties.Property; package Gdk_Drag_Protocol_Properties is new Generic_Internal_Discrete_Property (Gdk_Drag_Protocol); type Property_Gdk_Drag_Protocol is new Gdk_Drag_Protocol_Properties.Property; ------------------ -- Constructors -- ------------------ function Get_Type return Glib.GType; pragma Import (C, Get_Type, "gdk_drag_context_get_type"); ------------- -- Methods -- ------------- function Get_Actions (Self : not null access Drag_Context_Record) return Gdk_Drag_Action; -- Determines the bitmask of actions proposed by the source if -- Gdk.Drag_Contexts.Get_Suggested_Action returns -- Gdk.Drag_Contexts.Action_Ask. -- Since: gtk+ 2.22 function Get_Dest_Window (Self : not null access Drag_Context_Record) return Gdk.Gdk_Window; -- Returns the destination window for the DND operation. -- Since: gtk+ 3.0 function Get_Device (Self : not null access Drag_Context_Record) return Gdk.Device.Gdk_Device; -- Returns the Gdk.Device.Gdk_Device associated to the drag context. procedure Set_Device (Self : not null access Drag_Context_Record; Device : not null access Gdk.Device.Gdk_Device_Record'Class); -- Associates a Gdk.Device.Gdk_Device to Context, so all Drag and Drop -- events for Context are emitted as if they came from this device. -- "device": a Gdk.Device.Gdk_Device function Get_Drag_Window (Self : not null access Drag_Context_Record) return Gdk.Gdk_Window; -- Returns the window on which the drag icon should be rendered during the -- drag operation. Note that the window may not be available until the drag -- operation has begun. GDK will move the window in accordance with the -- ongoing drag operation. The window is owned by Context and will be -- destroyed when the drag operation is over. -- Since: gtk+ 3.20 function Get_Protocol (Self : not null access Drag_Context_Record) return Gdk_Drag_Protocol; -- Returns the drag protocol that is used by this context. -- Since: gtk+ 3.0 function Get_Selected_Action (Self : not null access Drag_Context_Record) return Gdk_Drag_Action; -- Determines the action chosen by the drag destination. -- Since: gtk+ 2.22 function Get_Source_Window (Self : not null access Drag_Context_Record) return Gdk.Gdk_Window; -- Returns the Gdk.Gdk_Window where the DND operation started. -- Since: gtk+ 2.22 function Get_Suggested_Action (Self : not null access Drag_Context_Record) return Gdk_Drag_Action; -- Determines the suggested drag action of the context. -- Since: gtk+ 2.22 function Manage_Dnd (Self : not null access Drag_Context_Record; Ipc_Window : Gdk.Gdk_Window; Actions : Gdk_Drag_Action) return Boolean; -- Requests the drag and drop operation to be managed by Context. When a -- drag and drop operation becomes managed, the -- Gdk.Drag_Contexts.Drag_Context will internally handle all input and -- source-side Gdk.Event.Gdk_Event_DND events as required by the windowing -- system. -- Once the drag and drop operation is managed, the drag context will emit -- the following signals: - The -- Gdk.Drag_Contexts.Drag_Context::action-changed signal whenever the final -- action to be performed by the drag and drop operation changes. - The -- Gdk.Drag_Contexts.Drag_Context::drop-performed signal after the user -- performs the drag and drop gesture (typically by releasing the mouse -- button). - The Gdk.Drag_Contexts.Drag_Context::dnd-finished signal after -- the drag and drop operation concludes (after all Gdk_Selection transfers -- happen). - The Gdk.Drag_Contexts.Drag_Context::cancel signal if the drag -- and drop operation is finished but doesn't happen over an accepting -- destination, or is cancelled through other means. -- Since: gtk+ 3.20 -- "ipc_window": Window to use for IPC messaging/events -- "actions": the actions supported by the drag source procedure Set_Hotspot (Self : not null access Drag_Context_Record; Hot_X : Glib.Gint; Hot_Y : Glib.Gint); -- Sets the position of the drag window that will be kept under the cursor -- hotspot. Initially, the hotspot is at the top left corner of the drag -- window. -- Since: gtk+ 3.20 -- "hot_x": x coordinate of the drag window hotspot -- "hot_y": y coordinate of the drag window hotspot ------------- -- Signals -- ------------- type Cb_Drag_Context_Gdk_Drag_Action_Void is not null access procedure (Self : access Drag_Context_Record'Class; Action : Gdk_Drag_Action); type Cb_GObject_Gdk_Drag_Action_Void is not null access procedure (Self : access Glib.Object.GObject_Record'Class; Action : Gdk_Drag_Action); Signal_Action_Changed : constant Glib.Signal_Name := "action-changed"; procedure On_Action_Changed (Self : not null access Drag_Context_Record; Call : Cb_Drag_Context_Gdk_Drag_Action_Void; After : Boolean := False); procedure On_Action_Changed (Self : not null access Drag_Context_Record; Call : Cb_GObject_Gdk_Drag_Action_Void; Slot : not null access Glib.Object.GObject_Record'Class; After : Boolean := False); -- A new action is being chosen for the drag and drop operation. -- -- This signal will only be emitted if the Gdk.Drag_Contexts.Drag_Context -- manages the drag and drop operation. See Gdk.Drag_Contexts.Manage_Dnd -- for more information. type Cb_Drag_Context_Gdk_Drag_Cancel_Reason_Void is not null access procedure (Self : access Drag_Context_Record'Class; Reason : Gdk_Drag_Cancel_Reason); type Cb_GObject_Gdk_Drag_Cancel_Reason_Void is not null access procedure (Self : access Glib.Object.GObject_Record'Class; Reason : Gdk_Drag_Cancel_Reason); Signal_Cancel : constant Glib.Signal_Name := "cancel"; procedure On_Cancel (Self : not null access Drag_Context_Record; Call : Cb_Drag_Context_Gdk_Drag_Cancel_Reason_Void; After : Boolean := False); procedure On_Cancel (Self : not null access Drag_Context_Record; Call : Cb_GObject_Gdk_Drag_Cancel_Reason_Void; Slot : not null access Glib.Object.GObject_Record'Class; After : Boolean := False); -- The drag and drop operation was cancelled. -- -- This signal will only be emitted if the Gdk.Drag_Contexts.Drag_Context -- manages the drag and drop operation. See Gdk.Drag_Contexts.Manage_Dnd -- for more information. type Cb_Drag_Context_Void is not null access procedure (Self : access Drag_Context_Record'Class); type Cb_GObject_Void is not null access procedure (Self : access Glib.Object.GObject_Record'Class); Signal_Dnd_Finished : constant Glib.Signal_Name := "dnd-finished"; procedure On_Dnd_Finished (Self : not null access Drag_Context_Record; Call : Cb_Drag_Context_Void; After : Boolean := False); procedure On_Dnd_Finished (Self : not null access Drag_Context_Record; Call : Cb_GObject_Void; Slot : not null access Glib.Object.GObject_Record'Class; After : Boolean := False); -- The drag and drop operation was finished, the drag destination finished -- reading all data. The drag source can now free all miscellaneous data. -- -- This signal will only be emitted if the Gdk.Drag_Contexts.Drag_Context -- manages the drag and drop operation. See Gdk.Drag_Contexts.Manage_Dnd -- for more information. type Cb_Drag_Context_Gint_Void is not null access procedure (Self : access Drag_Context_Record'Class; Time : Glib.Gint); type Cb_GObject_Gint_Void is not null access procedure (Self : access Glib.Object.GObject_Record'Class; Time : Glib.Gint); Signal_Drop_Performed : constant Glib.Signal_Name := "drop-performed"; procedure On_Drop_Performed (Self : not null access Drag_Context_Record; Call : Cb_Drag_Context_Gint_Void; After : Boolean := False); procedure On_Drop_Performed (Self : not null access Drag_Context_Record; Call : Cb_GObject_Gint_Void; Slot : not null access Glib.Object.GObject_Record'Class; After : Boolean := False); -- The drag and drop operation was performed on an accepting client. -- -- This signal will only be emitted if the Gdk.Drag_Contexts.Drag_Context -- manages the drag and drop operation. See Gdk.Drag_Contexts.Manage_Dnd -- for more information. end Gdk.Drag_Contexts; gtkada-24.0.0/src/generated/gdk-drawing_context.adb000066400000000000000000000072631446021174000221760ustar00rootroot00000000000000------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ pragma Style_Checks (Off); pragma Warnings (Off, "*is already use-visible*"); with Glib.Type_Conversion_Hooks; use Glib.Type_Conversion_Hooks; package body Gdk.Drawing_Context is package Type_Conversion_Gdk_Drawing_Context is new Glib.Type_Conversion_Hooks.Hook_Registrator (Get_Type'Access, Gdk_Drawing_Context_Record); pragma Unreferenced (Type_Conversion_Gdk_Drawing_Context); ----------------------- -- Get_Cairo_Context -- ----------------------- function Get_Cairo_Context (Self : not null access Gdk_Drawing_Context_Record) return Cairo.Cairo_Context is function Internal (Self : System.Address) return Cairo.Cairo_Context; pragma Import (C, Internal, "gdk_drawing_context_get_cairo_context"); begin return Internal (Get_Object (Self)); end Get_Cairo_Context; -------------- -- Get_Clip -- -------------- function Get_Clip (Self : not null access Gdk_Drawing_Context_Record) return Cairo.Region.Cairo_Region is function Internal (Self : System.Address) return Cairo.Region.Cairo_Region; pragma Import (C, Internal, "gdk_drawing_context_get_clip"); begin return Internal (Get_Object (Self)); end Get_Clip; ---------------- -- Get_Window -- ---------------- function Get_Window (Self : not null access Gdk_Drawing_Context_Record) return Gdk.Gdk_Window is function Internal (Self : System.Address) return Gdk.Gdk_Window; pragma Import (C, Internal, "gdk_drawing_context_get_window"); begin return Internal (Get_Object (Self)); end Get_Window; -------------- -- Is_Valid -- -------------- function Is_Valid (Self : not null access Gdk_Drawing_Context_Record) return Boolean is function Internal (Self : System.Address) return Glib.Gboolean; pragma Import (C, Internal, "gdk_drawing_context_is_valid"); begin return Internal (Get_Object (Self)) /= 0; end Is_Valid; end Gdk.Drawing_Context; gtkada-24.0.0/src/generated/gdk-drawing_context.ads000066400000000000000000000112771446021174000222170ustar00rootroot00000000000000------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ -- -- Gdk.Drawing_Context.Gdk_Drawing_Context is an object that represents the -- current drawing state of a Gdk.Gdk_Window. -- -- It's possible to use a Gdk.Drawing_Context.Gdk_Drawing_Context to draw on -- a Gdk.Gdk_Window via rendering API like Cairo or OpenGL. -- -- A Gdk.Drawing_Context.Gdk_Drawing_Context can only be created by calling -- Gdk.Window.Begin_Draw_Frame and will be valid until a call to -- Gdk.Window.End_Draw_Frame. -- -- Gdk.Drawing_Context.Gdk_Drawing_Context is available since GDK 3.22 -- -- pragma Warnings (Off, "*is already use-visible*"); with Cairo; use Cairo; with Cairo.Region; use Cairo.Region; with Glib; use Glib; with Glib.Object; use Glib.Object; with Glib.Properties; use Glib.Properties; package Gdk.Drawing_Context is type Gdk_Drawing_Context_Record is new GObject_Record with null record; type Gdk_Drawing_Context is access all Gdk_Drawing_Context_Record'Class; ------------------ -- Constructors -- ------------------ function Get_Type return Glib.GType; pragma Import (C, Get_Type, "gdk_drawing_context_get_type"); ------------- -- Methods -- ------------- function Get_Cairo_Context (Self : not null access Gdk_Drawing_Context_Record) return Cairo.Cairo_Context; -- Retrieves a Cairo context to be used to draw on the Gdk.Gdk_Window that -- created the Gdk.Drawing_Context.Gdk_Drawing_Context. -- The returned context is guaranteed to be valid as long as the -- Gdk.Drawing_Context.Gdk_Drawing_Context is valid, that is between a call -- to Gdk.Window.Begin_Draw_Frame and Gdk.Window.End_Draw_Frame. -- Since: gtk+ 3.22 function Get_Clip (Self : not null access Gdk_Drawing_Context_Record) return Cairo.Region.Cairo_Region; -- Retrieves a copy of the clip region used when creating the Context. -- Since: gtk+ 3.22 function Get_Window (Self : not null access Gdk_Drawing_Context_Record) return Gdk.Gdk_Window; -- Retrieves the window that created the drawing Context. -- Since: gtk+ 3.22 function Is_Valid (Self : not null access Gdk_Drawing_Context_Record) return Boolean; -- Checks whether the given Gdk.Drawing_Context.Gdk_Drawing_Context is -- valid. -- Since: gtk+ 3.22 ---------------- -- Properties -- ---------------- -- The following properties are defined for this widget. See -- Glib.Properties for more information on properties) Clip_Property : constant Glib.Properties.Property_Boxed; -- Type: cairo.Region -- The clip region applied to the drawing context. Window_Property : constant Glib.Properties.Property_Object; -- Type: Gtk.Window.Gtk_Window -- The Gdk.Gdk_Window that created the drawing context. private Window_Property : constant Glib.Properties.Property_Object := Glib.Properties.Build ("window"); Clip_Property : constant Glib.Properties.Property_Boxed := Glib.Properties.Build ("clip"); end Gdk.Drawing_Context; gtkada-24.0.0/src/generated/gdk-event.adb000066400000000000000000000452261446021174000201210ustar00rootroot00000000000000------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ pragma Style_Checks (Off); pragma Warnings (Off, "*is already use-visible*"); with Ada.Unchecked_Conversion; package body Gdk.Event is function From_Object_Free (B : access Gdk_Event_Sequence) return Gdk_Event_Sequence is Result : constant Gdk_Event_Sequence := B.all; begin Glib.g_free (B.all'Address); return Result; end From_Object_Free; function From_Object_Free (B : access Gdk_Event_Any) return Gdk_Event_Any is Result : constant Gdk_Event_Any := B.all; begin Glib.g_free (B.all'Address); return Result; end From_Object_Free; function From_Object_Free (B : access Gdk_Event_Button) return Gdk_Event_Button is Result : constant Gdk_Event_Button := B.all; begin Glib.g_free (B.all'Address); return Result; end From_Object_Free; function From_Object_Free (B : access Gdk_Event_Expose) return Gdk_Event_Expose is Result : constant Gdk_Event_Expose := B.all; begin Glib.g_free (B.all'Address); return Result; end From_Object_Free; function From_Object_Free (B : access Gdk_Event_Visibility) return Gdk_Event_Visibility is Result : constant Gdk_Event_Visibility := B.all; begin Glib.g_free (B.all'Address); return Result; end From_Object_Free; function From_Object_Free (B : access Gdk_Event_Motion) return Gdk_Event_Motion is Result : constant Gdk_Event_Motion := B.all; begin Glib.g_free (B.all'Address); return Result; end From_Object_Free; function From_Object_Free (B : access Gdk_Event_Scroll) return Gdk_Event_Scroll is Result : constant Gdk_Event_Scroll := B.all; begin Glib.g_free (B.all'Address); return Result; end From_Object_Free; function From_Object_Free (B : access Gdk_Event_Key) return Gdk_Event_Key is Result : constant Gdk_Event_Key := B.all; begin Glib.g_free (B.all'Address); return Result; end From_Object_Free; function From_Object_Free (B : access Gdk_Event_Crossing) return Gdk_Event_Crossing is Result : constant Gdk_Event_Crossing := B.all; begin Glib.g_free (B.all'Address); return Result; end From_Object_Free; function From_Object_Free (B : access Gdk_Event_Focus) return Gdk_Event_Focus is Result : constant Gdk_Event_Focus := B.all; begin Glib.g_free (B.all'Address); return Result; end From_Object_Free; function From_Object_Free (B : access Gdk_Event_Configure) return Gdk_Event_Configure is Result : constant Gdk_Event_Configure := B.all; begin Glib.g_free (B.all'Address); return Result; end From_Object_Free; function From_Object_Free (B : access Gdk_Event_Property) return Gdk_Event_Property is Result : constant Gdk_Event_Property := B.all; begin Glib.g_free (B.all'Address); return Result; end From_Object_Free; function From_Object_Free (B : access Gdk_Event_Selection) return Gdk_Event_Selection is Result : constant Gdk_Event_Selection := B.all; begin Glib.g_free (B.all'Address); return Result; end From_Object_Free; function From_Object_Free (B : access Gdk_Event_Owner_Change) return Gdk_Event_Owner_Change is Result : constant Gdk_Event_Owner_Change := B.all; begin Glib.g_free (B.all'Address); return Result; end From_Object_Free; function From_Object_Free (B : access Gdk_Event_Proximity) return Gdk_Event_Proximity is Result : constant Gdk_Event_Proximity := B.all; begin Glib.g_free (B.all'Address); return Result; end From_Object_Free; function From_Object_Free (B : access Gdk_Event_DND) return Gdk_Event_DND is Result : constant Gdk_Event_DND := B.all; begin Glib.g_free (B.all'Address); return Result; end From_Object_Free; function From_Object_Free (B : access Gdk_Event_Window_State) return Gdk_Event_Window_State is Result : constant Gdk_Event_Window_State := B.all; begin Glib.g_free (B.all'Address); return Result; end From_Object_Free; function From_Object_Free (B : access Gdk_Event_Setting) return Gdk_Event_Setting is Result : constant Gdk_Event_Setting := B.all; begin Glib.g_free (B.all'Address); return Result; end From_Object_Free; function From_Object_Free (B : access Gdk_Event_Touch) return Gdk_Event_Touch is Result : constant Gdk_Event_Touch := B.all; begin Glib.g_free (B.all'Address); return Result; end From_Object_Free; function From_Object_Free (B : access Gdk_Event_Grab_Broken) return Gdk_Event_Grab_Broken is Result : constant Gdk_Event_Grab_Broken := B.all; begin Glib.g_free (B.all'Address); return Result; end From_Object_Free; function From_Object_Free (B : access Gdk_Event_Touchpad_Swipe) return Gdk_Event_Touchpad_Swipe is Result : constant Gdk_Event_Touchpad_Swipe := B.all; begin Glib.g_free (B.all'Address); return Result; end From_Object_Free; function From_Object_Free (B : access Gdk_Event_Touchpad_Pinch) return Gdk_Event_Touchpad_Pinch is Result : constant Gdk_Event_Touchpad_Pinch := B.all; begin Glib.g_free (B.all'Address); return Result; end From_Object_Free; function From_Object_Free (B : access Gdk_Event_Pad_Button) return Gdk_Event_Pad_Button is Result : constant Gdk_Event_Pad_Button := B.all; begin Glib.g_free (B.all'Address); return Result; end From_Object_Free; function From_Object_Free (B : access Gdk_Event_Pad_Axis) return Gdk_Event_Pad_Axis is Result : constant Gdk_Event_Pad_Axis := B.all; begin Glib.g_free (B.all'Address); return Result; end From_Object_Free; function From_Object_Free (B : access Gdk_Event_Pad_Group_Mode) return Gdk_Event_Pad_Group_Mode is Result : constant Gdk_Event_Pad_Group_Mode := B.all; begin Glib.g_free (B.all'Address); return Result; end From_Object_Free; function From_Object_Free (B : access Gdk_Event_Record) return Gdk_Event_Record is Result : constant Gdk_Event_Record := B.all; begin Glib.g_free (B.all'Address); return Result; end From_Object_Free; function From_Address (C : System.Address) return Gdk_Event is function Convert is new Ada.Unchecked_Conversion (Glib.C_Proxy, Gdk_Event); begin return Convert (Glib.C_Proxy'(Glib.To_Proxy (C))); end From_Address; function To_Address (C : Gdk_Event) return System.Address is function Convert is new Ada.Unchecked_Conversion (Gdk_Event, Glib.C_Proxy); begin return Glib.To_Address (Convert (C)); end To_Address; function Get_Event (Value : Glib.Values.GValue) return Gdk_Event is function Convert is new Ada.Unchecked_Conversion (Glib.C_Proxy, Gdk_Event); begin return Convert (Glib.Values.Get_Proxy (Value)); end Get_Event; function To_Event (Event : access Gdk_Event_Button) return Gdk_Event is type Gdk_Event_Button_Access is access all Gdk_Event_Button; function Convert is new Ada.Unchecked_Conversion (Gdk_Event_Button_Access, Gdk_Event); begin return Convert (Gdk_Event_Button_Access (Event)); end To_Event; function To_Event (Event : access Gdk_Event_Key) return Gdk_Event is type Gdk_Event_Key_Access is access all Gdk_Event_Key; function Convert is new Ada.Unchecked_Conversion (Gdk_Event_Key_Access, Gdk_Event); begin return Convert (Gdk_Event_Key_Access (Event)); end To_Event; procedure C_Gdk_Event_Handler_Set (Func : System.Address; Data : System.Address; Notify : System.Address); pragma Import (C, C_Gdk_Event_Handler_Set, "gdk_event_handler_set"); -- Sets the function to call to handle all events from GDK. -- Note that GTK+ uses this to install its own event handler, so it is -- usually not useful for GTK+ applications. (Although an application can -- call this function then call Gtk.Main.Main_Do_Event to pass events to -- GTK+.) -- "func": the function to call to handle events from GDK. -- "data": user data to pass to the function. -- "notify": the function to call when the handler function is removed, -- i.e. when Gdk.Event.Handler_Set is called with another event handler. function To_Gdk_Event_Func is new Ada.Unchecked_Conversion (System.Address, Gdk_Event_Func); function To_Address is new Ada.Unchecked_Conversion (Gdk_Event_Func, System.Address); procedure Internal_Gdk_Event_Func (Event : Gdk.Event.Gdk_Event; Data : System.Address); pragma Convention (C, Internal_Gdk_Event_Func); -- "event": the Gdk.Event.Gdk_Event to process. -- "data": user data set when the event handler was installed with -- Gdk.Event.Handler_Set. ----------------------------- -- Internal_Gdk_Event_Func -- ----------------------------- procedure Internal_Gdk_Event_Func (Event : Gdk.Event.Gdk_Event; Data : System.Address) is Func : constant Gdk_Event_Func := To_Gdk_Event_Func (Data); begin Func (Event); end Internal_Gdk_Event_Func; ------------------- -- Gdk_Event_New -- ------------------- function Gdk_Event_New (The_Type : Gdk_Event_Type) return Gdk_Event is function Internal (The_Type : Gdk_Event_Type) return Gdk_Event; pragma Import (C, Internal, "gdk_event_new"); Event : Gdk_Event; begin Event := Internal (The_Type); return Event; end Gdk_Event_New; ------------- -- Gdk_New -- ------------- procedure Gdk_New (Event : out Gdk_Event; The_Type : Gdk_Event_Type) is function Internal (The_Type : Gdk_Event_Type) return Gdk_Event; pragma Import (C, Internal, "gdk_event_new"); begin Event := Internal (The_Type); end Gdk_New; --------------- -- Get_Angle -- --------------- function Get_Angle (Event : Gdk_Event; Event2 : Gdk_Event; Angle : access Gdouble) return Boolean is function Internal (Event : Gdk_Event; Event2 : Gdk_Event; Acc_Angle : access Gdouble) return Glib.Gboolean; pragma Import (C, Internal, "gdk_events_get_angle"); Acc_Angle : aliased Gdouble; Tmp_Return : Glib.Gboolean; begin Tmp_Return := Internal (Event, Event2, Acc_Angle'Access); Angle.all := Acc_Angle; return Tmp_Return /= 0; end Get_Angle; ---------------- -- Get_Center -- ---------------- function Get_Center (Event : Gdk_Event; Event2 : Gdk_Event; X : access Gdouble; Y : access Gdouble) return Boolean is function Internal (Event : Gdk_Event; Event2 : Gdk_Event; Acc_X : access Gdouble; Acc_Y : access Gdouble) return Glib.Gboolean; pragma Import (C, Internal, "gdk_events_get_center"); Acc_X : aliased Gdouble; Acc_Y : aliased Gdouble; Tmp_Return : Glib.Gboolean; begin Tmp_Return := Internal (Event, Event2, Acc_X'Access, Acc_Y'Access); X.all := Acc_X; Y.all := Acc_Y; return Tmp_Return /= 0; end Get_Center; --------------------- -- Get_Device_Tool -- --------------------- function Get_Device_Tool (Event : Gdk_Event) return Gdk.Device_Tool.Gdk_Device_Tool is function Internal (Event : Gdk_Event) return System.Address; pragma Import (C, Internal, "gdk_event_get_device_tool"); Stub_Gdk_Device_Tool : Gdk.Device_Tool.Gdk_Device_Tool_Record; begin return Gdk.Device_Tool.Gdk_Device_Tool (Get_User_Data (Internal (Event), Stub_Gdk_Device_Tool)); end Get_Device_Tool; ------------------ -- Get_Distance -- ------------------ function Get_Distance (Event : Gdk_Event; Event2 : Gdk_Event; Distance : access Gdouble) return Boolean is function Internal (Event : Gdk_Event; Event2 : Gdk_Event; Acc_Distance : access Gdouble) return Glib.Gboolean; pragma Import (C, Internal, "gdk_events_get_distance"); Acc_Distance : aliased Gdouble; Tmp_Return : Glib.Gboolean; begin Tmp_Return := Internal (Event, Event2, Acc_Distance'Access); Distance.all := Acc_Distance; return Tmp_Return /= 0; end Get_Distance; -------------------------- -- Get_Pointer_Emulated -- -------------------------- function Get_Pointer_Emulated (Event : Gdk_Event) return Boolean is function Internal (Event : Gdk_Event) return Glib.Gboolean; pragma Import (C, Internal, "gdk_event_get_pointer_emulated"); begin return Internal (Event) /= 0; end Get_Pointer_Emulated; -------------- -- Get_Seat -- -------------- function Get_Seat (Event : Gdk_Event) return Glib.Object.GObject is function Internal (Event : Gdk_Event) return System.Address; pragma Import (C, Internal, "gdk_event_get_seat"); Stub_GObject : Glib.Object.GObject_Record; begin return Get_User_Data (Internal (Event), Stub_GObject); end Get_Seat; ----------------- -- Handler_Set -- ----------------- procedure Handler_Set (Func : Gdk_Event_Func) is begin if Func = null then C_Gdk_Event_Handler_Set (System.Null_Address, System.Null_Address, System.Null_Address); else C_Gdk_Event_Handler_Set (Internal_Gdk_Event_Func'Address, To_Address (Func), System.Null_Address); end if; end Handler_Set; package body Handler_Set_User_Data is package Users is new Glib.Object.User_Data_Closure (User_Data_Type, Destroy); function To_Gdk_Event_Func is new Ada.Unchecked_Conversion (System.Address, Gdk_Event_Func); function To_Address is new Ada.Unchecked_Conversion (Gdk_Event_Func, System.Address); procedure Internal_Cb (Event : Gdk.Event.Gdk_Event; Data : System.Address); pragma Convention (C, Internal_Cb); -- Specifies the type of function passed to Gdk.Event.Handler_Set to -- handle all GDK events. -- "event": the Gdk.Event.Gdk_Event to process. -- "data": user data set when the event handler was installed with -- Gdk.Event.Handler_Set. ----------------- -- Handler_Set -- ----------------- procedure Handler_Set (Func : Gdk_Event_Func; Data : User_Data_Type) is D : System.Address; begin if Func = null then C_Gdk_Event_Handler_Set (System.Null_Address, System.Null_Address, Users.Free_Data'Address); else D := Users.Build (To_Address (Func), Data); C_Gdk_Event_Handler_Set (Internal_Cb'Address, D, Users.Free_Data'Address); end if; end Handler_Set; ----------------- -- Internal_Cb -- ----------------- procedure Internal_Cb (Event : Gdk.Event.Gdk_Event; Data : System.Address) is D : constant Users.Internal_Data_Access := Users.Convert (Data); begin To_Gdk_Event_Func (D.Func) (Event, D.Data.all); end Internal_Cb; end Handler_Set_User_Data; -------------------------- -- Is_Scroll_Stop_Event -- -------------------------- function Is_Scroll_Stop_Event (Event : Gdk_Event) return Boolean is function Internal (Event : Gdk_Event) return Glib.Gboolean; pragma Import (C, Internal, "gdk_event_is_scroll_stop_event"); begin return Internal (Event) /= 0; end Is_Scroll_Stop_Event; --------------------- -- Set_Device_Tool -- --------------------- procedure Set_Device_Tool (Event : Gdk_Event; Tool : access Gdk.Device_Tool.Gdk_Device_Tool_Record'Class) is procedure Internal (Event : Gdk_Event; Tool : System.Address); pragma Import (C, Internal, "gdk_event_set_device_tool"); begin Internal (Event, Get_Object_Or_Null (GObject (Tool))); end Set_Device_Tool; --------------------------- -- Triggers_Context_Menu -- --------------------------- function Triggers_Context_Menu (Event : Gdk_Event) return Boolean is function Internal (Event : Gdk_Event) return Glib.Gboolean; pragma Import (C, Internal, "gdk_event_triggers_context_menu"); begin return Internal (Event) /= 0; end Triggers_Context_Menu; -------------------- -- Events_Pending -- -------------------- function Events_Pending return Boolean is function Internal return Glib.Gboolean; pragma Import (C, Internal, "gdk_events_pending"); begin return Internal /= 0; end Events_Pending; --------------------- -- Get_Show_Events -- --------------------- function Get_Show_Events return Boolean is function Internal return Glib.Gboolean; pragma Import (C, Internal, "gdk_get_show_events"); begin return Internal /= 0; end Get_Show_Events; --------------------- -- Set_Show_Events -- --------------------- procedure Set_Show_Events (Show_Events : Boolean) is procedure Internal (Show_Events : Glib.Gboolean); pragma Import (C, Internal, "gdk_set_show_events"); begin Internal (Boolean'Pos (Show_Events)); end Set_Show_Events; end Gdk.Event; gtkada-24.0.0/src/generated/gdk-event.ads000066400000000000000000001440201446021174000201320ustar00rootroot00000000000000------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ -- -- A Gdk.Event.Gdk_Event contains a union of all of the event types, and -- allows access to the data fields in a number of ways. -- -- The event type is always the first field in all of the event types, and -- can always be accessed with the following code, no matter what type of -- event it is: |[ GdkEvent *event; GdkEventType type; -- -- type = event->type; ]| -- -- To access other fields of the event, the pointer to the event can be cast -- to the appropriate event type, or the union member name can be used. For -- example if the event type is Gdk.Event.Button_Press then the x coordinate -- of the button press can be accessed with: |[ GdkEvent -- *event; gdouble x; -- -- x = ((GdkEventButton*)event)->x; ]| or: |[ GdkEvent -- *event; gdouble x; -- -- x = event->button.x; ]| -- -- -- Gdk, the low-level API pragma Warnings (Off, "*is already use-visible*"); with Cairo.Region; use Cairo.Region; with Gdk.Device_Tool; use Gdk.Device_Tool; with Gdk.Rectangle; use Gdk.Rectangle; with Gdk.Types; use Gdk.Types; with Glib; use Glib; with Glib.Generic_Properties; use Glib.Generic_Properties; with Glib.Object; use Glib.Object; with Glib.Values; use Glib.Values; with Gtkada.Types; use Gtkada.Types; package Gdk.Event is type Gdk_Event_Type is ( Nothing, Delete, Destroy, Expose, Motion_Notify, Button_Press, Gdk_2button_Press, Gdk_3button_Press, Button_Release, Key_Press, Key_Release, Enter_Notify, Leave_Notify, Focus_Change, Configure, Map, Unmap, Property_Notify, Selection_Clear, Selection_Request, Selection_Notify, Proximity_In, Proximity_Out, Drag_Enter, Drag_Leave, Drag_Motion, Drag_Status, Drop_Start, Drop_Finished, Client_Event, Visibility_Notify, Scroll, Window_State, Setting, Owner_Change, Grab_Broken, Damage, Touch_Begin, Touch_Update, Touch_End, Touch_Cancel, Touchpad_Swipe, Touchpad_Pinch, Pad_Button_Press, Pad_Button_Release, Pad_Ring, Pad_Strip, Pad_Group_Mode); pragma Convention (C, Gdk_Event_Type); -- Specifies the type of the event. -- -- Do not confuse these events with the signals that GTK+ widgets emit. -- Although many of these events result in corresponding signals being -- emitted, the events are often transformed or filtered along the way. -- -- In some language bindings, the values Gdk.Event.Gdk_2button_Press and -- Gdk.Event.Gdk_3button_Press would translate into something syntactically -- invalid (eg `Gdk.EventType.2ButtonPress`, where a symbol is not allowed -- to start with a number). In that case, the aliases -- GDK_DOUBLE_BUTTON_PRESS and GDK_TRIPLE_BUTTON_PRESS can be used instead. for Gdk_Event_Type use ( Nothing => -1, Delete => 0, Destroy => 1, Expose => 2, Motion_Notify => 3, Button_Press => 4, Gdk_2button_Press => 5, Gdk_3button_Press => 6, Button_Release => 7, Key_Press => 8, Key_Release => 9, Enter_Notify => 10, Leave_Notify => 11, Focus_Change => 12, Configure => 13, Map => 14, Unmap => 15, Property_Notify => 16, Selection_Clear => 17, Selection_Request => 18, Selection_Notify => 19, Proximity_In => 20, Proximity_Out => 21, Drag_Enter => 22, Drag_Leave => 23, Drag_Motion => 24, Drag_Status => 25, Drop_Start => 26, Drop_Finished => 27, Client_Event => 28, Visibility_Notify => 29, Scroll => 31, Window_State => 32, Setting => 33, Owner_Change => 34, Grab_Broken => 35, Damage => 36, Touch_Begin => 37, Touch_Update => 38, Touch_End => 39, Touch_Cancel => 40, Touchpad_Swipe => 41, Touchpad_Pinch => 42, Pad_Button_Press => 43, Pad_Button_Release => 44, Pad_Ring => 45, Pad_Strip => 46, Pad_Group_Mode => 47); type Gdk_Event_Mask is mod 2 ** Integer'Size; pragma Convention (C, Gdk_Event_Mask); -- A set of bit-flags to indicate which events a window is to receive. -- Most of these masks map onto one or more of the Gdk.Event.Gdk_Event_Type -- event types above. -- -- See the [input handling overview][chap-input-handling] for details of -- [event masks][event-masks] and [event propagation][event-propagation]. -- -- Gdk.Event.Pointer_Motion_Hint_Mask is deprecated. It is a special mask -- to reduce the number of Gdk.Event.Motion_Notify events received. When -- using Gdk.Event.Pointer_Motion_Hint_Mask, fewer Gdk.Event.Motion_Notify -- events will be sent, some of which are marked as a hint (the is_hint -- member is True). To receive more motion events after a motion hint -- event, the application needs to asks for more, by calling -- Gdk.Event.Request_Motions. -- -- Since GTK 3.8, motion events are already compressed by default, -- independent of this mechanism. This compression can be disabled with -- Gdk.Window.Set_Event_Compression. See the documentation of that function -- for details. -- -- If Gdk.Event.Touch_Mask is enabled, the window will receive touch -- events from touch-enabled devices. Those will come as sequences of -- Gdk.Event.Gdk_Event_Touch with type Gdk.Event.Touch_Update, enclosed by -- two events with type Gdk.Event.Touch_Begin and Gdk.Event.Touch_End (or -- Gdk.Event.Touch_Cancel). Gdk.Event.Get_Event_Sequence returns the event -- sequence for these events, so different sequences may be distinguished. Exposure_Mask : constant Gdk_Event_Mask := 2; Pointer_Motion_Mask : constant Gdk_Event_Mask := 4; Pointer_Motion_Hint_Mask : constant Gdk_Event_Mask := 8; Button_Motion_Mask : constant Gdk_Event_Mask := 16; Button1_Motion_Mask : constant Gdk_Event_Mask := 32; Button2_Motion_Mask : constant Gdk_Event_Mask := 64; Button3_Motion_Mask : constant Gdk_Event_Mask := 128; Button_Press_Mask : constant Gdk_Event_Mask := 256; Button_Release_Mask : constant Gdk_Event_Mask := 512; Key_Press_Mask : constant Gdk_Event_Mask := 1024; Key_Release_Mask : constant Gdk_Event_Mask := 2048; Enter_Notify_Mask : constant Gdk_Event_Mask := 4096; Leave_Notify_Mask : constant Gdk_Event_Mask := 8192; Focus_Change_Mask : constant Gdk_Event_Mask := 16384; Structure_Mask : constant Gdk_Event_Mask := 32768; Property_Change_Mask : constant Gdk_Event_Mask := 65536; Visibility_Notify_Mask : constant Gdk_Event_Mask := 131072; Proximity_In_Mask : constant Gdk_Event_Mask := 262144; Proximity_Out_Mask : constant Gdk_Event_Mask := 524288; Substructure_Mask : constant Gdk_Event_Mask := 1048576; Scroll_Mask : constant Gdk_Event_Mask := 2097152; Touch_Mask : constant Gdk_Event_Mask := 4194304; Smooth_Scroll_Mask : constant Gdk_Event_Mask := 8388608; Touchpad_Gesture_Mask : constant Gdk_Event_Mask := 16777216; Tablet_Pad_Mask : constant Gdk_Event_Mask := 33554432; All_Events_Mask : constant Gdk_Event_Mask := 67108862; type Gdk_Visibility_State is ( Visibility_Unobscured, Visibility_Partial, Visibility_Fully_Obscured); pragma Convention (C, Gdk_Visibility_State); -- Specifies the visiblity status of a window for a -- Gdk.Event.Gdk_Event_Visibility. type Gdk_Scroll_Direction is ( Scroll_Up, Scroll_Down, Scroll_Left, Scroll_Right, Scroll_Smooth); pragma Convention (C, Gdk_Scroll_Direction); -- Specifies the direction for Gdk.Event.Gdk_Event_Scroll. type Gdk_Notify_Type is ( Notify_Ancestor, Notify_Virtual, Notify_Inferior, Notify_Nonlinear, Notify_Nonlinear_Virtual, Notify_Unknown); pragma Convention (C, Gdk_Notify_Type); -- Specifies the kind of crossing for Gdk.Event.Gdk_Event_Crossing. -- -- See the X11 protocol specification of LeaveNotify for full details of -- crossing event generation. type Gdk_Crossing_Mode is ( Crossing_Normal, Crossing_Grab, Crossing_Ungrab, Crossing_Gtk_Grab, Crossing_Gtk_Ungrab, Crossing_State_Changed, Crossing_Touch_Begin, Crossing_Touch_End, Crossing_Device_Switch); pragma Convention (C, Gdk_Crossing_Mode); -- Specifies the crossing mode for Gdk.Event.Gdk_Event_Crossing. type Gdk_Property_State is ( Property_New_Value, Property_Delete); pragma Convention (C, Gdk_Property_State); -- Specifies the type of a property change for a -- Gdk.Event.Gdk_Event_Property. type Gdk_Window_State is mod 2 ** Integer'Size; pragma Convention (C, Gdk_Window_State); -- Specifies the state of a toplevel window. Window_State_Withdrawn : constant Gdk_Window_State := 1; Window_State_Iconified : constant Gdk_Window_State := 2; Window_State_Maximized : constant Gdk_Window_State := 4; Window_State_Sticky : constant Gdk_Window_State := 8; Window_State_Fullscreen : constant Gdk_Window_State := 16; Window_State_Above : constant Gdk_Window_State := 32; Window_State_Below : constant Gdk_Window_State := 64; Window_State_Focused : constant Gdk_Window_State := 128; Window_State_Tiled : constant Gdk_Window_State := 256; Window_State_Top_Tiled : constant Gdk_Window_State := 512; Window_State_Top_Resizable : constant Gdk_Window_State := 1024; Window_State_Right_Tiled : constant Gdk_Window_State := 2048; Window_State_Right_Resizable : constant Gdk_Window_State := 4096; Window_State_Bottom_Tiled : constant Gdk_Window_State := 8192; Window_State_Bottom_Resizable : constant Gdk_Window_State := 16384; Window_State_Left_Tiled : constant Gdk_Window_State := 32768; Window_State_Left_Resizable : constant Gdk_Window_State := 65536; type Gdk_Setting_Action is ( Setting_Action_New, Setting_Action_Changed, Setting_Action_Deleted); pragma Convention (C, Gdk_Setting_Action); -- Specifies the kind of modification applied to a setting in a -- Gdk.Event.Gdk_Event_Setting. type Gdk_Owner_Change is ( Owner_Change_New_Owner, Owner_Change_Destroy, Owner_Change_Close); pragma Convention (C, Gdk_Owner_Change); -- Specifies why a selection ownership was changed. type Gdk_Event_Sequence is new Glib.C_Proxy; function From_Object_Free (B : access Gdk_Event_Sequence) return Gdk_Event_Sequence; pragma Inline (From_Object_Free); type Gdk_Event_Any is record The_Type : Gdk_Event_Type; Window : Gdk.Gdk_Window; Send_Event : Gint8; end record; pragma Convention (C, Gdk_Event_Any); function From_Object_Free (B : access Gdk_Event_Any) return Gdk_Event_Any; pragma Inline (From_Object_Free); -- Contains the fields which are common to all event structs. Any event -- pointer can safely be cast to a pointer to a Gdk.Event.Gdk_Event_Any to -- access these fields. type Gdk_Event_Button is record The_Type : Gdk_Event_Type; Window : Gdk.Gdk_Window; Send_Event : Gint8; Time : Guint32; X : Gdouble; Y : Gdouble; Axes : access Gdouble; State : Gdk.Types.Gdk_Modifier_Type; Button : Guint; Device : System.Address; X_Root : Gdouble; Y_Root : Gdouble; end record; pragma Convention (C, Gdk_Event_Button); function From_Object_Free (B : access Gdk_Event_Button) return Gdk_Event_Button; pragma Inline (From_Object_Free); -- Used for button press and button release events. The Type field will be -- one of Gdk.Event.Button_Press, Gdk.Event.Gdk_2button_Press, -- Gdk.Event.Gdk_3button_Press or Gdk.Event.Button_Release, -- -- Double and triple-clicks result in a sequence of events being received. -- For double-clicks the order of events will be: -- -- - Gdk.Event.Button_Press - Gdk.Event.Button_Release - -- Gdk.Event.Button_Press - Gdk.Event.Gdk_2button_Press - -- Gdk.Event.Button_Release -- -- Note that the first click is received just like a normal button press, -- while the second click results in a Gdk.Event.Gdk_2button_Press being -- received just after the Gdk.Event.Button_Press. -- -- Triple-clicks are very similar to double-clicks, except that -- Gdk.Event.Gdk_3button_Press is inserted after the third click. The order -- of the events is: -- -- - Gdk.Event.Button_Press - Gdk.Event.Button_Release - -- Gdk.Event.Button_Press - Gdk.Event.Gdk_2button_Press - -- Gdk.Event.Button_Release - Gdk.Event.Button_Press - -- Gdk.Event.Gdk_3button_Press - Gdk.Event.Button_Release -- -- For a double click to occur, the second button press must occur within -- 1/4 of a second of the first. For a triple click to occur, the third -- button press must also occur within 1/2 second of the first button -- press. type Gdk_Event_Expose is record The_Type : Gdk_Event_Type; Window : Gdk.Gdk_Window; Send_Event : Gint8; Area : Gdk.Rectangle.Gdk_Rectangle; Region : Cairo.Region.Cairo_Region; Count : Glib.Gint := 0; end record; pragma Convention (C, Gdk_Event_Expose); function From_Object_Free (B : access Gdk_Event_Expose) return Gdk_Event_Expose; pragma Inline (From_Object_Free); -- Generated when all or part of a window becomes visible and needs to be -- redrawn. type Gdk_Event_Visibility is record The_Type : Gdk_Event_Type; Window : Gdk.Gdk_Window; Send_Event : Gint8; State : Gdk_Visibility_State; end record; pragma Convention (C, Gdk_Event_Visibility); function From_Object_Free (B : access Gdk_Event_Visibility) return Gdk_Event_Visibility; pragma Inline (From_Object_Free); -- Generated when the window visibility status has changed. type Gdk_Event_Motion is record The_Type : Gdk_Event_Type; Window : Gdk.Gdk_Window; Send_Event : Gint8; Time : Guint32; X : Gdouble; Y : Gdouble; Axes : access Gdouble; State : Gdk.Types.Gdk_Modifier_Type; Is_Hint : Gint16; Device : System.Address; X_Root : Gdouble; Y_Root : Gdouble; end record; pragma Convention (C, Gdk_Event_Motion); function From_Object_Free (B : access Gdk_Event_Motion) return Gdk_Event_Motion; pragma Inline (From_Object_Free); -- Generated when the pointer moves. type Gdk_Event_Scroll is record The_Type : Gdk_Event_Type; Window : Gdk.Gdk_Window; Send_Event : Gint8; Time : Guint32; X : Gdouble; Y : Gdouble; State : Gdk.Types.Gdk_Modifier_Type; Direction : Gdk_Scroll_Direction; Device : System.Address; X_Root : Gdouble; Y_Root : Gdouble; Delta_X : Gdouble; Delta_Y : Gdouble; Is_Stop : Guint; end record; pragma Convention (C, Gdk_Event_Scroll); function From_Object_Free (B : access Gdk_Event_Scroll) return Gdk_Event_Scroll; pragma Inline (From_Object_Free); -- Generated from button presses for the buttons 4 to 7. Wheel mice are -- usually configured to generate button press events for buttons 4 and 5 -- when the wheel is turned. -- -- Some GDK backends can also generate "smooth" scroll events, which can -- be recognized by the Gdk.Event.Scroll_Smooth scroll direction. For -- these, the scroll deltas can be obtained with -- Gdk.Event.Get_Scroll_Deltas. type Gdk_Event_Key is record The_Type : Gdk_Event_Type; Window : Gdk.Gdk_Window; Send_Event : Gint8; Time : Guint32; State : Gdk.Types.Gdk_Modifier_Type; Keyval : Gdk.Types.Gdk_Key_Type; Length : Glib.Gint := 0; String : Gtkada.Types.Chars_Ptr; Hardware_Keycode : Guint16; Group : Guint8; Is_Modifier : Guint; end record; pragma Convention (C, Gdk_Event_Key); function From_Object_Free (B : access Gdk_Event_Key) return Gdk_Event_Key; pragma Inline (From_Object_Free); -- Describes a key press or key release event. type Gdk_Event_Crossing is record The_Type : Gdk_Event_Type; Window : Gdk.Gdk_Window; Send_Event : Gint8; Subwindow : Gdk.Gdk_Window; Time : Guint32; X : Gdouble; Y : Gdouble; X_Root : Gdouble; Y_Root : Gdouble; Mode : Gdk_Crossing_Mode; Detail : Gdk_Notify_Type; Focus : Boolean; State : Gdk.Types.Gdk_Modifier_Type; end record; pragma Convention (C, Gdk_Event_Crossing); function From_Object_Free (B : access Gdk_Event_Crossing) return Gdk_Event_Crossing; pragma Inline (From_Object_Free); -- Generated when the pointer enters or leaves a window. type Gdk_Event_Focus is record The_Type : Gdk_Event_Type; Window : Gdk.Gdk_Window; Send_Event : Gint8; Gtk_In : Gint16; end record; pragma Convention (C, Gdk_Event_Focus); function From_Object_Free (B : access Gdk_Event_Focus) return Gdk_Event_Focus; pragma Inline (From_Object_Free); -- Describes a change of keyboard focus. type Gdk_Event_Configure is record The_Type : Gdk_Event_Type; Window : Gdk.Gdk_Window; Send_Event : Gint8; X : Glib.Gint := 0; Y : Glib.Gint := 0; Width : Glib.Gint := 0; Height : Glib.Gint := 0; end record; pragma Convention (C, Gdk_Event_Configure); function From_Object_Free (B : access Gdk_Event_Configure) return Gdk_Event_Configure; pragma Inline (From_Object_Free); -- Generated when a window size or position has changed. type Gdk_Event_Property is record The_Type : Gdk_Event_Type; Window : Gdk.Gdk_Window; Send_Event : Gint8; Atom : Gdk.Types.Gdk_Atom; Time : Guint32; State : Gdk_Property_State; end record; pragma Convention (C, Gdk_Event_Property); function From_Object_Free (B : access Gdk_Event_Property) return Gdk_Event_Property; pragma Inline (From_Object_Free); -- Describes a property change on a window. type Gdk_Event_Selection is record The_Type : Gdk_Event_Type; Window : Gdk.Gdk_Window; Send_Event : Gint8; Selection : Gdk.Types.Gdk_Atom; Target : Gdk.Types.Gdk_Atom; Property : Gdk.Types.Gdk_Atom; Time : Guint32; Requestor : Gdk.Gdk_Window; end record; pragma Convention (C, Gdk_Event_Selection); function From_Object_Free (B : access Gdk_Event_Selection) return Gdk_Event_Selection; pragma Inline (From_Object_Free); -- Generated when a selection is requested or ownership of a selection is -- taken over by another client application. type Gdk_Event_Owner_Change is record The_Type : Gdk_Event_Type; Window : Gdk.Gdk_Window; Send_Event : Gint8; Owner : Gdk.Gdk_Window; Reason : Gdk_Owner_Change; Selection : Gdk.Types.Gdk_Atom; Time : Guint32; Selection_Time : Guint32; end record; pragma Convention (C, Gdk_Event_Owner_Change); function From_Object_Free (B : access Gdk_Event_Owner_Change) return Gdk_Event_Owner_Change; pragma Inline (From_Object_Free); -- Generated when the owner of a selection changes. On X11, this -- information is only available if the X server supports the XFIXES -- extension. type Gdk_Event_Proximity is record The_Type : Gdk_Event_Type; Window : Gdk.Gdk_Window; Send_Event : Gint8; Time : Guint32; Device : System.Address; end record; pragma Convention (C, Gdk_Event_Proximity); function From_Object_Free (B : access Gdk_Event_Proximity) return Gdk_Event_Proximity; pragma Inline (From_Object_Free); -- Proximity events are generated when using GDK's wrapper for the XInput -- extension. The XInput extension is an add-on for standard X that allows -- you to use nonstandard devices such as graphics tablets. A proximity -- event indicates that the stylus has moved in or out of contact with the -- tablet, or perhaps that the user's finger has moved in or out of contact -- with a touch screen. -- -- This event type will be used pretty rarely. It only is important for -- XInput aware programs that are drawing their own cursor. type Gdk_Event_DND is record The_Type : Gdk_Event_Type; Window : Gdk.Gdk_Window; Send_Event : Gint8; Context : System.Address; Time : Guint32; X_Root : Gshort; Y_Root : Gshort; end record; pragma Convention (C, Gdk_Event_DND); function From_Object_Free (B : access Gdk_Event_DND) return Gdk_Event_DND; pragma Inline (From_Object_Free); -- Generated during DND operations. type Gdk_Event_Window_State is record The_Type : Gdk_Event_Type; Window : Gdk.Gdk_Window; Send_Event : Gint8; Changed_Mask : Gdk_Window_State; New_Window_State : Gdk_Window_State; end record; pragma Convention (C, Gdk_Event_Window_State); function From_Object_Free (B : access Gdk_Event_Window_State) return Gdk_Event_Window_State; pragma Inline (From_Object_Free); -- Generated when the state of a toplevel window changes. type Gdk_Event_Setting is record The_Type : Gdk_Event_Type; Window : Gdk.Gdk_Window; Send_Event : Gint8; Action : Gdk_Setting_Action; Name : Gtkada.Types.Chars_Ptr; end record; pragma Convention (C, Gdk_Event_Setting); function From_Object_Free (B : access Gdk_Event_Setting) return Gdk_Event_Setting; pragma Inline (From_Object_Free); -- Generated when a setting is modified. type Gdk_Event_Touch is record The_Type : Gdk_Event_Type; Window : Gdk.Gdk_Window; Send_Event : Gint8; Time : Guint32; X : Gdouble; Y : Gdouble; Axes : access Gdouble; State : Gdk.Types.Gdk_Modifier_Type; Sequence : Gdk_Event_Sequence; Emulating_Pointer : Boolean; Device : System.Address; X_Root : Gdouble; Y_Root : Gdouble; end record; pragma Convention (C, Gdk_Event_Touch); function From_Object_Free (B : access Gdk_Event_Touch) return Gdk_Event_Touch; pragma Inline (From_Object_Free); -- Used for touch events. Type field will be one of Gdk.Event.Touch_Begin, -- Gdk.Event.Touch_Update, Gdk.Event.Touch_End or Gdk.Event.Touch_Cancel. -- -- Touch events are grouped into sequences by means of the Sequence field, -- which can also be obtained with Gdk.Event.Get_Event_Sequence. Each -- sequence begins with a Gdk.Event.Touch_Begin event, followed by any -- number of Gdk.Event.Touch_Update events, and ends with a -- Gdk.Event.Touch_End (or Gdk.Event.Touch_Cancel) event. With multitouch -- devices, there may be several active sequences at the same time. type Gdk_Event_Grab_Broken is record The_Type : Gdk_Event_Type; Window : Gdk.Gdk_Window; Send_Event : Gint8; Keyboard : Boolean; Implicit : Boolean; Grab_Window : Gdk.Gdk_Window; end record; pragma Convention (C, Gdk_Event_Grab_Broken); function From_Object_Free (B : access Gdk_Event_Grab_Broken) return Gdk_Event_Grab_Broken; pragma Inline (From_Object_Free); -- Generated when a pointer or keyboard grab is broken. On X11, this -- happens when the grab window becomes unviewable (i.e. it or one of its -- ancestors is unmapped), or if the same application grabs the pointer or -- keyboard again. Note that implicit grabs (which are initiated by button -- presses) can also cause Gdk.Event.Gdk_Event_Grab_Broken events. -- Generated when a pointer or keyboard grab is broken. On X11, this -- happens when the grab window becomes unviewable (i.e. it or one of its -- ancestors is unmapped), or if the same application grabs the pointer or -- keyboard again. Note that implicit grabs (which are initiated by button -- presses) can also cause Gdk.Event.Gdk_Event_Grab_Broken events. type Gdk_Event_Touchpad_Swipe is record The_Type : Gdk_Event_Type; Window : Gdk.Gdk_Window; Send_Event : Gint8; Phase : Gint8; N_Fingers : Gint8; Time : Guint32; X : Gdouble; Y : Gdouble; Dx : Gdouble; Dy : Gdouble; X_Root : Gdouble; Y_Root : Gdouble; State : Gdk.Types.Gdk_Modifier_Type; end record; pragma Convention (C, Gdk_Event_Touchpad_Swipe); function From_Object_Free (B : access Gdk_Event_Touchpad_Swipe) return Gdk_Event_Touchpad_Swipe; pragma Inline (From_Object_Free); -- Generated during touchpad swipe gestures. type Gdk_Event_Touchpad_Pinch is record The_Type : Gdk_Event_Type; Window : Gdk.Gdk_Window; Send_Event : Gint8; Phase : Gint8; N_Fingers : Gint8; Time : Guint32; X : Gdouble; Y : Gdouble; Dx : Gdouble; Dy : Gdouble; Angle_Delta : Gdouble; Scale : Gdouble; X_Root : Gdouble; Y_Root : Gdouble; State : Gdk.Types.Gdk_Modifier_Type; end record; pragma Convention (C, Gdk_Event_Touchpad_Pinch); function From_Object_Free (B : access Gdk_Event_Touchpad_Pinch) return Gdk_Event_Touchpad_Pinch; pragma Inline (From_Object_Free); -- Generated during touchpad swipe gestures. type Gdk_Event_Pad_Button is record The_Type : Gdk_Event_Type; Window : Gdk.Gdk_Window; Send_Event : Gint8; Time : Guint32; Group : Guint; Button : Guint; Mode : Guint; end record; pragma Convention (C, Gdk_Event_Pad_Button); function From_Object_Free (B : access Gdk_Event_Pad_Button) return Gdk_Event_Pad_Button; pragma Inline (From_Object_Free); -- Generated during GDK_SOURCE_TABLET_PAD button presses and releases. type Gdk_Event_Pad_Axis is record The_Type : Gdk_Event_Type; Window : Gdk.Gdk_Window; Send_Event : Gint8; Time : Guint32; Group : Guint; Index : Guint; Mode : Guint; Value : Gdouble; end record; pragma Convention (C, Gdk_Event_Pad_Axis); function From_Object_Free (B : access Gdk_Event_Pad_Axis) return Gdk_Event_Pad_Axis; pragma Inline (From_Object_Free); -- Generated during GDK_SOURCE_TABLET_PAD interaction with tactile -- sensors. type Gdk_Event_Pad_Group_Mode is record The_Type : Gdk_Event_Type; Window : Gdk.Gdk_Window; Send_Event : Gint8; Time : Guint32; Group : Guint; Mode : Guint; end record; pragma Convention (C, Gdk_Event_Pad_Group_Mode); function From_Object_Free (B : access Gdk_Event_Pad_Group_Mode) return Gdk_Event_Pad_Group_Mode; pragma Inline (From_Object_Free); -- Generated during GDK_SOURCE_TABLET_PAD mode switches in a group. type Gdk_Event_Record (The_Type : Gdk_Event_Type := Gdk.Event.Nothing) is record case The_Type is when Gdk.Event.Nothing | Gdk.Event.Delete | Gdk.Event.Destroy | Gdk.Event.Map | Gdk.Event.Unmap | Gdk.Event.Client_Event => Any : Gdk_Event_Any; when Gdk.Event.Expose | Gdk.Event.Damage => Expose : Gdk_Event_Expose; when Gdk.Event.Visibility_Notify => Visibility : Gdk_Event_Visibility; when Gdk.Event.Motion_Notify => Motion : Gdk_Event_Motion; when Gdk.Event.Button_Press | Gdk.Event.Gdk_2button_Press | Gdk.Event.Gdk_3button_Press | Gdk.Event.Button_Release => Button : Gdk_Event_Button; when Gdk.Event.Touch_Begin | Gdk.Event.Touch_Update | Gdk.Event.Touch_End | Gdk.Event.Touch_Cancel => Touch : Gdk_Event_Touch; when Gdk.Event.Scroll => Scroll : Gdk_Event_Scroll; when Gdk.Event.Key_Press | Gdk.Event.Key_Release => Key : Gdk_Event_Key; when Gdk.Event.Enter_Notify | Gdk.Event.Leave_Notify => Crossing : Gdk_Event_Crossing; when Gdk.Event.Focus_Change => Focus_Change : Gdk_Event_Focus; when Gdk.Event.Configure => Configure : Gdk_Event_Configure; when Gdk.Event.Property_Notify => Property : Gdk_Event_Property; when Gdk.Event.Selection_Clear | Gdk.Event.Selection_Request | Gdk.Event.Selection_Notify => Selection : Gdk_Event_Selection; when Gdk.Event.Owner_Change => Owner_Change : Gdk_Event_Owner_Change; when Gdk.Event.Proximity_In | Gdk.Event.Proximity_Out => Proximity : Gdk_Event_Proximity; when Gdk.Event.Drag_Enter | Gdk.Event.Drag_Leave | Gdk.Event.Drag_Motion | Gdk.Event.Drag_Status | Gdk.Event.Drop_Start | Gdk.Event.Drop_Finished => Dnd : Gdk_Event_DND; when Gdk.Event.Window_State => Window_State : Gdk_Event_Window_State; when Gdk.Event.Setting => Setting : Gdk_Event_Setting; when Gdk.Event.Grab_Broken => Grab_Broken : Gdk_Event_Grab_Broken; when Gdk.Event.Touchpad_Swipe => Touchpad_Swipe : Gdk_Event_Touchpad_Swipe; when Gdk.Event.Touchpad_Pinch => Touchpad_Pinch : Gdk_Event_Touchpad_Pinch; when Gdk.Event.Pad_Button_Press | Gdk.Event.Pad_Button_Release => Pad_Button : Gdk_Event_Pad_Button; when Gdk.Event.Pad_Ring | Gdk.Event.Pad_Strip => Pad_Axis : Gdk_Event_Pad_Axis; when Gdk.Event.Pad_Group_Mode => Pad_Group_Mode : Gdk_Event_Pad_Group_Mode; end case; end record; pragma Convention (C, Gdk_Event_Record); pragma Unchecked_Union(Gdk_Event_Record); function From_Object_Free (B : access Gdk_Event_Record) return Gdk_Event_Record; pragma Inline (From_Object_Free); -- A Gdk.Event.Gdk_Event contains a union of all of the event types, and -- allows access to the data fields in a number of ways. -- -- The event type is always the first field in all of the event types, and -- can always be accessed with the following code, no matter what type of -- event it is: |[ GdkEvent *event; GdkEventType type; -- -- type = event->type; ]| -- -- To access other fields of the event, the pointer to the event can be -- cast to the appropriate event type, or the union member name can be -- used. For example if the event type is Gdk.Event.Button_Press then the x -- coordinate of the button press can be accessed with: |[ GdkEvent *event; gdouble x; -- -- x = ((GdkEventButton*)event)->x; ]| or: |[ -- GdkEvent *event; gdouble x; -- -- x = event->button.x; ]| type Gdk_Event is access all Gdk_Event_Record; pragma No_Strict_Aliasing (Gdk_Event); --------------- -- Callbacks -- --------------- type Gdk_Event_Func is access procedure (Event : Gdk_Event); -- Specifies the type of function passed to Gdk.Event.Handler_Set to -- handle all GDK events. -- "event": the Gdk.Event.Gdk_Event to process. ---------------------------- -- Enumeration Properties -- ---------------------------- package Gdk_Event_Type_Properties is new Generic_Internal_Discrete_Property (Gdk_Event_Type); type Property_Gdk_Event_Type is new Gdk_Event_Type_Properties.Property; package Gdk_Event_Mask_Properties is new Generic_Internal_Discrete_Property (Gdk_Event_Mask); type Property_Gdk_Event_Mask is new Gdk_Event_Mask_Properties.Property; package Gdk_Visibility_State_Properties is new Generic_Internal_Discrete_Property (Gdk_Visibility_State); type Property_Gdk_Visibility_State is new Gdk_Visibility_State_Properties.Property; package Gdk_Scroll_Direction_Properties is new Generic_Internal_Discrete_Property (Gdk_Scroll_Direction); type Property_Gdk_Scroll_Direction is new Gdk_Scroll_Direction_Properties.Property; package Gdk_Notify_Type_Properties is new Generic_Internal_Discrete_Property (Gdk_Notify_Type); type Property_Gdk_Notify_Type is new Gdk_Notify_Type_Properties.Property; package Gdk_Crossing_Mode_Properties is new Generic_Internal_Discrete_Property (Gdk_Crossing_Mode); type Property_Gdk_Crossing_Mode is new Gdk_Crossing_Mode_Properties.Property; package Gdk_Property_State_Properties is new Generic_Internal_Discrete_Property (Gdk_Property_State); type Property_Gdk_Property_State is new Gdk_Property_State_Properties.Property; package Gdk_Window_State_Properties is new Generic_Internal_Discrete_Property (Gdk_Window_State); type Property_Gdk_Window_State is new Gdk_Window_State_Properties.Property; package Gdk_Setting_Action_Properties is new Generic_Internal_Discrete_Property (Gdk_Setting_Action); type Property_Gdk_Setting_Action is new Gdk_Setting_Action_Properties.Property; package Gdk_Owner_Change_Properties is new Generic_Internal_Discrete_Property (Gdk_Owner_Change); type Property_Gdk_Owner_Change is new Gdk_Owner_Change_Properties.Property; ------------------ -- Constructors -- ------------------ procedure Gdk_New (Event : out Gdk_Event; The_Type : Gdk_Event_Type); -- Creates a new event of the given type. All fields are set to 0. -- Since: gtk+ 2.2 -- "type": a Gdk.Event.Gdk_Event_Type function Gdk_Event_New (The_Type : Gdk_Event_Type) return Gdk_Event; -- Creates a new event of the given type. All fields are set to 0. -- Since: gtk+ 2.2 -- "type": a Gdk.Event.Gdk_Event_Type function Get_Type return Glib.GType; pragma Import (C, Get_Type, "gdk_event_get_type"); ------------- -- Methods -- ------------- function Get_Angle (Event : Gdk_Event; Event2 : Gdk_Event; Angle : access Gdouble) return Boolean; -- If both events contain X/Y information, this function will return True -- and return in Angle the relative angle from Event1 to Event2. The -- rotation direction for positive angles is from the positive X axis -- towards the positive Y axis. -- Since: gtk+ 3.0 -- "event2": second Gdk.Event.Gdk_Event -- "angle": return location for the relative angle between both events function Get_Center (Event : Gdk_Event; Event2 : Gdk_Event; X : access Gdouble; Y : access Gdouble) return Boolean; -- If both events contain X/Y information, the center of both coordinates -- will be returned in X and Y. -- Since: gtk+ 3.0 -- "event2": second Gdk.Event.Gdk_Event -- "x": return location for the X coordinate of the center -- "y": return location for the Y coordinate of the center function Get_Distance (Event : Gdk_Event; Event2 : Gdk_Event; Distance : access Gdouble) return Boolean; -- If both events have X/Y information, the distance between both -- coordinates (as in a straight line going from Event1 to Event2) will be -- returned. -- Since: gtk+ 3.0 -- "event2": second Gdk.Event.Gdk_Event -- "distance": return location for the distance function Copy (Event : Gdk_Event) return Gdk_Event; pragma Import (C, Copy, "gdk_event_copy"); -- Copies a Gdk.Event.Gdk_Event, copying or incrementing the reference -- count of the resources associated with it (e.g. Gdk.Gdk_Window's and -- strings). procedure Free (Event : Gdk_Event); pragma Import (C, Free, "gdk_event_free"); -- Frees a Gdk.Event.Gdk_Event, freeing or decrementing any resources -- associated with it. Note that this function should only be called with -- events returned from functions such as Gdk.Event.Peek, Gdk.Event.Get, -- Gdk.Event.Copy and gdk_event_new. procedure Get_Axis (Event : Gdk_Event; Axis_Use : Gdk_Axis_Use; Value : out Gdouble); pragma Import (C, Get_Axis, "gdk_event_get_axis"); -- Extract the axis value for a particular axis use from an event -- structure. -- "axis_use": the axis use to look for -- "value": location to store the value found procedure Get_Coords (Event : Gdk_Event; X_Win : out Gdouble; Y_Win : out Gdouble); pragma Import (C, Get_Coords, "gdk_event_get_coords"); -- Extract the event window relative x/y coordinates from an event. -- "x_win": location to put event window x coordinate -- "y_win": location to put event window y coordinate function Get_Device_Tool (Event : Gdk_Event) return Gdk.Device_Tool.Gdk_Device_Tool; -- If the event was generated by a device that supports different tools -- (eg. a tablet), this function will return a -- Gdk.Device_Tool.Gdk_Device_Tool representing the tool that caused the -- event. Otherwise, null will be returned. -- Note: the Gdk.Device_Tool.Gdk_Device_Tools will be constant -- during the application lifetime, if settings must be stored persistently -- across runs, see Gdk.Device_Tool.Get_Serial -- Since: gtk+ 3.22 procedure Set_Device_Tool (Event : Gdk_Event; Tool : access Gdk.Device_Tool.Gdk_Device_Tool_Record'Class); -- Sets the device tool for this event, should be rarely used. -- Since: gtk+ 3.22 -- "tool": tool to set on the event, or null function Get_Event_Sequence (Event : Gdk_Event) return Gdk_Event_Sequence; pragma Import (C, Get_Event_Sequence, "gdk_event_get_event_sequence"); -- If Event if of type Gdk.Event.Touch_Begin, Gdk.Event.Touch_Update, -- Gdk.Event.Touch_End or Gdk.Event.Touch_Cancel, returns the -- Gdk.Event.Gdk_Event_Sequence to which the event belongs. Otherwise, -- return null. -- Since: gtk+ 3.4 function Get_Event_Type (Event : Gdk_Event) return Gdk_Event_Type; pragma Import (C, Get_Event_Type, "gdk_event_get_event_type"); -- Retrieves the type of the event. -- Since: gtk+ 3.10 function Get_Pointer_Emulated (Event : Gdk_Event) return Boolean; -- event: a Gdk.Event.Gdk_Event Returns whether this event is an -- 'emulated' pointer event (typically from a touch event), as opposed to a -- real one. -- Since: gtk+ 3.22 procedure Get_Root_Coords (Event : Gdk_Event; X_Root : out Gdouble; Y_Root : out Gdouble); pragma Import (C, Get_Root_Coords, "gdk_event_get_root_coords"); -- Extract the root window relative x/y coordinates from an event. -- "x_root": location to put root window x coordinate -- "y_root": location to put root window y coordinate function Get_Scancode (Event : Gdk_Event) return Glib.Gint; pragma Import (C, Get_Scancode, "gdk_event_get_scancode"); -- Gets the keyboard low-level scancode of a key event. -- This is usually hardware_keycode. On Windows this is the high word of -- WM_KEY{DOWN,UP} lParam which contains the scancode and some extended -- flags. -- Since: gtk+ 3.22 procedure Get_Scroll_Deltas (Event : Gdk_Event; Delta_X : out Gdouble; Delta_Y : out Gdouble); pragma Import (C, Get_Scroll_Deltas, "gdk_event_get_scroll_deltas"); -- Retrieves the scroll deltas from a Gdk.Event.Gdk_Event -- See also: Gdk.Event.Get_Scroll_Direction -- Since: gtk+ 3.4 -- "delta_x": return location for X delta -- "delta_y": return location for Y delta procedure Get_Scroll_Direction (Event : Gdk_Event; Direction : out Gdk_Scroll_Direction); pragma Import (C, Get_Scroll_Direction, "gdk_event_get_scroll_direction"); -- Extracts the scroll direction from an event. -- If Event is not of type Gdk.Event.Scroll, the contents of Direction are -- undefined. -- If you wish to handle both discrete and smooth scrolling, you should -- check the return value of this function, or of -- Gdk.Event.Get_Scroll_Deltas; for instance: -- |[ GdkScrollDirection direction; double -- vscroll_factor = 0.0; double x_scroll, y_scroll; -- if (gdk_event_get_scroll_direction (event, &direction)) { // Handle -- discrete scrolling with a known constant delta; const double delta = -- 12.0; -- switch (direction) { case GDK_SCROLL_UP: vscroll_factor = -delta; -- break; case GDK_SCROLL_DOWN: vscroll_factor = delta; break; default: // -- no scrolling break; } } else if (gdk_event_get_scroll_deltas (event, -- &x_scroll, &y_scroll)) { // Handle smooth scrolling directly -- vscroll_factor = y_scroll; } ]| -- Since: gtk+ 3.2 -- "direction": location to store the scroll direction function Get_Seat (Event : Gdk_Event) return Glib.Object.GObject; -- Returns the Gdk.Seat.Gdk_Seat this event was generated for. -- Since: gtk+ 3.20 function Get_Time (Event : Gdk_Event) return Guint32; pragma Import (C, Get_Time, "gdk_event_get_time"); -- Returns the time stamp from Event, if there is one; otherwise returns -- GDK_CURRENT_TIME. If Event is null, returns GDK_CURRENT_TIME. function Get_Window (Event : Gdk_Event) return Gdk.Gdk_Window; pragma Import (C, Get_Window, "gdk_event_get_window"); -- Extracts the Gdk.Gdk_Window associated with an event. -- Since: gtk+ 3.10 function Is_Scroll_Stop_Event (Event : Gdk_Event) return Boolean; -- Check whether a scroll event is a stop scroll event. Scroll sequences -- with smooth scroll information may provide a stop scroll event once the -- interaction with the device finishes, e.g. by lifting a finger. This -- stop scroll event is the signal that a widget may trigger kinetic -- scrolling based on the current velocity. -- Stop scroll events always have a a delta of 0/0. -- Since: gtk+ 3.20 procedure Put (Event : Gdk_Event); pragma Import (C, Put, "gdk_event_put"); -- Appends a copy of the given event onto the front of the event queue for -- event->any.window's display, or the default event queue if -- event->any.window is null. See Gdk.Display.Put_Event. function Triggers_Context_Menu (Event : Gdk_Event) return Boolean; -- This function returns whether a Gdk.Event.Gdk_Event_Button should -- trigger a context menu, according to platform conventions. The right -- mouse button always triggers context menus. Additionally, if -- gdk_keymap_get_modifier_mask returns a non-0 mask for -- GDK_MODIFIER_INTENT_CONTEXT_MENU, then the left mouse button will also -- trigger a context menu if this modifier is pressed. -- This function should always be used instead of simply checking for -- event->button == GDK_BUTTON_SECONDARY. -- Since: gtk+ 3.4 function Get_Button (Event : Gdk_Event) return Guint; pragma Import (C, Get_Button, "ada_gdk_event_get_button"); -- Extract the button number from an event function Get_State (Event : Gdk_Event) return Gdk.Types.Gdk_Modifier_Type; pragma Import (C, Get_State, "ada_gdk_event_get_state"); -- State of the mouse buttons and keyboard keys just prior to the event function Get_Key_Val (Event : Gdk_Event) return Gdk.Types.Gdk_Key_Type; pragma Import (C, Get_Key_Val, "ada_gdk_event_get_keyval"); -- Code of the key that was pressed (and that generated the event) function Get_Keycode (Event : Gdk_Event) return Guint; pragma Import (C, Get_Keycode, "ada_gdk_event_get_keycode"); -- Hardware key code of the key that was pressed procedure Handler_Set (Func : Gdk_Event_Func); -- Sets the function to call to handle all events from GDK. -- Note that GTK+ uses this to install its own event handler, so it is -- usually not useful for GTK+ applications. (Although an application can -- call this function then call Gtk.Main.Main_Do_Event to pass events to -- GTK+.) -- "func": the function to call to handle events from GDK. generic type User_Data_Type (<>) is private; with procedure Destroy (Data : in out User_Data_Type) is null; package Handler_Set_User_Data is type Gdk_Event_Func is access procedure (Event : Gdk.Event.Gdk_Event; Data : User_Data_Type); -- Specifies the type of function passed to Gdk.Event.Handler_Set to -- handle all GDK events. -- "event": the Gdk.Event.Gdk_Event to process. -- "data": user data set when the event handler was installed with -- Gdk.Event.Handler_Set. procedure Handler_Set (Func : Gdk_Event_Func; Data : User_Data_Type); -- Sets the function to call to handle all events from GDK. -- Note that GTK+ uses this to install its own event handler, so it is -- usually not useful for GTK+ applications. (Although an application -- can call this function then call Gtk.Main.Main_Do_Event to pass -- events to GTK+.) -- "func": the function to call to handle events from GDK. -- "data": user data to pass to the function. end Handler_Set_User_Data; ---------------------- -- GtkAda additions -- ---------------------- Double_Button_Press : constant Gdk_Event_Type := Gdk_2button_Press; Triple_Button_Press : constant Gdk_Event_Type := Gdk_3button_Press; Button_Primary : constant Gint := 1; Button_Secondary : constant Gint := 3; Button_Middle : constant Gint := 2; -- The primary button is typically the left mouse button, or the -- right button in a left-handed setup. The secondary button is the -- other one. function From_Address (C : System.Address) return Gdk_Event; -- Convert a C handler to the matching Event structure. function To_Address (C : Gdk_Event) return System.Address; -- Convert an event to the underlying C handler. function Get_Event (Value : Glib.Values.GValue) return Gdk_Event; -- Convert a value into a Gdk_Event. function To_Event (Event : access Gdk_Event_Button) return Gdk_Event; function To_Event (Event : access Gdk_Event_Key) return Gdk_Event; -- Cast Event into a Gdk_Event, which can be used to call some of -- subprograms in the API. The return value is a pointer to Event, -- which should therefore remain valid as long as the pointer is in -- use. ------------------------------- -- Some constants used below -- ------------------------------- -- This constants have the '-1' since in some cases gtk itself uses -- the extrema to return some meaningful value (for instance, the result -- of Get_Area can have the values Guint16'Last to mean the whole area). Invalid_Gdouble_Value : constant Gdouble := Gdouble'Last - 1.0; Invalid_Gint_Value : constant Gint := Gint'Last - 1; Invalid_Guint_Value : constant Guint := Guint'Last - 1; Invalid_Guint32_Value : constant Guint32 := Guint32'Last - 1; Invalid_Gulong_Value : constant Gulong := Gulong'Last - 1; pragma Export (C, Invalid_Gdouble_Value, "ada_gdk_invalid_gdouble_value"); pragma Export (C, Invalid_Gint_Value, "ada_gdk_invalid_gint_value"); pragma Export (C, Invalid_Guint_Value, "ada_gdk_invalid_guint_value"); pragma Export (C, Invalid_Guint32_Value, "ada_gdk_invalid_guint32_value"); pragma Export (C, Invalid_Gulong_Value, "ada_gdk_invalid_gulong_value"); --------------- -- Functions -- --------------- function Get return Gdk_Event; pragma Import (C, Get, "gdk_event_get"); -- Checks all open displays for a Gdk.Event.Gdk_Event to process,to be -- processed on, fetching events from the windowing system if necessary. -- See Gdk.Display.Get_Event. function Peek return Gdk_Event; pragma Import (C, Peek, "gdk_event_peek"); -- If there is an event waiting in the event queue of some open display, -- returns a copy of it. See Gdk.Display.Peek_Event. procedure Request_Motions (Event : Gdk_Event_Motion); pragma Import (C, Request_Motions, "gdk_event_request_motions"); -- Request more motion notifies if Event is a motion notify hint event. -- This function should be used instead of Gdk.Window.Get_Pointer to -- request further motion notifies, because it also works for extension -- events where motion notifies are provided for devices other than the -- core pointer. Coordinate extraction, processing and requesting more -- motion events from a Gdk.Event.Motion_Notify event usually works like -- this: -- |[ { // motion_event handler x = motion_event->x; -- y = motion_event->y; // handle (x,y) motion gdk_event_request_motions -- (motion_event); // handles is_hint events } ]| -- Since: gtk+ 2.12 -- "event": a valid Gdk.Event.Gdk_Event function Events_Pending return Boolean; -- Checks if any events are ready to be processed for any display. procedure Set_Show_Events (Show_Events : Boolean); -- Sets whether a trace of received events is output. Note that GTK+ must -- be compiled with debugging (that is, configured using the -- `--enable-debug` option) to use this option. -- "show_events": True to output event debugging information. function Get_Show_Events return Boolean; -- Gets whether event debugging output is enabled. end Gdk.Event; gtkada-24.0.0/src/generated/gdk-frame_clock.adb000066400000000000000000000362161446021174000212440ustar00rootroot00000000000000------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ pragma Style_Checks (Off); pragma Warnings (Off, "*is already use-visible*"); with Ada.Unchecked_Conversion; with Glib.Type_Conversion_Hooks; use Glib.Type_Conversion_Hooks; with Glib.Values; use Glib.Values; with Gtk.Arguments; use Gtk.Arguments; with Gtkada.Bindings; use Gtkada.Bindings; package body Gdk.Frame_Clock is package Type_Conversion_Gdk_Frame_Clock is new Glib.Type_Conversion_Hooks.Hook_Registrator (Get_Type'Access, Gdk_Frame_Clock_Record); pragma Unreferenced (Type_Conversion_Gdk_Frame_Clock); -------------------- -- Begin_Updating -- -------------------- procedure Begin_Updating (Self : not null access Gdk_Frame_Clock_Record) is procedure Internal (Self : System.Address); pragma Import (C, Internal, "gdk_frame_clock_begin_updating"); begin Internal (Get_Object (Self)); end Begin_Updating; ------------------ -- End_Updating -- ------------------ procedure End_Updating (Self : not null access Gdk_Frame_Clock_Record) is procedure Internal (Self : System.Address); pragma Import (C, Internal, "gdk_frame_clock_end_updating"); begin Internal (Get_Object (Self)); end End_Updating; ------------------------- -- Get_Current_Timings -- ------------------------- function Get_Current_Timings (Self : not null access Gdk_Frame_Clock_Record) return Gdk.Frame_Timings.Gdk_Frame_Timings is function Internal (Self : System.Address) return System.Address; pragma Import (C, Internal, "gdk_frame_clock_get_current_timings"); begin return From_Object (Internal (Get_Object (Self))); end Get_Current_Timings; ----------------------- -- Get_Frame_Counter -- ----------------------- function Get_Frame_Counter (Self : not null access Gdk_Frame_Clock_Record) return Gint64 is function Internal (Self : System.Address) return Gint64; pragma Import (C, Internal, "gdk_frame_clock_get_frame_counter"); begin return Internal (Get_Object (Self)); end Get_Frame_Counter; -------------------- -- Get_Frame_Time -- -------------------- function Get_Frame_Time (Self : not null access Gdk_Frame_Clock_Record) return Gint64 is function Internal (Self : System.Address) return Gint64; pragma Import (C, Internal, "gdk_frame_clock_get_frame_time"); begin return Internal (Get_Object (Self)); end Get_Frame_Time; ----------------------- -- Get_History_Start -- ----------------------- function Get_History_Start (Self : not null access Gdk_Frame_Clock_Record) return Gint64 is function Internal (Self : System.Address) return Gint64; pragma Import (C, Internal, "gdk_frame_clock_get_history_start"); begin return Internal (Get_Object (Self)); end Get_History_Start; ---------------------- -- Get_Refresh_Info -- ---------------------- procedure Get_Refresh_Info (Self : not null access Gdk_Frame_Clock_Record; Base_Time : Gint64; Refresh_Interval_Return : out Gint64; Presentation_Time_Return : out Gint64) is procedure Internal (Self : System.Address; Base_Time : Gint64; Refresh_Interval_Return : out Gint64; Presentation_Time_Return : out Gint64); pragma Import (C, Internal, "gdk_frame_clock_get_refresh_info"); begin Internal (Get_Object (Self), Base_Time, Refresh_Interval_Return, Presentation_Time_Return); end Get_Refresh_Info; ----------------- -- Get_Timings -- ----------------- function Get_Timings (Self : not null access Gdk_Frame_Clock_Record; Frame_Counter : Gint64) return Gdk.Frame_Timings.Gdk_Frame_Timings is function Internal (Self : System.Address; Frame_Counter : Gint64) return System.Address; pragma Import (C, Internal, "gdk_frame_clock_get_timings"); begin return From_Object (Internal (Get_Object (Self), Frame_Counter)); end Get_Timings; ------------------- -- Request_Phase -- ------------------- procedure Request_Phase (Self : not null access Gdk_Frame_Clock_Record; Phase : Gdk_Frame_Clock_Phase) is procedure Internal (Self : System.Address; Phase : Gdk_Frame_Clock_Phase); pragma Import (C, Internal, "gdk_frame_clock_request_phase"); begin Internal (Get_Object (Self), Phase); end Request_Phase; use type System.Address; function Cb_To_Address is new Ada.Unchecked_Conversion (Cb_Gdk_Frame_Clock_Void, System.Address); function Address_To_Cb is new Ada.Unchecked_Conversion (System.Address, Cb_Gdk_Frame_Clock_Void); function Cb_To_Address is new Ada.Unchecked_Conversion (Cb_GObject_Void, System.Address); function Address_To_Cb is new Ada.Unchecked_Conversion (System.Address, Cb_GObject_Void); procedure Connect (Object : access Gdk_Frame_Clock_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_Gdk_Frame_Clock_Void; After : Boolean); procedure Connect_Slot (Object : access Gdk_Frame_Clock_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_GObject_Void; After : Boolean; Slot : access Glib.Object.GObject_Record'Class := null); procedure Marsh_GObject_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address); pragma Convention (C, Marsh_GObject_Void); procedure Marsh_Gdk_Frame_Clock_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address); pragma Convention (C, Marsh_Gdk_Frame_Clock_Void); ------------- -- Connect -- ------------- procedure Connect (Object : access Gdk_Frame_Clock_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_Gdk_Frame_Clock_Void; After : Boolean) is begin Unchecked_Do_Signal_Connect (Object => Object, C_Name => C_Name, Marshaller => Marsh_Gdk_Frame_Clock_Void'Access, Handler => Cb_To_Address (Handler),-- Set in the closure After => After); end Connect; ------------------ -- Connect_Slot -- ------------------ procedure Connect_Slot (Object : access Gdk_Frame_Clock_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_GObject_Void; After : Boolean; Slot : access Glib.Object.GObject_Record'Class := null) is begin Unchecked_Do_Signal_Connect (Object => Object, C_Name => C_Name, Marshaller => Marsh_GObject_Void'Access, Handler => Cb_To_Address (Handler),-- Set in the closure Slot_Object => Slot, After => After); end Connect_Slot; ------------------------ -- Marsh_GObject_Void -- ------------------------ procedure Marsh_GObject_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address) is pragma Unreferenced (Return_Value, N_Params, Params, Invocation_Hint, User_Data); H : constant Cb_GObject_Void := Address_To_Cb (Get_Callback (Closure)); Obj : constant Glib.Object.GObject := Glib.Object.Convert (Get_Data (Closure)); begin H (Obj); exception when E : others => Process_Exception (E); end Marsh_GObject_Void; -------------------------------- -- Marsh_Gdk_Frame_Clock_Void -- -------------------------------- procedure Marsh_Gdk_Frame_Clock_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address) is pragma Unreferenced (Return_Value, N_Params, Invocation_Hint, User_Data); H : constant Cb_Gdk_Frame_Clock_Void := Address_To_Cb (Get_Callback (Closure)); Obj : constant Gdk_Frame_Clock := Gdk_Frame_Clock (Unchecked_To_Object (Params, 0)); begin H (Obj); exception when E : others => Process_Exception (E); end Marsh_Gdk_Frame_Clock_Void; -------------------- -- On_After_Paint -- -------------------- procedure On_After_Paint (Self : not null access Gdk_Frame_Clock_Record; Call : Cb_Gdk_Frame_Clock_Void; After : Boolean := False) is begin Connect (Self, "after-paint" & ASCII.NUL, Call, After); end On_After_Paint; -------------------- -- On_After_Paint -- -------------------- procedure On_After_Paint (Self : not null access Gdk_Frame_Clock_Record; Call : Cb_GObject_Void; Slot : not null access Glib.Object.GObject_Record'Class; After : Boolean := False) is begin Connect_Slot (Self, "after-paint" & ASCII.NUL, Call, After, Slot); end On_After_Paint; --------------------- -- On_Before_Paint -- --------------------- procedure On_Before_Paint (Self : not null access Gdk_Frame_Clock_Record; Call : Cb_Gdk_Frame_Clock_Void; After : Boolean := False) is begin Connect (Self, "before-paint" & ASCII.NUL, Call, After); end On_Before_Paint; --------------------- -- On_Before_Paint -- --------------------- procedure On_Before_Paint (Self : not null access Gdk_Frame_Clock_Record; Call : Cb_GObject_Void; Slot : not null access Glib.Object.GObject_Record'Class; After : Boolean := False) is begin Connect_Slot (Self, "before-paint" & ASCII.NUL, Call, After, Slot); end On_Before_Paint; --------------------- -- On_Flush_Events -- --------------------- procedure On_Flush_Events (Self : not null access Gdk_Frame_Clock_Record; Call : Cb_Gdk_Frame_Clock_Void; After : Boolean := False) is begin Connect (Self, "flush-events" & ASCII.NUL, Call, After); end On_Flush_Events; --------------------- -- On_Flush_Events -- --------------------- procedure On_Flush_Events (Self : not null access Gdk_Frame_Clock_Record; Call : Cb_GObject_Void; Slot : not null access Glib.Object.GObject_Record'Class; After : Boolean := False) is begin Connect_Slot (Self, "flush-events" & ASCII.NUL, Call, After, Slot); end On_Flush_Events; --------------- -- On_Layout -- --------------- procedure On_Layout (Self : not null access Gdk_Frame_Clock_Record; Call : Cb_Gdk_Frame_Clock_Void; After : Boolean := False) is begin Connect (Self, "layout" & ASCII.NUL, Call, After); end On_Layout; --------------- -- On_Layout -- --------------- procedure On_Layout (Self : not null access Gdk_Frame_Clock_Record; Call : Cb_GObject_Void; Slot : not null access Glib.Object.GObject_Record'Class; After : Boolean := False) is begin Connect_Slot (Self, "layout" & ASCII.NUL, Call, After, Slot); end On_Layout; -------------- -- On_Paint -- -------------- procedure On_Paint (Self : not null access Gdk_Frame_Clock_Record; Call : Cb_Gdk_Frame_Clock_Void; After : Boolean := False) is begin Connect (Self, "paint" & ASCII.NUL, Call, After); end On_Paint; -------------- -- On_Paint -- -------------- procedure On_Paint (Self : not null access Gdk_Frame_Clock_Record; Call : Cb_GObject_Void; Slot : not null access Glib.Object.GObject_Record'Class; After : Boolean := False) is begin Connect_Slot (Self, "paint" & ASCII.NUL, Call, After, Slot); end On_Paint; ---------------------- -- On_Resume_Events -- ---------------------- procedure On_Resume_Events (Self : not null access Gdk_Frame_Clock_Record; Call : Cb_Gdk_Frame_Clock_Void; After : Boolean := False) is begin Connect (Self, "resume-events" & ASCII.NUL, Call, After); end On_Resume_Events; ---------------------- -- On_Resume_Events -- ---------------------- procedure On_Resume_Events (Self : not null access Gdk_Frame_Clock_Record; Call : Cb_GObject_Void; Slot : not null access Glib.Object.GObject_Record'Class; After : Boolean := False) is begin Connect_Slot (Self, "resume-events" & ASCII.NUL, Call, After, Slot); end On_Resume_Events; --------------- -- On_Update -- --------------- procedure On_Update (Self : not null access Gdk_Frame_Clock_Record; Call : Cb_Gdk_Frame_Clock_Void; After : Boolean := False) is begin Connect (Self, "update" & ASCII.NUL, Call, After); end On_Update; --------------- -- On_Update -- --------------- procedure On_Update (Self : not null access Gdk_Frame_Clock_Record; Call : Cb_GObject_Void; Slot : not null access Glib.Object.GObject_Record'Class; After : Boolean := False) is begin Connect_Slot (Self, "update" & ASCII.NUL, Call, After, Slot); end On_Update; end Gdk.Frame_Clock; gtkada-24.0.0/src/generated/gdk-frame_clock.ads000066400000000000000000000352031446021174000212600ustar00rootroot00000000000000------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ -- -- A Gdk.Frame_Clock.Gdk_Frame_Clock tells the application when to update and -- repaint a window. This may be synced to the vertical refresh rate of the -- monitor, for example. Even when the frame clock uses a simple timer rather -- than a hardware-based vertical sync, the frame clock helps because it -- ensures everything paints at the same time (reducing the total number of -- frames). The frame clock can also automatically stop painting when it knows -- the frames will not be visible, or scale back animation framerates. -- -- Gdk.Frame_Clock.Gdk_Frame_Clock is designed to be compatible with an -- OpenGL-based implementation or with mozRequestAnimationFrame in Firefox, -- for example. -- -- A frame clock is idle until someone requests a frame with -- Gdk.Frame_Clock.Request_Phase. At some later point that makes sense for the -- synchronization being implemented, the clock will process a frame and emit -- signals for each phase that has been requested. (See the signals of the -- Gdk.Frame_Clock.Gdk_Frame_Clock class for documentation of the phases. -- Gdk.Frame_Clock.Gdk_Frame_Clock_Phase_Update and the -- Gdk.Frame_Clock.Gdk_Frame_Clock::update signal are most interesting for -- application writers, and are used to update the animations, using the frame -- time given by Gdk.Frame_Clock.Get_Frame_Time. -- -- The frame time is reported in microseconds and generally in the same -- timescale as g_get_monotonic_time, however, it is not the same as -- g_get_monotonic_time. The frame time does not advance during the time a -- frame is being painted, and outside of a frame, an attempt is made so that -- all calls to Gdk.Frame_Clock.Get_Frame_Time that are called at a "similar" -- time get the same value. This means that if different animations are timed -- by looking at the difference in time between an initial value from -- Gdk.Frame_Clock.Get_Frame_Time and the value inside the -- Gdk.Frame_Clock.Gdk_Frame_Clock::update signal of the clock, they will stay -- exactly synchronized. -- -- pragma Warnings (Off, "*is already use-visible*"); with Gdk.Frame_Timings; use Gdk.Frame_Timings; with Glib; use Glib; with Glib.Generic_Properties; use Glib.Generic_Properties; with Glib.Object; use Glib.Object; package Gdk.Frame_Clock is type Gdk_Frame_Clock_Record is new GObject_Record with null record; type Gdk_Frame_Clock is access all Gdk_Frame_Clock_Record'Class; type Gdk_Frame_Clock_Phase is mod 2 ** Integer'Size; pragma Convention (C, Gdk_Frame_Clock_Phase); -- Gdk.Frame_Clock.Gdk_Frame_Clock_Phase is used to represent the -- different paint clock phases that can be requested. The elements of the -- enumeration correspond to the signals of -- Gdk.Frame_Clock.Gdk_Frame_Clock. Gdk_Frame_Clock_Phase_None : constant Gdk_Frame_Clock_Phase := 0; Gdk_Frame_Clock_Phase_Flush_Events : constant Gdk_Frame_Clock_Phase := 1; Gdk_Frame_Clock_Phase_Before_Paint : constant Gdk_Frame_Clock_Phase := 2; Gdk_Frame_Clock_Phase_Update : constant Gdk_Frame_Clock_Phase := 4; Gdk_Frame_Clock_Phase_Layout : constant Gdk_Frame_Clock_Phase := 8; Gdk_Frame_Clock_Phase_Paint : constant Gdk_Frame_Clock_Phase := 16; Gdk_Frame_Clock_Phase_Resume_Events : constant Gdk_Frame_Clock_Phase := 32; Gdk_Frame_Clock_Phase_After_Paint : constant Gdk_Frame_Clock_Phase := 64; ---------------------------- -- Enumeration Properties -- ---------------------------- package Gdk_Frame_Clock_Phase_Properties is new Generic_Internal_Discrete_Property (Gdk_Frame_Clock_Phase); type Property_Gdk_Frame_Clock_Phase is new Gdk_Frame_Clock_Phase_Properties.Property; ------------------ -- Constructors -- ------------------ function Get_Type return Glib.GType; pragma Import (C, Get_Type, "gdk_frame_clock_get_type"); ------------- -- Methods -- ------------- procedure Begin_Updating (Self : not null access Gdk_Frame_Clock_Record); -- Starts updates for an animation. Until a matching call to -- Gdk.Frame_Clock.End_Updating is made, the frame clock will continually -- request a new frame with the -- Gdk.Frame_Clock.Gdk_Frame_Clock_Phase_Update phase. This function may be -- called multiple times and frames will be requested until -- Gdk.Frame_Clock.End_Updating is called the same number of times. -- Since: gtk+ 3.8 procedure End_Updating (Self : not null access Gdk_Frame_Clock_Record); -- Stops updates for an animation. See the documentation for -- Gdk.Frame_Clock.Begin_Updating. -- Since: gtk+ 3.8 function Get_Current_Timings (Self : not null access Gdk_Frame_Clock_Record) return Gdk.Frame_Timings.Gdk_Frame_Timings; -- Gets the frame timings for the current frame. -- Since: gtk+ 3.8 function Get_Frame_Counter (Self : not null access Gdk_Frame_Clock_Record) return Gint64; -- A Gdk.Frame_Clock.Gdk_Frame_Clock maintains a 64-bit counter that -- increments for each frame drawn. -- Since: gtk+ 3.8 function Get_Frame_Time (Self : not null access Gdk_Frame_Clock_Record) return Gint64; -- Gets the time that should currently be used for animations. Inside the -- processing of a frame, it's the time used to compute the animation -- position of everything in a frame. Outside of a frame, it's the time of -- the conceptual "previous frame," which may be either the actual previous -- frame time, or if that's too old, an updated time. -- Since: gtk+ 3.8 function Get_History_Start (Self : not null access Gdk_Frame_Clock_Record) return Gint64; -- Gdk.Frame_Clock.Gdk_Frame_Clock internally keeps a history of -- Gdk.Frame_Timings.Gdk_Frame_Timings objects for recent frames that can -- be retrieved with Gdk.Frame_Clock.Get_Timings. The set of stored frames -- is the set from the counter values given by -- Gdk.Frame_Clock.Get_History_Start and Gdk.Frame_Clock.Get_Frame_Counter, -- inclusive. -- Since: gtk+ 3.8 procedure Get_Refresh_Info (Self : not null access Gdk_Frame_Clock_Record; Base_Time : Gint64; Refresh_Interval_Return : out Gint64; Presentation_Time_Return : out Gint64); -- Using the frame history stored in the frame clock, finds the last known -- presentation time and refresh interval, and assuming that presentation -- times are separated by the refresh interval, predicts a presentation -- time that is a multiple of the refresh interval after the last -- presentation time, and later than Base_Time. -- Since: gtk+ 3.8 -- "base_time": base time for determining a presentaton time -- "refresh_interval_return": a location to store the determined refresh -- interval, or null. A default refresh interval of 1/60th of a second will -- be stored if no history is present. -- "presentation_time_return": a location to store the next candidate -- presentation time after the given base time. 0 will be will be stored if -- no history is present. function Get_Timings (Self : not null access Gdk_Frame_Clock_Record; Frame_Counter : Gint64) return Gdk.Frame_Timings.Gdk_Frame_Timings; -- Retrieves a Gdk.Frame_Timings.Gdk_Frame_Timings object holding timing -- information for the current frame or a recent frame. The -- Gdk.Frame_Timings.Gdk_Frame_Timings object may not yet be complete: see -- Gdk.Frame_Timings.Get_Complete. -- Since: gtk+ 3.8 -- "frame_counter": the frame counter value identifying the frame to be -- received. procedure Request_Phase (Self : not null access Gdk_Frame_Clock_Record; Phase : Gdk_Frame_Clock_Phase); -- Asks the frame clock to run a particular phase. The signal -- corresponding the requested phase will be emitted the next time the -- frame clock processes. Multiple calls to Gdk.Frame_Clock.Request_Phase -- will be combined together and only one frame processed. If you are -- displaying animated content and want to continually request the -- Gdk.Frame_Clock.Gdk_Frame_Clock_Phase_Update phase for a period of time, -- you should use Gdk.Frame_Clock.Begin_Updating instead, since this allows -- GTK+ to adjust system parameters to get maximally smooth animations. -- Since: gtk+ 3.8 -- "phase": the phase that is requested ------------- -- Signals -- ------------- type Cb_Gdk_Frame_Clock_Void is not null access procedure (Self : access Gdk_Frame_Clock_Record'Class); type Cb_GObject_Void is not null access procedure (Self : access Glib.Object.GObject_Record'Class); Signal_After_Paint : constant Glib.Signal_Name := "after-paint"; procedure On_After_Paint (Self : not null access Gdk_Frame_Clock_Record; Call : Cb_Gdk_Frame_Clock_Void; After : Boolean := False); procedure On_After_Paint (Self : not null access Gdk_Frame_Clock_Record; Call : Cb_GObject_Void; Slot : not null access Glib.Object.GObject_Record'Class; After : Boolean := False); -- This signal ends processing of the frame. Applications should generally -- not handle this signal. Signal_Before_Paint : constant Glib.Signal_Name := "before-paint"; procedure On_Before_Paint (Self : not null access Gdk_Frame_Clock_Record; Call : Cb_Gdk_Frame_Clock_Void; After : Boolean := False); procedure On_Before_Paint (Self : not null access Gdk_Frame_Clock_Record; Call : Cb_GObject_Void; Slot : not null access Glib.Object.GObject_Record'Class; After : Boolean := False); -- This signal begins processing of the frame. Applications should -- generally not handle this signal. Signal_Flush_Events : constant Glib.Signal_Name := "flush-events"; procedure On_Flush_Events (Self : not null access Gdk_Frame_Clock_Record; Call : Cb_Gdk_Frame_Clock_Void; After : Boolean := False); procedure On_Flush_Events (Self : not null access Gdk_Frame_Clock_Record; Call : Cb_GObject_Void; Slot : not null access Glib.Object.GObject_Record'Class; After : Boolean := False); -- This signal is used to flush pending motion events that are being -- batched up and compressed together. Applications should not handle this -- signal. Signal_Layout : constant Glib.Signal_Name := "layout"; procedure On_Layout (Self : not null access Gdk_Frame_Clock_Record; Call : Cb_Gdk_Frame_Clock_Void; After : Boolean := False); procedure On_Layout (Self : not null access Gdk_Frame_Clock_Record; Call : Cb_GObject_Void; Slot : not null access Glib.Object.GObject_Record'Class; After : Boolean := False); -- This signal is emitted as the second step of toolkit and application -- processing of the frame. Any work to update sizes and positions of -- application elements should be performed. GTK+ normally handles this -- internally. Signal_Paint : constant Glib.Signal_Name := "paint"; procedure On_Paint (Self : not null access Gdk_Frame_Clock_Record; Call : Cb_Gdk_Frame_Clock_Void; After : Boolean := False); procedure On_Paint (Self : not null access Gdk_Frame_Clock_Record; Call : Cb_GObject_Void; Slot : not null access Glib.Object.GObject_Record'Class; After : Boolean := False); -- This signal is emitted as the third step of toolkit and application -- processing of the frame. The frame is repainted. GDK normally handles -- this internally and produces expose events, which are turned into GTK+ -- Gtk.Widget.Gtk_Widget::draw signals. Signal_Resume_Events : constant Glib.Signal_Name := "resume-events"; procedure On_Resume_Events (Self : not null access Gdk_Frame_Clock_Record; Call : Cb_Gdk_Frame_Clock_Void; After : Boolean := False); procedure On_Resume_Events (Self : not null access Gdk_Frame_Clock_Record; Call : Cb_GObject_Void; Slot : not null access Glib.Object.GObject_Record'Class; After : Boolean := False); -- This signal is emitted after processing of the frame is finished, and -- is handled internally by GTK+ to resume normal event processing. -- Applications should not handle this signal. Signal_Update : constant Glib.Signal_Name := "update"; procedure On_Update (Self : not null access Gdk_Frame_Clock_Record; Call : Cb_Gdk_Frame_Clock_Void; After : Boolean := False); procedure On_Update (Self : not null access Gdk_Frame_Clock_Record; Call : Cb_GObject_Void; Slot : not null access Glib.Object.GObject_Record'Class; After : Boolean := False); -- This signal is emitted as the first step of toolkit and application -- processing of the frame. Animations should be updated using -- Gdk.Frame_Clock.Get_Frame_Time. Applications can connect directly to -- this signal, or use Gtk.Widget.Add_Tick_Callback as a more convenient -- interface. end Gdk.Frame_Clock; gtkada-24.0.0/src/generated/gdk-frame_timings.adb000066400000000000000000000121731446021174000216170ustar00rootroot00000000000000------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ pragma Style_Checks (Off); pragma Warnings (Off, "*is already use-visible*"); package body Gdk.Frame_Timings is function From_Object_Free (B : access Gdk_Frame_Timings'Class) return Gdk_Frame_Timings is Result : constant Gdk_Frame_Timings := Gdk_Frame_Timings (B.all); begin Glib.g_free (B.all'Address); return Result; end From_Object_Free; function From_Object (Object : System.Address) return Gdk_Frame_Timings is S : Gdk_Frame_Timings; begin S.Set_Object (Object); return S; end From_Object; ------------------ -- Get_Complete -- ------------------ function Get_Complete (Self : Gdk_Frame_Timings) return Boolean is function Internal (Self : System.Address) return Glib.Gboolean; pragma Import (C, Internal, "gdk_frame_timings_get_complete"); begin return Internal (Get_Object (Self)) /= 0; end Get_Complete; ----------------------- -- Get_Frame_Counter -- ----------------------- function Get_Frame_Counter (Self : Gdk_Frame_Timings) return Gint64 is function Internal (Self : System.Address) return Gint64; pragma Import (C, Internal, "gdk_frame_timings_get_frame_counter"); begin return Internal (Get_Object (Self)); end Get_Frame_Counter; -------------------- -- Get_Frame_Time -- -------------------- function Get_Frame_Time (Self : Gdk_Frame_Timings) return Gint64 is function Internal (Self : System.Address) return Gint64; pragma Import (C, Internal, "gdk_frame_timings_get_frame_time"); begin return Internal (Get_Object (Self)); end Get_Frame_Time; ------------------------------------- -- Get_Predicted_Presentation_Time -- ------------------------------------- function Get_Predicted_Presentation_Time (Self : Gdk_Frame_Timings) return Gint64 is function Internal (Self : System.Address) return Gint64; pragma Import (C, Internal, "gdk_frame_timings_get_predicted_presentation_time"); begin return Internal (Get_Object (Self)); end Get_Predicted_Presentation_Time; --------------------------- -- Get_Presentation_Time -- --------------------------- function Get_Presentation_Time (Self : Gdk_Frame_Timings) return Gint64 is function Internal (Self : System.Address) return Gint64; pragma Import (C, Internal, "gdk_frame_timings_get_presentation_time"); begin return Internal (Get_Object (Self)); end Get_Presentation_Time; -------------------------- -- Get_Refresh_Interval -- -------------------------- function Get_Refresh_Interval (Self : Gdk_Frame_Timings) return Gint64 is function Internal (Self : System.Address) return Gint64; pragma Import (C, Internal, "gdk_frame_timings_get_refresh_interval"); begin return Internal (Get_Object (Self)); end Get_Refresh_Interval; --------- -- Ref -- --------- function Ref (Self : Gdk_Frame_Timings) return Gdk_Frame_Timings is function Internal (Self : System.Address) return System.Address; pragma Import (C, Internal, "gdk_frame_timings_ref"); begin return From_Object (Internal (Get_Object (Self))); end Ref; ----------- -- Unref -- ----------- procedure Unref (Self : Gdk_Frame_Timings) is procedure Internal (Self : System.Address); pragma Import (C, Internal, "gdk_frame_timings_unref"); begin Internal (Get_Object (Self)); end Unref; end Gdk.Frame_Timings; gtkada-24.0.0/src/generated/gdk-frame_timings.ads000066400000000000000000000133551446021174000216430ustar00rootroot00000000000000------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ -- -- A Gdk.Frame_Timings.Gdk_Frame_Timings object holds timing information for -- a single frame of the application's displays. To retrieve -- Gdk.Frame_Timings.Gdk_Frame_Timings objects, use -- Gdk.Frame_Clock.Get_Timings or Gdk.Frame_Clock.Get_Current_Timings. The -- information in Gdk.Frame_Timings.Gdk_Frame_Timings is useful for precise -- synchronization of video with the event or audio streams, and for measuring -- quality metrics for the application's display, such as latency and jitter. -- -- pragma Warnings (Off, "*is already use-visible*"); with Glib; use Glib; package Gdk.Frame_Timings is type Gdk_Frame_Timings is new Glib.C_Boxed with null record; Null_Gdk_Frame_Timings : constant Gdk_Frame_Timings; function From_Object (Object : System.Address) return Gdk_Frame_Timings; function From_Object_Free (B : access Gdk_Frame_Timings'Class) return Gdk_Frame_Timings; pragma Inline (From_Object_Free, From_Object); ------------------ -- Constructors -- ------------------ function Get_Type return Glib.GType; pragma Import (C, Get_Type, "gdk_frame_timings_get_type"); ------------- -- Methods -- ------------- function Get_Complete (Self : Gdk_Frame_Timings) return Boolean; -- The timing information in a Gdk.Frame_Timings.Gdk_Frame_Timings is -- filled in incrementally as the frame as drawn and passed off to the -- window system for processing and display to the user. The accessor -- functions for Gdk.Frame_Timings.Gdk_Frame_Timings can return 0 to -- indicate an unavailable value for two reasons: either because the -- information is not yet available, or because it isn't available at all. -- Once Gdk.Frame_Timings.Get_Complete returns True for a frame, you can be -- certain that no further values will become available and be stored in -- the Gdk.Frame_Timings.Gdk_Frame_Timings. -- Since: gtk+ 3.8 function Get_Frame_Counter (Self : Gdk_Frame_Timings) return Gint64; -- Gets the frame counter value of the Gdk.Frame_Clock.Gdk_Frame_Clock -- when this this frame was drawn. -- Since: gtk+ 3.8 function Get_Frame_Time (Self : Gdk_Frame_Timings) return Gint64; -- Returns the frame time for the frame. This is the time value that is -- typically used to time animations for the frame. See -- Gdk.Frame_Clock.Get_Frame_Time. function Get_Predicted_Presentation_Time (Self : Gdk_Frame_Timings) return Gint64; -- Gets the predicted time at which this frame will be displayed. Although -- no predicted time may be available, if one is available, it will be -- available while the frame is being generated, in contrast to -- Gdk.Frame_Timings.Get_Presentation_Time, which is only available after -- the frame has been presented. In general, if you are simply animating, -- you should use Gdk.Frame_Clock.Get_Frame_Time rather than this function, -- but this function is useful for applications that want exact control -- over latency. For example, a movie player may want this information for -- Audio/Video synchronization. -- Since: gtk+ 3.8 function Get_Presentation_Time (Self : Gdk_Frame_Timings) return Gint64; -- Reurns the presentation time. This is the time at which the frame -- became visible to the user. -- Since: gtk+ 3.8 function Get_Refresh_Interval (Self : Gdk_Frame_Timings) return Gint64; -- Gets the natural interval between presentation times for the display -- that this frame was displayed on. Frame presentation usually happens -- during the "vertical blanking interval". -- Since: gtk+ 3.8 function Ref (Self : Gdk_Frame_Timings) return Gdk_Frame_Timings; -- Increases the reference count of Timings. -- Since: gtk+ 3.8 procedure Unref (Self : Gdk_Frame_Timings); -- Decreases the reference count of Timings. If Timings is no longer -- referenced, it will be freed. -- Since: gtk+ 3.8 private Null_Gdk_Frame_Timings : constant Gdk_Frame_Timings := (Glib.C_Boxed with null record); end Gdk.Frame_Timings; gtkada-24.0.0/src/generated/gdk-glcontext.adb000066400000000000000000000220561446021174000210030ustar00rootroot00000000000000------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ pragma Style_Checks (Off); pragma Warnings (Off, "*is already use-visible*"); with Glib.Type_Conversion_Hooks; use Glib.Type_Conversion_Hooks; package body Gdk.GLContext is package Type_Conversion_Gdk_GLContext is new Glib.Type_Conversion_Hooks.Hook_Registrator (Get_Type'Access, Gdk_GLContext_Record); pragma Unreferenced (Type_Conversion_Gdk_GLContext); ----------------------- -- Get_Debug_Enabled -- ----------------------- function Get_Debug_Enabled (Self : not null access Gdk_GLContext_Record) return Boolean is function Internal (Self : System.Address) return Glib.Gboolean; pragma Import (C, Internal, "gdk_gl_context_get_debug_enabled"); begin return Internal (Get_Object (Self)) /= 0; end Get_Debug_Enabled; ----------------- -- Get_Display -- ----------------- function Get_Display (Self : not null access Gdk_GLContext_Record) return Gdk.Display.Gdk_Display is function Internal (Self : System.Address) return System.Address; pragma Import (C, Internal, "gdk_gl_context_get_display"); Stub_Gdk_Display : Gdk.Display.Gdk_Display_Record; begin return Gdk.Display.Gdk_Display (Get_User_Data (Internal (Get_Object (Self)), Stub_Gdk_Display)); end Get_Display; ---------------------------- -- Get_Forward_Compatible -- ---------------------------- function Get_Forward_Compatible (Self : not null access Gdk_GLContext_Record) return Boolean is function Internal (Self : System.Address) return Glib.Gboolean; pragma Import (C, Internal, "gdk_gl_context_get_forward_compatible"); begin return Internal (Get_Object (Self)) /= 0; end Get_Forward_Compatible; -------------------------- -- Get_Required_Version -- -------------------------- procedure Get_Required_Version (Self : not null access Gdk_GLContext_Record; Major : out Glib.Gint; Minor : out Glib.Gint) is procedure Internal (Self : System.Address; Major : out Glib.Gint; Minor : out Glib.Gint); pragma Import (C, Internal, "gdk_gl_context_get_required_version"); begin Internal (Get_Object (Self), Major, Minor); end Get_Required_Version; ------------------------ -- Get_Shared_Context -- ------------------------ function Get_Shared_Context (Self : not null access Gdk_GLContext_Record) return Gdk_GLContext is function Internal (Self : System.Address) return System.Address; pragma Import (C, Internal, "gdk_gl_context_get_shared_context"); Stub_Gdk_GLContext : Gdk_GLContext_Record; begin return Gdk.GLContext.Gdk_GLContext (Get_User_Data (Internal (Get_Object (Self)), Stub_Gdk_GLContext)); end Get_Shared_Context; ---------------- -- Get_Use_Es -- ---------------- function Get_Use_Es (Self : not null access Gdk_GLContext_Record) return Boolean is function Internal (Self : System.Address) return Glib.Gboolean; pragma Import (C, Internal, "gdk_gl_context_get_use_es"); begin return Internal (Get_Object (Self)) /= 0; end Get_Use_Es; ----------------- -- Get_Version -- ----------------- procedure Get_Version (Self : not null access Gdk_GLContext_Record; Major : out Glib.Gint; Minor : out Glib.Gint) is procedure Internal (Self : System.Address; Major : out Glib.Gint; Minor : out Glib.Gint); pragma Import (C, Internal, "gdk_gl_context_get_version"); begin Internal (Get_Object (Self), Major, Minor); end Get_Version; ---------------- -- Get_Window -- ---------------- function Get_Window (Self : not null access Gdk_GLContext_Record) return Gdk.Gdk_Window is function Internal (Self : System.Address) return Gdk.Gdk_Window; pragma Import (C, Internal, "gdk_gl_context_get_window"); begin return Internal (Get_Object (Self)); end Get_Window; --------------- -- Is_Legacy -- --------------- function Is_Legacy (Self : not null access Gdk_GLContext_Record) return Boolean is function Internal (Self : System.Address) return Glib.Gboolean; pragma Import (C, Internal, "gdk_gl_context_is_legacy"); begin return Internal (Get_Object (Self)) /= 0; end Is_Legacy; ------------------ -- Make_Current -- ------------------ procedure Make_Current (Self : not null access Gdk_GLContext_Record) is procedure Internal (Self : System.Address); pragma Import (C, Internal, "gdk_gl_context_make_current"); begin Internal (Get_Object (Self)); end Make_Current; ------------- -- Realize -- ------------- function Realize (Self : not null access Gdk_GLContext_Record) return Boolean is function Internal (Self : System.Address) return Glib.Gboolean; pragma Import (C, Internal, "gdk_gl_context_realize"); begin return Internal (Get_Object (Self)) /= 0; end Realize; ----------------------- -- Set_Debug_Enabled -- ----------------------- procedure Set_Debug_Enabled (Self : not null access Gdk_GLContext_Record; Enabled : Boolean) is procedure Internal (Self : System.Address; Enabled : Glib.Gboolean); pragma Import (C, Internal, "gdk_gl_context_set_debug_enabled"); begin Internal (Get_Object (Self), Boolean'Pos (Enabled)); end Set_Debug_Enabled; ---------------------------- -- Set_Forward_Compatible -- ---------------------------- procedure Set_Forward_Compatible (Self : not null access Gdk_GLContext_Record; Compatible : Boolean) is procedure Internal (Self : System.Address; Compatible : Glib.Gboolean); pragma Import (C, Internal, "gdk_gl_context_set_forward_compatible"); begin Internal (Get_Object (Self), Boolean'Pos (Compatible)); end Set_Forward_Compatible; -------------------------- -- Set_Required_Version -- -------------------------- procedure Set_Required_Version (Self : not null access Gdk_GLContext_Record; Major : Glib.Gint; Minor : Glib.Gint) is procedure Internal (Self : System.Address; Major : Glib.Gint; Minor : Glib.Gint); pragma Import (C, Internal, "gdk_gl_context_set_required_version"); begin Internal (Get_Object (Self), Major, Minor); end Set_Required_Version; ---------------- -- Set_Use_Es -- ---------------- procedure Set_Use_Es (Self : not null access Gdk_GLContext_Record; Use_Es : Glib.Gint) is procedure Internal (Self : System.Address; Use_Es : Glib.Gint); pragma Import (C, Internal, "gdk_gl_context_set_use_es"); begin Internal (Get_Object (Self), Use_Es); end Set_Use_Es; ------------------- -- Clear_Current -- ------------------- procedure Clear_Current is procedure Internal; pragma Import (C, Internal, "gdk_gl_context_clear_current"); begin Internal; end Clear_Current; ----------------- -- Get_Current -- ----------------- function Get_Current return Gdk_GLContext is function Internal return System.Address; pragma Import (C, Internal, "gdk_gl_context_get_current"); Stub_Gdk_GLContext : Gdk_GLContext_Record; begin return Gdk.GLContext.Gdk_GLContext (Get_User_Data (Internal, Stub_Gdk_GLContext)); end Get_Current; end Gdk.GLContext; gtkada-24.0.0/src/generated/gdk-glcontext.ads000066400000000000000000000275511446021174000210310ustar00rootroot00000000000000------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ -- -- Gdk.GLContext.Gdk_GLContext is an object representing the -- platform-specific OpenGL drawing context. -- -- Gdk_GLContexts are created for a Gdk.Gdk_Window using -- Gdk.Window.Create_Gl_Context, and the context will match the -- Gdk.Visual.Gdk_Visual of the window. -- -- A Gdk.GLContext.Gdk_GLContext is not tied to any particular normal -- framebuffer. For instance, it cannot draw to the Gdk.Gdk_Window back -- buffer. The GDK repaint system is in full control of the painting to that. -- Instead, you can create render buffers or textures and use -- gdk_cairo_draw_from_gl in the draw function of your widget to draw them. -- Then GDK will handle the integration of your rendering with that of other -- widgets. -- -- Support for Gdk.GLContext.Gdk_GLContext is platform-specific, context -- creation can fail, returning null context. -- -- A Gdk.GLContext.Gdk_GLContext has to be made "current" in order to start -- using it, otherwise any OpenGL call will be ignored. -- -- ## Creating a new OpenGL context ## -- -- In order to create a new Gdk.GLContext.Gdk_GLContext instance you need a -- Gdk.Gdk_Window, which you typically get during the realize call of a -- widget. -- -- A Gdk.GLContext.Gdk_GLContext is not realized until either -- Gdk.GLContext.Make_Current, or until it is realized using -- Gdk.GLContext.Realize. It is possible to specify details of the GL context -- like the OpenGL version to be used, or whether the GL context should have -- extra state validation enabled after calling Gdk.Window.Create_Gl_Context -- by calling Gdk.GLContext.Realize. If the realization fails you have the -- option to change the settings of the Gdk.GLContext.Gdk_GLContext and try -- again. -- -- ## Using a GdkGLContext ## -- -- You will need to make the Gdk.GLContext.Gdk_GLContext the current context -- before issuing OpenGL calls; the system sends OpenGL commands to whichever -- context is current. It is possible to have multiple contexts, so you always -- need to ensure that the one which you want to draw with is the current one -- before issuing commands: -- -- |[ gdk_gl_context_make_current (context); ]| -- -- You can now perform your drawing using OpenGL commands. -- -- You can check which Gdk.GLContext.Gdk_GLContext is the current one by -- using Gdk.GLContext.Get_Current; you can also unset any -- Gdk.GLContext.Gdk_GLContext that is currently set by calling -- Gdk.GLContext.Clear_Current. -- -- pragma Warnings (Off, "*is already use-visible*"); with Gdk.Display; use Gdk.Display; with Glib; use Glib; with Glib.Object; use Glib.Object; with Glib.Properties; use Glib.Properties; package Gdk.GLContext is type Gdk_GLContext_Record is new GObject_Record with null record; type Gdk_GLContext is access all Gdk_GLContext_Record'Class; ------------------ -- Constructors -- ------------------ function Get_Type return Glib.GType; pragma Import (C, Get_Type, "gdk_gl_context_get_type"); ------------- -- Methods -- ------------- function Get_Debug_Enabled (Self : not null access Gdk_GLContext_Record) return Boolean; -- Retrieves the value set using Gdk.GLContext.Set_Debug_Enabled. -- Since: gtk+ 3.16 procedure Set_Debug_Enabled (Self : not null access Gdk_GLContext_Record; Enabled : Boolean); -- Sets whether the Gdk.GLContext.Gdk_GLContext should perform extra -- validations and run time checking. This is useful during development, -- but has additional overhead. -- The Gdk.GLContext.Gdk_GLContext must not be realized or made current -- prior to calling this function. -- Since: gtk+ 3.16 -- "enabled": whether to enable debugging in the context function Get_Display (Self : not null access Gdk_GLContext_Record) return Gdk.Display.Gdk_Display; -- Retrieves the Gdk.Display.Gdk_Display the Context is created for -- Since: gtk+ 3.16 function Get_Forward_Compatible (Self : not null access Gdk_GLContext_Record) return Boolean; -- Retrieves the value set using Gdk.GLContext.Set_Forward_Compatible. -- Since: gtk+ 3.16 procedure Set_Forward_Compatible (Self : not null access Gdk_GLContext_Record; Compatible : Boolean); -- Sets whether the Gdk.GLContext.Gdk_GLContext should be forward -- compatible. -- Forward compatibile contexts must not support OpenGL functionality that -- has been marked as deprecated in the requested version; non-forward -- compatible contexts, on the other hand, must support both deprecated and -- non deprecated functionality. -- The Gdk.GLContext.Gdk_GLContext must not be realized or made current -- prior to calling this function. -- Since: gtk+ 3.16 -- "compatible": whether the context should be forward compatible procedure Get_Required_Version (Self : not null access Gdk_GLContext_Record; Major : out Glib.Gint; Minor : out Glib.Gint); -- Retrieves the major and minor version requested by calling -- Gdk.GLContext.Set_Required_Version. -- Since: gtk+ 3.16 -- "major": return location for the major version to request -- "minor": return location for the minor version to request procedure Set_Required_Version (Self : not null access Gdk_GLContext_Record; Major : Glib.Gint; Minor : Glib.Gint); -- Sets the major and minor version of OpenGL to request. -- Setting Major and Minor to zero will use the default values. -- The Gdk.GLContext.Gdk_GLContext must not be realized or made current -- prior to calling this function. -- Since: gtk+ 3.16 -- "major": the major version to request -- "minor": the minor version to request function Get_Shared_Context (Self : not null access Gdk_GLContext_Record) return Gdk_GLContext; -- Retrieves the Gdk.GLContext.Gdk_GLContext that this Context share data -- with. -- Since: gtk+ 3.16 function Get_Use_Es (Self : not null access Gdk_GLContext_Record) return Boolean; -- Checks whether the Context is using an OpenGL or OpenGL ES profile. -- Since: gtk+ 3.22 procedure Set_Use_Es (Self : not null access Gdk_GLContext_Record; Use_Es : Glib.Gint); -- Requests that GDK create a OpenGL ES context instead of an OpenGL one, -- if the platform and windowing system allows it. -- The Context must not have been realized. -- By default, GDK will attempt to automatically detect whether the -- underlying GL implementation is OpenGL or OpenGL ES once the Context is -- realized. -- You should check the return value of Gdk.GLContext.Get_Use_Es after -- calling Gdk.GLContext.Realize to decide whether to use the OpenGL or -- OpenGL ES API, extensions, or shaders. -- Since: gtk+ 3.22 -- "use_es": whether the context should use OpenGL ES instead of OpenGL, -- or -1 to allow auto-detection procedure Get_Version (Self : not null access Gdk_GLContext_Record; Major : out Glib.Gint; Minor : out Glib.Gint); -- Retrieves the OpenGL version of the Context. -- The Context must be realized prior to calling this function. -- Since: gtk+ 3.16 -- "major": return location for the major version -- "minor": return location for the minor version function Get_Window (Self : not null access Gdk_GLContext_Record) return Gdk.Gdk_Window; -- Retrieves the Gdk.Gdk_Window used by the Context. -- Since: gtk+ 3.16 function Is_Legacy (Self : not null access Gdk_GLContext_Record) return Boolean; -- Whether the Gdk.GLContext.Gdk_GLContext is in legacy mode or not. -- The Gdk.GLContext.Gdk_GLContext must be realized before calling this -- function. -- When realizing a GL context, GDK will try to use the OpenGL 3.2 core -- profile; this profile removes all the OpenGL API that was deprecated -- prior to the 3.2 version of the specification. If the realization is -- successful, this function will return False. -- If the underlying OpenGL implementation does not support core profiles, -- GDK will fall back to a pre-3.2 compatibility profile, and this function -- will return True. -- You can use the value returned by this function to decide which kind of -- OpenGL API to use, or whether to do extension discovery, or what kind of -- shader programs to load. -- Since: gtk+ 3.20 procedure Make_Current (Self : not null access Gdk_GLContext_Record); -- Makes the Context the current one. -- Since: gtk+ 3.16 function Realize (Self : not null access Gdk_GLContext_Record) return Boolean; -- Realizes the given Gdk.GLContext.Gdk_GLContext. -- It is safe to call this function on a realized -- Gdk.GLContext.Gdk_GLContext. -- Since: gtk+ 3.16 --------------- -- Functions -- --------------- procedure Clear_Current; -- Clears the current Gdk.GLContext.Gdk_GLContext. -- Any OpenGL call after this function returns will be ignored until -- Gdk.GLContext.Make_Current is called. -- Since: gtk+ 3.16 function Get_Current return Gdk_GLContext; -- Retrieves the current Gdk.GLContext.Gdk_GLContext. -- Since: gtk+ 3.16 ---------------- -- Properties -- ---------------- -- The following properties are defined for this widget. See -- Glib.Properties for more information on properties) Display_Property : constant Glib.Properties.Property_Boxed; -- Type: Display -- The Gdk.Display.Gdk_Display used to create the -- Gdk.GLContext.Gdk_GLContext. Shared_Context_Property : constant Glib.Properties.Property_Boxed; -- Type: GLContext -- The Gdk.GLContext.Gdk_GLContext that this context is sharing data with, -- or null Window_Property : constant Glib.Properties.Property_Object; -- Type: Gtk.Window.Gtk_Window -- The Gdk.Gdk_Window the gl context is bound to. private Window_Property : constant Glib.Properties.Property_Object := Glib.Properties.Build ("window"); Shared_Context_Property : constant Glib.Properties.Property_Boxed := Glib.Properties.Build ("shared-context"); Display_Property : constant Glib.Properties.Property_Boxed := Glib.Properties.Build ("display"); end Gdk.GLContext; gtkada-24.0.0/src/generated/gdk-monitor.adb000066400000000000000000000267351446021174000204730ustar00rootroot00000000000000------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ pragma Style_Checks (Off); pragma Warnings (Off, "*is already use-visible*"); with Ada.Unchecked_Conversion; with Glib.Type_Conversion_Hooks; use Glib.Type_Conversion_Hooks; with Glib.Values; use Glib.Values; with Gtk.Arguments; use Gtk.Arguments; with Gtkada.Bindings; use Gtkada.Bindings; with Gtkada.Types; use Gtkada.Types; package body Gdk.Monitor is package Type_Conversion_Gdk_Monitor is new Glib.Type_Conversion_Hooks.Hook_Registrator (Get_Type'Access, Gdk_Monitor_Record); pragma Unreferenced (Type_Conversion_Gdk_Monitor); ----------------- -- Get_Display -- ----------------- function Get_Display (Self : not null access Gdk_Monitor_Record) return Glib.Object.GObject is function Internal (Self : System.Address) return System.Address; pragma Import (C, Internal, "gdk_monitor_get_display"); Stub_GObject : Glib.Object.GObject_Record; begin return Get_User_Data (Internal (Get_Object (Self)), Stub_GObject); end Get_Display; ------------------ -- Get_Geometry -- ------------------ procedure Get_Geometry (Self : not null access Gdk_Monitor_Record; Geometry : out Gdk.Rectangle.Gdk_Rectangle) is procedure Internal (Self : System.Address; Geometry : out Gdk.Rectangle.Gdk_Rectangle); pragma Import (C, Internal, "gdk_monitor_get_geometry"); begin Internal (Get_Object (Self), Geometry); end Get_Geometry; ------------------- -- Get_Height_Mm -- ------------------- function Get_Height_Mm (Self : not null access Gdk_Monitor_Record) return Glib.Gint is function Internal (Self : System.Address) return Glib.Gint; pragma Import (C, Internal, "gdk_monitor_get_height_mm"); begin return Internal (Get_Object (Self)); end Get_Height_Mm; ---------------------- -- Get_Manufacturer -- ---------------------- function Get_Manufacturer (Self : not null access Gdk_Monitor_Record) return UTF8_String is function Internal (Self : System.Address) return Gtkada.Types.Chars_Ptr; pragma Import (C, Internal, "gdk_monitor_get_manufacturer"); begin return Gtkada.Bindings.Value_Allowing_Null (Internal (Get_Object (Self))); end Get_Manufacturer; --------------- -- Get_Model -- --------------- function Get_Model (Self : not null access Gdk_Monitor_Record) return UTF8_String is function Internal (Self : System.Address) return Gtkada.Types.Chars_Ptr; pragma Import (C, Internal, "gdk_monitor_get_model"); begin return Gtkada.Bindings.Value_Allowing_Null (Internal (Get_Object (Self))); end Get_Model; ---------------------- -- Get_Refresh_Rate -- ---------------------- function Get_Refresh_Rate (Self : not null access Gdk_Monitor_Record) return Glib.Gint is function Internal (Self : System.Address) return Glib.Gint; pragma Import (C, Internal, "gdk_monitor_get_refresh_rate"); begin return Internal (Get_Object (Self)); end Get_Refresh_Rate; ---------------------- -- Get_Scale_Factor -- ---------------------- function Get_Scale_Factor (Self : not null access Gdk_Monitor_Record) return Glib.Gint is function Internal (Self : System.Address) return Glib.Gint; pragma Import (C, Internal, "gdk_monitor_get_scale_factor"); begin return Internal (Get_Object (Self)); end Get_Scale_Factor; ------------------------- -- Get_Subpixel_Layout -- ------------------------- function Get_Subpixel_Layout (Self : not null access Gdk_Monitor_Record) return Gdk_Subpixel_Layout is function Internal (Self : System.Address) return Gdk_Subpixel_Layout; pragma Import (C, Internal, "gdk_monitor_get_subpixel_layout"); begin return Internal (Get_Object (Self)); end Get_Subpixel_Layout; ------------------ -- Get_Width_Mm -- ------------------ function Get_Width_Mm (Self : not null access Gdk_Monitor_Record) return Glib.Gint is function Internal (Self : System.Address) return Glib.Gint; pragma Import (C, Internal, "gdk_monitor_get_width_mm"); begin return Internal (Get_Object (Self)); end Get_Width_Mm; ------------------ -- Get_Workarea -- ------------------ procedure Get_Workarea (Self : not null access Gdk_Monitor_Record; Workarea : out Gdk.Rectangle.Gdk_Rectangle) is procedure Internal (Self : System.Address; Workarea : out Gdk.Rectangle.Gdk_Rectangle); pragma Import (C, Internal, "gdk_monitor_get_workarea"); begin Internal (Get_Object (Self), Workarea); end Get_Workarea; ---------------- -- Is_Primary -- ---------------- function Is_Primary (Self : not null access Gdk_Monitor_Record) return Boolean is function Internal (Self : System.Address) return Glib.Gboolean; pragma Import (C, Internal, "gdk_monitor_is_primary"); begin return Internal (Get_Object (Self)) /= 0; end Is_Primary; use type System.Address; function Cb_To_Address is new Ada.Unchecked_Conversion (Cb_Gdk_Monitor_Void, System.Address); function Address_To_Cb is new Ada.Unchecked_Conversion (System.Address, Cb_Gdk_Monitor_Void); function Cb_To_Address is new Ada.Unchecked_Conversion (Cb_GObject_Void, System.Address); function Address_To_Cb is new Ada.Unchecked_Conversion (System.Address, Cb_GObject_Void); procedure Connect (Object : access Gdk_Monitor_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_Gdk_Monitor_Void; After : Boolean); procedure Connect_Slot (Object : access Gdk_Monitor_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_GObject_Void; After : Boolean; Slot : access Glib.Object.GObject_Record'Class := null); procedure Marsh_GObject_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address); pragma Convention (C, Marsh_GObject_Void); procedure Marsh_Gdk_Monitor_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address); pragma Convention (C, Marsh_Gdk_Monitor_Void); ------------- -- Connect -- ------------- procedure Connect (Object : access Gdk_Monitor_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_Gdk_Monitor_Void; After : Boolean) is begin Unchecked_Do_Signal_Connect (Object => Object, C_Name => C_Name, Marshaller => Marsh_Gdk_Monitor_Void'Access, Handler => Cb_To_Address (Handler),-- Set in the closure After => After); end Connect; ------------------ -- Connect_Slot -- ------------------ procedure Connect_Slot (Object : access Gdk_Monitor_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_GObject_Void; After : Boolean; Slot : access Glib.Object.GObject_Record'Class := null) is begin Unchecked_Do_Signal_Connect (Object => Object, C_Name => C_Name, Marshaller => Marsh_GObject_Void'Access, Handler => Cb_To_Address (Handler),-- Set in the closure Slot_Object => Slot, After => After); end Connect_Slot; ------------------------ -- Marsh_GObject_Void -- ------------------------ procedure Marsh_GObject_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address) is pragma Unreferenced (Return_Value, N_Params, Params, Invocation_Hint, User_Data); H : constant Cb_GObject_Void := Address_To_Cb (Get_Callback (Closure)); Obj : constant Glib.Object.GObject := Glib.Object.Convert (Get_Data (Closure)); begin H (Obj); exception when E : others => Process_Exception (E); end Marsh_GObject_Void; ---------------------------- -- Marsh_Gdk_Monitor_Void -- ---------------------------- procedure Marsh_Gdk_Monitor_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address) is pragma Unreferenced (Return_Value, N_Params, Invocation_Hint, User_Data); H : constant Cb_Gdk_Monitor_Void := Address_To_Cb (Get_Callback (Closure)); Obj : constant Gdk_Monitor := Gdk_Monitor (Unchecked_To_Object (Params, 0)); begin H (Obj); exception when E : others => Process_Exception (E); end Marsh_Gdk_Monitor_Void; ------------------- -- On_Invalidate -- ------------------- procedure On_Invalidate (Self : not null access Gdk_Monitor_Record; Call : Cb_Gdk_Monitor_Void; After : Boolean := False) is begin Connect (Self, "invalidate" & ASCII.NUL, Call, After); end On_Invalidate; ------------------- -- On_Invalidate -- ------------------- procedure On_Invalidate (Self : not null access Gdk_Monitor_Record; Call : Cb_GObject_Void; Slot : not null access Glib.Object.GObject_Record'Class; After : Boolean := False) is begin Connect_Slot (Self, "invalidate" & ASCII.NUL, Call, After, Slot); end On_Invalidate; end Gdk.Monitor; gtkada-24.0.0/src/generated/gdk-monitor.ads000066400000000000000000000234651446021174000205110ustar00rootroot00000000000000------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ -- -- GdkMonitor objects represent the individual outputs that are associated -- with a Gdk.Display.Gdk_Display. GdkDisplay has APIs to enumerate monitors -- with Gdk.Display.Get_N_Monitors and Gdk.Display.Get_Monitor, and to find -- particular monitors with Gdk.Display.Get_Primary_Monitor or -- Gdk.Display.Get_Monitor_At_Window. -- -- GdkMonitor was introduced in GTK+ 3.22 and supersedes earlier APIs in -- GdkScreen to obtain monitor-related information. -- -- pragma Warnings (Off, "*is already use-visible*"); with Gdk.Rectangle; use Gdk.Rectangle; with Glib; use Glib; with Glib.Generic_Properties; use Glib.Generic_Properties; with Glib.Object; use Glib.Object; with Glib.Properties; use Glib.Properties; package Gdk.Monitor is type Gdk_Monitor_Record is new GObject_Record with null record; type Gdk_Monitor is access all Gdk_Monitor_Record'Class; type Gdk_Subpixel_Layout is ( Gdk_Subpixel_Layout_Unknown, Gdk_Subpixel_Layout_None, Gdk_Subpixel_Layout_Horizontal_Rgb, Gdk_Subpixel_Layout_Horizontal_Bgr, Gdk_Subpixel_Layout_Vertical_Rgb, Gdk_Subpixel_Layout_Vertical_Bgr); pragma Convention (C, Gdk_Subpixel_Layout); -- This enumeration describes how the red, green and blue components of -- physical pixels on an output device are laid out. ---------------------------- -- Enumeration Properties -- ---------------------------- package Gdk_Subpixel_Layout_Properties is new Generic_Internal_Discrete_Property (Gdk_Subpixel_Layout); type Property_Gdk_Subpixel_Layout is new Gdk_Subpixel_Layout_Properties.Property; ------------------ -- Constructors -- ------------------ function Get_Type return Glib.GType; pragma Import (C, Get_Type, "gdk_monitor_get_type"); ------------- -- Methods -- ------------- function Get_Display (Self : not null access Gdk_Monitor_Record) return Glib.Object.GObject; -- Gets the display that this monitor belongs to. -- Since: gtk+ 3.22 procedure Get_Geometry (Self : not null access Gdk_Monitor_Record; Geometry : out Gdk.Rectangle.Gdk_Rectangle); -- Retrieves the size and position of an individual monitor within the -- display coordinate space. The returned geometry is in "application -- pixels", not in "device pixels" (see Gdk.Monitor.Get_Scale_Factor). -- Since: gtk+ 3.22 -- "geometry": a Gdk.Rectangle.Gdk_Rectangle to be filled with the monitor -- geometry function Get_Height_Mm (Self : not null access Gdk_Monitor_Record) return Glib.Gint; -- Gets the height in millimeters of the monitor. -- Since: gtk+ 3.22 function Get_Manufacturer (Self : not null access Gdk_Monitor_Record) return UTF8_String; -- Gets the name or PNP ID of the monitor's manufacturer, if available. -- Note that this value might also vary depending on actual display -- backend. -- PNP ID registry is located at https://uefi.org/pnp_id_list function Get_Model (Self : not null access Gdk_Monitor_Record) return UTF8_String; -- Gets the a string identifying the monitor model, if available. function Get_Refresh_Rate (Self : not null access Gdk_Monitor_Record) return Glib.Gint; -- Gets the refresh rate of the monitor, if available. -- The value is in milli-Hertz, so a refresh rate of 60Hz is returned as -- 60000. -- Since: gtk+ 3.22 function Get_Scale_Factor (Self : not null access Gdk_Monitor_Record) return Glib.Gint; -- Gets the internal scale factor that maps from monitor coordinates to -- the actual device pixels. On traditional systems this is 1, but on very -- high density outputs this can be a higher value (often 2). -- This can be used if you want to create pixel based data for a -- particular monitor, but most of the time you're drawing to a window -- where it is better to use Gdk.Window.Get_Scale_Factor instead. -- Since: gtk+ 3.22 function Get_Subpixel_Layout (Self : not null access Gdk_Monitor_Record) return Gdk_Subpixel_Layout; -- Gets information about the layout of red, green and blue primaries for -- each pixel in this monitor, if available. -- Since: gtk+ 3.22 function Get_Width_Mm (Self : not null access Gdk_Monitor_Record) return Glib.Gint; -- Gets the width in millimeters of the monitor. -- Since: gtk+ 3.22 procedure Get_Workarea (Self : not null access Gdk_Monitor_Record; Workarea : out Gdk.Rectangle.Gdk_Rectangle); -- Retrieves the size and position of the "work area" on a monitor within -- the display coordinate space. The returned geometry is in "application -- pixels", not in "device pixels" (see Gdk.Monitor.Get_Scale_Factor). -- The work area should be considered when positioning menus and similar -- popups, to avoid placing them below panels, docks or other desktop -- components. -- Note that not all backends may have a concept of workarea. This -- function will return the monitor geometry if a workarea is not -- available, or does not apply. -- Since: gtk+ 3.22 -- "workarea": a Gdk.Rectangle.Gdk_Rectangle to be filled with the monitor -- workarea function Is_Primary (Self : not null access Gdk_Monitor_Record) return Boolean; -- Gets whether this monitor should be considered primary (see -- Gdk.Display.Get_Primary_Monitor). -- Since: gtk+ 3.22 ---------------- -- Properties -- ---------------- -- The following properties are defined for this widget. See -- Glib.Properties for more information on properties) Display_Property : constant Glib.Properties.Property_Boxed; -- Type: Display Geometry_Property : constant Glib.Properties.Property_Boxed; -- Type: Rectangle Height_Mm_Property : constant Glib.Properties.Property_Int; Manufacturer_Property : constant Glib.Properties.Property_String; Model_Property : constant Glib.Properties.Property_String; Refresh_Rate_Property : constant Glib.Properties.Property_Int; Scale_Factor_Property : constant Glib.Properties.Property_Int; Subpixel_Layout_Property : constant Glib.Properties.Property_Boxed; -- Type: Subpixel_Layout Width_Mm_Property : constant Glib.Properties.Property_Int; Workarea_Property : constant Glib.Properties.Property_Boxed; -- Type: Rectangle ------------- -- Signals -- ------------- type Cb_Gdk_Monitor_Void is not null access procedure (Self : access Gdk_Monitor_Record'Class); type Cb_GObject_Void is not null access procedure (Self : access Glib.Object.GObject_Record'Class); Signal_Invalidate : constant Glib.Signal_Name := "invalidate"; procedure On_Invalidate (Self : not null access Gdk_Monitor_Record; Call : Cb_Gdk_Monitor_Void; After : Boolean := False); procedure On_Invalidate (Self : not null access Gdk_Monitor_Record; Call : Cb_GObject_Void; Slot : not null access Glib.Object.GObject_Record'Class; After : Boolean := False); private Workarea_Property : constant Glib.Properties.Property_Boxed := Glib.Properties.Build ("workarea"); Width_Mm_Property : constant Glib.Properties.Property_Int := Glib.Properties.Build ("width-mm"); Subpixel_Layout_Property : constant Glib.Properties.Property_Boxed := Glib.Properties.Build ("subpixel-layout"); Scale_Factor_Property : constant Glib.Properties.Property_Int := Glib.Properties.Build ("scale-factor"); Refresh_Rate_Property : constant Glib.Properties.Property_Int := Glib.Properties.Build ("refresh-rate"); Model_Property : constant Glib.Properties.Property_String := Glib.Properties.Build ("model"); Manufacturer_Property : constant Glib.Properties.Property_String := Glib.Properties.Build ("manufacturer"); Height_Mm_Property : constant Glib.Properties.Property_Int := Glib.Properties.Build ("height-mm"); Geometry_Property : constant Glib.Properties.Property_Boxed := Glib.Properties.Build ("geometry"); Display_Property : constant Glib.Properties.Property_Boxed := Glib.Properties.Build ("display"); end Gdk.Monitor; gtkada-24.0.0/src/generated/gdk-rgba.adb000066400000000000000000000115371446021174000177110ustar00rootroot00000000000000------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ pragma Style_Checks (Off); pragma Warnings (Off, "*is already use-visible*"); with Glib.Generic_Properties; use Glib.Generic_Properties; with Gtkada.Bindings; use Gtkada.Bindings; with Gtkada.Types; use Gtkada.Types; package body Gdk.RGBA is function From_Object_Free (B : access Gdk_RGBA) return Gdk_RGBA is Result : constant Gdk_RGBA := B.all; begin Glib.g_free (B.all'Address); return Result; end From_Object_Free; function To_Address (Val : Gdk_RGBA; Addr : System.Address) return System.Address; package RGBA_Properties is new Generic_Internal_Boxed_Property (Gdk_RGBA, Gdk.RGBA.Get_Type, To_Address); procedure Set_Property (Object : access Glib.Object.GObject_Record'Class; Name : Property_RGBA; Value : Gdk_RGBA) is begin RGBA_Properties.Set_Property (Object, RGBA_Properties.Property (Name), Value); end Set_Property; function Get_Property (Object : access Glib.Object.GObject_Record'Class; Name : Property_RGBA) return Gdk_RGBA is begin return RGBA_Properties.Get_Property (Object, RGBA_Properties.Property (Name)); end Get_Property; function Gdk_RGBA_Or_Null (Val : System.Address) return System.Address is function Internal is new Gtkada.Bindings.Generic_To_Address_Or_Null (Gdk_RGBA, Null_RGBA); begin return Internal (Val); end Gdk_RGBA_Or_Null; function Get_Value (Value : Glib.Values.GValue) return Gdk_RGBA renames RGBA_Properties.Get_Value; procedure Set_Value (Value : in out Glib.Values.GValue; Val : Gdk_RGBA) renames RGBA_Properties.Set_Value; function To_Address (Val : Gdk_RGBA; Addr : System.Address) return System.Address is begin if Val = Null_RGBA then return System.Null_Address; else return Addr; end if; end To_Address; ----------- -- Equal -- ----------- function Equal (Self : Gdk_RGBA; P2 : Gdk_RGBA) return Boolean is function Internal (Self : Gdk_RGBA; P2 : Gdk_RGBA) return Glib.Gboolean; pragma Import (C, Internal, "gdk_rgba_equal"); begin return Internal (Self, P2) /= 0; end Equal; ----------- -- Parse -- ----------- procedure Parse (Self : out Gdk_RGBA; Spec : UTF8_String; Success : out Boolean) is function Internal (Acc_Self : access Gdk_RGBA; Spec : Gtkada.Types.Chars_Ptr) return Glib.Gboolean; pragma Import (C, Internal, "gdk_rgba_parse"); Acc_Self : aliased Gdk_RGBA; Tmp_Spec : Gtkada.Types.Chars_Ptr := New_String (Spec); Tmp_Return : Glib.Gboolean; begin Tmp_Return := Internal (Acc_Self'Access, Tmp_Spec); Free (Tmp_Spec); Self := Acc_Self; Success := Tmp_Return /= 0; end Parse; --------------- -- To_String -- --------------- function To_String (Self : Gdk_RGBA) return UTF8_String is function Internal (Self : Gdk_RGBA) return Gtkada.Types.Chars_Ptr; pragma Import (C, Internal, "gdk_rgba_to_string"); begin return Gtkada.Bindings.Value_And_Free (Internal (Self)); end To_String; end Gdk.RGBA; gtkada-24.0.0/src/generated/gdk-rgba.ads000066400000000000000000000145511446021174000177310ustar00rootroot00000000000000------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ -- -- A Gdk.RGBA.Gdk_RGBA is used to represent a (possibly translucent) color, -- in a way that is compatible with cairo's notion of color. -- -- pragma Warnings (Off, "*is already use-visible*"); with Glib; use Glib; with Glib.Object; use Glib.Object; with Glib.Values; use Glib.Values; package Gdk.RGBA is type Gdk_RGBA is record Red : Gdouble; Green : Gdouble; Blue : Gdouble; Alpha : Gdouble; end record; pragma Convention (C, Gdk_RGBA); function From_Object_Free (B : access Gdk_RGBA) return Gdk_RGBA; pragma Inline (From_Object_Free); -- A Gdk.RGBA.Gdk_RGBA is used to represent a (possibly translucent) -- color, in a way that is compatible with cairo's notion of color. ------------------ -- Constructors -- ------------------ function Get_Type return Glib.GType; pragma Import (C, Get_Type, "gdk_rgba_get_type"); ------------- -- Methods -- ------------- function Copy (Self : Gdk_RGBA) return Gdk_RGBA; pragma Import (C, Copy, "gdk_rgba_copy"); -- Makes a copy of a Gdk.RGBA.Gdk_RGBA. -- The result must be freed through Gdk.RGBA.Free. -- Since: gtk+ 3.0 function Equal (Self : Gdk_RGBA; P2 : Gdk_RGBA) return Boolean; -- Compares two RGBA colors. -- Since: gtk+ 3.0 -- "p2": another Gdk.RGBA.Gdk_RGBA pointer procedure Free (Self : Gdk_RGBA); pragma Import (C, Free, "gdk_rgba_free"); -- Frees a Gdk.RGBA.Gdk_RGBA created with Gdk.RGBA.Copy -- Since: gtk+ 3.0 function Hash (Self : Gdk_RGBA) return Guint; pragma Import (C, Hash, "gdk_rgba_hash"); -- A hash function suitable for using for a hash table that stores -- Gdk_RGBAs. -- Since: gtk+ 3.0 procedure Parse (Self : out Gdk_RGBA; Spec : UTF8_String; Success : out Boolean); -- Parses a textual representation of a color, filling in the Red, Green, -- Blue and Alpha fields of the Rgba Gdk.RGBA.Gdk_RGBA. -- The string can be either one of: - A standard name (Taken from the X11 -- rgb.txt file). - A hexadecimal value in the form "\rgb", "\rrggbb", -- "\rrrgggbbb" or "\rrrrggggbbbb" - A RGB color in the form "rgb(r,g,b)" -- (In this case the color will have full opacity) - A RGBA color in the -- form "rgba(r,g,b,a)" -- Where "r", "g", "b" and "a" are respectively the red, green, blue and -- alpha color values. In the last two cases, "r", "g", and "b" are either -- integers in the range 0 to 255 or percentage values in the range 0% to -- 100%, and a is a floating point value in the range 0 to 1. -- Since: gtk+ 3.0 -- "spec": the string specifying the color function To_String (Self : Gdk_RGBA) return UTF8_String; -- Returns a textual specification of Rgba in the form `rgb(r,g,b)` or -- `rgba(r g,b,a)`, where "r", "g", "b" and "a" represent the red, green, -- blue and alpha values respectively. "r", "g", and "b" are represented as -- integers in the range 0 to 255, and "a" is represented as a floating -- point value in the range 0 to 1. -- These string forms are string forms that are supported by the CSS3 -- colors module, and can be parsed by Gdk.RGBA.Parse. -- Note that this string representation may lose some precision, since -- "r", "g" and "b" are represented as 8-bit integers. If this is a -- concern, you should use a different representation. -- Since: gtk+ 3.0 ---------------------- -- GtkAda additions -- ---------------------- type array_of_Gdk_RGBA is array (Natural range <>) of Gdk_RGBA; Null_RGBA : constant Gdk_RGBA := (0.0, 0.0, 0.0, 0.0); Black_RGBA : constant Gdk_RGBA := (0.0, 0.0, 0.0, 1.0); White_RGBA : constant Gdk_RGBA := (1.0, 1.0, 1.0, 1.0); type Property_RGBA is new Glib.Property; procedure Set_Property (Object : access Glib.Object.GObject_Record'Class; Name : Property_RGBA; Value : Gdk_RGBA); function Get_Property (Object : access Glib.Object.GObject_Record'Class; Name : Property_RGBA) return Gdk_RGBA; function Gdk_RGBA_Or_Null (Val : System.Address) return System.Address; -- Used for the GtkAda binding itself. -- Return either a Null_Address or a pointer to Val, depending on -- whether Val is the null value for the type. -- In all cases, Val is supposed to be an access to the type mentioned in -- the name of the subprogram. -- In Ada2012, these could be replaced with expression functions instead. procedure Set_Value (Value : in out Glib.Values.GValue; Val : Gdk_RGBA); function Get_Value (Value : Glib.Values.GValue) return Gdk_RGBA; -- Conversion functions for storing a Gdk_RGBA as a GValue. end Gdk.RGBA; gtkada-24.0.0/src/generated/gdk-screen.adb000066400000000000000000000421561446021174000202560ustar00rootroot00000000000000------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ pragma Style_Checks (Off); pragma Warnings (Off, "*is already use-visible*"); with Glib.Type_Conversion_Hooks; use Glib.Type_Conversion_Hooks; with Gtkada.Bindings; use Gtkada.Bindings; with Gtkada.Types; use Gtkada.Types; package body Gdk.Screen is function Get_Screen (Display : access Gdk_Display_Record'Class; Screen_Num : Gint) return Gdk_Screen is function Internal (Display : System.Address; Screen_Num : Gint) return System.Address; pragma Import (C, Internal, "gdk_display_get_screen"); -- External binding: gdk_display_get_screen Stub : Gdk_Screen_Record; begin return Gdk_Screen (Get_User_Data (Internal (Get_Object (Display), Screen_Num), Stub)); end Get_Screen; function Get_Default_Screen (Display : access Gdk_Display_Record'Class) return Gdk_Screen is function Internal (Display : System.Address) return System.Address; pragma Import (C, Internal, "gdk_display_get_default_screen"); -- External binding: gdk_display_get_default_screen Stub : Gdk_Screen_Record; begin return Gdk_Screen (Get_User_Data (Internal (Get_Object (Display)), Stub)); end Get_Default_Screen; procedure Get_Pointer (Display : access Gdk_Display_Record'Class; Screen : out Gdk_Screen; X : out Gint; Y : out Gint; Mask : out Gdk_Modifier_Type) is procedure Internal (Display : System.Address; Screen : out System.Address; X : out Gint; Y : out Gint; Mask : out Gdk_Modifier_Type); pragma Import (C, Internal, "gdk_display_get_pointer"); -- External binding: gdk_display_get_pointer S : System.Address; Stub : Gdk_Screen_Record; begin Internal (Get_Object (Display), S, X, Y, Mask); Screen := Gdk_Screen (Get_User_Data (S, Stub)); end Get_Pointer; procedure Warp_Pointer (Display : access Gdk.Display.Gdk_Display_Record'Class; Screen : access Gdk_Screen_Record; X : Glib.Gint; Y : Glib.Gint) is procedure Internal (D, S : System.Address; X, Y : Gint); pragma Import (C, Internal, "gdk_display_warp_pointer"); -- External binding: gdk_display_warp_pointer begin Internal (Get_Object (Display), Get_Object (Screen), X, Y); end Warp_Pointer; package Type_Conversion_Gdk_Screen is new Glib.Type_Conversion_Hooks.Hook_Registrator (Get_Type'Access, Gdk_Screen_Record); pragma Unreferenced (Type_Conversion_Gdk_Screen); ----------------------- -- Get_Active_Window -- ----------------------- function Get_Active_Window (Screen : not null access Gdk_Screen_Record) return Gdk.Gdk_Window is function Internal (Screen : System.Address) return Gdk.Gdk_Window; pragma Import (C, Internal, "gdk_screen_get_active_window"); begin return Internal (Get_Object (Screen)); end Get_Active_Window; ----------------- -- Get_Display -- ----------------- function Get_Display (Screen : not null access Gdk_Screen_Record) return Gdk.Display.Gdk_Display is function Internal (Screen : System.Address) return System.Address; pragma Import (C, Internal, "gdk_screen_get_display"); Stub_Gdk_Display : Gdk.Display.Gdk_Display_Record; begin return Gdk.Display.Gdk_Display (Get_User_Data (Internal (Get_Object (Screen)), Stub_Gdk_Display)); end Get_Display; ---------------------- -- Get_Font_Options -- ---------------------- function Get_Font_Options (Screen : not null access Gdk_Screen_Record) return Cairo.Cairo_Font_Options is function Internal (Screen : System.Address) return Cairo.Cairo_Font_Options; pragma Import (C, Internal, "gdk_screen_get_font_options"); begin return Internal (Get_Object (Screen)); end Get_Font_Options; ---------------- -- Get_Height -- ---------------- function Get_Height (Screen : not null access Gdk_Screen_Record) return Glib.Gint is function Internal (Screen : System.Address) return Glib.Gint; pragma Import (C, Internal, "gdk_screen_get_height"); begin return Internal (Get_Object (Screen)); end Get_Height; ------------------- -- Get_Height_Mm -- ------------------- function Get_Height_Mm (Screen : not null access Gdk_Screen_Record) return Glib.Gint is function Internal (Screen : System.Address) return Glib.Gint; pragma Import (C, Internal, "gdk_screen_get_height_mm"); begin return Internal (Get_Object (Screen)); end Get_Height_Mm; -------------------------- -- Get_Monitor_At_Point -- -------------------------- function Get_Monitor_At_Point (Screen : not null access Gdk_Screen_Record; X : Glib.Gint; Y : Glib.Gint) return Glib.Gint is function Internal (Screen : System.Address; X : Glib.Gint; Y : Glib.Gint) return Glib.Gint; pragma Import (C, Internal, "gdk_screen_get_monitor_at_point"); begin return Internal (Get_Object (Screen), X, Y); end Get_Monitor_At_Point; --------------------------- -- Get_Monitor_At_Window -- --------------------------- function Get_Monitor_At_Window (Screen : not null access Gdk_Screen_Record; Window : Gdk.Gdk_Window) return Glib.Gint is function Internal (Screen : System.Address; Window : Gdk.Gdk_Window) return Glib.Gint; pragma Import (C, Internal, "gdk_screen_get_monitor_at_window"); begin return Internal (Get_Object (Screen), Window); end Get_Monitor_At_Window; -------------------------- -- Get_Monitor_Geometry -- -------------------------- procedure Get_Monitor_Geometry (Screen : not null access Gdk_Screen_Record; Monitor_Num : Glib.Gint; Dest : out Gdk.Rectangle.Gdk_Rectangle) is procedure Internal (Screen : System.Address; Monitor_Num : Glib.Gint; Dest : out Gdk.Rectangle.Gdk_Rectangle); pragma Import (C, Internal, "gdk_screen_get_monitor_geometry"); begin Internal (Get_Object (Screen), Monitor_Num, Dest); end Get_Monitor_Geometry; --------------------------- -- Get_Monitor_Height_Mm -- --------------------------- function Get_Monitor_Height_Mm (Screen : not null access Gdk_Screen_Record; Monitor_Num : Glib.Gint) return Glib.Gint is function Internal (Screen : System.Address; Monitor_Num : Glib.Gint) return Glib.Gint; pragma Import (C, Internal, "gdk_screen_get_monitor_height_mm"); begin return Internal (Get_Object (Screen), Monitor_Num); end Get_Monitor_Height_Mm; --------------------------- -- Get_Monitor_Plug_Name -- --------------------------- function Get_Monitor_Plug_Name (Screen : not null access Gdk_Screen_Record; Monitor_Num : Glib.Gint) return UTF8_String is function Internal (Screen : System.Address; Monitor_Num : Glib.Gint) return Gtkada.Types.Chars_Ptr; pragma Import (C, Internal, "gdk_screen_get_monitor_plug_name"); begin return Gtkada.Bindings.Value_And_Free (Internal (Get_Object (Screen), Monitor_Num)); end Get_Monitor_Plug_Name; ------------------------------ -- Get_Monitor_Scale_Factor -- ------------------------------ function Get_Monitor_Scale_Factor (Screen : not null access Gdk_Screen_Record; Monitor_Num : Glib.Gint) return Glib.Gint is function Internal (Screen : System.Address; Monitor_Num : Glib.Gint) return Glib.Gint; pragma Import (C, Internal, "gdk_screen_get_monitor_scale_factor"); begin return Internal (Get_Object (Screen), Monitor_Num); end Get_Monitor_Scale_Factor; -------------------------- -- Get_Monitor_Width_Mm -- -------------------------- function Get_Monitor_Width_Mm (Screen : not null access Gdk_Screen_Record; Monitor_Num : Glib.Gint) return Glib.Gint is function Internal (Screen : System.Address; Monitor_Num : Glib.Gint) return Glib.Gint; pragma Import (C, Internal, "gdk_screen_get_monitor_width_mm"); begin return Internal (Get_Object (Screen), Monitor_Num); end Get_Monitor_Width_Mm; -------------------------- -- Get_Monitor_Workarea -- -------------------------- procedure Get_Monitor_Workarea (Screen : not null access Gdk_Screen_Record; Monitor_Num : Glib.Gint; Dest : out Gdk.Rectangle.Gdk_Rectangle) is procedure Internal (Screen : System.Address; Monitor_Num : Glib.Gint; Dest : out Gdk.Rectangle.Gdk_Rectangle); pragma Import (C, Internal, "gdk_screen_get_monitor_workarea"); begin Internal (Get_Object (Screen), Monitor_Num, Dest); end Get_Monitor_Workarea; -------------------- -- Get_N_Monitors -- -------------------- function Get_N_Monitors (Screen : not null access Gdk_Screen_Record) return Glib.Gint is function Internal (Screen : System.Address) return Glib.Gint; pragma Import (C, Internal, "gdk_screen_get_n_monitors"); begin return Internal (Get_Object (Screen)); end Get_N_Monitors; ---------------- -- Get_Number -- ---------------- function Get_Number (Screen : not null access Gdk_Screen_Record) return Glib.Gint is function Internal (Screen : System.Address) return Glib.Gint; pragma Import (C, Internal, "gdk_screen_get_number"); begin return Internal (Get_Object (Screen)); end Get_Number; ------------------------- -- Get_Primary_Monitor -- ------------------------- function Get_Primary_Monitor (Screen : not null access Gdk_Screen_Record) return Glib.Gint is function Internal (Screen : System.Address) return Glib.Gint; pragma Import (C, Internal, "gdk_screen_get_primary_monitor"); begin return Internal (Get_Object (Screen)); end Get_Primary_Monitor; -------------------- -- Get_Resolution -- -------------------- function Get_Resolution (Screen : not null access Gdk_Screen_Record) return Gdouble is function Internal (Screen : System.Address) return Gdouble; pragma Import (C, Internal, "gdk_screen_get_resolution"); begin return Internal (Get_Object (Screen)); end Get_Resolution; --------------------- -- Get_Rgba_Visual -- --------------------- function Get_Rgba_Visual (Screen : not null access Gdk_Screen_Record) return Gdk.Visual.Gdk_Visual is function Internal (Screen : System.Address) return Gdk.Visual.Gdk_Visual; pragma Import (C, Internal, "gdk_screen_get_rgba_visual"); begin return Internal (Get_Object (Screen)); end Get_Rgba_Visual; --------------------- -- Get_Root_Window -- --------------------- function Get_Root_Window (Screen : not null access Gdk_Screen_Record) return Gdk.Gdk_Window is function Internal (Screen : System.Address) return Gdk.Gdk_Window; pragma Import (C, Internal, "gdk_screen_get_root_window"); begin return Internal (Get_Object (Screen)); end Get_Root_Window; ----------------------- -- Get_System_Visual -- ----------------------- function Get_System_Visual (Screen : not null access Gdk_Screen_Record) return Gdk.Visual.Gdk_Visual is function Internal (Screen : System.Address) return Gdk.Visual.Gdk_Visual; pragma Import (C, Internal, "gdk_screen_get_system_visual"); begin return Internal (Get_Object (Screen)); end Get_System_Visual; --------------- -- Get_Width -- --------------- function Get_Width (Screen : not null access Gdk_Screen_Record) return Glib.Gint is function Internal (Screen : System.Address) return Glib.Gint; pragma Import (C, Internal, "gdk_screen_get_width"); begin return Internal (Get_Object (Screen)); end Get_Width; ------------------ -- Get_Width_Mm -- ------------------ function Get_Width_Mm (Screen : not null access Gdk_Screen_Record) return Glib.Gint is function Internal (Screen : System.Address) return Glib.Gint; pragma Import (C, Internal, "gdk_screen_get_width_mm"); begin return Internal (Get_Object (Screen)); end Get_Width_Mm; ------------------- -- Is_Composited -- ------------------- function Is_Composited (Screen : not null access Gdk_Screen_Record) return Boolean is function Internal (Screen : System.Address) return Glib.Gboolean; pragma Import (C, Internal, "gdk_screen_is_composited"); begin return Internal (Get_Object (Screen)) /= 0; end Is_Composited; ----------------------- -- Make_Display_Name -- ----------------------- function Make_Display_Name (Screen : not null access Gdk_Screen_Record) return UTF8_String is function Internal (Screen : System.Address) return Gtkada.Types.Chars_Ptr; pragma Import (C, Internal, "gdk_screen_make_display_name"); begin return Gtkada.Bindings.Value_And_Free (Internal (Get_Object (Screen))); end Make_Display_Name; ---------------------- -- Set_Font_Options -- ---------------------- procedure Set_Font_Options (Screen : not null access Gdk_Screen_Record; Options : in out Cairo.Cairo_Font_Options) is procedure Internal (Screen : System.Address; Options : in out Cairo.Cairo_Font_Options); pragma Import (C, Internal, "gdk_screen_set_font_options"); begin Internal (Get_Object (Screen), Options); end Set_Font_Options; -------------------- -- Set_Resolution -- -------------------- procedure Set_Resolution (Screen : not null access Gdk_Screen_Record; Dpi : Gdouble) is procedure Internal (Screen : System.Address; Dpi : Gdouble); pragma Import (C, Internal, "gdk_screen_set_resolution"); begin Internal (Get_Object (Screen), Dpi); end Set_Resolution; ----------------- -- Get_Default -- ----------------- function Get_Default return Gdk_Screen is function Internal return System.Address; pragma Import (C, Internal, "gdk_screen_get_default"); Stub_Gdk_Screen : Gdk_Screen_Record; begin return Gdk.Screen.Gdk_Screen (Get_User_Data (Internal, Stub_Gdk_Screen)); end Get_Default; ------------ -- Height -- ------------ function Height return Glib.Gint is function Internal return Glib.Gint; pragma Import (C, Internal, "gdk_screen_height"); begin return Internal; end Height; --------------- -- Height_Mm -- --------------- function Height_Mm return Glib.Gint is function Internal return Glib.Gint; pragma Import (C, Internal, "gdk_screen_height_mm"); begin return Internal; end Height_Mm; ----------- -- Width -- ----------- function Width return Glib.Gint is function Internal return Glib.Gint; pragma Import (C, Internal, "gdk_screen_width"); begin return Internal; end Width; -------------- -- Width_Mm -- -------------- function Width_Mm return Glib.Gint is function Internal return Glib.Gint; pragma Import (C, Internal, "gdk_screen_width_mm"); begin return Internal; end Width_Mm; end Gdk.Screen; gtkada-24.0.0/src/generated/gdk-screen.ads000066400000000000000000000474531446021174000203040ustar00rootroot00000000000000------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ -- -- Gdk.Screen.Gdk_Screen objects are the GDK representation of the screen on -- which windows can be displayed and on which the pointer moves. X originally -- identified screens with physical screens, but nowadays it is more common to -- have a single Gdk.Screen.Gdk_Screen which combines several physical -- monitors (see Gdk.Screen.Get_N_Monitors). -- -- GdkScreen is used throughout GDK and GTK+ to specify which screen the top -- level windows are to be displayed on. it is also used to query the screen -- specification and default settings such as the default visual -- (gdk_screen_get_system_visual), the dimensions of the physical monitors -- (gdk_screen_get_monitor_geometry), etc. -- -- -- Gdk, the low-level API pragma Warnings (Off, "*is already use-visible*"); with Cairo; use Cairo; with Gdk.Display; use Gdk.Display; with Gdk.Rectangle; use Gdk.Rectangle; with Gdk.Types; use Gdk.Types; with Gdk.Visual; use Gdk.Visual; with Glib; use Glib; with Glib.Object; use Glib.Object; with Glib.Properties; use Glib.Properties; package Gdk.Screen is type Gdk_Screen_Record is new GObject_Record with null record; type Gdk_Screen is access all Gdk_Screen_Record'Class; ------------------ -- Constructors -- ------------------ function Get_Type return Glib.GType; pragma Import (C, Get_Type, "gdk_screen_get_type"); ------------- -- Methods -- ------------- function Get_Active_Window (Screen : not null access Gdk_Screen_Record) return Gdk.Gdk_Window; pragma Obsolescent (Get_Active_Window); -- Returns the screen's currently active window. -- On X11, this is done by inspecting the _NET_ACTIVE_WINDOW property on -- the root window, as described in the [Extended Window Manager -- Hints](http://www.freedesktop.org/Standards/wm-spec). If there is no -- currently currently active window, or the window manager does not -- support the _NET_ACTIVE_WINDOW hint, this function returns null. -- On other platforms, this function may return null, depending on whether -- it is implementable on that platform. -- The returned window should be unrefed using g_object_unref when no -- longer needed. -- Since: gtk+ 2.10 -- Deprecated since 3.22, 1 function Get_Display (Screen : not null access Gdk_Screen_Record) return Gdk.Display.Gdk_Display; -- Gets the display to which the Screen belongs. -- Since: gtk+ 2.2 function Get_Font_Options (Screen : not null access Gdk_Screen_Record) return Cairo.Cairo_Font_Options; -- Gets any options previously set with Gdk.Screen.Set_Font_Options. -- Since: gtk+ 2.10 procedure Set_Font_Options (Screen : not null access Gdk_Screen_Record; Options : in out Cairo.Cairo_Font_Options); -- Sets the default font options for the screen. These options will be set -- on any Pango.Context.Pango_Context's newly created with -- gdk_pango_context_get_for_screen. Changing the default set of font -- options does not affect contexts that have already been created. -- Since: gtk+ 2.10 -- "options": a Cairo.Cairo_Font_Options, or null to unset any previously -- set default font options. function Get_Height (Screen : not null access Gdk_Screen_Record) return Glib.Gint; pragma Obsolescent (Get_Height); -- Gets the height of Screen in pixels. The returned size is in -- "application pixels", not in "device pixels" (see -- Gdk.Screen.Get_Monitor_Scale_Factor). -- Since: gtk+ 2.2 -- Deprecated since 3.22, 1 function Get_Height_Mm (Screen : not null access Gdk_Screen_Record) return Glib.Gint; pragma Obsolescent (Get_Height_Mm); -- Returns the height of Screen in millimeters. -- Note that this value is somewhat ill-defined when the screen has -- multiple monitors of different resolution. It is recommended to use the -- monitor dimensions instead. -- Since: gtk+ 2.2 -- Deprecated since 3.22, 1 function Get_Monitor_At_Point (Screen : not null access Gdk_Screen_Record; X : Glib.Gint; Y : Glib.Gint) return Glib.Gint; pragma Obsolescent (Get_Monitor_At_Point); -- Returns the monitor number in which the point (X,Y) is located. -- Since: gtk+ 2.2 -- Deprecated since 3.22, 1 -- "x": the x coordinate in the virtual screen. -- "y": the y coordinate in the virtual screen. function Get_Monitor_At_Window (Screen : not null access Gdk_Screen_Record; Window : Gdk.Gdk_Window) return Glib.Gint; pragma Obsolescent (Get_Monitor_At_Window); -- Returns the number of the monitor in which the largest area of the -- bounding rectangle of Window resides. -- Since: gtk+ 2.2 -- Deprecated since 3.22, 1 -- "window": a Gdk.Gdk_Window procedure Get_Monitor_Geometry (Screen : not null access Gdk_Screen_Record; Monitor_Num : Glib.Gint; Dest : out Gdk.Rectangle.Gdk_Rectangle); pragma Obsolescent (Get_Monitor_Geometry); -- Retrieves the Gdk.Rectangle.Gdk_Rectangle representing the size and -- position of the individual monitor within the entire screen area. The -- returned geometry is in "application pixels", not in "device pixels" -- (see Gdk.Screen.Get_Monitor_Scale_Factor). -- Monitor numbers start at 0. To obtain the number of monitors of Screen, -- use Gdk.Screen.Get_N_Monitors. -- Note that the size of the entire screen area can be retrieved via -- Gdk.Screen.Get_Width and Gdk.Screen.Get_Height. -- Since: gtk+ 2.2 -- Deprecated since 3.22, 1 -- "monitor_num": the monitor number -- "dest": a Gdk.Rectangle.Gdk_Rectangle to be filled with the monitor -- geometry function Get_Monitor_Height_Mm (Screen : not null access Gdk_Screen_Record; Monitor_Num : Glib.Gint) return Glib.Gint; pragma Obsolescent (Get_Monitor_Height_Mm); -- Gets the height in millimeters of the specified monitor. -- Since: gtk+ 2.14 -- Deprecated since 3.22, 1 -- "monitor_num": number of the monitor, between 0 and -- gdk_screen_get_n_monitors (screen) function Get_Monitor_Plug_Name (Screen : not null access Gdk_Screen_Record; Monitor_Num : Glib.Gint) return UTF8_String; pragma Obsolescent (Get_Monitor_Plug_Name); -- Returns the output name of the specified monitor. Usually something -- like VGA, DVI, or TV, not the actual product name of the display device. -- Since: gtk+ 2.14 -- Deprecated since 3.22, 1 -- "monitor_num": number of the monitor, between 0 and -- gdk_screen_get_n_monitors (screen) function Get_Monitor_Scale_Factor (Screen : not null access Gdk_Screen_Record; Monitor_Num : Glib.Gint) return Glib.Gint; pragma Obsolescent (Get_Monitor_Scale_Factor); -- Returns the internal scale factor that maps from monitor coordinates to -- the actual device pixels. On traditional systems this is 1, but on very -- high density outputs this can be a higher value (often 2). -- This can be used if you want to create pixel based data for a -- particular monitor, but most of the time you're drawing to a window -- where it is better to use Gdk.Window.Get_Scale_Factor instead. -- Since: gtk+ 3.10 -- Deprecated since 3.22, 1 -- "monitor_num": number of the monitor, between 0 and -- gdk_screen_get_n_monitors (screen) function Get_Monitor_Width_Mm (Screen : not null access Gdk_Screen_Record; Monitor_Num : Glib.Gint) return Glib.Gint; pragma Obsolescent (Get_Monitor_Width_Mm); -- Gets the width in millimeters of the specified monitor, if available. -- Since: gtk+ 2.14 -- Deprecated since 3.22, 1 -- "monitor_num": number of the monitor, between 0 and -- gdk_screen_get_n_monitors (screen) procedure Get_Monitor_Workarea (Screen : not null access Gdk_Screen_Record; Monitor_Num : Glib.Gint; Dest : out Gdk.Rectangle.Gdk_Rectangle); pragma Obsolescent (Get_Monitor_Workarea); -- Retrieves the Gdk.Rectangle.Gdk_Rectangle representing the size and -- position of the "work area" on a monitor within the entire screen area. -- The returned geometry is in "application pixels", not in "device pixels" -- (see Gdk.Screen.Get_Monitor_Scale_Factor). -- The work area should be considered when positioning menus and similar -- popups, to avoid placing them below panels, docks or other desktop -- components. -- Note that not all backends may have a concept of workarea. This -- function will return the monitor geometry if a workarea is not -- available, or does not apply. -- Monitor numbers start at 0. To obtain the number of monitors of Screen, -- use Gdk.Screen.Get_N_Monitors. -- Since: gtk+ 3.4 -- Deprecated since 3.22, 1 -- "monitor_num": the monitor number -- "dest": a Gdk.Rectangle.Gdk_Rectangle to be filled with the monitor -- workarea function Get_N_Monitors (Screen : not null access Gdk_Screen_Record) return Glib.Gint; pragma Obsolescent (Get_N_Monitors); -- Returns the number of monitors which Screen consists of. -- Since: gtk+ 2.2 -- Deprecated since 3.22, 1 function Get_Number (Screen : not null access Gdk_Screen_Record) return Glib.Gint; pragma Obsolescent (Get_Number); -- Gets the index of Screen among the screens in the display to which it -- belongs. (See Gdk.Screen.Get_Display) -- Since: gtk+ 2.2 -- Deprecated since 3.22, 1 function Get_Primary_Monitor (Screen : not null access Gdk_Screen_Record) return Glib.Gint; pragma Obsolescent (Get_Primary_Monitor); -- Gets the primary monitor for Screen. The primary monitor is considered -- the monitor where the "main desktop" lives. While normal application -- windows typically allow the window manager to place the windows, -- specialized desktop applications such as panels should place themselves -- on the primary monitor. -- If no primary monitor is configured by the user, the return value will -- be 0, defaulting to the first monitor. -- Since: gtk+ 2.20 -- Deprecated since 3.22, 1 function Get_Resolution (Screen : not null access Gdk_Screen_Record) return Gdouble; -- Gets the resolution for font handling on the screen; see -- Gdk.Screen.Set_Resolution for full details. -- Since: gtk+ 2.10 procedure Set_Resolution (Screen : not null access Gdk_Screen_Record; Dpi : Gdouble); -- Sets the resolution for font handling on the screen. This is a scale -- factor between points specified in a Pango.Font.Pango_Font_Description -- and cairo units. The default value is 96, meaning that a 10 point font -- will be 13 units high. (10 * 96. / 72. = 13.3). -- Since: gtk+ 2.10 -- "dpi": the resolution in "dots per inch". (Physical inches aren't -- actually involved; the terminology is conventional.) function Get_Rgba_Visual (Screen : not null access Gdk_Screen_Record) return Gdk.Visual.Gdk_Visual; -- Gets a visual to use for creating windows with an alpha channel. The -- windowing system on which GTK+ is running may not support this -- capability, in which case null will be returned. Even if a non-null -- value is returned, its possible that the window's alpha channel won't be -- honored when displaying the window on the screen: in particular, for X -- an appropriate windowing manager and compositing manager must be running -- to provide appropriate display. -- This functionality is not implemented in the Windows backend. -- For setting an overall opacity for a top-level window, see -- Gdk.Window.Set_Opacity. -- Since: gtk+ 2.8 function Get_Root_Window (Screen : not null access Gdk_Screen_Record) return Gdk.Gdk_Window; -- Gets the root window of Screen. -- Since: gtk+ 2.2 function Get_System_Visual (Screen : not null access Gdk_Screen_Record) return Gdk.Visual.Gdk_Visual; -- Get the system's default visual for Screen. This is the visual for the -- root window of the display. The return value should not be freed. -- Since: gtk+ 2.2 function Get_Width (Screen : not null access Gdk_Screen_Record) return Glib.Gint; pragma Obsolescent (Get_Width); -- Gets the width of Screen in pixels. The returned size is in -- "application pixels", not in "device pixels" (see -- Gdk.Screen.Get_Monitor_Scale_Factor). -- Since: gtk+ 2.2 -- Deprecated since 3.22, 1 function Get_Width_Mm (Screen : not null access Gdk_Screen_Record) return Glib.Gint; pragma Obsolescent (Get_Width_Mm); -- Gets the width of Screen in millimeters. -- Note that this value is somewhat ill-defined when the screen has -- multiple monitors of different resolution. It is recommended to use the -- monitor dimensions instead. -- Since: gtk+ 2.2 -- Deprecated since 3.22, 1 function Is_Composited (Screen : not null access Gdk_Screen_Record) return Boolean; -- Returns whether windows with an RGBA visual can reasonably be expected -- to have their alpha channel drawn correctly on the screen. -- On X11 this function returns whether a compositing manager is -- compositing Screen. -- Since: gtk+ 2.10 function Make_Display_Name (Screen : not null access Gdk_Screen_Record) return UTF8_String; pragma Obsolescent (Make_Display_Name); -- Determines the name to pass to Gdk.Display.Open to get a -- Gdk.Display.Gdk_Display with this screen as the default screen. -- Since: gtk+ 2.2 -- Deprecated since 3.22, 1 ---------------------- -- GtkAda additions -- ---------------------- ------------- -- Display -- ------------- -- These subprograms should really be in gdk-display.ads to match what is -- done for gtk+ itself, but that would create dependency circularities. -- Ada 2012 has support for these, but we want GtkAda to build with Ada95 -- compilers. function Get_Screen (Display : access Gdk.Display.Gdk_Display_Record'Class; Screen_Num : Glib.Gint) return Gdk_Screen; -- Returns a screen object for one of the screens of the display. function Get_Default_Screen (Display : access Gdk.Display.Gdk_Display_Record'Class) return Gdk_Screen; -- Get the default Gdk_Screen for display. procedure Get_Pointer (Display : access Gdk.Display.Gdk_Display_Record'Class; Screen : out Gdk_Screen; X : out Glib.Gint; Y : out Glib.Gint; Mask : out Gdk.Types.Gdk_Modifier_Type); -- Gets the current location of the pointer and the current modifier -- mask for a given display. -- (X, Y) are coordinates relative to the root window on the display procedure Warp_Pointer (Display : access Gdk.Display.Gdk_Display_Record'Class; Screen : access Gdk_Screen_Record; X : Glib.Gint; Y : Glib.Gint); -- Warps the pointer of display to the point x,y on the screen screen, -- unless the pointer is confined to a window by a grab, in which case it -- will be moved as far as allowed by the grab. Warping the pointer creates -- events as if the user had moved the mouse instantaneously to the -- destination. -- -- Note that the pointer should normally be under the control of the user. -- This function was added to cover some rare use cases like keyboard -- navigation support for the color picker in the GtkColorSelectionDialog. --------------- -- Functions -- --------------- function Get_Default return Gdk_Screen; -- Gets the default screen for the default display. (See -- gdk_display_get_default ()). -- Since: gtk+ 2.2 function Height return Glib.Gint; pragma Obsolescent (Height); -- Gets the height of the default screen in pixels. The returned size is -- in "application pixels", not in "device pixels" (see -- Gdk.Screen.Get_Monitor_Scale_Factor). -- Deprecated since 3.22, 1 function Height_Mm return Glib.Gint; pragma Obsolescent (Height_Mm); -- Returns the height of the default screen in millimeters. Note that on -- many X servers this value will not be correct. -- Deprecated since 3.22, 1 function Width return Glib.Gint; pragma Obsolescent (Width); -- Gets the width of the default screen in pixels. The returned size is in -- "application pixels", not in "device pixels" (see -- Gdk.Screen.Get_Monitor_Scale_Factor). -- Deprecated since 3.22, 1 function Width_Mm return Glib.Gint; pragma Obsolescent (Width_Mm); -- Returns the width of the default screen in millimeters. Note that on -- many X servers this value will not be correct. -- Deprecated since 3.22, 1 ---------------- -- Properties -- ---------------- -- The following properties are defined for this widget. See -- Glib.Properties for more information on properties) Font_Options_Property : constant Glib.Properties.Property_String := Glib.Properties.Build ("font-options");-- Unknown type: gpointer Resolution_Property : constant Glib.Properties.Property_Double; -- Type: Gdouble ------------- -- Signals -- ------------- Signal_Composited_Changed : constant Glib.Signal_Name := "composited-changed"; -- The ::composited-changed signal is emitted when the composited status -- of the screen changes -- procedure Handler (Self : access Gdk_Screen_Record'Class) Signal_Monitors_Changed : constant Glib.Signal_Name := "monitors-changed"; -- The ::monitors-changed signal is emitted when the number, size or -- position of the monitors attached to the screen change. -- -- Only for X11 and OS X for now. A future implementation for Win32 may be -- a possibility. -- procedure Handler (Self : access Gdk_Screen_Record'Class) Signal_Size_Changed : constant Glib.Signal_Name := "size-changed"; -- The ::size-changed signal is emitted when the pixel width or height of -- a screen changes. -- procedure Handler (Self : access Gdk_Screen_Record'Class) private Resolution_Property : constant Glib.Properties.Property_Double := Glib.Properties.Build ("resolution"); end Gdk.Screen; gtkada-24.0.0/src/generated/gdk-seat.adb000066400000000000000000000423571446021174000177360ustar00rootroot00000000000000------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ pragma Style_Checks (Off); pragma Warnings (Off, "*is already use-visible*"); with Ada.Unchecked_Conversion; with Glib.Type_Conversion_Hooks; use Glib.Type_Conversion_Hooks; with Glib.Values; use Glib.Values; with Gtk.Arguments; use Gtk.Arguments; with Gtkada.Bindings; use Gtkada.Bindings; package body Gdk.Seat is function Convert (R : Gdk.Seat.Gdk_Seat) return System.Address is begin return Get_Object (R); end Convert; function Convert (R : System.Address) return Gdk.Seat.Gdk_Seat is Stub : Gdk.Seat.Gdk_Seat_Record;begin return Gdk.Seat.Gdk_Seat (Glib.Object.Get_User_Data (R, Stub)); end Convert; function C_Gdk_Seat_Grab (Self : System.Address; Window : Gdk.Gdk_Window; Capabilities : Gdk_Seat_Capabilities; Owner_Events : Glib.Gboolean; Cursor : Gdk.Gdk_Cursor; Event : Gdk.Event.Gdk_Event; Prepare_Func : System.Address; Prepare_Func_Data : System.Address) return Gdk_Grab_Status; pragma Import (C, C_Gdk_Seat_Grab, "gdk_seat_grab"); -- Grabs the seat so that all events corresponding to the given -- Capabilities are passed to this application until the seat is ungrabbed -- with Gdk.Seat.Ungrab, or the window becomes hidden. This overrides any -- previous grab on the seat by this client. -- As a rule of thumb, if a grab is desired over -- Gdk.Seat.Gdk_Seat_Capability_Pointer, all other "pointing" capabilities -- (eg. Gdk.Seat.Gdk_Seat_Capability_Touch) should be grabbed too, so the -- user is able to interact with all of those while the grab holds, you -- should thus use Gdk.Seat.Gdk_Seat_Capability_All_Pointing most commonly. -- Grabs are used for operations which need complete control over the -- events corresponding to the given capabilities. For example in GTK+ this -- is used for Drag and Drop operations, popup menus and such. -- Note that if the event mask of a Gdk.Gdk_Window has selected both -- button press and button release events, or touch begin and touch end, -- then a press event will cause an automatic grab until the button is -- released, equivalent to a grab on the window with Owner_Events set to -- True. This is done because most applications expect to receive paired -- press and release events. -- If you set up anything at the time you take the grab that needs to be -- cleaned up when the grab ends, you should handle the -- Gdk.Event.Gdk_Event_Grab_Broken events that are emitted when the grab -- ends unvoluntarily. -- Since: gtk+ 3.20 -- "window": the Gdk.Gdk_Window which will own the grab -- "capabilities": capabilities that will be grabbed -- "owner_events": if False then all device events are reported with -- respect to Window and are only reported if selected by Event_Mask. If -- True then pointer events for this application are reported as normal, -- but pointer events outside this application are reported with respect to -- Window and only if selected by Event_Mask. In either mode, unreported -- events are discarded. -- "cursor": the cursor to display while the grab is active. If this is -- null then the normal cursors are used for Window and its descendants, -- and the cursor for Window is used elsewhere. -- "event": the event that is triggering the grab, or null if none is -- available. -- "prepare_func": function to prepare the window to be grabbed, it can be -- null if Window is visible before this call. -- "prepare_func_data": user data to pass to Prepare_Func function To_Gdk_Seat_Grab_Prepare_Func is new Ada.Unchecked_Conversion (System.Address, Gdk_Seat_Grab_Prepare_Func); function To_Address is new Ada.Unchecked_Conversion (Gdk_Seat_Grab_Prepare_Func, System.Address); procedure Internal_Gdk_Seat_Grab_Prepare_Func (Seat : System.Address; Window : Gdk.Gdk_Window; User_Data : System.Address); pragma Convention (C, Internal_Gdk_Seat_Grab_Prepare_Func); -- "seat": the Gdk.Seat.Gdk_Seat being grabbed -- "window": the Gdk.Gdk_Window being grabbed -- "user_data": user data passed in Gdk.Seat.Grab ----------------------------------------- -- Internal_Gdk_Seat_Grab_Prepare_Func -- ----------------------------------------- procedure Internal_Gdk_Seat_Grab_Prepare_Func (Seat : System.Address; Window : Gdk.Gdk_Window; User_Data : System.Address) is Func : constant Gdk_Seat_Grab_Prepare_Func := To_Gdk_Seat_Grab_Prepare_Func (User_Data); Stub_Gdk_Seat : Gdk_Seat_Record; begin Func (Gdk.Seat.Gdk_Seat (Get_User_Data (Seat, Stub_Gdk_Seat)), Window); end Internal_Gdk_Seat_Grab_Prepare_Func; package Type_Conversion_Gdk_Seat is new Glib.Type_Conversion_Hooks.Hook_Registrator (Get_Type'Access, Gdk_Seat_Record); pragma Unreferenced (Type_Conversion_Gdk_Seat); ---------------------- -- Get_Capabilities -- ---------------------- function Get_Capabilities (Self : not null access Gdk_Seat_Record) return Gdk_Seat_Capabilities is function Internal (Self : System.Address) return Gdk_Seat_Capabilities; pragma Import (C, Internal, "gdk_seat_get_capabilities"); begin return Internal (Get_Object (Self)); end Get_Capabilities; ----------------- -- Get_Display -- ----------------- function Get_Display (Self : not null access Gdk_Seat_Record) return Glib.Object.GObject is function Internal (Self : System.Address) return System.Address; pragma Import (C, Internal, "gdk_seat_get_display"); Stub_GObject : Glib.Object.GObject_Record; begin return Get_User_Data (Internal (Get_Object (Self)), Stub_GObject); end Get_Display; ------------------ -- Get_Keyboard -- ------------------ function Get_Keyboard (Self : not null access Gdk_Seat_Record) return Gdk.Device.Gdk_Device is function Internal (Self : System.Address) return System.Address; pragma Import (C, Internal, "gdk_seat_get_keyboard"); Stub_Gdk_Device : Gdk.Device.Gdk_Device_Record; begin return Gdk.Device.Gdk_Device (Get_User_Data (Internal (Get_Object (Self)), Stub_Gdk_Device)); end Get_Keyboard; ----------------- -- Get_Pointer -- ----------------- function Get_Pointer (Self : not null access Gdk_Seat_Record) return Gdk.Device.Gdk_Device is function Internal (Self : System.Address) return System.Address; pragma Import (C, Internal, "gdk_seat_get_pointer"); Stub_Gdk_Device : Gdk.Device.Gdk_Device_Record; begin return Gdk.Device.Gdk_Device (Get_User_Data (Internal (Get_Object (Self)), Stub_Gdk_Device)); end Get_Pointer; ---------------- -- Get_Slaves -- ---------------- function Get_Slaves (Self : not null access Gdk_Seat_Record; Capabilities : Gdk_Seat_Capabilities) return Gdk.Device.Device_List.Glist is function Internal (Self : System.Address; Capabilities : Gdk_Seat_Capabilities) return System.Address; pragma Import (C, Internal, "gdk_seat_get_slaves"); Tmp_Return : Gdk.Device.Device_List.Glist; begin Gdk.Device.Device_List.Set_Object (Tmp_Return, Internal (Get_Object (Self), Capabilities)); return Tmp_Return; end Get_Slaves; ---------- -- Grab -- ---------- function Grab (Self : not null access Gdk_Seat_Record; Window : Gdk.Gdk_Window; Capabilities : Gdk_Seat_Capabilities; Owner_Events : Boolean; Cursor : Gdk.Gdk_Cursor; Event : Gdk.Event.Gdk_Event; Prepare_Func : Gdk_Seat_Grab_Prepare_Func) return Gdk_Grab_Status is begin if Prepare_Func = null then return C_Gdk_Seat_Grab (Get_Object (Self), Window, Capabilities, Boolean'Pos (Owner_Events), Cursor, Event, System.Null_Address, System.Null_Address); else return C_Gdk_Seat_Grab (Get_Object (Self), Window, Capabilities, Boolean'Pos (Owner_Events), Cursor, Event, Internal_Gdk_Seat_Grab_Prepare_Func'Address, To_Address (Prepare_Func)); end if; end Grab; ------------ -- Ungrab -- ------------ procedure Ungrab (Self : not null access Gdk_Seat_Record) is procedure Internal (Self : System.Address); pragma Import (C, Internal, "gdk_seat_ungrab"); begin Internal (Get_Object (Self)); end Ungrab; use type System.Address; function Cb_To_Address is new Ada.Unchecked_Conversion (Cb_Gdk_Seat_GObject_Void, System.Address); function Address_To_Cb is new Ada.Unchecked_Conversion (System.Address, Cb_Gdk_Seat_GObject_Void); function Cb_To_Address is new Ada.Unchecked_Conversion (Cb_GObject_GObject_Void, System.Address); function Address_To_Cb is new Ada.Unchecked_Conversion (System.Address, Cb_GObject_GObject_Void); procedure Connect (Object : access Gdk_Seat_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_Gdk_Seat_GObject_Void; After : Boolean); procedure Connect_Slot (Object : access Gdk_Seat_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_GObject_GObject_Void; After : Boolean; Slot : access Glib.Object.GObject_Record'Class := null); procedure Marsh_GObject_GObject_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address); pragma Convention (C, Marsh_GObject_GObject_Void); procedure Marsh_Gdk_Seat_GObject_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address); pragma Convention (C, Marsh_Gdk_Seat_GObject_Void); ------------- -- Connect -- ------------- procedure Connect (Object : access Gdk_Seat_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_Gdk_Seat_GObject_Void; After : Boolean) is begin Unchecked_Do_Signal_Connect (Object => Object, C_Name => C_Name, Marshaller => Marsh_Gdk_Seat_GObject_Void'Access, Handler => Cb_To_Address (Handler),-- Set in the closure After => After); end Connect; ------------------ -- Connect_Slot -- ------------------ procedure Connect_Slot (Object : access Gdk_Seat_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_GObject_GObject_Void; After : Boolean; Slot : access Glib.Object.GObject_Record'Class := null) is begin Unchecked_Do_Signal_Connect (Object => Object, C_Name => C_Name, Marshaller => Marsh_GObject_GObject_Void'Access, Handler => Cb_To_Address (Handler),-- Set in the closure Slot_Object => Slot, After => After); end Connect_Slot; -------------------------------- -- Marsh_GObject_GObject_Void -- -------------------------------- procedure Marsh_GObject_GObject_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address) is pragma Unreferenced (Return_Value, N_Params, Invocation_Hint, User_Data); H : constant Cb_GObject_GObject_Void := Address_To_Cb (Get_Callback (Closure)); Obj : constant Glib.Object.GObject := Glib.Object.Convert (Get_Data (Closure)); begin H (Obj, Unchecked_To_Object (Params, 1)); exception when E : others => Process_Exception (E); end Marsh_GObject_GObject_Void; --------------------------------- -- Marsh_Gdk_Seat_GObject_Void -- --------------------------------- procedure Marsh_Gdk_Seat_GObject_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address) is pragma Unreferenced (Return_Value, N_Params, Invocation_Hint, User_Data); H : constant Cb_Gdk_Seat_GObject_Void := Address_To_Cb (Get_Callback (Closure)); Obj : constant Gdk_Seat := Gdk_Seat (Unchecked_To_Object (Params, 0)); begin H (Obj, Unchecked_To_Object (Params, 1)); exception when E : others => Process_Exception (E); end Marsh_Gdk_Seat_GObject_Void; --------------------- -- On_Device_Added -- --------------------- procedure On_Device_Added (Self : not null access Gdk_Seat_Record; Call : Cb_Gdk_Seat_GObject_Void; After : Boolean := False) is begin Connect (Self, "device-added" & ASCII.NUL, Call, After); end On_Device_Added; --------------------- -- On_Device_Added -- --------------------- procedure On_Device_Added (Self : not null access Gdk_Seat_Record; Call : Cb_GObject_GObject_Void; Slot : not null access Glib.Object.GObject_Record'Class; After : Boolean := False) is begin Connect_Slot (Self, "device-added" & ASCII.NUL, Call, After, Slot); end On_Device_Added; ----------------------- -- On_Device_Removed -- ----------------------- procedure On_Device_Removed (Self : not null access Gdk_Seat_Record; Call : Cb_Gdk_Seat_GObject_Void; After : Boolean := False) is begin Connect (Self, "device-removed" & ASCII.NUL, Call, After); end On_Device_Removed; ----------------------- -- On_Device_Removed -- ----------------------- procedure On_Device_Removed (Self : not null access Gdk_Seat_Record; Call : Cb_GObject_GObject_Void; Slot : not null access Glib.Object.GObject_Record'Class; After : Boolean := False) is begin Connect_Slot (Self, "device-removed" & ASCII.NUL, Call, After, Slot); end On_Device_Removed; ------------------- -- On_Tool_Added -- ------------------- procedure On_Tool_Added (Self : not null access Gdk_Seat_Record; Call : Cb_Gdk_Seat_GObject_Void; After : Boolean := False) is begin Connect (Self, "tool-added" & ASCII.NUL, Call, After); end On_Tool_Added; ------------------- -- On_Tool_Added -- ------------------- procedure On_Tool_Added (Self : not null access Gdk_Seat_Record; Call : Cb_GObject_GObject_Void; Slot : not null access Glib.Object.GObject_Record'Class; After : Boolean := False) is begin Connect_Slot (Self, "tool-added" & ASCII.NUL, Call, After, Slot); end On_Tool_Added; --------------------- -- On_Tool_Removed -- --------------------- procedure On_Tool_Removed (Self : not null access Gdk_Seat_Record; Call : Cb_Gdk_Seat_GObject_Void; After : Boolean := False) is begin Connect (Self, "tool-removed" & ASCII.NUL, Call, After); end On_Tool_Removed; --------------------- -- On_Tool_Removed -- --------------------- procedure On_Tool_Removed (Self : not null access Gdk_Seat_Record; Call : Cb_GObject_GObject_Void; Slot : not null access Glib.Object.GObject_Record'Class; After : Boolean := False) is begin Connect_Slot (Self, "tool-removed" & ASCII.NUL, Call, After, Slot); end On_Tool_Removed; end Gdk.Seat; gtkada-24.0.0/src/generated/gdk-seat.ads000066400000000000000000000265101446021174000177500ustar00rootroot00000000000000------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ -- -- The Gdk.Seat.Gdk_Seat object represents a collection of input devices that -- belong to a user. -- -- pragma Warnings (Off, "*is already use-visible*"); with Gdk.Device; use Gdk.Device; with Gdk.Event; use Gdk.Event; with Gdk.Types; use Gdk.Types; with Glib; use Glib; with Glib.Generic_Properties; use Glib.Generic_Properties; with Glib.Glist; use Glib.Glist; with Glib.Object; use Glib.Object; with Glib.Properties; use Glib.Properties; package Gdk.Seat is type Gdk_Seat_Record is new GObject_Record with null record; type Gdk_Seat is access all Gdk_Seat_Record'Class; type Gdk_Seat_Capabilities is mod 2 ** Integer'Size; pragma Convention (C, Gdk_Seat_Capabilities); -- Flags describing the seat capabilities. Gdk_Seat_Capability_None : constant Gdk_Seat_Capabilities := 0; Gdk_Seat_Capability_Pointer : constant Gdk_Seat_Capabilities := 1; Gdk_Seat_Capability_Touch : constant Gdk_Seat_Capabilities := 2; Gdk_Seat_Capability_Tablet_Stylus : constant Gdk_Seat_Capabilities := 4; Gdk_Seat_Capability_Keyboard : constant Gdk_Seat_Capabilities := 8; Gdk_Seat_Capability_All_Pointing : constant Gdk_Seat_Capabilities := 7; Gdk_Seat_Capability_All : constant Gdk_Seat_Capabilities := 15; function Convert (R : Gdk.Seat.Gdk_Seat) return System.Address; function Convert (R : System.Address) return Gdk.Seat.Gdk_Seat; package Gdk_Seat_List is new Generic_List (Gdk.Seat.Gdk_Seat); --------------- -- Callbacks -- --------------- type Gdk_Seat_Grab_Prepare_Func is access procedure (Seat : not null access Gdk_Seat_Record'Class; Window : Gdk.Gdk_Window); -- Type of the callback used to set up Window so it can be grabbed. A -- typical action would be ensuring the window is visible, although there's -- room for other initialization actions. -- Since: gtk+ 3.20 -- "seat": the Gdk.Seat.Gdk_Seat being grabbed -- "window": the Gdk.Gdk_Window being grabbed ---------------------------- -- Enumeration Properties -- ---------------------------- package Gdk_Seat_Capabilities_Properties is new Generic_Internal_Discrete_Property (Gdk_Seat_Capabilities); type Property_Gdk_Seat_Capabilities is new Gdk_Seat_Capabilities_Properties.Property; ------------------ -- Constructors -- ------------------ function Get_Type return Glib.GType; pragma Import (C, Get_Type, "gdk_seat_get_type"); ------------- -- Methods -- ------------- function Get_Capabilities (Self : not null access Gdk_Seat_Record) return Gdk_Seat_Capabilities; -- Returns the capabilities this Gdk.Seat.Gdk_Seat currently has. -- Since: gtk+ 3.20 function Get_Display (Self : not null access Gdk_Seat_Record) return Glib.Object.GObject; -- Returns the Gdk.Display.Gdk_Display this seat belongs to. function Get_Keyboard (Self : not null access Gdk_Seat_Record) return Gdk.Device.Gdk_Device; -- Returns the master device that routes keyboard events. -- Since: gtk+ 3.20 function Get_Pointer (Self : not null access Gdk_Seat_Record) return Gdk.Device.Gdk_Device; -- Returns the master device that routes pointer events. -- Since: gtk+ 3.20 function Get_Slaves (Self : not null access Gdk_Seat_Record; Capabilities : Gdk_Seat_Capabilities) return Gdk.Device.Device_List.Glist; -- Returns the slave devices that match the given capabilities. -- Since: gtk+ 3.20 -- "capabilities": capabilities to get devices for function Grab (Self : not null access Gdk_Seat_Record; Window : Gdk.Gdk_Window; Capabilities : Gdk_Seat_Capabilities; Owner_Events : Boolean; Cursor : Gdk.Gdk_Cursor; Event : Gdk.Event.Gdk_Event; Prepare_Func : Gdk_Seat_Grab_Prepare_Func) return Gdk_Grab_Status; -- Grabs the seat so that all events corresponding to the given -- Capabilities are passed to this application until the seat is ungrabbed -- with Gdk.Seat.Ungrab, or the window becomes hidden. This overrides any -- previous grab on the seat by this client. -- As a rule of thumb, if a grab is desired over -- Gdk.Seat.Gdk_Seat_Capability_Pointer, all other "pointing" capabilities -- (eg. Gdk.Seat.Gdk_Seat_Capability_Touch) should be grabbed too, so the -- user is able to interact with all of those while the grab holds, you -- should thus use Gdk.Seat.Gdk_Seat_Capability_All_Pointing most commonly. -- Grabs are used for operations which need complete control over the -- events corresponding to the given capabilities. For example in GTK+ this -- is used for Drag and Drop operations, popup menus and such. -- Note that if the event mask of a Gdk.Gdk_Window has selected both -- button press and button release events, or touch begin and touch end, -- then a press event will cause an automatic grab until the button is -- released, equivalent to a grab on the window with Owner_Events set to -- True. This is done because most applications expect to receive paired -- press and release events. -- If you set up anything at the time you take the grab that needs to be -- cleaned up when the grab ends, you should handle the -- Gdk.Event.Gdk_Event_Grab_Broken events that are emitted when the grab -- ends unvoluntarily. -- Since: gtk+ 3.20 -- "window": the Gdk.Gdk_Window which will own the grab -- "capabilities": capabilities that will be grabbed -- "owner_events": if False then all device events are reported with -- respect to Window and are only reported if selected by Event_Mask. If -- True then pointer events for this application are reported as normal, -- but pointer events outside this application are reported with respect to -- Window and only if selected by Event_Mask. In either mode, unreported -- events are discarded. -- "cursor": the cursor to display while the grab is active. If this is -- null then the normal cursors are used for Window and its descendants, -- and the cursor for Window is used elsewhere. -- "event": the event that is triggering the grab, or null if none is -- available. -- "prepare_func": function to prepare the window to be grabbed, it can be -- null if Window is visible before this call. procedure Ungrab (Self : not null access Gdk_Seat_Record); -- Releases a grab added through Gdk.Seat.Grab. -- Since: gtk+ 3.20 ---------------- -- Properties -- ---------------- -- The following properties are defined for this widget. See -- Glib.Properties for more information on properties) Display_Property : constant Glib.Properties.Property_Boxed; -- Type: Display -- Gdk.Display.Gdk_Display of this seat. ------------- -- Signals -- ------------- type Cb_Gdk_Seat_GObject_Void is not null access procedure (Self : access Gdk_Seat_Record'Class; Device : not null access Glib.Object.GObject_Record'Class); type Cb_GObject_GObject_Void is not null access procedure (Self : access Glib.Object.GObject_Record'Class; Device : not null access Glib.Object.GObject_Record'Class); Signal_Device_Added : constant Glib.Signal_Name := "device-added"; procedure On_Device_Added (Self : not null access Gdk_Seat_Record; Call : Cb_Gdk_Seat_GObject_Void; After : Boolean := False); procedure On_Device_Added (Self : not null access Gdk_Seat_Record; Call : Cb_GObject_GObject_Void; Slot : not null access Glib.Object.GObject_Record'Class; After : Boolean := False); -- The ::device-added signal is emitted when a new input device is related -- to this seat. Signal_Device_Removed : constant Glib.Signal_Name := "device-removed"; procedure On_Device_Removed (Self : not null access Gdk_Seat_Record; Call : Cb_Gdk_Seat_GObject_Void; After : Boolean := False); procedure On_Device_Removed (Self : not null access Gdk_Seat_Record; Call : Cb_GObject_GObject_Void; Slot : not null access Glib.Object.GObject_Record'Class; After : Boolean := False); -- The ::device-removed signal is emitted when an input device is removed -- (e.g. unplugged). Signal_Tool_Added : constant Glib.Signal_Name := "tool-added"; procedure On_Tool_Added (Self : not null access Gdk_Seat_Record; Call : Cb_Gdk_Seat_GObject_Void; After : Boolean := False); procedure On_Tool_Added (Self : not null access Gdk_Seat_Record; Call : Cb_GObject_GObject_Void; Slot : not null access Glib.Object.GObject_Record'Class; After : Boolean := False); -- The ::tool-added signal is emitted whenever a new tool is made known to -- the seat. The tool may later be assigned to a device (i.e. on proximity -- with a tablet). The device will emit the -- Gdk.Device.Gdk_Device::tool-changed signal accordingly. -- -- A same tool may be used by several devices. Signal_Tool_Removed : constant Glib.Signal_Name := "tool-removed"; procedure On_Tool_Removed (Self : not null access Gdk_Seat_Record; Call : Cb_Gdk_Seat_GObject_Void; After : Boolean := False); procedure On_Tool_Removed (Self : not null access Gdk_Seat_Record; Call : Cb_GObject_GObject_Void; Slot : not null access Glib.Object.GObject_Record'Class; After : Boolean := False); -- This signal is emitted whenever a tool is no longer known to this Seat. private Display_Property : constant Glib.Properties.Property_Boxed := Glib.Properties.Build ("display"); end Gdk.Seat; gtkada-24.0.0/src/generated/gdk-window.adb000066400000000000000000001143441446021174000203050ustar00rootroot00000000000000------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ pragma Style_Checks (Off); pragma Warnings (Off, "*is already use-visible*"); with Ada.Unchecked_Conversion; pragma Warnings(Off); -- might be unused with Gtkada.Types; use Gtkada.Types; pragma Warnings(On); package body Gdk.Window is function From_Object_Free (B : access Gdk_Geometry) return Gdk_Geometry is Result : constant Gdk_Geometry := B.all; begin Glib.g_free (B.all'Address); return Result; end From_Object_Free; function Convert (R : Gdk.Gdk_Window) return System.Address is begin return Glib.To_Address (Glib.C_Proxy (R)); end Convert; function Convert (R : System.Address) return Gdk.Gdk_Window is begin return Gdk.Gdk_Window(Glib.C_Proxy'(Glib.To_Proxy (R))); end Convert; function Get_User_Data (Window : Gdk_Window) return Glib.Object.GObject is procedure Internal (Window : Gdk_Window; Widget : System.Address); pragma Import (C, Internal, "gdk_window_get_user_data"); Data : aliased System.Address; Stub : GObject_Record; begin Internal (Window, Data'Address); return Get_User_Data (Data, Stub); end Get_User_Data; procedure Set_User_Data (Window : Gdk_Window; Widget : access Glib.Object.GObject_Record'Class) is procedure Internal (Window : Gdk_Window; Widget : System.Address); pragma Import (C, Internal, "gdk_window_set_user_data"); begin Internal (Window, Get_Object (Widget)); end Set_User_Data; procedure C_Gdk_Window_Invalidate_Maybe_Recurse (Self : Gdk.Gdk_Window; Region : Cairo.Region.Cairo_Region; Child_Func : System.Address; User_Data : System.Address); pragma Import (C, C_Gdk_Window_Invalidate_Maybe_Recurse, "gdk_window_invalidate_maybe_recurse"); -- Adds Region to the update area for Window. The update area is the -- region that needs to be redrawn, or "dirty region." The call -- Gdk.Window.Process_Updates sends one or more expose events to the -- window, which together cover the entire update area. An application -- would normally redraw the contents of Window in response to those expose -- events. -- GDK will call Gdk.Window.Process_All_Updates on your behalf whenever -- your program returns to the main loop and becomes idle, so normally -- there's no need to do that manually, you just need to invalidate regions -- that you know should be redrawn. -- The Child_Func parameter controls whether the region of each child -- window that intersects Region will also be invalidated. Only children -- for which Child_Func returns TRUE will have the area invalidated. -- "region": a cairo_region_t -- "child_func": function to use to decide if to recurse to a child, null -- means never recurse. -- "user_data": data passed to Child_Func procedure C_Gdk_Window_Set_Invalidate_Handler (Self : Gdk.Gdk_Window; Handler : System.Address); pragma Import (C, C_Gdk_Window_Set_Invalidate_Handler, "gdk_window_set_invalidate_handler"); -- Registers an invalidate handler for a specific window. This will get -- called whenever a region in the window or its children is invalidated. -- This can be used to record the invalidated region, which is useful if -- you are keeping an offscreen copy of some region and want to keep it up -- to date. You can also modify the invalidated region in case you're doing -- some effect where e.g. a child widget appears in multiple places. -- Since: gtk+ 3.10 -- "handler": a Gdk_Window_Invalidate_Handler_Func callback function function To_Gdk_Window_Child_Func is new Ada.Unchecked_Conversion (System.Address, Gdk_Window_Child_Func); function To_Address is new Ada.Unchecked_Conversion (Gdk_Window_Child_Func, System.Address); function To_Address is new Ada.Unchecked_Conversion (Gdk_Window_Invalidate_Handler_Func, System.Address); function Internal_Gdk_Window_Child_Func (Window : Gdk.Gdk_Window; User_Data : System.Address) return Glib.Gboolean; pragma Convention (C, Internal_Gdk_Window_Child_Func); -- "window": a Gdk.Gdk_Window -- "user_data": user data ------------------------------------ -- Internal_Gdk_Window_Child_Func -- ------------------------------------ function Internal_Gdk_Window_Child_Func (Window : Gdk.Gdk_Window; User_Data : System.Address) return Glib.Gboolean is Func : constant Gdk_Window_Child_Func := To_Gdk_Window_Child_Func (User_Data); begin return Boolean'Pos (Func (Window)); end Internal_Gdk_Window_Child_Func; ------------- -- Gdk_New -- ------------- procedure Gdk_New (Self : out Gdk_Window; Parent : Gdk.Gdk_Window; Attributes : Gdk.Gdk_Window_Attr; Attributes_Mask : Gdk_Window_Attributes_Type) is function Internal (Parent : Gdk.Gdk_Window; Attributes : Gdk.Gdk_Window_Attr; Attributes_Mask : Gdk_Window_Attributes_Type) return Gdk_Window; pragma Import (C, Internal, "gdk_window_new"); begin Self := Internal (Parent, Attributes, Attributes_Mask); end Gdk_New; -------------------- -- Gdk_Window_New -- -------------------- function Gdk_Window_New (Parent : Gdk.Gdk_Window; Attributes : Gdk.Gdk_Window_Attr; Attributes_Mask : Gdk_Window_Attributes_Type) return Gdk_Window is function Internal (Parent : Gdk.Gdk_Window; Attributes : Gdk.Gdk_Window_Attr; Attributes_Mask : Gdk_Window_Attributes_Type) return Gdk_Window; pragma Import (C, Internal, "gdk_window_new"); Self : Gdk_Window; begin Self := Internal (Parent, Attributes, Attributes_Mask); return Self; end Gdk_Window_New; ---------------------- -- Begin_Draw_Frame -- ---------------------- function Begin_Draw_Frame (Self : Gdk.Gdk_Window; Region : Cairo.Region.Cairo_Region) return Gdk.Drawing_Context.Gdk_Drawing_Context is function Internal (Self : Gdk.Gdk_Window; Region : Cairo.Region.Cairo_Region) return System.Address; pragma Import (C, Internal, "gdk_window_begin_draw_frame"); Stub_Gdk_Drawing_Context : Gdk.Drawing_Context.Gdk_Drawing_Context_Record; begin return Gdk.Drawing_Context.Gdk_Drawing_Context (Get_User_Data (Internal (Self, Region), Stub_Gdk_Drawing_Context)); end Begin_Draw_Frame; -------------------------------- -- Begin_Move_Drag_For_Device -- -------------------------------- procedure Begin_Move_Drag_For_Device (Self : Gdk.Gdk_Window; Device : not null access Gdk.Device.Gdk_Device_Record'Class; Button : Glib.Gint; Root_X : Glib.Gint; Root_Y : Glib.Gint; Timestamp : Guint32) is procedure Internal (Self : Gdk.Gdk_Window; Device : System.Address; Button : Glib.Gint; Root_X : Glib.Gint; Root_Y : Glib.Gint; Timestamp : Guint32); pragma Import (C, Internal, "gdk_window_begin_move_drag_for_device"); begin Internal (Self, Get_Object (Device), Button, Root_X, Root_Y, Timestamp); end Begin_Move_Drag_For_Device; ---------------------------------- -- Begin_Resize_Drag_For_Device -- ---------------------------------- procedure Begin_Resize_Drag_For_Device (Self : Gdk.Gdk_Window; Edge : Gdk_Window_Edge; Device : not null access Gdk.Device.Gdk_Device_Record'Class; Button : Glib.Gint; Root_X : Glib.Gint; Root_Y : Glib.Gint; Timestamp : Guint32) is procedure Internal (Self : Gdk.Gdk_Window; Edge : Gdk_Window_Edge; Device : System.Address; Button : Glib.Gint; Root_X : Glib.Gint; Root_Y : Glib.Gint; Timestamp : Guint32); pragma Import (C, Internal, "gdk_window_begin_resize_drag_for_device"); begin Internal (Self, Edge, Get_Object (Device), Button, Root_X, Root_Y, Timestamp); end Begin_Resize_Drag_For_Device; ----------------------- -- Create_Gl_Context -- ----------------------- function Create_Gl_Context (Self : Gdk.Gdk_Window) return Gdk.GLContext.Gdk_GLContext is function Internal (Self : Gdk.Gdk_Window) return System.Address; pragma Import (C, Internal, "gdk_window_create_gl_context"); Stub_Gdk_GLContext : Gdk.GLContext.Gdk_GLContext_Record; begin return Gdk.GLContext.Gdk_GLContext (Get_User_Data (Internal (Self), Stub_Gdk_GLContext)); end Create_Gl_Context; -------------------- -- End_Draw_Frame -- -------------------- procedure End_Draw_Frame (Self : Gdk.Gdk_Window; Context : not null access Gdk.Drawing_Context.Gdk_Drawing_Context_Record'Class) is procedure Internal (Self : Gdk.Gdk_Window; Context : System.Address); pragma Import (C, Internal, "gdk_window_end_draw_frame"); begin Internal (Self, Get_Object (Context)); end End_Draw_Frame; ------------------- -- Ensure_Native -- ------------------- function Ensure_Native (Self : Gdk.Gdk_Window) return Boolean is function Internal (Self : Gdk.Gdk_Window) return Glib.Gboolean; pragma Import (C, Internal, "gdk_window_ensure_native"); begin return Internal (Self) /= 0; end Ensure_Native; ---------------------- -- Get_Accept_Focus -- ---------------------- function Get_Accept_Focus (Self : Gdk.Gdk_Window) return Boolean is function Internal (Self : Gdk.Gdk_Window) return Glib.Gboolean; pragma Import (C, Internal, "gdk_window_get_accept_focus"); begin return Internal (Self) /= 0; end Get_Accept_Focus; ------------------ -- Get_Children -- ------------------ function Get_Children (Self : Gdk.Gdk_Window) return Gdk_Window_List.Glist is function Internal (Self : Gdk.Gdk_Window) return System.Address; pragma Import (C, Internal, "gdk_window_get_children"); Tmp_Return : Gdk_Window_List.Glist; begin Gdk.Window.Gdk_Window_List.Set_Object (Tmp_Return, Internal (Self)); return Tmp_Return; end Get_Children; -------------------- -- Get_Composited -- -------------------- function Get_Composited (Self : Gdk.Gdk_Window) return Boolean is function Internal (Self : Gdk.Gdk_Window) return Glib.Gboolean; pragma Import (C, Internal, "gdk_window_get_composited"); begin return Internal (Self) /= 0; end Get_Composited; --------------------- -- Get_Decorations -- --------------------- procedure Get_Decorations (Self : Gdk.Gdk_Window; Decorations : out Gdk_WMDecoration; Has_Decorations : out Boolean) is function Internal (Self : Gdk.Gdk_Window; Acc_Decorations : access Gdk_WMDecoration) return Glib.Gboolean; pragma Import (C, Internal, "gdk_window_get_decorations"); Acc_Decorations : aliased Gdk_WMDecoration; Tmp_Return : Glib.Gboolean; begin Tmp_Return := Internal (Self, Acc_Decorations'Access); Decorations := Acc_Decorations; Has_Decorations := Tmp_Return /= 0; end Get_Decorations; ----------------------- -- Get_Device_Cursor -- ----------------------- function Get_Device_Cursor (Self : Gdk.Gdk_Window; Device : not null access Gdk.Device.Gdk_Device_Record'Class) return Gdk.Gdk_Cursor is function Internal (Self : Gdk.Gdk_Window; Device : System.Address) return Gdk.Gdk_Cursor; pragma Import (C, Internal, "gdk_window_get_device_cursor"); begin return Internal (Self, Get_Object (Device)); end Get_Device_Cursor; ----------------------- -- Get_Device_Events -- ----------------------- function Get_Device_Events (Self : Gdk.Gdk_Window; Device : not null access Gdk.Device.Gdk_Device_Record'Class) return Gdk.Event.Gdk_Event_Mask is function Internal (Self : Gdk.Gdk_Window; Device : System.Address) return Gdk.Event.Gdk_Event_Mask; pragma Import (C, Internal, "gdk_window_get_device_events"); begin return Internal (Self, Get_Object (Device)); end Get_Device_Events; ------------------------- -- Get_Device_Position -- ------------------------- procedure Get_Device_Position (Self : Gdk.Gdk_Window; Device : not null access Gdk.Device.Gdk_Device_Record'Class; X : out Glib.Gint; Y : out Glib.Gint; Mask : out Gdk.Types.Gdk_Modifier_Type; Window : out Gdk.Gdk_Window) is function Internal (Self : Gdk.Gdk_Window; Device : System.Address; Acc_X : access Glib.Gint; Acc_Y : access Glib.Gint; Acc_Mask : access Gdk.Types.Gdk_Modifier_Type) return Gdk.Gdk_Window; pragma Import (C, Internal, "gdk_window_get_device_position"); Acc_X : aliased Glib.Gint; Acc_Y : aliased Glib.Gint; Acc_Mask : aliased Gdk.Types.Gdk_Modifier_Type; Tmp_Return : Gdk.Gdk_Window; begin Tmp_Return := Internal (Self, Get_Object (Device), Acc_X'Access, Acc_Y'Access, Acc_Mask'Access); X := Acc_X; Y := Acc_Y; Mask := Acc_Mask; Window := Tmp_Return; end Get_Device_Position; -------------------------------- -- Get_Device_Position_Double -- -------------------------------- function Get_Device_Position_Double (Self : Gdk.Gdk_Window; Device : not null access Gdk.Device.Gdk_Device_Record'Class; X : access Gdouble; Y : access Gdouble; Mask : access Gdk.Types.Gdk_Modifier_Type) return Gdk.Gdk_Window is function Internal (Self : Gdk.Gdk_Window; Device : System.Address; Acc_X : access Gdouble; Acc_Y : access Gdouble; Acc_Mask : access Gdk.Types.Gdk_Modifier_Type) return Gdk.Gdk_Window; pragma Import (C, Internal, "gdk_window_get_device_position_double"); Acc_X : aliased Gdouble; Acc_Y : aliased Gdouble; Acc_Mask : aliased Gdk.Types.Gdk_Modifier_Type; Tmp_Return : Gdk.Gdk_Window; begin Tmp_Return := Internal (Self, Get_Object (Device), Acc_X'Access, Acc_Y'Access, Acc_Mask'Access); if X /= null then X.all := Acc_X; end if; if Y /= null then Y.all := Acc_Y; end if; if Mask /= null then Mask.all := Acc_Mask; end if; return Tmp_Return; end Get_Device_Position_Double; ----------------- -- Get_Display -- ----------------- function Get_Display (Self : Gdk.Gdk_Window) return Gdk.Display.Gdk_Display is function Internal (Self : Gdk.Gdk_Window) return System.Address; pragma Import (C, Internal, "gdk_window_get_display"); Stub_Gdk_Display : Gdk.Display.Gdk_Display_Record; begin return Gdk.Display.Gdk_Display (Get_User_Data (Internal (Self), Stub_Gdk_Display)); end Get_Display; --------------------------- -- Get_Event_Compression -- --------------------------- function Get_Event_Compression (Self : Gdk.Gdk_Window) return Boolean is function Internal (Self : Gdk.Gdk_Window) return Glib.Gboolean; pragma Import (C, Internal, "gdk_window_get_event_compression"); begin return Internal (Self) /= 0; end Get_Event_Compression; ---------------------- -- Get_Focus_On_Map -- ---------------------- function Get_Focus_On_Map (Self : Gdk.Gdk_Window) return Boolean is function Internal (Self : Gdk.Gdk_Window) return Glib.Gboolean; pragma Import (C, Internal, "gdk_window_get_focus_on_map"); begin return Internal (Self) /= 0; end Get_Focus_On_Map; --------------------- -- Get_Frame_Clock -- --------------------- function Get_Frame_Clock (Self : Gdk.Gdk_Window) return Gdk.Frame_Clock.Gdk_Frame_Clock is function Internal (Self : Gdk.Gdk_Window) return System.Address; pragma Import (C, Internal, "gdk_window_get_frame_clock"); Stub_Gdk_Frame_Clock : Gdk.Frame_Clock.Gdk_Frame_Clock_Record; begin return Gdk.Frame_Clock.Gdk_Frame_Clock (Get_User_Data (Internal (Self), Stub_Gdk_Frame_Clock)); end Get_Frame_Clock; -------------------- -- Get_Modal_Hint -- -------------------- function Get_Modal_Hint (Self : Gdk.Gdk_Window) return Boolean is function Internal (Self : Gdk.Gdk_Window) return Glib.Gboolean; pragma Import (C, Internal, "gdk_window_get_modal_hint"); begin return Internal (Self) /= 0; end Get_Modal_Hint; ---------------------- -- Get_Pass_Through -- ---------------------- function Get_Pass_Through (Self : Gdk.Gdk_Window) return Boolean is function Internal (Self : Gdk.Gdk_Window) return Glib.Gboolean; pragma Import (C, Internal, "gdk_window_get_pass_through"); begin return Internal (Self) /= 0; end Get_Pass_Through; ----------------- -- Get_Pointer -- ----------------- procedure Get_Pointer (Self : Gdk.Gdk_Window; X : out Glib.Gint; Y : out Glib.Gint; Mask : out Gdk.Types.Gdk_Modifier_Type; Window : out Gdk.Gdk_Window) is function Internal (Self : Gdk.Gdk_Window; Acc_X : access Glib.Gint; Acc_Y : access Glib.Gint; Acc_Mask : access Gdk.Types.Gdk_Modifier_Type) return Gdk.Gdk_Window; pragma Import (C, Internal, "gdk_window_get_pointer"); Acc_X : aliased Glib.Gint; Acc_Y : aliased Glib.Gint; Acc_Mask : aliased Gdk.Types.Gdk_Modifier_Type; Tmp_Return : Gdk.Gdk_Window; begin Tmp_Return := Internal (Self, Acc_X'Access, Acc_Y'Access, Acc_Mask'Access); X := Acc_X; Y := Acc_Y; Mask := Acc_Mask; Window := Tmp_Return; end Get_Pointer; ---------------- -- Get_Screen -- ---------------- function Get_Screen (Self : Gdk.Gdk_Window) return Gdk.Screen.Gdk_Screen is function Internal (Self : Gdk.Gdk_Window) return System.Address; pragma Import (C, Internal, "gdk_window_get_screen"); Stub_Gdk_Screen : Gdk.Screen.Gdk_Screen_Record; begin return Gdk.Screen.Gdk_Screen (Get_User_Data (Internal (Self), Stub_Gdk_Screen)); end Get_Screen; ----------------------------- -- Get_Support_Multidevice -- ----------------------------- function Get_Support_Multidevice (Self : Gdk.Gdk_Window) return Boolean is function Internal (Self : Gdk.Gdk_Window) return Glib.Gboolean; pragma Import (C, Internal, "gdk_window_get_support_multidevice"); begin return Internal (Self) /= 0; end Get_Support_Multidevice; ---------------- -- Has_Native -- ---------------- function Has_Native (Self : Gdk.Gdk_Window) return Boolean is function Internal (Self : Gdk.Gdk_Window) return Glib.Gboolean; pragma Import (C, Internal, "gdk_window_has_native"); begin return Internal (Self) /= 0; end Has_Native; ------------------------------ -- Invalidate_Maybe_Recurse -- ------------------------------ procedure Invalidate_Maybe_Recurse (Self : Gdk.Gdk_Window; Region : Cairo.Region.Cairo_Region; Child_Func : Gdk_Window_Child_Func) is begin if Child_Func = null then C_Gdk_Window_Invalidate_Maybe_Recurse (Self, Region, System.Null_Address, System.Null_Address); else C_Gdk_Window_Invalidate_Maybe_Recurse (Self, Region, Internal_Gdk_Window_Child_Func'Address, To_Address (Child_Func)); end if; end Invalidate_Maybe_Recurse; package body Invalidate_Maybe_Recurse_User_Data is package Users is new Glib.Object.User_Data_Closure (User_Data_Type, Destroy); function To_Gdk_Window_Child_Func is new Ada.Unchecked_Conversion (System.Address, Gdk_Window_Child_Func); function To_Address is new Ada.Unchecked_Conversion (Gdk_Window_Child_Func, System.Address); function Internal_Cb (Window : Gdk.Gdk_Window; User_Data : System.Address) return Glib.Gboolean; pragma Convention (C, Internal_Cb); -- A function of this type is passed to -- Gdk.Window.Invalidate_Maybe_Recurse. It gets called for each child of -- the window to determine whether to recursively invalidate it or now. -- "window": a Gdk.Gdk_Window -- "user_data": user data ----------------- -- Internal_Cb -- ----------------- function Internal_Cb (Window : Gdk.Gdk_Window; User_Data : System.Address) return Glib.Gboolean is D : constant Users.Internal_Data_Access := Users.Convert (User_Data); begin return Boolean'Pos (To_Gdk_Window_Child_Func (D.Func) (Window, D.Data.all)); end Internal_Cb; ------------------------------ -- Invalidate_Maybe_Recurse -- ------------------------------ procedure Invalidate_Maybe_Recurse (Self : Gdk.Gdk_Window; Region : Cairo.Region.Cairo_Region; Child_Func : Gdk_Window_Child_Func; User_Data : User_Data_Type) is D : System.Address; begin if Child_Func = null then C_Gdk_Window_Invalidate_Maybe_Recurse (Self, Region, System.Null_Address, System.Null_Address); else D := Users.Build (To_Address (Child_Func), User_Data); C_Gdk_Window_Invalidate_Maybe_Recurse (Self, Region, Internal_Cb'Address, D); Users.Free_Data (D); end if; end Invalidate_Maybe_Recurse; end Invalidate_Maybe_Recurse_User_Data; --------------------- -- Invalidate_Rect -- --------------------- procedure Invalidate_Rect (Self : Gdk.Gdk_Window; Rect : Gdk.Rectangle.Gdk_Rectangle; Invalidate_Children : Boolean) is procedure Internal (Self : Gdk.Gdk_Window; Rect : Gdk.Rectangle.Gdk_Rectangle; Invalidate_Children : Glib.Gboolean); pragma Import (C, Internal, "gdk_window_invalidate_rect"); begin Internal (Self, Rect, Boolean'Pos (Invalidate_Children)); end Invalidate_Rect; ----------------------- -- Invalidate_Region -- ----------------------- procedure Invalidate_Region (Self : Gdk.Gdk_Window; Region : Cairo.Region.Cairo_Region; Invalidate_Children : Boolean) is procedure Internal (Self : Gdk.Gdk_Window; Region : Cairo.Region.Cairo_Region; Invalidate_Children : Glib.Gboolean); pragma Import (C, Internal, "gdk_window_invalidate_region"); begin Internal (Self, Region, Boolean'Pos (Invalidate_Children)); end Invalidate_Region; ------------------ -- Is_Destroyed -- ------------------ function Is_Destroyed (Self : Gdk.Gdk_Window) return Boolean is function Internal (Self : Gdk.Gdk_Window) return Glib.Gboolean; pragma Import (C, Internal, "gdk_window_is_destroyed"); begin return Internal (Self) /= 0; end Is_Destroyed; ------------------- -- Is_Input_Only -- ------------------- function Is_Input_Only (Self : Gdk.Gdk_Window) return Boolean is function Internal (Self : Gdk.Gdk_Window) return Glib.Gboolean; pragma Import (C, Internal, "gdk_window_is_input_only"); begin return Internal (Self) /= 0; end Is_Input_Only; --------------- -- Is_Shaped -- --------------- function Is_Shaped (Self : Gdk.Gdk_Window) return Boolean is function Internal (Self : Gdk.Gdk_Window) return Glib.Gboolean; pragma Import (C, Internal, "gdk_window_is_shaped"); begin return Internal (Self) /= 0; end Is_Shaped; ----------------- -- Is_Viewable -- ----------------- function Is_Viewable (Self : Gdk.Gdk_Window) return Boolean is function Internal (Self : Gdk.Gdk_Window) return Glib.Gboolean; pragma Import (C, Internal, "gdk_window_is_viewable"); begin return Internal (Self) /= 0; end Is_Viewable; ---------------- -- Is_Visible -- ---------------- function Is_Visible (Self : Gdk.Gdk_Window) return Boolean is function Internal (Self : Gdk.Gdk_Window) return Glib.Gboolean; pragma Import (C, Internal, "gdk_window_is_visible"); begin return Internal (Self) /= 0; end Is_Visible; ------------------- -- Peek_Children -- ------------------- function Peek_Children (Self : Gdk.Gdk_Window) return Gdk_Window_List.Glist is function Internal (Self : Gdk.Gdk_Window) return System.Address; pragma Import (C, Internal, "gdk_window_peek_children"); Tmp_Return : Gdk_Window_List.Glist; begin Gdk.Window.Gdk_Window_List.Set_Object (Tmp_Return, Internal (Self)); return Tmp_Return; end Peek_Children; --------------------- -- Process_Updates -- --------------------- procedure Process_Updates (Self : Gdk.Gdk_Window; Update_Children : Boolean) is procedure Internal (Self : Gdk.Gdk_Window; Update_Children : Glib.Gboolean); pragma Import (C, Internal, "gdk_window_process_updates"); begin Internal (Self, Boolean'Pos (Update_Children)); end Process_Updates; ------------- -- Restack -- ------------- procedure Restack (Self : Gdk.Gdk_Window; Sibling : Gdk.Gdk_Window; Above : Boolean) is procedure Internal (Self : Gdk.Gdk_Window; Sibling : Gdk.Gdk_Window; Above : Glib.Gboolean); pragma Import (C, Internal, "gdk_window_restack"); begin Internal (Self, Sibling, Boolean'Pos (Above)); end Restack; ---------------------- -- Set_Accept_Focus -- ---------------------- procedure Set_Accept_Focus (Self : Gdk.Gdk_Window; Accept_Focus : Boolean) is procedure Internal (Self : Gdk.Gdk_Window; Accept_Focus : Glib.Gboolean); pragma Import (C, Internal, "gdk_window_set_accept_focus"); begin Internal (Self, Boolean'Pos (Accept_Focus)); end Set_Accept_Focus; -------------------- -- Set_Composited -- -------------------- procedure Set_Composited (Self : Gdk.Gdk_Window; Composited : Boolean) is procedure Internal (Self : Gdk.Gdk_Window; Composited : Glib.Gboolean); pragma Import (C, Internal, "gdk_window_set_composited"); begin Internal (Self, Boolean'Pos (Composited)); end Set_Composited; ----------------------- -- Set_Device_Cursor -- ----------------------- procedure Set_Device_Cursor (Self : Gdk.Gdk_Window; Device : not null access Gdk.Device.Gdk_Device_Record'Class; Cursor : Gdk.Gdk_Cursor) is procedure Internal (Self : Gdk.Gdk_Window; Device : System.Address; Cursor : Gdk.Gdk_Cursor); pragma Import (C, Internal, "gdk_window_set_device_cursor"); begin Internal (Self, Get_Object (Device), Cursor); end Set_Device_Cursor; ----------------------- -- Set_Device_Events -- ----------------------- procedure Set_Device_Events (Self : Gdk.Gdk_Window; Device : not null access Gdk.Device.Gdk_Device_Record'Class; Event_Mask : Gdk.Event.Gdk_Event_Mask) is procedure Internal (Self : Gdk.Gdk_Window; Device : System.Address; Event_Mask : Gdk.Event.Gdk_Event_Mask); pragma Import (C, Internal, "gdk_window_set_device_events"); begin Internal (Self, Get_Object (Device), Event_Mask); end Set_Device_Events; --------------------------- -- Set_Event_Compression -- --------------------------- procedure Set_Event_Compression (Self : Gdk.Gdk_Window; Event_Compression : Boolean) is procedure Internal (Self : Gdk.Gdk_Window; Event_Compression : Glib.Gboolean); pragma Import (C, Internal, "gdk_window_set_event_compression"); begin Internal (Self, Boolean'Pos (Event_Compression)); end Set_Event_Compression; ---------------------- -- Set_Focus_On_Map -- ---------------------- procedure Set_Focus_On_Map (Self : Gdk.Gdk_Window; Focus_On_Map : Boolean) is procedure Internal (Self : Gdk.Gdk_Window; Focus_On_Map : Glib.Gboolean); pragma Import (C, Internal, "gdk_window_set_focus_on_map"); begin Internal (Self, Boolean'Pos (Focus_On_Map)); end Set_Focus_On_Map; ------------------- -- Set_Icon_Name -- ------------------- procedure Set_Icon_Name (Self : Gdk.Gdk_Window; Name : UTF8_String := "") is procedure Internal (Self : Gdk.Gdk_Window; Name : Gtkada.Types.Chars_Ptr); pragma Import (C, Internal, "gdk_window_set_icon_name"); Tmp_Name : Gtkada.Types.Chars_Ptr; begin if Name = "" then Tmp_Name := Gtkada.Types.Null_Ptr; else Tmp_Name := New_String (Name); end if; Internal (Self, Tmp_Name); Free (Tmp_Name); end Set_Icon_Name; ---------------------------- -- Set_Invalidate_Handler -- ---------------------------- procedure Set_Invalidate_Handler (Self : Gdk.Gdk_Window; Handler : Gdk_Window_Invalidate_Handler_Func) is begin if Handler = null then C_Gdk_Window_Set_Invalidate_Handler (Self, System.Null_Address); else C_Gdk_Window_Set_Invalidate_Handler (Self, To_Address (Handler)); end if; end Set_Invalidate_Handler; -------------------- -- Set_Keep_Above -- -------------------- procedure Set_Keep_Above (Self : Gdk.Gdk_Window; Setting : Boolean) is procedure Internal (Self : Gdk.Gdk_Window; Setting : Glib.Gboolean); pragma Import (C, Internal, "gdk_window_set_keep_above"); begin Internal (Self, Boolean'Pos (Setting)); end Set_Keep_Above; -------------------- -- Set_Keep_Below -- -------------------- procedure Set_Keep_Below (Self : Gdk.Gdk_Window; Setting : Boolean) is procedure Internal (Self : Gdk.Gdk_Window; Setting : Glib.Gboolean); pragma Import (C, Internal, "gdk_window_set_keep_below"); begin Internal (Self, Boolean'Pos (Setting)); end Set_Keep_Below; -------------------- -- Set_Modal_Hint -- -------------------- procedure Set_Modal_Hint (Self : Gdk.Gdk_Window; Modal : Boolean) is procedure Internal (Self : Gdk.Gdk_Window; Modal : Glib.Gboolean); pragma Import (C, Internal, "gdk_window_set_modal_hint"); begin Internal (Self, Boolean'Pos (Modal)); end Set_Modal_Hint; --------------------------- -- Set_Override_Redirect -- --------------------------- procedure Set_Override_Redirect (Self : Gdk.Gdk_Window; Override_Redirect : Boolean) is procedure Internal (Self : Gdk.Gdk_Window; Override_Redirect : Glib.Gboolean); pragma Import (C, Internal, "gdk_window_set_override_redirect"); begin Internal (Self, Boolean'Pos (Override_Redirect)); end Set_Override_Redirect; ---------------------- -- Set_Pass_Through -- ---------------------- procedure Set_Pass_Through (Self : Gdk.Gdk_Window; Pass_Through : Boolean) is procedure Internal (Self : Gdk.Gdk_Window; Pass_Through : Glib.Gboolean); pragma Import (C, Internal, "gdk_window_set_pass_through"); begin Internal (Self, Boolean'Pos (Pass_Through)); end Set_Pass_Through; -------------- -- Set_Role -- -------------- procedure Set_Role (Self : Gdk.Gdk_Window; Role : UTF8_String) is procedure Internal (Self : Gdk.Gdk_Window; Role : Gtkada.Types.Chars_Ptr); pragma Import (C, Internal, "gdk_window_set_role"); Tmp_Role : Gtkada.Types.Chars_Ptr := New_String (Role); begin Internal (Self, Tmp_Role); Free (Tmp_Role); end Set_Role; ------------------------- -- Set_Skip_Pager_Hint -- ------------------------- procedure Set_Skip_Pager_Hint (Self : Gdk.Gdk_Window; Skips_Pager : Boolean) is procedure Internal (Self : Gdk.Gdk_Window; Skips_Pager : Glib.Gboolean); pragma Import (C, Internal, "gdk_window_set_skip_pager_hint"); begin Internal (Self, Boolean'Pos (Skips_Pager)); end Set_Skip_Pager_Hint; --------------------------- -- Set_Skip_Taskbar_Hint -- --------------------------- procedure Set_Skip_Taskbar_Hint (Self : Gdk.Gdk_Window; Skips_Taskbar : Boolean) is procedure Internal (Self : Gdk.Gdk_Window; Skips_Taskbar : Glib.Gboolean); pragma Import (C, Internal, "gdk_window_set_skip_taskbar_hint"); begin Internal (Self, Boolean'Pos (Skips_Taskbar)); end Set_Skip_Taskbar_Hint; -------------------- -- Set_Startup_Id -- -------------------- procedure Set_Startup_Id (Self : Gdk.Gdk_Window; Startup_Id : UTF8_String) is procedure Internal (Self : Gdk.Gdk_Window; Startup_Id : Gtkada.Types.Chars_Ptr); pragma Import (C, Internal, "gdk_window_set_startup_id"); Tmp_Startup_Id : Gtkada.Types.Chars_Ptr := New_String (Startup_Id); begin Internal (Self, Tmp_Startup_Id); Free (Tmp_Startup_Id); end Set_Startup_Id; -------------------------- -- Set_Static_Gravities -- -------------------------- function Set_Static_Gravities (Self : Gdk.Gdk_Window; Use_Static : Boolean) return Boolean is function Internal (Self : Gdk.Gdk_Window; Use_Static : Glib.Gboolean) return Glib.Gboolean; pragma Import (C, Internal, "gdk_window_set_static_gravities"); begin return Internal (Self, Boolean'Pos (Use_Static)) /= 0; end Set_Static_Gravities; ----------------------------- -- Set_Support_Multidevice -- ----------------------------- procedure Set_Support_Multidevice (Self : Gdk.Gdk_Window; Support_Multidevice : Boolean) is procedure Internal (Self : Gdk.Gdk_Window; Support_Multidevice : Glib.Gboolean); pragma Import (C, Internal, "gdk_window_set_support_multidevice"); begin Internal (Self, Boolean'Pos (Support_Multidevice)); end Set_Support_Multidevice; --------------- -- Set_Title -- --------------- procedure Set_Title (Self : Gdk.Gdk_Window; Title : UTF8_String) is procedure Internal (Self : Gdk.Gdk_Window; Title : Gtkada.Types.Chars_Ptr); pragma Import (C, Internal, "gdk_window_set_title"); Tmp_Title : Gtkada.Types.Chars_Ptr := New_String (Title); begin Internal (Self, Tmp_Title); Free (Tmp_Title); end Set_Title; ---------------------- -- Set_Urgency_Hint -- ---------------------- procedure Set_Urgency_Hint (Self : Gdk.Gdk_Window; Urgent : Boolean) is procedure Internal (Self : Gdk.Gdk_Window; Urgent : Glib.Gboolean); pragma Import (C, Internal, "gdk_window_set_urgency_hint"); begin Internal (Self, Boolean'Pos (Urgent)); end Set_Urgency_Hint; ---------------------- -- Show_Window_Menu -- ---------------------- function Show_Window_Menu (Self : Gdk.Gdk_Window; Event : Gdk.Event.Gdk_Event) return Boolean is function Internal (Self : Gdk.Gdk_Window; Event : Gdk.Event.Gdk_Event) return Glib.Gboolean; pragma Import (C, Internal, "gdk_window_show_window_menu"); begin return Internal (Self, Event) /= 0; end Show_Window_Menu; ---------------- -- At_Pointer -- ---------------- procedure At_Pointer (Win_X : out Glib.Gint; Win_Y : out Glib.Gint; Window : out Gdk.Gdk_Window) is function Internal (Acc_Win_X : access Glib.Gint; Acc_Win_Y : access Glib.Gint) return Gdk.Gdk_Window; pragma Import (C, Internal, "gdk_window_at_pointer"); Acc_Win_X : aliased Glib.Gint; Acc_Win_Y : aliased Glib.Gint; Tmp_Return : Gdk.Gdk_Window; begin Tmp_Return := Internal (Acc_Win_X'Access, Acc_Win_Y'Access); Win_X := Acc_Win_X; Win_Y := Acc_Win_Y; Window := Tmp_Return; end At_Pointer; ----------------------- -- Set_Debug_Updates -- ----------------------- procedure Set_Debug_Updates (Setting : Boolean) is procedure Internal (Setting : Glib.Gboolean); pragma Import (C, Internal, "gdk_window_set_debug_updates"); begin Internal (Boolean'Pos (Setting)); end Set_Debug_Updates; end Gdk.Window; gtkada-24.0.0/src/generated/gdk-window.ads000066400000000000000000003566331446021174000203370ustar00rootroot00000000000000------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ pragma Warnings (Off, "*is already use-visible*"); with Cairo; use Cairo; with Cairo.Region; use Cairo.Region; with Gdk.Color; use Gdk.Color; with Gdk.Device; use Gdk.Device; with Gdk.Display; use Gdk.Display; with Gdk.Drawing_Context; use Gdk.Drawing_Context; with Gdk.Event; use Gdk.Event; with Gdk.Frame_Clock; use Gdk.Frame_Clock; with Gdk.GLContext; use Gdk.GLContext; with Gdk.RGBA; use Gdk.RGBA; with Gdk.Rectangle; use Gdk.Rectangle; with Gdk.Screen; use Gdk.Screen; with Gdk.Types; use Gdk.Types; with Gdk.Visual; use Gdk.Visual; with Glib; use Glib; with Glib.Generic_Properties; use Glib.Generic_Properties; with Glib.Glist; use Glib.Glist; with Glib.Object; use Glib.Object; with Glib.Properties; use Glib.Properties; package Gdk.Window is type Gdk_Window_Class is ( Input_Output, Input_Only); pragma Convention (C, Gdk_Window_Class); -- Gdk_Input_Output windows are the standard kind of window you might -- expect. Such windows receive events and are also displayed on screen. -- Gdk_Input_Only windows are invisible; they are usually placed above -- other windows in order to trap or filter the events. You can't draw on -- Gdk_Input_Only windows. type Gdk_Window_Edge is ( Window_Edge_North_West, Window_Edge_North, Window_Edge_North_East, Window_Edge_West, Window_Edge_East, Window_Edge_South_West, Window_Edge_South, Window_Edge_South_East); pragma Convention (C, Gdk_Window_Edge); -- Determines a window edge or corner. type Gdk_Window_Type is ( Window_Root, Window_Toplevel, Window_Child, Window_Temp, Window_Foreign, Window_Offscreen, Window_Subsurface); pragma Convention (C, Gdk_Window_Type); -- Describes the kind of window. type Gdk_Window_Attributes_Type is mod 2 ** Integer'Size; pragma Convention (C, Gdk_Window_Attributes_Type); -- Used to indicate which fields in the Gdk_Window_Attr struct should be -- honored. For example, if you filled in the "cursor" and "x" fields of -- Gdk_Window_Attr, pass "Gdk_Wa_X | Gdk_Wa_Cursor" to gdk_window_new. -- Fields in Gdk_Window_Attr not covered by a bit in this enum are -- required; for example, the Width/Height, Wclass, and Window_Type fields -- are required, they have no corresponding flag in -- Gdk.Window.Gdk_Window_Attributes_Type. Wa_Title : constant Gdk_Window_Attributes_Type := 2; Wa_X : constant Gdk_Window_Attributes_Type := 4; Wa_Y : constant Gdk_Window_Attributes_Type := 8; Wa_Cursor : constant Gdk_Window_Attributes_Type := 16; Wa_Visual : constant Gdk_Window_Attributes_Type := 32; Wa_Wmclass : constant Gdk_Window_Attributes_Type := 64; Wa_Noredir : constant Gdk_Window_Attributes_Type := 128; Wa_Type_Hint : constant Gdk_Window_Attributes_Type := 256; type Gdk_Window_Hints is mod 2 ** Integer'Size; pragma Convention (C, Gdk_Window_Hints); -- Used to indicate which fields of a Gdk.Window.Gdk_Geometry struct -- should be paid attention to. Also, the presence/absence of Gdk_Hint_Pos, -- Gdk_Hint_User_Pos, and Gdk_Hint_User_Size is significant, though they -- don't directly refer to Gdk.Window.Gdk_Geometry fields. -- Gdk_Hint_User_Pos will be set automatically by Gtk.Window.Gtk_Window if -- you call Gtk.Window.Move. Gdk_Hint_User_Pos and Gdk_Hint_User_Size -- should be set if the user specified a size/position using a --geometry -- command-line argument; Gtk.Window.Parse_Geometry automatically sets -- these flags. Hint_Pos : constant Gdk_Window_Hints := 1; Hint_Min_Size : constant Gdk_Window_Hints := 2; Hint_Max_Size : constant Gdk_Window_Hints := 4; Hint_Base_Size : constant Gdk_Window_Hints := 8; Hint_Aspect : constant Gdk_Window_Hints := 16; Hint_Resize_Inc : constant Gdk_Window_Hints := 32; Hint_Win_Gravity : constant Gdk_Window_Hints := 64; Hint_User_Pos : constant Gdk_Window_Hints := 128; Hint_User_Size : constant Gdk_Window_Hints := 256; type Gdk_Window_Type_Hint is ( Window_Type_Hint_Normal, Window_Type_Hint_Dialog, Window_Type_Hint_Menu, Window_Type_Hint_Toolbar, Window_Type_Hint_Splashscreen, Window_Type_Hint_Utility, Window_Type_Hint_Dock, Window_Type_Hint_Desktop, Window_Type_Hint_Dropdown_Menu, Window_Type_Hint_Popup_Menu, Window_Type_Hint_Tooltip, Window_Type_Hint_Notification, Window_Type_Hint_Combo, Window_Type_Hint_Dnd); pragma Convention (C, Gdk_Window_Type_Hint); -- These are hints for the window manager that indicate what type of -- function the window has. The window manager can use this when -- determining decoration and behaviour of the window. The hint must be set -- before mapping the window. -- -- See the [Extended Window Manager -- Hints](http://www.freedesktop.org/Standards/wm-spec) specification for -- more details about window types. type Gdk_WMDecoration is mod 2 ** Integer'Size; pragma Convention (C, Gdk_WMDecoration); -- These are hints originally defined by the Motif toolkit. The window -- manager can use them when determining how to decorate the window. The -- hint must be set before mapping the window. Decor_All : constant Gdk_WMDecoration := 1; Decor_Border : constant Gdk_WMDecoration := 2; Decor_Resizeh : constant Gdk_WMDecoration := 4; Decor_Title : constant Gdk_WMDecoration := 8; Decor_Menu : constant Gdk_WMDecoration := 16; Decor_Minimize : constant Gdk_WMDecoration := 32; Decor_Maximize : constant Gdk_WMDecoration := 64; type Gdk_WMFunction is mod 2 ** Integer'Size; pragma Convention (C, Gdk_WMFunction); -- These are hints originally defined by the Motif toolkit. The window -- manager can use them when determining the functions to offer for the -- window. The hint must be set before mapping the window. Func_All : constant Gdk_WMFunction := 1; Func_Resize : constant Gdk_WMFunction := 2; Func_Move : constant Gdk_WMFunction := 4; Func_Minimize : constant Gdk_WMFunction := 8; Func_Maximize : constant Gdk_WMFunction := 16; Func_Close : constant Gdk_WMFunction := 32; type Gdk_Gravity is ( Gravity_North_West, Gravity_North, Gravity_North_East, Gravity_West, Gravity_Center, Gravity_East, Gravity_South_West, Gravity_South, Gravity_South_East, Gravity_Static); pragma Convention (C, Gdk_Gravity); -- Defines the reference point of a window and the meaning of coordinates -- passed to Gtk.Window.Move. See Gtk.Window.Move and the "implementation -- notes" section of the [Extended Window Manager -- Hints](http://www.freedesktop.org/Standards/wm-spec) specification for -- more details. for Gdk_Gravity use ( Gravity_North_West => 1, Gravity_North => 2, Gravity_North_East => 3, Gravity_West => 4, Gravity_Center => 5, Gravity_East => 6, Gravity_South_West => 7, Gravity_South => 8, Gravity_South_East => 9, Gravity_Static => 10); type Gdk_Fullscreen_Mode is ( On_Current_Monitor, On_All_Monitors); pragma Convention (C, Gdk_Fullscreen_Mode); -- Indicates which monitor (in a multi-head setup) a window should span -- over when in fullscreen mode. type Gdk_Anchor_Hints is mod 2 ** Integer'Size; pragma Convention (C, Gdk_Anchor_Hints); -- Positioning hints for aligning a window relative to a rectangle. -- -- These hints determine how the window should be positioned in the case -- that the window would fall off-screen if placed in its ideal position. -- -- For example, Gdk.Anchor_Flip_X will replace Gdk.Gravity_North_West with -- Gdk.Gravity_North_East and vice versa if the window extends beyond the -- left or right edges of the monitor. -- -- If Gdk.Anchor_Slide_X is set, the window can be shifted horizontally to -- fit on-screen. If Gdk.Anchor_Resize_X is set, the window can be shrunken -- horizontally to fit. -- -- In general, when multiple flags are set, flipping should take -- precedence over sliding, which should take precedence over resizing. Anchor_Flip_X : constant Gdk_Anchor_Hints := 1; Anchor_Flip_Y : constant Gdk_Anchor_Hints := 2; Anchor_Slide_X : constant Gdk_Anchor_Hints := 4; Anchor_Slide_Y : constant Gdk_Anchor_Hints := 8; Anchor_Resize_X : constant Gdk_Anchor_Hints := 16; Anchor_Resize_Y : constant Gdk_Anchor_Hints := 32; Anchor_Flip : constant Gdk_Anchor_Hints := 3; Anchor_Slide : constant Gdk_Anchor_Hints := 12; Anchor_Resize : constant Gdk_Anchor_Hints := 48; type Gdk_Geometry is record Min_Width : Glib.Gint := 0; Min_Height : Glib.Gint := 0; Max_Width : Glib.Gint := 0; Max_Height : Glib.Gint := 0; Base_Width : Glib.Gint := 0; Base_Height : Glib.Gint := 0; Width_Inc : Glib.Gint := 0; Height_Inc : Glib.Gint := 0; Min_Aspect : Gdouble; Max_Aspect : Gdouble; Win_Gravity : Gdk_Gravity; end record; pragma Convention (C, Gdk_Geometry); function From_Object_Free (B : access Gdk_Geometry) return Gdk_Geometry; pragma Inline (From_Object_Free); -- The Gdk.Window.Gdk_Geometry struct gives the window manager information -- about a window's geometry constraints. Normally you would set these on -- the GTK+ level using Gtk.Window.Set_Geometry_Hints. -- Gtk.Window.Gtk_Window then sets the hints on the Gdk.Gdk_Window it -- creates. -- -- Gdk.Window.Set_Geometry_Hints expects the hints to be fully valid -- already and simply passes them to the window manager; in contrast, -- Gtk.Window.Set_Geometry_Hints performs some interpretation. For example, -- Gtk.Window.Gtk_Window will apply the hints to the geometry widget -- instead of the toplevel window, if you set a geometry widget. Also, the -- Min_Width/Min_Height/Max_Width/Max_Height fields may be set to -1, and -- Gtk.Window.Gtk_Window will substitute the size request of the window or -- geometry widget. If the minimum size hint is not provided, -- Gtk.Window.Gtk_Window will use its requisition as the minimum size. If -- the minimum size is provided and a geometry widget is set, -- Gtk.Window.Gtk_Window will take the minimum size as the minimum size of -- the geometry widget rather than the entire window. The base size is -- treated similarly. -- -- The canonical use-case for Gtk.Window.Set_Geometry_Hints is to get a -- terminal widget to resize properly. Here, the terminal text area should -- be the geometry widget; Gtk.Window.Gtk_Window will then automatically -- set the base size to the size of other widgets in the terminal window, -- such as the menubar and scrollbar. Then, the Width_Inc and Height_Inc -- fields should be set to the size of one character in the terminal. -- Finally, the base size should be set to the size of one character. The -- net effect is that the minimum size of the terminal will have a 1x1 -- character terminal area, and only terminal sizes on the "character grid" -- will be allowed. -- -- Here's an example of how the terminal example would be implemented, -- assuming a terminal area widget called "terminal" and a toplevel window -- "toplevel": -- -- |[ GdkGeometry hints; -- -- hints.base_width = terminal->char_width; hints.base_height = -- terminal->char_height; hints.min_width = terminal->char_width; -- hints.min_height = terminal->char_height; hints.width_inc = -- terminal->char_width; hints.height_inc = terminal->char_height; -- -- gtk_window_set_geometry_hints (GTK_WINDOW (toplevel), GTK_WIDGET -- (terminal), &hints, GDK_HINT_RESIZE_INC | GDK_HINT_MIN_SIZE | -- GDK_HINT_BASE_SIZE); ]| -- -- The other useful fields are the Min_Aspect and Max_Aspect fields; these -- contain a width/height ratio as a floating point number. If a geometry -- widget is set, the aspect applies to the geometry widget rather than the -- entire window. The most common use of these hints is probably to set -- Min_Aspect and Max_Aspect to the same value, thus forcing the window to -- keep a constant aspect ratio. function Convert (R : Gdk.Gdk_Window) return System.Address; function Convert (R : System.Address) return Gdk.Gdk_Window; package Gdk_Window_List is new Generic_List (Gdk.Gdk_Window); --------------- -- Callbacks -- --------------- type Gdk_Window_Child_Func is access function (Window : Gdk.Gdk_Window) return Boolean; -- A function of this type is passed to -- Gdk.Window.Invalidate_Maybe_Recurse. It gets called for each child of -- the window to determine whether to recursively invalidate it or now. -- "window": a Gdk.Gdk_Window type Gdk_Window_Invalidate_Handler_Func is access procedure (Window : Gdk.Gdk_Window; Region : Cairo.Region.Cairo_Region); -- Whenever some area of the window is invalidated (directly in the window -- or in a child window) this gets called with Region in the coordinate -- space of Window. You can use Region to just keep track of the dirty -- region, or you can actually change Region in case you are doing display -- tricks like showing a child in multiple places. -- Since: gtk+ 3.10 -- "window": a Gdk.Gdk_Window -- "region": a cairo_region_t pragma Convention (C, Gdk_Window_Invalidate_Handler_Func); ---------------------------- -- Enumeration Properties -- ---------------------------- package Gdk_Window_Class_Properties is new Generic_Internal_Discrete_Property (Gdk_Window_Class); type Property_Gdk_Window_Class is new Gdk_Window_Class_Properties.Property; package Gdk_Window_Edge_Properties is new Generic_Internal_Discrete_Property (Gdk_Window_Edge); type Property_Gdk_Window_Edge is new Gdk_Window_Edge_Properties.Property; package Gdk_Window_Type_Properties is new Generic_Internal_Discrete_Property (Gdk_Window_Type); type Property_Gdk_Window_Type is new Gdk_Window_Type_Properties.Property; package Gdk_Window_Attributes_Type_Properties is new Generic_Internal_Discrete_Property (Gdk_Window_Attributes_Type); type Property_Gdk_Window_Attributes_Type is new Gdk_Window_Attributes_Type_Properties.Property; package Gdk_Window_Hints_Properties is new Generic_Internal_Discrete_Property (Gdk_Window_Hints); type Property_Gdk_Window_Hints is new Gdk_Window_Hints_Properties.Property; package Gdk_Window_Type_Hint_Properties is new Generic_Internal_Discrete_Property (Gdk_Window_Type_Hint); type Property_Gdk_Window_Type_Hint is new Gdk_Window_Type_Hint_Properties.Property; package Gdk_WMDecoration_Properties is new Generic_Internal_Discrete_Property (Gdk_WMDecoration); type Property_Gdk_WMDecoration is new Gdk_WMDecoration_Properties.Property; package Gdk_WMFunction_Properties is new Generic_Internal_Discrete_Property (Gdk_WMFunction); type Property_Gdk_WMFunction is new Gdk_WMFunction_Properties.Property; package Gdk_Gravity_Properties is new Generic_Internal_Discrete_Property (Gdk_Gravity); type Property_Gdk_Gravity is new Gdk_Gravity_Properties.Property; package Gdk_Fullscreen_Mode_Properties is new Generic_Internal_Discrete_Property (Gdk_Fullscreen_Mode); type Property_Gdk_Fullscreen_Mode is new Gdk_Fullscreen_Mode_Properties.Property; package Gdk_Anchor_Hints_Properties is new Generic_Internal_Discrete_Property (Gdk_Anchor_Hints); type Property_Gdk_Anchor_Hints is new Gdk_Anchor_Hints_Properties.Property; ------------------ -- Constructors -- ------------------ procedure Gdk_New (Self : out Gdk_Window; Parent : Gdk.Gdk_Window; Attributes : Gdk.Gdk_Window_Attr; Attributes_Mask : Gdk_Window_Attributes_Type); -- Creates a new Gdk.Gdk_Window using the attributes from Attributes. See -- Gdk_Window_Attr and Gdk.Window.Gdk_Window_Attributes_Type for more -- details. Note: to use this on displays other than the default display, -- Parent must be specified. -- "parent": a Gdk.Gdk_Window, or null to create the window as a child of -- the default root window for the default display. -- "attributes": attributes of the new window -- "attributes_mask": mask indicating which fields in Attributes are valid function Gdk_Window_New (Parent : Gdk.Gdk_Window; Attributes : Gdk.Gdk_Window_Attr; Attributes_Mask : Gdk_Window_Attributes_Type) return Gdk_Window; -- Creates a new Gdk.Gdk_Window using the attributes from Attributes. See -- Gdk_Window_Attr and Gdk.Window.Gdk_Window_Attributes_Type for more -- details. Note: to use this on displays other than the default display, -- Parent must be specified. -- "parent": a Gdk.Gdk_Window, or null to create the window as a child of -- the default root window for the default display. -- "attributes": attributes of the new window -- "attributes_mask": mask indicating which fields in Attributes are valid function Get_Type return Glib.GType; pragma Import (C, Get_Type, "gdk_window_get_type"); ------------- -- Methods -- ------------- procedure Beep (Self : Gdk.Gdk_Window); pragma Import (C, Beep, "gdk_window_beep"); -- Emits a short beep associated to Window in the appropriate display, if -- supported. Otherwise, emits a short beep on the display just as -- Gdk.Display.Beep. -- Since: gtk+ 2.12 function Begin_Draw_Frame (Self : Gdk.Gdk_Window; Region : Cairo.Region.Cairo_Region) return Gdk.Drawing_Context.Gdk_Drawing_Context; -- Indicates that you are beginning the process of redrawing Region on -- Window, and provides you with a Gdk.Drawing_Context.Gdk_Drawing_Context. -- If Window is a top level Gdk.Gdk_Window, backed by a native window -- implementation, a backing store (offscreen buffer) large enough to -- contain Region will be created. The backing store will be initialized -- with the background color or background surface for Window. Then, all -- drawing operations performed on Window will be diverted to the backing -- store. When you call gdk_window_end_frame, the contents of the backing -- store will be copied to Window, making it visible on screen. Only the -- part of Window contained in Region will be modified; that is, drawing -- operations are clipped to Region. -- The net result of all this is to remove flicker, because the user sees -- the finished product appear all at once when you call -- Gdk.Window.End_Draw_Frame. If you draw to Window directly without -- calling Gdk.Window.Begin_Draw_Frame, the user may see flicker as -- individual drawing operations are performed in sequence. -- When using GTK+, the widget system automatically places calls to -- Gdk.Window.Begin_Draw_Frame and Gdk.Window.End_Draw_Frame around -- emissions of the `GtkWidget::draw` signal. That is, if you're drawing -- the contents of the widget yourself, you can assume that the widget has -- a cleared background, is already set as the clip region, and already has -- a backing store. Therefore in most cases, application code in GTK does -- not need to call Gdk.Window.Begin_Draw_Frame explicitly. -- Since: gtk+ 3.22 -- "region": a Cairo region procedure Begin_Move_Drag (Self : Gdk.Gdk_Window; Button : Glib.Gint; Root_X : Glib.Gint; Root_Y : Glib.Gint; Timestamp : Guint32); pragma Import (C, Begin_Move_Drag, "gdk_window_begin_move_drag"); -- Begins a window move operation (for a toplevel window). -- This function assumes that the drag is controlled by the client pointer -- device, use Gdk.Window.Begin_Move_Drag_For_Device to begin a drag with a -- different device. -- "button": the button being used to drag, or 0 for a keyboard-initiated -- drag -- "root_x": root window X coordinate of mouse click that began the drag -- "root_y": root window Y coordinate of mouse click that began the drag -- "timestamp": timestamp of mouse click that began the drag procedure Begin_Move_Drag_For_Device (Self : Gdk.Gdk_Window; Device : not null access Gdk.Device.Gdk_Device_Record'Class; Button : Glib.Gint; Root_X : Glib.Gint; Root_Y : Glib.Gint; Timestamp : Guint32); -- Begins a window move operation (for a toplevel window). You might use -- this function to implement a "window move grip," for example. The -- function works best with window managers that support the [Extended -- Window Manager Hints](http://www.freedesktop.org/Standards/wm-spec) but -- has a fallback implementation for other window managers. -- Since: gtk+ 3.4 -- "device": the device used for the operation -- "button": the button being used to drag, or 0 for a keyboard-initiated -- drag -- "root_x": root window X coordinate of mouse click that began the drag -- "root_y": root window Y coordinate of mouse click that began the drag -- "timestamp": timestamp of mouse click that began the drag procedure Begin_Paint_Rect (Self : Gdk.Gdk_Window; Rectangle : Gdk.Rectangle.Gdk_Rectangle); pragma Import (C, Begin_Paint_Rect, "gdk_window_begin_paint_rect"); pragma Obsolescent (Begin_Paint_Rect); -- A convenience wrapper around Gdk.Window.Begin_Paint_Region which -- creates a rectangular region for you. See Gdk.Window.Begin_Paint_Region -- for details. -- Deprecated since 3.22, 1 -- "rectangle": rectangle you intend to draw to procedure Begin_Paint_Region (Self : Gdk.Gdk_Window; Region : Cairo.Region.Cairo_Region); pragma Import (C, Begin_Paint_Region, "gdk_window_begin_paint_region"); pragma Obsolescent (Begin_Paint_Region); -- Indicates that you are beginning the process of redrawing Region. A -- backing store (offscreen buffer) large enough to contain Region will be -- created. The backing store will be initialized with the background color -- or background surface for Window. Then, all drawing operations performed -- on Window will be diverted to the backing store. When you call -- Gdk.Window.End_Paint, the backing store will be copied to Window, making -- it visible onscreen. Only the part of Window contained in Region will be -- modified; that is, drawing operations are clipped to Region. -- The net result of all this is to remove flicker, because the user sees -- the finished product appear all at once when you call -- Gdk.Window.End_Paint. If you draw to Window directly without calling -- Gdk.Window.Begin_Paint_Region, the user may see flicker as individual -- drawing operations are performed in sequence. The clipping and -- background-initializing features of Gdk.Window.Begin_Paint_Region are -- conveniences for the programmer, so you can avoid doing that work -- yourself. -- When using GTK+, the widget system automatically places calls to -- Gdk.Window.Begin_Paint_Region and Gdk.Window.End_Paint around emissions -- of the expose_event signal. That is, if you're writing an expose event -- handler, you can assume that the exposed area in -- Gdk.Event.Gdk_Event_Expose has already been cleared to the window -- background, is already set as the clip region, and already has a backing -- store. Therefore in most cases, application code need not call -- Gdk.Window.Begin_Paint_Region. (You can disable the automatic calls -- around expose events on a widget-by-widget basis by calling -- Gtk.Widget.Set_Double_Buffered.) -- If you call this function multiple times before calling the matching -- Gdk.Window.End_Paint, the backing stores are pushed onto a stack. -- Gdk.Window.End_Paint copies the topmost backing store onscreen, -- subtracts the topmost region from all other regions in the stack, and -- pops the stack. All drawing operations affect only the topmost backing -- store in the stack. One matching call to Gdk.Window.End_Paint is -- required for each call to Gdk.Window.Begin_Paint_Region. -- Deprecated since 3.22, 1 -- "region": region you intend to draw to procedure Begin_Resize_Drag (Self : Gdk.Gdk_Window; Edge : Gdk_Window_Edge; Button : Glib.Gint; Root_X : Glib.Gint; Root_Y : Glib.Gint; Timestamp : Guint32); pragma Import (C, Begin_Resize_Drag, "gdk_window_begin_resize_drag"); -- Begins a window resize operation (for a toplevel window). -- This function assumes that the drag is controlled by the client pointer -- device, use Gdk.Window.Begin_Resize_Drag_For_Device to begin a drag with -- a different device. -- "edge": the edge or corner from which the drag is started -- "button": the button being used to drag, or 0 for a keyboard-initiated -- drag -- "root_x": root window X coordinate of mouse click that began the drag -- "root_y": root window Y coordinate of mouse click that began the drag -- "timestamp": timestamp of mouse click that began the drag (use -- Gdk.Event.Get_Time) procedure Begin_Resize_Drag_For_Device (Self : Gdk.Gdk_Window; Edge : Gdk_Window_Edge; Device : not null access Gdk.Device.Gdk_Device_Record'Class; Button : Glib.Gint; Root_X : Glib.Gint; Root_Y : Glib.Gint; Timestamp : Guint32); -- Begins a window resize operation (for a toplevel window). You might use -- this function to implement a "window resize grip," for example; in fact -- Gtk.Status_Bar.Gtk_Status_Bar uses it. The function works best with -- window managers that support the [Extended Window Manager -- Hints](http://www.freedesktop.org/Standards/wm-spec) but has a fallback -- implementation for other window managers. -- Since: gtk+ 3.4 -- "edge": the edge or corner from which the drag is started -- "device": the device used for the operation -- "button": the button being used to drag, or 0 for a keyboard-initiated -- drag -- "root_x": root window X coordinate of mouse click that began the drag -- "root_y": root window Y coordinate of mouse click that began the drag -- "timestamp": timestamp of mouse click that began the drag (use -- Gdk.Event.Get_Time) procedure Configure_Finished (Self : Gdk.Gdk_Window); pragma Import (C, Configure_Finished, "gdk_window_configure_finished"); pragma Obsolescent (Configure_Finished); -- Does nothing, present only for compatiblity. -- Since: gtk+ 2.6 -- Deprecated since 3.8, 1 procedure Coords_From_Parent (Self : Gdk.Gdk_Window; Parent_X : Gdouble; Parent_Y : Gdouble; X : out Gdouble; Y : out Gdouble); pragma Import (C, Coords_From_Parent, "gdk_window_coords_from_parent"); -- Transforms window coordinates from a parent window to a child window, -- where the parent window is the normal parent as returned by -- Gdk.Window.Get_Parent for normal windows, and the window's embedder as -- returned by gdk_offscreen_window_get_embedder for offscreen windows. -- For normal windows, calling this function is equivalent to subtracting -- the return values of Gdk.Window.Get_Position from the parent -- coordinates. For offscreen windows however (which can be arbitrarily -- transformed), this function calls the GdkWindow::from-embedder: signal -- to translate the coordinates. -- You should always use this function when writing generic code that -- walks down a window hierarchy. -- See also: Gdk.Window.Coords_To_Parent -- Since: gtk+ 2.22 -- "parent_x": X coordinate in parent's coordinate system -- "parent_y": Y coordinate in parent's coordinate system -- "x": return location for X coordinate in child's coordinate system -- "y": return location for Y coordinate in child's coordinate system procedure Coords_To_Parent (Self : Gdk.Gdk_Window; X : Gdouble; Y : Gdouble; Parent_X : out Gdouble; Parent_Y : out Gdouble); pragma Import (C, Coords_To_Parent, "gdk_window_coords_to_parent"); -- Transforms window coordinates from a child window to its parent window, -- where the parent window is the normal parent as returned by -- Gdk.Window.Get_Parent for normal windows, and the window's embedder as -- returned by gdk_offscreen_window_get_embedder for offscreen windows. -- For normal windows, calling this function is equivalent to adding the -- return values of Gdk.Window.Get_Position to the child coordinates. For -- offscreen windows however (which can be arbitrarily transformed), this -- function calls the GdkWindow::to-embedder: signal to translate the -- coordinates. -- You should always use this function when writing generic code that -- walks up a window hierarchy. -- See also: Gdk.Window.Coords_From_Parent -- Since: gtk+ 2.22 -- "x": X coordinate in child's coordinate system -- "y": Y coordinate in child's coordinate system -- "parent_x": return location for X coordinate in parent's coordinate -- system, or null -- "parent_y": return location for Y coordinate in parent's coordinate -- system, or null function Create_Gl_Context (Self : Gdk.Gdk_Window) return Gdk.GLContext.Gdk_GLContext; -- Creates a new Gdk.GLContext.Gdk_GLContext matching the framebuffer -- format to the visual of the Gdk.Gdk_Window. The context is disconnected -- from any particular window or surface. -- If the creation of the Gdk.GLContext.Gdk_GLContext failed, Error will -- be set. -- Before using the returned Gdk.GLContext.Gdk_GLContext, you will need to -- call Gdk.GLContext.Make_Current or Gdk.GLContext.Realize. -- Since: gtk+ 3.16 function Create_Similar_Image_Surface (Self : Gdk.Gdk_Window; Format : Cairo.Cairo_Format; Width : Glib.Gint; Height : Glib.Gint; Scale : Glib.Gint) return Cairo.Cairo_Surface; pragma Import (C, Create_Similar_Image_Surface, "gdk_window_create_similar_image_surface"); -- Create a new image surface that is efficient to draw on the given -- Window. -- Initially the surface contents are all 0 (transparent if contents have -- transparency, black otherwise.) -- The Width and Height of the new surface are not affected by the scaling -- factor of the Window, or by the Scale argument; they are the size of the -- surface in device pixels. If you wish to create an image surface capable -- of holding the contents of Window you can use: -- |[ int scale = gdk_window_get_scale_factor -- (window); int width = gdk_window_get_width (window) * scale; int height -- = gdk_window_get_height (window) * scale; -- // format is set elsewhere cairo_surface_t *surface = -- gdk_window_create_similar_image_surface (window, format, width, height, -- scale); ]| -- Note that unlike cairo_surface_create_similar_image, the new surface's -- device scale is set to Scale, or to the scale factor of Window if Scale -- is 0. -- Since: gtk+ 3.10 -- "format": the format for the new surface -- "width": width of the new surface -- "height": height of the new surface -- "scale": the scale of the new surface, or 0 to use same as Window function Create_Similar_Surface (Self : Gdk.Gdk_Window; Content : Cairo.Cairo_Content; Width : Glib.Gint; Height : Glib.Gint) return Cairo.Cairo_Surface; pragma Import (C, Create_Similar_Surface, "gdk_window_create_similar_surface"); -- Create a new surface that is as compatible as possible with the given -- Window. For example the new surface will have the same fallback -- resolution and font options as Window. Generally, the new surface will -- also use the same backend as Window, unless that is not possible for -- some reason. The type of the returned surface may be examined with -- cairo_surface_get_type. -- Initially the surface contents are all 0 (transparent if contents have -- transparency, black otherwise.) -- Since: gtk+ 2.22 -- "content": the content for the new surface -- "width": width of the new surface -- "height": height of the new surface procedure Deiconify (Self : Gdk.Gdk_Window); pragma Import (C, Deiconify, "gdk_window_deiconify"); -- Attempt to deiconify (unminimize) Window. On X11 the window manager may -- choose to ignore the request to deiconify. When using GTK+, use -- Gtk.Window.Deiconify instead of the Gdk.Gdk_Window variant. Or better -- yet, you probably want to use Gtk.Window.Present_With_Time, which raises -- the window, focuses it, unminimizes it, and puts it on the current -- desktop. procedure Destroy (Self : Gdk.Gdk_Window); pragma Import (C, Destroy, "gdk_window_destroy"); -- Destroys the window system resources associated with Window and -- decrements Window's reference count. The window system resources for all -- children of Window are also destroyed, but the children's reference -- counts are not decremented. -- Note that a window will not be destroyed automatically when its -- reference count reaches zero. You must call this function yourself -- before that happens. procedure Destroy_Notify (Self : Gdk.Gdk_Window); pragma Import (C, Destroy_Notify, "gdk_window_destroy_notify"); procedure Enable_Synchronized_Configure (Self : Gdk.Gdk_Window); pragma Import (C, Enable_Synchronized_Configure, "gdk_window_enable_synchronized_configure"); pragma Obsolescent (Enable_Synchronized_Configure); -- Does nothing, present only for compatiblity. -- Since: gtk+ 2.6 -- Deprecated since 3.8, 1 procedure End_Draw_Frame (Self : Gdk.Gdk_Window; Context : not null access Gdk.Drawing_Context.Gdk_Drawing_Context_Record'Class); -- Indicates that the drawing of the contents of Window started with -- gdk_window_begin_frame has been completed. -- This function will take care of destroying the -- Gdk.Drawing_Context.Gdk_Drawing_Context. -- It is an error to call this function without a matching -- gdk_window_begin_frame first. -- Since: gtk+ 3.22 -- "context": the Gdk.Drawing_Context.Gdk_Drawing_Context created by -- Gdk.Window.Begin_Draw_Frame procedure End_Paint (Self : Gdk.Gdk_Window); pragma Import (C, End_Paint, "gdk_window_end_paint"); -- Indicates that the backing store created by the most recent call to -- Gdk.Window.Begin_Paint_Region should be copied onscreen and deleted, -- leaving the next-most-recent backing store or no backing store at all as -- the active paint region. See Gdk.Window.Begin_Paint_Region for full -- details. -- It is an error to call this function without a matching -- Gdk.Window.Begin_Paint_Region first. function Ensure_Native (Self : Gdk.Gdk_Window) return Boolean; -- Tries to ensure that there is a window-system native window for this -- GdkWindow. This may fail in some situations, returning False. -- Offscreen window and children of them can never have native windows. -- Some backends may not support native child windows. -- Since: gtk+ 2.18 procedure Flush (Self : Gdk.Gdk_Window); pragma Import (C, Flush, "gdk_window_flush"); pragma Obsolescent (Flush); -- This function does nothing. -- Since: gtk+ 2.18 -- Deprecated since 3.14, 1 procedure Focus (Self : Gdk.Gdk_Window; Timestamp : Guint32); pragma Import (C, Focus, "gdk_window_focus"); -- Sets keyboard focus to Window. In most cases, -- Gtk.Window.Present_With_Time should be used on a Gtk.Window.Gtk_Window, -- rather than calling this function. -- "timestamp": timestamp of the event triggering the window focus procedure Freeze_Toplevel_Updates_Libgtk_Only (Self : Gdk.Gdk_Window); pragma Import (C, Freeze_Toplevel_Updates_Libgtk_Only, "gdk_window_freeze_toplevel_updates_libgtk_only"); pragma Obsolescent (Freeze_Toplevel_Updates_Libgtk_Only); -- Temporarily freezes a window and all its descendants such that it won't -- receive expose events. The window will begin receiving expose events -- again when Gdk.Window.Thaw_Toplevel_Updates_Libgtk_Only is called. If -- Gdk.Window.Freeze_Toplevel_Updates_Libgtk_Only has been called more than -- once, Gdk.Window.Thaw_Toplevel_Updates_Libgtk_Only must be called an -- equal number of times to begin processing exposes. -- This function is not part of the GDK public API and is only for use by -- GTK+. -- Deprecated since 3.16, 1 procedure Freeze_Updates (Self : Gdk.Gdk_Window); pragma Import (C, Freeze_Updates, "gdk_window_freeze_updates"); -- Temporarily freezes a window such that it won't receive expose events. -- The window will begin receiving expose events again when -- Gdk.Window.Thaw_Updates is called. If Gdk.Window.Freeze_Updates has been -- called more than once, Gdk.Window.Thaw_Updates must be called an equal -- number of times to begin processing exposes. procedure Fullscreen (Self : Gdk.Gdk_Window); pragma Import (C, Fullscreen, "gdk_window_fullscreen"); -- Moves the window into fullscreen mode. This means the window covers the -- entire screen and is above any panels or task bars. -- If the window was already fullscreen, then this function does nothing. -- On X11, asks the window manager to put Window in a fullscreen state, if -- the window manager supports this operation. Not all window managers -- support this, and some deliberately ignore it or don't have a concept of -- "fullscreen"; so you can't rely on the fullscreenification actually -- happening. But it will happen with most standard window managers, and -- GDK makes a best effort to get it to happen. -- Since: gtk+ 2.2 procedure Fullscreen_On_Monitor (Self : Gdk.Gdk_Window; Monitor : Glib.Gint); pragma Import (C, Fullscreen_On_Monitor, "gdk_window_fullscreen_on_monitor"); -- Moves the window into fullscreen mode on the given monitor. This means -- the window covers the entire screen and is above any panels or task -- bars. -- If the window was already fullscreen, then this function does nothing. -- "monitor": Which monitor to display fullscreen on. procedure Geometry_Changed (Self : Gdk.Gdk_Window); pragma Import (C, Geometry_Changed, "gdk_window_geometry_changed"); -- This function informs GDK that the geometry of an embedded offscreen -- window has changed. This is necessary for GDK to keep track of which -- offscreen window the pointer is in. -- Since: gtk+ 2.18 function Get_Accept_Focus (Self : Gdk.Gdk_Window) return Boolean; -- Determines whether or not the desktop environment shuld be hinted that -- the window does not want to receive input focus. -- Since: gtk+ 2.22 procedure Set_Accept_Focus (Self : Gdk.Gdk_Window; Accept_Focus : Boolean); -- Setting Accept_Focus to False hints the desktop environment that the -- window doesn't want to receive input focus. -- On X, it is the responsibility of the window manager to interpret this -- hint. ICCCM-compliant window manager usually respect it. -- Since: gtk+ 2.4 -- "accept_focus": True if the window should receive input focus function Get_Background_Pattern (Self : Gdk.Gdk_Window) return Cairo.Cairo_Pattern; pragma Import (C, Get_Background_Pattern, "gdk_window_get_background_pattern"); pragma Obsolescent (Get_Background_Pattern); -- Gets the pattern used to clear the background on Window. -- Since: gtk+ 2.22 -- Deprecated since 3.22, 1 procedure Set_Background_Pattern (Self : Gdk.Gdk_Window; Pattern : Cairo.Cairo_Pattern); pragma Import (C, Set_Background_Pattern, "gdk_window_set_background_pattern"); pragma Obsolescent (Set_Background_Pattern); -- Sets the background of Window. -- A background of null means that the window won't have any background. -- On the X11 backend it's also possible to inherit the background from the -- parent window using gdk_x11_get_parent_relative_pattern. -- The windowing system will normally fill a window with its background -- when the window is obscured then exposed. -- Deprecated since 3.22, 1 -- "pattern": a pattern to use, or null function Get_Children (Self : Gdk.Gdk_Window) return Gdk_Window_List.Glist; -- Gets the list of children of Window known to GDK. This function only -- returns children created via GDK, so for example it's useless when used -- with the root window; it only returns windows an application created -- itself. -- The returned list must be freed, but the elements in the list need not -- be. function Get_Clip_Region (Self : Gdk.Gdk_Window) return Cairo.Region.Cairo_Region; pragma Import (C, Get_Clip_Region, "gdk_window_get_clip_region"); -- Computes the region of a window that potentially can be written to by -- drawing primitives. This region may not take into account other factors -- such as if the window is obscured by other windows, but no area outside -- of this region will be affected by drawing primitives. function Get_Composited (Self : Gdk.Gdk_Window) return Boolean; pragma Obsolescent (Get_Composited); -- Determines whether Window is composited. -- See Gdk.Window.Set_Composited. -- Since: gtk+ 2.22 -- Deprecated since 3.16, 1 procedure Set_Composited (Self : Gdk.Gdk_Window; Composited : Boolean); pragma Obsolescent (Set_Composited); -- Sets a Gdk.Gdk_Window as composited, or unsets it. Composited windows -- do not automatically have their contents drawn to the screen. Drawing is -- redirected to an offscreen buffer and an expose event is emitted on the -- parent of the composited window. It is the responsibility of the -- parent's expose handler to manually merge the off-screen content onto -- the screen in whatever way it sees fit. -- It only makes sense for child windows to be composited; see -- Gdk.Window.Set_Opacity if you need translucent toplevel windows. -- An additional effect of this call is that the area of this window is no -- longer clipped from regions marked for invalidation on its parent. Draws -- done on the parent window are also no longer clipped by the child. -- This call is only supported on some systems (currently, only X11 with -- new enough Xcomposite and Xdamage extensions). You must call -- Gdk.Display.Supports_Composite to check if setting a window as -- composited is supported before attempting to do so. -- Since: gtk+ 2.12 -- Deprecated since 3.16, 1 -- "composited": True to set the window as composited function Get_Cursor (Self : Gdk.Gdk_Window) return Gdk.Gdk_Cursor; pragma Import (C, Get_Cursor, "gdk_window_get_cursor"); -- Retrieves a Gdk.Gdk_Cursor pointer for the cursor currently set on the -- specified Gdk.Gdk_Window, or null. If the return value is null then -- there is no custom cursor set on the specified window, and it is using -- the cursor for its parent window. -- Since: gtk+ 2.18 procedure Set_Cursor (Self : Gdk.Gdk_Window; Cursor : Gdk.Gdk_Cursor); pragma Import (C, Set_Cursor, "gdk_window_set_cursor"); -- Sets the default mouse pointer for a Gdk.Gdk_Window. -- Note that Cursor must be for the same display as Window. -- Use gdk_cursor_new_for_display or gdk_cursor_new_from_pixbuf to create -- the cursor. To make the cursor invisible, use Gdk.Blank_Cursor. Passing -- null for the Cursor argument to Gdk.Window.Set_Cursor means that Window -- will use the cursor of its parent window. Most windows should use this -- default. -- "cursor": a cursor procedure Get_Decorations (Self : Gdk.Gdk_Window; Decorations : out Gdk_WMDecoration; Has_Decorations : out Boolean); -- Returns the decorations set on the GdkWindow with -- Gdk.Window.Set_Decorations. -- "decorations": The window decorations will be written here procedure Set_Decorations (Self : Gdk.Gdk_Window; Decorations : Gdk_WMDecoration); pragma Import (C, Set_Decorations, "gdk_window_set_decorations"); -- "Decorations" are the features the window manager adds to a toplevel -- Gdk.Gdk_Window. This function sets the traditional Motif window manager -- hints that tell the window manager which decorations you would like your -- window to have. Usually you should use Gtk.Window.Set_Decorated on a -- Gtk.Window.Gtk_Window instead of using the GDK function directly. -- The Decorations argument is the logical OR of the fields in the -- Gdk.Window.Gdk_WMDecoration enumeration. If GDK_DECOR_ALL is included in -- the mask, the other bits indicate which decorations should be turned -- off. If GDK_DECOR_ALL is not included, then the other bits indicate -- which decorations should be turned on. -- Most window managers honor a decorations hint of 0 to disable all -- decorations, but very few honor all possible combinations of bits. -- "decorations": decoration hint mask function Get_Device_Cursor (Self : Gdk.Gdk_Window; Device : not null access Gdk.Device.Gdk_Device_Record'Class) return Gdk.Gdk_Cursor; -- Retrieves a Gdk.Gdk_Cursor pointer for the Device currently set on the -- specified Gdk.Gdk_Window, or null. If the return value is null then -- there is no custom cursor set on the specified window, and it is using -- the cursor for its parent window. -- Since: gtk+ 3.0 -- "device": a master, pointer Gdk.Device.Gdk_Device. procedure Set_Device_Cursor (Self : Gdk.Gdk_Window; Device : not null access Gdk.Device.Gdk_Device_Record'Class; Cursor : Gdk.Gdk_Cursor); -- Sets a specific Gdk.Gdk_Cursor for a given device when it gets inside -- Window. Use gdk_cursor_new_for_display or gdk_cursor_new_from_pixbuf to -- create the cursor. To make the cursor invisible, use Gdk.Blank_Cursor. -- Passing null for the Cursor argument to Gdk.Window.Set_Cursor means that -- Window will use the cursor of its parent window. Most windows should use -- this default. -- Since: gtk+ 3.0 -- "device": a master, pointer Gdk.Device.Gdk_Device -- "cursor": a Gdk.Gdk_Cursor function Get_Device_Events (Self : Gdk.Gdk_Window; Device : not null access Gdk.Device.Gdk_Device_Record'Class) return Gdk.Event.Gdk_Event_Mask; -- Returns the event mask for Window corresponding to an specific device. -- Since: gtk+ 3.0 -- "device": a Gdk.Device.Gdk_Device. procedure Set_Device_Events (Self : Gdk.Gdk_Window; Device : not null access Gdk.Device.Gdk_Device_Record'Class; Event_Mask : Gdk.Event.Gdk_Event_Mask); -- Sets the event mask for a given device (Normally a floating device, not -- attached to any visible pointer) to Window. For example, an event mask -- including GDK_BUTTON_PRESS_MASK means the window should report button -- press events. The event mask is the bitwise OR of values from the -- Gdk.Event.Gdk_Event_Mask enumeration. -- See the [input handling overview][event-masks] for details. -- Since: gtk+ 3.0 -- "device": Gdk.Device.Gdk_Device to enable events for. -- "event_mask": event mask for Window procedure Get_Device_Position (Self : Gdk.Gdk_Window; Device : not null access Gdk.Device.Gdk_Device_Record'Class; X : out Glib.Gint; Y : out Glib.Gint; Mask : out Gdk.Types.Gdk_Modifier_Type; Window : out Gdk.Gdk_Window); -- Obtains the current device position and modifier state. The position is -- given in coordinates relative to the upper left corner of Window. -- Use Gdk.Window.Get_Device_Position_Double if you need subpixel -- precision. -- Since: gtk+ 3.0 -- "device": pointer Gdk.Device.Gdk_Device to query to. -- "x": return location for the X coordinate of Device, or null. -- "y": return location for the Y coordinate of Device, or null. -- "mask": return location for the modifier mask, or null. function Get_Device_Position_Double (Self : Gdk.Gdk_Window; Device : not null access Gdk.Device.Gdk_Device_Record'Class; X : access Gdouble; Y : access Gdouble; Mask : access Gdk.Types.Gdk_Modifier_Type) return Gdk.Gdk_Window; -- Obtains the current device position in doubles and modifier state. The -- position is given in coordinates relative to the upper left corner of -- Window. -- Since: gtk+ 3.10 -- "device": pointer Gdk.Device.Gdk_Device to query to. -- "x": return location for the X coordinate of Device, or null. -- "y": return location for the Y coordinate of Device, or null. -- "mask": return location for the modifier mask, or null. function Get_Display (Self : Gdk.Gdk_Window) return Gdk.Display.Gdk_Display; -- Gets the Gdk.Display.Gdk_Display associated with a Gdk.Gdk_Window. -- Since: gtk+ 2.24 function Get_Effective_Parent (Self : Gdk.Gdk_Window) return Gdk.Gdk_Window; pragma Import (C, Get_Effective_Parent, "gdk_window_get_effective_parent"); -- Obtains the parent of Window, as known to GDK. Works like -- Gdk.Window.Get_Parent for normal windows, but returns the window's -- embedder for offscreen windows. -- See also: gdk_offscreen_window_get_embedder -- Since: gtk+ 2.22 function Get_Effective_Toplevel (Self : Gdk.Gdk_Window) return Gdk.Gdk_Window; pragma Import (C, Get_Effective_Toplevel, "gdk_window_get_effective_toplevel"); -- Gets the toplevel window that's an ancestor of Window. -- Works like Gdk.Window.Get_Toplevel, but treats an offscreen window's -- embedder as its parent, using Gdk.Window.Get_Effective_Parent. -- See also: gdk_offscreen_window_get_embedder -- Since: gtk+ 2.22 function Get_Event_Compression (Self : Gdk.Gdk_Window) return Boolean; -- Get the current event compression setting for this window. -- Since: gtk+ 3.12 procedure Set_Event_Compression (Self : Gdk.Gdk_Window; Event_Compression : Boolean); -- Determines whether or not extra unprocessed motion events in the event -- queue can be discarded. If True only the most recent event will be -- delivered. -- Some types of applications, e.g. paint programs, need to see all motion -- events and will benefit from turning off event compression. -- By default, event compression is enabled. -- Since: gtk+ 3.12 -- "event_compression": True if motion events should be compressed function Get_Events (Self : Gdk.Gdk_Window) return Gdk.Event.Gdk_Event_Mask; pragma Import (C, Get_Events, "gdk_window_get_events"); -- Gets the event mask for Window for all master input devices. See -- Gdk.Window.Set_Events. procedure Set_Events (Self : Gdk.Gdk_Window; Event_Mask : Gdk.Event.Gdk_Event_Mask); pragma Import (C, Set_Events, "gdk_window_set_events"); -- The event mask for a window determines which events will be reported -- for that window from all master input devices. For example, an event -- mask including GDK_BUTTON_PRESS_MASK means the window should report -- button press events. The event mask is the bitwise OR of values from the -- Gdk.Event.Gdk_Event_Mask enumeration. -- See the [input handling overview][event-masks] for details. -- "event_mask": event mask for Window function Get_Focus_On_Map (Self : Gdk.Gdk_Window) return Boolean; -- Determines whether or not the desktop environment should be hinted that -- the window does not want to receive input focus when it is mapped. -- Since: gtk+ 2.22 procedure Set_Focus_On_Map (Self : Gdk.Gdk_Window; Focus_On_Map : Boolean); -- Setting Focus_On_Map to False hints the desktop environment that the -- window doesn't want to receive input focus when it is mapped. -- focus_on_map should be turned off for windows that aren't triggered -- interactively (such as popups from network activity). -- On X, it is the responsibility of the window manager to interpret this -- hint. Window managers following the freedesktop.org window manager -- extension specification should respect it. -- Since: gtk+ 2.6 -- "focus_on_map": True if the window should receive input focus when -- mapped function Get_Frame_Clock (Self : Gdk.Gdk_Window) return Gdk.Frame_Clock.Gdk_Frame_Clock; -- Gets the frame clock for the window. The frame clock for a window never -- changes unless the window is reparented to a new toplevel window. -- Since: gtk+ 3.8 procedure Get_Frame_Extents (Self : Gdk.Gdk_Window; Rect : out Gdk.Rectangle.Gdk_Rectangle); pragma Import (C, Get_Frame_Extents, "gdk_window_get_frame_extents"); -- Obtains the bounding box of the window, including window manager -- titlebar/borders if any. The frame position is given in root window -- coordinates. To get the position of the window itself (rather than the -- frame) in root window coordinates, use Gdk.Window.Get_Origin. -- "rect": rectangle to fill with bounding box of the window frame function Get_Fullscreen_Mode (Self : Gdk.Gdk_Window) return Gdk_Fullscreen_Mode; pragma Import (C, Get_Fullscreen_Mode, "gdk_window_get_fullscreen_mode"); -- Obtains the Gdk.Window.Gdk_Fullscreen_Mode of the Window. -- Since: gtk+ 3.8 procedure Set_Fullscreen_Mode (Self : Gdk.Gdk_Window; Mode : Gdk_Fullscreen_Mode); pragma Import (C, Set_Fullscreen_Mode, "gdk_window_set_fullscreen_mode"); -- Specifies whether the Window should span over all monitors (in a -- multi-head setup) or only the current monitor when in fullscreen mode. -- The Mode argument is from the Gdk.Window.Gdk_Fullscreen_Mode -- enumeration. If GDK_FULLSCREEN_ON_ALL_MONITORS is specified, the -- fullscreen Window will span over all monitors from the -- Gdk.Screen.Gdk_Screen. -- On X11, searches through the list of monitors from the -- Gdk.Screen.Gdk_Screen the ones which delimit the 4 edges of the entire -- Gdk.Screen.Gdk_Screen and will ask the window manager to span the Window -- over these monitors. -- If the XINERAMA extension is not available or not usable, this function -- has no effect. -- Not all window managers support this, so you can't rely on the -- fullscreen window to span over the multiple monitors when -- GDK_FULLSCREEN_ON_ALL_MONITORS is specified. -- Since: gtk+ 3.8 -- "mode": fullscreen mode procedure Get_Geometry (Self : Gdk.Gdk_Window; X : out Glib.Gint; Y : out Glib.Gint; Width : out Glib.Gint; Height : out Glib.Gint); pragma Import (C, Get_Geometry, "gdk_window_get_geometry"); -- Any of the return location arguments to this function may be null, if -- you aren't interested in getting the value of that field. -- The X and Y coordinates returned are relative to the parent window of -- Window, which for toplevels usually means relative to the window -- decorations (titlebar, etc.) rather than relative to the root window -- (screen-size background window). -- On the X11 platform, the geometry is obtained from the X server, so -- reflects the latest position of Window; this may be out-of-sync with the -- position of Window delivered in the most-recently-processed -- Gdk.Event.Gdk_Event_Configure. Gdk.Window.Get_Position in contrast gets -- the position from the most recent configure event. -- Note: If Window is not a toplevel, it is much better to call -- Gdk.Window.Get_Position, Gdk.Window.Get_Width and Gdk.Window.Get_Height -- instead, because it avoids the roundtrip to the X server and because -- these functions support the full 32-bit coordinate space, whereas -- Gdk.Window.Get_Geometry is restricted to the 16-bit coordinates of X11. -- "x": return location for X coordinate of window (relative to its -- parent) -- "y": return location for Y coordinate of window (relative to its -- parent) -- "width": return location for width of window -- "height": return location for height of window function Get_Group (Self : Gdk.Gdk_Window) return Gdk.Gdk_Window; pragma Import (C, Get_Group, "gdk_window_get_group"); -- Returns the group leader window for Window. See Gdk.Window.Set_Group. -- Since: gtk+ 2.4 procedure Set_Group (Self : Gdk.Gdk_Window; Leader : Gdk.Gdk_Window); pragma Import (C, Set_Group, "gdk_window_set_group"); -- Sets the group leader window for Window. By default, GDK sets the group -- leader for all toplevel windows to a global window implicitly created by -- GDK. With this function you can override this default. -- The group leader window allows the window manager to distinguish all -- windows that belong to a single application. It may for example allow -- users to minimize/unminimize all windows belonging to an application at -- once. You should only set a non-default group window if your application -- pretends to be multiple applications. -- "leader": group leader window, or null to restore the default group -- leader window function Get_Height (Self : Gdk.Gdk_Window) return Glib.Gint; pragma Import (C, Get_Height, "gdk_window_get_height"); -- Returns the height of the given Window. -- On the X11 platform the returned size is the size reported in the -- most-recently-processed configure event, rather than the current size on -- the X server. -- Since: gtk+ 2.24 function Get_Modal_Hint (Self : Gdk.Gdk_Window) return Boolean; -- Determines whether or not the window manager is hinted that Window has -- modal behaviour. -- Since: gtk+ 2.22 procedure Set_Modal_Hint (Self : Gdk.Gdk_Window; Modal : Boolean); -- The application can use this hint to tell the window manager that a -- certain window has modal behaviour. The window manager can use this -- information to handle modal windows in a special way. -- You should only use this on windows for which you have previously -- called Gdk.Window.Set_Transient_For -- "modal": True if the window is modal, False otherwise. procedure Get_Origin (Self : Gdk.Gdk_Window; X : out Glib.Gint; Y : out Glib.Gint); pragma Import (C, Get_Origin, "gdk_window_get_origin"); -- Obtains the position of a window in root window coordinates. (Compare -- with Gdk.Window.Get_Position and Gdk.Window.Get_Geometry which return -- the position of a window relative to its parent window.) -- "x": return location for X coordinate -- "y": return location for Y coordinate function Get_Parent (Self : Gdk.Gdk_Window) return Gdk.Gdk_Window; pragma Import (C, Get_Parent, "gdk_window_get_parent"); -- Obtains the parent of Window, as known to GDK. Does not query the X -- server; thus this returns the parent as passed to gdk_window_new, not -- the actual parent. This should never matter unless you're using Xlib -- calls mixed with GDK calls on the X11 platform. It may also matter for -- toplevel windows, because the window manager may choose to reparent -- them. -- Note that you should use Gdk.Window.Get_Effective_Parent when writing -- generic code that walks up a window hierarchy, because -- Gdk.Window.Get_Parent will most likely not do what you expect if there -- are offscreen windows in the hierarchy. function Get_Pass_Through (Self : Gdk.Gdk_Window) return Boolean; -- Returns whether input to the window is passed through to the window -- below. -- See Gdk.Window.Set_Pass_Through for details -- Since: gtk+ 3.18 procedure Set_Pass_Through (Self : Gdk.Gdk_Window; Pass_Through : Boolean); -- Sets whether input to the window is passed through to the window below. -- The default value of this is False, which means that pointer events -- that happen inside the window are send first to the window, but if the -- event is not selected by the event mask then the event is sent to the -- parent window, and so on up the hierarchy. -- If Pass_Through is True then such pointer events happen as if the -- window wasn't there at all, and thus will be sent first to any windows -- below Window. This is useful if the window is used in a transparent -- fashion. In the terminology of the web this would be called -- "pointer-events: none". -- Note that a window with Pass_Through True can still have a subwindow -- without pass through, so you can get events on a subset of a window. And -- in that cases you would get the in-between related events such as the -- pointer enter/leave events on its way to the destination window. -- Since: gtk+ 3.18 -- "pass_through": a boolean procedure Get_Pointer (Self : Gdk.Gdk_Window; X : out Glib.Gint; Y : out Glib.Gint; Mask : out Gdk.Types.Gdk_Modifier_Type; Window : out Gdk.Gdk_Window); pragma Obsolescent (Get_Pointer); -- Obtains the current pointer position and modifier state. The position -- is given in coordinates relative to the upper left corner of Window. -- Deprecated since 3.0, 1 -- "x": return location for X coordinate of pointer or null to not return -- the X coordinate -- "y": return location for Y coordinate of pointer or null to not return -- the Y coordinate -- "mask": return location for modifier mask or null to not return the -- modifier mask procedure Get_Position (Self : Gdk.Gdk_Window; X : out Glib.Gint; Y : out Glib.Gint); pragma Import (C, Get_Position, "gdk_window_get_position"); -- Obtains the position of the window as reported in the -- most-recently-processed Gdk.Event.Gdk_Event_Configure. Contrast with -- Gdk.Window.Get_Geometry which queries the X server for the current -- window position, regardless of which events have been received or -- processed. -- The position coordinates are relative to the window's parent window. -- "x": X coordinate of window -- "y": Y coordinate of window procedure Get_Root_Coords (Self : Gdk.Gdk_Window; X : Glib.Gint; Y : Glib.Gint; Root_X : out Glib.Gint; Root_Y : out Glib.Gint); pragma Import (C, Get_Root_Coords, "gdk_window_get_root_coords"); -- Obtains the position of a window position in root window coordinates. -- This is similar to Gdk.Window.Get_Origin but allows you to pass in any -- position in the window, not just the origin. -- Since: gtk+ 2.18 -- "x": X coordinate in window -- "y": Y coordinate in window -- "root_x": return location for X coordinate -- "root_y": return location for Y coordinate procedure Get_Root_Origin (Self : Gdk.Gdk_Window; X : out Glib.Gint; Y : out Glib.Gint); pragma Import (C, Get_Root_Origin, "gdk_window_get_root_origin"); -- Obtains the top-left corner of the window manager frame in root window -- coordinates. -- "x": return location for X position of window frame -- "y": return location for Y position of window frame function Get_Scale_Factor (Self : Gdk.Gdk_Window) return Glib.Gint; pragma Import (C, Get_Scale_Factor, "gdk_window_get_scale_factor"); -- Returns the internal scale factor that maps from window coordiantes to -- the actual device pixels. On traditional systems this is 1, but on very -- high density outputs this can be a higher value (often 2). -- A higher value means that drawing is automatically scaled up to a -- higher resolution, so any code doing drawing will automatically look -- nicer. However, if you are supplying pixel-based data the scale value -- can be used to determine whether to use a pixel resource with higher -- resolution data. -- The scale of a window may change during runtime, if this happens a -- configure event will be sent to the toplevel window. -- Since: gtk+ 3.10 function Get_Screen (Self : Gdk.Gdk_Window) return Gdk.Screen.Gdk_Screen; -- Gets the Gdk.Screen.Gdk_Screen associated with a Gdk.Gdk_Window. -- Since: gtk+ 2.24 function Get_Source_Events (Self : Gdk.Gdk_Window; Source : Gdk_Input_Source) return Gdk.Event.Gdk_Event_Mask; pragma Import (C, Get_Source_Events, "gdk_window_get_source_events"); -- Returns the event mask for Window corresponding to the device class -- specified by Source. -- "source": a Gdk_Input_Source to define the source class. procedure Set_Source_Events (Self : Gdk.Gdk_Window; Source : Gdk_Input_Source; Event_Mask : Gdk.Event.Gdk_Event_Mask); pragma Import (C, Set_Source_Events, "gdk_window_set_source_events"); -- Sets the event mask for any floating device (i.e. not attached to any -- visible pointer) that has the source defined as Source. This event mask -- will be applied both to currently existing, newly added devices after -- this call, and devices being attached/detached. -- Since: gtk+ 3.0 -- "source": a Gdk_Input_Source to define the source class. -- "event_mask": event mask for Window function Get_State (Self : Gdk.Gdk_Window) return Gdk.Event.Gdk_Window_State; pragma Import (C, Get_State, "gdk_window_get_state"); -- Gets the bitwise OR of the currently active window state flags, from -- the Gdk.Event.Gdk_Window_State enumeration. function Get_Support_Multidevice (Self : Gdk.Gdk_Window) return Boolean; -- Returns True if the window is aware of the existence of multiple -- devices. -- Since: gtk+ 3.0 procedure Set_Support_Multidevice (Self : Gdk.Gdk_Window; Support_Multidevice : Boolean); -- This function will enable multidevice features in Window. -- Multidevice aware windows will need to handle properly multiple, per -- device enter/leave events, device grabs and grab ownerships. -- Since: gtk+ 3.0 -- "support_multidevice": True to enable multidevice support in Window. function Get_Toplevel (Self : Gdk.Gdk_Window) return Gdk.Gdk_Window; pragma Import (C, Get_Toplevel, "gdk_window_get_toplevel"); -- Gets the toplevel window that's an ancestor of Window. -- Any window type but Gdk.Window_Child is considered a toplevel window, -- as is a Gdk.Window_Child window that has a root window as parent. -- Note that you should use Gdk.Window.Get_Effective_Toplevel when you -- want to get to a window's toplevel as seen on screen, because -- Gdk.Window.Get_Toplevel will most likely not do what you expect if there -- are offscreen windows in the hierarchy. function Get_Type_Hint (Self : Gdk.Gdk_Window) return Gdk_Window_Type_Hint; pragma Import (C, Get_Type_Hint, "gdk_window_get_type_hint"); -- This function returns the type hint set for a window. -- Since: gtk+ 2.10 procedure Set_Type_Hint (Self : Gdk.Gdk_Window; Hint : Gdk_Window_Type_Hint); pragma Import (C, Set_Type_Hint, "gdk_window_set_type_hint"); -- The application can use this call to provide a hint to the window -- manager about the functionality of a window. The window manager can use -- this information when determining the decoration and behaviour of the -- window. -- The hint must be set before the window is mapped. -- "hint": A hint of the function this window will have function Get_Update_Area (Self : Gdk.Gdk_Window) return Cairo.Region.Cairo_Region; pragma Import (C, Get_Update_Area, "gdk_window_get_update_area"); -- Transfers ownership of the update area from Window to the caller of the -- function. That is, after calling this function, Window will no longer -- have an invalid/dirty region; the update area is removed from Window and -- handed to you. If a window has no update area, -- Gdk.Window.Get_Update_Area returns null. You are responsible for calling -- cairo_region_destroy on the returned region if it's non-null. function Get_Visible_Region (Self : Gdk.Gdk_Window) return Cairo.Region.Cairo_Region; pragma Import (C, Get_Visible_Region, "gdk_window_get_visible_region"); -- Computes the region of the Window that is potentially visible. This -- does not necessarily take into account if the window is obscured by -- other windows, but no area outside of this region is visible. function Get_Visual (Self : Gdk.Gdk_Window) return Gdk.Visual.Gdk_Visual; pragma Import (C, Get_Visual, "gdk_window_get_visual"); -- Gets the Gdk.Visual.Gdk_Visual describing the pixel format of Window. -- Since: gtk+ 2.24 function Get_Width (Self : Gdk.Gdk_Window) return Glib.Gint; pragma Import (C, Get_Width, "gdk_window_get_width"); -- Returns the width of the given Window. -- On the X11 platform the returned size is the size reported in the -- most-recently-processed configure event, rather than the current size on -- the X server. -- Since: gtk+ 2.24 function Get_Window_Type (Self : Gdk.Gdk_Window) return Gdk_Window_Type; pragma Import (C, Get_Window_Type, "gdk_window_get_window_type"); -- Gets the type of the window. See Gdk.Window.Gdk_Window_Type. function Has_Native (Self : Gdk.Gdk_Window) return Boolean; -- Checks whether the window has a native window or not. Note that you can -- use Gdk.Window.Ensure_Native if a native window is needed. -- Since: gtk+ 2.22 procedure Hide (Self : Gdk.Gdk_Window); pragma Import (C, Hide, "gdk_window_hide"); -- For toplevel windows, withdraws them, so they will no longer be known -- to the window manager; for all windows, unmaps them, so they won't be -- displayed. Normally done automatically as part of Gtk.Widget.Hide. procedure Iconify (Self : Gdk.Gdk_Window); pragma Import (C, Iconify, "gdk_window_iconify"); -- Asks to iconify (minimize) Window. The window manager may choose to -- ignore the request, but normally will honor it. Using Gtk.Window.Iconify -- is preferred, if you have a Gtk.Window.Gtk_Window widget. -- This function only makes sense when Window is a toplevel window. procedure Input_Shape_Combine_Region (Self : Gdk.Gdk_Window; Shape_Region : Cairo.Region.Cairo_Region; Offset_X : Glib.Gint; Offset_Y : Glib.Gint); pragma Import (C, Input_Shape_Combine_Region, "gdk_window_input_shape_combine_region"); -- Like Gdk.Window.Shape_Combine_Region, but the shape applies only to -- event handling. Mouse events which happen while the pointer position -- corresponds to an unset bit in the mask will be passed on the window -- below Window. -- An input shape is typically used with RGBA windows. The alpha channel -- of the window defines which pixels are invisible and allows for nicely -- antialiased borders, and the input shape controls where the window is -- "clickable". -- On the X11 platform, this requires version 1.1 of the shape extension. -- On the Win32 platform, this functionality is not present and the -- function does nothing. -- Since: gtk+ 2.10 -- "shape_region": region of window to be non-transparent -- "offset_x": X position of Shape_Region in Window coordinates -- "offset_y": Y position of Shape_Region in Window coordinates procedure Invalidate_Maybe_Recurse (Self : Gdk.Gdk_Window; Region : Cairo.Region.Cairo_Region; Child_Func : Gdk_Window_Child_Func); -- Adds Region to the update area for Window. The update area is the -- region that needs to be redrawn, or "dirty region." The call -- Gdk.Window.Process_Updates sends one or more expose events to the -- window, which together cover the entire update area. An application -- would normally redraw the contents of Window in response to those expose -- events. -- GDK will call Gdk.Window.Process_All_Updates on your behalf whenever -- your program returns to the main loop and becomes idle, so normally -- there's no need to do that manually, you just need to invalidate regions -- that you know should be redrawn. -- The Child_Func parameter controls whether the region of each child -- window that intersects Region will also be invalidated. Only children -- for which Child_Func returns TRUE will have the area invalidated. -- "region": a cairo_region_t -- "child_func": function to use to decide if to recurse to a child, null -- means never recurse. generic type User_Data_Type (<>) is private; with procedure Destroy (Data : in out User_Data_Type) is null; package Invalidate_Maybe_Recurse_User_Data is type Gdk_Window_Child_Func is access function (Window : Gdk.Gdk_Window; User_Data : User_Data_Type) return Boolean; -- A function of this type is passed to -- Gdk.Window.Invalidate_Maybe_Recurse. It gets called for each child of -- the window to determine whether to recursively invalidate it or now. -- "window": a Gdk.Gdk_Window -- "user_data": user data procedure Invalidate_Maybe_Recurse (Self : Gdk.Gdk_Window; Region : Cairo.Region.Cairo_Region; Child_Func : Gdk_Window_Child_Func; User_Data : User_Data_Type); -- Adds Region to the update area for Window. The update area is the -- region that needs to be redrawn, or "dirty region." The call -- Gdk.Window.Process_Updates sends one or more expose events to the -- window, which together cover the entire update area. An application -- would normally redraw the contents of Window in response to those -- expose events. -- GDK will call Gdk.Window.Process_All_Updates on your behalf whenever -- your program returns to the main loop and becomes idle, so normally -- there's no need to do that manually, you just need to invalidate -- regions that you know should be redrawn. -- The Child_Func parameter controls whether the region of each child -- window that intersects Region will also be invalidated. Only children -- for which Child_Func returns TRUE will have the area invalidated. -- "region": a cairo_region_t -- "child_func": function to use to decide if to recurse to a child, -- null means never recurse. -- "user_data": data passed to Child_Func end Invalidate_Maybe_Recurse_User_Data; procedure Invalidate_Rect (Self : Gdk.Gdk_Window; Rect : Gdk.Rectangle.Gdk_Rectangle; Invalidate_Children : Boolean); -- A convenience wrapper around Gdk.Window.Invalidate_Region which -- invalidates a rectangular region. See Gdk.Window.Invalidate_Region for -- details. -- "rect": rectangle to invalidate or null to invalidate the whole window -- "invalidate_children": whether to also invalidate child windows procedure Invalidate_Region (Self : Gdk.Gdk_Window; Region : Cairo.Region.Cairo_Region; Invalidate_Children : Boolean); -- Adds Region to the update area for Window. The update area is the -- region that needs to be redrawn, or "dirty region." The call -- Gdk.Window.Process_Updates sends one or more expose events to the -- window, which together cover the entire update area. An application -- would normally redraw the contents of Window in response to those expose -- events. -- GDK will call Gdk.Window.Process_All_Updates on your behalf whenever -- your program returns to the main loop and becomes idle, so normally -- there's no need to do that manually, you just need to invalidate regions -- that you know should be redrawn. -- The Invalidate_Children parameter controls whether the region of each -- child window that intersects Region will also be invalidated. If False, -- then the update area for child windows will remain unaffected. See -- gdk_window_invalidate_maybe_recurse if you need fine grained control -- over which children are invalidated. -- "region": a cairo_region_t -- "invalidate_children": True to also invalidate child windows function Is_Destroyed (Self : Gdk.Gdk_Window) return Boolean; -- Check to see if a window is destroyed.. -- Since: gtk+ 2.18 function Is_Input_Only (Self : Gdk.Gdk_Window) return Boolean; -- Determines whether or not the window is an input only window. -- Since: gtk+ 2.22 function Is_Shaped (Self : Gdk.Gdk_Window) return Boolean; -- Determines whether or not the window is shaped. -- Since: gtk+ 2.22 function Is_Viewable (Self : Gdk.Gdk_Window) return Boolean; -- Check if the window and all ancestors of the window are mapped. (This -- is not necessarily "viewable" in the X sense, since we only check as far -- as we have GDK window parents, not to the root window.) function Is_Visible (Self : Gdk.Gdk_Window) return Boolean; -- Checks whether the window has been mapped (with Gdk.Window.Show or -- Gdk.Window.Show_Unraised). procedure Lower (Self : Gdk.Gdk_Window); pragma Import (C, Lower, "gdk_window_lower"); -- Lowers Window to the bottom of the Z-order (stacking order), so that -- other windows with the same parent window appear above Window. This is -- true whether or not the other windows are visible. -- If Window is a toplevel, the window manager may choose to deny the -- request to move the window in the Z-order, Gdk.Window.Lower only -- requests the restack, does not guarantee it. -- Note that Gdk.Window.Show raises the window again, so don't call this -- function before Gdk.Window.Show. (Try Gdk.Window.Show_Unraised.) procedure Mark_Paint_From_Clip (Self : Gdk.Gdk_Window; Cr : Cairo.Cairo_Context); pragma Import (C, Mark_Paint_From_Clip, "gdk_window_mark_paint_from_clip"); -- If you call this during a paint (e.g. between -- Gdk.Window.Begin_Paint_Region and Gdk.Window.End_Paint then GDK will -- mark the current clip region of the window as being drawn. This is -- required when mixing GL rendering via gdk_cairo_draw_from_gl and cairo -- rendering, as otherwise GDK has no way of knowing when something paints -- over the GL-drawn regions. -- This is typically called automatically by GTK+ and you don't need to -- care about this. -- Since: gtk+ 3.16 -- "cr": a cairo_t procedure Maximize (Self : Gdk.Gdk_Window); pragma Import (C, Maximize, "gdk_window_maximize"); -- Maximizes the window. If the window was already maximized, then this -- function does nothing. -- On X11, asks the window manager to maximize Window, if the window -- manager supports this operation. Not all window managers support this, -- and some deliberately ignore it or don't have a concept of "maximized"; -- so you can't rely on the maximization actually happening. But it will -- happen with most standard window managers, and GDK makes a best effort -- to get it to happen. -- On Windows, reliably maximizes the window. procedure Merge_Child_Input_Shapes (Self : Gdk.Gdk_Window); pragma Import (C, Merge_Child_Input_Shapes, "gdk_window_merge_child_input_shapes"); -- Merges the input shape masks for any child windows into the input shape -- mask for Window. i.e. the union of all input masks for Window and its -- children will become the new input mask for Window. See -- Gdk.Window.Input_Shape_Combine_Region. -- This function is distinct from Gdk.Window.Set_Child_Input_Shapes -- because it includes Window's input shape mask in the set of shapes to be -- merged. -- Since: gtk+ 2.10 procedure Merge_Child_Shapes (Self : Gdk.Gdk_Window); pragma Import (C, Merge_Child_Shapes, "gdk_window_merge_child_shapes"); -- Merges the shape masks for any child windows into the shape mask for -- Window. i.e. the union of all masks for Window and its children will -- become the new mask for Window. See Gdk.Window.Shape_Combine_Region. -- This function is distinct from Gdk.Window.Set_Child_Shapes because it -- includes Window's shape mask in the set of shapes to be merged. procedure Move (Self : Gdk.Gdk_Window; X : Glib.Gint; Y : Glib.Gint); pragma Import (C, Move, "gdk_window_move"); -- Repositions a window relative to its parent window. For toplevel -- windows, window managers may ignore or modify the move; you should -- probably use Gtk.Window.Move on a Gtk.Window.Gtk_Window widget anyway, -- instead of using GDK functions. For child windows, the move will -- reliably succeed. -- If you're also planning to resize the window, use -- Gdk.Window.Move_Resize to both move and resize simultaneously, for a -- nicer visual effect. -- "x": X coordinate relative to window's parent -- "y": Y coordinate relative to window's parent procedure Move_Region (Self : Gdk.Gdk_Window; Region : Cairo.Region.Cairo_Region; Dx : Glib.Gint; Dy : Glib.Gint); pragma Import (C, Move_Region, "gdk_window_move_region"); -- Move the part of Window indicated by Region by Dy pixels in the Y -- direction and Dx pixels in the X direction. The portions of Region that -- not covered by the new position of Region are invalidated. -- Child windows are not moved. -- Since: gtk+ 2.8 -- "region": The cairo_region_t to move -- "dx": Amount to move in the X direction -- "dy": Amount to move in the Y direction procedure Move_Resize (Self : Gdk.Gdk_Window; X : Glib.Gint; Y : Glib.Gint; Width : Glib.Gint; Height : Glib.Gint); pragma Import (C, Move_Resize, "gdk_window_move_resize"); -- Equivalent to calling Gdk.Window.Move and Gdk.Window.Resize, except -- that both operations are performed at once, avoiding strange visual -- effects. (i.e. the user may be able to see the window first move, then -- resize, if you don't use Gdk.Window.Move_Resize.) -- "x": new X position relative to window's parent -- "y": new Y position relative to window's parent -- "width": new width -- "height": new height procedure Move_To_Rect (Self : Gdk.Gdk_Window; Rect : Gdk.Rectangle.Gdk_Rectangle; Rect_Anchor : Gdk_Gravity; Window_Anchor : Gdk_Gravity; Anchor_Hints : Gdk_Anchor_Hints; Rect_Anchor_Dx : Glib.Gint; Rect_Anchor_Dy : Glib.Gint); pragma Import (C, Move_To_Rect, "gdk_window_move_to_rect"); -- Moves Window to Rect, aligning their anchor points. -- Rect is relative to the top-left corner of the window that Window is -- transient for. Rect_Anchor and Window_Anchor determine anchor points on -- Rect and Window to pin together. Rect's anchor point can optionally be -- offset by Rect_Anchor_Dx and Rect_Anchor_Dy, which is equivalent to -- offsetting the position of Window. -- Anchor_Hints determines how Window will be moved if the anchor points -- cause it to move off-screen. For example, Gdk.Anchor_Flip_X will replace -- Gdk.Gravity_North_West with Gdk.Gravity_North_East and vice versa if -- Window extends beyond the left or right edges of the monitor. -- Connect to the Gdk.Gdk_Window::moved-to-rect signal to find out how it -- was actually positioned. -- Since: gtk+ 3.24 -- "rect": the destination Gdk.Rectangle.Gdk_Rectangle to align Window -- with -- "rect_anchor": the point on Rect to align with Window's anchor point -- "window_anchor": the point on Window to align with Rect's anchor point -- "anchor_hints": positioning hints to use when limited on space -- "rect_anchor_dx": horizontal offset to shift Window, i.e. Rect's anchor -- point -- "rect_anchor_dy": vertical offset to shift Window, i.e. Rect's anchor -- point function Peek_Children (Self : Gdk.Gdk_Window) return Gdk_Window_List.Glist; -- Like Gdk.Window.Get_Children, but does not copy the list of children, -- so the list does not need to be freed. procedure Process_Updates (Self : Gdk.Gdk_Window; Update_Children : Boolean); pragma Obsolescent (Process_Updates); -- Sends one or more expose events to Window. The areas in each expose -- event will cover the entire update area for the window (see -- Gdk.Window.Invalidate_Region for details). Normally GDK calls -- Gdk.Window.Process_All_Updates on your behalf, so there's no need to -- call this function unless you want to force expose events to be -- delivered immediately and synchronously (vs. the usual case, where GDK -- delivers them in an idle handler). Occasionally this is useful to -- produce nicer scrolling behavior, for example. -- Deprecated since 3.22, 1 -- "update_children": whether to also process updates for child windows procedure Gdk_Raise (Self : Gdk.Gdk_Window); pragma Import (C, Gdk_Raise, "gdk_window_raise"); -- Raises Window to the top of the Z-order (stacking order), so that other -- windows with the same parent window appear below Window. This is true -- whether or not the windows are visible. -- If Window is a toplevel, the window manager may choose to deny the -- request to move the window in the Z-order, Gdk.Window.Gdk_Raise only -- requests the restack, does not guarantee it. procedure Register_Dnd (Self : Gdk.Gdk_Window); pragma Import (C, Register_Dnd, "gdk_window_register_dnd"); -- Registers a window as a potential drop destination. procedure Reparent (Self : Gdk.Gdk_Window; New_Parent : Gdk.Gdk_Window; X : Glib.Gint; Y : Glib.Gint); pragma Import (C, Reparent, "gdk_window_reparent"); -- Reparents Window into the given New_Parent. The window being reparented -- will be unmapped as a side effect. -- "new_parent": new parent to move Window into -- "x": X location inside the new parent -- "y": Y location inside the new parent procedure Resize (Self : Gdk.Gdk_Window; Width : Glib.Gint; Height : Glib.Gint); pragma Import (C, Resize, "gdk_window_resize"); -- Resizes Window; for toplevel windows, asks the window manager to resize -- the window. The window manager may not allow the resize. When using -- GTK+, use Gtk.Window.Resize instead of this low-level GDK function. -- Windows may not be resized below 1x1. -- If you're also planning to move the window, use Gdk.Window.Move_Resize -- to both move and resize simultaneously, for a nicer visual effect. -- "width": new width of the window -- "height": new height of the window procedure Restack (Self : Gdk.Gdk_Window; Sibling : Gdk.Gdk_Window; Above : Boolean); -- Changes the position of Window in the Z-order (stacking order), so that -- it is above Sibling (if Above is True) or below Sibling (if Above is -- False). -- If Sibling is null, then this either raises (if Above is True) or -- lowers the window. -- If Window is a toplevel, the window manager may choose to deny the -- request to move the window in the Z-order, Gdk.Window.Restack only -- requests the restack, does not guarantee it. -- Since: gtk+ 2.18 -- "sibling": a Gdk.Gdk_Window that is a sibling of Window, or null -- "above": a boolean procedure Scroll (Self : Gdk.Gdk_Window; Dx : Glib.Gint; Dy : Glib.Gint); pragma Import (C, Scroll, "gdk_window_scroll"); -- Scroll the contents of Window, both pixels and children, by the given -- amount. Window itself does not move. Portions of the window that the -- scroll operation brings in from offscreen areas are invalidated. The -- invalidated region may be bigger than what would strictly be necessary. -- For X11, a minimum area will be invalidated if the window has no -- subwindows, or if the edges of the window's parent do not extend beyond -- the edges of the window. In other cases, a multi-step process is used to -- scroll the window which may produce temporary visual artifacts and -- unnecessary invalidations. -- "dx": Amount to scroll in the X direction -- "dy": Amount to scroll in the Y direction procedure Set_Background (Self : Gdk.Gdk_Window; Color : Gdk.Color.Gdk_Color); pragma Import (C, Set_Background, "gdk_window_set_background"); pragma Obsolescent (Set_Background); -- Sets the background color of Window. -- However, when using GTK+, influence the background of a widget using a -- style class or CSS — if you're an application — or with -- Gtk.Style_Context.Set_Background — if you're implementing a custom -- widget. -- Deprecated since 3.4, 1 -- "color": a Gdk.Color.Gdk_Color procedure Set_Background_Rgba (Self : Gdk.Gdk_Window; Rgba : Gdk.RGBA.Gdk_RGBA); pragma Import (C, Set_Background_Rgba, "gdk_window_set_background_rgba"); pragma Obsolescent (Set_Background_Rgba); -- Sets the background color of Window. -- See also Gdk.Window.Set_Background_Pattern. -- Deprecated since 3.22, 1 -- "rgba": a Gdk.RGBA.Gdk_RGBA color procedure Set_Child_Input_Shapes (Self : Gdk.Gdk_Window); pragma Import (C, Set_Child_Input_Shapes, "gdk_window_set_child_input_shapes"); -- Sets the input shape mask of Window to the union of input shape masks -- for all children of Window, ignoring the input shape mask of Window -- itself. Contrast with Gdk.Window.Merge_Child_Input_Shapes which includes -- the input shape mask of Window in the masks to be merged. -- Since: gtk+ 2.10 procedure Set_Child_Shapes (Self : Gdk.Gdk_Window); pragma Import (C, Set_Child_Shapes, "gdk_window_set_child_shapes"); -- Sets the shape mask of Window to the union of shape masks for all -- children of Window, ignoring the shape mask of Window itself. Contrast -- with Gdk.Window.Merge_Child_Shapes which includes the shape mask of -- Window in the masks to be merged. procedure Set_Functions (Self : Gdk.Gdk_Window; Functions : Gdk_WMFunction); pragma Import (C, Set_Functions, "gdk_window_set_functions"); -- Sets hints about the window management functions to make available via -- buttons on the window frame. -- On the X backend, this function sets the traditional Motif window -- manager hint for this purpose. However, few window managers do anything -- reliable or interesting with this hint. Many ignore it entirely. -- The Functions argument is the logical OR of values from the -- Gdk.Window.Gdk_WMFunction enumeration. If the bitmask includes -- GDK_FUNC_ALL, then the other bits indicate which functions to disable; -- if it doesn't include GDK_FUNC_ALL, it indicates which functions to -- enable. -- "functions": bitmask of operations to allow on Window procedure Set_Geometry_Hints (Self : Gdk.Gdk_Window; Geometry : Gdk_Geometry; Geom_Mask : Gdk_Window_Hints); pragma Import (C, Set_Geometry_Hints, "gdk_window_set_geometry_hints"); -- Sets the geometry hints for Window. Hints flagged in Geom_Mask are set, -- hints not flagged in Geom_Mask are unset. To unset all hints, use a -- Geom_Mask of 0 and a Geometry of null. -- This function provides hints to the windowing system about acceptable -- sizes for a toplevel window. The purpose of this is to constrain user -- resizing, but the windowing system will typically (but is not required -- to) also constrain the current size of the window to the provided values -- and constrain programatic resizing via Gdk.Window.Resize or -- Gdk.Window.Move_Resize. -- Note that on X11, this effect has no effect on windows of type -- Gdk.Window_Temp or windows where override redirect has been turned on -- via Gdk.Window.Set_Override_Redirect since these windows are not -- resizable by the user. -- Since you can't count on the windowing system doing the constraints for -- programmatic resizes, you should generally call -- Gdk.Window.Constrain_Size yourself to determine appropriate sizes. -- "geometry": geometry hints -- "geom_mask": bitmask indicating fields of Geometry to pay attention to procedure Set_Icon_Name (Self : Gdk.Gdk_Window; Name : UTF8_String := ""); -- Windows may have a name used while minimized, distinct from the name -- they display in their titlebar. Most of the time this is a bad idea from -- a user interface standpoint. But you can set such a name with this -- function, if you like. -- After calling this with a non-null Name, calls to Gdk.Window.Set_Title -- will not update the icon title. -- Using null for Name unsets the icon title; further calls to -- Gdk.Window.Set_Title will again update the icon title as well. -- Note that some platforms don't support window icons. -- "name": name of window while iconified (minimized) procedure Set_Invalidate_Handler (Self : Gdk.Gdk_Window; Handler : Gdk_Window_Invalidate_Handler_Func); -- Registers an invalidate handler for a specific window. This will get -- called whenever a region in the window or its children is invalidated. -- This can be used to record the invalidated region, which is useful if -- you are keeping an offscreen copy of some region and want to keep it up -- to date. You can also modify the invalidated region in case you're doing -- some effect where e.g. a child widget appears in multiple places. -- Since: gtk+ 3.10 -- "handler": a Gdk_Window_Invalidate_Handler_Func callback function procedure Set_Keep_Above (Self : Gdk.Gdk_Window; Setting : Boolean); -- Set if Window must be kept above other windows. If the window was -- already above, then this function does nothing. -- On X11, asks the window manager to keep Window above, if the window -- manager supports this operation. Not all window managers support this, -- and some deliberately ignore it or don't have a concept of "keep above"; -- so you can't rely on the window being kept above. But it will happen -- with most standard window managers, and GDK makes a best effort to get -- it to happen. -- Since: gtk+ 2.4 -- "setting": whether to keep Window above other windows procedure Set_Keep_Below (Self : Gdk.Gdk_Window; Setting : Boolean); -- Set if Window must be kept below other windows. If the window was -- already below, then this function does nothing. -- On X11, asks the window manager to keep Window below, if the window -- manager supports this operation. Not all window managers support this, -- and some deliberately ignore it or don't have a concept of "keep below"; -- so you can't rely on the window being kept below. But it will happen -- with most standard window managers, and GDK makes a best effort to get -- it to happen. -- Since: gtk+ 2.4 -- "setting": whether to keep Window below other windows procedure Set_Opacity (Self : Gdk.Gdk_Window; Opacity : Gdouble); pragma Import (C, Set_Opacity, "gdk_window_set_opacity"); -- Set Window to render as partially transparent, with opacity 0 being -- fully transparent and 1 fully opaque. (Values of the opacity parameter -- are clamped to the [0,1] range.) -- For toplevel windows this depends on support from the windowing system -- that may not always be there. For instance, On X11, this works only on X -- screens with a compositing manager running. On Wayland, there is no -- per-window opacity value that the compositor would apply. Instead, use -- `gdk_window_set_opaque_region (window, NULL)` to tell the compositor -- that the entire window is (potentially) non-opaque, and draw your -- content with alpha, or use Gtk.Widget.Set_Opacity to set an overall -- opacity for your widgets. -- For child windows this function only works for non-native windows. -- For setting up per-pixel alpha topelevels, see -- Gdk.Screen.Get_Rgba_Visual, and for non-toplevels, see -- Gdk.Window.Set_Composited. -- Support for non-toplevel windows was added in 3.8. -- Since: gtk+ 2.12 -- "opacity": opacity procedure Set_Opaque_Region (Self : Gdk.Gdk_Window; Region : Cairo.Region.Cairo_Region); pragma Import (C, Set_Opaque_Region, "gdk_window_set_opaque_region"); -- For optimisation purposes, compositing window managers may like to not -- draw obscured regions of windows, or turn off blending during for these -- regions. With RGB windows with no transparency, this is just the shape -- of the window, but with ARGB32 windows, the compositor does not know -- what regions of the window are transparent or not. -- This function only works for toplevel windows. -- GTK+ will update this property automatically if the Window background -- is opaque, as we know where the opaque regions are. If your window -- background is not opaque, please update this property in your -- Gtk.Widget.Gtk_Widget::style-updated handler. -- Since: gtk+ 3.10 -- "region": a region, or null procedure Set_Override_Redirect (Self : Gdk.Gdk_Window; Override_Redirect : Boolean); -- An override redirect window is not under the control of the window -- manager. This means it won't have a titlebar, won't be minimizable, etc. -- - it will be entirely under the control of the application. The window -- manager can't see the override redirect window at all. -- Override redirect should only be used for short-lived temporary -- windows, such as popup menus. Gtk.Menu.Gtk_Menu uses an override -- redirect window in its implementation, for example. -- "override_redirect": True if window should be override redirect procedure Set_Role (Self : Gdk.Gdk_Window; Role : UTF8_String); -- When using GTK+, typically you should use Gtk.Window.Set_Role instead -- of this low-level function. -- The window manager and session manager use a window's role to -- distinguish it from other kinds of window in the same application. When -- an application is restarted after being saved in a previous session, all -- windows with the same title and role are treated as interchangeable. So -- if you have two windows with the same title that should be distinguished -- for session management purposes, you should set the role on those -- windows. It doesn't matter what string you use for the role, as long as -- you have a different role for each non-interchangeable kind of window. -- "role": a string indicating its role procedure Set_Shadow_Width (Self : Gdk.Gdk_Window; Left : Glib.Gint; Right : Glib.Gint; Top : Glib.Gint; Bottom : Glib.Gint); pragma Import (C, Set_Shadow_Width, "gdk_window_set_shadow_width"); -- Newer GTK+ windows using client-side decorations use extra geometry -- around their frames for effects like shadows and invisible borders. -- Window managers that want to maximize windows or snap to edges need to -- know where the extents of the actual frame lie, so that users don't feel -- like windows are snapping against random invisible edges. -- Note that this property is automatically updated by GTK+, so this -- function should only be used by applications which do not use GTK+ to -- create toplevel windows. -- Since: gtk+ 3.12 -- "left": The left extent -- "right": The right extent -- "top": The top extent -- "bottom": The bottom extent procedure Set_Skip_Pager_Hint (Self : Gdk.Gdk_Window; Skips_Pager : Boolean); -- Toggles whether a window should appear in a pager (workspace switcher, -- or other desktop utility program that displays a small thumbnail -- representation of the windows on the desktop). If a window's semantic -- type as specified with Gdk.Window.Set_Type_Hint already fully describes -- the window, this function should not be called in addition, instead you -- should allow the window to be treated according to standard policy for -- its semantic type. -- Since: gtk+ 2.2 -- "skips_pager": True to skip the pager procedure Set_Skip_Taskbar_Hint (Self : Gdk.Gdk_Window; Skips_Taskbar : Boolean); -- Toggles whether a window should appear in a task list or window list. -- If a window's semantic type as specified with Gdk.Window.Set_Type_Hint -- already fully describes the window, this function should not be called -- in addition, instead you should allow the window to be treated according -- to standard policy for its semantic type. -- Since: gtk+ 2.2 -- "skips_taskbar": True to skip the taskbar procedure Set_Startup_Id (Self : Gdk.Gdk_Window; Startup_Id : UTF8_String); -- When using GTK+, typically you should use Gtk.Window.Set_Startup_Id -- instead of this low-level function. -- Since: gtk+ 2.12 -- "startup_id": a string with startup-notification identifier function Set_Static_Gravities (Self : Gdk.Gdk_Window; Use_Static : Boolean) return Boolean; pragma Obsolescent (Set_Static_Gravities); -- Used to set the bit gravity of the given window to static, and flag it -- so all children get static subwindow gravity. This is used if you are -- implementing scary features that involve deep knowledge of the windowing -- system. Don't worry about it. -- Deprecated since 3.16, 1 -- "use_static": True to turn on static gravity procedure Set_Title (Self : Gdk.Gdk_Window; Title : UTF8_String); -- Sets the title of a toplevel window, to be displayed in the titlebar. -- If you haven't explicitly set the icon name for the window (using -- Gdk.Window.Set_Icon_Name), the icon name will be set to Title as well. -- Title must be in UTF-8 encoding (as with all user-readable strings in -- GDK/GTK+). Title may not be null. -- "title": title of Window procedure Set_Transient_For (Self : Gdk.Gdk_Window; Parent : Gdk.Gdk_Window); pragma Import (C, Set_Transient_For, "gdk_window_set_transient_for"); -- Indicates to the window manager that Window is a transient dialog -- associated with the application window Parent. This allows the window -- manager to do things like center Window on Parent and keep Window above -- Parent. -- See Gtk.Window.Set_Transient_For if you're using Gtk.Window.Gtk_Window -- or Gtk.Dialog.Gtk_Dialog. -- "parent": another toplevel Gdk.Gdk_Window procedure Set_Urgency_Hint (Self : Gdk.Gdk_Window; Urgent : Boolean); -- Toggles whether a window needs the user's urgent attention. -- Since: gtk+ 2.8 -- "urgent": True if the window is urgent procedure Set_User_Data (Self : Gdk.Gdk_Window; User_Data : System.Address); pragma Import (C, Set_User_Data, "gdk_window_set_user_data"); -- For most purposes this function is deprecated in favor of -- g_object_set_data. However, for historical reasons GTK+ stores the -- Gtk.Widget.Gtk_Widget that owns a Gdk.Gdk_Window as user data on the -- Gdk.Gdk_Window. So, custom widget implementations should use this -- function for that. If GTK+ receives an event for a Gdk.Gdk_Window, and -- the user data for the window is non-null, GTK+ will assume the user data -- is a Gtk.Widget.Gtk_Widget, and forward the event to that widget. -- "user_data": user data procedure Shape_Combine_Region (Self : Gdk.Gdk_Window; Shape_Region : Cairo.Region.Cairo_Region; Offset_X : Glib.Gint; Offset_Y : Glib.Gint); pragma Import (C, Shape_Combine_Region, "gdk_window_shape_combine_region"); -- Makes pixels in Window outside Shape_Region be transparent, so that the -- window may be nonrectangular. -- If Shape_Region is null, the shape will be unset, so the whole window -- will be opaque again. Offset_X and Offset_Y are ignored if Shape_Region -- is null. -- On the X11 platform, this uses an X server extension which is widely -- available on most common platforms, but not available on very old X -- servers, and occasionally the implementation will be buggy. On servers -- without the shape extension, this function will do nothing. -- This function works on both toplevel and child windows. -- "shape_region": region of window to be non-transparent -- "offset_x": X position of Shape_Region in Window coordinates -- "offset_y": Y position of Shape_Region in Window coordinates procedure Show (Self : Gdk.Gdk_Window); pragma Import (C, Show, "gdk_window_show"); -- Like Gdk.Window.Show_Unraised, but also raises the window to the top of -- the window stack (moves the window to the front of the Z-order). -- This function maps a window so it's visible onscreen. Its opposite is -- Gdk.Window.Hide. -- When implementing a Gtk.Widget.Gtk_Widget, you should call this -- function on the widget's Gdk.Gdk_Window as part of the "map" method. procedure Show_Unraised (Self : Gdk.Gdk_Window); pragma Import (C, Show_Unraised, "gdk_window_show_unraised"); -- Shows a Gdk.Gdk_Window onscreen, but does not modify its stacking -- order. In contrast, Gdk.Window.Show will raise the window to the top of -- the window stack. -- On the X11 platform, in Xlib terms, this function calls XMapWindow (it -- also updates some internal GDK state, which means that you can't really -- use XMapWindow directly on a GDK window). function Show_Window_Menu (Self : Gdk.Gdk_Window; Event : Gdk.Event.Gdk_Event) return Boolean; -- Asks the windowing system to show the window menu. The window menu is -- the menu shown when right-clicking the titlebar on traditional windows -- managed by the window manager. This is useful for windows using -- client-side decorations, activating it with a right-click on the window -- decorations. -- Since: gtk+ 3.14 -- "event": a Gdk.Event.Gdk_Event to show the menu for procedure Stick (Self : Gdk.Gdk_Window); pragma Import (C, Stick, "gdk_window_stick"); -- "Pins" a window such that it's on all workspaces and does not scroll -- with viewports, for window managers that have scrollable viewports. -- (When using Gtk.Window.Gtk_Window, Gtk.Window.Stick may be more useful.) -- On the X11 platform, this function depends on window manager support, -- so may have no effect with many window managers. However, GDK will do -- the best it can to convince the window manager to stick the window. For -- window managers that don't support this operation, there's nothing you -- can do to force it to happen. procedure Thaw_Toplevel_Updates_Libgtk_Only (Self : Gdk.Gdk_Window); pragma Import (C, Thaw_Toplevel_Updates_Libgtk_Only, "gdk_window_thaw_toplevel_updates_libgtk_only"); pragma Obsolescent (Thaw_Toplevel_Updates_Libgtk_Only); -- Thaws a window frozen with -- Gdk.Window.Freeze_Toplevel_Updates_Libgtk_Only. -- This function is not part of the GDK public API and is only for use by -- GTK+. -- Deprecated since 3.16, 1 procedure Thaw_Updates (Self : Gdk.Gdk_Window); pragma Import (C, Thaw_Updates, "gdk_window_thaw_updates"); -- Thaws a window frozen with Gdk.Window.Freeze_Updates. procedure Unfullscreen (Self : Gdk.Gdk_Window); pragma Import (C, Unfullscreen, "gdk_window_unfullscreen"); -- Moves the window out of fullscreen mode. If the window was not -- fullscreen, does nothing. -- On X11, asks the window manager to move Window out of the fullscreen -- state, if the window manager supports this operation. Not all window -- managers support this, and some deliberately ignore it or don't have a -- concept of "fullscreen"; so you can't rely on the unfullscreenification -- actually happening. But it will happen with most standard window -- managers, and GDK makes a best effort to get it to happen. -- Since: gtk+ 2.2 procedure Unmaximize (Self : Gdk.Gdk_Window); pragma Import (C, Unmaximize, "gdk_window_unmaximize"); -- Unmaximizes the window. If the window wasn't maximized, then this -- function does nothing. -- On X11, asks the window manager to unmaximize Window, if the window -- manager supports this operation. Not all window managers support this, -- and some deliberately ignore it or don't have a concept of "maximized"; -- so you can't rely on the unmaximization actually happening. But it will -- happen with most standard window managers, and GDK makes a best effort -- to get it to happen. -- On Windows, reliably unmaximizes the window. procedure Unstick (Self : Gdk.Gdk_Window); pragma Import (C, Unstick, "gdk_window_unstick"); -- Reverse operation for Gdk.Window.Stick; see Gdk.Window.Stick, and -- Gtk.Window.Unstick. procedure Withdraw (Self : Gdk.Gdk_Window); pragma Import (C, Withdraw, "gdk_window_withdraw"); -- Withdraws a window (unmaps it and asks the window manager to forget -- about it). This function is not really useful as Gdk.Window.Hide -- automatically withdraws toplevel windows before hiding them. ---------------------- -- GtkAda additions -- ---------------------- function Get_User_Data (Window : Gdk_Window) return Glib.Object.GObject; -- Return the widget to which events are reported when they happen on -- Window. This is the widget that was set through the call to -- Set_User_data. procedure Set_User_Data (Window : Gdk_Window; Widget : access Glib.Object.GObject_Record'Class); -- Sets a special field in the window. -- All the events reported by the Xserver (or the Windows server) for -- Window will be redirected to Widget through the standard signals -- "expose_event", "button_press_event", ... -- You almost always need to call this function after creating a new -- Gdk_Window yourself, or you won't be able to handle the events. procedure Ref (Window : Gdk_Window); procedure Unref (Window : Gdk_Window); pragma Import (C, Ref, "g_object_ref"); pragma Import (C, Unref, "g_object_unref"); --------------- -- Functions -- --------------- procedure At_Pointer (Win_X : out Glib.Gint; Win_Y : out Glib.Gint; Window : out Gdk.Gdk_Window); pragma Obsolescent (At_Pointer); -- Obtains the window underneath the mouse pointer, returning the location -- of that window in Win_X, Win_Y. Returns null if the window under the -- mouse pointer is not known to GDK (if the window belongs to another -- application and a Gdk.Gdk_Window hasn't been created for it with -- gdk_window_foreign_new) -- NOTE: For multihead-aware widgets or applications use -- gdk_display_get_window_at_pointer instead. -- Deprecated since 3.0, 1 -- "win_x": return location for origin of the window under the pointer -- "win_y": return location for origin of the window under the pointer procedure Constrain_Size (Geometry : Gdk_Geometry; Flags : Gdk_Window_Hints; Width : Glib.Gint; Height : Glib.Gint; New_Width : out Glib.Gint; New_Height : out Glib.Gint); pragma Import (C, Constrain_Size, "gdk_window_constrain_size"); -- Constrains a desired width and height according to a set of geometry -- hints (such as minimum and maximum size). -- "geometry": a Gdk.Window.Gdk_Geometry structure -- "flags": a mask indicating what portions of Geometry are set -- "width": desired width of window -- "height": desired height of the window -- "new_width": location to store resulting width -- "new_height": location to store resulting height procedure Process_All_Updates; pragma Import (C, Process_All_Updates, "gdk_window_process_all_updates"); pragma Obsolescent (Process_All_Updates); -- Calls Gdk.Window.Process_Updates for all windows (see Gdk.Gdk_Window) -- in the application. -- Deprecated since 3.22, 1 procedure Set_Debug_Updates (Setting : Boolean); pragma Obsolescent (Set_Debug_Updates); -- With update debugging enabled, calls to Gdk.Window.Invalidate_Region -- clear the invalidated region of the screen to a noticeable color, and -- GDK pauses for a short time before sending exposes to windows during -- Gdk.Window.Process_Updates. The net effect is that you can see the -- invalid region for each window and watch redraws as they occur. This -- allows you to diagnose inefficiencies in your application. -- In essence, because the GDK rendering model prevents all flicker, if -- you are redrawing the same region 400 times you may never notice, aside -- from noticing a speed problem. Enabling update debugging causes GTK to -- flicker slowly and noticeably, so you can see exactly what's being -- redrawn when, in what order. -- The --gtk-debug=updates command line option passed to GTK+ programs -- enables this debug option at application startup time. That's usually -- more useful than calling Gdk.Window.Set_Debug_Updates yourself, though -- you might want to use this function to enable updates sometime after -- application startup time. -- Deprecated since 3.22, 1 -- "setting": True to turn on update debugging ---------------- -- Properties -- ---------------- -- The following properties are defined for this widget. See -- Glib.Properties for more information on properties) Cursor_Property : constant Glib.Properties.Property_Boxed; -- Type: Cursor -- The mouse pointer for a Gdk.Gdk_Window. See Gdk.Window.Set_Cursor and -- Gdk.Window.Get_Cursor for details. ------------- -- Signals -- ------------- Signal_Create_Surface : constant Glib.Signal_Name := "create-surface"; -- The ::create-surface signal is emitted when an offscreen window needs -- its surface (re)created, which happens either when the window is first -- drawn to, or when the window is being resized. The first signal handler -- that returns a non-null surface will stop any further signal emission, -- and its surface will be used. -- -- Note that it is not possible to access the window's previous surface -- from within any callback of this signal. Calling -- gdk_offscreen_window_get_surface will lead to a crash. -- function Handler -- (Self : Gdk_Window; -- Width : Glib.Gint; -- Height : Glib.Gint) return Cairo.Cairo_Surface -- -- Callback parameters: -- -- "width": the width of the offscreen surface to create -- -- "height": the height of the offscreen surface to create -- -- Returns the newly created cairo_surface_t for the offscreen window Signal_From_Embedder : constant Glib.Signal_Name := "from-embedder"; -- The ::from-embedder signal is emitted to translate coordinates in the -- embedder of an offscreen window to the offscreen window. -- -- See also Gdk.Gdk_Window::to-embedder. -- procedure Handler -- (Self : Gdk_Window; -- Embedder_X : Gdouble; -- Embedder_Y : Gdouble; -- Offscreen_X : out System.Address; -- Offscreen_Y : out System.Address) -- -- Callback parameters: -- -- "embedder_x": x coordinate in the embedder window -- -- "embedder_y": y coordinate in the embedder window -- -- "offscreen_x": return location for the x coordinate in the offscreen -- -- window -- -- "offscreen_y": return location for the y coordinate in the offscreen -- -- window Signal_Moved_To_Rect : constant Glib.Signal_Name := "moved-to-rect"; -- Emitted when the position of Window is finalized after being moved to a -- destination rectangle. -- -- Window might be flipped over the destination rectangle in order to keep -- it on-screen, in which case Flipped_X and Flipped_Y will be set to True -- accordingly. -- -- Flipped_Rect is the ideal position of Window after any possible -- flipping, but before any possible sliding. Final_Rect is Flipped_Rect, -- but possibly translated in the case that flipping is still ineffective -- in keeping Window on-screen. -- procedure Handler -- (Self : Gdk_Window; -- Flipped_Rect : System.Address; -- Final_Rect : System.Address; -- Flipped_X : Boolean; -- Flipped_Y : Boolean) -- -- Callback parameters: -- -- "flipped_rect": the position of Window after any possible flipping or -- -- null if the backend can't obtain it -- -- "final_rect": the final position of Window or null if the backend can't -- -- obtain it -- -- "flipped_x": True if the anchors were flipped horizontally -- -- "flipped_y": True if the anchors were flipped vertically Signal_Pick_Embedded_Child : constant Glib.Signal_Name := "pick-embedded-child"; -- The ::pick-embedded-child signal is emitted to find an embedded child -- at the given position. -- function Handler -- (Self : Gdk_Window; -- X : Gdouble; -- Y : Gdouble) return Gtk.Window.Gtk_Window -- -- Callback parameters: -- -- "x": x coordinate in the window -- -- "y": y coordinate in the window -- -- Returns the Gdk.Gdk_Window of the -- embedded child at X, Y, or null Signal_To_Embedder : constant Glib.Signal_Name := "to-embedder"; -- The ::to-embedder signal is emitted to translate coordinates in an -- offscreen window to its embedder. -- -- See also Gdk.Gdk_Window::from-embedder. -- procedure Handler -- (Self : Gdk_Window; -- Offscreen_X : Gdouble; -- Offscreen_Y : Gdouble; -- Embedder_X : out System.Address; -- Embedder_Y : out System.Address) -- -- Callback parameters: -- -- "offscreen_x": x coordinate in the offscreen window -- -- "offscreen_y": y coordinate in the offscreen window -- -- "embedder_x": return location for the x coordinate in the embedder -- -- window -- -- "embedder_y": return location for the y coordinate in the embedder -- -- window private Cursor_Property : constant Glib.Properties.Property_Boxed := Glib.Properties.Build ("cursor"); end Gdk.Window; gtkada-24.0.0/src/generated/glib-action.adb000066400000000000000000000122731446021174000204210ustar00rootroot00000000000000------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ pragma Style_Checks (Off); pragma Warnings (Off, "*is already use-visible*"); with Gtkada.Bindings; use Gtkada.Bindings; package body Glib.Action is -------------- -- Activate -- -------------- procedure Activate (Self : Gaction; Parameter : Glib.Variant.Gvariant) is procedure Internal (Self : Gaction; Parameter : System.Address); pragma Import (C, Internal, "g_action_activate"); begin Internal (Self, Get_Object (Parameter)); end Activate; ------------------ -- Change_State -- ------------------ procedure Change_State (Self : Gaction; Value : Glib.Variant.Gvariant) is procedure Internal (Self : Gaction; Value : System.Address); pragma Import (C, Internal, "g_action_change_state"); begin Internal (Self, Get_Object (Value)); end Change_State; ----------------- -- Get_Enabled -- ----------------- function Get_Enabled (Self : Gaction) return Boolean is function Internal (Self : Gaction) return Glib.Gboolean; pragma Import (C, Internal, "g_action_get_enabled"); begin return Internal (Self) /= 0; end Get_Enabled; -------------- -- Get_Name -- -------------- function Get_Name (Self : Gaction) return UTF8_String is function Internal (Self : Gaction) return Gtkada.Types.Chars_Ptr; pragma Import (C, Internal, "g_action_get_name"); begin return Gtkada.Bindings.Value_Allowing_Null (Internal (Self)); end Get_Name; --------------- -- Get_State -- --------------- function Get_State (Self : Gaction) return Glib.Variant.Gvariant is function Internal (Self : Gaction) return System.Address; pragma Import (C, Internal, "g_action_get_state"); begin return From_Object (Internal (Self)); end Get_State; -------------------- -- Get_State_Hint -- -------------------- function Get_State_Hint (Self : Gaction) return Glib.Variant.Gvariant is function Internal (Self : Gaction) return System.Address; pragma Import (C, Internal, "g_action_get_state_hint"); begin return From_Object (Internal (Self)); end Get_State_Hint; ------------------- -- Name_Is_Valid -- ------------------- function Name_Is_Valid (Action_Name : UTF8_String) return Boolean is function Internal (Action_Name : Gtkada.Types.Chars_Ptr) return Glib.Gboolean; pragma Import (C, Internal, "g_action_name_is_valid"); Tmp_Action_Name : Gtkada.Types.Chars_Ptr := New_String (Action_Name); Tmp_Return : Glib.Gboolean; begin Tmp_Return := Internal (Tmp_Action_Name); Free (Tmp_Action_Name); return Tmp_Return /= 0; end Name_Is_Valid; ------------------------- -- Print_Detailed_Name -- ------------------------- function Print_Detailed_Name (Action_Name : UTF8_String; Target_Value : Glib.Variant.Gvariant) return UTF8_String is function Internal (Action_Name : Gtkada.Types.Chars_Ptr; Target_Value : System.Address) return Gtkada.Types.Chars_Ptr; pragma Import (C, Internal, "g_action_print_detailed_name"); Tmp_Action_Name : Gtkada.Types.Chars_Ptr := New_String (Action_Name); Tmp_Return : Gtkada.Types.Chars_Ptr; begin Tmp_Return := Internal (Tmp_Action_Name, Get_Object (Target_Value)); Free (Tmp_Action_Name); return Gtkada.Bindings.Value_And_Free (Tmp_Return); end Print_Detailed_Name; function "+" (W : Gaction) return Gaction is begin return W; end "+"; end Glib.Action; gtkada-24.0.0/src/generated/glib-action.ads000066400000000000000000000425471446021174000204510ustar00rootroot00000000000000------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ -- -- Glib.Action.Gaction represents a single named action. -- -- The main interface to an action is that it can be activated with -- Glib.Action.Activate. This results in the 'activate' signal being emitted. -- An activation has a Glib.Variant.Gvariant parameter (which may be null). -- The correct type for the parameter is determined by a static parameter type -- (which is given at construction time). -- -- An action may optionally have a state, in which case the state may be set -- with Glib.Action.Change_State. This call takes a Glib.Variant.Gvariant. The -- correct type for the state is determined by a static state type (which is -- given at construction time). -- -- The state may have a hint associated with it, specifying its valid range. -- -- Glib.Action.Gaction is merely the interface to the concept of an action, -- as described above. Various implementations of actions exist, including -- Glib.Simple_Action.Gsimple_Action. -- -- In all cases, the implementing class is responsible for storing the name -- of the action, the parameter type, the enabled state, the optional state -- type and the state and emitting the appropriate signals when these change. -- The implementor is responsible for filtering calls to Glib.Action.Activate -- and Glib.Action.Change_State for type safety and for the state being -- enabled. -- -- Probably the only useful thing to do with a Glib.Action.Gaction is to put -- it inside of a Glib.Simple_Action_Group.Gsimple_Action_Group. -- -- pragma Warnings (Off, "*is already use-visible*"); with Glib.Object; use Glib.Object; with Glib.Properties; use Glib.Properties; with Glib.Types; use Glib.Types; with Glib.Variant; use Glib.Variant; pragma Warnings(Off); -- might be unused with Gtkada.Types; use Gtkada.Types; pragma Warnings(On); package Glib.Action is type Gaction is new Glib.Types.GType_Interface; Null_Gaction : constant Gaction; ------------------ -- Constructors -- ------------------ function Get_Type return Glib.GType; pragma Import (C, Get_Type, "g_action_get_type"); ------------- -- Methods -- ------------- procedure Activate (Self : Gaction; Parameter : Glib.Variant.Gvariant); -- Activates the action. -- Parameter must be the correct type of parameter for the action (ie: the -- parameter type given at construction time). If the parameter type was -- null then Parameter must also be null. -- If the Parameter GVariant is floating, it is consumed. -- Since: gtk+ 2.28 -- "parameter": the parameter to the activation procedure Change_State (Self : Gaction; Value : Glib.Variant.Gvariant); -- Request for the state of Action to be changed to Value. -- The action must be stateful and Value must be of the correct type. See -- Glib.Action.Get_State_Type. -- This call merely requests a change. The action may refuse to change its -- state or may change its state to something other than Value. See -- Glib.Action.Get_State_Hint. -- If the Value GVariant is floating, it is consumed. -- Since: gtk+ 2.30 -- "value": the new state function Get_Enabled (Self : Gaction) return Boolean; -- Checks if Action is currently enabled. -- An action must be enabled in order to be activated or in order to have -- its state changed from outside callers. -- Since: gtk+ 2.28 function Get_Name (Self : Gaction) return UTF8_String; -- Queries the name of Action. -- Since: gtk+ 2.28 function Get_Parameter_Type (Self : Gaction) return Glib.Variant.Gvariant_Type; pragma Import (C, Get_Parameter_Type, "g_action_get_parameter_type"); -- Queries the type of the parameter that must be given when activating -- Action. -- When activating the action using Glib.Action.Activate, the -- Glib.Variant.Gvariant given to that function must be of the type -- returned by this function. -- In the case that this function returns null, you must not give any -- Glib.Variant.Gvariant, but null instead. -- Since: gtk+ 2.28 function Get_State (Self : Gaction) return Glib.Variant.Gvariant; -- Queries the current state of Action. -- If the action is not stateful then null will be returned. If the action -- is stateful then the type of the return value is the type given by -- Glib.Action.Get_State_Type. -- The return value (if non-null) should be freed with Glib.Variant.Unref -- when it is no longer required. -- Since: gtk+ 2.28 function Get_State_Hint (Self : Gaction) return Glib.Variant.Gvariant; -- Requests a hint about the valid range of values for the state of -- Action. -- If null is returned it either means that the action is not stateful or -- that there is no hint about the valid range of values for the state of -- the action. -- If a Glib.Variant.Gvariant array is returned then each item in the -- array is a possible value for the state. If a Glib.Variant.Gvariant pair -- (ie: two-tuple) is returned then the tuple specifies the inclusive lower -- and upper bound of valid values for the state. -- In any case, the information is merely a hint. It may be possible to -- have a state value outside of the hinted range and setting a value -- within the range may fail. -- The return value (if non-null) should be freed with Glib.Variant.Unref -- when it is no longer required. -- Since: gtk+ 2.28 function Get_State_Type (Self : Gaction) return Glib.Variant.Gvariant_Type; pragma Import (C, Get_State_Type, "g_action_get_state_type"); -- Queries the type of the state of Action. -- If the action is stateful (e.g. created with -- Glib.Simple_Action.G_New_Stateful) then this function returns the -- Glib.Variant.Gvariant_Type of the state. This is the type of the initial -- value given as the state. All calls to Glib.Action.Change_State must -- give a Glib.Variant.Gvariant of this type and Glib.Action.Get_State will -- return a Glib.Variant.Gvariant of the same type. -- If the action is not stateful (e.g. created with -- Glib.Simple_Action.G_New) then this function will return null. In that -- case, Glib.Action.Get_State will return null and you must not call -- Glib.Action.Change_State. -- Since: gtk+ 2.28 --------------- -- Functions -- --------------- function Name_Is_Valid (Action_Name : UTF8_String) return Boolean; -- Checks if Action_Name is valid. -- Action_Name is valid if it consists only of alphanumeric characters, -- plus '-' and '.'. The empty string is not a valid action name. -- It is an error to call this function with a non-utf8 Action_Name. -- Action_Name must not be null. -- Since: gtk+ 2.38 -- "action_name": a potential action name function Print_Detailed_Name (Action_Name : UTF8_String; Target_Value : Glib.Variant.Gvariant) return UTF8_String; -- Formats a detailed action name from Action_Name and Target_Value. -- It is an error to call this function with an invalid action name. -- This function is the opposite of g_action_parse_detailed_name. It will -- produce a string that can be parsed back to the Action_Name and -- Target_Value by that function. -- See that function for the types of strings that will be printed by this -- function. -- Since: gtk+ 2.38 -- "action_name": a valid action name -- "target_value": a Glib.Variant.Gvariant target value, or null ---------------- -- Properties -- ---------------- -- The following properties are defined for this widget. See -- Glib.Properties for more information on properties) Enabled_Property : constant Glib.Properties.Property_Boolean; -- If Action is currently enabled. -- -- If the action is disabled then calls to Glib.Action.Activate and -- Glib.Action.Change_State have no effect. Name_Property : constant Glib.Properties.Property_String; -- The name of the action. This is mostly meaningful for identifying the -- action once it has been added to a Glib.Action_Group.Gaction_Group. It -- is immutable. Parameter_Type_Property : constant Glib.Properties.Property_Boxed; -- Type: GLib.Variant_Type -- The type of the parameter that must be given when activating the -- action. This is immutable, and may be null if no parameter is needed -- when activating the action. State_Property : constant Glib.Properties.Property_Object; -- Type: Glib.Variant.Gvariant -- The state of the action, or null if the action is stateless. State_Type_Property : constant Glib.Properties.Property_Boxed; -- Type: GLib.Variant_Type -- The Glib.Variant.Gvariant_Type of the state that the action has, or -- null if the action is stateless. This is immutable. ---------------- -- Interfaces -- ---------------- -- This class implements several interfaces. See Glib.Types -- -- - "Gaction" function "+" (W : Gaction) return Gaction; pragma Inline ("+"); --------------------- -- Virtual Methods -- --------------------- type Virtual_Activate is access procedure (Self : Gaction; Parameter : System.Address); pragma Convention (C, Virtual_Activate); -- Activates the action. -- Parameter must be the correct type of parameter for the action (ie: the -- parameter type given at construction time). If the parameter type was -- null then Parameter must also be null. -- If the Parameter GVariant is floating, it is consumed. -- Since: gtk+ 2.28 -- "parameter": the parameter to the activation type Virtual_Change_State is access procedure (Self : Gaction; Value : System.Address); pragma Convention (C, Virtual_Change_State); -- Request for the state of Action to be changed to Value. -- The action must be stateful and Value must be of the correct type. See -- Glib.Action.Get_State_Type. -- This call merely requests a change. The action may refuse to change its -- state or may change its state to something other than Value. See -- Glib.Action.Get_State_Hint. -- If the Value GVariant is floating, it is consumed. -- Since: gtk+ 2.30 -- "value": the new state type Virtual_Get_Enabled is access function (Self : Gaction) return Glib.Gboolean; pragma Convention (C, Virtual_Get_Enabled); -- Checks if Action is currently enabled. -- An action must be enabled in order to be activated or in order to have -- its state changed from outside callers. -- Since: gtk+ 2.28 type Virtual_Get_Name is access function (Self : Gaction) return Gtkada.Types.Chars_Ptr; pragma Convention (C, Virtual_Get_Name); -- Queries the name of Action. -- Since: gtk+ 2.28 type Virtual_Get_Parameter_Type is access function (Self : Gaction) return Glib.Variant.Gvariant_Type; pragma Convention (C, Virtual_Get_Parameter_Type); -- Queries the type of the parameter that must be given when activating -- Action. -- When activating the action using Glib.Action.Activate, the -- Glib.Variant.Gvariant given to that function must be of the type -- returned by this function. -- In the case that this function returns null, you must not give any -- Glib.Variant.Gvariant, but null instead. -- Since: gtk+ 2.28 type Virtual_Get_State is access function (Self : Gaction) return System.Address; pragma Convention (C, Virtual_Get_State); -- Queries the current state of Action. -- If the action is not stateful then null will be returned. If the action -- is stateful then the type of the return value is the type given by -- Glib.Action.Get_State_Type. -- The return value (if non-null) should be freed with g_variant_unref -- when it is no longer required. -- Since: gtk+ 2.28 type Virtual_Get_State_Hint is access function (Self : Gaction) return System.Address; pragma Convention (C, Virtual_Get_State_Hint); -- Requests a hint about the valid range of values for the state of -- Action. -- If null is returned it either means that the action is not stateful or -- that there is no hint about the valid range of values for the state of -- the action. -- If a Glib.Variant.Gvariant array is returned then each item in the -- array is a possible value for the state. If a Glib.Variant.Gvariant pair -- (ie: two-tuple) is returned then the tuple specifies the inclusive lower -- and upper bound of valid values for the state. -- In any case, the information is merely a hint. It may be possible to -- have a state value outside of the hinted range and setting a value -- within the range may fail. -- The return value (if non-null) should be freed with g_variant_unref -- when it is no longer required. -- Since: gtk+ 2.28 type Virtual_Get_State_Type is access function (Self : Gaction) return Glib.Variant.Gvariant_Type; pragma Convention (C, Virtual_Get_State_Type); -- Queries the type of the state of Action. -- If the action is stateful (e.g. created with -- g_simple_action_new_stateful) then this function returns the -- Glib.Variant.Gvariant_Type of the state. This is the type of the initial -- value given as the state. All calls to Glib.Action.Change_State must -- give a Glib.Variant.Gvariant of this type and Glib.Action.Get_State will -- return a Glib.Variant.Gvariant of the same type. -- If the action is not stateful (e.g. created with g_simple_action_new) -- then this function will return null. In that case, Glib.Action.Get_State -- will return null and you must not call Glib.Action.Change_State. -- Since: gtk+ 2.28 subtype Action_Interface_Descr is Glib.Object.Interface_Description; procedure Set_Activate (Self : Action_Interface_Descr; Handler : Virtual_Activate); pragma Import (C, Set_Activate, "gtkada_Action_set_activate"); procedure Set_Change_State (Self : Action_Interface_Descr; Handler : Virtual_Change_State); pragma Import (C, Set_Change_State, "gtkada_Action_set_change_state"); procedure Set_Get_Enabled (Self : Action_Interface_Descr; Handler : Virtual_Get_Enabled); pragma Import (C, Set_Get_Enabled, "gtkada_Action_set_get_enabled"); procedure Set_Get_Name (Self : Action_Interface_Descr; Handler : Virtual_Get_Name); pragma Import (C, Set_Get_Name, "gtkada_Action_set_get_name"); procedure Set_Get_Parameter_Type (Self : Action_Interface_Descr; Handler : Virtual_Get_Parameter_Type); pragma Import (C, Set_Get_Parameter_Type, "gtkada_Action_set_get_parameter_type"); procedure Set_Get_State (Self : Action_Interface_Descr; Handler : Virtual_Get_State); pragma Import (C, Set_Get_State, "gtkada_Action_set_get_state"); procedure Set_Get_State_Hint (Self : Action_Interface_Descr; Handler : Virtual_Get_State_Hint); pragma Import (C, Set_Get_State_Hint, "gtkada_Action_set_get_state_hint"); procedure Set_Get_State_Type (Self : Action_Interface_Descr; Handler : Virtual_Get_State_Type); pragma Import (C, Set_Get_State_Type, "gtkada_Action_set_get_state_type"); -- See Glib.Object.Add_Interface private State_Type_Property : constant Glib.Properties.Property_Boxed := Glib.Properties.Build ("state-type"); State_Property : constant Glib.Properties.Property_Object := Glib.Properties.Build ("state"); Parameter_Type_Property : constant Glib.Properties.Property_Boxed := Glib.Properties.Build ("parameter-type"); Name_Property : constant Glib.Properties.Property_String := Glib.Properties.Build ("name"); Enabled_Property : constant Glib.Properties.Property_Boolean := Glib.Properties.Build ("enabled"); Null_Gaction : constant Gaction := Gaction (Glib.Types.Null_Interface); end Glib.Action; gtkada-24.0.0/src/generated/glib-action_group.adb000066400000000000000000000725031446021174000216370ustar00rootroot00000000000000------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ pragma Style_Checks (Off); pragma Warnings (Off, "*is already use-visible*"); with Ada.Unchecked_Conversion; with Glib.Values; use Glib.Values; with Gtk.Arguments; use Gtk.Arguments; package body Glib.Action_Group is ------------------ -- Action_Added -- ------------------ procedure Action_Added (Self : Gaction_Group; Action_Name : UTF8_String) is procedure Internal (Self : Gaction_Group; Action_Name : Gtkada.Types.Chars_Ptr); pragma Import (C, Internal, "g_action_group_action_added"); Tmp_Action_Name : Gtkada.Types.Chars_Ptr := New_String (Action_Name); begin Internal (Self, Tmp_Action_Name); Free (Tmp_Action_Name); end Action_Added; ---------------------------- -- Action_Enabled_Changed -- ---------------------------- procedure Action_Enabled_Changed (Self : Gaction_Group; Action_Name : UTF8_String; Enabled : Boolean) is procedure Internal (Self : Gaction_Group; Action_Name : Gtkada.Types.Chars_Ptr; Enabled : Glib.Gboolean); pragma Import (C, Internal, "g_action_group_action_enabled_changed"); Tmp_Action_Name : Gtkada.Types.Chars_Ptr := New_String (Action_Name); begin Internal (Self, Tmp_Action_Name, Boolean'Pos (Enabled)); Free (Tmp_Action_Name); end Action_Enabled_Changed; -------------------- -- Action_Removed -- -------------------- procedure Action_Removed (Self : Gaction_Group; Action_Name : UTF8_String) is procedure Internal (Self : Gaction_Group; Action_Name : Gtkada.Types.Chars_Ptr); pragma Import (C, Internal, "g_action_group_action_removed"); Tmp_Action_Name : Gtkada.Types.Chars_Ptr := New_String (Action_Name); begin Internal (Self, Tmp_Action_Name); Free (Tmp_Action_Name); end Action_Removed; -------------------------- -- Action_State_Changed -- -------------------------- procedure Action_State_Changed (Self : Gaction_Group; Action_Name : UTF8_String; State : Glib.Variant.Gvariant) is procedure Internal (Self : Gaction_Group; Action_Name : Gtkada.Types.Chars_Ptr; State : System.Address); pragma Import (C, Internal, "g_action_group_action_state_changed"); Tmp_Action_Name : Gtkada.Types.Chars_Ptr := New_String (Action_Name); begin Internal (Self, Tmp_Action_Name, Get_Object (State)); Free (Tmp_Action_Name); end Action_State_Changed; --------------------- -- Activate_Action -- --------------------- procedure Activate_Action (Self : Gaction_Group; Action_Name : UTF8_String; Parameter : Glib.Variant.Gvariant) is procedure Internal (Self : Gaction_Group; Action_Name : Gtkada.Types.Chars_Ptr; Parameter : System.Address); pragma Import (C, Internal, "g_action_group_activate_action"); Tmp_Action_Name : Gtkada.Types.Chars_Ptr := New_String (Action_Name); begin Internal (Self, Tmp_Action_Name, Get_Object (Parameter)); Free (Tmp_Action_Name); end Activate_Action; ------------------------- -- Change_Action_State -- ------------------------- procedure Change_Action_State (Self : Gaction_Group; Action_Name : UTF8_String; Value : Glib.Variant.Gvariant) is procedure Internal (Self : Gaction_Group; Action_Name : Gtkada.Types.Chars_Ptr; Value : System.Address); pragma Import (C, Internal, "g_action_group_change_action_state"); Tmp_Action_Name : Gtkada.Types.Chars_Ptr := New_String (Action_Name); begin Internal (Self, Tmp_Action_Name, Get_Object (Value)); Free (Tmp_Action_Name); end Change_Action_State; ------------------------ -- Get_Action_Enabled -- ------------------------ function Get_Action_Enabled (Self : Gaction_Group; Action_Name : UTF8_String) return Boolean is function Internal (Self : Gaction_Group; Action_Name : Gtkada.Types.Chars_Ptr) return Glib.Gboolean; pragma Import (C, Internal, "g_action_group_get_action_enabled"); Tmp_Action_Name : Gtkada.Types.Chars_Ptr := New_String (Action_Name); Tmp_Return : Glib.Gboolean; begin Tmp_Return := Internal (Self, Tmp_Action_Name); Free (Tmp_Action_Name); return Tmp_Return /= 0; end Get_Action_Enabled; ------------------------------- -- Get_Action_Parameter_Type -- ------------------------------- function Get_Action_Parameter_Type (Self : Gaction_Group; Action_Name : UTF8_String) return Glib.Variant.Gvariant_Type is function Internal (Self : Gaction_Group; Action_Name : Gtkada.Types.Chars_Ptr) return Glib.Variant.Gvariant_Type; pragma Import (C, Internal, "g_action_group_get_action_parameter_type"); Tmp_Action_Name : Gtkada.Types.Chars_Ptr := New_String (Action_Name); Tmp_Return : Glib.Variant.Gvariant_Type; begin Tmp_Return := Internal (Self, Tmp_Action_Name); Free (Tmp_Action_Name); return Tmp_Return; end Get_Action_Parameter_Type; ---------------------- -- Get_Action_State -- ---------------------- function Get_Action_State (Self : Gaction_Group; Action_Name : UTF8_String) return Glib.Variant.Gvariant is function Internal (Self : Gaction_Group; Action_Name : Gtkada.Types.Chars_Ptr) return System.Address; pragma Import (C, Internal, "g_action_group_get_action_state"); Tmp_Action_Name : Gtkada.Types.Chars_Ptr := New_String (Action_Name); Tmp_Return : System.Address; begin Tmp_Return := Internal (Self, Tmp_Action_Name); Free (Tmp_Action_Name); return From_Object (Tmp_Return); end Get_Action_State; --------------------------- -- Get_Action_State_Hint -- --------------------------- function Get_Action_State_Hint (Self : Gaction_Group; Action_Name : UTF8_String) return Glib.Variant.Gvariant is function Internal (Self : Gaction_Group; Action_Name : Gtkada.Types.Chars_Ptr) return System.Address; pragma Import (C, Internal, "g_action_group_get_action_state_hint"); Tmp_Action_Name : Gtkada.Types.Chars_Ptr := New_String (Action_Name); Tmp_Return : System.Address; begin Tmp_Return := Internal (Self, Tmp_Action_Name); Free (Tmp_Action_Name); return From_Object (Tmp_Return); end Get_Action_State_Hint; --------------------------- -- Get_Action_State_Type -- --------------------------- function Get_Action_State_Type (Self : Gaction_Group; Action_Name : UTF8_String) return Glib.Variant.Gvariant_Type is function Internal (Self : Gaction_Group; Action_Name : Gtkada.Types.Chars_Ptr) return Glib.Variant.Gvariant_Type; pragma Import (C, Internal, "g_action_group_get_action_state_type"); Tmp_Action_Name : Gtkada.Types.Chars_Ptr := New_String (Action_Name); Tmp_Return : Glib.Variant.Gvariant_Type; begin Tmp_Return := Internal (Self, Tmp_Action_Name); Free (Tmp_Action_Name); return Tmp_Return; end Get_Action_State_Type; ---------------- -- Has_Action -- ---------------- function Has_Action (Self : Gaction_Group; Action_Name : UTF8_String) return Boolean is function Internal (Self : Gaction_Group; Action_Name : Gtkada.Types.Chars_Ptr) return Glib.Gboolean; pragma Import (C, Internal, "g_action_group_has_action"); Tmp_Action_Name : Gtkada.Types.Chars_Ptr := New_String (Action_Name); Tmp_Return : Glib.Gboolean; begin Tmp_Return := Internal (Self, Tmp_Action_Name); Free (Tmp_Action_Name); return Tmp_Return /= 0; end Has_Action; ------------------ -- List_Actions -- ------------------ function List_Actions (Self : Gaction_Group) return GNAT.Strings.String_List is function Internal (Self : Gaction_Group) return chars_ptr_array_access; pragma Import (C, Internal, "g_action_group_list_actions"); begin return To_String_List_And_Free (Internal (Self)); end List_Actions; ------------------ -- Query_Action -- ------------------ function Query_Action (Self : Gaction_Group; Action_Name : UTF8_String; Enabled : access Boolean; Parameter_Type : access Glib.Variant.Gvariant_Type; State_Type : access Glib.Variant.Gvariant_Type; State_Hint : access Glib.Variant.Gvariant; State : access Glib.Variant.Gvariant) return Boolean is function Internal (Self : Gaction_Group; Action_Name : Gtkada.Types.Chars_Ptr; Acc_Enabled : access Glib.Gboolean; Acc_Parameter_Type : access Glib.Variant.Gvariant_Type; Acc_State_Type : access Glib.Variant.Gvariant_Type; Acc_State_Hint : access System.Address; Acc_State : access System.Address) return Glib.Gboolean; pragma Import (C, Internal, "g_action_group_query_action"); Acc_Enabled : aliased Boolean; Acc_Parameter_Type : aliased Glib.Variant.Gvariant_Type; Acc_State_Type : aliased Glib.Variant.Gvariant_Type; Acc_State_Hint : aliased Glib.Variant.Gvariant; Acc_State : aliased Glib.Variant.Gvariant; Tmp_Action_Name : Gtkada.Types.Chars_Ptr := New_String (Action_Name); Tmp_Acc_Enabled : aliased Glib.Gboolean; Tmp_Acc_State_Hint : aliased System.Address; Tmp_Acc_State : aliased System.Address; Tmp_Return : Glib.Gboolean; begin Tmp_Return := Internal (Self, Tmp_Action_Name, Tmp_Acc_Enabled'Access, Acc_Parameter_Type'Access, Acc_State_Type'Access, Tmp_Acc_State_Hint'Access, Tmp_Acc_State'Access); Acc_State := From_Object (Tmp_Acc_State); Acc_State_Hint := From_Object (Tmp_Acc_State_Hint); Acc_Enabled := Tmp_Acc_Enabled /= 0; Free (Tmp_Action_Name); Enabled.all := Acc_Enabled; if Parameter_Type /= null then Parameter_Type.all := Acc_Parameter_Type; end if; if State_Type /= null then State_Type.all := Acc_State_Type; end if; if State_Hint /= null then State_Hint.all := Acc_State_Hint; end if; if State /= null then State.all := Acc_State; end if; return Tmp_Return /= 0; end Query_Action; use type System.Address; function Cb_To_Address is new Ada.Unchecked_Conversion (Cb_Gaction_Group_UTF8_String_Void, System.Address); function Address_To_Cb is new Ada.Unchecked_Conversion (System.Address, Cb_Gaction_Group_UTF8_String_Void); function Cb_To_Address is new Ada.Unchecked_Conversion (Cb_GObject_UTF8_String_Void, System.Address); function Address_To_Cb is new Ada.Unchecked_Conversion (System.Address, Cb_GObject_UTF8_String_Void); function Cb_To_Address is new Ada.Unchecked_Conversion (Cb_Gaction_Group_UTF8_String_Boolean_Void, System.Address); function Address_To_Cb is new Ada.Unchecked_Conversion (System.Address, Cb_Gaction_Group_UTF8_String_Boolean_Void); function Cb_To_Address is new Ada.Unchecked_Conversion (Cb_GObject_UTF8_String_Boolean_Void, System.Address); function Address_To_Cb is new Ada.Unchecked_Conversion (System.Address, Cb_GObject_UTF8_String_Boolean_Void); function Cb_To_Address is new Ada.Unchecked_Conversion (Cb_Gaction_Group_UTF8_String_Gvariant_Void, System.Address); function Address_To_Cb is new Ada.Unchecked_Conversion (System.Address, Cb_Gaction_Group_UTF8_String_Gvariant_Void); function Cb_To_Address is new Ada.Unchecked_Conversion (Cb_GObject_UTF8_String_Gvariant_Void, System.Address); function Address_To_Cb is new Ada.Unchecked_Conversion (System.Address, Cb_GObject_UTF8_String_Gvariant_Void); procedure Connect (Object : Gaction_Group; C_Name : Glib.Signal_Name; Handler : Cb_Gaction_Group_UTF8_String_Void; After : Boolean); procedure Connect (Object : Gaction_Group; C_Name : Glib.Signal_Name; Handler : Cb_Gaction_Group_UTF8_String_Boolean_Void; After : Boolean); procedure Connect (Object : Gaction_Group; C_Name : Glib.Signal_Name; Handler : Cb_Gaction_Group_UTF8_String_Gvariant_Void; After : Boolean); procedure Connect_Slot (Object : Gaction_Group; C_Name : Glib.Signal_Name; Handler : Cb_GObject_UTF8_String_Void; After : Boolean; Slot : access Glib.Object.GObject_Record'Class := null); procedure Connect_Slot (Object : Gaction_Group; C_Name : Glib.Signal_Name; Handler : Cb_GObject_UTF8_String_Boolean_Void; After : Boolean; Slot : access Glib.Object.GObject_Record'Class := null); procedure Connect_Slot (Object : Gaction_Group; C_Name : Glib.Signal_Name; Handler : Cb_GObject_UTF8_String_Gvariant_Void; After : Boolean; Slot : access Glib.Object.GObject_Record'Class := null); procedure Marsh_GObject_UTF8_String_Boolean_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address); pragma Convention (C, Marsh_GObject_UTF8_String_Boolean_Void); procedure Marsh_GObject_UTF8_String_Gvariant_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address); pragma Convention (C, Marsh_GObject_UTF8_String_Gvariant_Void); procedure Marsh_GObject_UTF8_String_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address); pragma Convention (C, Marsh_GObject_UTF8_String_Void); procedure Marsh_Gaction_Group_UTF8_String_Boolean_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address); pragma Convention (C, Marsh_Gaction_Group_UTF8_String_Boolean_Void); procedure Marsh_Gaction_Group_UTF8_String_Gvariant_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address); pragma Convention (C, Marsh_Gaction_Group_UTF8_String_Gvariant_Void); procedure Marsh_Gaction_Group_UTF8_String_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address); pragma Convention (C, Marsh_Gaction_Group_UTF8_String_Void); ------------- -- Connect -- ------------- procedure Connect (Object : Gaction_Group; C_Name : Glib.Signal_Name; Handler : Cb_Gaction_Group_UTF8_String_Void; After : Boolean) is begin Unchecked_Do_Signal_Connect (Object => Glib.Types.GType_Interface (Object), C_Name => C_Name, Marshaller => Marsh_Gaction_Group_UTF8_String_Void'Access, Handler => Cb_To_Address (Handler),-- Set in the closure After => After); end Connect; ------------- -- Connect -- ------------- procedure Connect (Object : Gaction_Group; C_Name : Glib.Signal_Name; Handler : Cb_Gaction_Group_UTF8_String_Boolean_Void; After : Boolean) is begin Unchecked_Do_Signal_Connect (Object => Glib.Types.GType_Interface (Object), C_Name => C_Name, Marshaller => Marsh_Gaction_Group_UTF8_String_Boolean_Void'Access, Handler => Cb_To_Address (Handler),-- Set in the closure After => After); end Connect; ------------- -- Connect -- ------------- procedure Connect (Object : Gaction_Group; C_Name : Glib.Signal_Name; Handler : Cb_Gaction_Group_UTF8_String_Gvariant_Void; After : Boolean) is begin Unchecked_Do_Signal_Connect (Object => Glib.Types.GType_Interface (Object), C_Name => C_Name, Marshaller => Marsh_Gaction_Group_UTF8_String_Gvariant_Void'Access, Handler => Cb_To_Address (Handler),-- Set in the closure After => After); end Connect; ------------------ -- Connect_Slot -- ------------------ procedure Connect_Slot (Object : Gaction_Group; C_Name : Glib.Signal_Name; Handler : Cb_GObject_UTF8_String_Void; After : Boolean; Slot : access Glib.Object.GObject_Record'Class := null) is begin Unchecked_Do_Signal_Connect (Object => Glib.Types.GType_Interface (Object), C_Name => C_Name, Marshaller => Marsh_GObject_UTF8_String_Void'Access, Handler => Cb_To_Address (Handler),-- Set in the closure Slot_Object => Slot, After => After); end Connect_Slot; ------------------ -- Connect_Slot -- ------------------ procedure Connect_Slot (Object : Gaction_Group; C_Name : Glib.Signal_Name; Handler : Cb_GObject_UTF8_String_Boolean_Void; After : Boolean; Slot : access Glib.Object.GObject_Record'Class := null) is begin Unchecked_Do_Signal_Connect (Object => Glib.Types.GType_Interface (Object), C_Name => C_Name, Marshaller => Marsh_GObject_UTF8_String_Boolean_Void'Access, Handler => Cb_To_Address (Handler),-- Set in the closure Slot_Object => Slot, After => After); end Connect_Slot; ------------------ -- Connect_Slot -- ------------------ procedure Connect_Slot (Object : Gaction_Group; C_Name : Glib.Signal_Name; Handler : Cb_GObject_UTF8_String_Gvariant_Void; After : Boolean; Slot : access Glib.Object.GObject_Record'Class := null) is begin Unchecked_Do_Signal_Connect (Object => Glib.Types.GType_Interface (Object), C_Name => C_Name, Marshaller => Marsh_GObject_UTF8_String_Gvariant_Void'Access, Handler => Cb_To_Address (Handler),-- Set in the closure Slot_Object => Slot, After => After); end Connect_Slot; -------------------------------------------- -- Marsh_GObject_UTF8_String_Boolean_Void -- -------------------------------------------- procedure Marsh_GObject_UTF8_String_Boolean_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address) is pragma Unreferenced (Return_Value, N_Params, Invocation_Hint, User_Data); H : constant Cb_GObject_UTF8_String_Boolean_Void := Address_To_Cb (Get_Callback (Closure)); Obj : constant Glib.Object.GObject := Glib.Object.Convert (Get_Data (Closure)); begin H (Obj, Unchecked_To_UTF8_String (Params, 1), Unchecked_To_Boolean (Params, 2)); exception when E : others => Process_Exception (E); end Marsh_GObject_UTF8_String_Boolean_Void; --------------------------------------------- -- Marsh_GObject_UTF8_String_Gvariant_Void -- --------------------------------------------- procedure Marsh_GObject_UTF8_String_Gvariant_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address) is pragma Unreferenced (Return_Value, N_Params, Invocation_Hint, User_Data); H : constant Cb_GObject_UTF8_String_Gvariant_Void := Address_To_Cb (Get_Callback (Closure)); Obj : constant Glib.Object.GObject := Glib.Object.Convert (Get_Data (Closure)); begin H (Obj, Unchecked_To_UTF8_String (Params, 1), Glib.Variant.From_Object (Unchecked_To_Address (Params, 2))); exception when E : others => Process_Exception (E); end Marsh_GObject_UTF8_String_Gvariant_Void; ------------------------------------ -- Marsh_GObject_UTF8_String_Void -- ------------------------------------ procedure Marsh_GObject_UTF8_String_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address) is pragma Unreferenced (Return_Value, N_Params, Invocation_Hint, User_Data); H : constant Cb_GObject_UTF8_String_Void := Address_To_Cb (Get_Callback (Closure)); Obj : constant Glib.Object.GObject := Glib.Object.Convert (Get_Data (Closure)); begin H (Obj, Unchecked_To_UTF8_String (Params, 1)); exception when E : others => Process_Exception (E); end Marsh_GObject_UTF8_String_Void; -------------------------------------------------- -- Marsh_Gaction_Group_UTF8_String_Boolean_Void -- -------------------------------------------------- procedure Marsh_Gaction_Group_UTF8_String_Boolean_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address) is pragma Unreferenced (Return_Value, N_Params, Invocation_Hint, User_Data); H : constant Cb_Gaction_Group_UTF8_String_Boolean_Void := Address_To_Cb (Get_Callback (Closure)); Obj : constant Gaction_Group := Gaction_Group (Unchecked_To_Interface (Params, 0)); begin H (Obj, Unchecked_To_UTF8_String (Params, 1), Unchecked_To_Boolean (Params, 2)); exception when E : others => Process_Exception (E); end Marsh_Gaction_Group_UTF8_String_Boolean_Void; --------------------------------------------------- -- Marsh_Gaction_Group_UTF8_String_Gvariant_Void -- --------------------------------------------------- procedure Marsh_Gaction_Group_UTF8_String_Gvariant_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address) is pragma Unreferenced (Return_Value, N_Params, Invocation_Hint, User_Data); H : constant Cb_Gaction_Group_UTF8_String_Gvariant_Void := Address_To_Cb (Get_Callback (Closure)); Obj : constant Gaction_Group := Gaction_Group (Unchecked_To_Interface (Params, 0)); begin H (Obj, Unchecked_To_UTF8_String (Params, 1), Glib.Variant.From_Object (Unchecked_To_Address (Params, 2))); exception when E : others => Process_Exception (E); end Marsh_Gaction_Group_UTF8_String_Gvariant_Void; ------------------------------------------ -- Marsh_Gaction_Group_UTF8_String_Void -- ------------------------------------------ procedure Marsh_Gaction_Group_UTF8_String_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address) is pragma Unreferenced (Return_Value, N_Params, Invocation_Hint, User_Data); H : constant Cb_Gaction_Group_UTF8_String_Void := Address_To_Cb (Get_Callback (Closure)); Obj : constant Gaction_Group := Gaction_Group (Unchecked_To_Interface (Params, 0)); begin H (Obj, Unchecked_To_UTF8_String (Params, 1)); exception when E : others => Process_Exception (E); end Marsh_Gaction_Group_UTF8_String_Void; --------------------- -- On_Action_Added -- --------------------- procedure On_Action_Added (Self : Gaction_Group; Call : Cb_Gaction_Group_UTF8_String_Void; After : Boolean := False) is begin Connect (Self, "action-added" & ASCII.NUL, Call, After); end On_Action_Added; --------------------- -- On_Action_Added -- --------------------- procedure On_Action_Added (Self : Gaction_Group; Call : Cb_GObject_UTF8_String_Void; Slot : not null access Glib.Object.GObject_Record'Class; After : Boolean := False) is begin Connect_Slot (Self, "action-added" & ASCII.NUL, Call, After, Slot); end On_Action_Added; ------------------------------- -- On_Action_Enabled_Changed -- ------------------------------- procedure On_Action_Enabled_Changed (Self : Gaction_Group; Call : Cb_Gaction_Group_UTF8_String_Boolean_Void; After : Boolean := False) is begin Connect (Self, "action-enabled-changed" & ASCII.NUL, Call, After); end On_Action_Enabled_Changed; ------------------------------- -- On_Action_Enabled_Changed -- ------------------------------- procedure On_Action_Enabled_Changed (Self : Gaction_Group; Call : Cb_GObject_UTF8_String_Boolean_Void; Slot : not null access Glib.Object.GObject_Record'Class; After : Boolean := False) is begin Connect_Slot (Self, "action-enabled-changed" & ASCII.NUL, Call, After, Slot); end On_Action_Enabled_Changed; ----------------------- -- On_Action_Removed -- ----------------------- procedure On_Action_Removed (Self : Gaction_Group; Call : Cb_Gaction_Group_UTF8_String_Void; After : Boolean := False) is begin Connect (Self, "action-removed" & ASCII.NUL, Call, After); end On_Action_Removed; ----------------------- -- On_Action_Removed -- ----------------------- procedure On_Action_Removed (Self : Gaction_Group; Call : Cb_GObject_UTF8_String_Void; Slot : not null access Glib.Object.GObject_Record'Class; After : Boolean := False) is begin Connect_Slot (Self, "action-removed" & ASCII.NUL, Call, After, Slot); end On_Action_Removed; ----------------------------- -- On_Action_State_Changed -- ----------------------------- procedure On_Action_State_Changed (Self : Gaction_Group; Call : Cb_Gaction_Group_UTF8_String_Gvariant_Void; After : Boolean := False) is begin Connect (Self, "action-state-changed" & ASCII.NUL, Call, After); end On_Action_State_Changed; ----------------------------- -- On_Action_State_Changed -- ----------------------------- procedure On_Action_State_Changed (Self : Gaction_Group; Call : Cb_GObject_UTF8_String_Gvariant_Void; Slot : not null access Glib.Object.GObject_Record'Class; After : Boolean := False) is begin Connect_Slot (Self, "action-state-changed" & ASCII.NUL, Call, After, Slot); end On_Action_State_Changed; function "+" (W : Gaction_Group) return Gaction_Group is begin return W; end "+"; end Glib.Action_Group; gtkada-24.0.0/src/generated/glib-action_group.ads000066400000000000000000001002351446021174000216520ustar00rootroot00000000000000------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ -- -- Glib.Action_Group.Gaction_Group represents a group of actions. Actions can -- be used to expose functionality in a structured way, either from one part -- of a program to another, or to the outside world. Action groups are often -- used together with a Glib.Menu_Model.Gmenu_Model that provides additional -- representation data for displaying the actions to the user, e.g. in a menu. -- -- The main way to interact with the actions in a GActionGroup is to activate -- them with Glib.Action_Group.Activate_Action. Activating an action may -- require a Glib.Variant.Gvariant parameter. The required type of the -- parameter can be inquired with Glib.Action_Group.Get_Action_Parameter_Type. -- Actions may be disabled, see Glib.Action_Group.Get_Action_Enabled. -- Activating a disabled action has no effect. -- -- Actions may optionally have a state in the form of a -- Glib.Variant.Gvariant. The current state of an action can be inquired with -- Glib.Action_Group.Get_Action_State. Activating a stateful action may change -- its state, but it is also possible to set the state by calling -- Glib.Action_Group.Change_Action_State. -- -- As typical example, consider a text editing application which has an -- option to change the current font to 'bold'. A good way to represent this -- would be a stateful action, with a boolean state. Activating the action -- would toggle the state. -- -- Each action in the group has a unique name (which is a string). All method -- calls, except Glib.Action_Group.List_Actions take the name of an action as -- an argument. -- -- The Glib.Action_Group.Gaction_Group API is meant to be the 'public' API to -- the action group. The calls here are exactly the interaction that 'external -- forces' (eg: UI, incoming D-Bus messages, etc.) are supposed to have with -- actions. 'Internal' APIs (ie: ones meant only to be accessed by the action -- group implementation) are found on subclasses. This is why you will find - -- for example - Glib.Action_Group.Get_Action_Enabled but not an equivalent -- set call. -- -- Signals are emitted on the action group in response to state changes on -- individual actions. -- -- Implementations of Glib.Action_Group.Gaction_Group should provide -- implementations for the virtual functions Glib.Action_Group.List_Actions -- and Glib.Action_Group.Query_Action. The other virtual functions should not -- be implemented - their "wrappers" are actually implemented with calls to -- Glib.Action_Group.Query_Action. -- -- pragma Warnings (Off, "*is already use-visible*"); with GNAT.Strings; use GNAT.Strings; with Glib.Object; use Glib.Object; with Glib.Types; use Glib.Types; with Glib.Variant; use Glib.Variant; pragma Warnings(Off); -- might be unused with Gtkada.Bindings; use Gtkada.Bindings; with Gtkada.Types; use Gtkada.Types; pragma Warnings(On); package Glib.Action_Group is type Gaction_Group is new Glib.Types.GType_Interface; Null_Gaction_Group : constant Gaction_Group; ------------------ -- Constructors -- ------------------ function Get_Type return Glib.GType; pragma Import (C, Get_Type, "g_action_group_get_type"); ------------- -- Methods -- ------------- procedure Action_Added (Self : Gaction_Group; Action_Name : UTF8_String); -- Emits the Glib.Action_Group.Gaction_Group::action-added signal on -- Action_Group. -- This function should only be called by Glib.Action_Group.Gaction_Group -- implementations. -- Since: gtk+ 2.28 -- "action_name": the name of an action in the group procedure Action_Enabled_Changed (Self : Gaction_Group; Action_Name : UTF8_String; Enabled : Boolean); -- Emits the Glib.Action_Group.Gaction_Group::action-enabled-changed -- signal on Action_Group. -- This function should only be called by Glib.Action_Group.Gaction_Group -- implementations. -- Since: gtk+ 2.28 -- "action_name": the name of an action in the group -- "enabled": whether or not the action is now enabled procedure Action_Removed (Self : Gaction_Group; Action_Name : UTF8_String); -- Emits the Glib.Action_Group.Gaction_Group::action-removed signal on -- Action_Group. -- This function should only be called by Glib.Action_Group.Gaction_Group -- implementations. -- Since: gtk+ 2.28 -- "action_name": the name of an action in the group procedure Action_State_Changed (Self : Gaction_Group; Action_Name : UTF8_String; State : Glib.Variant.Gvariant); -- Emits the Glib.Action_Group.Gaction_Group::action-state-changed signal -- on Action_Group. -- This function should only be called by Glib.Action_Group.Gaction_Group -- implementations. -- Since: gtk+ 2.28 -- "action_name": the name of an action in the group -- "state": the new state of the named action procedure Activate_Action (Self : Gaction_Group; Action_Name : UTF8_String; Parameter : Glib.Variant.Gvariant); -- Activate the named action within Action_Group. -- If the action is expecting a parameter, then the correct type of -- parameter must be given as Parameter. If the action is expecting no -- parameters then Parameter must be null. See -- Glib.Action_Group.Get_Action_Parameter_Type. -- Since: gtk+ 2.28 -- "action_name": the name of the action to activate -- "parameter": parameters to the activation procedure Change_Action_State (Self : Gaction_Group; Action_Name : UTF8_String; Value : Glib.Variant.Gvariant); -- Request for the state of the named action within Action_Group to be -- changed to Value. -- The action must be stateful and Value must be of the correct type. See -- Glib.Action_Group.Get_Action_State_Type. -- This call merely requests a change. The action may refuse to change its -- state or may change its state to something other than Value. See -- Glib.Action_Group.Get_Action_State_Hint. -- If the Value GVariant is floating, it is consumed. -- Since: gtk+ 2.28 -- "action_name": the name of the action to request the change on -- "value": the new state function Get_Action_Enabled (Self : Gaction_Group; Action_Name : UTF8_String) return Boolean; -- Checks if the named action within Action_Group is currently enabled. -- An action must be enabled in order to be activated or in order to have -- its state changed from outside callers. -- Since: gtk+ 2.28 -- "action_name": the name of the action to query function Get_Action_Parameter_Type (Self : Gaction_Group; Action_Name : UTF8_String) return Glib.Variant.Gvariant_Type; -- Queries the type of the parameter that must be given when activating -- the named action within Action_Group. -- When activating the action using Glib.Action_Group.Activate_Action, the -- Glib.Variant.Gvariant given to that function must be of the type -- returned by this function. -- In the case that this function returns null, you must not give any -- Glib.Variant.Gvariant, but null instead. -- The parameter type of a particular action will never change but it is -- possible for an action to be removed and for a new action to be added -- with the same name but a different parameter type. -- Since: gtk+ 2.28 -- "action_name": the name of the action to query function Get_Action_State (Self : Gaction_Group; Action_Name : UTF8_String) return Glib.Variant.Gvariant; -- Queries the current state of the named action within Action_Group. -- If the action is not stateful then null will be returned. If the action -- is stateful then the type of the return value is the type given by -- Glib.Action_Group.Get_Action_State_Type. -- The return value (if non-null) should be freed with Glib.Variant.Unref -- when it is no longer required. -- Since: gtk+ 2.28 -- "action_name": the name of the action to query function Get_Action_State_Hint (Self : Gaction_Group; Action_Name : UTF8_String) return Glib.Variant.Gvariant; -- Requests a hint about the valid range of values for the state of the -- named action within Action_Group. -- If null is returned it either means that the action is not stateful or -- that there is no hint about the valid range of values for the state of -- the action. -- If a Glib.Variant.Gvariant array is returned then each item in the -- array is a possible value for the state. If a Glib.Variant.Gvariant pair -- (ie: two-tuple) is returned then the tuple specifies the inclusive lower -- and upper bound of valid values for the state. -- In any case, the information is merely a hint. It may be possible to -- have a state value outside of the hinted range and setting a value -- within the range may fail. -- The return value (if non-null) should be freed with Glib.Variant.Unref -- when it is no longer required. -- Since: gtk+ 2.28 -- "action_name": the name of the action to query function Get_Action_State_Type (Self : Gaction_Group; Action_Name : UTF8_String) return Glib.Variant.Gvariant_Type; -- Queries the type of the state of the named action within Action_Group. -- If the action is stateful then this function returns the -- Glib.Variant.Gvariant_Type of the state. All calls to -- Glib.Action_Group.Change_Action_State must give a Glib.Variant.Gvariant -- of this type and Glib.Action_Group.Get_Action_State will return a -- Glib.Variant.Gvariant of the same type. -- If the action is not stateful then this function will return null. In -- that case, Glib.Action_Group.Get_Action_State will return null and you -- must not call Glib.Action_Group.Change_Action_State. -- The state type of a particular action will never change but it is -- possible for an action to be removed and for a new action to be added -- with the same name but a different state type. -- Since: gtk+ 2.28 -- "action_name": the name of the action to query function Has_Action (Self : Gaction_Group; Action_Name : UTF8_String) return Boolean; -- Checks if the named action exists within Action_Group. -- Since: gtk+ 2.28 -- "action_name": the name of the action to check for function List_Actions (Self : Gaction_Group) return GNAT.Strings.String_List; -- Lists the actions contained within Action_Group. -- The caller is responsible for freeing the list with g_strfreev when it -- is no longer required. -- Since: gtk+ 2.28 function Query_Action (Self : Gaction_Group; Action_Name : UTF8_String; Enabled : access Boolean; Parameter_Type : access Glib.Variant.Gvariant_Type; State_Type : access Glib.Variant.Gvariant_Type; State_Hint : access Glib.Variant.Gvariant; State : access Glib.Variant.Gvariant) return Boolean; -- Queries all aspects of the named action within an Action_Group. -- This function acquires the information available from -- Glib.Action_Group.Has_Action, Glib.Action_Group.Get_Action_Enabled, -- Glib.Action_Group.Get_Action_Parameter_Type, -- Glib.Action_Group.Get_Action_State_Type, -- Glib.Action_Group.Get_Action_State_Hint and -- Glib.Action_Group.Get_Action_State with a single function call. -- This provides two main benefits. -- The first is the improvement in efficiency that comes with not having -- to perform repeated lookups of the action in order to discover different -- things about it. The second is that implementing -- Glib.Action_Group.Gaction_Group can now be done by only overriding this -- one virtual function. -- The interface provides a default implementation of this function that -- calls the individual functions, as required, to fetch the information. -- The interface also provides default implementations of those functions -- that call this function. All implementations, therefore, must override -- either this function or all of the others. -- If the action exists, True is returned and any of the requested fields -- (as indicated by having a non-null reference passed in) are filled. If -- the action doesn't exist, False is returned and the fields may or may -- not have been modified. -- Since: gtk+ 2.32 -- "action_name": the name of an action in the group -- "enabled": if the action is presently enabled -- "parameter_type": the parameter type, or null if none needed -- "state_type": the state type, or null if stateless -- "state_hint": the state hint, or null if none -- "state": the current state, or null if stateless ------------- -- Signals -- ------------- type Cb_Gaction_Group_UTF8_String_Void is not null access procedure (Self : Gaction_Group; Action_Name : UTF8_String); type Cb_GObject_UTF8_String_Void is not null access procedure (Self : access Glib.Object.GObject_Record'Class; Action_Name : UTF8_String); Signal_Action_Added : constant Glib.Signal_Name := "action-added"; procedure On_Action_Added (Self : Gaction_Group; Call : Cb_Gaction_Group_UTF8_String_Void; After : Boolean := False); procedure On_Action_Added (Self : Gaction_Group; Call : Cb_GObject_UTF8_String_Void; Slot : not null access Glib.Object.GObject_Record'Class; After : Boolean := False); -- Signals that a new action was just added to the group. This signal is -- emitted after the action has been added and is now visible. type Cb_Gaction_Group_UTF8_String_Boolean_Void is not null access procedure (Self : Gaction_Group; Action_Name : UTF8_String; Enabled : Boolean); type Cb_GObject_UTF8_String_Boolean_Void is not null access procedure (Self : access Glib.Object.GObject_Record'Class; Action_Name : UTF8_String; Enabled : Boolean); Signal_Action_Enabled_Changed : constant Glib.Signal_Name := "action-enabled-changed"; procedure On_Action_Enabled_Changed (Self : Gaction_Group; Call : Cb_Gaction_Group_UTF8_String_Boolean_Void; After : Boolean := False); procedure On_Action_Enabled_Changed (Self : Gaction_Group; Call : Cb_GObject_UTF8_String_Boolean_Void; Slot : not null access Glib.Object.GObject_Record'Class; After : Boolean := False); -- Signals that the enabled status of the named action has changed. -- -- Callback parameters: -- -- "action_name": the name of the action in Action_Group -- -- "enabled": whether the action is enabled or not Signal_Action_Removed : constant Glib.Signal_Name := "action-removed"; procedure On_Action_Removed (Self : Gaction_Group; Call : Cb_Gaction_Group_UTF8_String_Void; After : Boolean := False); procedure On_Action_Removed (Self : Gaction_Group; Call : Cb_GObject_UTF8_String_Void; Slot : not null access Glib.Object.GObject_Record'Class; After : Boolean := False); -- Signals that an action is just about to be removed from the group. This -- signal is emitted before the action is removed, so the action is still -- visible and can be queried from the signal handler. type Cb_Gaction_Group_UTF8_String_Gvariant_Void is not null access procedure (Self : Gaction_Group; Action_Name : UTF8_String; Value : Glib.Variant.Gvariant); type Cb_GObject_UTF8_String_Gvariant_Void is not null access procedure (Self : access Glib.Object.GObject_Record'Class; Action_Name : UTF8_String; Value : Glib.Variant.Gvariant); Signal_Action_State_Changed : constant Glib.Signal_Name := "action-state-changed"; procedure On_Action_State_Changed (Self : Gaction_Group; Call : Cb_Gaction_Group_UTF8_String_Gvariant_Void; After : Boolean := False); procedure On_Action_State_Changed (Self : Gaction_Group; Call : Cb_GObject_UTF8_String_Gvariant_Void; Slot : not null access Glib.Object.GObject_Record'Class; After : Boolean := False); -- Signals that the state of the named action has changed. -- -- Callback parameters: -- -- "action_name": the name of the action in Action_Group -- -- "value": the new value of the state ---------------- -- Interfaces -- ---------------- -- This class implements several interfaces. See Glib.Types -- -- - "Gaction_Group" function "+" (W : Gaction_Group) return Gaction_Group; pragma Inline ("+"); --------------------- -- Virtual Methods -- --------------------- type Virtual_Action_Added is access procedure (Self : Gaction_Group; Action_Name : Gtkada.Types.Chars_Ptr); pragma Convention (C, Virtual_Action_Added); -- Emits the Glib.Action_Group.Gaction_Group::action-added signal on -- Action_Group. -- This function should only be called by Glib.Action_Group.Gaction_Group -- implementations. -- Since: gtk+ 2.28 -- "action_name": the name of an action in the group type Virtual_Action_Enabled_Changed is access procedure (Self : Gaction_Group; Action_Name : Gtkada.Types.Chars_Ptr; Enabled : Glib.Gboolean); pragma Convention (C, Virtual_Action_Enabled_Changed); -- Emits the Glib.Action_Group.Gaction_Group::action-enabled-changed -- signal on Action_Group. -- This function should only be called by Glib.Action_Group.Gaction_Group -- implementations. -- Since: gtk+ 2.28 -- "action_name": the name of an action in the group -- "enabled": whether or not the action is now enabled type Virtual_Action_Removed is access procedure (Self : Gaction_Group; Action_Name : Gtkada.Types.Chars_Ptr); pragma Convention (C, Virtual_Action_Removed); -- Emits the Glib.Action_Group.Gaction_Group::action-removed signal on -- Action_Group. -- This function should only be called by Glib.Action_Group.Gaction_Group -- implementations. -- Since: gtk+ 2.28 -- "action_name": the name of an action in the group type Virtual_Action_State_Changed is access procedure (Self : Gaction_Group; Action_Name : Gtkada.Types.Chars_Ptr; State : System.Address); pragma Convention (C, Virtual_Action_State_Changed); -- Emits the Glib.Action_Group.Gaction_Group::action-state-changed signal -- on Action_Group. -- This function should only be called by Glib.Action_Group.Gaction_Group -- implementations. -- Since: gtk+ 2.28 -- "action_name": the name of an action in the group -- "state": the new state of the named action type Virtual_Activate_Action is access procedure (Self : Gaction_Group; Action_Name : Gtkada.Types.Chars_Ptr; Parameter : System.Address); pragma Convention (C, Virtual_Activate_Action); -- Activate the named action within Action_Group. -- If the action is expecting a parameter, then the correct type of -- parameter must be given as Parameter. If the action is expecting no -- parameters then Parameter must be null. See -- Glib.Action_Group.Get_Action_Parameter_Type. -- Since: gtk+ 2.28 -- "action_name": the name of the action to activate -- "parameter": parameters to the activation type Virtual_Change_Action_State is access procedure (Self : Gaction_Group; Action_Name : Gtkada.Types.Chars_Ptr; Value : System.Address); pragma Convention (C, Virtual_Change_Action_State); -- Request for the state of the named action within Action_Group to be -- changed to Value. -- The action must be stateful and Value must be of the correct type. See -- Glib.Action_Group.Get_Action_State_Type. -- This call merely requests a change. The action may refuse to change its -- state or may change its state to something other than Value. See -- Glib.Action_Group.Get_Action_State_Hint. -- If the Value GVariant is floating, it is consumed. -- Since: gtk+ 2.28 -- "action_name": the name of the action to request the change on -- "value": the new state type Virtual_Get_Action_Enabled is access function (Self : Gaction_Group; Action_Name : Gtkada.Types.Chars_Ptr) return Glib.Gboolean; pragma Convention (C, Virtual_Get_Action_Enabled); -- Checks if the named action within Action_Group is currently enabled. -- An action must be enabled in order to be activated or in order to have -- its state changed from outside callers. -- Since: gtk+ 2.28 -- "action_name": the name of the action to query type Virtual_Get_Action_Parameter_Type is access function (Self : Gaction_Group; Action_Name : Gtkada.Types.Chars_Ptr) return Glib.Variant.Gvariant_Type; pragma Convention (C, Virtual_Get_Action_Parameter_Type); -- Queries the type of the parameter that must be given when activating -- the named action within Action_Group. -- When activating the action using Glib.Action_Group.Activate_Action, the -- Glib.Variant.Gvariant given to that function must be of the type -- returned by this function. -- In the case that this function returns null, you must not give any -- Glib.Variant.Gvariant, but null instead. -- The parameter type of a particular action will never change but it is -- possible for an action to be removed and for a new action to be added -- with the same name but a different parameter type. -- Since: gtk+ 2.28 -- "action_name": the name of the action to query type Virtual_Get_Action_State is access function (Self : Gaction_Group; Action_Name : Gtkada.Types.Chars_Ptr) return System.Address; pragma Convention (C, Virtual_Get_Action_State); -- Queries the current state of the named action within Action_Group. -- If the action is not stateful then null will be returned. If the action -- is stateful then the type of the return value is the type given by -- Glib.Action_Group.Get_Action_State_Type. -- The return value (if non-null) should be freed with g_variant_unref -- when it is no longer required. -- Since: gtk+ 2.28 -- "action_name": the name of the action to query type Virtual_Get_Action_State_Hint is access function (Self : Gaction_Group; Action_Name : Gtkada.Types.Chars_Ptr) return System.Address; pragma Convention (C, Virtual_Get_Action_State_Hint); -- Requests a hint about the valid range of values for the state of the -- named action within Action_Group. -- If null is returned it either means that the action is not stateful or -- that there is no hint about the valid range of values for the state of -- the action. -- If a Glib.Variant.Gvariant array is returned then each item in the -- array is a possible value for the state. If a Glib.Variant.Gvariant pair -- (ie: two-tuple) is returned then the tuple specifies the inclusive lower -- and upper bound of valid values for the state. -- In any case, the information is merely a hint. It may be possible to -- have a state value outside of the hinted range and setting a value -- within the range may fail. -- The return value (if non-null) should be freed with g_variant_unref -- when it is no longer required. -- Since: gtk+ 2.28 -- "action_name": the name of the action to query type Virtual_Get_Action_State_Type is access function (Self : Gaction_Group; Action_Name : Gtkada.Types.Chars_Ptr) return Glib.Variant.Gvariant_Type; pragma Convention (C, Virtual_Get_Action_State_Type); -- Queries the type of the state of the named action within Action_Group. -- If the action is stateful then this function returns the -- Glib.Variant.Gvariant_Type of the state. All calls to -- Glib.Action_Group.Change_Action_State must give a Glib.Variant.Gvariant -- of this type and Glib.Action_Group.Get_Action_State will return a -- Glib.Variant.Gvariant of the same type. -- If the action is not stateful then this function will return null. In -- that case, Glib.Action_Group.Get_Action_State will return null and you -- must not call Glib.Action_Group.Change_Action_State. -- The state type of a particular action will never change but it is -- possible for an action to be removed and for a new action to be added -- with the same name but a different state type. -- Since: gtk+ 2.28 -- "action_name": the name of the action to query type Virtual_Has_Action is access function (Self : Gaction_Group; Action_Name : Gtkada.Types.Chars_Ptr) return Glib.Gboolean; pragma Convention (C, Virtual_Has_Action); -- Checks if the named action exists within Action_Group. -- Since: gtk+ 2.28 -- "action_name": the name of the action to check for type Virtual_List_Actions is access function (Self : Gaction_Group) return chars_ptr_array_access; pragma Convention (C, Virtual_List_Actions); -- Lists the actions contained within Action_Group. -- The caller is responsible for freeing the list with g_strfreev when it -- is no longer required. -- Since: gtk+ 2.28 type Virtual_Query_Action is access function (Self : Gaction_Group; Action_Name : Gtkada.Types.Chars_Ptr; Enabled : access Glib.Gboolean; Parameter_Type : access Glib.Variant.Gvariant_Type; State_Type : access Glib.Variant.Gvariant_Type; State_Hint : access System.Address; State : access System.Address) return Glib.Gboolean; pragma Convention (C, Virtual_Query_Action); -- Queries all aspects of the named action within an Action_Group. -- This function acquires the information available from -- Glib.Action_Group.Has_Action, Glib.Action_Group.Get_Action_Enabled, -- Glib.Action_Group.Get_Action_Parameter_Type, -- Glib.Action_Group.Get_Action_State_Type, -- Glib.Action_Group.Get_Action_State_Hint and -- Glib.Action_Group.Get_Action_State with a single function call. -- This provides two main benefits. -- The first is the improvement in efficiency that comes with not having -- to perform repeated lookups of the action in order to discover different -- things about it. The second is that implementing -- Glib.Action_Group.Gaction_Group can now be done by only overriding this -- one virtual function. -- The interface provides a default implementation of this function that -- calls the individual functions, as required, to fetch the information. -- The interface also provides default implementations of those functions -- that call this function. All implementations, therefore, must override -- either this function or all of the others. -- If the action exists, True is returned and any of the requested fields -- (as indicated by having a non-null reference passed in) are filled. If -- the action doesn't exist, False is returned and the fields may or may -- not have been modified. -- Since: gtk+ 2.32 -- "action_name": the name of an action in the group -- "enabled": if the action is presently enabled -- "parameter_type": the parameter type, or null if none needed -- "state_type": the state type, or null if stateless -- "state_hint": the state hint, or null if none -- "state": the current state, or null if stateless subtype Action_Group_Interface_Descr is Glib.Object.Interface_Description; procedure Set_Action_Added (Self : Action_Group_Interface_Descr; Handler : Virtual_Action_Added); pragma Import (C, Set_Action_Added, "gtkada_Action_Group_set_action_added"); procedure Set_Action_Enabled_Changed (Self : Action_Group_Interface_Descr; Handler : Virtual_Action_Enabled_Changed); pragma Import (C, Set_Action_Enabled_Changed, "gtkada_Action_Group_set_action_enabled_changed"); procedure Set_Action_Removed (Self : Action_Group_Interface_Descr; Handler : Virtual_Action_Removed); pragma Import (C, Set_Action_Removed, "gtkada_Action_Group_set_action_removed"); procedure Set_Action_State_Changed (Self : Action_Group_Interface_Descr; Handler : Virtual_Action_State_Changed); pragma Import (C, Set_Action_State_Changed, "gtkada_Action_Group_set_action_state_changed"); procedure Set_Activate_Action (Self : Action_Group_Interface_Descr; Handler : Virtual_Activate_Action); pragma Import (C, Set_Activate_Action, "gtkada_Action_Group_set_activate_action"); procedure Set_Change_Action_State (Self : Action_Group_Interface_Descr; Handler : Virtual_Change_Action_State); pragma Import (C, Set_Change_Action_State, "gtkada_Action_Group_set_change_action_state"); procedure Set_Get_Action_Enabled (Self : Action_Group_Interface_Descr; Handler : Virtual_Get_Action_Enabled); pragma Import (C, Set_Get_Action_Enabled, "gtkada_Action_Group_set_get_action_enabled"); procedure Set_Get_Action_Parameter_Type (Self : Action_Group_Interface_Descr; Handler : Virtual_Get_Action_Parameter_Type); pragma Import (C, Set_Get_Action_Parameter_Type, "gtkada_Action_Group_set_get_action_parameter_type"); procedure Set_Get_Action_State (Self : Action_Group_Interface_Descr; Handler : Virtual_Get_Action_State); pragma Import (C, Set_Get_Action_State, "gtkada_Action_Group_set_get_action_state"); procedure Set_Get_Action_State_Hint (Self : Action_Group_Interface_Descr; Handler : Virtual_Get_Action_State_Hint); pragma Import (C, Set_Get_Action_State_Hint, "gtkada_Action_Group_set_get_action_state_hint"); procedure Set_Get_Action_State_Type (Self : Action_Group_Interface_Descr; Handler : Virtual_Get_Action_State_Type); pragma Import (C, Set_Get_Action_State_Type, "gtkada_Action_Group_set_get_action_state_type"); procedure Set_Has_Action (Self : Action_Group_Interface_Descr; Handler : Virtual_Has_Action); pragma Import (C, Set_Has_Action, "gtkada_Action_Group_set_has_action"); procedure Set_List_Actions (Self : Action_Group_Interface_Descr; Handler : Virtual_List_Actions); pragma Import (C, Set_List_Actions, "gtkada_Action_Group_set_list_actions"); procedure Set_Query_Action (Self : Action_Group_Interface_Descr; Handler : Virtual_Query_Action); pragma Import (C, Set_Query_Action, "gtkada_Action_Group_set_query_action"); -- See Glib.Object.Add_Interface private Null_Gaction_Group : constant Gaction_Group := Gaction_Group (Glib.Types.Null_Interface); end Glib.Action_Group; gtkada-24.0.0/src/generated/glib-action_map.adb000066400000000000000000000114611446021174000212540ustar00rootroot00000000000000------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ pragma Style_Checks (Off); pragma Warnings (Off, "*is already use-visible*"); with Ada.Unchecked_Conversion; package body Glib.Action_Map is function From_Object_Free (B : access GAction_Entry) return GAction_Entry is Result : constant GAction_Entry := B.all; begin Glib.g_free (B.all'Address); return Result; end From_Object_Free; function Convert is new Ada.Unchecked_Conversion (Activate_Callback, System.Address); function Convert is new Ada.Unchecked_Conversion (Change_State_Callback, System.Address); function Build (Name : String; Activate : Activate_Callback := null; Parameter_Type : String := ""; State : String := ""; Change_State : Change_State_Callback := null) return GAction_Entry is P, S : chars_ptr := null_ptr; begin if Parameter_Type /= "" then P := New_String (Parameter_Type); end if; if State /= "" then S := New_String (State); end if; return GAction_Entry' (Name => New_String (Name), Activate => Convert (Activate), Parameter_Type => P, State => S, Change_State => Convert (Change_State), Padding => <>); end Build; ------------------------ -- Add_Action_Entries -- ------------------------ procedure Add_Action_Entries (Self : Gaction_Map; Entries : GAction_Entry_Array; User_Data : System.Address := System.Null_Address) is procedure Internal (Self : Gaction_Map; Entries : GAction_Entry_Array; N_Entries : Glib.Gint; User_Data : System.Address); pragma Import (C, Internal, "g_action_map_add_action_entries"); begin Internal (Self, Entries, Entries'Length, User_Data); end Add_Action_Entries; ------------------- -- Lookup_Action -- ------------------- function Lookup_Action (Self : Gaction_Map; Action_Name : UTF8_String) return Glib.Action.Gaction is function Internal (Self : Gaction_Map; Action_Name : Gtkada.Types.Chars_Ptr) return Glib.Action.Gaction; pragma Import (C, Internal, "g_action_map_lookup_action"); Tmp_Action_Name : Gtkada.Types.Chars_Ptr := New_String (Action_Name); Tmp_Return : Glib.Action.Gaction; begin Tmp_Return := Internal (Self, Tmp_Action_Name); Free (Tmp_Action_Name); return Tmp_Return; end Lookup_Action; ------------------- -- Remove_Action -- ------------------- procedure Remove_Action (Self : Gaction_Map; Action_Name : UTF8_String) is procedure Internal (Self : Gaction_Map; Action_Name : Gtkada.Types.Chars_Ptr); pragma Import (C, Internal, "g_action_map_remove_action"); Tmp_Action_Name : Gtkada.Types.Chars_Ptr := New_String (Action_Name); begin Internal (Self, Tmp_Action_Name); Free (Tmp_Action_Name); end Remove_Action; function "+" (W : Gaction_Map) return Gaction_Map is begin return W; end "+"; end Glib.Action_Map; gtkada-24.0.0/src/generated/glib-action_map.ads000066400000000000000000000236161446021174000213020ustar00rootroot00000000000000------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ -- -- The GActionMap interface is implemented by Glib.Action_Group.Gaction_Group -- implementations that operate by containing a number of named -- Glib.Action.Gaction instances, such as -- Glib.Simple_Action_Group.Gsimple_Action_Group. -- -- One useful application of this interface is to map the names of actions -- from various action groups to unique, prefixed names (e.g. by prepending -- "app." or "win."). This is the motivation for the 'Map' part of the -- interface name. -- -- pragma Warnings (Off, "*is already use-visible*"); with Glib.Action; use Glib.Action; with Glib.Object; use Glib.Object; with Glib.Simple_Action; use Glib.Simple_Action; with Glib.Types; use Glib.Types; with Glib.Variant; use Glib.Variant; pragma Warnings(Off); -- might be unused with Gtkada.Types; use Gtkada.Types; pragma Warnings(On); package Glib.Action_Map is type Gaction_Map is new Glib.Types.GType_Interface; Null_Gaction_Map : constant Gaction_Map; type GAction_Entry is private; function From_Object_Free (B : access GAction_Entry) return GAction_Entry; pragma Inline (From_Object_Free); -- This struct defines a single action. It is for use with -- Glib.Action_Map.Add_Action_Entries. -- -- The order of the items in the structure are intended to reflect -- frequency of use. It is permissible to use an incomplete initialiser in -- order to leave some of the later values as null. All values after Name -- are optional. Additional optional fields may be added in the future. -- -- See Glib.Action_Map.Add_Action_Entries for an example. type GAction_Entry_Array is array (Natural range <>) of GAction_Entry; ------------------ -- Constructors -- ------------------ function Get_Type return Glib.GType; pragma Import (C, Get_Type, "g_action_map_get_type"); ------------- -- Methods -- ------------- procedure Add_Action (Self : Gaction_Map; Action : Glib.Action.Gaction); pragma Import (C, Add_Action, "g_action_map_add_action"); -- Adds an action to the Action_Map. -- If the action map already contains an action with the same name as -- Action then the old action is dropped from the action map. -- The action map takes its own reference on Action. -- Since: gtk+ 2.32 -- "action": a Glib.Action.Gaction procedure Add_Action_Entries (Self : Gaction_Map; Entries : GAction_Entry_Array; User_Data : System.Address := System.Null_Address); -- A convenience function for creating multiple -- Glib.Simple_Action.Gsimple_Action instances and adding them to a -- Glib.Action_Map.Gaction_Map. -- Each action is constructed as per one Glib.Action_Map.GAction_Entry. -- |[ static void activate_quit (GSimpleAction -- *simple, GVariant *parameter, gpointer user_data) { exit (0); } -- static void activate_print_string (GSimpleAction *simple, GVariant -- *parameter, gpointer user_data) { g_print ("%s\n", g_variant_get_string -- (parameter, NULL)); } -- static GActionGroup * create_action_group (void) { const GActionEntry -- entries[] = { { "quit", activate_quit }, { "print-string", -- activate_print_string, "s" } }; GSimpleActionGroup *group; -- group = g_simple_action_group_new (); g_action_map_add_action_entries -- (G_ACTION_MAP (group), entries, G_N_ELEMENTS (entries), NULL); -- return G_ACTION_GROUP (group); } ]| -- Since: gtk+ 2.32 -- "entries": a pointer to the first item in an array of -- Glib.Action_Map.GAction_Entry structs -- "user_data": the user data for signal connections function Lookup_Action (Self : Gaction_Map; Action_Name : UTF8_String) return Glib.Action.Gaction; -- Looks up the action with the name Action_Name in Action_Map. -- If no such action exists, returns null. -- Since: gtk+ 2.32 -- "action_name": the name of an action procedure Remove_Action (Self : Gaction_Map; Action_Name : UTF8_String); -- Removes the named action from the action map. -- If no action of this name is in the map then nothing happens. -- Since: gtk+ 2.32 -- "action_name": the name of the action ---------------------- -- GtkAda additions -- ---------------------- type Activate_Callback is access procedure (Action : access Glib.Simple_Action.Gsimple_Action; Parameter : Glib.Variant.Gvariant; Data : System.Address); pragma Convention (C, Activate_Callback); type Change_State_Callback is access procedure (Action : access Glib.Simple_Action.Gsimple_Action; Parameter : Glib.Variant.Gvariant; Data : System.Address); pragma Convention (C, Change_State_Callback); function Build (Name : String; Activate : Activate_Callback := null; Parameter_Type : String := ""; State : String := ""; Change_State : Change_State_Callback := null) return GAction_Entry; -- Return a newly allocation action entry. -- This will be freed by the the action_map when needed. -- -- Name is the name of the action. -- Activate is the callback to connect to the "activate" signal of -- the action. -- Parameter_Type is the type of the parameter that must be passed -- to the activate function for this action, given as a single -- Gvariant (or the empty string for no parameter). -- State is the initial state of this action, given in Gvariant -- text format. The state is parsed with no extra type information -- so type tags must be added to the string if they are necessary. -- Change_State is the callback for the "change-state" signal. ---------------- -- Interfaces -- ---------------- -- This class implements several interfaces. See Glib.Types -- -- - "Gaction_Map" function "+" (W : Gaction_Map) return Gaction_Map; pragma Inline ("+"); --------------------- -- Virtual Methods -- --------------------- type Virtual_Add_Action is access procedure (Self : Gaction_Map; Action : Glib.Action.Gaction); pragma Convention (C, Virtual_Add_Action); -- Adds an action to the Action_Map. -- If the action map already contains an action with the same name as -- Action then the old action is dropped from the action map. -- The action map takes its own reference on Action. -- Since: gtk+ 2.32 -- "action": a Glib.Action.Gaction type Virtual_Lookup_Action is access function (Self : Gaction_Map; Action_Name : Gtkada.Types.Chars_Ptr) return Glib.Action.Gaction; pragma Convention (C, Virtual_Lookup_Action); -- Looks up the action with the name Action_Name in Action_Map. -- If no such action exists, returns null. -- Since: gtk+ 2.32 -- "action_name": the name of an action type Virtual_Remove_Action is access procedure (Self : Gaction_Map; Action_Name : Gtkada.Types.Chars_Ptr); pragma Convention (C, Virtual_Remove_Action); -- Removes the named action from the action map. -- If no action of this name is in the map then nothing happens. -- Since: gtk+ 2.32 -- "action_name": the name of the action subtype Action_Map_Interface_Descr is Glib.Object.Interface_Description; procedure Set_Add_Action (Self : Action_Map_Interface_Descr; Handler : Virtual_Add_Action); pragma Import (C, Set_Add_Action, "gtkada_Action_Map_set_add_action"); procedure Set_Lookup_Action (Self : Action_Map_Interface_Descr; Handler : Virtual_Lookup_Action); pragma Import (C, Set_Lookup_Action, "gtkada_Action_Map_set_lookup_action"); procedure Set_Remove_Action (Self : Action_Map_Interface_Descr; Handler : Virtual_Remove_Action); pragma Import (C, Set_Remove_Action, "gtkada_Action_Map_set_remove_action"); -- See Glib.Object.Add_Interface private type GAction_Entry is record Name : Gtkada.Types.Chars_Ptr; Activate : System.Address; Parameter_Type : Gtkada.Types.Chars_Ptr; State : Gtkada.Types.Chars_Ptr; Change_State : System.Address; Padding : array_of_gsize (1 .. 3); end record; pragma Convention (C, GAction_Entry); Null_Gaction_Map : constant Gaction_Map := Gaction_Map (Glib.Types.Null_Interface); end Glib.Action_Map; gtkada-24.0.0/src/generated/glib-application.adb000066400000000000000000001531321446021174000214470ustar00rootroot00000000000000------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ pragma Style_Checks (Off); pragma Warnings (Off, "*is already use-visible*"); with Ada.Unchecked_Conversion; with Glib.Type_Conversion_Hooks; use Glib.Type_Conversion_Hooks; with Glib.Values; use Glib.Values; with Gtk.Arguments; use Gtk.Arguments; pragma Warnings(Off); -- might be unused with Gtkada.Types; use Gtkada.Types; pragma Warnings(On); package body Glib.Application is -------------- -- Register -- -------------- function Register (Self : not null access Gapplication_Record; Cancellable : access Glib.Cancellable.Gcancellable_Record'Class) return Boolean is function Internal (Self : System.Address; Cancellable : System.Address; Error : System.Address) return Glib.Gboolean; pragma Import (C, Internal, "g_application_register"); begin return Internal (Get_Object (Self), Get_Object_Or_Null (GObject (Cancellable)), System.Null_Address) /= 0; end Register; gnat_argc : Interfaces.C.int; pragma Import (C, gnat_argc); gnat_argv : System.Address; pragma Import (C, gnat_argv); function Run (Self : not null access Gapplication_Record) return Gint is function Internal (Self : System.Address; Argc : Gint; Argv : System.Address) return Gint; pragma Import (C, Internal, "g_application_run"); begin return Internal (Self.Get_Object, Gint (gnat_argc), gnat_argv); end Run; package Type_Conversion_Gapplication is new Glib.Type_Conversion_Hooks.Hook_Registrator (Get_Type'Access, Gapplication_Record); pragma Unreferenced (Type_Conversion_Gapplication); package Type_Conversion_Gapplication_Command_Line is new Glib.Type_Conversion_Hooks.Hook_Registrator (Get_Type_Command_Line'Access, Gapplication_Command_Line_Record); pragma Unreferenced (Type_Conversion_Gapplication_Command_Line); ----------- -- G_New -- ----------- procedure G_New (Self : out Gapplication; Application_Id : UTF8_String := ""; Flags : GApplication_Flags) is begin Self := new Gapplication_Record; Glib.Application.Initialize (Self, Application_Id, Flags); end G_New; ---------------------- -- Gapplication_New -- ---------------------- function Gapplication_New (Application_Id : UTF8_String := ""; Flags : GApplication_Flags) return Gapplication is Self : constant Gapplication := new Gapplication_Record; begin Glib.Application.Initialize (Self, Application_Id, Flags); return Self; end Gapplication_New; ---------------- -- Initialize -- ---------------- procedure Initialize (Self : not null access Gapplication_Record'Class; Application_Id : UTF8_String := ""; Flags : GApplication_Flags) is function Internal (Application_Id : Gtkada.Types.Chars_Ptr; Flags : GApplication_Flags) return System.Address; pragma Import (C, Internal, "g_application_new"); Tmp_Application_Id : Gtkada.Types.Chars_Ptr; Tmp_Return : System.Address; begin if not Self.Is_Created then if Application_Id = "" then Tmp_Application_Id := Gtkada.Types.Null_Ptr; else Tmp_Application_Id := New_String (Application_Id); end if; Tmp_Return := Internal (Tmp_Application_Id, Flags); Free (Tmp_Application_Id); Set_Object (Self, Tmp_Return); end if; end Initialize; -------------- -- Activate -- -------------- procedure Activate (Self : not null access Gapplication_Record) is procedure Internal (Self : System.Address); pragma Import (C, Internal, "g_application_activate"); begin Internal (Get_Object (Self)); end Activate; ------------------------ -- Bind_Busy_Property -- ------------------------ procedure Bind_Busy_Property (Self : not null access Gapplication_Record; Object : System.Address; Property : UTF8_String) is procedure Internal (Self : System.Address; Object : System.Address; Property : Gtkada.Types.Chars_Ptr); pragma Import (C, Internal, "g_application_bind_busy_property"); Tmp_Property : Gtkada.Types.Chars_Ptr := New_String (Property); begin Internal (Get_Object (Self), Object, Tmp_Property); Free (Tmp_Property); end Bind_Busy_Property; ------------------------ -- Get_Application_Id -- ------------------------ function Get_Application_Id (Self : not null access Gapplication_Record) return UTF8_String is function Internal (Self : System.Address) return Gtkada.Types.Chars_Ptr; pragma Import (C, Internal, "g_application_get_application_id"); begin return Gtkada.Bindings.Value_Allowing_Null (Internal (Get_Object (Self))); end Get_Application_Id; ------------------- -- Get_Arguments -- ------------------- function Get_Arguments (Self : not null access Gapplication_Command_Line_Record) return GNAT.Strings.String_List is function Internal (Self : System.Address; Argc : access Glib.Gint) return chars_ptr_array_access; pragma Import (C, Internal, "g_application_command_line_get_arguments"); begin return To_String_List_And_Free (Internal (Get_Object (Self), null)); end Get_Arguments; ------------- -- Get_Cwd -- ------------- function Get_Cwd (Self : not null access Gapplication_Command_Line_Record) return UTF8_String is function Internal (Self : System.Address) return Gtkada.Types.Chars_Ptr; pragma Import (C, Internal, "g_application_command_line_get_cwd"); begin return Gtkada.Bindings.Value_Allowing_Null (Internal (Get_Object (Self))); end Get_Cwd; -------------------------- -- Get_Dbus_Object_Path -- -------------------------- function Get_Dbus_Object_Path (Self : not null access Gapplication_Record) return UTF8_String is function Internal (Self : System.Address) return Gtkada.Types.Chars_Ptr; pragma Import (C, Internal, "g_application_get_dbus_object_path"); begin return Gtkada.Bindings.Value_Allowing_Null (Internal (Get_Object (Self))); end Get_Dbus_Object_Path; ----------------- -- Get_Environ -- ----------------- function Get_Environ (Self : not null access Gapplication_Command_Line_Record) return GNAT.Strings.String_List is function Internal (Self : System.Address) return chars_ptr_array_access; pragma Import (C, Internal, "g_application_command_line_get_environ"); begin return To_String_List (Internal (Get_Object (Self)).all); end Get_Environ; --------------------- -- Get_Exit_Status -- --------------------- function Get_Exit_Status (Self : not null access Gapplication_Command_Line_Record) return Glib.Gint is function Internal (Self : System.Address) return Glib.Gint; pragma Import (C, Internal, "g_application_command_line_get_exit_status"); begin return Internal (Get_Object (Self)); end Get_Exit_Status; --------------- -- Get_Flags -- --------------- function Get_Flags (Self : not null access Gapplication_Record) return GApplication_Flags is function Internal (Self : System.Address) return GApplication_Flags; pragma Import (C, Internal, "g_application_get_flags"); begin return Internal (Get_Object (Self)); end Get_Flags; ---------------------------- -- Get_Inactivity_Timeout -- ---------------------------- function Get_Inactivity_Timeout (Self : not null access Gapplication_Record) return Guint is function Internal (Self : System.Address) return Guint; pragma Import (C, Internal, "g_application_get_inactivity_timeout"); begin return Internal (Get_Object (Self)); end Get_Inactivity_Timeout; ----------------- -- Get_Is_Busy -- ----------------- function Get_Is_Busy (Self : not null access Gapplication_Record) return Boolean is function Internal (Self : System.Address) return Glib.Gboolean; pragma Import (C, Internal, "g_application_get_is_busy"); begin return Internal (Get_Object (Self)) /= 0; end Get_Is_Busy; ----------------------- -- Get_Is_Registered -- ----------------------- function Get_Is_Registered (Self : not null access Gapplication_Record) return Boolean is function Internal (Self : System.Address) return Glib.Gboolean; pragma Import (C, Internal, "g_application_get_is_registered"); begin return Internal (Get_Object (Self)) /= 0; end Get_Is_Registered; ------------------- -- Get_Is_Remote -- ------------------- function Get_Is_Remote (Self : not null access Gapplication_Record) return Boolean is function Internal (Self : System.Address) return Glib.Gboolean; pragma Import (C, Internal, "g_application_get_is_remote"); begin return Internal (Get_Object (Self)) /= 0; end Get_Is_Remote; ------------------- -- Get_Is_Remote -- ------------------- function Get_Is_Remote (Self : not null access Gapplication_Command_Line_Record) return Boolean is function Internal (Self : System.Address) return Glib.Gboolean; pragma Import (C, Internal, "g_application_command_line_get_is_remote"); begin return Internal (Get_Object (Self)) /= 0; end Get_Is_Remote; ----------------------- -- Get_Platform_Data -- ----------------------- function Get_Platform_Data (Self : not null access Gapplication_Command_Line_Record) return Glib.Variant.Gvariant is function Internal (Self : System.Address) return System.Address; pragma Import (C, Internal, "g_application_command_line_get_platform_data"); begin return From_Object (Internal (Get_Object (Self))); end Get_Platform_Data; ---------------------------- -- Get_Resource_Base_Path -- ---------------------------- function Get_Resource_Base_Path (Self : not null access Gapplication_Record) return UTF8_String is function Internal (Self : System.Address) return Gtkada.Types.Chars_Ptr; pragma Import (C, Internal, "g_application_get_resource_base_path"); begin return Gtkada.Bindings.Value_Allowing_Null (Internal (Get_Object (Self))); end Get_Resource_Base_Path; ------------ -- Getenv -- ------------ function Getenv (Self : not null access Gapplication_Command_Line_Record; Name : UTF8_String) return UTF8_String is function Internal (Self : System.Address; Name : Gtkada.Types.Chars_Ptr) return Gtkada.Types.Chars_Ptr; pragma Import (C, Internal, "g_application_command_line_getenv"); Tmp_Name : Gtkada.Types.Chars_Ptr := New_String (Name); Tmp_Return : Gtkada.Types.Chars_Ptr; begin Tmp_Return := Internal (Get_Object (Self), Tmp_Name); Free (Tmp_Name); return Gtkada.Bindings.Value_Allowing_Null (Tmp_Return); end Getenv; ---------- -- Hold -- ---------- procedure Hold (Self : not null access Gapplication_Record) is procedure Internal (Self : System.Address); pragma Import (C, Internal, "g_application_hold"); begin Internal (Get_Object (Self)); end Hold; --------------- -- Mark_Busy -- --------------- procedure Mark_Busy (Self : not null access Gapplication_Record) is procedure Internal (Self : System.Address); pragma Import (C, Internal, "g_application_mark_busy"); begin Internal (Get_Object (Self)); end Mark_Busy; ---------- -- Quit -- ---------- procedure Quit (Self : not null access Gapplication_Record) is procedure Internal (Self : System.Address); pragma Import (C, Internal, "g_application_quit"); begin Internal (Get_Object (Self)); end Quit; ------------- -- Release -- ------------- procedure Release (Self : not null access Gapplication_Record) is procedure Internal (Self : System.Address); pragma Import (C, Internal, "g_application_release"); begin Internal (Get_Object (Self)); end Release; --------- -- Run -- --------- function Run (Self : not null access Gapplication_Record; Argc : Glib.Gint; Argv : GNAT.Strings.String_List) return Glib.Gint is function Internal (Self : System.Address; Argc : Glib.Gint; Argv : Gtkada.Types.chars_ptr_array) return Glib.Gint; pragma Import (C, Internal, "g_application_run"); Tmp_Argv : Gtkada.Types.chars_ptr_array := From_String_List (Argv); Tmp_Return : Glib.Gint; begin Tmp_Return := Internal (Get_Object (Self), Argc, Tmp_Argv); Gtkada.Types.Free (Tmp_Argv); return Tmp_Return; end Run; ----------------------- -- Send_Notification -- ----------------------- procedure Send_Notification (Self : not null access Gapplication_Record; Id : UTF8_String := ""; Notification : not null access Glib.Notification.Gnotification_Record'Class) is procedure Internal (Self : System.Address; Id : Gtkada.Types.Chars_Ptr; Notification : System.Address); pragma Import (C, Internal, "g_application_send_notification"); Tmp_Id : Gtkada.Types.Chars_Ptr; begin if Id = "" then Tmp_Id := Gtkada.Types.Null_Ptr; else Tmp_Id := New_String (Id); end if; Internal (Get_Object (Self), Tmp_Id, Get_Object (Notification)); Free (Tmp_Id); end Send_Notification; ---------------------- -- Set_Action_Group -- ---------------------- procedure Set_Action_Group (Self : not null access Gapplication_Record; Action_Group : Glib.Action_Group.Gaction_Group) is procedure Internal (Self : System.Address; Action_Group : Glib.Action_Group.Gaction_Group); pragma Import (C, Internal, "g_application_set_action_group"); begin Internal (Get_Object (Self), Action_Group); end Set_Action_Group; ------------------------ -- Set_Application_Id -- ------------------------ procedure Set_Application_Id (Self : not null access Gapplication_Record; Application_Id : UTF8_String := "") is procedure Internal (Self : System.Address; Application_Id : Gtkada.Types.Chars_Ptr); pragma Import (C, Internal, "g_application_set_application_id"); Tmp_Application_Id : Gtkada.Types.Chars_Ptr; begin if Application_Id = "" then Tmp_Application_Id := Gtkada.Types.Null_Ptr; else Tmp_Application_Id := New_String (Application_Id); end if; Internal (Get_Object (Self), Tmp_Application_Id); Free (Tmp_Application_Id); end Set_Application_Id; ----------------- -- Set_Default -- ----------------- procedure Set_Default (Self : not null access Gapplication_Record) is procedure Internal (Self : System.Address); pragma Import (C, Internal, "g_application_set_default"); begin Internal (Get_Object (Self)); end Set_Default; --------------------- -- Set_Exit_Status -- --------------------- procedure Set_Exit_Status (Self : not null access Gapplication_Command_Line_Record; Exit_Status : Glib.Gint) is procedure Internal (Self : System.Address; Exit_Status : Glib.Gint); pragma Import (C, Internal, "g_application_command_line_set_exit_status"); begin Internal (Get_Object (Self), Exit_Status); end Set_Exit_Status; --------------- -- Set_Flags -- --------------- procedure Set_Flags (Self : not null access Gapplication_Record; Flags : GApplication_Flags) is procedure Internal (Self : System.Address; Flags : GApplication_Flags); pragma Import (C, Internal, "g_application_set_flags"); begin Internal (Get_Object (Self), Flags); end Set_Flags; ---------------------------- -- Set_Inactivity_Timeout -- ---------------------------- procedure Set_Inactivity_Timeout (Self : not null access Gapplication_Record; Inactivity_Timeout : Guint) is procedure Internal (Self : System.Address; Inactivity_Timeout : Guint); pragma Import (C, Internal, "g_application_set_inactivity_timeout"); begin Internal (Get_Object (Self), Inactivity_Timeout); end Set_Inactivity_Timeout; ------------------------------------ -- Set_Option_Context_Description -- ------------------------------------ procedure Set_Option_Context_Description (Self : not null access Gapplication_Record; Description : UTF8_String := "") is procedure Internal (Self : System.Address; Description : Gtkada.Types.Chars_Ptr); pragma Import (C, Internal, "g_application_set_option_context_description"); Tmp_Description : Gtkada.Types.Chars_Ptr; begin if Description = "" then Tmp_Description := Gtkada.Types.Null_Ptr; else Tmp_Description := New_String (Description); end if; Internal (Get_Object (Self), Tmp_Description); Free (Tmp_Description); end Set_Option_Context_Description; ----------------------------------------- -- Set_Option_Context_Parameter_String -- ----------------------------------------- procedure Set_Option_Context_Parameter_String (Self : not null access Gapplication_Record; Parameter_String : UTF8_String := "") is procedure Internal (Self : System.Address; Parameter_String : Gtkada.Types.Chars_Ptr); pragma Import (C, Internal, "g_application_set_option_context_parameter_string"); Tmp_Parameter_String : Gtkada.Types.Chars_Ptr; begin if Parameter_String = "" then Tmp_Parameter_String := Gtkada.Types.Null_Ptr; else Tmp_Parameter_String := New_String (Parameter_String); end if; Internal (Get_Object (Self), Tmp_Parameter_String); Free (Tmp_Parameter_String); end Set_Option_Context_Parameter_String; -------------------------------- -- Set_Option_Context_Summary -- -------------------------------- procedure Set_Option_Context_Summary (Self : not null access Gapplication_Record; Summary : UTF8_String := "") is procedure Internal (Self : System.Address; Summary : Gtkada.Types.Chars_Ptr); pragma Import (C, Internal, "g_application_set_option_context_summary"); Tmp_Summary : Gtkada.Types.Chars_Ptr; begin if Summary = "" then Tmp_Summary := Gtkada.Types.Null_Ptr; else Tmp_Summary := New_String (Summary); end if; Internal (Get_Object (Self), Tmp_Summary); Free (Tmp_Summary); end Set_Option_Context_Summary; ---------------------------- -- Set_Resource_Base_Path -- ---------------------------- procedure Set_Resource_Base_Path (Self : not null access Gapplication_Record; Resource_Path : UTF8_String := "") is procedure Internal (Self : System.Address; Resource_Path : Gtkada.Types.Chars_Ptr); pragma Import (C, Internal, "g_application_set_resource_base_path"); Tmp_Resource_Path : Gtkada.Types.Chars_Ptr; begin if Resource_Path = "" then Tmp_Resource_Path := Gtkada.Types.Null_Ptr; else Tmp_Resource_Path := New_String (Resource_Path); end if; Internal (Get_Object (Self), Tmp_Resource_Path); Free (Tmp_Resource_Path); end Set_Resource_Base_Path; -------------------------- -- Unbind_Busy_Property -- -------------------------- procedure Unbind_Busy_Property (Self : not null access Gapplication_Record; Object : System.Address; Property : UTF8_String) is procedure Internal (Self : System.Address; Object : System.Address; Property : Gtkada.Types.Chars_Ptr); pragma Import (C, Internal, "g_application_unbind_busy_property"); Tmp_Property : Gtkada.Types.Chars_Ptr := New_String (Property); begin Internal (Get_Object (Self), Object, Tmp_Property); Free (Tmp_Property); end Unbind_Busy_Property; ----------------- -- Unmark_Busy -- ----------------- procedure Unmark_Busy (Self : not null access Gapplication_Record) is procedure Internal (Self : System.Address); pragma Import (C, Internal, "g_application_unmark_busy"); begin Internal (Get_Object (Self)); end Unmark_Busy; --------------------------- -- Withdraw_Notification -- --------------------------- procedure Withdraw_Notification (Self : not null access Gapplication_Record; Id : UTF8_String) is procedure Internal (Self : System.Address; Id : Gtkada.Types.Chars_Ptr); pragma Import (C, Internal, "g_application_withdraw_notification"); Tmp_Id : Gtkada.Types.Chars_Ptr := New_String (Id); begin Internal (Get_Object (Self), Tmp_Id); Free (Tmp_Id); end Withdraw_Notification; ------------------ -- Action_Added -- ------------------ procedure Action_Added (Self : not null access Gapplication_Record; Action_Name : UTF8_String) is procedure Internal (Self : System.Address; Action_Name : Gtkada.Types.Chars_Ptr); pragma Import (C, Internal, "g_action_group_action_added"); Tmp_Action_Name : Gtkada.Types.Chars_Ptr := New_String (Action_Name); begin Internal (Get_Object (Self), Tmp_Action_Name); Free (Tmp_Action_Name); end Action_Added; ---------------------------- -- Action_Enabled_Changed -- ---------------------------- procedure Action_Enabled_Changed (Self : not null access Gapplication_Record; Action_Name : UTF8_String; Enabled : Boolean) is procedure Internal (Self : System.Address; Action_Name : Gtkada.Types.Chars_Ptr; Enabled : Glib.Gboolean); pragma Import (C, Internal, "g_action_group_action_enabled_changed"); Tmp_Action_Name : Gtkada.Types.Chars_Ptr := New_String (Action_Name); begin Internal (Get_Object (Self), Tmp_Action_Name, Boolean'Pos (Enabled)); Free (Tmp_Action_Name); end Action_Enabled_Changed; -------------------- -- Action_Removed -- -------------------- procedure Action_Removed (Self : not null access Gapplication_Record; Action_Name : UTF8_String) is procedure Internal (Self : System.Address; Action_Name : Gtkada.Types.Chars_Ptr); pragma Import (C, Internal, "g_action_group_action_removed"); Tmp_Action_Name : Gtkada.Types.Chars_Ptr := New_String (Action_Name); begin Internal (Get_Object (Self), Tmp_Action_Name); Free (Tmp_Action_Name); end Action_Removed; -------------------------- -- Action_State_Changed -- -------------------------- procedure Action_State_Changed (Self : not null access Gapplication_Record; Action_Name : UTF8_String; State : Glib.Variant.Gvariant) is procedure Internal (Self : System.Address; Action_Name : Gtkada.Types.Chars_Ptr; State : System.Address); pragma Import (C, Internal, "g_action_group_action_state_changed"); Tmp_Action_Name : Gtkada.Types.Chars_Ptr := New_String (Action_Name); begin Internal (Get_Object (Self), Tmp_Action_Name, Get_Object (State)); Free (Tmp_Action_Name); end Action_State_Changed; --------------------- -- Activate_Action -- --------------------- procedure Activate_Action (Self : not null access Gapplication_Record; Action_Name : UTF8_String; Parameter : Glib.Variant.Gvariant) is procedure Internal (Self : System.Address; Action_Name : Gtkada.Types.Chars_Ptr; Parameter : System.Address); pragma Import (C, Internal, "g_action_group_activate_action"); Tmp_Action_Name : Gtkada.Types.Chars_Ptr := New_String (Action_Name); begin Internal (Get_Object (Self), Tmp_Action_Name, Get_Object (Parameter)); Free (Tmp_Action_Name); end Activate_Action; ---------------- -- Add_Action -- ---------------- procedure Add_Action (Self : not null access Gapplication_Record; Action : Glib.Action.Gaction) is procedure Internal (Self : System.Address; Action : Glib.Action.Gaction); pragma Import (C, Internal, "g_action_map_add_action"); begin Internal (Get_Object (Self), Action); end Add_Action; ------------------------ -- Add_Action_Entries -- ------------------------ procedure Add_Action_Entries (Self : not null access Gapplication_Record; Entries : GAction_Entry_Array; User_Data : System.Address := System.Null_Address) is procedure Internal (Self : System.Address; Entries : GAction_Entry_Array; N_Entries : Glib.Gint; User_Data : System.Address); pragma Import (C, Internal, "g_action_map_add_action_entries"); begin Internal (Get_Object (Self), Entries, Entries'Length, User_Data); end Add_Action_Entries; ------------------------- -- Change_Action_State -- ------------------------- procedure Change_Action_State (Self : not null access Gapplication_Record; Action_Name : UTF8_String; Value : Glib.Variant.Gvariant) is procedure Internal (Self : System.Address; Action_Name : Gtkada.Types.Chars_Ptr; Value : System.Address); pragma Import (C, Internal, "g_action_group_change_action_state"); Tmp_Action_Name : Gtkada.Types.Chars_Ptr := New_String (Action_Name); begin Internal (Get_Object (Self), Tmp_Action_Name, Get_Object (Value)); Free (Tmp_Action_Name); end Change_Action_State; ------------------------ -- Get_Action_Enabled -- ------------------------ function Get_Action_Enabled (Self : not null access Gapplication_Record; Action_Name : UTF8_String) return Boolean is function Internal (Self : System.Address; Action_Name : Gtkada.Types.Chars_Ptr) return Glib.Gboolean; pragma Import (C, Internal, "g_action_group_get_action_enabled"); Tmp_Action_Name : Gtkada.Types.Chars_Ptr := New_String (Action_Name); Tmp_Return : Glib.Gboolean; begin Tmp_Return := Internal (Get_Object (Self), Tmp_Action_Name); Free (Tmp_Action_Name); return Tmp_Return /= 0; end Get_Action_Enabled; ------------------------------- -- Get_Action_Parameter_Type -- ------------------------------- function Get_Action_Parameter_Type (Self : not null access Gapplication_Record; Action_Name : UTF8_String) return Glib.Variant.Gvariant_Type is function Internal (Self : System.Address; Action_Name : Gtkada.Types.Chars_Ptr) return Glib.Variant.Gvariant_Type; pragma Import (C, Internal, "g_action_group_get_action_parameter_type"); Tmp_Action_Name : Gtkada.Types.Chars_Ptr := New_String (Action_Name); Tmp_Return : Glib.Variant.Gvariant_Type; begin Tmp_Return := Internal (Get_Object (Self), Tmp_Action_Name); Free (Tmp_Action_Name); return Tmp_Return; end Get_Action_Parameter_Type; ---------------------- -- Get_Action_State -- ---------------------- function Get_Action_State (Self : not null access Gapplication_Record; Action_Name : UTF8_String) return Glib.Variant.Gvariant is function Internal (Self : System.Address; Action_Name : Gtkada.Types.Chars_Ptr) return System.Address; pragma Import (C, Internal, "g_action_group_get_action_state"); Tmp_Action_Name : Gtkada.Types.Chars_Ptr := New_String (Action_Name); Tmp_Return : System.Address; begin Tmp_Return := Internal (Get_Object (Self), Tmp_Action_Name); Free (Tmp_Action_Name); return From_Object (Tmp_Return); end Get_Action_State; --------------------------- -- Get_Action_State_Hint -- --------------------------- function Get_Action_State_Hint (Self : not null access Gapplication_Record; Action_Name : UTF8_String) return Glib.Variant.Gvariant is function Internal (Self : System.Address; Action_Name : Gtkada.Types.Chars_Ptr) return System.Address; pragma Import (C, Internal, "g_action_group_get_action_state_hint"); Tmp_Action_Name : Gtkada.Types.Chars_Ptr := New_String (Action_Name); Tmp_Return : System.Address; begin Tmp_Return := Internal (Get_Object (Self), Tmp_Action_Name); Free (Tmp_Action_Name); return From_Object (Tmp_Return); end Get_Action_State_Hint; --------------------------- -- Get_Action_State_Type -- --------------------------- function Get_Action_State_Type (Self : not null access Gapplication_Record; Action_Name : UTF8_String) return Glib.Variant.Gvariant_Type is function Internal (Self : System.Address; Action_Name : Gtkada.Types.Chars_Ptr) return Glib.Variant.Gvariant_Type; pragma Import (C, Internal, "g_action_group_get_action_state_type"); Tmp_Action_Name : Gtkada.Types.Chars_Ptr := New_String (Action_Name); Tmp_Return : Glib.Variant.Gvariant_Type; begin Tmp_Return := Internal (Get_Object (Self), Tmp_Action_Name); Free (Tmp_Action_Name); return Tmp_Return; end Get_Action_State_Type; ---------------- -- Has_Action -- ---------------- function Has_Action (Self : not null access Gapplication_Record; Action_Name : UTF8_String) return Boolean is function Internal (Self : System.Address; Action_Name : Gtkada.Types.Chars_Ptr) return Glib.Gboolean; pragma Import (C, Internal, "g_action_group_has_action"); Tmp_Action_Name : Gtkada.Types.Chars_Ptr := New_String (Action_Name); Tmp_Return : Glib.Gboolean; begin Tmp_Return := Internal (Get_Object (Self), Tmp_Action_Name); Free (Tmp_Action_Name); return Tmp_Return /= 0; end Has_Action; ------------------ -- List_Actions -- ------------------ function List_Actions (Self : not null access Gapplication_Record) return GNAT.Strings.String_List is function Internal (Self : System.Address) return chars_ptr_array_access; pragma Import (C, Internal, "g_action_group_list_actions"); begin return To_String_List_And_Free (Internal (Get_Object (Self))); end List_Actions; ------------------- -- Lookup_Action -- ------------------- function Lookup_Action (Self : not null access Gapplication_Record; Action_Name : UTF8_String) return Glib.Action.Gaction is function Internal (Self : System.Address; Action_Name : Gtkada.Types.Chars_Ptr) return Glib.Action.Gaction; pragma Import (C, Internal, "g_action_map_lookup_action"); Tmp_Action_Name : Gtkada.Types.Chars_Ptr := New_String (Action_Name); Tmp_Return : Glib.Action.Gaction; begin Tmp_Return := Internal (Get_Object (Self), Tmp_Action_Name); Free (Tmp_Action_Name); return Tmp_Return; end Lookup_Action; ------------------ -- Query_Action -- ------------------ function Query_Action (Self : not null access Gapplication_Record; Action_Name : UTF8_String; Enabled : access Boolean; Parameter_Type : access Glib.Variant.Gvariant_Type; State_Type : access Glib.Variant.Gvariant_Type; State_Hint : access Glib.Variant.Gvariant; State : access Glib.Variant.Gvariant) return Boolean is function Internal (Self : System.Address; Action_Name : Gtkada.Types.Chars_Ptr; Acc_Enabled : access Glib.Gboolean; Acc_Parameter_Type : access Glib.Variant.Gvariant_Type; Acc_State_Type : access Glib.Variant.Gvariant_Type; Acc_State_Hint : access System.Address; Acc_State : access System.Address) return Glib.Gboolean; pragma Import (C, Internal, "g_action_group_query_action"); Acc_Enabled : aliased Boolean; Acc_Parameter_Type : aliased Glib.Variant.Gvariant_Type; Acc_State_Type : aliased Glib.Variant.Gvariant_Type; Acc_State_Hint : aliased Glib.Variant.Gvariant; Acc_State : aliased Glib.Variant.Gvariant; Tmp_Action_Name : Gtkada.Types.Chars_Ptr := New_String (Action_Name); Tmp_Acc_Enabled : aliased Glib.Gboolean; Tmp_Acc_State_Hint : aliased System.Address; Tmp_Acc_State : aliased System.Address; Tmp_Return : Glib.Gboolean; begin Tmp_Return := Internal (Get_Object (Self), Tmp_Action_Name, Tmp_Acc_Enabled'Access, Acc_Parameter_Type'Access, Acc_State_Type'Access, Tmp_Acc_State_Hint'Access, Tmp_Acc_State'Access); Acc_State := From_Object (Tmp_Acc_State); Acc_State_Hint := From_Object (Tmp_Acc_State_Hint); Acc_Enabled := Tmp_Acc_Enabled /= 0; Free (Tmp_Action_Name); Enabled.all := Acc_Enabled; if Parameter_Type /= null then Parameter_Type.all := Acc_Parameter_Type; end if; if State_Type /= null then State_Type.all := Acc_State_Type; end if; if State_Hint /= null then State_Hint.all := Acc_State_Hint; end if; if State /= null then State.all := Acc_State; end if; return Tmp_Return /= 0; end Query_Action; ------------------- -- Remove_Action -- ------------------- procedure Remove_Action (Self : not null access Gapplication_Record; Action_Name : UTF8_String) is procedure Internal (Self : System.Address; Action_Name : Gtkada.Types.Chars_Ptr); pragma Import (C, Internal, "g_action_map_remove_action"); Tmp_Action_Name : Gtkada.Types.Chars_Ptr := New_String (Action_Name); begin Internal (Get_Object (Self), Tmp_Action_Name); Free (Tmp_Action_Name); end Remove_Action; ----------------- -- Get_Default -- ----------------- function Get_Default return Gapplication is function Internal return System.Address; pragma Import (C, Internal, "g_application_get_default"); Stub_Gapplication : Gapplication_Record; begin return Glib.Application.Gapplication (Get_User_Data (Internal, Stub_Gapplication)); end Get_Default; ----------------- -- Id_Is_Valid -- ----------------- function Id_Is_Valid (Application_Id : UTF8_String) return Boolean is function Internal (Application_Id : Gtkada.Types.Chars_Ptr) return Glib.Gboolean; pragma Import (C, Internal, "g_application_id_is_valid"); Tmp_Application_Id : Gtkada.Types.Chars_Ptr := New_String (Application_Id); Tmp_Return : Glib.Gboolean; begin Tmp_Return := Internal (Tmp_Application_Id); Free (Tmp_Application_Id); return Tmp_Return /= 0; end Id_Is_Valid; use type System.Address; function Cb_To_Address is new Ada.Unchecked_Conversion (Cb_Gapplication_Void, System.Address); function Address_To_Cb is new Ada.Unchecked_Conversion (System.Address, Cb_Gapplication_Void); function Cb_To_Address is new Ada.Unchecked_Conversion (Cb_GObject_Void, System.Address); function Address_To_Cb is new Ada.Unchecked_Conversion (System.Address, Cb_GObject_Void); function Cb_To_Address is new Ada.Unchecked_Conversion (Cb_Gapplication_Gapplication_Command_Line_Gint, System.Address); function Address_To_Cb is new Ada.Unchecked_Conversion (System.Address, Cb_Gapplication_Gapplication_Command_Line_Gint); function Cb_To_Address is new Ada.Unchecked_Conversion (Cb_GObject_Gapplication_Command_Line_Gint, System.Address); function Address_To_Cb is new Ada.Unchecked_Conversion (System.Address, Cb_GObject_Gapplication_Command_Line_Gint); function Cb_To_Address is new Ada.Unchecked_Conversion (Cb_Gapplication_Boolean, System.Address); function Address_To_Cb is new Ada.Unchecked_Conversion (System.Address, Cb_Gapplication_Boolean); function Cb_To_Address is new Ada.Unchecked_Conversion (Cb_GObject_Boolean, System.Address); function Address_To_Cb is new Ada.Unchecked_Conversion (System.Address, Cb_GObject_Boolean); procedure Connect (Object : access Gapplication_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_Gapplication_Void; After : Boolean); procedure Connect (Object : access Gapplication_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_Gapplication_Gapplication_Command_Line_Gint; After : Boolean); procedure Connect (Object : access Gapplication_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_Gapplication_Boolean; After : Boolean); procedure Connect_Slot (Object : access Gapplication_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_GObject_Void; After : Boolean; Slot : access Glib.Object.GObject_Record'Class := null); procedure Connect_Slot (Object : access Gapplication_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_GObject_Gapplication_Command_Line_Gint; After : Boolean; Slot : access Glib.Object.GObject_Record'Class := null); procedure Connect_Slot (Object : access Gapplication_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_GObject_Boolean; After : Boolean; Slot : access Glib.Object.GObject_Record'Class := null); procedure Marsh_GObject_Boolean (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address); pragma Convention (C, Marsh_GObject_Boolean); procedure Marsh_GObject_Gapplication_Command_Line_Gint (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address); pragma Convention (C, Marsh_GObject_Gapplication_Command_Line_Gint); procedure Marsh_GObject_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address); pragma Convention (C, Marsh_GObject_Void); procedure Marsh_Gapplication_Boolean (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address); pragma Convention (C, Marsh_Gapplication_Boolean); procedure Marsh_Gapplication_Gapplication_Command_Line_Gint (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address); pragma Convention (C, Marsh_Gapplication_Gapplication_Command_Line_Gint); procedure Marsh_Gapplication_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address); pragma Convention (C, Marsh_Gapplication_Void); ------------- -- Connect -- ------------- procedure Connect (Object : access Gapplication_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_Gapplication_Void; After : Boolean) is begin Unchecked_Do_Signal_Connect (Object => Object, C_Name => C_Name, Marshaller => Marsh_Gapplication_Void'Access, Handler => Cb_To_Address (Handler),-- Set in the closure After => After); end Connect; ------------- -- Connect -- ------------- procedure Connect (Object : access Gapplication_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_Gapplication_Gapplication_Command_Line_Gint; After : Boolean) is begin Unchecked_Do_Signal_Connect (Object => Object, C_Name => C_Name, Marshaller => Marsh_Gapplication_Gapplication_Command_Line_Gint'Access, Handler => Cb_To_Address (Handler),-- Set in the closure After => After); end Connect; ------------- -- Connect -- ------------- procedure Connect (Object : access Gapplication_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_Gapplication_Boolean; After : Boolean) is begin Unchecked_Do_Signal_Connect (Object => Object, C_Name => C_Name, Marshaller => Marsh_Gapplication_Boolean'Access, Handler => Cb_To_Address (Handler),-- Set in the closure After => After); end Connect; ------------------ -- Connect_Slot -- ------------------ procedure Connect_Slot (Object : access Gapplication_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_GObject_Void; After : Boolean; Slot : access Glib.Object.GObject_Record'Class := null) is begin Unchecked_Do_Signal_Connect (Object => Object, C_Name => C_Name, Marshaller => Marsh_GObject_Void'Access, Handler => Cb_To_Address (Handler),-- Set in the closure Slot_Object => Slot, After => After); end Connect_Slot; ------------------ -- Connect_Slot -- ------------------ procedure Connect_Slot (Object : access Gapplication_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_GObject_Gapplication_Command_Line_Gint; After : Boolean; Slot : access Glib.Object.GObject_Record'Class := null) is begin Unchecked_Do_Signal_Connect (Object => Object, C_Name => C_Name, Marshaller => Marsh_GObject_Gapplication_Command_Line_Gint'Access, Handler => Cb_To_Address (Handler),-- Set in the closure Slot_Object => Slot, After => After); end Connect_Slot; ------------------ -- Connect_Slot -- ------------------ procedure Connect_Slot (Object : access Gapplication_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_GObject_Boolean; After : Boolean; Slot : access Glib.Object.GObject_Record'Class := null) is begin Unchecked_Do_Signal_Connect (Object => Object, C_Name => C_Name, Marshaller => Marsh_GObject_Boolean'Access, Handler => Cb_To_Address (Handler),-- Set in the closure Slot_Object => Slot, After => After); end Connect_Slot; --------------------------- -- Marsh_GObject_Boolean -- --------------------------- procedure Marsh_GObject_Boolean (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address) is pragma Unreferenced (N_Params, Params, Invocation_Hint, User_Data); H : constant Cb_GObject_Boolean := Address_To_Cb (Get_Callback (Closure)); Obj : constant Glib.Object.GObject := Glib.Object.Convert (Get_Data (Closure)); V : aliased Boolean := H (Obj); begin Set_Value (Return_Value, V'Address); exception when E : others => Process_Exception (E); end Marsh_GObject_Boolean; -------------------------------------------------- -- Marsh_GObject_Gapplication_Command_Line_Gint -- -------------------------------------------------- procedure Marsh_GObject_Gapplication_Command_Line_Gint (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address) is pragma Unreferenced (N_Params, Invocation_Hint, User_Data); H : constant Cb_GObject_Gapplication_Command_Line_Gint := Address_To_Cb (Get_Callback (Closure)); Obj : constant Glib.Object.GObject := Glib.Object.Convert (Get_Data (Closure)); V : aliased Glib.Gint := H (Obj, Glib.Application.Gapplication_Command_Line (Unchecked_To_Object (Params, 1))); begin Set_Value (Return_Value, V'Address); exception when E : others => Process_Exception (E); end Marsh_GObject_Gapplication_Command_Line_Gint; ------------------------ -- Marsh_GObject_Void -- ------------------------ procedure Marsh_GObject_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address) is pragma Unreferenced (Return_Value, N_Params, Params, Invocation_Hint, User_Data); H : constant Cb_GObject_Void := Address_To_Cb (Get_Callback (Closure)); Obj : constant Glib.Object.GObject := Glib.Object.Convert (Get_Data (Closure)); begin H (Obj); exception when E : others => Process_Exception (E); end Marsh_GObject_Void; -------------------------------- -- Marsh_Gapplication_Boolean -- -------------------------------- procedure Marsh_Gapplication_Boolean (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address) is pragma Unreferenced (N_Params, Invocation_Hint, User_Data); H : constant Cb_Gapplication_Boolean := Address_To_Cb (Get_Callback (Closure)); Obj : constant Gapplication := Gapplication (Unchecked_To_Object (Params, 0)); V : aliased Boolean := H (Obj); begin Set_Value (Return_Value, V'Address); exception when E : others => Process_Exception (E); end Marsh_Gapplication_Boolean; ------------------------------------------------------- -- Marsh_Gapplication_Gapplication_Command_Line_Gint -- ------------------------------------------------------- procedure Marsh_Gapplication_Gapplication_Command_Line_Gint (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address) is pragma Unreferenced (N_Params, Invocation_Hint, User_Data); H : constant Cb_Gapplication_Gapplication_Command_Line_Gint := Address_To_Cb (Get_Callback (Closure)); Obj : constant Gapplication := Gapplication (Unchecked_To_Object (Params, 0)); V : aliased Glib.Gint := H (Obj, Glib.Application.Gapplication_Command_Line (Unchecked_To_Object (Params, 1))); begin Set_Value (Return_Value, V'Address); exception when E : others => Process_Exception (E); end Marsh_Gapplication_Gapplication_Command_Line_Gint; ----------------------------- -- Marsh_Gapplication_Void -- ----------------------------- procedure Marsh_Gapplication_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address) is pragma Unreferenced (Return_Value, N_Params, Invocation_Hint, User_Data); H : constant Cb_Gapplication_Void := Address_To_Cb (Get_Callback (Closure)); Obj : constant Gapplication := Gapplication (Unchecked_To_Object (Params, 0)); begin H (Obj); exception when E : others => Process_Exception (E); end Marsh_Gapplication_Void; ----------------- -- On_Activate -- ----------------- procedure On_Activate (Self : not null access Gapplication_Record; Call : Cb_Gapplication_Void; After : Boolean := False) is begin Connect (Self, "activate" & ASCII.NUL, Call, After); end On_Activate; ----------------- -- On_Activate -- ----------------- procedure On_Activate (Self : not null access Gapplication_Record; Call : Cb_GObject_Void; Slot : not null access Glib.Object.GObject_Record'Class; After : Boolean := False) is begin Connect_Slot (Self, "activate" & ASCII.NUL, Call, After, Slot); end On_Activate; --------------------- -- On_Command_Line -- --------------------- procedure On_Command_Line (Self : not null access Gapplication_Record; Call : Cb_Gapplication_Gapplication_Command_Line_Gint; After : Boolean := False) is begin Connect (Self, "command-line" & ASCII.NUL, Call, After); end On_Command_Line; --------------------- -- On_Command_Line -- --------------------- procedure On_Command_Line (Self : not null access Gapplication_Record; Call : Cb_GObject_Gapplication_Command_Line_Gint; Slot : not null access Glib.Object.GObject_Record'Class; After : Boolean := False) is begin Connect_Slot (Self, "command-line" & ASCII.NUL, Call, After, Slot); end On_Command_Line; ------------------ -- On_Name_Lost -- ------------------ procedure On_Name_Lost (Self : not null access Gapplication_Record; Call : Cb_Gapplication_Boolean; After : Boolean := False) is begin Connect (Self, "name-lost" & ASCII.NUL, Call, After); end On_Name_Lost; ------------------ -- On_Name_Lost -- ------------------ procedure On_Name_Lost (Self : not null access Gapplication_Record; Call : Cb_GObject_Boolean; Slot : not null access Glib.Object.GObject_Record'Class; After : Boolean := False) is begin Connect_Slot (Self, "name-lost" & ASCII.NUL, Call, After, Slot); end On_Name_Lost; ----------------- -- On_Shutdown -- ----------------- procedure On_Shutdown (Self : not null access Gapplication_Record; Call : Cb_Gapplication_Void; After : Boolean := False) is begin Connect (Self, "shutdown" & ASCII.NUL, Call, After); end On_Shutdown; ----------------- -- On_Shutdown -- ----------------- procedure On_Shutdown (Self : not null access Gapplication_Record; Call : Cb_GObject_Void; Slot : not null access Glib.Object.GObject_Record'Class; After : Boolean := False) is begin Connect_Slot (Self, "shutdown" & ASCII.NUL, Call, After, Slot); end On_Shutdown; ---------------- -- On_Startup -- ---------------- procedure On_Startup (Self : not null access Gapplication_Record; Call : Cb_Gapplication_Void; After : Boolean := False) is begin Connect (Self, "startup" & ASCII.NUL, Call, After); end On_Startup; ---------------- -- On_Startup -- ---------------- procedure On_Startup (Self : not null access Gapplication_Record; Call : Cb_GObject_Void; Slot : not null access Glib.Object.GObject_Record'Class; After : Boolean := False) is begin Connect_Slot (Self, "startup" & ASCII.NUL, Call, After, Slot); end On_Startup; end Glib.Application; gtkada-24.0.0/src/generated/glib-application.ads000066400000000000000000001634541446021174000215000ustar00rootroot00000000000000------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ -- -- A Glib.Application.Gapplication is the foundation of an application. It -- wraps some low-level platform-specific services and is intended to act as -- the foundation for higher-level application classes such as -- Gtk.Application.Gtk_Application or Mx_Application. In general, you should -- not use this class outside of a higher level framework. -- -- GApplication provides convenient life cycle management by maintaining a -- "use count" for the primary application instance. The use count can be -- changed using Glib.Application.Hold and Glib.Application.Release. If it -- drops to zero, the application exits. Higher-level classes such as -- Gtk.Application.Gtk_Application employ the use count to ensure that the -- application stays alive as long as it has any opened windows. -- -- Another feature that GApplication (optionally) provides is process -- uniqueness. Applications can make use of this functionality by providing a -- unique application ID. If given, only one application with this ID can be -- running at a time per session. The session concept is platform-dependent, -- but corresponds roughly to a graphical desktop login. When your application -- is launched again, its arguments are passed through platform communication -- to the already running program. The already running instance of the program -- is called the "primary instance"; for non-unique applications this is -- always the current instance. On Linux, the D-Bus session bus is used for -- communication. -- -- The use of Glib.Application.Gapplication differs from some other -- commonly-used uniqueness libraries (such as libunique) in important ways. -- The application is not expected to manually register itself and check if it -- is the primary instance. Instead, the main function of a -- Glib.Application.Gapplication should do very little more than instantiating -- the application instance, possibly connecting signal handlers, then calling -- Glib.Application.Run. All checks for uniqueness are done internally. If the -- application is the primary instance then the startup signal is emitted and -- the mainloop runs. If the application is not the primary instance then a -- signal is sent to the primary instance and Glib.Application.Run promptly -- returns. See the code examples below. -- -- If used, the expected form of an application identifier is the same as -- that of of a [D-Bus well-known bus -- name](https://dbus.freedesktop.org/doc/dbus-specification.htmlmessage-protocol-names-bus). -- Examples include: `com.example.MyApp`, -- `org.example.internal_apps.Calculator`, `org._7_zip.Archiver`. For details -- on valid application identifiers, see Glib.Application.Id_Is_Valid. -- -- On Linux, the application identifier is claimed as a well-known bus name -- on the user's session bus. This means that the uniqueness of your -- application is scoped to the current session. It also means that your -- application may provide additional services (through registration of other -- object paths) at that bus name. The registration of these object paths -- should be done with the shared GDBus session bus. Note that due to the -- internal architecture of GDBus, method calls can be dispatched at any time -- (even if a main loop is not running). For this reason, you must ensure that -- any object paths that you wish to register are registered before -- Glib.Application.Gapplication attempts to acquire the bus name of your -- application (which happens in g_application_register). Unfortunately, this -- means that you cannot use Glib.Application.Get_Is_Remote to decide if you -- want to register object paths. -- -- GApplication also implements the Glib.Action_Group.Gaction_Group and -- Glib.Action_Map.Gaction_Map interfaces and lets you easily export actions -- by adding them with Glib.Action_Map.Add_Action. When invoking an action by -- calling Glib.Action_Group.Activate_Action on the application, it is always -- invoked in the primary instance. The actions are also exported on the -- session bus, and GIO provides the Gdbus.Action_Group.Gdbus_Action_Group -- wrapper to conveniently access them remotely. GIO provides a -- Gdbus.Menu_Model.Gdbus_Menu_Model wrapper for remote access to exported -- GMenu_Models. -- -- There is a number of different entry points into a GApplication: -- -- - via 'Activate' (i.e. just starting the application) -- -- - via 'Open' (i.e. opening some files) -- -- - by handling a command-line -- -- - via activating an action -- -- The Glib.Application.Gapplication::startup signal lets you handle the -- application initialization for all of these in a single place. -- -- Regardless of which of these entry points is used to start the -- application, GApplication passes some ‘platform data' from the launching -- instance to the primary instance, in the form of a Glib.Variant.Gvariant -- dictionary mapping strings to variants. To use platform data, override the -- Before_Emit or After_Emit virtual functions in your -- Glib.Application.Gapplication subclass. When dealing with -- Glib.Application.Gapplication_Command_Line objects, the platform data is -- directly available via Glib.Application.Get_Cwd, -- Glib.Application.Get_Environ and Glib.Application.Get_Platform_Data. -- -- As the name indicates, the platform data may vary depending on the -- operating system, but it always includes the current directory (key "cwd"), -- and optionally the environment (ie the set of environment variables and -- their values) of the calling process (key "environ"). The environment is -- only added to the platform data if the -- Glib.Application.G_Application_Send_Environment flag is set. -- Glib.Application.Gapplication subclasses can add their own platform data by -- overriding the Add_Platform_Data virtual function. For instance, -- Gtk.Application.Gtk_Application adds startup notification data in this way. -- -- To parse commandline arguments you may handle the -- Glib.Application.Gapplication::command-line signal or override the -- local_command_line vfunc, to parse them in either the primary instance or -- the local instance, respectively. -- -- For an example of opening files with a GApplication, see -- [gapplication-example-open.c](https://git.gnome.org/browse/glib/tree/gio/tests/gapplication-example-open.c). -- -- For an example of using actions with GApplication, see -- [gapplication-example-actions.c](https://git.gnome.org/browse/glib/tree/gio/tests/gapplication-example-actions.c). -- -- For an example of using extra D-Bus hooks with GApplication, see -- [gapplication-example-dbushooks.c](https://git.gnome.org/browse/glib/tree/gio/tests/gapplication-example-dbushooks.c). -- -- pragma Warnings (Off, "*is already use-visible*"); with GNAT.Strings; use GNAT.Strings; with Glib.Action; use Glib.Action; with Glib.Action_Group; use Glib.Action_Group; with Glib.Action_Map; use Glib.Action_Map; with Glib.Cancellable; use Glib.Cancellable; with Glib.Generic_Properties; use Glib.Generic_Properties; with Glib.Notification; use Glib.Notification; with Glib.Object; use Glib.Object; with Glib.Properties; use Glib.Properties; with Glib.Types; use Glib.Types; with Glib.Variant; use Glib.Variant; with Gtkada.Bindings; use Gtkada.Bindings; package Glib.Application is type Gapplication_Record is new GObject_Record with null record; type Gapplication is access all Gapplication_Record'Class; type GApplication_Flags is mod 2 ** Integer'Size; pragma Convention (C, GApplication_Flags); -- Flags used to define the behaviour of a Glib.Application.Gapplication. G_Application_Flags_None : constant GApplication_Flags := 0; G_Application_Is_Service : constant GApplication_Flags := 1; G_Application_Is_Launcher : constant GApplication_Flags := 2; G_Application_Handles_Open : constant GApplication_Flags := 4; G_Application_Handles_Command_Line : constant GApplication_Flags := 8; G_Application_Send_Environment : constant GApplication_Flags := 16; G_Application_Non_Unique : constant GApplication_Flags := 32; G_Application_Can_Override_App_Id : constant GApplication_Flags := 64; G_Application_Allow_Replacement : constant GApplication_Flags := 128; G_Application_Replace : constant GApplication_Flags := 256; type Gapplication_Command_Line_Record is new GObject_Record with null record; type Gapplication_Command_Line is access all Gapplication_Command_Line_Record'Class; ---------------------------- -- Enumeration Properties -- ---------------------------- package GApplication_Flags_Properties is new Generic_Internal_Discrete_Property (GApplication_Flags); type Property_GApplication_Flags is new GApplication_Flags_Properties.Property; ------------------ -- Constructors -- ------------------ procedure G_New (Self : out Gapplication; Application_Id : UTF8_String := ""; Flags : GApplication_Flags); -- Creates a new Glib.Application.Gapplication instance. -- If non-null, the application id must be valid. See -- Glib.Application.Id_Is_Valid. -- If no application ID is given then some features of -- Glib.Application.Gapplication (most notably application uniqueness) will -- be disabled. -- "application_id": the application id -- "flags": the application flags procedure Initialize (Self : not null access Gapplication_Record'Class; Application_Id : UTF8_String := ""; Flags : GApplication_Flags); -- Creates a new Glib.Application.Gapplication instance. -- If non-null, the application id must be valid. See -- Glib.Application.Id_Is_Valid. -- If no application ID is given then some features of -- Glib.Application.Gapplication (most notably application uniqueness) will -- be disabled. -- Initialize does nothing if the object was already created with another -- call to Initialize* or G_New. -- "application_id": the application id -- "flags": the application flags function Gapplication_New (Application_Id : UTF8_String := ""; Flags : GApplication_Flags) return Gapplication; -- Creates a new Glib.Application.Gapplication instance. -- If non-null, the application id must be valid. See -- Glib.Application.Id_Is_Valid. -- If no application ID is given then some features of -- Glib.Application.Gapplication (most notably application uniqueness) will -- be disabled. -- "application_id": the application id -- "flags": the application flags function Get_Type return Glib.GType; pragma Import (C, Get_Type, "g_application_get_type"); function Get_Type_Command_Line return Glib.GType; pragma Import (C, Get_Type_Command_Line, "g_application_command_line_get_type"); ------------- -- Methods -- ------------- procedure Activate (Self : not null access Gapplication_Record); -- Activates the application. -- In essence, this results in the Glib.Application.Gapplication::activate -- signal being emitted in the primary instance. -- The application must be registered before calling this function. -- Since: gtk+ 2.28 procedure Bind_Busy_Property (Self : not null access Gapplication_Record; Object : System.Address; Property : UTF8_String); -- Marks Application as busy (see Glib.Application.Mark_Busy) while -- Property on Object is True. -- The binding holds a reference to Application while it is active, but -- not to Object. Instead, the binding is destroyed when Object is -- finalized. -- Since: gtk+ 2.44 -- "object": a Glib.Object.GObject -- "property": the name of a boolean property of Object function Get_Application_Id (Self : not null access Gapplication_Record) return UTF8_String; -- Gets the unique identifier for Application. -- Since: gtk+ 2.28 procedure Set_Application_Id (Self : not null access Gapplication_Record; Application_Id : UTF8_String := ""); -- Sets the unique identifier for Application. -- The application id can only be modified if Application has not yet been -- registered. -- If non-null, the application id must be valid. See -- Glib.Application.Id_Is_Valid. -- Since: gtk+ 2.28 -- "application_id": the identifier for Application function Get_Dbus_Object_Path (Self : not null access Gapplication_Record) return UTF8_String; -- Gets the D-Bus object path being used by the application, or null. -- If Glib.Application.Gapplication is using its D-Bus backend then this -- function will return the D-Bus object path that -- Glib.Application.Gapplication is using. If the application is the -- primary instance then there is an object published at this path. If the -- application is not the primary instance then the result of this function -- is undefined. -- If Glib.Application.Gapplication is not using D-Bus then this function -- will return null. This includes the situation where the D-Bus backend -- would normally be in use but we were unable to connect to the bus. -- This function must not be called before the application has been -- registered. See Glib.Application.Get_Is_Registered. -- Since: gtk+ 2.34 function Get_Flags (Self : not null access Gapplication_Record) return GApplication_Flags; -- Gets the flags for Application. -- See Glib.Application.GApplication_Flags. -- Since: gtk+ 2.28 procedure Set_Flags (Self : not null access Gapplication_Record; Flags : GApplication_Flags); -- Sets the flags for Application. -- The flags can only be modified if Application has not yet been -- registered. -- See Glib.Application.GApplication_Flags. -- Since: gtk+ 2.28 -- "flags": the flags for Application function Get_Inactivity_Timeout (Self : not null access Gapplication_Record) return Guint; -- Gets the current inactivity timeout for the application. -- This is the amount of time (in milliseconds) after the last call to -- Glib.Application.Release before the application stops running. -- Since: gtk+ 2.28 procedure Set_Inactivity_Timeout (Self : not null access Gapplication_Record; Inactivity_Timeout : Guint); -- Sets the current inactivity timeout for the application. -- This is the amount of time (in milliseconds) after the last call to -- Glib.Application.Release before the application stops running. -- This call has no side effects of its own. The value set here is only -- used for next time Glib.Application.Release drops the use count to zero. -- Any timeouts currently in progress are not impacted. -- Since: gtk+ 2.28 -- "inactivity_timeout": the timeout, in milliseconds function Get_Is_Busy (Self : not null access Gapplication_Record) return Boolean; -- Gets the application's current busy state, as set through -- Glib.Application.Mark_Busy or Glib.Application.Bind_Busy_Property. -- Since: gtk+ 2.44 function Get_Is_Registered (Self : not null access Gapplication_Record) return Boolean; -- Checks if Application is registered. -- An application is registered if g_application_register has been -- successfully called. -- Since: gtk+ 2.28 function Get_Is_Remote (Self : not null access Gapplication_Record) return Boolean; -- Checks if Application is remote. -- If Application is remote then it means that another instance of -- application already exists (the 'primary' instance). Calls to perform -- actions on Application will result in the actions being performed by the -- primary instance. -- The value of this property cannot be accessed before -- g_application_register has been called. See -- Glib.Application.Get_Is_Registered. -- Since: gtk+ 2.28 function Get_Is_Remote (Self : not null access Gapplication_Command_Line_Record) return Boolean; -- Determines if Cmdline represents a remote invocation. -- Since: gtk+ 2.28 function Get_Resource_Base_Path (Self : not null access Gapplication_Record) return UTF8_String; -- Gets the resource base path of Application. -- See Glib.Application.Set_Resource_Base_Path for more information. -- Since: gtk+ 2.42 procedure Set_Resource_Base_Path (Self : not null access Gapplication_Record; Resource_Path : UTF8_String := ""); -- Sets (or unsets) the base resource path of Application. -- The path is used to automatically load various [application -- resources][gresource] such as menu layouts and action descriptions. The -- various types of resources will be found at fixed names relative to the -- given base path. -- By default, the resource base path is determined from the application -- ID by prefixing '/' and replacing each '.' with '/'. This is done at the -- time that the Glib.Application.Gapplication object is constructed. -- Changes to the application ID after that point will not have an impact -- on the resource base path. -- As an example, if the application has an ID of "org.example.app" then -- the default resource base path will be "/org/example/app". If this is a -- Gtk.Application.Gtk_Application (and you have not manually changed the -- path) then Gtk will then search for the menus of the application at -- "/org/example/app/gtk/menus.ui". -- See Gresource.Gresource for more information about adding resources to -- your application. -- You can disable automatic resource loading functionality by setting the -- path to null. -- Changing the resource base path once the application is running is not -- recommended. The point at which the resource path is consulted for -- forming paths for various purposes is unspecified. When writing a -- sub-class of Glib.Application.Gapplication you should either set the -- Glib.Application.Gapplication:resource-base-path property at -- construction time, or call this function during the instance -- initialization. Alternatively, you can call this function in the -- GApplication_Class.startup virtual function, before chaining up to the -- parent implementation. -- Since: gtk+ 2.42 -- "resource_path": the resource path to use procedure Hold (Self : not null access Gapplication_Record); -- Increases the use count of Application. -- Use this function to indicate that the application has a reason to -- continue to run. For example, Glib.Application.Hold is called by GTK+ -- when a toplevel window is on the screen. -- To cancel the hold, call Glib.Application.Release. procedure Mark_Busy (Self : not null access Gapplication_Record); -- Increases the busy count of Application. -- Use this function to indicate that the application is busy, for -- instance while a long running operation is pending. -- The busy state will be exposed to other processes, so a session shell -- will use that information to indicate the state to the user (e.g. with a -- spinner). -- To cancel the busy indication, use Glib.Application.Unmark_Busy. -- Since: gtk+ 2.38 procedure Quit (Self : not null access Gapplication_Record); -- Immediately quits the application. -- Upon return to the mainloop, Glib.Application.Run will return, calling -- only the 'shutdown' function before doing so. -- The hold count is ignored. Take care if your code has called -- Glib.Application.Hold on the application and is therefore still -- expecting it to exist. (Note that you may have called -- Glib.Application.Hold indirectly, for example through -- Gtk.Application.Add_Window.) -- The result of calling Glib.Application.Run again after it returns is -- unspecified. -- Since: gtk+ 2.32 procedure Release (Self : not null access Gapplication_Record); -- Decrease the use count of Application. -- When the use count reaches zero, the application will stop running. -- Never call this function except to cancel the effect of a previous call -- to Glib.Application.Hold. function Run (Self : not null access Gapplication_Record; Argc : Glib.Gint; Argv : GNAT.Strings.String_List) return Glib.Gint; -- Runs the application. -- This function is intended to be run from main and its return value is -- intended to be returned by main. Although you are expected to pass the -- Argc, Argv parameters from main to this function, it is possible to pass -- null if Argv is not available or commandline handling is not required. -- Note that on Windows, Argc and Argv are ignored, and -- g_win32_get_command_line is called internally (for proper support of -- Unicode commandline arguments). -- Glib.Application.Gapplication will attempt to parse the commandline -- arguments. You can add commandline flags to the list of recognised -- options by way of g_application_add_main_option_entries. After this, the -- Glib.Application.Gapplication::handle-local-options signal is emitted, -- from which the application can inspect the values of its GOption_Entrys. -- Glib.Application.Gapplication::handle-local-options is a good place to -- handle options such as `--version`, where an immediate reply from the -- local process is desired (instead of communicating with an -- already-running instance). A -- Glib.Application.Gapplication::handle-local-options handler can stop -- further processing by returning a non-negative value, which then becomes -- the exit status of the process. -- What happens next depends on the flags: if -- Glib.Application.G_Application_Handles_Command_Line was specified then -- the remaining commandline arguments are sent to the primary instance, -- where a Glib.Application.Gapplication::command-line signal is emitted. -- Otherwise, the remaining commandline arguments are assumed to be a list -- of files. If there are no files listed, the application is activated via -- the Glib.Application.Gapplication::activate signal. If there are one or -- more files, and Glib.Application.G_Application_Handles_Open was -- specified then the files are opened via the -- Glib.Application.Gapplication::open signal. -- If you are interested in doing more complicated local handling of the -- commandline then you should implement your own -- Glib.Application.Gapplication subclass and override local_command_line. -- In this case, you most likely want to return True from your -- local_command_line implementation to suppress the default handling. See -- [gapplication-example-cmdline2.c][gapplication-example-cmdline2] for an -- example. -- If, after the above is done, the use count of the application is zero -- then the exit status is returned immediately. If the use count is -- non-zero then the default main context is iterated until the use count -- falls to zero, at which point 0 is returned. -- If the Glib.Application.G_Application_Is_Service flag is set, then the -- service will run for as much as 10 seconds with a use count of zero -- while waiting for the message that caused the activation to arrive. -- After that, if the use count falls to zero the application will exit -- immediately, except in the case that -- Glib.Application.Set_Inactivity_Timeout is in use. -- This function sets the prgname (g_set_prgname), if not already set, to -- the basename of argv[0]. -- Much like g_main_loop_run, this function will acquire the main context -- for the duration that the application is running. -- Since 2.40, applications that are not explicitly flagged as services or -- launchers (ie: neither Glib.Application.G_Application_Is_Service or -- Glib.Application.G_Application_Is_Launcher are given as flags) will -- check (from the default handler for local_command_line) if -- "--gapplication-service" was given in the command line. If this flag is -- present then normal commandline processing is interrupted and the -- Glib.Application.G_Application_Is_Service flag is set. This provides a -- "compromise" solution whereby running an application directly from the -- commandline will invoke it in the normal way (which can be useful for -- debugging) while still allowing applications to be D-Bus activated in -- service mode. The D-Bus service file should invoke the executable with -- "--gapplication-service" as the sole commandline argument. This approach -- is suitable for use by most graphical applications but should not be -- used from applications like editors that need precise control over when -- processes invoked via the commandline will exit and what their exit -- status will be. -- Since: gtk+ 2.28 -- "argc": the argc from main (or 0 if Argv is null) -- "argv": the argv from main, or null procedure Send_Notification (Self : not null access Gapplication_Record; Id : UTF8_String := ""; Notification : not null access Glib.Notification.Gnotification_Record'Class); -- Sends a notification on behalf of Application to the desktop shell. -- There is no guarantee that the notification is displayed immediately, or -- even at all. -- Notifications may persist after the application exits. It will be -- D-Bus-activated when the notification or one of its actions is -- activated. -- Modifying Notification after this call has no effect. However, the -- object can be reused for a later call to this function. -- Id may be any string that uniquely identifies the event for the -- application. It does not need to be in any special format. For example, -- "new-message" might be appropriate for a notification about new -- messages. -- If a previous notification was sent with the same Id, it will be -- replaced with Notification and shown again as if it was a new -- notification. This works even for notifications sent from a previous -- execution of the application, as long as Id is the same string. -- Id may be null, but it is impossible to replace or withdraw -- notifications without an id. -- If Notification is no longer relevant, it can be withdrawn with -- Glib.Application.Withdraw_Notification. -- Since: gtk+ 2.40 -- "id": id of the notification, or null -- "notification": the Glib.Notification.Gnotification to send procedure Set_Action_Group (Self : not null access Gapplication_Record; Action_Group : Glib.Action_Group.Gaction_Group); pragma Obsolescent (Set_Action_Group); -- This used to be how actions were associated with a -- Glib.Application.Gapplication. Now there is Glib.Action_Map.Gaction_Map -- for that. -- Since: gtk+ 2.28 -- Deprecated since 2.32, 1 -- "action_group": a Glib.Action_Group.Gaction_Group, or null procedure Set_Default (Self : not null access Gapplication_Record); -- Sets or unsets the default application for the process, as returned by -- Glib.Application.Get_Default. -- This function does not take its own reference on Application. If -- Application is destroyed then the default application will revert back -- to null. -- Since: gtk+ 2.32 procedure Set_Option_Context_Description (Self : not null access Gapplication_Record; Description : UTF8_String := ""); -- Adds a description to the Application option context. -- See Glib.Option.Set_Description for more information. -- Since: gtk+ 2.56 -- "description": a string to be shown in `--help` output after the list -- of options, or null procedure Set_Option_Context_Parameter_String (Self : not null access Gapplication_Record; Parameter_String : UTF8_String := ""); -- Sets the parameter string to be used by the commandline handling of -- Application. -- This function registers the argument to be passed to Glib.Option.G_New -- when the internal Glib.Option.Goption_Context of Application is created. -- See Glib.Option.G_New for more information about Parameter_String. -- Since: gtk+ 2.56 -- "parameter_string": a string which is displayed in the first line of -- `--help` output, after the usage summary `programname [OPTION...]`. procedure Set_Option_Context_Summary (Self : not null access Gapplication_Record; Summary : UTF8_String := ""); -- Adds a summary to the Application option context. -- See Glib.Option.Set_Summary for more information. -- Since: gtk+ 2.56 -- "summary": a string to be shown in `--help` output before the list of -- options, or null procedure Unbind_Busy_Property (Self : not null access Gapplication_Record; Object : System.Address; Property : UTF8_String); -- Destroys a binding between Property and the busy state of Application -- that was previously created with Glib.Application.Bind_Busy_Property. -- Since: gtk+ 2.44 -- "object": a Glib.Object.GObject -- "property": the name of a boolean property of Object procedure Unmark_Busy (Self : not null access Gapplication_Record); -- Decreases the busy count of Application. -- When the busy count reaches zero, the new state will be propagated to -- other processes. -- This function must only be called to cancel the effect of a previous -- call to Glib.Application.Mark_Busy. -- Since: gtk+ 2.38 procedure Withdraw_Notification (Self : not null access Gapplication_Record; Id : UTF8_String); -- Withdraws a notification that was sent with -- Glib.Application.Send_Notification. -- This call does nothing if a notification with Id doesn't exist or the -- notification was never sent. -- This function works even for notifications sent in previous executions -- of this application, as long Id is the same as it was for the sent -- notification. -- Note that notifications are dismissed when the user clicks on one of -- the buttons in a notification or triggers its default action, so there -- is no need to explicitly withdraw the notification in that case. -- Since: gtk+ 2.40 -- "id": id of a previously sent notification function Get_Arguments (Self : not null access Gapplication_Command_Line_Record) return GNAT.Strings.String_List; -- Gets the list of arguments that was passed on the command line. -- The strings in the array may contain non-UTF-8 data on UNIX (such as -- filenames or arguments given in the system locale) but are always in -- UTF-8 on Windows. -- If you wish to use the return value with Glib.Option.Goption_Context, -- you must use g_option_context_parse_strv. -- The return value is null-terminated and should be freed using -- g_strfreev. -- Since: gtk+ 2.28 function Get_Cwd (Self : not null access Gapplication_Command_Line_Record) return UTF8_String; -- Gets the working directory of the command line invocation. The string -- may contain non-utf8 data. -- It is possible that the remote application did not send a working -- directory, so this may be null. -- The return value should not be modified or freed and is valid for as -- long as Cmdline exists. -- Since: gtk+ 2.28 function Get_Environ (Self : not null access Gapplication_Command_Line_Record) return GNAT.Strings.String_List; -- Gets the contents of the 'environ' variable of the command line -- invocation, as would be returned by Glib.Spawn.Get_Environ, ie as a -- null-terminated list of strings in the form 'NAME=VALUE'. The strings -- may contain non-utf8 data. -- The remote application usually does not send an environment. Use -- Glib.Application.G_Application_Send_Environment to affect that. Even -- with this flag set it is possible that the environment is still not -- available (due to invocation messages from other applications). -- The return value should not be modified or freed and is valid for as -- long as Cmdline exists. -- See Glib.Application.Getenv if you are only interested in the value of -- a single environment variable. -- Since: gtk+ 2.28 function Get_Exit_Status (Self : not null access Gapplication_Command_Line_Record) return Glib.Gint; -- Gets the exit status of Cmdline. See Glib.Application.Set_Exit_Status -- for more information. -- Since: gtk+ 2.28 procedure Set_Exit_Status (Self : not null access Gapplication_Command_Line_Record; Exit_Status : Glib.Gint); -- Sets the exit status that will be used when the invoking process exits. -- The return value of the Glib.Application.Gapplication::command-line -- signal is passed to this function when the handler returns. This is the -- usual way of setting the exit status. -- In the event that you want the remote invocation to continue running -- and want to decide on the exit status in the future, you can use this -- call. For the case of a remote invocation, the remote process will -- typically exit when the last reference is dropped on Cmdline. The exit -- status of the remote process will be equal to the last value that was -- set with this function. -- In the case that the commandline invocation is local, the situation is -- slightly more complicated. If the commandline invocation results in the -- mainloop running (ie: because the use-count of the application increased -- to a non-zero value) then the application is considered to have been -- 'successful' in a certain sense, and the exit status is always zero. If -- the application use count is zero, though, the exit status of the local -- Glib.Application.Gapplication_Command_Line is used. -- Since: gtk+ 2.28 -- "exit_status": the exit status function Get_Platform_Data (Self : not null access Gapplication_Command_Line_Record) return Glib.Variant.Gvariant; -- Gets the platform data associated with the invocation of Cmdline. -- This is a Glib.Variant.Gvariant dictionary containing information about -- the context in which the invocation occurred. It typically contains -- information like the current working directory and the startup -- notification ID. -- For local invocation, it will be null. -- Since: gtk+ 2.28 function Getenv (Self : not null access Gapplication_Command_Line_Record; Name : UTF8_String) return UTF8_String; -- Gets the value of a particular environment variable of the command line -- invocation, as would be returned by g_getenv. The strings may contain -- non-utf8 data. -- The remote application usually does not send an environment. Use -- Glib.Application.G_Application_Send_Environment to affect that. Even -- with this flag set it is possible that the environment is still not -- available (due to invocation messages from other applications). -- The return value should not be modified or freed and is valid for as -- long as Cmdline exists. -- Since: gtk+ 2.28 -- "name": the environment variable to get ---------------------- -- GtkAda additions -- ---------------------- function Register (Self : not null access Gapplication_Record; Cancellable : access Glib.Cancellable.Gcancellable_Record'Class) return Boolean; -- Attempts registration of the application. -- This is the point at which the application discovers if it is the -- primary instance or merely acting as a remote for an already-existing -- primary instance. This is implemented by attempting to acquire the -- application identifier as a unique bus name on the session bus using -- GDBus. -- If there is no application ID or if -- Glib.Application.G_Application_Non_Unique was given, then this process -- will always become the primary instance. -- Due to the internal architecture of GDBus, method calls can be -- dispatched at any time (even if a main loop is not running). For this -- reason, you must ensure that any object paths that you wish to register -- are registered before calling this function. -- If the application has already been registered then True is returned -- with no work performed. -- The Glib.Application.Gapplication::startup signal is emitted if -- registration succeeds and Application is the primary instance (including -- the non-unique case). -- In the event of an error (such as Cancellable being cancelled, or a -- failure to connect to the session bus), False is returned and Error is -- set appropriately. -- Note: the return value of this function is not an indicator that this -- instance is or is not the primary instance of the application. See -- Glib.Application.Get_Is_Remote for that. -- Since: gtk+ 2.28 -- "cancellable": a Glib.Cancellable.Gcancellable, or null function Run (Self : not null access Gapplication_Record) return Gint; -- Same as above, but automatically sets argc argv from actual values. --------------------------------------------- -- Inherited subprograms (from interfaces) -- --------------------------------------------- procedure Action_Added (Self : not null access Gapplication_Record; Action_Name : UTF8_String); procedure Action_Enabled_Changed (Self : not null access Gapplication_Record; Action_Name : UTF8_String; Enabled : Boolean); procedure Action_Removed (Self : not null access Gapplication_Record; Action_Name : UTF8_String); procedure Action_State_Changed (Self : not null access Gapplication_Record; Action_Name : UTF8_String; State : Glib.Variant.Gvariant); procedure Activate_Action (Self : not null access Gapplication_Record; Action_Name : UTF8_String; Parameter : Glib.Variant.Gvariant); procedure Change_Action_State (Self : not null access Gapplication_Record; Action_Name : UTF8_String; Value : Glib.Variant.Gvariant); function Get_Action_Enabled (Self : not null access Gapplication_Record; Action_Name : UTF8_String) return Boolean; function Get_Action_Parameter_Type (Self : not null access Gapplication_Record; Action_Name : UTF8_String) return Glib.Variant.Gvariant_Type; function Get_Action_State (Self : not null access Gapplication_Record; Action_Name : UTF8_String) return Glib.Variant.Gvariant; function Get_Action_State_Hint (Self : not null access Gapplication_Record; Action_Name : UTF8_String) return Glib.Variant.Gvariant; function Get_Action_State_Type (Self : not null access Gapplication_Record; Action_Name : UTF8_String) return Glib.Variant.Gvariant_Type; function Has_Action (Self : not null access Gapplication_Record; Action_Name : UTF8_String) return Boolean; function List_Actions (Self : not null access Gapplication_Record) return GNAT.Strings.String_List; function Query_Action (Self : not null access Gapplication_Record; Action_Name : UTF8_String; Enabled : access Boolean; Parameter_Type : access Glib.Variant.Gvariant_Type; State_Type : access Glib.Variant.Gvariant_Type; State_Hint : access Glib.Variant.Gvariant; State : access Glib.Variant.Gvariant) return Boolean; procedure Add_Action (Self : not null access Gapplication_Record; Action : Glib.Action.Gaction); procedure Add_Action_Entries (Self : not null access Gapplication_Record; Entries : GAction_Entry_Array; User_Data : System.Address := System.Null_Address); function Lookup_Action (Self : not null access Gapplication_Record; Action_Name : UTF8_String) return Glib.Action.Gaction; procedure Remove_Action (Self : not null access Gapplication_Record; Action_Name : UTF8_String); --------------- -- Functions -- --------------- function Get_Default return Gapplication; -- Returns the default Glib.Application.Gapplication instance for this -- process. -- Normally there is only one Glib.Application.Gapplication per process -- and it becomes the default when it is created. You can exercise more -- control over this by using Glib.Application.Set_Default. -- If there is no default application then null is returned. -- Since: gtk+ 2.32 function Id_Is_Valid (Application_Id : UTF8_String) return Boolean; -- Checks if Application_Id is a valid application identifier. -- A valid ID is required for calls to Glib.Application.G_New and -- Glib.Application.Set_Application_Id. -- Application identifiers follow the same format as [D-Bus well-known bus -- names](https://dbus.freedesktop.org/doc/dbus-specification.htmlmessage-protocol-names-bus). -- For convenience, the restrictions on application identifiers are -- reproduced here: -- - Application identifiers are composed of 1 or more elements separated -- by a period (`.`) character. All elements must contain at least one -- character. -- - Each element must only contain the ASCII characters -- `[A-Z][a-z][0-9]_-`, with `-` discouraged in new application -- identifiers. Each element must not begin with a digit. -- - Application identifiers must contain at least one `.` (period) -- character (and thus at least two elements). -- - Application identifiers must not begin with a `.` (period) character. -- - Application identifiers must not exceed 255 characters. -- Note that the hyphen (`-`) character is allowed in application -- identifiers, but is problematic or not allowed in various specifications -- and APIs that refer to D-Bus, such as [Flatpak application -- IDs](http://docs.flatpak.org/en/latest/introduction.htmlidentifiers), -- the [`DBusActivatable` interface in the Desktop Entry -- Specification](https://specifications.freedesktop.org/desktop-entry-spec/desktop-entry-spec-latest.htmldbus), -- and the convention that an application's "main" interface and object -- path resemble its application identifier and bus name. To avoid -- situations that require special-case handling, it is recommended that -- new application identifiers consistently replace hyphens with -- underscores. -- Like D-Bus interface names, application identifiers should start with -- the reversed DNS domain name of the author of the interface (in -- lower-case), and it is conventional for the rest of the application -- identifier to consist of words run together, with initial capital -- letters. -- As with D-Bus interface names, if the author's DNS domain name contains -- hyphen/minus characters they should be replaced by underscores, and if -- it contains leading digits they should be escaped by prepending an -- underscore. For example, if the owner of 7-zip.org used an application -- identifier for an archiving application, it might be named -- `org._7_zip.Archiver`. -- "application_id": a potential application identifier ---------------- -- Properties -- ---------------- -- The following properties are defined for this widget. See -- Glib.Properties for more information on properties) -- The following properties are defined for this widget. See -- Glib.Properties for more information on properties) Action_Group_Property : constant Glib.Properties.Property_Object; -- Type: Gtk.Action_Group.Gtk_Action_Group -- Flags: write Application_Id_Property : constant Glib.Properties.Property_String; Flags_Property : constant Glib.Properties.Property_Boxed; -- Type: Application_Flags Inactivity_Timeout_Property : constant Glib.Properties.Property_Uint; Is_Busy_Property : constant Glib.Properties.Property_Boolean; -- Whether the application is currently marked as busy through -- Glib.Application.Mark_Busy or Glib.Application.Bind_Busy_Property. Is_Registered_Property : constant Glib.Properties.Property_Boolean; Is_Remote_Property : constant Glib.Properties.Property_Boolean; Resource_Base_Path_Property : constant Glib.Properties.Property_String; Arguments_Property : constant Glib.Properties.Property_Object; -- Type: Glib.Variant.Gvariant -- Flags: write Options_Property : constant Glib.Properties.Property_Object; -- Type: Glib.Variant.Gvariant -- Flags: write Platform_Data_Property : constant Glib.Properties.Property_Object; -- Type: Glib.Variant.Gvariant -- Flags: write ------------- -- Signals -- ------------- type Cb_Gapplication_Void is not null access procedure (Self : access Gapplication_Record'Class); type Cb_GObject_Void is not null access procedure (Self : access Glib.Object.GObject_Record'Class); Signal_Activate : constant Glib.Signal_Name := "activate"; procedure On_Activate (Self : not null access Gapplication_Record; Call : Cb_Gapplication_Void; After : Boolean := False); procedure On_Activate (Self : not null access Gapplication_Record; Call : Cb_GObject_Void; Slot : not null access Glib.Object.GObject_Record'Class; After : Boolean := False); -- The ::activate signal is emitted on the primary instance when an -- activation occurs. See Glib.Application.Activate. type Cb_Gapplication_Gapplication_Command_Line_Gint is not null access function (Self : access Gapplication_Record'Class; Command_Line : not null access Gapplication_Command_Line_Record'Class) return Glib.Gint; type Cb_GObject_Gapplication_Command_Line_Gint is not null access function (Self : access Glib.Object.GObject_Record'Class; Command_Line : not null access Gapplication_Command_Line_Record'Class) return Glib.Gint; Signal_Command_Line : constant Glib.Signal_Name := "command-line"; procedure On_Command_Line (Self : not null access Gapplication_Record; Call : Cb_Gapplication_Gapplication_Command_Line_Gint; After : Boolean := False); procedure On_Command_Line (Self : not null access Gapplication_Record; Call : Cb_GObject_Gapplication_Command_Line_Gint; Slot : not null access Glib.Object.GObject_Record'Class; After : Boolean := False); -- The ::command-line signal is emitted on the primary instance when a -- commandline is not handled locally. See Glib.Application.Run and the -- Glib.Application.Gapplication_Command_Line documentation for more -- information. -- -- Callback parameters: -- -- "command_line": a Glib.Application.Gapplication_Command_Line -- -- representing the passed commandline -- -- Returns An integer that is set as the exit status for the calling -- process. See Glib.Application.Set_Exit_Status. Signal_Handle_Local_Options : constant Glib.Signal_Name := "handle-local-options"; -- The ::handle-local-options signal is emitted on the local instance -- after the parsing of the commandline options has occurred. -- -- You can add options to be recognised during commandline option parsing -- using g_application_add_main_option_entries and -- g_application_add_option_group. -- -- Signal handlers can inspect Options (along with values pointed to from -- the Arg_Data of an installed GOption_Entrys) in order to decide to -- perform certain actions, including direct local handling (which may be -- useful for options like --version). -- -- In the event that the application is marked -- Glib.Application.G_Application_Handles_Command_Line the "normal -- processing" will send the Options dictionary to the primary instance -- where it can be read with g_application_command_line_get_options_dict. -- The signal handler can modify the dictionary before returning, and the -- modified dictionary will be sent. -- -- In the event that Glib.Application.G_Application_Handles_Command_Line -- is not set, "normal processing" will treat the remaining uncollected -- command line arguments as filenames or URIs. If there are no arguments, -- the application is activated by Glib.Application.Activate. One or more -- arguments results in a call to g_application_open. -- -- If you want to handle the local commandline arguments for yourself by -- converting them to calls to g_application_open or -- Glib.Action_Group.Activate_Action then you must be sure to register the -- application first. You should probably not call -- Glib.Application.Activate for yourself, however: just return -1 and -- allow the default handler to do it for you. This will ensure that the -- `--gapplication-service` switch works properly (i.e. no activation in -- that case). -- -- Note that this signal is emitted from the default implementation of -- local_command_line. If you override that function and don't chain up -- then this signal will never be emitted. -- -- You can override local_command_line if you need more powerful -- capabilities than what is provided here, but this should not normally be -- required. -- function Handler -- (Self : access Gapplication_Record'Class; -- Options : GLib.Variant_Dict) return Glib.Gint -- -- Callback parameters: -- -- "options": the options dictionary -- -- Returns an exit code. If you have handled your options and want -- to exit the process, return a non-negative option, 0 for success, -- and a positive value for failure. To continue, return -1 to let -- the default option processing continue. type Cb_Gapplication_Boolean is not null access function (Self : access Gapplication_Record'Class) return Boolean; type Cb_GObject_Boolean is not null access function (Self : access Glib.Object.GObject_Record'Class) return Boolean; Signal_Name_Lost : constant Glib.Signal_Name := "name-lost"; procedure On_Name_Lost (Self : not null access Gapplication_Record; Call : Cb_Gapplication_Boolean; After : Boolean := False); procedure On_Name_Lost (Self : not null access Gapplication_Record; Call : Cb_GObject_Boolean; Slot : not null access Glib.Object.GObject_Record'Class; After : Boolean := False); -- The ::name-lost signal is emitted only on the registered primary -- instance when a new instance has taken over. This can only happen if the -- application is using the -- Glib.Application.G_Application_Allow_Replacement flag. -- -- The default handler for this signal calls Glib.Application.Quit. -- -- Callback parameters: -- -- Returns True if the signal has been handled Signal_Open : constant Glib.Signal_Name := "open"; -- The ::open signal is emitted on the primary instance when there are -- files to open. See g_application_open for more information. -- procedure Handler -- (Self : access Gapplication_Record'Class; -- Files : array_of_File; -- N_Files : Glib.Gint; -- Hint : UTF8_String) -- -- Callback parameters: -- -- "files": an array of GFiles -- -- "n_files": the length of Files -- -- "hint": a hint provided by the calling instance Signal_Shutdown : constant Glib.Signal_Name := "shutdown"; procedure On_Shutdown (Self : not null access Gapplication_Record; Call : Cb_Gapplication_Void; After : Boolean := False); procedure On_Shutdown (Self : not null access Gapplication_Record; Call : Cb_GObject_Void; Slot : not null access Glib.Object.GObject_Record'Class; After : Boolean := False); -- The ::shutdown signal is emitted only on the registered primary -- instance immediately after the main loop terminates. Signal_Startup : constant Glib.Signal_Name := "startup"; procedure On_Startup (Self : not null access Gapplication_Record; Call : Cb_Gapplication_Void; After : Boolean := False); procedure On_Startup (Self : not null access Gapplication_Record; Call : Cb_GObject_Void; Slot : not null access Glib.Object.GObject_Record'Class; After : Boolean := False); -- The ::startup signal is emitted on the primary instance immediately -- after registration. See g_application_register. ---------------- -- Interfaces -- ---------------- -- This class implements several interfaces. See Glib.Types -- -- - "ActionGroup" -- -- - "ActionMap" package Implements_Gaction_Group is new Glib.Types.Implements (Glib.Action_Group.Gaction_Group, Gapplication_Record, Gapplication); function "+" (Widget : access Gapplication_Record'Class) return Glib.Action_Group.Gaction_Group renames Implements_Gaction_Group.To_Interface; function "-" (Interf : Glib.Action_Group.Gaction_Group) return Gapplication renames Implements_Gaction_Group.To_Object; package Implements_Gaction_Map is new Glib.Types.Implements (Glib.Action_Map.Gaction_Map, Gapplication_Record, Gapplication); function "+" (Widget : access Gapplication_Record'Class) return Glib.Action_Map.Gaction_Map renames Implements_Gaction_Map.To_Interface; function "-" (Interf : Glib.Action_Map.Gaction_Map) return Gapplication renames Implements_Gaction_Map.To_Object; --------------------- -- Virtual Methods -- --------------------- type Virtual_Command_Line is access function (Self : System.Address; Command_Line : System.Address) return Glib.Gint; pragma Convention (C, Virtual_Command_Line); type Virtual_Local_Command_Line is access function (Self : System.Address; Arguments : access Gtkada.Bindings.chars_ptr_array_access; Exit_Status : access Glib.Gint) return Glib.Gboolean; pragma Convention (C, Virtual_Local_Command_Line); -- This virtual function is always invoked in the local instance. It gets -- passed a pointer to a null-terminated copy of Argv and is expected to -- remove arguments that it handled (shifting up remaining arguments). -- The last argument to local_command_line is a pointer to the Status -- variable which can used to set the exit status that is returned from -- Glib.Application.Run. -- See Glib.Application.Run for more details on -- Glib.Application.Gapplication startup. -- "arguments": array of command line arguments -- "exit_status": exit status to fill after processing the command line. subtype Application_Interface_Descr is Glib.Object.Interface_Description; procedure Set_Command_Line (Self : Glib.Object.GObject_Class; Handler : Virtual_Command_Line); pragma Import (C, Set_Command_Line, "gtkada_Application_set_command_line"); procedure Set_Local_Command_Line (Self : Glib.Object.GObject_Class; Handler : Virtual_Local_Command_Line); pragma Import (C, Set_Local_Command_Line, "gtkada_Application_set_local_command_line"); -- See Glib.Object.Add_Interface private Platform_Data_Property : constant Glib.Properties.Property_Object := Glib.Properties.Build ("platform-data"); Options_Property : constant Glib.Properties.Property_Object := Glib.Properties.Build ("options"); Arguments_Property : constant Glib.Properties.Property_Object := Glib.Properties.Build ("arguments"); Resource_Base_Path_Property : constant Glib.Properties.Property_String := Glib.Properties.Build ("resource-base-path"); Is_Remote_Property : constant Glib.Properties.Property_Boolean := Glib.Properties.Build ("is-remote"); Is_Registered_Property : constant Glib.Properties.Property_Boolean := Glib.Properties.Build ("is-registered"); Is_Busy_Property : constant Glib.Properties.Property_Boolean := Glib.Properties.Build ("is-busy"); Inactivity_Timeout_Property : constant Glib.Properties.Property_Uint := Glib.Properties.Build ("inactivity-timeout"); Flags_Property : constant Glib.Properties.Property_Boxed := Glib.Properties.Build ("flags"); Application_Id_Property : constant Glib.Properties.Property_String := Glib.Properties.Build ("application-id"); Action_Group_Property : constant Glib.Properties.Property_Object := Glib.Properties.Build ("action-group"); end Glib.Application; gtkada-24.0.0/src/generated/glib-cancellable.adb000066400000000000000000000376071446021174000214010ustar00rootroot00000000000000------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ pragma Style_Checks (Off); pragma Warnings (Off, "*is already use-visible*"); with Ada.Unchecked_Conversion; with Glib.Type_Conversion_Hooks; use Glib.Type_Conversion_Hooks; with Glib.Values; use Glib.Values; with Gtk.Arguments; use Gtk.Arguments; with Gtkada.Bindings; use Gtkada.Bindings; package body Glib.Cancellable is function C_G_Cancellable_Connect (Self : System.Address; Callback : System.Address; Data : System.Address; Data_Destroy_Func : Glib.G_Destroy_Notify_Address) return Gulong; pragma Import (C, C_G_Cancellable_Connect, "g_cancellable_connect"); -- Convenience function to connect to the -- Glib.Cancellable.Gcancellable::cancelled signal. Also handles the race -- condition that may happen if the cancellable is cancelled right before -- connecting. -- Callback is called at most once, either directly at the time of the -- connect if Cancellable is already cancelled, or when Cancellable is -- cancelled in some thread. -- Data_Destroy_Func will be called when the handler is disconnected, or -- immediately if the cancellable is already cancelled. -- See Glib.Cancellable.Gcancellable::cancelled for details on how to use -- this. -- Since GLib 2.40, the lock protecting Cancellable is not held when -- Callback is invoked. This lifts a restriction in place for earlier GLib -- versions which now makes it easier to write cleanup code that -- unconditionally invokes e.g. Glib.Cancellable.Cancel. -- Since: gtk+ 2.22 -- "callback": The Gcallback to connect. -- "data": Data to pass to Callback. -- "data_destroy_func": Free function for Data or null. function To_Gcallback is new Ada.Unchecked_Conversion (System.Address, Gcallback); function To_Address is new Ada.Unchecked_Conversion (Gcallback, System.Address); procedure Internal_Gcallback (Data : System.Address); pragma Convention (C, Internal_Gcallback); ------------------------ -- Internal_Gcallback -- ------------------------ procedure Internal_Gcallback (Data : System.Address) is Func : constant Gcallback := To_Gcallback (Data); begin Func.all; end Internal_Gcallback; package Type_Conversion_Gcancellable is new Glib.Type_Conversion_Hooks.Hook_Registrator (Get_Type'Access, Gcancellable_Record); pragma Unreferenced (Type_Conversion_Gcancellable); ----------- -- G_New -- ----------- procedure G_New (Self : out Gcancellable) is begin Self := new Gcancellable_Record; Glib.Cancellable.Initialize (Self); end G_New; ---------------------- -- Gcancellable_New -- ---------------------- function Gcancellable_New return Gcancellable is Self : constant Gcancellable := new Gcancellable_Record; begin Glib.Cancellable.Initialize (Self); return Self; end Gcancellable_New; ---------------- -- Initialize -- ---------------- procedure Initialize (Self : not null access Gcancellable_Record'Class) is function Internal return System.Address; pragma Import (C, Internal, "g_cancellable_new"); begin if not Self.Is_Created then Set_Object (Self, Internal); end if; end Initialize; ------------ -- Cancel -- ------------ procedure Cancel (Self : not null access Gcancellable_Record) is procedure Internal (Self : System.Address); pragma Import (C, Internal, "g_cancellable_cancel"); begin Internal (Get_Object (Self)); end Cancel; ------------- -- Connect -- ------------- function Connect (Self : not null access Gcancellable_Record; Callback : Gcallback; Data_Destroy_Func : Glib.G_Destroy_Notify_Address) return Gulong is begin if Callback = null then return C_G_Cancellable_Connect (Get_Object (Self), System.Null_Address, System.Null_Address, Data_Destroy_Func); else return C_G_Cancellable_Connect (Get_Object (Self), Internal_Gcallback'Address, To_Address (Callback), Data_Destroy_Func); end if; end Connect; package body Connect_User_Data is package Users is new Glib.Object.User_Data_Closure (User_Data_Type, Destroy); function To_Gcallback is new Ada.Unchecked_Conversion (System.Address, Gcallback); function To_Address is new Ada.Unchecked_Conversion (Gcallback, System.Address); procedure Internal_Cb (Data : System.Address); pragma Convention (C, Internal_Cb); -- The type used for callback functions in structure definitions and -- function signatures. This doesn't mean that all callback functions -- must take no parameters and return void. The required signature of a -- callback function is determined by the context in which is used (e.g. -- the signal to which it is connected). Use G_CALLBACK to cast the -- callback function to a Gcallback. ------------- -- Connect -- ------------- function Connect (Self : not null access Glib.Cancellable.Gcancellable_Record'Class; Callback : Gcallback; Data : User_Data_Type; Data_Destroy_Func : Glib.G_Destroy_Notify_Address) return Gulong is D : System.Address; begin if Callback = null then return C_G_Cancellable_Connect (Get_Object (Self), System.Null_Address, System.Null_Address, Data_Destroy_Func); else D := Users.Build (To_Address (Callback), Data); return C_G_Cancellable_Connect (Get_Object (Self), Internal_Cb'Address, D, Data_Destroy_Func); end if; end Connect; ----------------- -- Internal_Cb -- ----------------- procedure Internal_Cb (Data : System.Address) is D : constant Users.Internal_Data_Access := Users.Convert (Data); begin To_Gcallback (D.Func) (D.Data.all); end Internal_Cb; end Connect_User_Data; ---------------- -- Disconnect -- ---------------- procedure Disconnect (Self : not null access Gcancellable_Record; Handler_Id : Gulong) is procedure Internal (Self : System.Address; Handler_Id : Gulong); pragma Import (C, Internal, "g_cancellable_disconnect"); begin Internal (Get_Object (Self), Handler_Id); end Disconnect; ------------ -- Get_Fd -- ------------ function Get_Fd (Self : not null access Gcancellable_Record) return Glib.Gint is function Internal (Self : System.Address) return Glib.Gint; pragma Import (C, Internal, "g_cancellable_get_fd"); begin return Internal (Get_Object (Self)); end Get_Fd; ------------------ -- Is_Cancelled -- ------------------ function Is_Cancelled (Self : not null access Gcancellable_Record) return Boolean is function Internal (Self : System.Address) return Glib.Gboolean; pragma Import (C, Internal, "g_cancellable_is_cancelled"); begin return Internal (Get_Object (Self)) /= 0; end Is_Cancelled; ----------------- -- Pop_Current -- ----------------- procedure Pop_Current (Self : not null access Gcancellable_Record) is procedure Internal (Self : System.Address); pragma Import (C, Internal, "g_cancellable_pop_current"); begin Internal (Get_Object (Self)); end Pop_Current; ------------------ -- Push_Current -- ------------------ procedure Push_Current (Self : not null access Gcancellable_Record) is procedure Internal (Self : System.Address); pragma Import (C, Internal, "g_cancellable_push_current"); begin Internal (Get_Object (Self)); end Push_Current; ---------------- -- Release_Fd -- ---------------- procedure Release_Fd (Self : not null access Gcancellable_Record) is procedure Internal (Self : System.Address); pragma Import (C, Internal, "g_cancellable_release_fd"); begin Internal (Get_Object (Self)); end Release_Fd; ----------- -- Reset -- ----------- procedure Reset (Self : not null access Gcancellable_Record) is procedure Internal (Self : System.Address); pragma Import (C, Internal, "g_cancellable_reset"); begin Internal (Get_Object (Self)); end Reset; ---------------------------- -- Set_Error_If_Cancelled -- ---------------------------- function Set_Error_If_Cancelled (Self : not null access Gcancellable_Record) return Boolean is function Internal (Self : System.Address) return Glib.Gboolean; pragma Import (C, Internal, "g_cancellable_set_error_if_cancelled"); begin return Internal (Get_Object (Self)) /= 0; end Set_Error_If_Cancelled; ---------------- -- Source_New -- ---------------- function Source_New (Self : not null access Gcancellable_Record) return Glib.Main.G_Source is function Internal (Self : System.Address) return Glib.Main.G_Source; pragma Import (C, Internal, "g_cancellable_source_new"); begin return Internal (Get_Object (Self)); end Source_New; ----------------- -- Get_Current -- ----------------- function Get_Current return Gcancellable is function Internal return System.Address; pragma Import (C, Internal, "g_cancellable_get_current"); Stub_Gcancellable : Gcancellable_Record; begin return Glib.Cancellable.Gcancellable (Get_User_Data (Internal, Stub_Gcancellable)); end Get_Current; use type System.Address; function Cb_To_Address is new Ada.Unchecked_Conversion (Cb_Gcancellable_Void, System.Address); function Address_To_Cb is new Ada.Unchecked_Conversion (System.Address, Cb_Gcancellable_Void); function Cb_To_Address is new Ada.Unchecked_Conversion (Cb_GObject_Void, System.Address); function Address_To_Cb is new Ada.Unchecked_Conversion (System.Address, Cb_GObject_Void); procedure Connect (Object : access Gcancellable_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_Gcancellable_Void; After : Boolean); procedure Connect_Slot (Object : access Gcancellable_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_GObject_Void; After : Boolean; Slot : access Glib.Object.GObject_Record'Class := null); procedure Marsh_GObject_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address); pragma Convention (C, Marsh_GObject_Void); procedure Marsh_Gcancellable_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address); pragma Convention (C, Marsh_Gcancellable_Void); ------------- -- Connect -- ------------- procedure Connect (Object : access Gcancellable_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_Gcancellable_Void; After : Boolean) is begin Unchecked_Do_Signal_Connect (Object => Object, C_Name => C_Name, Marshaller => Marsh_Gcancellable_Void'Access, Handler => Cb_To_Address (Handler),-- Set in the closure After => After); end Connect; ------------------ -- Connect_Slot -- ------------------ procedure Connect_Slot (Object : access Gcancellable_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_GObject_Void; After : Boolean; Slot : access Glib.Object.GObject_Record'Class := null) is begin Unchecked_Do_Signal_Connect (Object => Object, C_Name => C_Name, Marshaller => Marsh_GObject_Void'Access, Handler => Cb_To_Address (Handler),-- Set in the closure Slot_Object => Slot, After => After); end Connect_Slot; ------------------------ -- Marsh_GObject_Void -- ------------------------ procedure Marsh_GObject_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address) is pragma Unreferenced (Return_Value, N_Params, Params, Invocation_Hint, User_Data); H : constant Cb_GObject_Void := Address_To_Cb (Get_Callback (Closure)); Obj : constant Glib.Object.GObject := Glib.Object.Convert (Get_Data (Closure)); begin H (Obj); exception when E : others => Process_Exception (E); end Marsh_GObject_Void; ----------------------------- -- Marsh_Gcancellable_Void -- ----------------------------- procedure Marsh_Gcancellable_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address) is pragma Unreferenced (Return_Value, N_Params, Invocation_Hint, User_Data); H : constant Cb_Gcancellable_Void := Address_To_Cb (Get_Callback (Closure)); Obj : constant Gcancellable := Gcancellable (Unchecked_To_Object (Params, 0)); begin H (Obj); exception when E : others => Process_Exception (E); end Marsh_Gcancellable_Void; ------------------ -- On_Cancelled -- ------------------ procedure On_Cancelled (Self : not null access Gcancellable_Record; Call : Cb_Gcancellable_Void; After : Boolean := False) is begin Connect (Self, "cancelled" & ASCII.NUL, Call, After); end On_Cancelled; ------------------ -- On_Cancelled -- ------------------ procedure On_Cancelled (Self : not null access Gcancellable_Record; Call : Cb_GObject_Void; Slot : not null access Glib.Object.GObject_Record'Class; After : Boolean := False) is begin Connect_Slot (Self, "cancelled" & ASCII.NUL, Call, After, Slot); end On_Cancelled; end Glib.Cancellable; gtkada-24.0.0/src/generated/glib-cancellable.ads000066400000000000000000000373501446021174000214150ustar00rootroot00000000000000------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ -- -- GCancellable is a thread-safe operation cancellation stack used throughout -- GIO to allow for cancellation of synchronous and asynchronous operations. -- -- pragma Warnings (Off, "*is already use-visible*"); with Glib.Main; use Glib.Main; with Glib.Object; use Glib.Object; package Glib.Cancellable is type Gcancellable_Record is new GObject_Record with null record; type Gcancellable is access all Gcancellable_Record'Class; --------------- -- Callbacks -- --------------- type Gcallback is access procedure; -- The type used for callback functions in structure definitions and -- function signatures. This doesn't mean that all callback functions must -- take no parameters and return void. The required signature of a callback -- function is determined by the context in which is used (e.g. the signal -- to which it is connected). Use G_CALLBACK to cast the callback function -- to a Gcallback. ------------------ -- Constructors -- ------------------ procedure G_New (Self : out Gcancellable); -- Creates a new Glib.Cancellable.Gcancellable object. -- Applications that want to start one or more operations that should be -- cancellable should create a Glib.Cancellable.Gcancellable and pass it to -- the operations. -- One Glib.Cancellable.Gcancellable can be used in multiple consecutive -- operations or in multiple concurrent operations. procedure Initialize (Self : not null access Gcancellable_Record'Class); -- Creates a new Glib.Cancellable.Gcancellable object. -- Applications that want to start one or more operations that should be -- cancellable should create a Glib.Cancellable.Gcancellable and pass it to -- the operations. -- One Glib.Cancellable.Gcancellable can be used in multiple consecutive -- operations or in multiple concurrent operations. -- Initialize does nothing if the object was already created with another -- call to Initialize* or G_New. function Gcancellable_New return Gcancellable; -- Creates a new Glib.Cancellable.Gcancellable object. -- Applications that want to start one or more operations that should be -- cancellable should create a Glib.Cancellable.Gcancellable and pass it to -- the operations. -- One Glib.Cancellable.Gcancellable can be used in multiple consecutive -- operations or in multiple concurrent operations. function Get_Type return Glib.GType; pragma Import (C, Get_Type, "g_cancellable_get_type"); ------------- -- Methods -- ------------- procedure Cancel (Self : not null access Gcancellable_Record); -- Will set Cancellable to cancelled, and will emit the -- Glib.Cancellable.Gcancellable::cancelled signal. (However, see the -- warning about race conditions in the documentation for that signal if -- you are planning to connect to it.) -- This function is thread-safe. In other words, you can safely call it -- from a thread other than the one running the operation that was passed -- the Cancellable. -- If Cancellable is null, this function returns immediately for -- convenience. -- The convention within GIO is that cancelling an asynchronous operation -- causes it to complete asynchronously. That is, if you cancel the -- operation from the same thread in which it is running, then the -- operation's Gasync_Ready_Callback will not be invoked until the -- application returns to the main loop. function Connect (Self : not null access Gcancellable_Record; Callback : Gcallback; Data_Destroy_Func : Glib.G_Destroy_Notify_Address) return Gulong; -- Convenience function to connect to the -- Glib.Cancellable.Gcancellable::cancelled signal. Also handles the race -- condition that may happen if the cancellable is cancelled right before -- connecting. -- Callback is called at most once, either directly at the time of the -- connect if Cancellable is already cancelled, or when Cancellable is -- cancelled in some thread. -- Data_Destroy_Func will be called when the handler is disconnected, or -- immediately if the cancellable is already cancelled. -- See Glib.Cancellable.Gcancellable::cancelled for details on how to use -- this. -- Since GLib 2.40, the lock protecting Cancellable is not held when -- Callback is invoked. This lifts a restriction in place for earlier GLib -- versions which now makes it easier to write cleanup code that -- unconditionally invokes e.g. Glib.Cancellable.Cancel. -- Since: gtk+ 2.22 -- "callback": The Gcallback to connect. -- "data_destroy_func": Free function for Data or null. generic type User_Data_Type (<>) is private; with procedure Destroy (Data : in out User_Data_Type) is null; package Connect_User_Data is type Gcallback is access procedure (Data : User_Data_Type); -- The type used for callback functions in structure definitions and -- function signatures. This doesn't mean that all callback functions must -- take no parameters and return void. The required signature of a callback -- function is determined by the context in which is used (e.g. the signal -- to which it is connected). Use G_CALLBACK to cast the callback function -- to a Gcallback. function Connect (Self : not null access Glib.Cancellable.Gcancellable_Record'Class; Callback : Gcallback; Data : User_Data_Type; Data_Destroy_Func : Glib.G_Destroy_Notify_Address) return Gulong; -- Convenience function to connect to the -- Glib.Cancellable.Gcancellable::cancelled signal. Also handles the -- race condition that may happen if the cancellable is cancelled right -- before connecting. -- Callback is called at most once, either directly at the time of the -- connect if Cancellable is already cancelled, or when Cancellable is -- cancelled in some thread. -- Data_Destroy_Func will be called when the handler is disconnected, -- or immediately if the cancellable is already cancelled. -- See Glib.Cancellable.Gcancellable::cancelled for details on how to -- use this. -- Since GLib 2.40, the lock protecting Cancellable is not held when -- Callback is invoked. This lifts a restriction in place for earlier -- GLib versions which now makes it easier to write cleanup code that -- unconditionally invokes e.g. Glib.Cancellable.Cancel. -- Since: gtk+ 2.22 -- "callback": The Gcallback to connect. -- "data": Data to pass to Callback. -- "data_destroy_func": Free function for Data or null. end Connect_User_Data; procedure Disconnect (Self : not null access Gcancellable_Record; Handler_Id : Gulong); -- Disconnects a handler from a cancellable instance similar to -- g_signal_handler_disconnect. Additionally, in the event that a signal -- handler is currently running, this call will block until the handler has -- finished. Calling this function from a -- Glib.Cancellable.Gcancellable::cancelled signal handler will therefore -- result in a deadlock. -- This avoids a race condition where a thread cancels at the same time as -- the cancellable operation is finished and the signal handler is removed. -- See Glib.Cancellable.Gcancellable::cancelled for details on how to use -- this. -- If Cancellable is null or Handler_Id is `0` this function does nothing. -- Since: gtk+ 2.22 -- "handler_id": Handler id of the handler to be disconnected, or `0`. function Get_Fd (Self : not null access Gcancellable_Record) return Glib.Gint; -- Gets the file descriptor for a cancellable job. This can be used to -- implement cancellable operations on Unix systems. The returned fd will -- turn readable when Cancellable is cancelled. -- You are not supposed to read from the fd yourself, just check for -- readable status. Reading to unset the readable status is done with -- Glib.Cancellable.Reset. -- After a successful return from this function, you should use -- Glib.Cancellable.Release_Fd to free up resources allocated for the -- returned file descriptor. -- See also g_cancellable_make_pollfd. function Is_Cancelled (Self : not null access Gcancellable_Record) return Boolean; -- Checks if a cancellable job has been cancelled. procedure Pop_Current (Self : not null access Gcancellable_Record); -- Pops Cancellable off the cancellable stack (verifying that Cancellable -- is on the top of the stack). procedure Push_Current (Self : not null access Gcancellable_Record); -- Pushes Cancellable onto the cancellable stack. The current cancellable -- can then be received using Glib.Cancellable.Get_Current. -- This is useful when implementing cancellable operations in code that -- does not allow you to pass down the cancellable object. -- This is typically called automatically by e.g. Gfile.Gfile operations, -- so you rarely have to call this yourself. procedure Release_Fd (Self : not null access Gcancellable_Record); -- Releases a resources previously allocated by Glib.Cancellable.Get_Fd or -- g_cancellable_make_pollfd. -- For compatibility reasons with older releases, calling this function is -- not strictly required, the resources will be automatically freed when -- the Cancellable is finalized. However, the Cancellable will block scarce -- file descriptors until it is finalized if this function is not called. -- This can cause the application to run out of file descriptors when many -- GCancellables are used at the same time. -- Since: gtk+ 2.22 procedure Reset (Self : not null access Gcancellable_Record); -- Resets Cancellable to its uncancelled state. -- If cancellable is currently in use by any cancellable operation then -- the behavior of this function is undefined. -- Note that it is generally not a good idea to reuse an existing -- cancellable for more operations after it has been cancelled once, as -- this function might tempt you to do. The recommended practice is to drop -- the reference to a cancellable after cancelling it, and let it die with -- the outstanding async operations. You should create a fresh cancellable -- for further async operations. function Set_Error_If_Cancelled (Self : not null access Gcancellable_Record) return Boolean; -- If the Cancellable is cancelled, sets the error to notify that the -- operation was cancelled. function Source_New (Self : not null access Gcancellable_Record) return Glib.Main.G_Source; -- Creates a source that triggers if Cancellable is cancelled and calls -- its callback of type Gcancellable_Source_Func. This is primarily useful -- for attaching to another (non-cancellable) source with -- g_source_add_child_source to add cancellability to it. -- For convenience, you can call this with a null -- Glib.Cancellable.Gcancellable, in which case the source will never -- trigger. -- The new Glib.Main.G_Source will hold a reference to the -- Glib.Cancellable.Gcancellable. -- Since: gtk+ 2.28 --------------- -- Functions -- --------------- function Get_Current return Gcancellable; -- Gets the top cancellable from the stack. ------------- -- Signals -- ------------- type Cb_Gcancellable_Void is not null access procedure (Self : access Gcancellable_Record'Class); type Cb_GObject_Void is not null access procedure (Self : access Glib.Object.GObject_Record'Class); Signal_Cancelled : constant Glib.Signal_Name := "cancelled"; procedure On_Cancelled (Self : not null access Gcancellable_Record; Call : Cb_Gcancellable_Void; After : Boolean := False); procedure On_Cancelled (Self : not null access Gcancellable_Record; Call : Cb_GObject_Void; Slot : not null access Glib.Object.GObject_Record'Class; After : Boolean := False); -- Emitted when the operation has been cancelled. -- -- Can be used by implementations of cancellable operations. If the -- operation is cancelled from another thread, the signal will be emitted -- in the thread that cancelled the operation, not the thread that is -- running the operation. -- -- Note that disconnecting from this signal (or any signal) in a -- multi-threaded program is prone to race conditions. For instance it is -- possible that a signal handler may be invoked even after a call to -- g_signal_handler_disconnect for that handler has already returned. -- -- There is also a problem when cancellation happens right before -- connecting to the signal. If this happens the signal will unexpectedly -- not be emitted, and checking before connecting to the signal leaves a -- race condition where this is still happening. -- -- In order to make it safe and easy to connect handlers there are two -- helper functions: Glib.Cancellable.Connect and -- Glib.Cancellable.Disconnect which protect against problems like this. -- -- An example of how to us this: |[ // Make sure we -- don't do unnecessary work if already cancelled if -- (g_cancellable_set_error_if_cancelled (cancellable, error)) return; -- -- // Set up all the data needed to be able to handle cancellation // of -- the operation my_data = my_data_new (...); -- -- id = 0; if (cancellable) id = g_cancellable_connect (cancellable, -- G_CALLBACK (cancelled_handler) data, NULL); -- -- // cancellable operation here... -- -- g_cancellable_disconnect (cancellable, id); -- -- // cancelled_handler is never called after this, it is now safe // to -- free the data my_data_free (my_data); ]| -- -- Note that the cancelled signal is emitted in the thread that the user -- cancelled from, which may be the main thread. So, the cancellable signal -- should not do something that can block. end Glib.Cancellable; gtkada-24.0.0/src/generated/glib-g_icon.adb000066400000000000000000000074321446021174000204030ustar00rootroot00000000000000------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ pragma Style_Checks (Off); pragma Warnings (Off, "*is already use-visible*"); with Gtkada.Bindings; use Gtkada.Bindings; pragma Warnings(Off); -- might be unused with Gtkada.Types; use Gtkada.Types; pragma Warnings(On); package body Glib.G_Icon is ----------- -- Equal -- ----------- function Equal (Self : G_Icon; Icon2 : G_Icon) return Boolean is function Internal (Self : G_Icon; Icon2 : G_Icon) return Glib.Gboolean; pragma Import (C, Internal, "g_icon_equal"); begin return Internal (Self, Icon2) /= 0; end Equal; --------------- -- Serialize -- --------------- function Serialize (Self : G_Icon) return Glib.Variant.Gvariant is function Internal (Self : G_Icon) return System.Address; pragma Import (C, Internal, "g_icon_serialize"); begin return From_Object (Internal (Self)); end Serialize; --------------- -- To_String -- --------------- function To_String (Self : G_Icon) return UTF8_String is function Internal (Self : G_Icon) return Gtkada.Types.Chars_Ptr; pragma Import (C, Internal, "g_icon_to_string"); begin return Gtkada.Bindings.Value_And_Free (Internal (Self)); end To_String; ----------------- -- Deserialize -- ----------------- function Deserialize (Value : Glib.Variant.Gvariant) return G_Icon is function Internal (Value : System.Address) return G_Icon; pragma Import (C, Internal, "g_icon_deserialize"); begin return Internal (Get_Object (Value)); end Deserialize; -------------------- -- New_For_String -- -------------------- function New_For_String (Str : UTF8_String) return G_Icon is function Internal (Str : Gtkada.Types.Chars_Ptr) return G_Icon; pragma Import (C, Internal, "g_icon_new_for_string"); Tmp_Str : Gtkada.Types.Chars_Ptr := New_String (Str); Tmp_Return : G_Icon; begin Tmp_Return := Internal (Tmp_Str); Free (Tmp_Str); return Tmp_Return; end New_For_String; function "+" (W : G_Icon) return G_Icon is begin return W; end "+"; end Glib.G_Icon; gtkada-24.0.0/src/generated/glib-g_icon.ads000066400000000000000000000152471446021174000204270ustar00rootroot00000000000000------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ -- -- Glib.G_Icon.G_Icon is a very minimal interface for icons. It provides -- functions for checking the equality of two icons, hashing of icons and -- serializing an icon to and from strings. -- -- Glib.G_Icon.G_Icon does not provide the actual pixmap for the icon as this -- is out of GIO's scope, however implementations of Glib.G_Icon.G_Icon may -- contain the name of an icon (see Gthemed.Icon.Gthemed_Icon), or the path to -- an icon (see Gloadable.Icon.Gloadable_Icon). -- -- To obtain a hash of a Glib.G_Icon.G_Icon, see Glib.G_Icon.Hash. -- -- To check if two GIcons are equal, see Glib.G_Icon.Equal. -- -- For serializing a Glib.G_Icon.G_Icon, use Glib.G_Icon.Serialize and -- Glib.G_Icon.Deserialize. -- -- If you want to consume Glib.G_Icon.G_Icon (for example, in a toolkit) you -- must be prepared to handle at least the three following cases: -- Gloadable.Icon.Gloadable_Icon, Gthemed.Icon.Gthemed_Icon and -- Gemblemed.Icon.Gemblemed_Icon. It may also make sense to have fast-paths -- for other cases (like handling Gdk.Pixbuf.Gdk_Pixbuf directly, for example) -- but all compliant Glib.G_Icon.G_Icon implementations outside of GIO must -- implement Gloadable.Icon.Gloadable_Icon. -- -- If your application or library provides one or more Glib.G_Icon.G_Icon -- implementations you need to ensure that your new implementation also -- implements Gloadable.Icon.Gloadable_Icon. Additionally, you must provide an -- implementation of Glib.G_Icon.Serialize that gives a result that is -- understood by Glib.G_Icon.Deserialize, yielding one of the built-in icon -- types. -- -- pragma Warnings (Off, "*is already use-visible*"); with Glib.Types; use Glib.Types; with Glib.Variant; use Glib.Variant; package Glib.G_Icon is type G_Icon is new Glib.Types.GType_Interface; Null_G_Icon : constant G_Icon; ------------------ -- Constructors -- ------------------ function Get_Type return Glib.GType; pragma Import (C, Get_Type, "g_icon_get_type"); ------------- -- Methods -- ------------- function Equal (Self : G_Icon; Icon2 : G_Icon) return Boolean; -- Checks if two icons are equal. -- "icon2": pointer to the second Glib.G_Icon.G_Icon. function Serialize (Self : G_Icon) return Glib.Variant.Gvariant; -- Serializes a Glib.G_Icon.G_Icon into a Glib.Variant.Gvariant. An -- equivalent Glib.G_Icon.G_Icon can be retrieved back by calling -- Glib.G_Icon.Deserialize on the returned value. As serialization will -- avoid using raw icon data when possible, it only makes sense to transfer -- the Glib.Variant.Gvariant between processes on the same machine, (as -- opposed to over the network), and within the same file system namespace. -- Since: gtk+ 2.38 function To_String (Self : G_Icon) return UTF8_String; -- Generates a textual representation of Icon that can be used for -- serialization such as when passing Icon to a different process or saving -- it to persistent storage. Use Glib.G_Icon.New_For_String to get Icon -- back from the returned string. -- The encoding of the returned string is proprietary to -- Glib.G_Icon.G_Icon except in the following two cases -- - If Icon is a Gfile.Icon.Gfile_Icon, the returned string is a native -- path (such as `/path/to/my icon.png`) without escaping if the -- Gfile.Gfile for Icon is a native file. If the file is not native, the -- returned string is the result of g_file_get_uri (such as -- `sftp://path/to/my%20icon.png`). -- - If Icon is a Gthemed.Icon.Gthemed_Icon with exactly one name and no -- fallbacks, the encoding is simply the name (such as `network-server`). -- Since: gtk+ 2.20 --------------- -- Functions -- --------------- function Deserialize (Value : Glib.Variant.Gvariant) return G_Icon; -- Deserializes a Glib.G_Icon.G_Icon previously serialized using -- Glib.G_Icon.Serialize. -- Since: gtk+ 2.38 -- "value": a Glib.Variant.Gvariant created with Glib.G_Icon.Serialize function Hash (Icon : G_Icon) return Guint; pragma Import (C, Hash, "g_icon_hash"); -- Gets a hash for an icon. -- "icon": gconstpointer to an icon object. function New_For_String (Str : UTF8_String) return G_Icon; -- Generate a Glib.G_Icon.G_Icon instance from Str. This function can fail -- if Str is not valid - see Glib.G_Icon.To_String for discussion. -- If your application or library provides one or more Glib.G_Icon.G_Icon -- implementations you need to ensure that each GType is registered with -- the type system prior to calling Glib.G_Icon.New_For_String. -- Since: gtk+ 2.20 -- "str": A string obtained via Glib.G_Icon.To_String. ---------------- -- Interfaces -- ---------------- -- This class implements several interfaces. See Glib.Types -- -- - "G_Icon" function "+" (W : G_Icon) return G_Icon; pragma Inline ("+"); private Null_G_Icon : constant G_Icon := G_Icon (Glib.Types.Null_Interface); end Glib.G_Icon; gtkada-24.0.0/src/generated/glib-iochannel.adb000066400000000000000000000211311446021174000210750ustar00rootroot00000000000000------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ pragma Style_Checks (Off); pragma Warnings (Off, "*is already use-visible*"); with Gtkada.Bindings; use Gtkada.Bindings; package body Glib.IOChannel is function From_Object_Free (B : access GIOFuncs) return GIOFuncs is Result : constant GIOFuncs := B.all; begin Glib.g_free (B.all'Address); return Result; end From_Object_Free; function From_Object_Free (B : access GIO_Channel_Record) return GIO_Channel_Record is Result : constant GIO_Channel_Record := B.all; begin Glib.g_free (B.all'Address); return Result; end From_Object_Free; ------------------ -- Set_Encoding -- ------------------ function Set_Encoding (Self : Giochannel; Encoding : UTF8_String := ""; Error : access Glib.Error.GError) return GIOStatus is function Internal (Self : Giochannel; Encoding : Gtkada.Types.Chars_Ptr; Error : access Glib.Error.GError) return GIOStatus; pragma Import (C, Internal, "g_io_channel_set_encoding"); Tmp_Encoding : Gtkada.Types.Chars_Ptr; Tmp_Return : GIOStatus; begin if Encoding = "" then Tmp_Encoding := Gtkada.Types.Null_Ptr; else Tmp_Encoding := New_String (Encoding); end if; Tmp_Return := Internal (Self, Tmp_Encoding, Error); Free (Tmp_Encoding); return Tmp_Return; end Set_Encoding; ---------------- -- Read_Chars -- ---------------- function Read_Chars (Self : Giochannel; Buf : out Ada.Streams.Stream_Element_Array; Bytes_Read : access Gsize; Error : access Glib.Error.GError) return GIOStatus is function Internal (Self : Giochannel; Buf : System.Address; Count : Gsize; Acc_Bytes_Read : access Gsize; Error : access Glib.Error.GError) return GIOStatus; pragma Import (C, Internal, "g_io_channel_read_chars"); Acc_Bytes_Read : aliased Gsize; Tmp_Return : GIOStatus; begin Tmp_Return := Internal (Self, Buf'Address, Buf'Length, Acc_Bytes_Read'Access, Error); if Bytes_Read /= null then Bytes_Read.all := Acc_Bytes_Read; end if; return Tmp_Return; end Read_Chars; ----------------- -- Write_Chars -- ----------------- function Write_Chars (Self : Giochannel; Buf : Ada.Streams.Stream_Element_Array; Bytes_Written : access Gsize; Error : access Glib.Error.GError) return GIOStatus is function Internal (Self : Giochannel; Buf : System.Address; Count : Gssize; Acc_Bytes_Written : access Gsize; Error : access Glib.Error.GError) return GIOStatus; pragma Import (C, Internal, "g_io_channel_write_chars"); Acc_Bytes_Written : aliased Gsize; Tmp_Return : GIOStatus; begin Tmp_Return := Internal (Self, Buf'Address, Buf'Length, Acc_Bytes_Written'Access, Error); Bytes_Written.all := Acc_Bytes_Written; return Tmp_Return; end Write_Chars; ---------------- -- G_Unix_New -- ---------------- procedure G_Unix_New (Self : out Giochannel; Fd : Glib.Gint) is function Internal (Fd : Glib.Gint) return Giochannel; pragma Import (C, Internal, "g_io_channel_unix_new"); begin Self := Internal (Fd); end G_Unix_New; ------------------------- -- Giochannel_Unix_New -- ------------------------- function Giochannel_Unix_New (Fd : Glib.Gint) return Giochannel is function Internal (Fd : Glib.Gint) return Giochannel; pragma Import (C, Internal, "g_io_channel_unix_new"); Self : Giochannel; begin Self := Internal (Fd); return Self; end Giochannel_Unix_New; ------------------ -- Get_Buffered -- ------------------ function Get_Buffered (Self : Giochannel) return Boolean is function Internal (Self : Giochannel) return Glib.Gboolean; pragma Import (C, Internal, "g_io_channel_get_buffered"); begin return Internal (Self) /= 0; end Get_Buffered; ------------------------ -- Get_Close_On_Unref -- ------------------------ function Get_Close_On_Unref (Self : Giochannel) return Boolean is function Internal (Self : Giochannel) return Glib.Gboolean; pragma Import (C, Internal, "g_io_channel_get_close_on_unref"); begin return Internal (Self) /= 0; end Get_Close_On_Unref; ------------------ -- Get_Encoding -- ------------------ function Get_Encoding (Self : Giochannel) return UTF8_String is function Internal (Self : Giochannel) return Gtkada.Types.Chars_Ptr; pragma Import (C, Internal, "g_io_channel_get_encoding"); begin return Gtkada.Bindings.Value_Allowing_Null (Internal (Self)); end Get_Encoding; ------------------- -- Get_Line_Term -- ------------------- function Get_Line_Term (Self : Giochannel; Length : in out Glib.Gint) return UTF8_String is function Internal (Self : Giochannel; Acc_Length : access Glib.Gint) return Gtkada.Types.Chars_Ptr; pragma Import (C, Internal, "g_io_channel_get_line_term"); Acc_Length : aliased Glib.Gint := Length; Tmp_Return : Gtkada.Types.Chars_Ptr; begin Tmp_Return := Internal (Self, Acc_Length'Access); Length := Acc_Length; return Gtkada.Bindings.Value_Allowing_Null (Tmp_Return); end Get_Line_Term; ------------------ -- Set_Buffered -- ------------------ procedure Set_Buffered (Self : Giochannel; Buffered : Boolean) is procedure Internal (Self : Giochannel; Buffered : Glib.Gboolean); pragma Import (C, Internal, "g_io_channel_set_buffered"); begin Internal (Self, Boolean'Pos (Buffered)); end Set_Buffered; ------------------------ -- Set_Close_On_Unref -- ------------------------ procedure Set_Close_On_Unref (Self : Giochannel; Do_Close : Boolean) is procedure Internal (Self : Giochannel; Do_Close : Glib.Gboolean); pragma Import (C, Internal, "g_io_channel_set_close_on_unref"); begin Internal (Self, Boolean'Pos (Do_Close)); end Set_Close_On_Unref; ------------------- -- Set_Line_Term -- ------------------- procedure Set_Line_Term (Self : Giochannel; Line_Term : UTF8_String := ""; Length : Glib.Gint) is procedure Internal (Self : Giochannel; Line_Term : Gtkada.Types.Chars_Ptr; Length : Glib.Gint); pragma Import (C, Internal, "g_io_channel_set_line_term"); Tmp_Line_Term : Gtkada.Types.Chars_Ptr; begin if Line_Term = "" then Tmp_Line_Term := Gtkada.Types.Null_Ptr; else Tmp_Line_Term := New_String (Line_Term); end if; Internal (Self, Tmp_Line_Term, Length); Free (Tmp_Line_Term); end Set_Line_Term; end Glib.IOChannel; gtkada-24.0.0/src/generated/glib-iochannel.ads000066400000000000000000000573741446021174000211400ustar00rootroot00000000000000------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ -- -- A data structure representing an IO Channel. The fields should be -- considered private and should only be accessed with the following -- functions. -- -- pragma Warnings (Off, "*is already use-visible*"); with Ada.Streams; use Ada.Streams; with Glib.Error; use Glib.Error; with Glib.Generic_Properties; use Glib.Generic_Properties; with Glib.Main; use Glib.Main; with Glib.String; use Glib.String; with Gtkada.Types; use Gtkada.Types; package Glib.IOChannel is type GIOCondition is mod 2 ** Integer'Size; pragma Convention (C, GIOCondition); -- A bitwise combination representing a condition to watch for on an event -- source. G_Io_In : constant GIOCondition := 1; G_Io_Out : constant GIOCondition := 4; G_Io_Pri : constant GIOCondition := 2; G_Io_Err : constant GIOCondition := 8; G_Io_Hup : constant GIOCondition := 16; G_Io_Nval : constant GIOCondition := 32; type GIOFlags is mod 2 ** Integer'Size; pragma Convention (C, GIOFlags); -- Specifies properties of a Glib.IOChannel.Giochannel. Some of the flags -- can only be read with Glib.IOChannel.Get_Flags, but not changed with -- g_io_channel_set_flags. G_Io_Flag_Append : constant GIOFlags := 1; G_Io_Flag_Nonblock : constant GIOFlags := 2; G_Io_Flag_Is_Readable : constant GIOFlags := 4; G_Io_Flag_Is_Writable : constant GIOFlags := 8; G_Io_Flag_Is_Writeable : constant GIOFlags := 8; G_Io_Flag_Is_Seekable : constant GIOFlags := 16; G_Io_Flag_Mask : constant GIOFlags := 31; G_Io_Flag_Get_Mask : constant GIOFlags := 31; G_Io_Flag_Set_Mask : constant GIOFlags := 3; type GIOStatus is ( G_Io_Status_Error, G_Io_Status_Normal, G_Io_Status_Eof, G_Io_Status_Again); pragma Convention (C, GIOStatus); -- Stati returned by most of the Glib.IOChannel.GIOFuncs functions. type GIOError is ( G_Io_Error_None, G_Io_Error_Again, G_Io_Error_Inval, G_Io_Error_Unknown); pragma Convention (C, GIOError); -- Glib.IOChannel.GIOError is only used by the deprecated functions -- g_io_channel_read, g_io_channel_write, and g_io_channel_seek. type GIOChannel_Error is ( G_Io_Channel_Error_Fbig, G_Io_Channel_Error_Inval, G_Io_Channel_Error_Io, G_Io_Channel_Error_Isdir, G_Io_Channel_Error_Nospc, G_Io_Channel_Error_Nxio, G_Io_Channel_Error_Overflow, G_Io_Channel_Error_Pipe, G_Io_Channel_Error_Failed); pragma Convention (C, GIOChannel_Error); -- Error codes returned by Glib.IOChannel.Giochannel operations. type GSeek_Type is ( G_Seek_Cur, G_Seek_Set, G_Seek_End); pragma Convention (C, GSeek_Type); -- An enumeration specifying the base position for a -- Glib.IOChannel.Seek_Position operation. type GIOFuncs is record Io_Read : System.Address; Io_Write : System.Address; Io_Seek : System.Address; Io_Close : System.Address; Io_Create_Watch : System.Address; Io_Free : System.Address; Io_Set_Flags : System.Address; Io_Get_Flags : System.Address; end record; pragma Convention (C, GIOFuncs); function From_Object_Free (B : access GIOFuncs) return GIOFuncs; pragma Inline (From_Object_Free); -- A table of functions used to handle different types of -- Glib.IOChannel.Giochannel in a generic way. type GIO_Channel_Record is record Ref_Count : Glib.Gint := 0; Funcs : GIOFuncs; Encoding : Gtkada.Types.Chars_Ptr; Read_Cd : System.Address; Write_Cd : System.Address; Line_Term : Gtkada.Types.Chars_Ptr; Line_Term_Len : Guint; Buf_Size : Gsize; Read_Buf : Glib.String.Gstring; Encoded_Read_Buf : Glib.String.Gstring; Write_Buf : Glib.String.Gstring; Partial_Write_Buf : Gchar_Array (1 .. 6); Use_Buffer : Guint; Do_Encode : Guint; Close_On_Unref : Guint; Is_Readable : Guint; Is_Writeable : Guint; Is_Seekable : Guint; Reserved1 : System.Address := System.Null_Address; Reserved2 : System.Address := System.Null_Address; end record; pragma Convention (C, GIO_Channel_Record); function From_Object_Free (B : access GIO_Channel_Record) return GIO_Channel_Record; pragma Inline (From_Object_Free); -- A data structure representing an IO Channel. The fields should be -- considered private and should only be accessed with the following -- functions. type Giochannel is access all GIO_Channel_Record; pragma No_Strict_Aliasing (Giochannel); ---------------------------- -- Enumeration Properties -- ---------------------------- package GIOCondition_Properties is new Generic_Internal_Discrete_Property (GIOCondition); type Property_GIOCondition is new GIOCondition_Properties.Property; package GIOFlags_Properties is new Generic_Internal_Discrete_Property (GIOFlags); type Property_GIOFlags is new GIOFlags_Properties.Property; package GIOStatus_Properties is new Generic_Internal_Discrete_Property (GIOStatus); type Property_GIOStatus is new GIOStatus_Properties.Property; package GIOError_Properties is new Generic_Internal_Discrete_Property (GIOError); type Property_GIOError is new GIOError_Properties.Property; package GIOChannel_Error_Properties is new Generic_Internal_Discrete_Property (GIOChannel_Error); type Property_GIOChannel_Error is new GIOChannel_Error_Properties.Property; package GSeek_Type_Properties is new Generic_Internal_Discrete_Property (GSeek_Type); type Property_GSeek_Type is new GSeek_Type_Properties.Property; ------------------ -- Constructors -- ------------------ procedure G_Unix_New (Self : out Giochannel; Fd : Glib.Gint); -- Creates a new Glib.IOChannel.Giochannel given a file descriptor. On -- UNIX systems this works for plain files, pipes, and sockets. -- The returned Glib.IOChannel.Giochannel has a reference count of 1. -- The default encoding for Glib.IOChannel.Giochannel is UTF-8. If your -- application is reading output from a command using via pipe, you may -- need to set the encoding to the encoding of the current locale (see -- g_get_charset) with the g_io_channel_set_encoding function. -- If you want to read raw binary data without interpretation, then call -- the g_io_channel_set_encoding function with null for the encoding -- argument. -- This function is available in GLib on Windows, too, but you should -- avoid using it on Windows. The domain of file descriptors and sockets -- overlap. There is no way for GLib to know which one you mean in case the -- argument you pass to this function happens to be both a valid file -- descriptor and socket. If that happens a warning is issued, and GLib -- assumes that it is the file descriptor you mean. -- "fd": a file descriptor. function Giochannel_Unix_New (Fd : Glib.Gint) return Giochannel; -- Creates a new Glib.IOChannel.Giochannel given a file descriptor. On -- UNIX systems this works for plain files, pipes, and sockets. -- The returned Glib.IOChannel.Giochannel has a reference count of 1. -- The default encoding for Glib.IOChannel.Giochannel is UTF-8. If your -- application is reading output from a command using via pipe, you may -- need to set the encoding to the encoding of the current locale (see -- g_get_charset) with the g_io_channel_set_encoding function. -- If you want to read raw binary data without interpretation, then call -- the g_io_channel_set_encoding function with null for the encoding -- argument. -- This function is available in GLib on Windows, too, but you should -- avoid using it on Windows. The domain of file descriptors and sockets -- overlap. There is no way for GLib to know which one you mean in case the -- argument you pass to this function happens to be both a valid file -- descriptor and socket. If that happens a warning is issued, and GLib -- assumes that it is the file descriptor you mean. -- "fd": a file descriptor. ------------- -- Methods -- ------------- function Get_Buffer_Condition (Self : Giochannel) return GIOCondition; pragma Import (C, Get_Buffer_Condition, "g_io_channel_get_buffer_condition"); -- This function returns a Glib.IOChannel.GIOCondition depending on -- whether there is data to be read/space to write data in the internal -- buffers in the Glib.IOChannel.Giochannel. Only the flags -- Glib.IOChannel.G_Io_In and Glib.IOChannel.G_Io_Out may be set. function Get_Buffer_Size (Self : Giochannel) return Gsize; pragma Import (C, Get_Buffer_Size, "g_io_channel_get_buffer_size"); -- Gets the buffer size. procedure Set_Buffer_Size (Self : Giochannel; Size : Gsize); pragma Import (C, Set_Buffer_Size, "g_io_channel_set_buffer_size"); -- Sets the buffer size. -- "size": the size of the buffer, or 0 to let GLib pick a good size function Get_Buffered (Self : Giochannel) return Boolean; -- Returns whether Channel is buffered. procedure Set_Buffered (Self : Giochannel; Buffered : Boolean); -- The buffering state can only be set if the channel's encoding is null. -- For any other encoding, the channel must be buffered. -- A buffered channel can only be set unbuffered if the channel's internal -- buffers have been flushed. Newly created channels or channels which have -- returned Glib.IOChannel.G_Io_Status_Eof not require such a flush. For -- write-only channels, a call to g_io_channel_flush () is sufficient. For -- all other channels, the buffers may be flushed by a call to -- g_io_channel_seek_position (). This includes the possibility of seeking -- with seek type Glib.IOChannel.G_Seek_Cur and an offset of zero. Note -- that this means that socket-based channels cannot be set unbuffered once -- they have had data read from them. -- On unbuffered channels, it is safe to mix read and write calls from the -- new and old APIs, if this is necessary for maintaining old code. -- The default state of the channel is buffered. -- "buffered": whether to set the channel buffered or unbuffered function Get_Close_On_Unref (Self : Giochannel) return Boolean; -- Returns whether the file/socket/whatever associated with Channel will -- be closed when Channel receives its final unref and is destroyed. The -- default value of this is True for channels created by -- g_io_channel_new_file (), and False for all other channels. procedure Set_Close_On_Unref (Self : Giochannel; Do_Close : Boolean); -- Setting this flag to True for a channel you have already closed can -- cause problems. -- "do_close": Whether to close the channel on the final unref of the -- GIOChannel data structure. The default value of this is True for -- channels created by g_io_channel_new_file (), and False for all other -- channels. function Get_Encoding (Self : Giochannel) return UTF8_String; -- Gets the encoding for the input/output of the channel. The internal -- encoding is always UTF-8. The encoding null makes the channel safe for -- binary data. function Get_Flags (Self : Giochannel) return GIOFlags; pragma Import (C, Get_Flags, "g_io_channel_get_flags"); -- Gets the current flags for a Glib.IOChannel.Giochannel, including -- read-only flags such as Glib.IOChannel.G_Io_Flag_Is_Readable. -- The values of the flags Glib.IOChannel.G_Io_Flag_Is_Readable and -- Glib.IOChannel.G_Io_Flag_Is_Writable are cached for internal use by the -- channel when it is created. If they should change at some later point -- (e.g. partial shutdown of a socket with the UNIX shutdown function), the -- user should immediately call Glib.IOChannel.Get_Flags to update the -- internal values of these flags. function Get_Line_Term (Self : Giochannel; Length : in out Glib.Gint) return UTF8_String; -- This returns the string that Glib.IOChannel.Giochannel uses to -- determine where in the file a line break occurs. A value of null -- indicates autodetection. -- "length": a location to return the length of the line terminator procedure Set_Line_Term (Self : Giochannel; Line_Term : UTF8_String := ""; Length : Glib.Gint); -- This sets the string that Glib.IOChannel.Giochannel uses to determine -- where in the file a line break occurs. -- "line_term": The line termination string. Use null for autodetect. -- Autodetection breaks on "\n", "\r\n", "\r", "\0", and the Unicode -- paragraph separator. Autodetection should not be used for anything other -- than file-based channels. -- "length": The length of the termination string. If -1 is passed, the -- string is assumed to be nul-terminated. This option allows termination -- strings with embedded nuls. procedure Init (Self : Giochannel); pragma Import (C, Init, "g_io_channel_init"); -- Initializes a Glib.IOChannel.Giochannel struct. -- This is called by each of the above functions when creating a -- Glib.IOChannel.Giochannel, and so is not often needed by the application -- programmer (unless you are creating a new type of -- Glib.IOChannel.Giochannel). function Ref (Self : Giochannel) return Giochannel; pragma Import (C, Ref, "g_io_channel_ref"); -- Increments the reference count of a Glib.IOChannel.Giochannel. function Seek_Position (Self : Giochannel; Offset : Gint64; The_Type : GSeek_Type) return GIOStatus; pragma Import (C, Seek_Position, "g_io_channel_seek_position"); -- Replacement for g_io_channel_seek with the new API. -- "offset": The offset in bytes from the position specified by Type -- "type": a Glib.IOChannel.GSeek_Type. The type Glib.IOChannel.G_Seek_Cur -- is only allowed in those cases where a call to g_io_channel_set_encoding -- () is allowed. See the documentation for g_io_channel_set_encoding () -- for details. function Unix_Get_Fd (Self : Giochannel) return Glib.Gint; pragma Import (C, Unix_Get_Fd, "g_io_channel_unix_get_fd"); -- Returns the file descriptor of the Glib.IOChannel.Giochannel. -- On Windows this function returns the file descriptor or socket of the -- Glib.IOChannel.Giochannel. procedure Unref (Self : Giochannel); pragma Import (C, Unref, "g_io_channel_unref"); -- Decrements the reference count of a Glib.IOChannel.Giochannel. ---------------------- -- GtkAda additions -- ---------------------- function Shutdown (Self : Giochannel; Flush : Glib.Gboolean; Error : access Glib.Error.GError) return GIOStatus; pragma Import (C, Shutdown, "g_io_channel_shutdown"); -- Close an IO channel. Any pending data to be written will be flushed if -- Flush is True. The channel will not be freed until the last reference is -- dropped using Glib.IOChannel.Unref. -- "flush": if True, flush pending function Flush (Self : Giochannel; Error : access Glib.Error.GError) return GIOStatus; pragma Import (C, Flush, "g_io_channel_flush"); -- Flushes the write buffer for the GIOChannel. function Set_Encoding (Self : Giochannel; Encoding : UTF8_String := ""; Error : access Glib.Error.GError) return GIOStatus; -- Sets the encoding for the input/output of the channel. The internal -- encoding is always UTF-8. The default encoding for the external file is -- UTF-8. -- The encoding null is safe to use with binary data. -- The encoding can only be set if one of the following conditions is -- true: -- - The channel was just created, and has not been written to or read -- from yet. -- - The channel is write-only. -- - The channel is a file, and the file pointer was just repositioned by -- a call to Glib.IOChannel.Seek_Position. (This flushes all the internal -- buffers.) -- - The current encoding is null or UTF-8. -- - One of the (new API) read functions has just returned -- Glib.IOChannel.G_Io_Status_Eof (or, in the case of -- g_io_channel_read_to_end, Glib.IOChannel.G_Io_Status_Normal). -- - One of the functions Glib.IOChannel.Read_Chars or -- Glib.IOChannel.Read_Unichar has returned -- Glib.IOChannel.G_Io_Status_Again or Glib.IOChannel.G_Io_Status_Error. -- This may be useful in the case of G_CONVERT_ERROR_ILLEGAL_SEQUENCE. -- Returning one of these statuses from g_io_channel_read_line, -- Glib.IOChannel.Read_Line_String, or g_io_channel_read_to_end does not -- guarantee that the encoding can be changed. -- Channels which do not meet one of the above conditions cannot call -- Glib.IOChannel.Seek_Position with an offset of -- Glib.IOChannel.G_Seek_Cur, and, if they are "seekable", cannot call -- Glib.IOChannel.Write_Chars after calling one of the API "read" -- functions. -- "encoding": the encoding type function Set_Flags (Self : Giochannel; Flags : GIOFlags; Error : access Glib.Error.GError) return GIOStatus; pragma Import (C, Set_Flags, "g_io_channel_set_flags"); -- Sets the (writeable) flags in Channel to (Flags and -- Glib.IOChannel.G_Io_Flag_Set_Mask). -- "flags": the flags to set on the IO channel function Read_Chars (Self : Giochannel; Buf : out Ada.Streams.Stream_Element_Array; Bytes_Read : access Gsize; Error : access Glib.Error.GError) return GIOStatus; -- Replacement for g_io_channel_read with the new API. -- "buf": a buffer to read data into -- "count": is sent as Buf'Length. -- "bytes_read": The number of bytes read. This may be zero even on -- success if count less than 6 and the channel's encoding is non-null. -- This indicates that the next UTF-8 character is too wide for -- the buffer. function Write_Chars (Self : Giochannel; Buf : Ada.Streams.Stream_Element_Array; Bytes_Written : access Gsize; Error : access Glib.Error.GError) return GIOStatus; -- Replacement for g_io_channel_write with the new API. -- On seekable channels with encodings other than null or UTF-8, generic -- mixing of reading and writing is not allowed. A call to -- g_io_channel_write_chars () may only be made on a channel from which -- data has been read in the cases described in the documentation for -- g_io_channel_set_encoding (). -- "buf": a buffer to write data from -- "count": is sent as Buf'Length. -- "bytes_written": The number of bytes written. This can be nonzero even -- if the return value is not Glib.IOChannel.G_Io_Status_Normal. If the -- return value is Glib.IOChannel.G_Io_Status_Normal and the channel is -- blocking, this will always be equal to Count if Count >= 0. function Read_Line_String (Self : Giochannel; Buffer : Glib.String.Gstring; Terminator_Pos : in out Gsize; Error : access Glib.Error.GError) return GIOStatus; pragma Import (C, Read_Line_String, "g_io_channel_read_line_string"); -- Reads a line from a Glib.IOChannel.Giochannel, using a -- Glib.String.Gstring as a buffer. -- "buffer": a Glib.String.Gstring into which the line will be written. If -- Buffer already contains data, the old data will be overwritten. -- "terminator_pos": location to store position of line terminator, or -- null function Read_Unichar (Self : Giochannel; Thechar : access Gunichar; Error : access Glib.Error.GError) return GIOStatus; pragma Import (C, Read_Unichar, "g_io_channel_read_unichar"); -- Reads a Unicode character from Channel. This function cannot be called -- on a channel with null encoding. -- "thechar": a location to return a character function Write_Unichar (Self : Giochannel; Thechar : Gunichar; Error : access Glib.Error.GError) return GIOStatus; pragma Import (C, Write_Unichar, "g_io_channel_write_unichar"); -- Writes a Unicode character to Channel. This function cannot be called -- on a channel with null encoding. -- "thechar": a character generic type User_Data is limited private; function Generic_Add_Watch (Channel : Giochannel; Condition : GIOCondition; Callback : access function (Source : Giochannel; Condition : GIOCondition; Data : access User_Data) return Glib.Gboolean; Data : access User_Data) return Glib.Main.G_Source_Id; pragma Import (C, Generic_Add_Watch, "g_io_add_watch"); -- Adds the Glib.IOChannel.Giochannel into the default main loop context -- with the default priority. -- "channel": a Glib.IOChannel.Giochannel -- "condition": the condition to watch for -- "callback": the function to call when the condition is satisfied --------------- -- Functions -- --------------- function Error_From_Errno (En : Glib.Gint) return GIOChannel_Error; pragma Import (C, Error_From_Errno, "g_io_channel_error_from_errno"); -- Converts an `errno` error number to a Glib.IOChannel.GIOChannel_Error. -- "en": an `errno` error number, e.g. `EINVAL` function Error_Quark return Glib.GQuark; pragma Import (C, Error_Quark, "g_io_channel_error_quark"); function Io_Create_Watch (Channel : Giochannel; Condition : GIOCondition) return Glib.Main.G_Source; pragma Import (C, Io_Create_Watch, "g_io_create_watch"); -- Creates a Glib.Main.G_Source that's dispatched when Condition is met -- for the given Channel. For example, if condition is G_IO_IN, the source -- will be dispatched when there's data available for reading. -- g_io_add_watch is a simpler interface to this same functionality, for -- the case where you want to add the source to the default main loop -- context at the default priority. -- On Windows, polling a Glib.Main.G_Source created to watch a channel for -- a socket puts the socket in non-blocking mode. This is a side-effect of -- the implementation and unavoidable. -- "channel": a Glib.IOChannel.Giochannel to watch -- "condition": conditions to watch for end Glib.IOChannel; gtkada-24.0.0/src/generated/glib-list_model.adb000066400000000000000000000176701446021174000213050ustar00rootroot00000000000000------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ pragma Style_Checks (Off); pragma Warnings (Off, "*is already use-visible*"); with Ada.Unchecked_Conversion; with Glib.Values; use Glib.Values; with Gtk.Arguments; use Gtk.Arguments; with Gtkada.Bindings; use Gtkada.Bindings; package body Glib.List_Model is ---------------- -- Get_Object -- ---------------- function Get_Object (Self : Glist_Model; Position : Guint) return Glib.Object.GObject is function Internal (Self : Glist_Model; Position : Guint) return System.Address; pragma Import (C, Internal, "g_list_model_get_object"); Stub_GObject : Glib.Object.GObject_Record; begin return Get_User_Data (Internal (Self, Position), Stub_GObject); end Get_Object; use type System.Address; function Cb_To_Address is new Ada.Unchecked_Conversion (Cb_Glist_Model_Guint_Guint_Guint_Void, System.Address); function Address_To_Cb is new Ada.Unchecked_Conversion (System.Address, Cb_Glist_Model_Guint_Guint_Guint_Void); function Cb_To_Address is new Ada.Unchecked_Conversion (Cb_GObject_Guint_Guint_Guint_Void, System.Address); function Address_To_Cb is new Ada.Unchecked_Conversion (System.Address, Cb_GObject_Guint_Guint_Guint_Void); procedure Connect (Object : Glist_Model; C_Name : Glib.Signal_Name; Handler : Cb_Glist_Model_Guint_Guint_Guint_Void; After : Boolean); procedure Connect_Slot (Object : Glist_Model; C_Name : Glib.Signal_Name; Handler : Cb_GObject_Guint_Guint_Guint_Void; After : Boolean; Slot : access Glib.Object.GObject_Record'Class := null); procedure Marsh_GObject_Guint_Guint_Guint_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address); pragma Convention (C, Marsh_GObject_Guint_Guint_Guint_Void); procedure Marsh_Glist_Model_Guint_Guint_Guint_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address); pragma Convention (C, Marsh_Glist_Model_Guint_Guint_Guint_Void); ------------- -- Connect -- ------------- procedure Connect (Object : Glist_Model; C_Name : Glib.Signal_Name; Handler : Cb_Glist_Model_Guint_Guint_Guint_Void; After : Boolean) is begin Unchecked_Do_Signal_Connect (Object => Glib.Types.GType_Interface (Object), C_Name => C_Name, Marshaller => Marsh_Glist_Model_Guint_Guint_Guint_Void'Access, Handler => Cb_To_Address (Handler),-- Set in the closure After => After); end Connect; ------------------ -- Connect_Slot -- ------------------ procedure Connect_Slot (Object : Glist_Model; C_Name : Glib.Signal_Name; Handler : Cb_GObject_Guint_Guint_Guint_Void; After : Boolean; Slot : access Glib.Object.GObject_Record'Class := null) is begin Unchecked_Do_Signal_Connect (Object => Glib.Types.GType_Interface (Object), C_Name => C_Name, Marshaller => Marsh_GObject_Guint_Guint_Guint_Void'Access, Handler => Cb_To_Address (Handler),-- Set in the closure Slot_Object => Slot, After => After); end Connect_Slot; ------------------------------------------ -- Marsh_GObject_Guint_Guint_Guint_Void -- ------------------------------------------ procedure Marsh_GObject_Guint_Guint_Guint_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address) is pragma Unreferenced (Return_Value, N_Params, Invocation_Hint, User_Data); H : constant Cb_GObject_Guint_Guint_Guint_Void := Address_To_Cb (Get_Callback (Closure)); Obj : constant Glib.Object.GObject := Glib.Object.Convert (Get_Data (Closure)); begin H (Obj, Unchecked_To_Guint (Params, 1), Unchecked_To_Guint (Params, 2), Unchecked_To_Guint (Params, 3)); exception when E : others => Process_Exception (E); end Marsh_GObject_Guint_Guint_Guint_Void; ---------------------------------------------- -- Marsh_Glist_Model_Guint_Guint_Guint_Void -- ---------------------------------------------- procedure Marsh_Glist_Model_Guint_Guint_Guint_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address) is pragma Unreferenced (Return_Value, N_Params, Invocation_Hint, User_Data); H : constant Cb_Glist_Model_Guint_Guint_Guint_Void := Address_To_Cb (Get_Callback (Closure)); Obj : constant Glist_Model := Glist_Model (Unchecked_To_Interface (Params, 0)); begin H (Obj, Unchecked_To_Guint (Params, 1), Unchecked_To_Guint (Params, 2), Unchecked_To_Guint (Params, 3)); exception when E : others => Process_Exception (E); end Marsh_Glist_Model_Guint_Guint_Guint_Void; ---------------------- -- On_Items_Changed -- ---------------------- procedure On_Items_Changed (Self : Glist_Model; Call : Cb_Glist_Model_Guint_Guint_Guint_Void; After : Boolean := False) is begin Connect (Self, "items-changed" & ASCII.NUL, Call, After); end On_Items_Changed; ---------------------- -- On_Items_Changed -- ---------------------- procedure On_Items_Changed (Self : Glist_Model; Call : Cb_GObject_Guint_Guint_Guint_Void; Slot : not null access Glib.Object.GObject_Record'Class; After : Boolean := False) is begin Connect_Slot (Self, "items-changed" & ASCII.NUL, Call, After, Slot); end On_Items_Changed; function "+" (W : Glist_Model) return Glist_Model is begin return W; end "+"; end Glib.List_Model; gtkada-24.0.0/src/generated/glib-list_model.ads000066400000000000000000000270741446021174000213250ustar00rootroot00000000000000------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ -- -- Glib.List_Model.Glist_Model is an interface that represents a mutable list -- of GObjects. Its main intention is as a model for various widgets in user -- interfaces, such as list views, but it can also be used as a convenient -- method of returning lists of data, with support for updates. -- -- Each object in the list may also report changes in itself via some -- mechanism (normally the Glib.Object.GObject::notify signal). Taken together -- with the Glib.List_Model.Glist_Model::items-changed signal, this provides -- for a list that can change its membership, and in which the members can -- change their individual properties. -- -- A good example would be the list of visible wireless network access -- points, where each access point can report dynamic properties such as -- signal strength. -- -- It is important to note that the Glib.List_Model.Glist_Model itself does -- not report changes to the individual items. It only reports changes to the -- list membership. If you want to observe changes to the objects themselves -- then you need to connect signals to the objects that you are interested in. -- -- All items in a Glib.List_Model.Glist_Model are of (or derived from) the -- same type. Glib.List_Model.Get_Item_Type returns that type. The type may be -- an interface, in which case all objects in the list must implement it. -- -- The semantics are close to that of an array: Glib.List_Model.Get_N_Items -- returns the number of items in the list and Glib.List_Model.Get_Item -- returns an item at a (0-based) position. In order to allow implementations -- to calculate the list length lazily, you can also iterate over items: -- starting from 0, repeatedly call Glib.List_Model.Get_Item until it returns -- null. -- -- An implementation may create objects lazily, but must take care to return -- the same object for a given position until all references to it are gone. -- -- On the other side, a consumer is expected only to hold references on -- objects that are currently "user visible", in order to facilitate the -- maximum level of laziness in the implementation of the list and to reduce -- the required number of signal connections at a given time. -- -- This interface is intended only to be used from a single thread. The -- thread in which it is appropriate to use it depends on the particular -- implementation, but typically it will be from the thread that owns the -- [thread-default main context][g-main-context-push-thread-default] in effect -- at the time that the model was created. -- -- pragma Warnings (Off, "*is already use-visible*"); with Glib.Object; use Glib.Object; with Glib.Types; use Glib.Types; package Glib.List_Model is type Glist_Model is new Glib.Types.GType_Interface; Null_Glist_Model : constant Glist_Model; ------------------ -- Constructors -- ------------------ function Get_Type return Glib.GType; pragma Import (C, Get_Type, "g_list_model_get_type"); ------------- -- Methods -- ------------- function Get_Item (Self : Glist_Model; Position : Guint) return System.Address; pragma Import (C, Get_Item, "g_list_model_get_item"); -- Get the item at Position. If Position is greater than the number of -- items in List, null is returned. -- null is never returned for an index that is smaller than the length of -- the list. See Glib.List_Model.Get_N_Items. -- Since: gtk+ 2.44 -- "position": the position of the item to fetch function Get_Item_Type (Self : Glist_Model) return GType; pragma Import (C, Get_Item_Type, "g_list_model_get_item_type"); -- Gets the type of the items in List. All items returned from -- g_list_model_get_type are of that type or a subtype, or are an -- implementation of that interface. -- The item type of a Glib.List_Model.Glist_Model can not change during -- the life of the model. -- Since: gtk+ 2.44 function Get_N_Items (Self : Glist_Model) return Guint; pragma Import (C, Get_N_Items, "g_list_model_get_n_items"); -- Gets the number of items in List. -- Depending on the model implementation, calling this function may be -- less efficient than iterating the list with increasing values for -- Position until Glib.List_Model.Get_Item returns null. -- Since: gtk+ 2.44 function Get_Object (Self : Glist_Model; Position : Guint) return Glib.Object.GObject; -- Get the item at Position. If Position is greater than the number of -- items in List, null is returned. -- null is never returned for an index that is smaller than the length of -- the list. See Glib.List_Model.Get_N_Items. -- Since: gtk+ 2.44 -- "position": the position of the item to fetch procedure Items_Changed (Self : Glist_Model; Position : Guint; Removed : Guint; Added : Guint); pragma Import (C, Items_Changed, "g_list_model_items_changed"); -- Emits the Glib.List_Model.Glist_Model::items-changed signal on List. -- This function should only be called by classes implementing -- Glib.List_Model.Glist_Model. It has to be called after the internal -- representation of List has been updated, because handlers connected to -- this signal might query the new state of the list. -- Implementations must only make changes to the model (as visible to its -- consumer) in places that will not cause problems for that consumer. For -- models that are driven directly by a write API (such as -- Glist.Store.Glist_Store), changes can be reported in response to uses of -- that API. For models that represent remote data, changes should only be -- made from a fresh mainloop dispatch. It is particularly not permitted to -- make changes in response to a call to the Glib.List_Model.Glist_Model -- consumer API. -- Stated another way: in general, it is assumed that code making a series -- of accesses to the model via the API, without returning to the mainloop, -- and without calling other code, will continue to view the same contents -- of the model. -- Since: gtk+ 2.44 -- "position": the position at which List changed -- "removed": the number of items removed -- "added": the number of items added ------------- -- Signals -- ------------- type Cb_Glist_Model_Guint_Guint_Guint_Void is not null access procedure (Self : Glist_Model; Position : Guint; Removed : Guint; Added : Guint); type Cb_GObject_Guint_Guint_Guint_Void is not null access procedure (Self : access Glib.Object.GObject_Record'Class; Position : Guint; Removed : Guint; Added : Guint); Signal_Items_Changed : constant Glib.Signal_Name := "items-changed"; procedure On_Items_Changed (Self : Glist_Model; Call : Cb_Glist_Model_Guint_Guint_Guint_Void; After : Boolean := False); procedure On_Items_Changed (Self : Glist_Model; Call : Cb_GObject_Guint_Guint_Guint_Void; Slot : not null access Glib.Object.GObject_Record'Class; After : Boolean := False); -- This signal is emitted whenever items were added to or removed from -- List. At Position, Removed items were removed and Added items were added -- in their place. -- -- Note: If Removed != Added, the positions of all later items in the -- model change. -- -- Callback parameters: -- -- "position": the position at which List changed -- -- "removed": the number of items removed -- -- "added": the number of items added ---------------- -- Interfaces -- ---------------- -- This class implements several interfaces. See Glib.Types -- -- - "Glist_Model" function "+" (W : Glist_Model) return Glist_Model; pragma Inline ("+"); --------------------- -- Virtual Methods -- --------------------- type Virtual_Get_Item is access function (Self : Glist_Model; Position : Guint) return System.Address; pragma Convention (C, Virtual_Get_Item); -- Get the item at Position. If Position is greater than the number of -- items in List, null is returned. -- null is never returned for an index that is smaller than the length of -- the list. See Glib.List_Model.Get_N_Items. -- Since: gtk+ 2.44 -- "position": the position of the item to fetch type Virtual_Get_Item_Type is access function (Self : Glist_Model) return GType; pragma Convention (C, Virtual_Get_Item_Type); -- Gets the type of the items in List. All items returned from -- g_list_model_get_type are of that type or a subtype, or are an -- implementation of that interface. -- The item type of a Glib.List_Model.Glist_Model can not change during -- the life of the model. -- Since: gtk+ 2.44 type Virtual_Get_N_Items is access function (Self : Glist_Model) return Guint; pragma Convention (C, Virtual_Get_N_Items); -- Gets the number of items in List. -- Depending on the model implementation, calling this function may be -- less efficient than iterating the list with increasing values for -- Position until Glib.List_Model.Get_Item returns null. -- Since: gtk+ 2.44 subtype List_Model_Interface_Descr is Glib.Object.Interface_Description; procedure Set_Get_Item (Self : List_Model_Interface_Descr; Handler : Virtual_Get_Item); pragma Import (C, Set_Get_Item, "gtkada_List_Model_set_get_item"); procedure Set_Get_Item_Type (Self : List_Model_Interface_Descr; Handler : Virtual_Get_Item_Type); pragma Import (C, Set_Get_Item_Type, "gtkada_List_Model_set_get_item_type"); procedure Set_Get_N_Items (Self : List_Model_Interface_Descr; Handler : Virtual_Get_N_Items); pragma Import (C, Set_Get_N_Items, "gtkada_List_Model_set_get_n_items"); -- See Glib.Object.Add_Interface private Null_Glist_Model : constant Glist_Model := Glist_Model (Glib.Types.Null_Interface); end Glib.List_Model; gtkada-24.0.0/src/generated/glib-menu.adb000066400000000000000000000636771446021174000201260ustar00rootroot00000000000000------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ pragma Style_Checks (Off); pragma Warnings (Off, "*is already use-visible*"); with Glib.Type_Conversion_Hooks; use Glib.Type_Conversion_Hooks; pragma Warnings(Off); -- might be unused with Gtkada.Types; use Gtkada.Types; pragma Warnings(On); package body Glib.Menu is package Type_Conversion_Gmenu is new Glib.Type_Conversion_Hooks.Hook_Registrator (Get_Type_Menu'Access, Gmenu_Record); pragma Unreferenced (Type_Conversion_Gmenu); package Type_Conversion_Gmenu_Item is new Glib.Type_Conversion_Hooks.Hook_Registrator (Get_Type_Menu_Item'Access, Gmenu_Item_Record); pragma Unreferenced (Type_Conversion_Gmenu_Item); ----------- -- G_New -- ----------- procedure G_New (Self : out Gmenu) is begin Self := new Gmenu_Record; Glib.Menu.Initialize (Self); end G_New; ----------- -- G_New -- ----------- procedure G_New (Self : out Gmenu_Item; Label : UTF8_String := ""; Detailed_Action : UTF8_String := "") is begin Self := new Gmenu_Item_Record; Glib.Menu.Initialize (Self, Label, Detailed_Action); end G_New; ---------------------- -- G_New_From_Model -- ---------------------- procedure G_New_From_Model (Self : out Gmenu_Item; Model : not null access Glib.Menu_Model.Gmenu_Model_Record'Class; Item_Index : Glib.Gint) is begin Self := new Gmenu_Item_Record; Glib.Menu.Initialize_From_Model (Self, Model, Item_Index); end G_New_From_Model; ------------------- -- G_New_Section -- ------------------- procedure G_New_Section (Self : out Gmenu_Item; Label : UTF8_String := ""; Section : not null access Glib.Menu_Model.Gmenu_Model_Record'Class) is begin Self := new Gmenu_Item_Record; Glib.Menu.Initialize_Section (Self, Label, Section); end G_New_Section; ------------------- -- G_New_Submenu -- ------------------- procedure G_New_Submenu (Self : out Gmenu_Item; Label : UTF8_String := ""; Submenu : not null access Glib.Menu_Model.Gmenu_Model_Record'Class) is begin Self := new Gmenu_Item_Record; Glib.Menu.Initialize_Submenu (Self, Label, Submenu); end G_New_Submenu; -------------------- -- Gmenu_Item_New -- -------------------- function Gmenu_Item_New (Label : UTF8_String := ""; Detailed_Action : UTF8_String := "") return Gmenu_Item is Self : constant Gmenu_Item := new Gmenu_Item_Record; begin Glib.Menu.Initialize (Self, Label, Detailed_Action); return Self; end Gmenu_Item_New; ------------------------------- -- Gmenu_Item_New_From_Model -- ------------------------------- function Gmenu_Item_New_From_Model (Model : not null access Glib.Menu_Model.Gmenu_Model_Record'Class; Item_Index : Glib.Gint) return Gmenu_Item is Self : constant Gmenu_Item := new Gmenu_Item_Record; begin Glib.Menu.Initialize_From_Model (Self, Model, Item_Index); return Self; end Gmenu_Item_New_From_Model; ---------------------------- -- Gmenu_Item_New_Section -- ---------------------------- function Gmenu_Item_New_Section (Label : UTF8_String := ""; Section : not null access Glib.Menu_Model.Gmenu_Model_Record'Class) return Gmenu_Item is Self : constant Gmenu_Item := new Gmenu_Item_Record; begin Glib.Menu.Initialize_Section (Self, Label, Section); return Self; end Gmenu_Item_New_Section; ---------------------------- -- Gmenu_Item_New_Submenu -- ---------------------------- function Gmenu_Item_New_Submenu (Label : UTF8_String := ""; Submenu : not null access Glib.Menu_Model.Gmenu_Model_Record'Class) return Gmenu_Item is Self : constant Gmenu_Item := new Gmenu_Item_Record; begin Glib.Menu.Initialize_Submenu (Self, Label, Submenu); return Self; end Gmenu_Item_New_Submenu; --------------- -- Gmenu_New -- --------------- function Gmenu_New return Gmenu is Self : constant Gmenu := new Gmenu_Record; begin Glib.Menu.Initialize (Self); return Self; end Gmenu_New; ---------------- -- Initialize -- ---------------- procedure Initialize (Self : not null access Gmenu_Record'Class) is function Internal return System.Address; pragma Import (C, Internal, "g_menu_new"); begin if not Self.Is_Created then Set_Object (Self, Internal); end if; end Initialize; ---------------- -- Initialize -- ---------------- procedure Initialize (Self : not null access Gmenu_Item_Record'Class; Label : UTF8_String := ""; Detailed_Action : UTF8_String := "") is function Internal (Label : Gtkada.Types.Chars_Ptr; Detailed_Action : Gtkada.Types.Chars_Ptr) return System.Address; pragma Import (C, Internal, "g_menu_item_new"); Tmp_Label : Gtkada.Types.Chars_Ptr; Tmp_Detailed_Action : Gtkada.Types.Chars_Ptr; Tmp_Return : System.Address; begin if not Self.Is_Created then if Label = "" then Tmp_Label := Gtkada.Types.Null_Ptr; else Tmp_Label := New_String (Label); end if; if Detailed_Action = "" then Tmp_Detailed_Action := Gtkada.Types.Null_Ptr; else Tmp_Detailed_Action := New_String (Detailed_Action); end if; Tmp_Return := Internal (Tmp_Label, Tmp_Detailed_Action); Free (Tmp_Detailed_Action); Free (Tmp_Label); Set_Object (Self, Tmp_Return); end if; end Initialize; --------------------------- -- Initialize_From_Model -- --------------------------- procedure Initialize_From_Model (Self : not null access Gmenu_Item_Record'Class; Model : not null access Glib.Menu_Model.Gmenu_Model_Record'Class; Item_Index : Glib.Gint) is function Internal (Model : System.Address; Item_Index : Glib.Gint) return System.Address; pragma Import (C, Internal, "g_menu_item_new_from_model"); begin if not Self.Is_Created then Set_Object (Self, Internal (Get_Object (Model), Item_Index)); end if; end Initialize_From_Model; ------------------------ -- Initialize_Section -- ------------------------ procedure Initialize_Section (Self : not null access Gmenu_Item_Record'Class; Label : UTF8_String := ""; Section : not null access Glib.Menu_Model.Gmenu_Model_Record'Class) is function Internal (Label : Gtkada.Types.Chars_Ptr; Section : System.Address) return System.Address; pragma Import (C, Internal, "g_menu_item_new_section"); Tmp_Label : Gtkada.Types.Chars_Ptr; Tmp_Return : System.Address; begin if not Self.Is_Created then if Label = "" then Tmp_Label := Gtkada.Types.Null_Ptr; else Tmp_Label := New_String (Label); end if; Tmp_Return := Internal (Tmp_Label, Get_Object (Section)); Free (Tmp_Label); Set_Object (Self, Tmp_Return); end if; end Initialize_Section; ------------------------ -- Initialize_Submenu -- ------------------------ procedure Initialize_Submenu (Self : not null access Gmenu_Item_Record'Class; Label : UTF8_String := ""; Submenu : not null access Glib.Menu_Model.Gmenu_Model_Record'Class) is function Internal (Label : Gtkada.Types.Chars_Ptr; Submenu : System.Address) return System.Address; pragma Import (C, Internal, "g_menu_item_new_submenu"); Tmp_Label : Gtkada.Types.Chars_Ptr; Tmp_Return : System.Address; begin if not Self.Is_Created then if Label = "" then Tmp_Label := Gtkada.Types.Null_Ptr; else Tmp_Label := New_String (Label); end if; Tmp_Return := Internal (Tmp_Label, Get_Object (Submenu)); Free (Tmp_Label); Set_Object (Self, Tmp_Return); end if; end Initialize_Submenu; ------------ -- Append -- ------------ procedure Append (Self : not null access Gmenu_Record; Label : UTF8_String := ""; Detailed_Action : UTF8_String := "") is procedure Internal (Self : System.Address; Label : Gtkada.Types.Chars_Ptr; Detailed_Action : Gtkada.Types.Chars_Ptr); pragma Import (C, Internal, "g_menu_append"); Tmp_Label : Gtkada.Types.Chars_Ptr; Tmp_Detailed_Action : Gtkada.Types.Chars_Ptr; begin if Label = "" then Tmp_Label := Gtkada.Types.Null_Ptr; else Tmp_Label := New_String (Label); end if; if Detailed_Action = "" then Tmp_Detailed_Action := Gtkada.Types.Null_Ptr; else Tmp_Detailed_Action := New_String (Detailed_Action); end if; Internal (Get_Object (Self), Tmp_Label, Tmp_Detailed_Action); Free (Tmp_Detailed_Action); Free (Tmp_Label); end Append; ----------------- -- Append_Item -- ----------------- procedure Append_Item (Self : not null access Gmenu_Record; Item : not null access Gmenu_Item_Record'Class) is procedure Internal (Self : System.Address; Item : System.Address); pragma Import (C, Internal, "g_menu_append_item"); begin Internal (Get_Object (Self), Get_Object (Item)); end Append_Item; -------------------- -- Append_Section -- -------------------- procedure Append_Section (Self : not null access Gmenu_Record; Label : UTF8_String := ""; Section : not null access Glib.Menu_Model.Gmenu_Model_Record'Class) is procedure Internal (Self : System.Address; Label : Gtkada.Types.Chars_Ptr; Section : System.Address); pragma Import (C, Internal, "g_menu_append_section"); Tmp_Label : Gtkada.Types.Chars_Ptr; begin if Label = "" then Tmp_Label := Gtkada.Types.Null_Ptr; else Tmp_Label := New_String (Label); end if; Internal (Get_Object (Self), Tmp_Label, Get_Object (Section)); Free (Tmp_Label); end Append_Section; -------------------- -- Append_Submenu -- -------------------- procedure Append_Submenu (Self : not null access Gmenu_Record; Label : UTF8_String := ""; Submenu : not null access Glib.Menu_Model.Gmenu_Model_Record'Class) is procedure Internal (Self : System.Address; Label : Gtkada.Types.Chars_Ptr; Submenu : System.Address); pragma Import (C, Internal, "g_menu_append_submenu"); Tmp_Label : Gtkada.Types.Chars_Ptr; begin if Label = "" then Tmp_Label := Gtkada.Types.Null_Ptr; else Tmp_Label := New_String (Label); end if; Internal (Get_Object (Self), Tmp_Label, Get_Object (Submenu)); Free (Tmp_Label); end Append_Submenu; ------------ -- Freeze -- ------------ procedure Freeze (Self : not null access Gmenu_Record) is procedure Internal (Self : System.Address); pragma Import (C, Internal, "g_menu_freeze"); begin Internal (Get_Object (Self)); end Freeze; ------------------------- -- Get_Attribute_Value -- ------------------------- function Get_Attribute_Value (Self : not null access Gmenu_Item_Record; Attribute : UTF8_String; Expected_Type : Glib.Variant.Gvariant_Type) return Glib.Variant.Gvariant is function Internal (Self : System.Address; Attribute : Gtkada.Types.Chars_Ptr; Expected_Type : Glib.Variant.Gvariant_Type) return System.Address; pragma Import (C, Internal, "g_menu_item_get_attribute_value"); Tmp_Attribute : Gtkada.Types.Chars_Ptr := New_String (Attribute); Tmp_Return : System.Address; begin Tmp_Return := Internal (Get_Object (Self), Tmp_Attribute, Expected_Type); Free (Tmp_Attribute); return From_Object (Tmp_Return); end Get_Attribute_Value; -------------- -- Get_Link -- -------------- function Get_Link (Self : not null access Gmenu_Item_Record; Link : UTF8_String) return Glib.Menu_Model.Gmenu_Model is function Internal (Self : System.Address; Link : Gtkada.Types.Chars_Ptr) return System.Address; pragma Import (C, Internal, "g_menu_item_get_link"); Tmp_Link : Gtkada.Types.Chars_Ptr := New_String (Link); Stub_Gmenu_Model : Glib.Menu_Model.Gmenu_Model_Record; Tmp_Return : System.Address; begin Tmp_Return := Internal (Get_Object (Self), Tmp_Link); Free (Tmp_Link); return Glib.Menu_Model.Gmenu_Model (Get_User_Data (Tmp_Return, Stub_Gmenu_Model)); end Get_Link; ------------ -- Insert -- ------------ procedure Insert (Self : not null access Gmenu_Record; Position : Glib.Gint; Label : UTF8_String := ""; Detailed_Action : UTF8_String := "") is procedure Internal (Self : System.Address; Position : Glib.Gint; Label : Gtkada.Types.Chars_Ptr; Detailed_Action : Gtkada.Types.Chars_Ptr); pragma Import (C, Internal, "g_menu_insert"); Tmp_Label : Gtkada.Types.Chars_Ptr; Tmp_Detailed_Action : Gtkada.Types.Chars_Ptr; begin if Label = "" then Tmp_Label := Gtkada.Types.Null_Ptr; else Tmp_Label := New_String (Label); end if; if Detailed_Action = "" then Tmp_Detailed_Action := Gtkada.Types.Null_Ptr; else Tmp_Detailed_Action := New_String (Detailed_Action); end if; Internal (Get_Object (Self), Position, Tmp_Label, Tmp_Detailed_Action); Free (Tmp_Detailed_Action); Free (Tmp_Label); end Insert; ----------------- -- Insert_Item -- ----------------- procedure Insert_Item (Self : not null access Gmenu_Record; Position : Glib.Gint; Item : not null access Gmenu_Item_Record'Class) is procedure Internal (Self : System.Address; Position : Glib.Gint; Item : System.Address); pragma Import (C, Internal, "g_menu_insert_item"); begin Internal (Get_Object (Self), Position, Get_Object (Item)); end Insert_Item; -------------------- -- Insert_Section -- -------------------- procedure Insert_Section (Self : not null access Gmenu_Record; Position : Glib.Gint; Label : UTF8_String := ""; Section : not null access Glib.Menu_Model.Gmenu_Model_Record'Class) is procedure Internal (Self : System.Address; Position : Glib.Gint; Label : Gtkada.Types.Chars_Ptr; Section : System.Address); pragma Import (C, Internal, "g_menu_insert_section"); Tmp_Label : Gtkada.Types.Chars_Ptr; begin if Label = "" then Tmp_Label := Gtkada.Types.Null_Ptr; else Tmp_Label := New_String (Label); end if; Internal (Get_Object (Self), Position, Tmp_Label, Get_Object (Section)); Free (Tmp_Label); end Insert_Section; -------------------- -- Insert_Submenu -- -------------------- procedure Insert_Submenu (Self : not null access Gmenu_Record; Position : Glib.Gint; Label : UTF8_String := ""; Submenu : not null access Glib.Menu_Model.Gmenu_Model_Record'Class) is procedure Internal (Self : System.Address; Position : Glib.Gint; Label : Gtkada.Types.Chars_Ptr; Submenu : System.Address); pragma Import (C, Internal, "g_menu_insert_submenu"); Tmp_Label : Gtkada.Types.Chars_Ptr; begin if Label = "" then Tmp_Label := Gtkada.Types.Null_Ptr; else Tmp_Label := New_String (Label); end if; Internal (Get_Object (Self), Position, Tmp_Label, Get_Object (Submenu)); Free (Tmp_Label); end Insert_Submenu; ------------- -- Prepend -- ------------- procedure Prepend (Self : not null access Gmenu_Record; Label : UTF8_String := ""; Detailed_Action : UTF8_String := "") is procedure Internal (Self : System.Address; Label : Gtkada.Types.Chars_Ptr; Detailed_Action : Gtkada.Types.Chars_Ptr); pragma Import (C, Internal, "g_menu_prepend"); Tmp_Label : Gtkada.Types.Chars_Ptr; Tmp_Detailed_Action : Gtkada.Types.Chars_Ptr; begin if Label = "" then Tmp_Label := Gtkada.Types.Null_Ptr; else Tmp_Label := New_String (Label); end if; if Detailed_Action = "" then Tmp_Detailed_Action := Gtkada.Types.Null_Ptr; else Tmp_Detailed_Action := New_String (Detailed_Action); end if; Internal (Get_Object (Self), Tmp_Label, Tmp_Detailed_Action); Free (Tmp_Detailed_Action); Free (Tmp_Label); end Prepend; ------------------ -- Prepend_Item -- ------------------ procedure Prepend_Item (Self : not null access Gmenu_Record; Item : not null access Gmenu_Item_Record'Class) is procedure Internal (Self : System.Address; Item : System.Address); pragma Import (C, Internal, "g_menu_prepend_item"); begin Internal (Get_Object (Self), Get_Object (Item)); end Prepend_Item; --------------------- -- Prepend_Section -- --------------------- procedure Prepend_Section (Self : not null access Gmenu_Record; Label : UTF8_String := ""; Section : not null access Glib.Menu_Model.Gmenu_Model_Record'Class) is procedure Internal (Self : System.Address; Label : Gtkada.Types.Chars_Ptr; Section : System.Address); pragma Import (C, Internal, "g_menu_prepend_section"); Tmp_Label : Gtkada.Types.Chars_Ptr; begin if Label = "" then Tmp_Label := Gtkada.Types.Null_Ptr; else Tmp_Label := New_String (Label); end if; Internal (Get_Object (Self), Tmp_Label, Get_Object (Section)); Free (Tmp_Label); end Prepend_Section; --------------------- -- Prepend_Submenu -- --------------------- procedure Prepend_Submenu (Self : not null access Gmenu_Record; Label : UTF8_String := ""; Submenu : not null access Glib.Menu_Model.Gmenu_Model_Record'Class) is procedure Internal (Self : System.Address; Label : Gtkada.Types.Chars_Ptr; Submenu : System.Address); pragma Import (C, Internal, "g_menu_prepend_submenu"); Tmp_Label : Gtkada.Types.Chars_Ptr; begin if Label = "" then Tmp_Label := Gtkada.Types.Null_Ptr; else Tmp_Label := New_String (Label); end if; Internal (Get_Object (Self), Tmp_Label, Get_Object (Submenu)); Free (Tmp_Label); end Prepend_Submenu; ------------ -- Remove -- ------------ procedure Remove (Self : not null access Gmenu_Record; Position : Glib.Gint) is procedure Internal (Self : System.Address; Position : Glib.Gint); pragma Import (C, Internal, "g_menu_remove"); begin Internal (Get_Object (Self), Position); end Remove; ---------------- -- Remove_All -- ---------------- procedure Remove_All (Self : not null access Gmenu_Record) is procedure Internal (Self : System.Address); pragma Import (C, Internal, "g_menu_remove_all"); begin Internal (Get_Object (Self)); end Remove_All; --------------------------------- -- Set_Action_And_Target_Value -- --------------------------------- procedure Set_Action_And_Target_Value (Self : not null access Gmenu_Item_Record; Action : UTF8_String := ""; Target_Value : Glib.Variant.Gvariant) is procedure Internal (Self : System.Address; Action : Gtkada.Types.Chars_Ptr; Target_Value : System.Address); pragma Import (C, Internal, "g_menu_item_set_action_and_target_value"); Tmp_Action : Gtkada.Types.Chars_Ptr; begin if Action = "" then Tmp_Action := Gtkada.Types.Null_Ptr; else Tmp_Action := New_String (Action); end if; Internal (Get_Object (Self), Tmp_Action, Get_Object (Target_Value)); Free (Tmp_Action); end Set_Action_And_Target_Value; ------------------------- -- Set_Attribute_Value -- ------------------------- procedure Set_Attribute_Value (Self : not null access Gmenu_Item_Record; Attribute : UTF8_String; Value : Glib.Variant.Gvariant) is procedure Internal (Self : System.Address; Attribute : Gtkada.Types.Chars_Ptr; Value : System.Address); pragma Import (C, Internal, "g_menu_item_set_attribute_value"); Tmp_Attribute : Gtkada.Types.Chars_Ptr := New_String (Attribute); begin Internal (Get_Object (Self), Tmp_Attribute, Get_Object (Value)); Free (Tmp_Attribute); end Set_Attribute_Value; ------------------------- -- Set_Detailed_Action -- ------------------------- procedure Set_Detailed_Action (Self : not null access Gmenu_Item_Record; Detailed_Action : UTF8_String) is procedure Internal (Self : System.Address; Detailed_Action : Gtkada.Types.Chars_Ptr); pragma Import (C, Internal, "g_menu_item_set_detailed_action"); Tmp_Detailed_Action : Gtkada.Types.Chars_Ptr := New_String (Detailed_Action); begin Internal (Get_Object (Self), Tmp_Detailed_Action); Free (Tmp_Detailed_Action); end Set_Detailed_Action; -------------- -- Set_Icon -- -------------- procedure Set_Icon (Self : not null access Gmenu_Item_Record; Icon : Glib.G_Icon.G_Icon) is procedure Internal (Self : System.Address; Icon : Glib.G_Icon.G_Icon); pragma Import (C, Internal, "g_menu_item_set_icon"); begin Internal (Get_Object (Self), Icon); end Set_Icon; --------------- -- Set_Label -- --------------- procedure Set_Label (Self : not null access Gmenu_Item_Record; Label : UTF8_String := "") is procedure Internal (Self : System.Address; Label : Gtkada.Types.Chars_Ptr); pragma Import (C, Internal, "g_menu_item_set_label"); Tmp_Label : Gtkada.Types.Chars_Ptr; begin if Label = "" then Tmp_Label := Gtkada.Types.Null_Ptr; else Tmp_Label := New_String (Label); end if; Internal (Get_Object (Self), Tmp_Label); Free (Tmp_Label); end Set_Label; -------------- -- Set_Link -- -------------- procedure Set_Link (Self : not null access Gmenu_Item_Record; Link : UTF8_String; Model : access Glib.Menu_Model.Gmenu_Model_Record'Class) is procedure Internal (Self : System.Address; Link : Gtkada.Types.Chars_Ptr; Model : System.Address); pragma Import (C, Internal, "g_menu_item_set_link"); Tmp_Link : Gtkada.Types.Chars_Ptr := New_String (Link); begin Internal (Get_Object (Self), Tmp_Link, Get_Object_Or_Null (GObject (Model))); Free (Tmp_Link); end Set_Link; ----------------- -- Set_Section -- ----------------- procedure Set_Section (Self : not null access Gmenu_Item_Record; Section : access Glib.Menu_Model.Gmenu_Model_Record'Class) is procedure Internal (Self : System.Address; Section : System.Address); pragma Import (C, Internal, "g_menu_item_set_section"); begin Internal (Get_Object (Self), Get_Object_Or_Null (GObject (Section))); end Set_Section; ----------------- -- Set_Submenu -- ----------------- procedure Set_Submenu (Self : not null access Gmenu_Item_Record; Submenu : access Glib.Menu_Model.Gmenu_Model_Record'Class) is procedure Internal (Self : System.Address; Submenu : System.Address); pragma Import (C, Internal, "g_menu_item_set_submenu"); begin Internal (Get_Object (Self), Get_Object_Or_Null (GObject (Submenu))); end Set_Submenu; end Glib.Menu; gtkada-24.0.0/src/generated/glib-menu.ads000066400000000000000000000756131446021174000201400ustar00rootroot00000000000000------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ -- -- Glib.Menu.Gmenu is a simple implementation of Glib.Menu_Model.Gmenu_Model. -- You populate a Glib.Menu.Gmenu by adding Glib.Menu.Gmenu_Item instances to -- it. -- -- There are some convenience functions to allow you to directly add items -- (avoiding Glib.Menu.Gmenu_Item) for the common cases. To add a regular -- item, use Glib.Menu.Insert. To add a section, use Glib.Menu.Insert_Section. -- To add a submenu, use Glib.Menu.Insert_Submenu. -- -- pragma Warnings (Off, "*is already use-visible*"); with Glib.G_Icon; use Glib.G_Icon; with Glib.Menu_Model; use Glib.Menu_Model; with Glib.Object; use Glib.Object; with Glib.Variant; use Glib.Variant; package Glib.Menu is type Gmenu_Record is new Gmenu_Model_Record with null record; type Gmenu is access all Gmenu_Record'Class; type Gmenu_Item_Record is new GObject_Record with null record; type Gmenu_Item is access all Gmenu_Item_Record'Class; ------------------ -- Constructors -- ------------------ procedure G_New (Self : out Gmenu); -- Creates a new Glib.Menu.Gmenu. -- The new menu has no items. -- Since: gtk+ 2.32 procedure Initialize (Self : not null access Gmenu_Record'Class); -- Creates a new Glib.Menu.Gmenu. -- The new menu has no items. -- Since: gtk+ 2.32 -- Initialize does nothing if the object was already created with another -- call to Initialize* or G_New. function Gmenu_New return Gmenu; -- Creates a new Glib.Menu.Gmenu. -- The new menu has no items. -- Since: gtk+ 2.32 function Get_Type_Menu return Glib.GType; pragma Import (C, Get_Type_Menu, "g_menu_get_type"); procedure G_New (Self : out Gmenu_Item; Label : UTF8_String := ""; Detailed_Action : UTF8_String := ""); -- Creates a new Glib.Menu.Gmenu_Item. -- If Label is non-null it is used to set the "label" attribute of the new -- item. -- If Detailed_Action is non-null it is used to set the "action" and -- possibly the "target" attribute of the new item. See -- Glib.Menu.Set_Detailed_Action for more information. -- Since: gtk+ 2.32 -- "label": the section label, or null -- "detailed_action": the detailed action string, or null procedure Initialize (Self : not null access Gmenu_Item_Record'Class; Label : UTF8_String := ""; Detailed_Action : UTF8_String := ""); -- Creates a new Glib.Menu.Gmenu_Item. -- If Label is non-null it is used to set the "label" attribute of the new -- item. -- If Detailed_Action is non-null it is used to set the "action" and -- possibly the "target" attribute of the new item. See -- Glib.Menu.Set_Detailed_Action for more information. -- Since: gtk+ 2.32 -- Initialize does nothing if the object was already created with another -- call to Initialize* or G_New. -- "label": the section label, or null -- "detailed_action": the detailed action string, or null function Gmenu_Item_New (Label : UTF8_String := ""; Detailed_Action : UTF8_String := "") return Gmenu_Item; -- Creates a new Glib.Menu.Gmenu_Item. -- If Label is non-null it is used to set the "label" attribute of the new -- item. -- If Detailed_Action is non-null it is used to set the "action" and -- possibly the "target" attribute of the new item. See -- Glib.Menu.Set_Detailed_Action for more information. -- Since: gtk+ 2.32 -- "label": the section label, or null -- "detailed_action": the detailed action string, or null procedure G_New_From_Model (Self : out Gmenu_Item; Model : not null access Glib.Menu_Model.Gmenu_Model_Record'Class; Item_Index : Glib.Gint); -- Creates a Glib.Menu.Gmenu_Item as an exact copy of an existing menu -- item in a Glib.Menu_Model.Gmenu_Model. -- Item_Index must be valid (ie: be sure to call -- Glib.Menu_Model.Get_N_Items first). -- Since: gtk+ 2.34 -- "model": a Glib.Menu_Model.Gmenu_Model -- "item_index": the index of an item in Model procedure Initialize_From_Model (Self : not null access Gmenu_Item_Record'Class; Model : not null access Glib.Menu_Model.Gmenu_Model_Record'Class; Item_Index : Glib.Gint); -- Creates a Glib.Menu.Gmenu_Item as an exact copy of an existing menu -- item in a Glib.Menu_Model.Gmenu_Model. -- Item_Index must be valid (ie: be sure to call -- Glib.Menu_Model.Get_N_Items first). -- Since: gtk+ 2.34 -- Initialize_From_Model does nothing if the object was already created -- with another call to Initialize* or G_New. -- "model": a Glib.Menu_Model.Gmenu_Model -- "item_index": the index of an item in Model function Gmenu_Item_New_From_Model (Model : not null access Glib.Menu_Model.Gmenu_Model_Record'Class; Item_Index : Glib.Gint) return Gmenu_Item; -- Creates a Glib.Menu.Gmenu_Item as an exact copy of an existing menu -- item in a Glib.Menu_Model.Gmenu_Model. -- Item_Index must be valid (ie: be sure to call -- Glib.Menu_Model.Get_N_Items first). -- Since: gtk+ 2.34 -- "model": a Glib.Menu_Model.Gmenu_Model -- "item_index": the index of an item in Model procedure G_New_Section (Self : out Gmenu_Item; Label : UTF8_String := ""; Section : not null access Glib.Menu_Model.Gmenu_Model_Record'Class); -- Creates a new Glib.Menu.Gmenu_Item representing a section. -- This is a convenience API around Glib.Menu.G_New and -- Glib.Menu.Set_Section. -- The effect of having one menu appear as a section of another is exactly -- as it sounds: the items from Section become a direct part of the menu -- that Menu_Item is added to. -- Visual separation is typically displayed between two non-empty -- sections. If Label is non-null then it will be encorporated into this -- visual indication. This allows for labeled subsections of a menu. -- As a simple example, consider a typical "Edit" menu from a simple -- program. It probably contains an "Undo" and "Redo" item, followed by a -- separator, followed by "Cut", "Copy" and "Paste". -- This would be accomplished by creating three Glib.Menu.Gmenu instances. -- The first would be populated with the "Undo" and "Redo" items, and the -- second with the "Cut", "Copy" and "Paste" items. The first and second -- menus would then be added as submenus of the third. In XML format, this -- would look something like the following: |[ --
    -- --
    ]| -- The following example is exactly equivalent. It is more illustrative of -- the exact relationship between the menus and items (keeping in mind that -- the 'link' element defines a new menu that is linked to the containing -- one). The style of the second example is more verbose and difficult to -- read (and therefore not recommended except for the purpose of -- understanding what is really going on). |[ -- -- ]| -- Since: gtk+ 2.32 -- "label": the section label, or null -- "section": a Glib.Menu_Model.Gmenu_Model with the items of the section procedure Initialize_Section (Self : not null access Gmenu_Item_Record'Class; Label : UTF8_String := ""; Section : not null access Glib.Menu_Model.Gmenu_Model_Record'Class); -- Creates a new Glib.Menu.Gmenu_Item representing a section. -- This is a convenience API around Glib.Menu.G_New and -- Glib.Menu.Set_Section. -- The effect of having one menu appear as a section of another is exactly -- as it sounds: the items from Section become a direct part of the menu -- that Menu_Item is added to. -- Visual separation is typically displayed between two non-empty -- sections. If Label is non-null then it will be encorporated into this -- visual indication. This allows for labeled subsections of a menu. -- As a simple example, consider a typical "Edit" menu from a simple -- program. It probably contains an "Undo" and "Redo" item, followed by a -- separator, followed by "Cut", "Copy" and "Paste". -- This would be accomplished by creating three Glib.Menu.Gmenu instances. -- The first would be populated with the "Undo" and "Redo" items, and the -- second with the "Cut", "Copy" and "Paste" items. The first and second -- menus would then be added as submenus of the third. In XML format, this -- would look something like the following: |[ --
    -- --
    ]| -- The following example is exactly equivalent. It is more illustrative of -- the exact relationship between the menus and items (keeping in mind that -- the 'link' element defines a new menu that is linked to the containing -- one). The style of the second example is more verbose and difficult to -- read (and therefore not recommended except for the purpose of -- understanding what is really going on). |[ -- -- ]| -- Since: gtk+ 2.32 -- Initialize_Section does nothing if the object was already created with -- another call to Initialize* or G_New. -- "label": the section label, or null -- "section": a Glib.Menu_Model.Gmenu_Model with the items of the section function Gmenu_Item_New_Section (Label : UTF8_String := ""; Section : not null access Glib.Menu_Model.Gmenu_Model_Record'Class) return Gmenu_Item; -- Creates a new Glib.Menu.Gmenu_Item representing a section. -- This is a convenience API around Glib.Menu.G_New and -- Glib.Menu.Set_Section. -- The effect of having one menu appear as a section of another is exactly -- as it sounds: the items from Section become a direct part of the menu -- that Menu_Item is added to. -- Visual separation is typically displayed between two non-empty -- sections. If Label is non-null then it will be encorporated into this -- visual indication. This allows for labeled subsections of a menu. -- As a simple example, consider a typical "Edit" menu from a simple -- program. It probably contains an "Undo" and "Redo" item, followed by a -- separator, followed by "Cut", "Copy" and "Paste". -- This would be accomplished by creating three Glib.Menu.Gmenu instances. -- The first would be populated with the "Undo" and "Redo" items, and the -- second with the "Cut", "Copy" and "Paste" items. The first and second -- menus would then be added as submenus of the third. In XML format, this -- would look something like the following: |[ --
    -- --
    ]| -- The following example is exactly equivalent. It is more illustrative of -- the exact relationship between the menus and items (keeping in mind that -- the 'link' element defines a new menu that is linked to the containing -- one). The style of the second example is more verbose and difficult to -- read (and therefore not recommended except for the purpose of -- understanding what is really going on). |[ -- -- ]| -- Since: gtk+ 2.32 -- "label": the section label, or null -- "section": a Glib.Menu_Model.Gmenu_Model with the items of the section procedure G_New_Submenu (Self : out Gmenu_Item; Label : UTF8_String := ""; Submenu : not null access Glib.Menu_Model.Gmenu_Model_Record'Class); -- Creates a new Glib.Menu.Gmenu_Item representing a submenu. -- This is a convenience API around Glib.Menu.G_New and -- Glib.Menu.Set_Submenu. -- Since: gtk+ 2.32 -- "label": the section label, or null -- "submenu": a Glib.Menu_Model.Gmenu_Model with the items of the submenu procedure Initialize_Submenu (Self : not null access Gmenu_Item_Record'Class; Label : UTF8_String := ""; Submenu : not null access Glib.Menu_Model.Gmenu_Model_Record'Class); -- Creates a new Glib.Menu.Gmenu_Item representing a submenu. -- This is a convenience API around Glib.Menu.G_New and -- Glib.Menu.Set_Submenu. -- Since: gtk+ 2.32 -- Initialize_Submenu does nothing if the object was already created with -- another call to Initialize* or G_New. -- "label": the section label, or null -- "submenu": a Glib.Menu_Model.Gmenu_Model with the items of the submenu function Gmenu_Item_New_Submenu (Label : UTF8_String := ""; Submenu : not null access Glib.Menu_Model.Gmenu_Model_Record'Class) return Gmenu_Item; -- Creates a new Glib.Menu.Gmenu_Item representing a submenu. -- This is a convenience API around Glib.Menu.G_New and -- Glib.Menu.Set_Submenu. -- Since: gtk+ 2.32 -- "label": the section label, or null -- "submenu": a Glib.Menu_Model.Gmenu_Model with the items of the submenu function Get_Type_Menu_Item return Glib.GType; pragma Import (C, Get_Type_Menu_Item, "g_menu_item_get_type"); ------------- -- Methods -- ------------- procedure Append (Self : not null access Gmenu_Record; Label : UTF8_String := ""; Detailed_Action : UTF8_String := ""); -- Convenience function for appending a normal menu item to the end of -- Menu. Combine Glib.Menu.G_New and Glib.Menu.Insert_Item for a more -- flexible alternative. -- Since: gtk+ 2.32 -- "label": the section label, or null -- "detailed_action": the detailed action string, or null procedure Append_Item (Self : not null access Gmenu_Record; Item : not null access Gmenu_Item_Record'Class); -- Appends Item to the end of Menu. -- See Glib.Menu.Insert_Item for more information. -- Since: gtk+ 2.32 -- "item": a Glib.Menu.Gmenu_Item to append procedure Append_Section (Self : not null access Gmenu_Record; Label : UTF8_String := ""; Section : not null access Glib.Menu_Model.Gmenu_Model_Record'Class); -- Convenience function for appending a section menu item to the end of -- Menu. Combine Glib.Menu.G_New_Section and Glib.Menu.Insert_Item for a -- more flexible alternative. -- Since: gtk+ 2.32 -- "label": the section label, or null -- "section": a Glib.Menu_Model.Gmenu_Model with the items of the section procedure Append_Submenu (Self : not null access Gmenu_Record; Label : UTF8_String := ""; Submenu : not null access Glib.Menu_Model.Gmenu_Model_Record'Class); -- Convenience function for appending a submenu menu item to the end of -- Menu. Combine Glib.Menu.G_New_Submenu and Glib.Menu.Insert_Item for a -- more flexible alternative. -- Since: gtk+ 2.32 -- "label": the section label, or null -- "submenu": a Glib.Menu_Model.Gmenu_Model with the items of the submenu procedure Freeze (Self : not null access Gmenu_Record); -- Marks Menu as frozen. -- After the menu is frozen, it is an error to attempt to make any changes -- to it. In effect this means that the Glib.Menu.Gmenu API must no longer -- be used. -- This function causes Glib.Menu_Model.Is_Mutable to begin returning -- False, which has some positive performance implications. -- Since: gtk+ 2.32 procedure Insert (Self : not null access Gmenu_Record; Position : Glib.Gint; Label : UTF8_String := ""; Detailed_Action : UTF8_String := ""); -- Convenience function for inserting a normal menu item into Menu. -- Combine Glib.Menu.G_New and Glib.Menu.Insert_Item for a more flexible -- alternative. -- Since: gtk+ 2.32 -- "position": the position at which to insert the item -- "label": the section label, or null -- "detailed_action": the detailed action string, or null procedure Insert_Item (Self : not null access Gmenu_Record; Position : Glib.Gint; Item : not null access Gmenu_Item_Record'Class); -- Inserts Item into Menu. -- The "insertion" is actually done by copying all of the attribute and -- link values of Item and using them to form a new item within Menu. As -- such, Item itself is not really inserted, but rather, a menu item that -- is exactly the same as the one presently described by Item. -- This means that Item is essentially useless after the insertion occurs. -- Any changes you make to it are ignored unless it is inserted again (at -- which point its updated values will be copied). -- You should probably just free Item once you're done. -- There are many convenience functions to take care of common cases. See -- Glib.Menu.Insert, Glib.Menu.Insert_Section and Glib.Menu.Insert_Submenu -- as well as "prepend" and "append" variants of each of these functions. -- Since: gtk+ 2.32 -- "position": the position at which to insert the item -- "item": the Glib.Menu.Gmenu_Item to insert procedure Insert_Section (Self : not null access Gmenu_Record; Position : Glib.Gint; Label : UTF8_String := ""; Section : not null access Glib.Menu_Model.Gmenu_Model_Record'Class); -- Convenience function for inserting a section menu item into Menu. -- Combine Glib.Menu.G_New_Section and Glib.Menu.Insert_Item for a more -- flexible alternative. -- Since: gtk+ 2.32 -- "position": the position at which to insert the item -- "label": the section label, or null -- "section": a Glib.Menu_Model.Gmenu_Model with the items of the section procedure Insert_Submenu (Self : not null access Gmenu_Record; Position : Glib.Gint; Label : UTF8_String := ""; Submenu : not null access Glib.Menu_Model.Gmenu_Model_Record'Class); -- Convenience function for inserting a submenu menu item into Menu. -- Combine Glib.Menu.G_New_Submenu and Glib.Menu.Insert_Item for a more -- flexible alternative. -- Since: gtk+ 2.32 -- "position": the position at which to insert the item -- "label": the section label, or null -- "submenu": a Glib.Menu_Model.Gmenu_Model with the items of the submenu procedure Prepend (Self : not null access Gmenu_Record; Label : UTF8_String := ""; Detailed_Action : UTF8_String := ""); -- Convenience function for prepending a normal menu item to the start of -- Menu. Combine Glib.Menu.G_New and Glib.Menu.Insert_Item for a more -- flexible alternative. -- Since: gtk+ 2.32 -- "label": the section label, or null -- "detailed_action": the detailed action string, or null procedure Prepend_Item (Self : not null access Gmenu_Record; Item : not null access Gmenu_Item_Record'Class); -- Prepends Item to the start of Menu. -- See Glib.Menu.Insert_Item for more information. -- Since: gtk+ 2.32 -- "item": a Glib.Menu.Gmenu_Item to prepend procedure Prepend_Section (Self : not null access Gmenu_Record; Label : UTF8_String := ""; Section : not null access Glib.Menu_Model.Gmenu_Model_Record'Class); -- Convenience function for prepending a section menu item to the start of -- Menu. Combine Glib.Menu.G_New_Section and Glib.Menu.Insert_Item for a -- more flexible alternative. -- Since: gtk+ 2.32 -- "label": the section label, or null -- "section": a Glib.Menu_Model.Gmenu_Model with the items of the section procedure Prepend_Submenu (Self : not null access Gmenu_Record; Label : UTF8_String := ""; Submenu : not null access Glib.Menu_Model.Gmenu_Model_Record'Class); -- Convenience function for prepending a submenu menu item to the start of -- Menu. Combine Glib.Menu.G_New_Submenu and Glib.Menu.Insert_Item for a -- more flexible alternative. -- Since: gtk+ 2.32 -- "label": the section label, or null -- "submenu": a Glib.Menu_Model.Gmenu_Model with the items of the submenu procedure Remove (Self : not null access Gmenu_Record; Position : Glib.Gint); -- Removes an item from the menu. -- Position gives the index of the item to remove. -- It is an error if position is not in range the range from 0 to one less -- than the number of items in the menu. -- It is not possible to remove items by identity since items are added to -- the menu simply by copying their links and attributes (ie: identity of -- the item itself is not preserved). -- Since: gtk+ 2.32 -- "position": the position of the item to remove procedure Remove_All (Self : not null access Gmenu_Record); -- Removes all items in the menu. -- Since: gtk+ 2.38 function Get_Attribute_Value (Self : not null access Gmenu_Item_Record; Attribute : UTF8_String; Expected_Type : Glib.Variant.Gvariant_Type) return Glib.Variant.Gvariant; -- Queries the named Attribute on Menu_Item. -- If Expected_Type is specified and the attribute does not have this -- type, null is returned. null is also returned if the attribute simply -- does not exist. -- Since: gtk+ 2.34 -- "attribute": the attribute name to query -- "expected_type": the expected type of the attribute procedure Set_Attribute_Value (Self : not null access Gmenu_Item_Record; Attribute : UTF8_String; Value : Glib.Variant.Gvariant); -- Sets or unsets an attribute on Menu_Item. -- The attribute to set or unset is specified by Attribute. This can be -- one of the standard attribute names G_MENU_ATTRIBUTE_LABEL, -- G_MENU_ATTRIBUTE_ACTION, G_MENU_ATTRIBUTE_TARGET, or a custom attribute -- name. Attribute names are restricted to lowercase characters, numbers -- and '-'. Furthermore, the names must begin with a lowercase character, -- must not end with a '-', and must not contain consecutive dashes. -- must consist only of lowercase ASCII characters, digits and '-'. -- If Value is non-null then it is used as the new value for the -- attribute. If Value is null then the attribute is unset. If the Value -- Glib.Variant.Gvariant is floating, it is consumed. -- See also g_menu_item_set_attribute for a more convenient way to do the -- same. -- Since: gtk+ 2.32 -- "attribute": the attribute to set -- "value": a Glib.Variant.Gvariant to use as the value, or null function Get_Link (Self : not null access Gmenu_Item_Record; Link : UTF8_String) return Glib.Menu_Model.Gmenu_Model; -- Queries the named Link on Menu_Item. -- Since: gtk+ 2.34 -- "link": the link name to query procedure Set_Link (Self : not null access Gmenu_Item_Record; Link : UTF8_String; Model : access Glib.Menu_Model.Gmenu_Model_Record'Class); -- Creates a link from Menu_Item to Model if non-null, or unsets it. -- Links are used to establish a relationship between a particular menu -- item and another menu. For example, G_MENU_LINK_SUBMENU is used to -- associate a submenu with a particular menu item, and G_MENU_LINK_SECTION -- is used to create a section. Other types of link can be used, but there -- is no guarantee that clients will be able to make sense of them. Link -- types are restricted to lowercase characters, numbers and '-'. -- Furthermore, the names must begin with a lowercase character, must not -- end with a '-', and must not contain consecutive dashes. -- Since: gtk+ 2.32 -- "link": type of link to establish or unset -- "model": the Glib.Menu_Model.Gmenu_Model to link to (or null to unset) procedure Set_Action_And_Target_Value (Self : not null access Gmenu_Item_Record; Action : UTF8_String := ""; Target_Value : Glib.Variant.Gvariant); -- Sets or unsets the "action" and "target" attributes of Menu_Item. -- If Action is null then both the "action" and "target" attributes are -- unset (and Target_Value is ignored). -- If Action is non-null then the "action" attribute is set. The "target" -- attribute is then set to the value of Target_Value if it is non-null or -- unset otherwise. -- Normal menu items (ie: not submenu, section or other custom item types) -- are expected to have the "action" attribute set to identify the action -- that they are associated with. The state type of the action help to -- determine the disposition of the menu item. See Glib.Action.Gaction and -- Glib.Action_Group.Gaction_Group for an overview of actions. -- In general, clicking on the menu item will result in activation of the -- named action with the "target" attribute given as the parameter to the -- action invocation. If the "target" attribute is not set then the action -- is invoked with no parameter. -- If the action has no state then the menu item is usually drawn as a -- plain menu item (ie: with no additional decoration). -- If the action has a boolean state then the menu item is usually drawn -- as a toggle menu item (ie: with a checkmark or equivalent indication). -- The item should be marked as 'toggled' or 'checked' when the boolean -- state is True. -- If the action has a string state then the menu item is usually drawn as -- a radio menu item (ie: with a radio bullet or equivalent indication). -- The item should be marked as 'selected' when the string state is equal -- to the value of the Target property. -- See g_menu_item_set_action_and_target or Glib.Menu.Set_Detailed_Action -- for two equivalent calls that are probably more convenient for most -- uses. -- Since: gtk+ 2.32 -- "action": the name of the action for this item -- "target_value": a Glib.Variant.Gvariant to use as the action target procedure Set_Detailed_Action (Self : not null access Gmenu_Item_Record; Detailed_Action : UTF8_String); -- Sets the "action" and possibly the "target" attribute of Menu_Item. -- The format of Detailed_Action is the same format parsed by -- g_action_parse_detailed_name. -- See g_menu_item_set_action_and_target or -- Glib.Menu.Set_Action_And_Target_Value for more flexible (but slightly -- less convenient) alternatives. -- See also Glib.Menu.Set_Action_And_Target_Value for a description of the -- semantics of the action and target attributes. -- Since: gtk+ 2.32 -- "detailed_action": the "detailed" action string procedure Set_Icon (Self : not null access Gmenu_Item_Record; Icon : Glib.G_Icon.G_Icon); -- Sets (or unsets) the icon on Menu_Item. -- This call is the same as calling Glib.G_Icon.Serialize and using the -- result as the value to Glib.Menu.Set_Attribute_Value for -- G_MENU_ATTRIBUTE_ICON. -- This API is only intended for use with "noun" menu items; things like -- bookmarks or applications in an "Open With" menu. Don't use it on menu -- items corresponding to verbs (eg: stock icons for 'Save' or 'Quit'). -- If Icon is null then the icon is unset. -- Since: gtk+ 2.38 -- "icon": a Glib.G_Icon.G_Icon, or null procedure Set_Label (Self : not null access Gmenu_Item_Record; Label : UTF8_String := ""); -- Sets or unsets the "label" attribute of Menu_Item. -- If Label is non-null it is used as the label for the menu item. If it -- is null then the label attribute is unset. -- Since: gtk+ 2.32 -- "label": the label to set, or null to unset procedure Set_Section (Self : not null access Gmenu_Item_Record; Section : access Glib.Menu_Model.Gmenu_Model_Record'Class); -- Sets or unsets the "section" link of Menu_Item to Section. -- The effect of having one menu appear as a section of another is exactly -- as it sounds: the items from Section become a direct part of the menu -- that Menu_Item is added to. See Glib.Menu.G_New_Section for more -- information about what it means for a menu item to be a section. -- Since: gtk+ 2.32 -- "section": a Glib.Menu_Model.Gmenu_Model, or null procedure Set_Submenu (Self : not null access Gmenu_Item_Record; Submenu : access Glib.Menu_Model.Gmenu_Model_Record'Class); -- Sets or unsets the "submenu" link of Menu_Item to Submenu. -- If Submenu is non-null, it is linked to. If it is null then the link is -- unset. -- The effect of having one menu appear as a submenu of another is exactly -- as it sounds. -- Since: gtk+ 2.32 -- "submenu": a Glib.Menu_Model.Gmenu_Model, or null end Glib.Menu; gtkada-24.0.0/src/generated/glib-menu_model.adb000066400000000000000000000354451446021174000212760ustar00rootroot00000000000000------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ pragma Style_Checks (Off); pragma Warnings (Off, "*is already use-visible*"); with Ada.Unchecked_Conversion; with Glib.Type_Conversion_Hooks; use Glib.Type_Conversion_Hooks; with Glib.Values; use Glib.Values; with Gtk.Arguments; use Gtk.Arguments; with Gtkada.Bindings; use Gtkada.Bindings; with Gtkada.Types; use Gtkada.Types; package body Glib.Menu_Model is package Type_Conversion_Gmenu_Model is new Glib.Type_Conversion_Hooks.Hook_Registrator (Get_Type_Menu_Model'Access, Gmenu_Model_Record); pragma Unreferenced (Type_Conversion_Gmenu_Model); package Type_Conversion_Gmenu_Attribute_Iter is new Glib.Type_Conversion_Hooks.Hook_Registrator (Get_Type_Menu_Attribute_Iter'Access, Gmenu_Attribute_Iter_Record); pragma Unreferenced (Type_Conversion_Gmenu_Attribute_Iter); package Type_Conversion_Gmenu_Link_Iter is new Glib.Type_Conversion_Hooks.Hook_Registrator (Get_Type_Menu_Link_Iter'Access, Gmenu_Link_Iter_Record); pragma Unreferenced (Type_Conversion_Gmenu_Link_Iter); ------------------------------ -- Get_Item_Attribute_Value -- ------------------------------ function Get_Item_Attribute_Value (Self : not null access Gmenu_Model_Record; Item_Index : Glib.Gint; Attribute : UTF8_String; Expected_Type : Glib.Variant.Gvariant_Type) return Glib.Variant.Gvariant is function Internal (Self : System.Address; Item_Index : Glib.Gint; Attribute : Gtkada.Types.Chars_Ptr; Expected_Type : Glib.Variant.Gvariant_Type) return System.Address; pragma Import (C, Internal, "g_menu_model_get_item_attribute_value"); Tmp_Attribute : Gtkada.Types.Chars_Ptr := New_String (Attribute); Tmp_Return : System.Address; begin Tmp_Return := Internal (Get_Object (Self), Item_Index, Tmp_Attribute, Expected_Type); Free (Tmp_Attribute); return From_Object (Tmp_Return); end Get_Item_Attribute_Value; ------------------- -- Get_Item_Link -- ------------------- function Get_Item_Link (Self : not null access Gmenu_Model_Record; Item_Index : Glib.Gint; Link : UTF8_String) return Gmenu_Model is function Internal (Self : System.Address; Item_Index : Glib.Gint; Link : Gtkada.Types.Chars_Ptr) return System.Address; pragma Import (C, Internal, "g_menu_model_get_item_link"); Tmp_Link : Gtkada.Types.Chars_Ptr := New_String (Link); Stub_Gmenu_Model : Gmenu_Model_Record; Tmp_Return : System.Address; begin Tmp_Return := Internal (Get_Object (Self), Item_Index, Tmp_Link); Free (Tmp_Link); return Glib.Menu_Model.Gmenu_Model (Get_User_Data (Tmp_Return, Stub_Gmenu_Model)); end Get_Item_Link; ----------------- -- Get_N_Items -- ----------------- function Get_N_Items (Self : not null access Gmenu_Model_Record) return Glib.Gint is function Internal (Self : System.Address) return Glib.Gint; pragma Import (C, Internal, "g_menu_model_get_n_items"); begin return Internal (Get_Object (Self)); end Get_N_Items; -------------- -- Get_Name -- -------------- function Get_Name (Self : not null access Gmenu_Attribute_Iter_Record) return UTF8_String is function Internal (Self : System.Address) return Gtkada.Types.Chars_Ptr; pragma Import (C, Internal, "g_menu_attribute_iter_get_name"); begin return Gtkada.Bindings.Value_Allowing_Null (Internal (Get_Object (Self))); end Get_Name; -------------- -- Get_Name -- -------------- function Get_Name (Self : not null access Gmenu_Link_Iter_Record) return UTF8_String is function Internal (Self : System.Address) return Gtkada.Types.Chars_Ptr; pragma Import (C, Internal, "g_menu_link_iter_get_name"); begin return Gtkada.Bindings.Value_Allowing_Null (Internal (Get_Object (Self))); end Get_Name; --------------- -- Get_Value -- --------------- function Get_Value (Self : not null access Gmenu_Attribute_Iter_Record) return Glib.Variant.Gvariant is function Internal (Self : System.Address) return System.Address; pragma Import (C, Internal, "g_menu_attribute_iter_get_value"); begin return From_Object (Internal (Get_Object (Self))); end Get_Value; --------------- -- Get_Value -- --------------- function Get_Value (Self : not null access Gmenu_Link_Iter_Record) return Gmenu_Model is function Internal (Self : System.Address) return System.Address; pragma Import (C, Internal, "g_menu_link_iter_get_value"); Stub_Gmenu_Model : Gmenu_Model_Record; begin return Glib.Menu_Model.Gmenu_Model (Get_User_Data (Internal (Get_Object (Self)), Stub_Gmenu_Model)); end Get_Value; ---------------- -- Is_Mutable -- ---------------- function Is_Mutable (Self : not null access Gmenu_Model_Record) return Boolean is function Internal (Self : System.Address) return Glib.Gboolean; pragma Import (C, Internal, "g_menu_model_is_mutable"); begin return Internal (Get_Object (Self)) /= 0; end Is_Mutable; ------------------- -- Items_Changed -- ------------------- procedure Items_Changed (Self : not null access Gmenu_Model_Record; Position : Glib.Gint; Removed : Glib.Gint; Added : Glib.Gint) is procedure Internal (Self : System.Address; Position : Glib.Gint; Removed : Glib.Gint; Added : Glib.Gint); pragma Import (C, Internal, "g_menu_model_items_changed"); begin Internal (Get_Object (Self), Position, Removed, Added); end Items_Changed; ----------------------------- -- Iterate_Item_Attributes -- ----------------------------- function Iterate_Item_Attributes (Self : not null access Gmenu_Model_Record; Item_Index : Glib.Gint) return Gmenu_Attribute_Iter is function Internal (Self : System.Address; Item_Index : Glib.Gint) return System.Address; pragma Import (C, Internal, "g_menu_model_iterate_item_attributes"); Stub_Gmenu_Attribute_Iter : Gmenu_Attribute_Iter_Record; begin return Glib.Menu_Model.Gmenu_Attribute_Iter (Get_User_Data (Internal (Get_Object (Self), Item_Index), Stub_Gmenu_Attribute_Iter)); end Iterate_Item_Attributes; ------------------------ -- Iterate_Item_Links -- ------------------------ function Iterate_Item_Links (Self : not null access Gmenu_Model_Record; Item_Index : Glib.Gint) return Gmenu_Link_Iter is function Internal (Self : System.Address; Item_Index : Glib.Gint) return System.Address; pragma Import (C, Internal, "g_menu_model_iterate_item_links"); Stub_Gmenu_Link_Iter : Gmenu_Link_Iter_Record; begin return Glib.Menu_Model.Gmenu_Link_Iter (Get_User_Data (Internal (Get_Object (Self), Item_Index), Stub_Gmenu_Link_Iter)); end Iterate_Item_Links; ---------- -- Next -- ---------- function Next (Self : not null access Gmenu_Attribute_Iter_Record) return Boolean is function Internal (Self : System.Address) return Glib.Gboolean; pragma Import (C, Internal, "g_menu_attribute_iter_next"); begin return Internal (Get_Object (Self)) /= 0; end Next; ---------- -- Next -- ---------- function Next (Self : not null access Gmenu_Link_Iter_Record) return Boolean is function Internal (Self : System.Address) return Glib.Gboolean; pragma Import (C, Internal, "g_menu_link_iter_next"); begin return Internal (Get_Object (Self)) /= 0; end Next; use type System.Address; function Cb_To_Address is new Ada.Unchecked_Conversion (Cb_Gmenu_Model_Gint_Gint_Gint_Void, System.Address); function Address_To_Cb is new Ada.Unchecked_Conversion (System.Address, Cb_Gmenu_Model_Gint_Gint_Gint_Void); function Cb_To_Address is new Ada.Unchecked_Conversion (Cb_GObject_Gint_Gint_Gint_Void, System.Address); function Address_To_Cb is new Ada.Unchecked_Conversion (System.Address, Cb_GObject_Gint_Gint_Gint_Void); procedure Connect (Object : access Gmenu_Model_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_Gmenu_Model_Gint_Gint_Gint_Void; After : Boolean); procedure Connect_Slot (Object : access Gmenu_Model_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_GObject_Gint_Gint_Gint_Void; After : Boolean; Slot : access Glib.Object.GObject_Record'Class := null); procedure Marsh_GObject_Gint_Gint_Gint_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address); pragma Convention (C, Marsh_GObject_Gint_Gint_Gint_Void); procedure Marsh_Gmenu_Model_Gint_Gint_Gint_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address); pragma Convention (C, Marsh_Gmenu_Model_Gint_Gint_Gint_Void); ------------- -- Connect -- ------------- procedure Connect (Object : access Gmenu_Model_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_Gmenu_Model_Gint_Gint_Gint_Void; After : Boolean) is begin Unchecked_Do_Signal_Connect (Object => Object, C_Name => C_Name, Marshaller => Marsh_Gmenu_Model_Gint_Gint_Gint_Void'Access, Handler => Cb_To_Address (Handler),-- Set in the closure After => After); end Connect; ------------------ -- Connect_Slot -- ------------------ procedure Connect_Slot (Object : access Gmenu_Model_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_GObject_Gint_Gint_Gint_Void; After : Boolean; Slot : access Glib.Object.GObject_Record'Class := null) is begin Unchecked_Do_Signal_Connect (Object => Object, C_Name => C_Name, Marshaller => Marsh_GObject_Gint_Gint_Gint_Void'Access, Handler => Cb_To_Address (Handler),-- Set in the closure Slot_Object => Slot, After => After); end Connect_Slot; --------------------------------------- -- Marsh_GObject_Gint_Gint_Gint_Void -- --------------------------------------- procedure Marsh_GObject_Gint_Gint_Gint_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address) is pragma Unreferenced (Return_Value, N_Params, Invocation_Hint, User_Data); H : constant Cb_GObject_Gint_Gint_Gint_Void := Address_To_Cb (Get_Callback (Closure)); Obj : constant Glib.Object.GObject := Glib.Object.Convert (Get_Data (Closure)); begin H (Obj, Unchecked_To_Gint (Params, 1), Unchecked_To_Gint (Params, 2), Unchecked_To_Gint (Params, 3)); exception when E : others => Process_Exception (E); end Marsh_GObject_Gint_Gint_Gint_Void; ------------------------------------------- -- Marsh_Gmenu_Model_Gint_Gint_Gint_Void -- ------------------------------------------- procedure Marsh_Gmenu_Model_Gint_Gint_Gint_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address) is pragma Unreferenced (Return_Value, N_Params, Invocation_Hint, User_Data); H : constant Cb_Gmenu_Model_Gint_Gint_Gint_Void := Address_To_Cb (Get_Callback (Closure)); Obj : constant Gmenu_Model := Gmenu_Model (Unchecked_To_Object (Params, 0)); begin H (Obj, Unchecked_To_Gint (Params, 1), Unchecked_To_Gint (Params, 2), Unchecked_To_Gint (Params, 3)); exception when E : others => Process_Exception (E); end Marsh_Gmenu_Model_Gint_Gint_Gint_Void; ---------------------- -- On_Items_Changed -- ---------------------- procedure On_Items_Changed (Self : not null access Gmenu_Model_Record; Call : Cb_Gmenu_Model_Gint_Gint_Gint_Void; After : Boolean := False) is begin Connect (Self, "items-changed" & ASCII.NUL, Call, After); end On_Items_Changed; ---------------------- -- On_Items_Changed -- ---------------------- procedure On_Items_Changed (Self : not null access Gmenu_Model_Record; Call : Cb_GObject_Gint_Gint_Gint_Void; Slot : not null access Glib.Object.GObject_Record'Class; After : Boolean := False) is begin Connect_Slot (Self, "items-changed" & ASCII.NUL, Call, After, Slot); end On_Items_Changed; end Glib.Menu_Model; gtkada-24.0.0/src/generated/glib-menu_model.ads000066400000000000000000000405611446021174000213120ustar00rootroot00000000000000------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ -- -- Glib.Menu_Model.Gmenu_Model represents the contents of a menu -- an -- ordered list of menu items. The items are associated with actions, which -- can be activated through them. Items can be grouped in sections, and may -- have submenus associated with them. Both items and sections usually have -- some representation data, such as labels or icons. The type of the -- associated action (ie whether it is stateful, and what kind of state it -- has) can influence the representation of the item. -- -- The conceptual model of menus in Glib.Menu_Model.Gmenu_Model is -- hierarchical: sections and submenus are again represented by GMenu_Models. -- Menus themselves do not define their own roles. Rather, the role of a -- particular Glib.Menu_Model.Gmenu_Model is defined by the item that -- references it (or, in the case of the 'root' menu, is defined by the -- context in which it is used). -- -- As an example, consider the visible portions of this menu: -- -- ## An example menu # {menu-example} -- -- ![](menu-example.png) -- -- There are 8 "menus" visible in the screenshot: one menubar, two submenus -- and 5 sections: -- -- - the toplevel menubar (containing 4 items) - the View submenu (containing -- 3 sections) - the first section of the View submenu (containing 2 items) - -- the second section of the View submenu (containing 1 item) - the final -- section of the View submenu (containing 1 item) - the Highlight Mode -- submenu (containing 2 sections) - the Sources section (containing 2 items) -- - the Markup section (containing 2 items) -- -- The [example][menu-model] illustrates the conceptual connection between -- these 8 menus. Each large block in the figure represents a menu and the -- smaller blocks within the large block represent items in that menu. Some -- items contain references to other menus. -- -- ## A menu example # {menu-model} -- -- ![](menu-model.png) -- -- Notice that the separators visible in the [example][menu-example] appear -- nowhere in the [menu model][menu-model]. This is because separators are not -- explicitly represented in the menu model. Instead, a separator is inserted -- between any two non-empty sections of a menu. Section items can have labels -- just like any other item. In that case, a display system may show a section -- header instead of a separator. -- -- The motivation for this abstract model of application controls is that -- modern user interfaces tend to make these controls available outside the -- application. Examples include global menus, jumplists, dash boards, etc. To -- support such uses, it is necessary to 'export' information about actions -- and their representation in menus, which is exactly what the [GActionGroup -- exporter][gio-GActionGroup-exporter] and the [GMenuModel -- exporter][gio-GMenuModel-exporter] do for Glib.Action_Group.Gaction_Group -- and Glib.Menu_Model.Gmenu_Model. The client-side counterparts to make use -- of the exported information are Gdbus.Action_Group.Gdbus_Action_Group and -- Gdbus.Menu_Model.Gdbus_Menu_Model. -- -- The API of Glib.Menu_Model.Gmenu_Model is very generic, with iterators for -- the attributes and links of an item, see -- Glib.Menu_Model.Iterate_Item_Attributes and -- Glib.Menu_Model.Iterate_Item_Links. The 'standard' attributes and link -- types have predefined names: G_MENU_ATTRIBUTE_LABEL, -- G_MENU_ATTRIBUTE_ACTION, G_MENU_ATTRIBUTE_TARGET, G_MENU_LINK_SECTION and -- G_MENU_LINK_SUBMENU. -- -- Items in a Glib.Menu_Model.Gmenu_Model represent active controls if they -- refer to an action that can get activated when the user interacts with the -- menu item. The reference to the action is encoded by the string id in the -- G_MENU_ATTRIBUTE_ACTION attribute. An action id uniquely identifies an -- action in an action group. Which action group(s) provide actions depends on -- the context in which the menu model is used. E.g. when the model is -- exported as the application menu of a Gtk.Application.Gtk_Application, -- actions can be application-wide or window-specific (and thus come from two -- different action groups). By convention, the application-wide actions have -- names that start with "app.", while the names of window-specific actions -- start with "win.". -- -- While a wide variety of stateful actions is possible, the following is the -- minimum that is expected to be supported by all users of exported menu -- information: - an action with no parameter type and no state - an action -- with no parameter type and boolean state - an action with string parameter -- type and string state -- -- ## Stateless -- -- A stateless action typically corresponds to an ordinary menu item. -- -- Selecting such a menu item will activate the action (with no parameter). -- -- ## Boolean State -- -- An action with a boolean state will most typically be used with a "toggle" -- or "switch" menu item. The state can be set directly, but activating the -- action (with no parameter) results in the state being toggled. -- -- Selecting a toggle menu item will activate the action. The menu item -- should be rendered as "checked" when the state is true. -- -- ## String Parameter and State -- -- Actions with string parameters and state will most typically be used to -- represent an enumerated choice over the items available for a group of -- radio menu items. Activating the action with a string parameter is -- equivalent to setting that parameter as the state. -- -- Radio menu items, in addition to being associated with the action, will -- have a target value. Selecting that menu item will result in activation of -- the action with the target value as the parameter. The menu item should be -- rendered as "selected" when the state of the action is equal to the target -- value of the menu item. -- -- pragma Warnings (Off, "*is already use-visible*"); with Glib.Object; use Glib.Object; with Glib.Variant; use Glib.Variant; package Glib.Menu_Model is type Gmenu_Model_Record is new GObject_Record with null record; type Gmenu_Model is access all Gmenu_Model_Record'Class; type Gmenu_Attribute_Iter_Record is new GObject_Record with null record; type Gmenu_Attribute_Iter is access all Gmenu_Attribute_Iter_Record'Class; type Gmenu_Link_Iter_Record is new GObject_Record with null record; type Gmenu_Link_Iter is access all Gmenu_Link_Iter_Record'Class; ------------------ -- Constructors -- ------------------ function Get_Type_Menu_Model return Glib.GType; pragma Import (C, Get_Type_Menu_Model, "g_menu_model_get_type"); function Get_Type_Menu_Attribute_Iter return Glib.GType; pragma Import (C, Get_Type_Menu_Attribute_Iter, "g_menu_attribute_iter_get_type"); function Get_Type_Menu_Link_Iter return Glib.GType; pragma Import (C, Get_Type_Menu_Link_Iter, "g_menu_link_iter_get_type"); ------------- -- Methods -- ------------- function Get_Item_Attribute_Value (Self : not null access Gmenu_Model_Record; Item_Index : Glib.Gint; Attribute : UTF8_String; Expected_Type : Glib.Variant.Gvariant_Type) return Glib.Variant.Gvariant; -- Queries the item at position Item_Index in Model for the attribute -- specified by Attribute. -- If Expected_Type is non-null then it specifies the expected type of the -- attribute. If it is null then any type will be accepted. -- If the attribute exists and matches Expected_Type (or if the expected -- type is unspecified) then the value is returned. -- If the attribute does not exist, or does not match the expected type -- then null is returned. -- Since: gtk+ 2.32 -- "item_index": the index of the item -- "attribute": the attribute to query -- "expected_type": the expected type of the attribute, or null function Get_Item_Link (Self : not null access Gmenu_Model_Record; Item_Index : Glib.Gint; Link : UTF8_String) return Gmenu_Model; -- Queries the item at position Item_Index in Model for the link specified -- by Link. -- If the link exists, the linked Glib.Menu_Model.Gmenu_Model is returned. -- If the link does not exist, null is returned. -- Since: gtk+ 2.32 -- "item_index": the index of the item -- "link": the link to query function Get_N_Items (Self : not null access Gmenu_Model_Record) return Glib.Gint; -- Query the number of items in Model. -- Since: gtk+ 2.32 function Is_Mutable (Self : not null access Gmenu_Model_Record) return Boolean; -- Queries if Model is mutable. -- An immutable Glib.Menu_Model.Gmenu_Model will never emit the -- Glib.Menu_Model.Gmenu_Model::items-changed signal. Consumers of the -- model may make optimisations accordingly. -- Since: gtk+ 2.32 procedure Items_Changed (Self : not null access Gmenu_Model_Record; Position : Glib.Gint; Removed : Glib.Gint; Added : Glib.Gint); -- Requests emission of the Glib.Menu_Model.Gmenu_Model::items-changed -- signal on Model. -- This function should never be called except by -- Glib.Menu_Model.Gmenu_Model subclasses. Any other calls to this function -- will very likely lead to a violation of the interface of the model. -- The implementation should update its internal representation of the -- menu before emitting the signal. The implementation should further -- expect to receive queries about the new state of the menu (and -- particularly added menu items) while signal handlers are running. -- The implementation must dispatch this call directly from a mainloop -- entry and not in response to calls -- particularly those from the -- Glib.Menu_Model.Gmenu_Model API. Said another way: the menu must not -- change while user code is running without returning to the mainloop. -- Since: gtk+ 2.32 -- "position": the position of the change -- "removed": the number of items removed -- "added": the number of items added function Iterate_Item_Attributes (Self : not null access Gmenu_Model_Record; Item_Index : Glib.Gint) return Gmenu_Attribute_Iter; -- Creates a Glib.Menu_Model.Gmenu_Attribute_Iter to iterate over the -- attributes of the item at position Item_Index in Model. -- You must free the iterator with g_object_unref when you are done. -- Since: gtk+ 2.32 -- "item_index": the index of the item function Iterate_Item_Links (Self : not null access Gmenu_Model_Record; Item_Index : Glib.Gint) return Gmenu_Link_Iter; -- Creates a Glib.Menu_Model.Gmenu_Link_Iter to iterate over the links of -- the item at position Item_Index in Model. -- You must free the iterator with g_object_unref when you are done. -- Since: gtk+ 2.32 -- "item_index": the index of the item function Get_Name (Self : not null access Gmenu_Attribute_Iter_Record) return UTF8_String; -- Gets the name of the attribute at the current iterator position, as a -- string. -- The iterator is not advanced. -- Since: gtk+ 2.32 function Get_Name (Self : not null access Gmenu_Link_Iter_Record) return UTF8_String; -- Gets the name of the link at the current iterator position. -- The iterator is not advanced. -- Since: gtk+ 2.32 function Get_Value (Self : not null access Gmenu_Attribute_Iter_Record) return Glib.Variant.Gvariant; -- Gets the value of the attribute at the current iterator position. -- The iterator is not advanced. -- Since: gtk+ 2.32 function Get_Value (Self : not null access Gmenu_Link_Iter_Record) return Gmenu_Model; -- Gets the linked Glib.Menu_Model.Gmenu_Model at the current iterator -- position. -- The iterator is not advanced. -- Since: gtk+ 2.32 function Next (Self : not null access Gmenu_Attribute_Iter_Record) return Boolean; -- Attempts to advance the iterator to the next (possibly first) -- attribute. -- True is returned on success, or False if there are no more attributes. -- You must call this function when you first acquire the iterator to -- advance it to the first attribute (and determine if the first attribute -- exists at all). -- Since: gtk+ 2.32 function Next (Self : not null access Gmenu_Link_Iter_Record) return Boolean; -- Attempts to advance the iterator to the next (possibly first) link. -- True is returned on success, or False if there are no more links. -- You must call this function when you first acquire the iterator to -- advance it to the first link (and determine if the first link exists at -- all). -- Since: gtk+ 2.32 ------------- -- Signals -- ------------- type Cb_Gmenu_Model_Gint_Gint_Gint_Void is not null access procedure (Self : access Gmenu_Model_Record'Class; Position : Glib.Gint; Removed : Glib.Gint; Added : Glib.Gint); type Cb_GObject_Gint_Gint_Gint_Void is not null access procedure (Self : access Glib.Object.GObject_Record'Class; Position : Glib.Gint; Removed : Glib.Gint; Added : Glib.Gint); Signal_Items_Changed : constant Glib.Signal_Name := "items-changed"; procedure On_Items_Changed (Self : not null access Gmenu_Model_Record; Call : Cb_Gmenu_Model_Gint_Gint_Gint_Void; After : Boolean := False); procedure On_Items_Changed (Self : not null access Gmenu_Model_Record; Call : Cb_GObject_Gint_Gint_Gint_Void; Slot : not null access Glib.Object.GObject_Record'Class; After : Boolean := False); -- Emitted when a change has occurred to the menu. -- -- The only changes that can occur to a menu is that items are removed or -- added. Items may not change (except by being removed and added back in -- the same location). This signal is capable of describing both of those -- changes (at the same time). -- -- The signal means that starting at the index Position, Removed items -- were removed and Added items were added in their place. If Removed is -- zero then only items were added. If Added is zero then only items were -- removed. -- -- As an example, if the menu contains items a, b, c, d (in that order) -- and the signal (2, 1, 3) occurs then the new composition of the menu -- will be a, b, _, _, _, d (with each _ representing some new item). -- -- Signal handlers may query the model (particularly the added items) and -- expect to see the results of the modification that is being reported. -- The signal is emitted after the modification. -- -- Callback parameters: -- -- "position": the position of the change -- -- "removed": the number of items removed -- -- "added": the number of items added end Glib.Menu_Model; gtkada-24.0.0/src/generated/glib-notification.adb000066400000000000000000000212011446021174000216210ustar00rootroot00000000000000------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ pragma Style_Checks (Off); pragma Warnings (Off, "*is already use-visible*"); with Glib.Type_Conversion_Hooks; use Glib.Type_Conversion_Hooks; pragma Warnings(Off); -- might be unused with Gtkada.Types; use Gtkada.Types; pragma Warnings(On); package body Glib.Notification is package Type_Conversion_Gnotification is new Glib.Type_Conversion_Hooks.Hook_Registrator (Get_Type'Access, Gnotification_Record); pragma Unreferenced (Type_Conversion_Gnotification); ----------- -- G_New -- ----------- procedure G_New (Self : out Gnotification; Title : UTF8_String) is begin Self := new Gnotification_Record; Glib.Notification.Initialize (Self, Title); end G_New; ----------------------- -- Gnotification_New -- ----------------------- function Gnotification_New (Title : UTF8_String) return Gnotification is Self : constant Gnotification := new Gnotification_Record; begin Glib.Notification.Initialize (Self, Title); return Self; end Gnotification_New; ---------------- -- Initialize -- ---------------- procedure Initialize (Self : not null access Gnotification_Record'Class; Title : UTF8_String) is function Internal (Title : Gtkada.Types.Chars_Ptr) return System.Address; pragma Import (C, Internal, "g_notification_new"); Tmp_Title : Gtkada.Types.Chars_Ptr := New_String (Title); Tmp_Return : System.Address; begin if not Self.Is_Created then Tmp_Return := Internal (Tmp_Title); Free (Tmp_Title); Set_Object (Self, Tmp_Return); end if; end Initialize; ---------------- -- Add_Button -- ---------------- procedure Add_Button (Self : not null access Gnotification_Record; Label : UTF8_String; Detailed_Action : UTF8_String) is procedure Internal (Self : System.Address; Label : Gtkada.Types.Chars_Ptr; Detailed_Action : Gtkada.Types.Chars_Ptr); pragma Import (C, Internal, "g_notification_add_button"); Tmp_Label : Gtkada.Types.Chars_Ptr := New_String (Label); Tmp_Detailed_Action : Gtkada.Types.Chars_Ptr := New_String (Detailed_Action); begin Internal (Get_Object (Self), Tmp_Label, Tmp_Detailed_Action); Free (Tmp_Detailed_Action); Free (Tmp_Label); end Add_Button; ---------------------------------- -- Add_Button_With_Target_Value -- ---------------------------------- procedure Add_Button_With_Target_Value (Self : not null access Gnotification_Record; Label : UTF8_String; Action : UTF8_String; Target : Glib.Variant.Gvariant) is procedure Internal (Self : System.Address; Label : Gtkada.Types.Chars_Ptr; Action : Gtkada.Types.Chars_Ptr; Target : System.Address); pragma Import (C, Internal, "g_notification_add_button_with_target_value"); Tmp_Label : Gtkada.Types.Chars_Ptr := New_String (Label); Tmp_Action : Gtkada.Types.Chars_Ptr := New_String (Action); begin Internal (Get_Object (Self), Tmp_Label, Tmp_Action, Get_Object (Target)); Free (Tmp_Action); Free (Tmp_Label); end Add_Button_With_Target_Value; -------------- -- Set_Body -- -------------- procedure Set_Body (Self : not null access Gnotification_Record; The_Body : UTF8_String := "") is procedure Internal (Self : System.Address; The_Body : Gtkada.Types.Chars_Ptr); pragma Import (C, Internal, "g_notification_set_body"); Tmp_The_Body : Gtkada.Types.Chars_Ptr; begin if The_Body = "" then Tmp_The_Body := Gtkada.Types.Null_Ptr; else Tmp_The_Body := New_String (The_Body); end if; Internal (Get_Object (Self), Tmp_The_Body); Free (Tmp_The_Body); end Set_Body; ------------------------ -- Set_Default_Action -- ------------------------ procedure Set_Default_Action (Self : not null access Gnotification_Record; Detailed_Action : UTF8_String) is procedure Internal (Self : System.Address; Detailed_Action : Gtkada.Types.Chars_Ptr); pragma Import (C, Internal, "g_notification_set_default_action"); Tmp_Detailed_Action : Gtkada.Types.Chars_Ptr := New_String (Detailed_Action); begin Internal (Get_Object (Self), Tmp_Detailed_Action); Free (Tmp_Detailed_Action); end Set_Default_Action; ----------------------------------------- -- Set_Default_Action_And_Target_Value -- ----------------------------------------- procedure Set_Default_Action_And_Target_Value (Self : not null access Gnotification_Record; Action : UTF8_String; Target : Glib.Variant.Gvariant) is procedure Internal (Self : System.Address; Action : Gtkada.Types.Chars_Ptr; Target : System.Address); pragma Import (C, Internal, "g_notification_set_default_action_and_target_value"); Tmp_Action : Gtkada.Types.Chars_Ptr := New_String (Action); begin Internal (Get_Object (Self), Tmp_Action, Get_Object (Target)); Free (Tmp_Action); end Set_Default_Action_And_Target_Value; -------------- -- Set_Icon -- -------------- procedure Set_Icon (Self : not null access Gnotification_Record; Icon : Glib.G_Icon.G_Icon) is procedure Internal (Self : System.Address; Icon : Glib.G_Icon.G_Icon); pragma Import (C, Internal, "g_notification_set_icon"); begin Internal (Get_Object (Self), Icon); end Set_Icon; ------------------ -- Set_Priority -- ------------------ procedure Set_Priority (Self : not null access Gnotification_Record; Priority : GNotification_Priority) is procedure Internal (Self : System.Address; Priority : GNotification_Priority); pragma Import (C, Internal, "g_notification_set_priority"); begin Internal (Get_Object (Self), Priority); end Set_Priority; --------------- -- Set_Title -- --------------- procedure Set_Title (Self : not null access Gnotification_Record; Title : UTF8_String) is procedure Internal (Self : System.Address; Title : Gtkada.Types.Chars_Ptr); pragma Import (C, Internal, "g_notification_set_title"); Tmp_Title : Gtkada.Types.Chars_Ptr := New_String (Title); begin Internal (Get_Object (Self), Tmp_Title); Free (Tmp_Title); end Set_Title; ---------------- -- Set_Urgent -- ---------------- procedure Set_Urgent (Self : not null access Gnotification_Record; Urgent : Boolean) is procedure Internal (Self : System.Address; Urgent : Glib.Gboolean); pragma Import (C, Internal, "g_notification_set_urgent"); begin Internal (Get_Object (Self), Boolean'Pos (Urgent)); end Set_Urgent; end Glib.Notification; gtkada-24.0.0/src/generated/glib-notification.ads000066400000000000000000000231571446021174000216560ustar00rootroot00000000000000------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ -- -- Glib.Notification.Gnotification is a mechanism for creating a notification -- to be shown to the user -- typically as a pop-up notification presented by -- the desktop environment shell. -- -- The key difference between Glib.Notification.Gnotification and other -- similar APIs is that, if supported by the desktop environment, -- notifications sent with Glib.Notification.Gnotification will persist after -- the application has exited, and even across system reboots. -- -- Since the user may click on a notification while the application is not -- running, applications using Glib.Notification.Gnotification should be able -- to be started as a D-Bus service, using Glib.Application.Gapplication. -- -- User interaction with a notification (either the default action, or -- buttons) must be associated with actions on the application (ie: "app." -- actions). It is not possible to route user interaction through the -- notification itself, because the object will not exist if the application -- is autostarted as a result of a notification being clicked. -- -- A notification can be sent with Glib.Application.Send_Notification. -- -- pragma Warnings (Off, "*is already use-visible*"); with Glib.G_Icon; use Glib.G_Icon; with Glib.Generic_Properties; use Glib.Generic_Properties; with Glib.Object; use Glib.Object; with Glib.Variant; use Glib.Variant; package Glib.Notification is type Gnotification_Record is new GObject_Record with null record; type Gnotification is access all Gnotification_Record'Class; type GNotification_Priority is ( G_Notification_Priority_Normal, G_Notification_Priority_Low, G_Notification_Priority_High, G_Notification_Priority_Urgent); pragma Convention (C, GNotification_Priority); -- Priority levels for GNotifications. ---------------------------- -- Enumeration Properties -- ---------------------------- package GNotification_Priority_Properties is new Generic_Internal_Discrete_Property (GNotification_Priority); type Property_GNotification_Priority is new GNotification_Priority_Properties.Property; ------------------ -- Constructors -- ------------------ procedure G_New (Self : out Gnotification; Title : UTF8_String); -- Creates a new Glib.Notification.Gnotification with Title as its title. -- After populating Notification with more details, it can be sent to the -- desktop shell with Glib.Application.Send_Notification. Changing any -- properties after this call will not have any effect until resending -- Notification. -- Since: gtk+ 2.40 -- "title": the title of the notification procedure Initialize (Self : not null access Gnotification_Record'Class; Title : UTF8_String); -- Creates a new Glib.Notification.Gnotification with Title as its title. -- After populating Notification with more details, it can be sent to the -- desktop shell with Glib.Application.Send_Notification. Changing any -- properties after this call will not have any effect until resending -- Notification. -- Since: gtk+ 2.40 -- Initialize does nothing if the object was already created with another -- call to Initialize* or G_New. -- "title": the title of the notification function Gnotification_New (Title : UTF8_String) return Gnotification; -- Creates a new Glib.Notification.Gnotification with Title as its title. -- After populating Notification with more details, it can be sent to the -- desktop shell with Glib.Application.Send_Notification. Changing any -- properties after this call will not have any effect until resending -- Notification. -- Since: gtk+ 2.40 -- "title": the title of the notification function Get_Type return Glib.GType; pragma Import (C, Get_Type, "g_notification_get_type"); ------------- -- Methods -- ------------- procedure Add_Button (Self : not null access Gnotification_Record; Label : UTF8_String; Detailed_Action : UTF8_String); -- Adds a button to Notification that activates the action in -- Detailed_Action when clicked. That action must be an application-wide -- action (starting with "app."). If Detailed_Action contains a target, the -- action will be activated with that target as its parameter. -- See g_action_parse_detailed_name for a description of the format for -- Detailed_Action. -- Since: gtk+ 2.40 -- "label": label of the button -- "detailed_action": a detailed action name procedure Add_Button_With_Target_Value (Self : not null access Gnotification_Record; Label : UTF8_String; Action : UTF8_String; Target : Glib.Variant.Gvariant); -- Adds a button to Notification that activates Action when clicked. -- Action must be an application-wide action (it must start with "app."). -- If Target is non-null, Action will be activated with Target as its -- parameter. -- Since: gtk+ 2.40 -- "label": label of the button -- "action": an action name -- "target": a Glib.Variant.Gvariant to use as Action's parameter, or null procedure Set_Body (Self : not null access Gnotification_Record; The_Body : UTF8_String := ""); -- Sets the body of Notification to Body. -- Since: gtk+ 2.40 -- "the_body": the new body for Notification, or null procedure Set_Default_Action (Self : not null access Gnotification_Record; Detailed_Action : UTF8_String); -- Sets the default action of Notification to Detailed_Action. This action -- is activated when the notification is clicked on. -- The action in Detailed_Action must be an application-wide action (it -- must start with "app."). If Detailed_Action contains a target, the given -- action will be activated with that target as its parameter. See -- g_action_parse_detailed_name for a description of the format for -- Detailed_Action. -- When no default action is set, the application that the notification -- was sent on is activated. -- Since: gtk+ 2.40 -- "detailed_action": a detailed action name procedure Set_Default_Action_And_Target_Value (Self : not null access Gnotification_Record; Action : UTF8_String; Target : Glib.Variant.Gvariant); -- Sets the default action of Notification to Action. This action is -- activated when the notification is clicked on. It must be an -- application-wide action (start with "app."). -- If Target is non-null, Action will be activated with Target as its -- parameter. -- When no default action is set, the application that the notification -- was sent on is activated. -- Since: gtk+ 2.40 -- "action": an action name -- "target": a Glib.Variant.Gvariant to use as Action's parameter, or null procedure Set_Icon (Self : not null access Gnotification_Record; Icon : Glib.G_Icon.G_Icon); -- Sets the icon of Notification to Icon. -- Since: gtk+ 2.40 -- "icon": the icon to be shown in Notification, as a Glib.G_Icon.G_Icon procedure Set_Priority (Self : not null access Gnotification_Record; Priority : GNotification_Priority); -- Sets the priority of Notification to Priority. See -- Glib.Notification.GNotification_Priority for possible values. -- "priority": a Glib.Notification.GNotification_Priority procedure Set_Title (Self : not null access Gnotification_Record; Title : UTF8_String); -- Sets the title of Notification to Title. -- Since: gtk+ 2.40 -- "title": the new title for Notification procedure Set_Urgent (Self : not null access Gnotification_Record; Urgent : Boolean); pragma Obsolescent (Set_Urgent); -- Deprecated in favor of Glib.Notification.Set_Priority. -- Since: gtk+ 2.40 -- Deprecated since 2.42, 1 -- "urgent": True if Notification is urgent end Glib.Notification; gtkada-24.0.0/src/generated/glib-option.adb000066400000000000000000000443701446021174000204570ustar00rootroot00000000000000------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ pragma Style_Checks (Off); pragma Warnings (Off, "*is already use-visible*"); with Ada.Unchecked_Conversion; with Glib.Object; package body Glib.Option is function From_Object_Free (B : access Goption_Context'Class) return Goption_Context is Result : constant Goption_Context := Goption_Context (B.all); begin Glib.g_free (B.all'Address); return Result; end From_Object_Free; function From_Object (Object : System.Address) return Goption_Context is S : Goption_Context; begin S.Set_Object (Object); return S; end From_Object; function From_Object_Free (B : access GOption_Group) return GOption_Group is Result : constant GOption_Group := B.all; begin Glib.g_free (B.all'Address); return Result; end From_Object_Free; function From_Object_Free (B : access GOption_Entry) return GOption_Entry is Result : constant GOption_Entry := B.all; begin Glib.g_free (B.all'Address); return Result; end From_Object_Free; ----------- -- Parse -- ----------- procedure Parse (Self : Goption_Context; Command_Line : not null access Glib.Application.Gapplication_Command_Line_Record'Class; Filter : Parse_Filter := null; Success : out Boolean; Error : out Glib.Error.GError) is function Get_Args (Self : System.Address; Argc : access Glib.Gint) return chars_ptr_array_access; pragma Import (C, Get_Args, "g_application_command_line_get_arguments"); function Internal (Self : System.Address; Argc : access Glib.Gint; Argv : System.Address; Error : System.Address) return Glib.Gboolean; pragma Import (C, Internal, "g_option_context_parse"); pragma Warnings (Off, "possible aliasing problem for*"); function Convert is new Ada.Unchecked_Conversion (System.Address, chars_ptr_array_access); pragma Warnings (On, "possible aliasing problem for*"); Argc : aliased Glib.Gint; Argv : chars_ptr_array_access; Err : Glib.Error.GError; Ret : Glib.Gboolean; begin Argv := Get_Args (Command_Line.Get_Object, Argc'Access); if Filter = null then Ret := Internal (Get_Object (Self), Argc'Access, Argv'Address, Err'Address); else declare Args : aliased Gtkada.Types.Chars_Ptr_Array := To_Chars_Ptr (Argv); Idx : aliased Glib.Gint := 1; begin -- Copy command name argument Args (0) := Argv (0); Idx := 1; for J in 1 .. Argc - 1 loop if Filter (Gtkada.Types.Value (Argv (Interfaces.C.size_t (J)))) then Args (Interfaces.C.size_t (Idx)) := Argv (Interfaces.C.size_t (J)); Idx := Idx + 1; end if; end loop; Argv := Convert (Args'Address); Ret := Internal (Get_Object (Self), Idx'Access, Argv'Address, Err'Address); end; end if; Error := Err; Success := Ret /= 0; end Parse; ----------- -- Parse -- ----------- procedure Parse (Self : Goption_Context; Argv : access chars_ptr_array_access;-- Null-terminated Success : out Boolean; Error : out Glib.Error.GError) is use Interfaces.C; function Internal (Self : System.Address; Argc : access Glib.Gint; Argv : access chars_ptr_array_access; Error : System.Address) return Glib.Gboolean; pragma Import (C, Internal, "g_option_context_parse"); Err : Glib.Error.GError; Ret : Glib.Gboolean; Argc : aliased Glib.Gint := 0; begin while Argv.all (size_t (Argc)) /= Gtkada.Types.Null_Ptr loop Argc := Argc + 1; end loop; Ret := Internal (Get_Object (Self), Argc'Access, Argv, Err'Address); Argv.all (size_t (Argc)) := Gtkada.Types.Null_Ptr; Error := Err; Success := Ret /= 0; end Parse; procedure C_G_Option_Context_Set_Translate_Func (Self : System.Address; Func : System.Address; Data : System.Address; Destroy_Notify : Glib.G_Destroy_Notify_Address); pragma Import (C, C_G_Option_Context_Set_Translate_Func, "g_option_context_set_translate_func"); -- Sets the function which is used to translate the contexts user-visible -- strings, for `--help` output. If Func is null, strings are not -- translated. -- Note that option groups have their own translation functions, this -- function only affects the Parameter_String (see Glib.Option.G_New), the -- summary (see Glib.Option.Set_Summary) and the description (see -- Glib.Option.Set_Description). -- If you are using gettext, you only need to set the translation domain, -- see Glib.Option.Set_Translation_Domain. -- Since: gtk+ 2.12 -- "func": the Gtranslate_Func, or null -- "data": user data to pass to Func, or null -- "destroy_notify": a function which gets called to free Data, or null function To_Gtranslate_Func is new Ada.Unchecked_Conversion (System.Address, Gtranslate_Func); function To_Address is new Ada.Unchecked_Conversion (Gtranslate_Func, System.Address); function Internal_Gtranslate_Func (Str : Gtkada.Types.Chars_Ptr; Data : System.Address) return Gtkada.Types.Chars_Ptr; pragma Convention (C, Internal_Gtranslate_Func); -- "str": the untranslated string -- "data": user data specified when installing the function, e.g. in -- g_option_group_set_translate_func ------------------------------ -- Internal_Gtranslate_Func -- ------------------------------ function Internal_Gtranslate_Func (Str : Gtkada.Types.Chars_Ptr; Data : System.Address) return Gtkada.Types.Chars_Ptr is Func : constant Gtranslate_Func := To_Gtranslate_Func (Data); begin return New_String (Func (Gtkada.Bindings.Value_Allowing_Null (Str))); end Internal_Gtranslate_Func; --------------- -- Add_Group -- --------------- procedure Add_Group (Self : Goption_Context; Group : GOption_Group) is procedure Internal (Self : System.Address; Group : GOption_Group); pragma Import (C, Internal, "g_option_context_add_group"); begin Internal (Get_Object (Self), Group); end Add_Group; ---------------------- -- Add_Main_Entries -- ---------------------- procedure Add_Main_Entries (Self : Goption_Context; Entries : GOption_Entry_Array; Translation_Domain : UTF8_String := "") is procedure Internal (Self : System.Address; Entries : GOption_Entry_Array; Translation_Domain : Gtkada.Types.Chars_Ptr); pragma Import (C, Internal, "g_option_context_add_main_entries"); Tmp_Translation_Domain : Gtkada.Types.Chars_Ptr; begin if Translation_Domain = "" then Tmp_Translation_Domain := Gtkada.Types.Null_Ptr; else Tmp_Translation_Domain := New_String (Translation_Domain); end if; Internal (Get_Object (Self), Entries, Tmp_Translation_Domain); Free (Tmp_Translation_Domain); end Add_Main_Entries; ---------- -- Free -- ---------- procedure Free (Self : Goption_Context) is procedure Internal (Self : System.Address); pragma Import (C, Internal, "g_option_context_free"); begin Internal (Get_Object (Self)); end Free; --------------------- -- Get_Description -- --------------------- function Get_Description (Self : Goption_Context) return UTF8_String is function Internal (Self : System.Address) return Gtkada.Types.Chars_Ptr; pragma Import (C, Internal, "g_option_context_get_description"); begin return Gtkada.Bindings.Value_Allowing_Null (Internal (Get_Object (Self))); end Get_Description; -------------- -- Get_Help -- -------------- function Get_Help (Self : Goption_Context; Main_Help : Boolean; Group : GOption_Group) return UTF8_String is function Internal (Self : System.Address; Main_Help : Glib.Gboolean; Group : GOption_Group) return Gtkada.Types.Chars_Ptr; pragma Import (C, Internal, "g_option_context_get_help"); begin return Gtkada.Bindings.Value_And_Free (Internal (Get_Object (Self), Boolean'Pos (Main_Help), Group)); end Get_Help; ---------------------- -- Get_Help_Enabled -- ---------------------- function Get_Help_Enabled (Self : Goption_Context) return Boolean is function Internal (Self : System.Address) return Glib.Gboolean; pragma Import (C, Internal, "g_option_context_get_help_enabled"); begin return Internal (Get_Object (Self)) /= 0; end Get_Help_Enabled; -------------------------------- -- Get_Ignore_Unknown_Options -- -------------------------------- function Get_Ignore_Unknown_Options (Self : Goption_Context) return Boolean is function Internal (Self : System.Address) return Glib.Gboolean; pragma Import (C, Internal, "g_option_context_get_ignore_unknown_options"); begin return Internal (Get_Object (Self)) /= 0; end Get_Ignore_Unknown_Options; -------------------- -- Get_Main_Group -- -------------------- function Get_Main_Group (Self : Goption_Context) return GOption_Group is function Internal (Self : System.Address) return access GOption_Group; pragma Import (C, Internal, "g_option_context_get_main_group"); begin return Internal (Get_Object (Self)).all; end Get_Main_Group; ----------------- -- Get_Summary -- ----------------- function Get_Summary (Self : Goption_Context) return UTF8_String is function Internal (Self : System.Address) return Gtkada.Types.Chars_Ptr; pragma Import (C, Internal, "g_option_context_get_summary"); begin return Gtkada.Bindings.Value_Allowing_Null (Internal (Get_Object (Self))); end Get_Summary; --------------------- -- Set_Description -- --------------------- procedure Set_Description (Self : Goption_Context; Description : UTF8_String := "") is procedure Internal (Self : System.Address; Description : Gtkada.Types.Chars_Ptr); pragma Import (C, Internal, "g_option_context_set_description"); Tmp_Description : Gtkada.Types.Chars_Ptr; begin if Description = "" then Tmp_Description := Gtkada.Types.Null_Ptr; else Tmp_Description := New_String (Description); end if; Internal (Get_Object (Self), Tmp_Description); Free (Tmp_Description); end Set_Description; ---------------------- -- Set_Help_Enabled -- ---------------------- procedure Set_Help_Enabled (Self : Goption_Context; Help_Enabled : Boolean) is procedure Internal (Self : System.Address; Help_Enabled : Glib.Gboolean); pragma Import (C, Internal, "g_option_context_set_help_enabled"); begin Internal (Get_Object (Self), Boolean'Pos (Help_Enabled)); end Set_Help_Enabled; -------------------------------- -- Set_Ignore_Unknown_Options -- -------------------------------- procedure Set_Ignore_Unknown_Options (Self : Goption_Context; Ignore_Unknown : Boolean) is procedure Internal (Self : System.Address; Ignore_Unknown : Glib.Gboolean); pragma Import (C, Internal, "g_option_context_set_ignore_unknown_options"); begin Internal (Get_Object (Self), Boolean'Pos (Ignore_Unknown)); end Set_Ignore_Unknown_Options; -------------------- -- Set_Main_Group -- -------------------- procedure Set_Main_Group (Self : Goption_Context; Group : GOption_Group) is procedure Internal (Self : System.Address; Group : GOption_Group); pragma Import (C, Internal, "g_option_context_set_main_group"); begin Internal (Get_Object (Self), Group); end Set_Main_Group; ----------------- -- Set_Summary -- ----------------- procedure Set_Summary (Self : Goption_Context; Summary : UTF8_String := "") is procedure Internal (Self : System.Address; Summary : Gtkada.Types.Chars_Ptr); pragma Import (C, Internal, "g_option_context_set_summary"); Tmp_Summary : Gtkada.Types.Chars_Ptr; begin if Summary = "" then Tmp_Summary := Gtkada.Types.Null_Ptr; else Tmp_Summary := New_String (Summary); end if; Internal (Get_Object (Self), Tmp_Summary); Free (Tmp_Summary); end Set_Summary; ------------------------ -- Set_Translate_Func -- ------------------------ procedure Set_Translate_Func (Self : Goption_Context; Func : Gtranslate_Func; Destroy_Notify : Glib.G_Destroy_Notify_Address) is begin if Func = null then C_G_Option_Context_Set_Translate_Func (Get_Object (Self), System.Null_Address, System.Null_Address, Destroy_Notify); else C_G_Option_Context_Set_Translate_Func (Get_Object (Self), Internal_Gtranslate_Func'Address, To_Address (Func), Destroy_Notify); end if; end Set_Translate_Func; package body Set_Translate_Func_User_Data is package Users is new Glib.Object.User_Data_Closure (User_Data_Type, Destroy); function To_Gtranslate_Func is new Ada.Unchecked_Conversion (System.Address, Gtranslate_Func); function To_Address is new Ada.Unchecked_Conversion (Gtranslate_Func, System.Address); function Internal_Cb (Str : Gtkada.Types.Chars_Ptr; Data : System.Address) return Gtkada.Types.Chars_Ptr; pragma Convention (C, Internal_Cb); -- The type of functions which are used to translate user-visible -- strings, for output. -- "str": the untranslated string -- "data": user data specified when installing the function, e.g. in -- g_option_group_set_translate_func ----------------- -- Internal_Cb -- ----------------- function Internal_Cb (Str : Gtkada.Types.Chars_Ptr; Data : System.Address) return Gtkada.Types.Chars_Ptr is D : constant Users.Internal_Data_Access := Users.Convert (Data); begin return New_String (To_Gtranslate_Func (D.Func) (Gtkada.Bindings.Value_Allowing_Null (Str), D.Data.all)); end Internal_Cb; ------------------------ -- Set_Translate_Func -- ------------------------ procedure Set_Translate_Func (Self : Glib.Option.Goption_Context; Func : Gtranslate_Func; Data : User_Data_Type; Destroy_Notify : Glib.G_Destroy_Notify_Address) is D : System.Address; begin if Func = null then C_G_Option_Context_Set_Translate_Func (Get_Object (Self), System.Null_Address, System.Null_Address, Destroy_Notify); else D := Users.Build (To_Address (Func), Data); C_G_Option_Context_Set_Translate_Func (Get_Object (Self), Internal_Cb'Address, D, Destroy_Notify); end if; end Set_Translate_Func; end Set_Translate_Func_User_Data; ---------------------------- -- Set_Translation_Domain -- ---------------------------- procedure Set_Translation_Domain (Self : Goption_Context; Domain : UTF8_String) is procedure Internal (Self : System.Address; Domain : Gtkada.Types.Chars_Ptr); pragma Import (C, Internal, "g_option_context_set_translation_domain"); Tmp_Domain : Gtkada.Types.Chars_Ptr := New_String (Domain); begin Internal (Get_Object (Self), Tmp_Domain); Free (Tmp_Domain); end Set_Translation_Domain; ----------- -- G_New -- ----------- function G_New (Parameter_String : UTF8_String := "") return Goption_Context is function Internal (Parameter_String : Gtkada.Types.Chars_Ptr) return System.Address; pragma Import (C, Internal, "g_option_context_new"); Tmp_Parameter_String : Gtkada.Types.Chars_Ptr; Tmp_Return : System.Address; begin if Parameter_String = "" then Tmp_Parameter_String := Gtkada.Types.Null_Ptr; else Tmp_Parameter_String := New_String (Parameter_String); end if; Tmp_Return := Internal (Tmp_Parameter_String); Free (Tmp_Parameter_String); return From_Object (Tmp_Return); end G_New; end Glib.Option; gtkada-24.0.0/src/generated/glib-option.ads000066400000000000000000000414301446021174000204720ustar00rootroot00000000000000------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ -- -- A `GOptionContext` struct defines which options are accepted by the -- commandline option parser. The struct has only private fields and should -- not be directly accessed. -- -- pragma Warnings (Off, "*is already use-visible*"); with Glib.Application; use Glib.Application; with Glib.Error; use Glib.Error; with Glib.Generic_Properties; use Glib.Generic_Properties; with Gtkada.Bindings; use Gtkada.Bindings; with Gtkada.Types; use Gtkada.Types; package Glib.Option is type Goption_Context is new Glib.C_Boxed with null record; Null_Goption_Context : constant Goption_Context; function From_Object (Object : System.Address) return Goption_Context; function From_Object_Free (B : access Goption_Context'Class) return Goption_Context; pragma Inline (From_Object_Free, From_Object); type GOption_Error is ( G_Option_Error_Unknown_Option, G_Option_Error_Bad_Value, G_Option_Error_Failed); pragma Convention (C, GOption_Error); -- Error codes returned by option parsing. type GOption_Arg is ( G_Option_Arg_None, G_Option_Arg_String, G_Option_Arg_Int, G_Option_Arg_Callback, G_Option_Arg_Filename, G_Option_Arg_String_Array, G_Option_Arg_Filename_Array, G_Option_Arg_Double, G_Option_Arg_Int64); pragma Convention (C, GOption_Arg); -- The Glib.Option.GOption_Arg enum values determine which type of extra -- argument the options expect to find. If an option expects an extra -- argument, it can be specified in several ways; with a short option: `-x -- arg`, with a long option: `--name arg` or combined in a single argument: -- `--name=arg`. type GOption_Flags is mod 2 ** Integer'Size; pragma Convention (C, GOption_Flags); -- Flags which modify individual options. G_Option_Flag_None : constant GOption_Flags := 0; G_Option_Flag_Hidden : constant GOption_Flags := 1; G_Option_Flag_In_Main : constant GOption_Flags := 2; G_Option_Flag_Reverse : constant GOption_Flags := 4; G_Option_Flag_No_Arg : constant GOption_Flags := 8; G_Option_Flag_Filename : constant GOption_Flags := 16; G_Option_Flag_Optional_Arg : constant GOption_Flags := 32; G_Option_Flag_Noalias : constant GOption_Flags := 64; type GOption_Group is new Glib.C_Proxy; function From_Object_Free (B : access GOption_Group) return GOption_Group; pragma Inline (From_Object_Free); -- A `GOptionGroup` struct defines the options in a single group. The -- struct has only private fields and should not be directly accessed. -- -- All options in a group share the same translation function. Libraries -- which need to parse commandline options are expected to provide a -- function for getting a `GOptionGroup` holding their options, which the -- application can then add to its Glib.Option.Goption_Context. type GOption_Entry is record Long_Name : Gtkada.Types.Chars_Ptr; Short_Name : Gchar; Flags : GOption_Flags; Arg : GOption_Arg; Arg_Data : System.Address := System.Null_Address; Description : Gtkada.Types.Chars_Ptr; Arg_Description : Gtkada.Types.Chars_Ptr; end record; pragma Convention (C, GOption_Entry); function From_Object_Free (B : access GOption_Entry) return GOption_Entry; pragma Inline (From_Object_Free); -- A GOptionEntry struct defines a single option. To have an effect, they -- must be added to a Glib.Option.GOption_Group with -- Glib.Option.Add_Main_Entries or g_option_group_add_entries. type GOption_Entry_Array is array (Natural range <>) of GOption_Entry; --------------- -- Callbacks -- --------------- type Gtranslate_Func is access function (Str : UTF8_String) return UTF8_String; -- The type of functions which are used to translate user-visible strings, -- for output. -- "str": the untranslated string ---------------------------- -- Enumeration Properties -- ---------------------------- package GOption_Error_Properties is new Generic_Internal_Discrete_Property (GOption_Error); type Property_GOption_Error is new GOption_Error_Properties.Property; package GOption_Arg_Properties is new Generic_Internal_Discrete_Property (GOption_Arg); type Property_GOption_Arg is new GOption_Arg_Properties.Property; package GOption_Flags_Properties is new Generic_Internal_Discrete_Property (GOption_Flags); type Property_GOption_Flags is new GOption_Flags_Properties.Property; ------------- -- Methods -- ------------- procedure Add_Group (Self : Goption_Context; Group : GOption_Group); -- Adds a Glib.Option.GOption_Group to the Context, so that parsing with -- Context will recognize the options in the group. Note that the group -- will be freed together with the context when Glib.Option.Free is called, -- so you must not free the group yourself after adding it to a context. -- Since: gtk+ 2.6 -- "group": the group to add procedure Add_Main_Entries (Self : Goption_Context; Entries : GOption_Entry_Array; Translation_Domain : UTF8_String := ""); -- A convenience function which creates a main group if it doesn't exist, -- adds the Entries to it and sets the translation domain. -- Since: gtk+ 2.6 -- "entries": a null-terminated array of GOption_Entrys -- "translation_domain": a translation domain to use for translating the -- `--help` output for the options in Entries with gettext, or null procedure Free (Self : Goption_Context); -- Frees context and all the groups which have been added to it. -- Please note that parsed arguments need to be freed separately (see -- Glib.Option.GOption_Entry). -- Since: gtk+ 2.6 function Get_Description (Self : Goption_Context) return UTF8_String; -- Returns the description. See Glib.Option.Set_Description. -- Since: gtk+ 2.12 procedure Set_Description (Self : Goption_Context; Description : UTF8_String := ""); -- Adds a string to be displayed in `--help` output after the list of -- options. This text often includes a bug reporting address. -- Note that the summary is translated (see -- Glib.Option.Set_Translate_Func). -- Since: gtk+ 2.12 -- "description": a string to be shown in `--help` output after the list -- of options, or null function Get_Help (Self : Goption_Context; Main_Help : Boolean; Group : GOption_Group) return UTF8_String; -- Returns a formatted, translated help text for the given context. To -- obtain the text produced by `--help`, call `g_option_context_get_help -- (context, TRUE, NULL)`. To obtain the text produced by `--help-all`, -- call `g_option_context_get_help (context, FALSE, NULL)`. To obtain the -- help text for an option group, call `g_option_context_get_help (context, -- FALSE, group)`. -- Since: gtk+ 2.14 -- "main_help": if True, only include the main group -- "group": the Glib.Option.GOption_Group to create help for, or null function Get_Help_Enabled (Self : Goption_Context) return Boolean; -- Returns whether automatic `--help` generation is turned on for Context. -- See Glib.Option.Set_Help_Enabled. -- Since: gtk+ 2.6 procedure Set_Help_Enabled (Self : Goption_Context; Help_Enabled : Boolean); -- Enables or disables automatic generation of `--help` output. By -- default, g_option_context_parse recognizes `--help`, `-h`, `-?`, -- `--help-all` and `--help-groupname` and creates suitable output to -- stdout. -- Since: gtk+ 2.6 -- "help_enabled": True to enable `--help`, False to disable it function Get_Ignore_Unknown_Options (Self : Goption_Context) return Boolean; -- Returns whether unknown options are ignored or not. See -- Glib.Option.Set_Ignore_Unknown_Options. -- Since: gtk+ 2.6 procedure Set_Ignore_Unknown_Options (Self : Goption_Context; Ignore_Unknown : Boolean); -- Sets whether to ignore unknown options or not. If an argument is -- ignored, it is left in the Argv array after parsing. By default, -- g_option_context_parse treats unknown options as error. -- This setting does not affect non-option arguments (i.e. arguments which -- don't start with a dash). But note that GOption cannot reliably -- determine whether a non-option belongs to a preceding unknown option. -- Since: gtk+ 2.6 -- "ignore_unknown": True to ignore unknown options, False to produce an -- error when unknown options are met function Get_Main_Group (Self : Goption_Context) return GOption_Group; -- Returns a pointer to the main group of Context. -- Since: gtk+ 2.6 procedure Set_Main_Group (Self : Goption_Context; Group : GOption_Group); -- Sets a Glib.Option.GOption_Group as main group of the Context. This has -- the same effect as calling Glib.Option.Add_Group, the only difference is -- that the options in the main group are treated differently when -- generating `--help` output. -- Since: gtk+ 2.6 -- "group": the group to set as main group function Get_Summary (Self : Goption_Context) return UTF8_String; -- Returns the summary. See Glib.Option.Set_Summary. -- Since: gtk+ 2.12 procedure Set_Summary (Self : Goption_Context; Summary : UTF8_String := ""); -- Adds a string to be displayed in `--help` output before the list of -- options. This is typically a summary of the program functionality. -- Note that the summary is translated (see Glib.Option.Set_Translate_Func -- and Glib.Option.Set_Translation_Domain). -- Since: gtk+ 2.12 -- "summary": a string to be shown in `--help` output before the list of -- options, or null procedure Set_Translate_Func (Self : Goption_Context; Func : Gtranslate_Func; Destroy_Notify : Glib.G_Destroy_Notify_Address); -- Sets the function which is used to translate the contexts user-visible -- strings, for `--help` output. If Func is null, strings are not -- translated. -- Note that option groups have their own translation functions, this -- function only affects the Parameter_String (see Glib.Option.G_New), the -- summary (see Glib.Option.Set_Summary) and the description (see -- Glib.Option.Set_Description). -- If you are using gettext, you only need to set the translation domain, -- see Glib.Option.Set_Translation_Domain. -- Since: gtk+ 2.12 -- "func": the Gtranslate_Func, or null -- "destroy_notify": a function which gets called to free Data, or null generic type User_Data_Type (<>) is private; with procedure Destroy (Data : in out User_Data_Type) is null; package Set_Translate_Func_User_Data is type Gtranslate_Func is access function (Str : UTF8_String; Data : User_Data_Type) return UTF8_String; -- The type of functions which are used to translate user-visible strings, -- for output. -- "str": the untranslated string -- "data": user data specified when installing the function, e.g. in -- g_option_group_set_translate_func procedure Set_Translate_Func (Self : Glib.Option.Goption_Context; Func : Gtranslate_Func; Data : User_Data_Type; Destroy_Notify : Glib.G_Destroy_Notify_Address); -- Sets the function which is used to translate the contexts -- user-visible strings, for `--help` output. If Func is null, strings -- are not translated. -- Note that option groups have their own translation functions, this -- function only affects the Parameter_String (see Glib.Option.G_New), -- the summary (see Glib.Option.Set_Summary) and the description (see -- Glib.Option.Set_Description). -- If you are using gettext, you only need to set the translation -- domain, see Glib.Option.Set_Translation_Domain. -- Since: gtk+ 2.12 -- "func": the Gtranslate_Func, or null -- "data": user data to pass to Func, or null -- "destroy_notify": a function which gets called to free Data, or null end Set_Translate_Func_User_Data; procedure Set_Translation_Domain (Self : Goption_Context; Domain : UTF8_String); -- A convenience function to use gettext for translating user-visible -- strings. -- Since: gtk+ 2.12 -- "domain": the domain to use ---------------------- -- GtkAda additions -- ---------------------- Null_GOption_Entry : constant GOption_Entry; type Parse_Filter is access function (Param : String) return Boolean; -- Returns True if the parameter is to be passed from Command_Line to -- Goption_Context procedure Parse (Self : Goption_Context; Command_Line : not null access Glib.Application.Gapplication_Command_Line_Record'Class; Filter : Parse_Filter := null; Success : out Boolean; Error : out Glib.Error.GError); -- Parses the arguments given via Command_Line, removing from the arguments -- list all parsed switches. procedure Parse (Self : Goption_Context; Argv : access chars_ptr_array_access;-- Null-terminated Success : out Boolean; Error : out Glib.Error.GError); -- This version is suitable for use from Glib.Application.Local_Command_Line --------------- -- Functions -- --------------- function G_New (Parameter_String : UTF8_String := "") return Goption_Context; -- Creates a new option context. -- The Parameter_String can serve multiple purposes. It can be used to add -- descriptions for "rest" arguments, which are not parsed by the -- Glib.Option.Goption_Context, typically something like "FILES" or "FILE1 -- FILE2...". If you are using G_OPTION_REMAINING for collecting "rest" -- arguments, GLib handles this automatically by using the Arg_Description -- of the corresponding Glib.Option.GOption_Entry in the usage summary. -- Another usage is to give a short summary of the program functionality, -- like " - frob the strings", which will be displayed in the same line as -- the usage. For a longer description of the program functionality that -- should be displayed as a paragraph below the usage line, use -- Glib.Option.Set_Summary. -- Note that the Parameter_String is translated using the function set -- with Glib.Option.Set_Translate_Func, so it should normally be passed -- untranslated. -- Since: gtk+ 2.6 -- "parameter_string": a string which is displayed in the first line of -- `--help` output, after the usage summary `programname [OPTION...]` private Null_Goption_Context : constant Goption_Context := (Glib.C_Boxed with null record); Null_GOption_Entry : constant GOption_Entry := (Gtkada.Types.Null_Ptr, Gchar(ASCII.NUL), 0, G_Option_Arg_None, System.Null_Address, Gtkada.Types.Null_Ptr, Gtkada.Types.Null_Ptr); end Glib.Option; gtkada-24.0.0/src/generated/glib-poll.adb000066400000000000000000000040201446021174000201010ustar00rootroot00000000000000------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ pragma Style_Checks (Off); pragma Warnings (Off, "*is already use-visible*"); package body Glib.Poll is function From_Object_Free (B : access GPoll_FD) return GPoll_FD is Result : constant GPoll_FD := B.all; begin Glib.g_free (B.all'Address); return Result; end From_Object_Free; end Glib.Poll; gtkada-24.0.0/src/generated/glib-poll.ads000066400000000000000000000042131446021174000201260ustar00rootroot00000000000000------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ pragma Warnings (Off, "*is already use-visible*"); package Glib.Poll is type GPoll_FD is record Fd : Glib.Gint := 0; Events : Gushort; Revents : Gushort; end record; pragma Convention (C, GPoll_FD); function From_Object_Free (B : access GPoll_FD) return GPoll_FD; pragma Inline (From_Object_Free); -- Represents a file descriptor, which events to poll for, and which -- events occurred. end Glib.Poll; gtkada-24.0.0/src/generated/glib-simple_action.adb000066400000000000000000000377331446021174000220020ustar00rootroot00000000000000------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ pragma Style_Checks (Off); pragma Warnings (Off, "*is already use-visible*"); with Ada.Unchecked_Conversion; with Glib.Type_Conversion_Hooks; use Glib.Type_Conversion_Hooks; with Glib.Values; use Glib.Values; with Gtk.Arguments; use Gtk.Arguments; with Gtkada.Bindings; use Gtkada.Bindings; with Gtkada.Types; use Gtkada.Types; package body Glib.Simple_Action is package Type_Conversion_Gsimple_Action is new Glib.Type_Conversion_Hooks.Hook_Registrator (Get_Type'Access, Gsimple_Action_Record); pragma Unreferenced (Type_Conversion_Gsimple_Action); ----------- -- G_New -- ----------- procedure G_New (Self : out Gsimple_Action; Name : UTF8_String; Parameter_Type : Glib.Variant.Gvariant_Type) is begin Self := new Gsimple_Action_Record; Glib.Simple_Action.Initialize (Self, Name, Parameter_Type); end G_New; -------------------- -- G_New_Stateful -- -------------------- procedure G_New_Stateful (Self : out Gsimple_Action; Name : UTF8_String; Parameter_Type : Glib.Variant.Gvariant_Type; State : Glib.Variant.Gvariant) is begin Self := new Gsimple_Action_Record; Glib.Simple_Action.Initialize_Stateful (Self, Name, Parameter_Type, State); end G_New_Stateful; ------------------------ -- Gsimple_Action_New -- ------------------------ function Gsimple_Action_New (Name : UTF8_String; Parameter_Type : Glib.Variant.Gvariant_Type) return Gsimple_Action is Self : constant Gsimple_Action := new Gsimple_Action_Record; begin Glib.Simple_Action.Initialize (Self, Name, Parameter_Type); return Self; end Gsimple_Action_New; --------------------------------- -- Gsimple_Action_New_Stateful -- --------------------------------- function Gsimple_Action_New_Stateful (Name : UTF8_String; Parameter_Type : Glib.Variant.Gvariant_Type; State : Glib.Variant.Gvariant) return Gsimple_Action is Self : constant Gsimple_Action := new Gsimple_Action_Record; begin Glib.Simple_Action.Initialize_Stateful (Self, Name, Parameter_Type, State); return Self; end Gsimple_Action_New_Stateful; ---------------- -- Initialize -- ---------------- procedure Initialize (Self : not null access Gsimple_Action_Record'Class; Name : UTF8_String; Parameter_Type : Glib.Variant.Gvariant_Type) is function Internal (Name : Gtkada.Types.Chars_Ptr; Parameter_Type : Glib.Variant.Gvariant_Type) return System.Address; pragma Import (C, Internal, "g_simple_action_new"); Tmp_Name : Gtkada.Types.Chars_Ptr := New_String (Name); Tmp_Return : System.Address; begin if not Self.Is_Created then Tmp_Return := Internal (Tmp_Name, Parameter_Type); Free (Tmp_Name); Set_Object (Self, Tmp_Return); end if; end Initialize; ------------------------- -- Initialize_Stateful -- ------------------------- procedure Initialize_Stateful (Self : not null access Gsimple_Action_Record'Class; Name : UTF8_String; Parameter_Type : Glib.Variant.Gvariant_Type; State : Glib.Variant.Gvariant) is function Internal (Name : Gtkada.Types.Chars_Ptr; Parameter_Type : Glib.Variant.Gvariant_Type; State : System.Address) return System.Address; pragma Import (C, Internal, "g_simple_action_new_stateful"); Tmp_Name : Gtkada.Types.Chars_Ptr := New_String (Name); Tmp_Return : System.Address; begin if not Self.Is_Created then Tmp_Return := Internal (Tmp_Name, Parameter_Type, Get_Object (State)); Free (Tmp_Name); Set_Object (Self, Tmp_Return); end if; end Initialize_Stateful; ----------------- -- Set_Enabled -- ----------------- procedure Set_Enabled (Self : not null access Gsimple_Action_Record; Enabled : Boolean) is procedure Internal (Self : System.Address; Enabled : Glib.Gboolean); pragma Import (C, Internal, "g_simple_action_set_enabled"); begin Internal (Get_Object (Self), Boolean'Pos (Enabled)); end Set_Enabled; --------------- -- Set_State -- --------------- procedure Set_State (Self : not null access Gsimple_Action_Record; Value : Glib.Variant.Gvariant) is procedure Internal (Self : System.Address; Value : System.Address); pragma Import (C, Internal, "g_simple_action_set_state"); begin Internal (Get_Object (Self), Get_Object (Value)); end Set_State; -------------------- -- Set_State_Hint -- -------------------- procedure Set_State_Hint (Self : not null access Gsimple_Action_Record; State_Hint : Glib.Variant.Gvariant) is procedure Internal (Self : System.Address; State_Hint : System.Address); pragma Import (C, Internal, "g_simple_action_set_state_hint"); begin Internal (Get_Object (Self), Get_Object (State_Hint)); end Set_State_Hint; -------------- -- Activate -- -------------- procedure Activate (Self : not null access Gsimple_Action_Record; Parameter : Glib.Variant.Gvariant) is procedure Internal (Self : System.Address; Parameter : System.Address); pragma Import (C, Internal, "g_action_activate"); begin Internal (Get_Object (Self), Get_Object (Parameter)); end Activate; ------------------ -- Change_State -- ------------------ procedure Change_State (Self : not null access Gsimple_Action_Record; Value : Glib.Variant.Gvariant) is procedure Internal (Self : System.Address; Value : System.Address); pragma Import (C, Internal, "g_action_change_state"); begin Internal (Get_Object (Self), Get_Object (Value)); end Change_State; ----------------- -- Get_Enabled -- ----------------- function Get_Enabled (Self : not null access Gsimple_Action_Record) return Boolean is function Internal (Self : System.Address) return Glib.Gboolean; pragma Import (C, Internal, "g_action_get_enabled"); begin return Internal (Get_Object (Self)) /= 0; end Get_Enabled; -------------- -- Get_Name -- -------------- function Get_Name (Self : not null access Gsimple_Action_Record) return UTF8_String is function Internal (Self : System.Address) return Gtkada.Types.Chars_Ptr; pragma Import (C, Internal, "g_action_get_name"); begin return Gtkada.Bindings.Value_Allowing_Null (Internal (Get_Object (Self))); end Get_Name; ------------------------ -- Get_Parameter_Type -- ------------------------ function Get_Parameter_Type (Self : not null access Gsimple_Action_Record) return Glib.Variant.Gvariant_Type is function Internal (Self : System.Address) return Glib.Variant.Gvariant_Type; pragma Import (C, Internal, "g_action_get_parameter_type"); begin return Internal (Get_Object (Self)); end Get_Parameter_Type; --------------- -- Get_State -- --------------- function Get_State (Self : not null access Gsimple_Action_Record) return Glib.Variant.Gvariant is function Internal (Self : System.Address) return System.Address; pragma Import (C, Internal, "g_action_get_state"); begin return From_Object (Internal (Get_Object (Self))); end Get_State; -------------------- -- Get_State_Hint -- -------------------- function Get_State_Hint (Self : not null access Gsimple_Action_Record) return Glib.Variant.Gvariant is function Internal (Self : System.Address) return System.Address; pragma Import (C, Internal, "g_action_get_state_hint"); begin return From_Object (Internal (Get_Object (Self))); end Get_State_Hint; -------------------- -- Get_State_Type -- -------------------- function Get_State_Type (Self : not null access Gsimple_Action_Record) return Glib.Variant.Gvariant_Type is function Internal (Self : System.Address) return Glib.Variant.Gvariant_Type; pragma Import (C, Internal, "g_action_get_state_type"); begin return Internal (Get_Object (Self)); end Get_State_Type; use type System.Address; function Cb_To_Address is new Ada.Unchecked_Conversion (Cb_Gsimple_Action_Gvariant_Void, System.Address); function Address_To_Cb is new Ada.Unchecked_Conversion (System.Address, Cb_Gsimple_Action_Gvariant_Void); function Cb_To_Address is new Ada.Unchecked_Conversion (Cb_GObject_Gvariant_Void, System.Address); function Address_To_Cb is new Ada.Unchecked_Conversion (System.Address, Cb_GObject_Gvariant_Void); procedure Connect (Object : access Gsimple_Action_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_Gsimple_Action_Gvariant_Void; After : Boolean); procedure Connect_Slot (Object : access Gsimple_Action_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_GObject_Gvariant_Void; After : Boolean; Slot : access Glib.Object.GObject_Record'Class := null); procedure Marsh_GObject_Gvariant_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address); pragma Convention (C, Marsh_GObject_Gvariant_Void); procedure Marsh_Gsimple_Action_Gvariant_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address); pragma Convention (C, Marsh_Gsimple_Action_Gvariant_Void); ------------- -- Connect -- ------------- procedure Connect (Object : access Gsimple_Action_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_Gsimple_Action_Gvariant_Void; After : Boolean) is begin Unchecked_Do_Signal_Connect (Object => Object, C_Name => C_Name, Marshaller => Marsh_Gsimple_Action_Gvariant_Void'Access, Handler => Cb_To_Address (Handler),-- Set in the closure After => After); end Connect; ------------------ -- Connect_Slot -- ------------------ procedure Connect_Slot (Object : access Gsimple_Action_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_GObject_Gvariant_Void; After : Boolean; Slot : access Glib.Object.GObject_Record'Class := null) is begin Unchecked_Do_Signal_Connect (Object => Object, C_Name => C_Name, Marshaller => Marsh_GObject_Gvariant_Void'Access, Handler => Cb_To_Address (Handler),-- Set in the closure Slot_Object => Slot, After => After); end Connect_Slot; --------------------------------- -- Marsh_GObject_Gvariant_Void -- --------------------------------- procedure Marsh_GObject_Gvariant_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address) is pragma Unreferenced (Return_Value, N_Params, Invocation_Hint, User_Data); H : constant Cb_GObject_Gvariant_Void := Address_To_Cb (Get_Callback (Closure)); Obj : constant Glib.Object.GObject := Glib.Object.Convert (Get_Data (Closure)); begin H (Obj, Glib.Variant.From_Object (Unchecked_To_Address (Params, 1))); exception when E : others => Process_Exception (E); end Marsh_GObject_Gvariant_Void; ---------------------------------------- -- Marsh_Gsimple_Action_Gvariant_Void -- ---------------------------------------- procedure Marsh_Gsimple_Action_Gvariant_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address) is pragma Unreferenced (Return_Value, N_Params, Invocation_Hint, User_Data); H : constant Cb_Gsimple_Action_Gvariant_Void := Address_To_Cb (Get_Callback (Closure)); Obj : constant Gsimple_Action := Gsimple_Action (Unchecked_To_Object (Params, 0)); begin H (Obj, Glib.Variant.From_Object (Unchecked_To_Address (Params, 1))); exception when E : others => Process_Exception (E); end Marsh_Gsimple_Action_Gvariant_Void; ----------------- -- On_Activate -- ----------------- procedure On_Activate (Self : not null access Gsimple_Action_Record; Call : Cb_Gsimple_Action_Gvariant_Void; After : Boolean := False) is begin Connect (Self, "activate" & ASCII.NUL, Call, After); end On_Activate; ----------------- -- On_Activate -- ----------------- procedure On_Activate (Self : not null access Gsimple_Action_Record; Call : Cb_GObject_Gvariant_Void; Slot : not null access Glib.Object.GObject_Record'Class; After : Boolean := False) is begin Connect_Slot (Self, "activate" & ASCII.NUL, Call, After, Slot); end On_Activate; --------------------- -- On_Change_State -- --------------------- procedure On_Change_State (Self : not null access Gsimple_Action_Record; Call : Cb_Gsimple_Action_Gvariant_Void; After : Boolean := False) is begin Connect (Self, "change-state" & ASCII.NUL, Call, After); end On_Change_State; --------------------- -- On_Change_State -- --------------------- procedure On_Change_State (Self : not null access Gsimple_Action_Record; Call : Cb_GObject_Gvariant_Void; Slot : not null access Glib.Object.GObject_Record'Class; After : Boolean := False) is begin Connect_Slot (Self, "change-state" & ASCII.NUL, Call, After, Slot); end On_Change_State; end Glib.Simple_Action; gtkada-24.0.0/src/generated/glib-simple_action.ads000066400000000000000000000351751446021174000220210ustar00rootroot00000000000000------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ -- -- A Glib.Simple_Action.Gsimple_Action is the obvious simple implementation -- of the Glib.Action.Gaction interface. This is the easiest way to create an -- action for purposes of adding it to a -- Glib.Simple_Action_Group.Gsimple_Action_Group. -- -- See also Gtk.Action.Gtk_Action. -- -- pragma Warnings (Off, "*is already use-visible*"); with Glib.Action; use Glib.Action; with Glib.Object; use Glib.Object; with Glib.Properties; use Glib.Properties; with Glib.Types; use Glib.Types; with Glib.Variant; use Glib.Variant; package Glib.Simple_Action is type Gsimple_Action_Record is new GObject_Record with null record; type Gsimple_Action is access all Gsimple_Action_Record'Class; ------------------ -- Constructors -- ------------------ procedure G_New (Self : out Gsimple_Action; Name : UTF8_String; Parameter_Type : Glib.Variant.Gvariant_Type); -- Creates a new action. -- The created action is stateless. See Glib.Simple_Action.G_New_Stateful -- to create an action that has state. -- Since: gtk+ 2.28 -- "name": the name of the action -- "parameter_type": the type of parameter that will be passed to handlers -- for the Glib.Simple_Action.Gsimple_Action::activate signal, or null for -- no parameter procedure Initialize (Self : not null access Gsimple_Action_Record'Class; Name : UTF8_String; Parameter_Type : Glib.Variant.Gvariant_Type); -- Creates a new action. -- The created action is stateless. See Glib.Simple_Action.G_New_Stateful -- to create an action that has state. -- Since: gtk+ 2.28 -- Initialize does nothing if the object was already created with another -- call to Initialize* or G_New. -- "name": the name of the action -- "parameter_type": the type of parameter that will be passed to handlers -- for the Glib.Simple_Action.Gsimple_Action::activate signal, or null for -- no parameter function Gsimple_Action_New (Name : UTF8_String; Parameter_Type : Glib.Variant.Gvariant_Type) return Gsimple_Action; -- Creates a new action. -- The created action is stateless. See Glib.Simple_Action.G_New_Stateful -- to create an action that has state. -- Since: gtk+ 2.28 -- "name": the name of the action -- "parameter_type": the type of parameter that will be passed to handlers -- for the Glib.Simple_Action.Gsimple_Action::activate signal, or null for -- no parameter procedure G_New_Stateful (Self : out Gsimple_Action; Name : UTF8_String; Parameter_Type : Glib.Variant.Gvariant_Type; State : Glib.Variant.Gvariant); -- Creates a new stateful action. -- All future state values must have the same Glib.Variant.Gvariant_Type -- as the initial State. -- If the State Glib.Variant.Gvariant is floating, it is consumed. -- Since: gtk+ 2.28 -- "name": the name of the action -- "parameter_type": the type of the parameter that will be passed to -- handlers for the Glib.Simple_Action.Gsimple_Action::activate signal, or -- null for no parameter -- "state": the initial state of the action procedure Initialize_Stateful (Self : not null access Gsimple_Action_Record'Class; Name : UTF8_String; Parameter_Type : Glib.Variant.Gvariant_Type; State : Glib.Variant.Gvariant); -- Creates a new stateful action. -- All future state values must have the same Glib.Variant.Gvariant_Type -- as the initial State. -- If the State Glib.Variant.Gvariant is floating, it is consumed. -- Since: gtk+ 2.28 -- Initialize_Stateful does nothing if the object was already created with -- another call to Initialize* or G_New. -- "name": the name of the action -- "parameter_type": the type of the parameter that will be passed to -- handlers for the Glib.Simple_Action.Gsimple_Action::activate signal, or -- null for no parameter -- "state": the initial state of the action function Gsimple_Action_New_Stateful (Name : UTF8_String; Parameter_Type : Glib.Variant.Gvariant_Type; State : Glib.Variant.Gvariant) return Gsimple_Action; -- Creates a new stateful action. -- All future state values must have the same Glib.Variant.Gvariant_Type -- as the initial State. -- If the State Glib.Variant.Gvariant is floating, it is consumed. -- Since: gtk+ 2.28 -- "name": the name of the action -- "parameter_type": the type of the parameter that will be passed to -- handlers for the Glib.Simple_Action.Gsimple_Action::activate signal, or -- null for no parameter -- "state": the initial state of the action function Get_Type return Glib.GType; pragma Import (C, Get_Type, "g_simple_action_get_type"); ------------- -- Methods -- ------------- procedure Set_Enabled (Self : not null access Gsimple_Action_Record; Enabled : Boolean); -- Sets the action as enabled or not. -- An action must be enabled in order to be activated or in order to have -- its state changed from outside callers. -- This should only be called by the implementor of the action. Users of -- the action should not attempt to modify its enabled flag. -- Since: gtk+ 2.28 -- "enabled": whether the action is enabled procedure Set_State (Self : not null access Gsimple_Action_Record; Value : Glib.Variant.Gvariant); -- Sets the state of the action. -- This directly updates the 'state' property to the given value. -- This should only be called by the implementor of the action. Users of -- the action should not attempt to directly modify the 'state' property. -- Instead, they should call Glib.Action.Change_State to request the -- change. -- If the Value GVariant is floating, it is consumed. -- Since: gtk+ 2.30 -- "value": the new Glib.Variant.Gvariant for the state procedure Set_State_Hint (Self : not null access Gsimple_Action_Record; State_Hint : Glib.Variant.Gvariant); -- Sets the state hint for the action. -- See Glib.Action.Get_State_Hint for more information about action state -- hints. -- Since: gtk+ 2.44 -- "state_hint": a Glib.Variant.Gvariant representing the state hint --------------------------------------------- -- Inherited subprograms (from interfaces) -- --------------------------------------------- procedure Activate (Self : not null access Gsimple_Action_Record; Parameter : Glib.Variant.Gvariant); procedure Change_State (Self : not null access Gsimple_Action_Record; Value : Glib.Variant.Gvariant); function Get_Enabled (Self : not null access Gsimple_Action_Record) return Boolean; function Get_Name (Self : not null access Gsimple_Action_Record) return UTF8_String; function Get_Parameter_Type (Self : not null access Gsimple_Action_Record) return Glib.Variant.Gvariant_Type; function Get_State (Self : not null access Gsimple_Action_Record) return Glib.Variant.Gvariant; function Get_State_Hint (Self : not null access Gsimple_Action_Record) return Glib.Variant.Gvariant; function Get_State_Type (Self : not null access Gsimple_Action_Record) return Glib.Variant.Gvariant_Type; ---------------- -- Properties -- ---------------- -- The following properties are defined for this widget. See -- Glib.Properties for more information on properties) Enabled_Property : constant Glib.Properties.Property_Boolean; -- If Action is currently enabled. -- -- If the action is disabled then calls to Glib.Action.Activate and -- Glib.Action.Change_State have no effect. Name_Property : constant Glib.Properties.Property_String; -- The name of the action. This is mostly meaningful for identifying the -- action once it has been added to a -- Glib.Simple_Action_Group.Gsimple_Action_Group. Parameter_Type_Property : constant Glib.Properties.Property_Boxed; -- Type: GLib.Variant_Type -- The type of the parameter that must be given when activating the -- action. State_Property : constant Glib.Properties.Property_Object; -- Type: Glib.Variant.Gvariant -- The state of the action, or null if the action is stateless. State_Type_Property : constant Glib.Properties.Property_Boxed; -- Type: GLib.Variant_Type -- The Glib.Variant.Gvariant_Type of the state that the action has, or -- null if the action is stateless. ------------- -- Signals -- ------------- type Cb_Gsimple_Action_Gvariant_Void is not null access procedure (Self : access Gsimple_Action_Record'Class; Parameter : Glib.Variant.Gvariant); type Cb_GObject_Gvariant_Void is not null access procedure (Self : access Glib.Object.GObject_Record'Class; Parameter : Glib.Variant.Gvariant); Signal_Activate : constant Glib.Signal_Name := "activate"; procedure On_Activate (Self : not null access Gsimple_Action_Record; Call : Cb_Gsimple_Action_Gvariant_Void; After : Boolean := False); procedure On_Activate (Self : not null access Gsimple_Action_Record; Call : Cb_GObject_Gvariant_Void; Slot : not null access Glib.Object.GObject_Record'Class; After : Boolean := False); -- Indicates that the action was just activated. -- -- Parameter will always be of the expected type, i.e. the parameter type -- specified when the action was created. If an incorrect type is given -- when activating the action, this signal is not emitted. -- -- Since GLib 2.40, if no handler is connected to this signal then the -- default behaviour for boolean-stated actions with a null parameter type -- is to toggle them via the -- Glib.Simple_Action.Gsimple_Action::change-state signal. For stateful -- actions where the state type is equal to the parameter type, the default -- is to forward them directly to -- Glib.Simple_Action.Gsimple_Action::change-state. This should allow -- almost all users of Glib.Simple_Action.Gsimple_Action to connect only -- one handler or the other. Signal_Change_State : constant Glib.Signal_Name := "change-state"; procedure On_Change_State (Self : not null access Gsimple_Action_Record; Call : Cb_Gsimple_Action_Gvariant_Void; After : Boolean := False); procedure On_Change_State (Self : not null access Gsimple_Action_Record; Call : Cb_GObject_Gvariant_Void; Slot : not null access Glib.Object.GObject_Record'Class; After : Boolean := False); -- Indicates that the action just received a request to change its state. -- -- Value will always be of the correct state type, i.e. the type of the -- initial state passed to Glib.Simple_Action.G_New_Stateful. If an -- incorrect type is given when requesting to change the state, this signal -- is not emitted. -- -- If no handler is connected to this signal then the default behaviour is -- to call Glib.Simple_Action.Set_State to set the state to the requested -- value. If you connect a signal handler then no default action is taken. -- If the state should change then you must call -- Glib.Simple_Action.Set_State from the handler. -- -- An example of a 'change-state' handler: |[ static -- void change_volume_state (GSimpleAction *action, GVariant *value, -- gpointer user_data) { gint requested; -- -- requested = g_variant_get_int32 (value); -- -- // Volume only goes from 0 to 10 if (0 <= requested && requested <= 10) -- g_simple_action_set_state (action, value); } ]| -- -- The handler need not set the state to the requested value. It could set -- it to any value at all, or take some other action. ---------------- -- Interfaces -- ---------------- -- This class implements several interfaces. See Glib.Types -- -- - "Action" package Implements_Gaction is new Glib.Types.Implements (Glib.Action.Gaction, Gsimple_Action_Record, Gsimple_Action); function "+" (Widget : access Gsimple_Action_Record'Class) return Glib.Action.Gaction renames Implements_Gaction.To_Interface; function "-" (Interf : Glib.Action.Gaction) return Gsimple_Action renames Implements_Gaction.To_Object; private State_Type_Property : constant Glib.Properties.Property_Boxed := Glib.Properties.Build ("state-type"); State_Property : constant Glib.Properties.Property_Object := Glib.Properties.Build ("state"); Parameter_Type_Property : constant Glib.Properties.Property_Boxed := Glib.Properties.Build ("parameter-type"); Name_Property : constant Glib.Properties.Property_String := Glib.Properties.Build ("name"); Enabled_Property : constant Glib.Properties.Property_Boolean := Glib.Properties.Build ("enabled"); end Glib.Simple_Action; gtkada-24.0.0/src/generated/glib-simple_action_group.adb000066400000000000000000000454571446021174000232200ustar00rootroot00000000000000------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ pragma Style_Checks (Off); pragma Warnings (Off, "*is already use-visible*"); with Glib.Type_Conversion_Hooks; use Glib.Type_Conversion_Hooks; pragma Warnings(Off); -- might be unused with Gtkada.Bindings; use Gtkada.Bindings; with Gtkada.Types; use Gtkada.Types; pragma Warnings(On); package body Glib.Simple_Action_Group is package Type_Conversion_Gsimple_Action_Group is new Glib.Type_Conversion_Hooks.Hook_Registrator (Get_Type'Access, Gsimple_Action_Group_Record); pragma Unreferenced (Type_Conversion_Gsimple_Action_Group); ----------- -- G_New -- ----------- procedure G_New (Self : out Gsimple_Action_Group) is begin Self := new Gsimple_Action_Group_Record; Glib.Simple_Action_Group.Initialize (Self); end G_New; ------------------------------ -- Gsimple_Action_Group_New -- ------------------------------ function Gsimple_Action_Group_New return Gsimple_Action_Group is Self : constant Gsimple_Action_Group := new Gsimple_Action_Group_Record; begin Glib.Simple_Action_Group.Initialize (Self); return Self; end Gsimple_Action_Group_New; ---------------- -- Initialize -- ---------------- procedure Initialize (Self : not null access Gsimple_Action_Group_Record'Class) is function Internal return System.Address; pragma Import (C, Internal, "g_simple_action_group_new"); begin if not Self.Is_Created then Set_Object (Self, Internal); end if; end Initialize; ----------------- -- Add_Entries -- ----------------- procedure Add_Entries (Self : not null access Gsimple_Action_Group_Record; Entries : Glib.Action_Map.GAction_Entry_Array; User_Data : System.Address := System.Null_Address) is procedure Internal (Self : System.Address; Entries : Glib.Action_Map.GAction_Entry_Array; N_Entries : Glib.Gint; User_Data : System.Address); pragma Import (C, Internal, "g_simple_action_group_add_entries"); begin Internal (Get_Object (Self), Entries, Entries'Length, User_Data); end Add_Entries; ------------ -- Insert -- ------------ procedure Insert (Self : not null access Gsimple_Action_Group_Record; Action : Glib.Action.Gaction) is procedure Internal (Self : System.Address; Action : Glib.Action.Gaction); pragma Import (C, Internal, "g_simple_action_group_insert"); begin Internal (Get_Object (Self), Action); end Insert; ------------ -- Lookup -- ------------ function Lookup (Self : not null access Gsimple_Action_Group_Record; Action_Name : UTF8_String) return Glib.Action.Gaction is function Internal (Self : System.Address; Action_Name : Gtkada.Types.Chars_Ptr) return Glib.Action.Gaction; pragma Import (C, Internal, "g_simple_action_group_lookup"); Tmp_Action_Name : Gtkada.Types.Chars_Ptr := New_String (Action_Name); Tmp_Return : Glib.Action.Gaction; begin Tmp_Return := Internal (Get_Object (Self), Tmp_Action_Name); Free (Tmp_Action_Name); return Tmp_Return; end Lookup; ------------ -- Remove -- ------------ procedure Remove (Self : not null access Gsimple_Action_Group_Record; Action_Name : UTF8_String) is procedure Internal (Self : System.Address; Action_Name : Gtkada.Types.Chars_Ptr); pragma Import (C, Internal, "g_simple_action_group_remove"); Tmp_Action_Name : Gtkada.Types.Chars_Ptr := New_String (Action_Name); begin Internal (Get_Object (Self), Tmp_Action_Name); Free (Tmp_Action_Name); end Remove; ------------------ -- Action_Added -- ------------------ procedure Action_Added (Self : not null access Gsimple_Action_Group_Record; Action_Name : UTF8_String) is procedure Internal (Self : System.Address; Action_Name : Gtkada.Types.Chars_Ptr); pragma Import (C, Internal, "g_action_group_action_added"); Tmp_Action_Name : Gtkada.Types.Chars_Ptr := New_String (Action_Name); begin Internal (Get_Object (Self), Tmp_Action_Name); Free (Tmp_Action_Name); end Action_Added; ---------------------------- -- Action_Enabled_Changed -- ---------------------------- procedure Action_Enabled_Changed (Self : not null access Gsimple_Action_Group_Record; Action_Name : UTF8_String; Enabled : Boolean) is procedure Internal (Self : System.Address; Action_Name : Gtkada.Types.Chars_Ptr; Enabled : Glib.Gboolean); pragma Import (C, Internal, "g_action_group_action_enabled_changed"); Tmp_Action_Name : Gtkada.Types.Chars_Ptr := New_String (Action_Name); begin Internal (Get_Object (Self), Tmp_Action_Name, Boolean'Pos (Enabled)); Free (Tmp_Action_Name); end Action_Enabled_Changed; -------------------- -- Action_Removed -- -------------------- procedure Action_Removed (Self : not null access Gsimple_Action_Group_Record; Action_Name : UTF8_String) is procedure Internal (Self : System.Address; Action_Name : Gtkada.Types.Chars_Ptr); pragma Import (C, Internal, "g_action_group_action_removed"); Tmp_Action_Name : Gtkada.Types.Chars_Ptr := New_String (Action_Name); begin Internal (Get_Object (Self), Tmp_Action_Name); Free (Tmp_Action_Name); end Action_Removed; -------------------------- -- Action_State_Changed -- -------------------------- procedure Action_State_Changed (Self : not null access Gsimple_Action_Group_Record; Action_Name : UTF8_String; State : Glib.Variant.Gvariant) is procedure Internal (Self : System.Address; Action_Name : Gtkada.Types.Chars_Ptr; State : System.Address); pragma Import (C, Internal, "g_action_group_action_state_changed"); Tmp_Action_Name : Gtkada.Types.Chars_Ptr := New_String (Action_Name); begin Internal (Get_Object (Self), Tmp_Action_Name, Get_Object (State)); Free (Tmp_Action_Name); end Action_State_Changed; --------------------- -- Activate_Action -- --------------------- procedure Activate_Action (Self : not null access Gsimple_Action_Group_Record; Action_Name : UTF8_String; Parameter : Glib.Variant.Gvariant) is procedure Internal (Self : System.Address; Action_Name : Gtkada.Types.Chars_Ptr; Parameter : System.Address); pragma Import (C, Internal, "g_action_group_activate_action"); Tmp_Action_Name : Gtkada.Types.Chars_Ptr := New_String (Action_Name); begin Internal (Get_Object (Self), Tmp_Action_Name, Get_Object (Parameter)); Free (Tmp_Action_Name); end Activate_Action; ---------------- -- Add_Action -- ---------------- procedure Add_Action (Self : not null access Gsimple_Action_Group_Record; Action : Glib.Action.Gaction) is procedure Internal (Self : System.Address; Action : Glib.Action.Gaction); pragma Import (C, Internal, "g_action_map_add_action"); begin Internal (Get_Object (Self), Action); end Add_Action; ------------------------ -- Add_Action_Entries -- ------------------------ procedure Add_Action_Entries (Self : not null access Gsimple_Action_Group_Record; Entries : GAction_Entry_Array; User_Data : System.Address := System.Null_Address) is procedure Internal (Self : System.Address; Entries : GAction_Entry_Array; N_Entries : Glib.Gint; User_Data : System.Address); pragma Import (C, Internal, "g_action_map_add_action_entries"); begin Internal (Get_Object (Self), Entries, Entries'Length, User_Data); end Add_Action_Entries; ------------------------- -- Change_Action_State -- ------------------------- procedure Change_Action_State (Self : not null access Gsimple_Action_Group_Record; Action_Name : UTF8_String; Value : Glib.Variant.Gvariant) is procedure Internal (Self : System.Address; Action_Name : Gtkada.Types.Chars_Ptr; Value : System.Address); pragma Import (C, Internal, "g_action_group_change_action_state"); Tmp_Action_Name : Gtkada.Types.Chars_Ptr := New_String (Action_Name); begin Internal (Get_Object (Self), Tmp_Action_Name, Get_Object (Value)); Free (Tmp_Action_Name); end Change_Action_State; ------------------------ -- Get_Action_Enabled -- ------------------------ function Get_Action_Enabled (Self : not null access Gsimple_Action_Group_Record; Action_Name : UTF8_String) return Boolean is function Internal (Self : System.Address; Action_Name : Gtkada.Types.Chars_Ptr) return Glib.Gboolean; pragma Import (C, Internal, "g_action_group_get_action_enabled"); Tmp_Action_Name : Gtkada.Types.Chars_Ptr := New_String (Action_Name); Tmp_Return : Glib.Gboolean; begin Tmp_Return := Internal (Get_Object (Self), Tmp_Action_Name); Free (Tmp_Action_Name); return Tmp_Return /= 0; end Get_Action_Enabled; ------------------------------- -- Get_Action_Parameter_Type -- ------------------------------- function Get_Action_Parameter_Type (Self : not null access Gsimple_Action_Group_Record; Action_Name : UTF8_String) return Glib.Variant.Gvariant_Type is function Internal (Self : System.Address; Action_Name : Gtkada.Types.Chars_Ptr) return Glib.Variant.Gvariant_Type; pragma Import (C, Internal, "g_action_group_get_action_parameter_type"); Tmp_Action_Name : Gtkada.Types.Chars_Ptr := New_String (Action_Name); Tmp_Return : Glib.Variant.Gvariant_Type; begin Tmp_Return := Internal (Get_Object (Self), Tmp_Action_Name); Free (Tmp_Action_Name); return Tmp_Return; end Get_Action_Parameter_Type; ---------------------- -- Get_Action_State -- ---------------------- function Get_Action_State (Self : not null access Gsimple_Action_Group_Record; Action_Name : UTF8_String) return Glib.Variant.Gvariant is function Internal (Self : System.Address; Action_Name : Gtkada.Types.Chars_Ptr) return System.Address; pragma Import (C, Internal, "g_action_group_get_action_state"); Tmp_Action_Name : Gtkada.Types.Chars_Ptr := New_String (Action_Name); Tmp_Return : System.Address; begin Tmp_Return := Internal (Get_Object (Self), Tmp_Action_Name); Free (Tmp_Action_Name); return From_Object (Tmp_Return); end Get_Action_State; --------------------------- -- Get_Action_State_Hint -- --------------------------- function Get_Action_State_Hint (Self : not null access Gsimple_Action_Group_Record; Action_Name : UTF8_String) return Glib.Variant.Gvariant is function Internal (Self : System.Address; Action_Name : Gtkada.Types.Chars_Ptr) return System.Address; pragma Import (C, Internal, "g_action_group_get_action_state_hint"); Tmp_Action_Name : Gtkada.Types.Chars_Ptr := New_String (Action_Name); Tmp_Return : System.Address; begin Tmp_Return := Internal (Get_Object (Self), Tmp_Action_Name); Free (Tmp_Action_Name); return From_Object (Tmp_Return); end Get_Action_State_Hint; --------------------------- -- Get_Action_State_Type -- --------------------------- function Get_Action_State_Type (Self : not null access Gsimple_Action_Group_Record; Action_Name : UTF8_String) return Glib.Variant.Gvariant_Type is function Internal (Self : System.Address; Action_Name : Gtkada.Types.Chars_Ptr) return Glib.Variant.Gvariant_Type; pragma Import (C, Internal, "g_action_group_get_action_state_type"); Tmp_Action_Name : Gtkada.Types.Chars_Ptr := New_String (Action_Name); Tmp_Return : Glib.Variant.Gvariant_Type; begin Tmp_Return := Internal (Get_Object (Self), Tmp_Action_Name); Free (Tmp_Action_Name); return Tmp_Return; end Get_Action_State_Type; ---------------- -- Has_Action -- ---------------- function Has_Action (Self : not null access Gsimple_Action_Group_Record; Action_Name : UTF8_String) return Boolean is function Internal (Self : System.Address; Action_Name : Gtkada.Types.Chars_Ptr) return Glib.Gboolean; pragma Import (C, Internal, "g_action_group_has_action"); Tmp_Action_Name : Gtkada.Types.Chars_Ptr := New_String (Action_Name); Tmp_Return : Glib.Gboolean; begin Tmp_Return := Internal (Get_Object (Self), Tmp_Action_Name); Free (Tmp_Action_Name); return Tmp_Return /= 0; end Has_Action; ------------------ -- List_Actions -- ------------------ function List_Actions (Self : not null access Gsimple_Action_Group_Record) return GNAT.Strings.String_List is function Internal (Self : System.Address) return chars_ptr_array_access; pragma Import (C, Internal, "g_action_group_list_actions"); begin return To_String_List_And_Free (Internal (Get_Object (Self))); end List_Actions; ------------------- -- Lookup_Action -- ------------------- function Lookup_Action (Self : not null access Gsimple_Action_Group_Record; Action_Name : UTF8_String) return Glib.Action.Gaction is function Internal (Self : System.Address; Action_Name : Gtkada.Types.Chars_Ptr) return Glib.Action.Gaction; pragma Import (C, Internal, "g_action_map_lookup_action"); Tmp_Action_Name : Gtkada.Types.Chars_Ptr := New_String (Action_Name); Tmp_Return : Glib.Action.Gaction; begin Tmp_Return := Internal (Get_Object (Self), Tmp_Action_Name); Free (Tmp_Action_Name); return Tmp_Return; end Lookup_Action; ------------------ -- Query_Action -- ------------------ function Query_Action (Self : not null access Gsimple_Action_Group_Record; Action_Name : UTF8_String; Enabled : access Boolean; Parameter_Type : access Glib.Variant.Gvariant_Type; State_Type : access Glib.Variant.Gvariant_Type; State_Hint : access Glib.Variant.Gvariant; State : access Glib.Variant.Gvariant) return Boolean is function Internal (Self : System.Address; Action_Name : Gtkada.Types.Chars_Ptr; Acc_Enabled : access Glib.Gboolean; Acc_Parameter_Type : access Glib.Variant.Gvariant_Type; Acc_State_Type : access Glib.Variant.Gvariant_Type; Acc_State_Hint : access System.Address; Acc_State : access System.Address) return Glib.Gboolean; pragma Import (C, Internal, "g_action_group_query_action"); Acc_Enabled : aliased Boolean; Acc_Parameter_Type : aliased Glib.Variant.Gvariant_Type; Acc_State_Type : aliased Glib.Variant.Gvariant_Type; Acc_State_Hint : aliased Glib.Variant.Gvariant; Acc_State : aliased Glib.Variant.Gvariant; Tmp_Action_Name : Gtkada.Types.Chars_Ptr := New_String (Action_Name); Tmp_Acc_Enabled : aliased Glib.Gboolean; Tmp_Acc_State_Hint : aliased System.Address; Tmp_Acc_State : aliased System.Address; Tmp_Return : Glib.Gboolean; begin Tmp_Return := Internal (Get_Object (Self), Tmp_Action_Name, Tmp_Acc_Enabled'Access, Acc_Parameter_Type'Access, Acc_State_Type'Access, Tmp_Acc_State_Hint'Access, Tmp_Acc_State'Access); Acc_State := From_Object (Tmp_Acc_State); Acc_State_Hint := From_Object (Tmp_Acc_State_Hint); Acc_Enabled := Tmp_Acc_Enabled /= 0; Free (Tmp_Action_Name); Enabled.all := Acc_Enabled; if Parameter_Type /= null then Parameter_Type.all := Acc_Parameter_Type; end if; if State_Type /= null then State_Type.all := Acc_State_Type; end if; if State_Hint /= null then State_Hint.all := Acc_State_Hint; end if; if State /= null then State.all := Acc_State; end if; return Tmp_Return /= 0; end Query_Action; ------------------- -- Remove_Action -- ------------------- procedure Remove_Action (Self : not null access Gsimple_Action_Group_Record; Action_Name : UTF8_String) is procedure Internal (Self : System.Address; Action_Name : Gtkada.Types.Chars_Ptr); pragma Import (C, Internal, "g_action_map_remove_action"); Tmp_Action_Name : Gtkada.Types.Chars_Ptr := New_String (Action_Name); begin Internal (Get_Object (Self), Tmp_Action_Name); Free (Tmp_Action_Name); end Remove_Action; end Glib.Simple_Action_Group; gtkada-24.0.0/src/generated/glib-simple_action_group.ads000066400000000000000000000225561446021174000232340ustar00rootroot00000000000000------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ -- -- Glib.Simple_Action_Group.Gsimple_Action_Group is a hash table filled with -- Glib.Action.Gaction objects, implementing the -- Glib.Action_Group.Gaction_Group and Glib.Action_Map.Gaction_Map interfaces. -- -- pragma Warnings (Off, "*is already use-visible*"); with GNAT.Strings; use GNAT.Strings; with Glib.Action; use Glib.Action; with Glib.Action_Group; use Glib.Action_Group; with Glib.Action_Map; use Glib.Action_Map; with Glib.Object; use Glib.Object; with Glib.Types; use Glib.Types; with Glib.Variant; use Glib.Variant; package Glib.Simple_Action_Group is type Gsimple_Action_Group_Record is new GObject_Record with null record; type Gsimple_Action_Group is access all Gsimple_Action_Group_Record'Class; ------------------ -- Constructors -- ------------------ procedure G_New (Self : out Gsimple_Action_Group); -- Creates a new, empty, Glib.Simple_Action_Group.Gsimple_Action_Group. -- Since: gtk+ 2.28 procedure Initialize (Self : not null access Gsimple_Action_Group_Record'Class); -- Creates a new, empty, Glib.Simple_Action_Group.Gsimple_Action_Group. -- Since: gtk+ 2.28 -- Initialize does nothing if the object was already created with another -- call to Initialize* or G_New. function Gsimple_Action_Group_New return Gsimple_Action_Group; -- Creates a new, empty, Glib.Simple_Action_Group.Gsimple_Action_Group. -- Since: gtk+ 2.28 function Get_Type return Glib.GType; pragma Import (C, Get_Type, "g_simple_action_group_get_type"); ------------- -- Methods -- ------------- procedure Add_Entries (Self : not null access Gsimple_Action_Group_Record; Entries : Glib.Action_Map.GAction_Entry_Array; User_Data : System.Address := System.Null_Address); pragma Obsolescent (Add_Entries); -- A convenience function for creating multiple -- Glib.Simple_Action.Gsimple_Action instances and adding them to the -- action group. -- Since: gtk+ 2.30 -- Deprecated since 2.38, 1 -- "entries": a pointer to the first item in an array of -- Glib.Action_Map.GAction_Entry structs -- "user_data": the user data for signal connections procedure Insert (Self : not null access Gsimple_Action_Group_Record; Action : Glib.Action.Gaction); pragma Obsolescent (Insert); -- Adds an action to the action group. -- If the action group already contains an action with the same name as -- Action then the old action is dropped from the group. -- The action group takes its own reference on Action. -- Since: gtk+ 2.28 -- Deprecated since 2.38, 1 -- "action": a Glib.Action.Gaction function Lookup (Self : not null access Gsimple_Action_Group_Record; Action_Name : UTF8_String) return Glib.Action.Gaction; pragma Obsolescent (Lookup); -- Looks up the action with the name Action_Name in the group. -- If no such action exists, returns null. -- Since: gtk+ 2.28 -- Deprecated since 2.38, 1 -- "action_name": the name of an action procedure Remove (Self : not null access Gsimple_Action_Group_Record; Action_Name : UTF8_String); pragma Obsolescent (Remove); -- Removes the named action from the action group. -- If no action of this name is in the group then nothing happens. -- Since: gtk+ 2.28 -- Deprecated since 2.38, 1 -- "action_name": the name of the action --------------------------------------------- -- Inherited subprograms (from interfaces) -- --------------------------------------------- procedure Action_Added (Self : not null access Gsimple_Action_Group_Record; Action_Name : UTF8_String); procedure Action_Enabled_Changed (Self : not null access Gsimple_Action_Group_Record; Action_Name : UTF8_String; Enabled : Boolean); procedure Action_Removed (Self : not null access Gsimple_Action_Group_Record; Action_Name : UTF8_String); procedure Action_State_Changed (Self : not null access Gsimple_Action_Group_Record; Action_Name : UTF8_String; State : Glib.Variant.Gvariant); procedure Activate_Action (Self : not null access Gsimple_Action_Group_Record; Action_Name : UTF8_String; Parameter : Glib.Variant.Gvariant); procedure Change_Action_State (Self : not null access Gsimple_Action_Group_Record; Action_Name : UTF8_String; Value : Glib.Variant.Gvariant); function Get_Action_Enabled (Self : not null access Gsimple_Action_Group_Record; Action_Name : UTF8_String) return Boolean; function Get_Action_Parameter_Type (Self : not null access Gsimple_Action_Group_Record; Action_Name : UTF8_String) return Glib.Variant.Gvariant_Type; function Get_Action_State (Self : not null access Gsimple_Action_Group_Record; Action_Name : UTF8_String) return Glib.Variant.Gvariant; function Get_Action_State_Hint (Self : not null access Gsimple_Action_Group_Record; Action_Name : UTF8_String) return Glib.Variant.Gvariant; function Get_Action_State_Type (Self : not null access Gsimple_Action_Group_Record; Action_Name : UTF8_String) return Glib.Variant.Gvariant_Type; function Has_Action (Self : not null access Gsimple_Action_Group_Record; Action_Name : UTF8_String) return Boolean; function List_Actions (Self : not null access Gsimple_Action_Group_Record) return GNAT.Strings.String_List; function Query_Action (Self : not null access Gsimple_Action_Group_Record; Action_Name : UTF8_String; Enabled : access Boolean; Parameter_Type : access Glib.Variant.Gvariant_Type; State_Type : access Glib.Variant.Gvariant_Type; State_Hint : access Glib.Variant.Gvariant; State : access Glib.Variant.Gvariant) return Boolean; procedure Add_Action (Self : not null access Gsimple_Action_Group_Record; Action : Glib.Action.Gaction); procedure Add_Action_Entries (Self : not null access Gsimple_Action_Group_Record; Entries : GAction_Entry_Array; User_Data : System.Address := System.Null_Address); function Lookup_Action (Self : not null access Gsimple_Action_Group_Record; Action_Name : UTF8_String) return Glib.Action.Gaction; procedure Remove_Action (Self : not null access Gsimple_Action_Group_Record; Action_Name : UTF8_String); ---------------- -- Interfaces -- ---------------- -- This class implements several interfaces. See Glib.Types -- -- - "ActionGroup" -- -- - "ActionMap" package Implements_Gaction_Group is new Glib.Types.Implements (Glib.Action_Group.Gaction_Group, Gsimple_Action_Group_Record, Gsimple_Action_Group); function "+" (Widget : access Gsimple_Action_Group_Record'Class) return Glib.Action_Group.Gaction_Group renames Implements_Gaction_Group.To_Interface; function "-" (Interf : Glib.Action_Group.Gaction_Group) return Gsimple_Action_Group renames Implements_Gaction_Group.To_Object; package Implements_Gaction_Map is new Glib.Types.Implements (Glib.Action_Map.Gaction_Map, Gsimple_Action_Group_Record, Gsimple_Action_Group); function "+" (Widget : access Gsimple_Action_Group_Record'Class) return Glib.Action_Map.Gaction_Map renames Implements_Gaction_Map.To_Interface; function "-" (Interf : Glib.Action_Map.Gaction_Map) return Gsimple_Action_Group renames Implements_Gaction_Map.To_Object; end Glib.Simple_Action_Group; gtkada-24.0.0/src/generated/glib-spawn.adb000066400000000000000000000070741446021174000202770ustar00rootroot00000000000000------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ pragma Style_Checks (Off); pragma Warnings (Off, "*is already use-visible*"); pragma Warnings(Off); -- might be unused with Gtkada.Bindings; use Gtkada.Bindings; pragma Warnings(On); package body Glib.Spawn is ------------------------------ -- Spawn_Command_Line_Async -- ------------------------------ function Spawn_Command_Line_Async (Command_Line : Gtkada.Types.Chars_Ptr; Error : access Glib.Error.GError) return Boolean is function Internal (Command_Line : Gtkada.Types.Chars_Ptr; Error : access Glib.Error.GError) return Glib.Gboolean; pragma Import (C, Internal, "gnat_spawn_command_line_async"); begin return Internal (Command_Line, Error) /= 0; end Spawn_Command_Line_Async; ----------------------------- -- Spawn_Check_Exit_Status -- ----------------------------- function Spawn_Check_Exit_Status (Exit_Status : Glib.Gint; Error : access Glib.Error.GError) return Boolean is function Internal (Exit_Status : Glib.Gint; Error : access Glib.Error.GError) return Glib.Gboolean; pragma Import (C, Internal, "g_spawn_check_exit_status"); begin return Internal (Exit_Status, Error) /= 0; end Spawn_Check_Exit_Status; ----------------- -- Get_Environ -- ----------------- function Get_Environ return GNAT.Strings.String_List is function Internal return chars_ptr_array_access; pragma Import (C, Internal, "g_get_environ"); begin return To_String_List_And_Free (Internal); end Get_Environ; --------------------- -- Spawn_Close_Pid -- --------------------- procedure Spawn_Close_Pid (Pid : GPid) is procedure Internal (Pid : GPid); pragma Import (C, Internal, "g_spawn_close_pid"); begin Internal (Pid); end Spawn_Close_Pid; end Glib.Spawn; gtkada-24.0.0/src/generated/glib-spawn.ads000066400000000000000000000672521446021174000203240ustar00rootroot00000000000000------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ pragma Warnings (Off, "*is already use-visible*"); with GNAT.Strings; use GNAT.Strings; with Glib.Error; use Glib.Error; with Glib.Generic_Properties; use Glib.Generic_Properties; with Gtkada.Types; use Gtkada.Types; package Glib.Spawn is type GSpawn_Flags is mod 2 ** Integer'Size; pragma Convention (C, GSpawn_Flags); -- Flags passed to g_spawn_sync, g_spawn_async and -- g_spawn_async_with_pipes. G_Spawn_Default : constant GSpawn_Flags := 0; G_Spawn_Leave_Descriptors_Open : constant GSpawn_Flags := 1; G_Spawn_Do_Not_Reap_Child : constant GSpawn_Flags := 2; G_Spawn_Search_Path : constant GSpawn_Flags := 4; G_Spawn_Stdout_To_Dev_Null : constant GSpawn_Flags := 8; G_Spawn_Stderr_To_Dev_Null : constant GSpawn_Flags := 16; G_Spawn_Child_Inherits_Stdin : constant GSpawn_Flags := 32; G_Spawn_File_And_Argv_Zero : constant GSpawn_Flags := 64; G_Spawn_Search_Path_From_Envp : constant GSpawn_Flags := 128; G_Spawn_Cloexec_Pipes : constant GSpawn_Flags := 256; type GSpawn_Error is ( G_Spawn_Error_Fork, G_Spawn_Error_Read, G_Spawn_Error_Chdir, G_Spawn_Error_Acces, G_Spawn_Error_Perm, G_Spawn_Error_Too_Big, G_Spawn_Error_Noexec, G_Spawn_Error_Nametoolong, G_Spawn_Error_Noent, G_Spawn_Error_Nomem, G_Spawn_Error_Notdir, G_Spawn_Error_Loop, G_Spawn_Error_Txtbusy, G_Spawn_Error_Io, G_Spawn_Error_Nfile, G_Spawn_Error_Mfile, G_Spawn_Error_Inval, G_Spawn_Error_Isdir, G_Spawn_Error_Libbad, G_Spawn_Error_Failed); pragma Convention (C, GSpawn_Error); -- Error codes returned by spawning processes. type GPid is new Interfaces.C.ptrdiff_t; ---------------------------- -- Enumeration Properties -- ---------------------------- package GSpawn_Flags_Properties is new Generic_Internal_Discrete_Property (GSpawn_Flags); type Property_GSpawn_Flags is new GSpawn_Flags_Properties.Property; package GSpawn_Error_Properties is new Generic_Internal_Discrete_Property (GSpawn_Error); type Property_GSpawn_Error is new GSpawn_Error_Properties.Property; ---------------------- -- GtkAda additions -- ---------------------- generic type User_Data is limited private; function Generic_Spawn_Async (Working_Directory : Gtkada.Types.Chars_Ptr := Gtkada.Types.Null_Ptr; Argv : access Gtkada.Types.Chars_Ptr_Array; Envp : access Gtkada.Types.Chars_Ptr_Array; Flags : GSpawn_Flags; Child_Setup : access procedure (Data : access User_Data); Data : access User_Data; Child_Pid : access GPid; Error : access Glib.Error.GError) return Glib.Gboolean; pragma Import (C, Generic_Spawn_Async, "gnat_spawn_async"); -- See Glib.Spawn.Spawn_Async_With_Pipes for a full description; this -- function simply calls the Glib.Spawn.Spawn_Async_With_Pipes without any -- pipes. -- You should call Glib.Spawn.Spawn_Close_Pid on the returned child -- process reference when you don't need it any more. -- If you are writing a GTK+ application, and the program you are spawning -- is a graphical application, too, then you may want to use -- gdk_spawn_on_screen instead to ensure that the spawned program opens its -- windows on the right screen. -- Note that the returned Child_Pid on Windows is a handle to the child -- process and not its identifier. Process handles and process identifiers -- are different concepts on Windows. -- "working_directory": child's current working directory, or null to -- inherit parent's -- "argv": child's argument vector -- "envp": child's environment, or null to inherit parent's -- "flags": flags from Glib.Spawn.GSpawn_Flags -- "child_setup": function to run in the child just before exec -- "child_pid": return location for child process reference, or null generic type User_Data is limited private; function Generic_Spawn_Async_With_Pipes (Working_Directory : Gtkada.Types.Chars_Ptr := Gtkada.Types.Null_Ptr; Argv : access Gtkada.Types.Chars_Ptr_Array; Envp : access Gtkada.Types.Chars_Ptr_Array; Flags : GSpawn_Flags; Child_Setup : access procedure (Data : access User_Data); Data : access User_Data; Child_Pid : access GPid; Standard_Input : access Glib.Gint; Standard_Output : access Glib.Gint; Standard_Error : access Glib.Gint; Error : access Glib.Error.GError) return Glib.Gboolean; pragma Import (C, Generic_Spawn_Async_With_Pipes, "gnat_spawn_async_with_pipes"); -- Executes a child program asynchronously (your program will not block -- waiting for the child to exit). The child program is specified by the -- only argument that must be provided, Argv. Argv should be a -- null-terminated array of strings, to be passed as the argument vector -- for the child. The first string in Argv is of course the name of the -- program to execute. By default, the name of the program must be a full -- path. If Flags contains the Glib.Spawn.G_Spawn_Search_Path flag, the -- `PATH` environment variable is used to search for the executable. If -- Flags contains the Glib.Spawn.G_Spawn_Search_Path_From_Envp flag, the -- `PATH` variable from Envp is used to search for the executable. If both -- the Glib.Spawn.G_Spawn_Search_Path and -- Glib.Spawn.G_Spawn_Search_Path_From_Envp flags are set, the `PATH` -- variable from Envp takes precedence over the environment variable. -- If the program name is not a full path and -- Glib.Spawn.G_Spawn_Search_Path flag is not used, then the program will -- be run from the current directory (or Working_Directory, if specified); -- this might be unexpected or even dangerous in some cases when the -- current directory is world-writable. -- On Windows, note that all the string or string vector arguments to this -- function and the other g_spawn* functions are in UTF-8, the GLib file -- name encoding. Unicode characters that are not part of the system -- codepage passed in these arguments will be correctly available in the -- spawned program only if it uses wide character API to retrieve its -- command line. For C programs built with Microsoft's tools it is enough -- to make the program have a wmain instead of main. wmain has a wide -- character argument vector as parameter. -- At least currently, mingw doesn't support wmain, so if you use mingw to -- develop the spawned program, it will have to call the undocumented -- function __wgetmainargs to get the wide character argument vector and -- environment. See gspawn-win32-helper.c in the GLib sources or init.c in -- the mingw runtime sources for a prototype for that function. -- Alternatively, you can retrieve the Win32 system level wide character -- command line passed to the spawned program using the GetCommandLineW -- function. -- On Windows the low-level child process creation API CreateProcess -- doesn't use argument vectors, but a command line. The C runtime -- library's spawn* family of functions (which -- Glib.Spawn.Spawn_Async_With_Pipes eventually calls) paste the argument -- vector elements together into a command line, and the C runtime startup -- code does a corresponding reconstruction of an argument vector from the -- command line, to be passed to main. Complications arise when you have -- argument vector elements that contain spaces of double quotes. The -- spawn* functions don't do any quoting or escaping, but on the other hand -- the startup code does do unquoting and unescaping in order to enable -- receiving arguments with embedded spaces or double quotes. To work -- around this asymmetry, Glib.Spawn.Spawn_Async_With_Pipes will do quoting -- and escaping on argument vector elements that need it before calling the -- C runtime spawn function. -- The returned Child_Pid on Windows is a handle to the child process, not -- its identifier. Process handles and process identifiers are different -- concepts on Windows. -- Envp is a null-terminated array of strings, where each string has the -- form `KEY=VALUE`. This will become the child's environment. If Envp is -- null, the child inherits its parent's environment. -- Flags should be the bitwise OR of any flags you want to affect the -- function's behaviour. The Glib.Spawn.G_Spawn_Do_Not_Reap_Child means -- that the child will not automatically be reaped; you must use a child -- watch to be notified about the death of the child process. Eventually -- you must call Glib.Spawn.Spawn_Close_Pid on the Child_Pid, in order to -- free resources which may be associated with the child process. (On Unix, -- using a child watch is equivalent to calling waitpid or handling the -- SIGCHLD signal manually. On Windows, calling Glib.Spawn.Spawn_Close_Pid -- is equivalent to calling CloseHandle on the process handle returned in -- Child_Pid). See g_child_watch_add. -- Glib.Spawn.G_Spawn_Leave_Descriptors_Open means that the parent's open -- file descriptors will be inherited by the child; otherwise all -- descriptors except stdin/stdout/stderr will be closed before calling -- exec in the child. Glib.Spawn.G_Spawn_Search_Path means that Argv[0] -- need not be an absolute path, it will be looked for in the `PATH` -- environment variable. Glib.Spawn.G_Spawn_Search_Path_From_Envp means -- need not be an absolute path, it will be looked for in the `PATH` -- variable from Envp. If both Glib.Spawn.G_Spawn_Search_Path and -- Glib.Spawn.G_Spawn_Search_Path_From_Envp are used, the value from Envp -- takes precedence over the environment. -- Glib.Spawn.G_Spawn_Stdout_To_Dev_Null means that the child's standard -- output will be discarded, instead of going to the same location as the -- parent's standard output. If you use this flag, Standard_Output must be -- null. Glib.Spawn.G_Spawn_Stderr_To_Dev_Null means that the child's -- standard error will be discarded, instead of going to the same location -- as the parent's standard error. If you use this flag, Standard_Error -- must be null. Glib.Spawn.G_Spawn_Child_Inherits_Stdin means that the -- child will inherit the parent's standard input (by default, the child's -- standard input is attached to /dev/null). If you use this flag, -- Standard_Input must be null. Glib.Spawn.G_Spawn_File_And_Argv_Zero means -- that the first element of Argv is the file to execute, while the -- remaining elements are the actual argument vector to pass to the file. -- Normally Glib.Spawn.Spawn_Async_With_Pipes uses Argv[0] as the file to -- execute, and passes all of Argv to the child. -- Child_Setup and User_Data are a function and user data. On POSIX -- platforms, the function is called in the child after GLib has performed -- all the setup it plans to perform (including creating pipes, closing -- file descriptors, etc.) but before calling exec. That is, Child_Setup is -- called just before calling exec in the child. Obviously actions taken in -- this function will only affect the child, not the parent. -- On Windows, there is no separate fork and exec functionality. Child -- processes are created and run with a single API call, CreateProcess. -- There is no sensible thing Child_Setup could be used for on Windows so -- it is ignored and not called. -- If non-null, Child_Pid will on Unix be filled with the child's process -- ID. You can use the process ID to send signals to the child, or to use -- g_child_watch_add (or waitpid) if you specified the -- Glib.Spawn.G_Spawn_Do_Not_Reap_Child flag. On Windows, Child_Pid will be -- filled with a handle to the child process only if you specified the -- Glib.Spawn.G_Spawn_Do_Not_Reap_Child flag. You can then access the child -- process using the Win32 API, for example wait for its termination with -- the WaitFor* functions, or examine its exit code with -- GetExitCodeProcess. You should close the handle with CloseHandle or -- Glib.Spawn.Spawn_Close_Pid when you no longer need it. -- If non-null, the Standard_Input, Standard_Output, Standard_Error -- locations will be filled with file descriptors for writing to the -- child's standard input or reading from its standard output or standard -- error. The caller of Glib.Spawn.Spawn_Async_With_Pipes must close these -- file descriptors when they are no longer in use. If these parameters are -- null, the corresponding pipe won't be created. -- If Standard_Input is NULL, the child's standard input is attached to -- /dev/null unless Glib.Spawn.G_Spawn_Child_Inherits_Stdin is set. -- If Standard_Error is NULL, the child's standard error goes to the same -- location as the parent's standard error unless -- Glib.Spawn.G_Spawn_Stderr_To_Dev_Null is set. -- If Standard_Output is NULL, the child's standard output goes to the -- same location as the parent's standard output unless -- Glib.Spawn.G_Spawn_Stdout_To_Dev_Null is set. -- Error can be null to ignore errors, or non-null to report errors. If an -- error is set, the function returns False. Errors are reported even if -- they occur in the child (for example if the executable in Argv[0] is not -- found). Typically the `message` field of returned errors should be -- displayed to users. Possible errors are those from the G_SPAWN_ERROR -- domain. -- If an error occurs, Child_Pid, Standard_Input, Standard_Output, and -- Standard_Error will not be filled with valid values. -- If Child_Pid is not null and an error does not occur then the returned -- process reference must be closed using Glib.Spawn.Spawn_Close_Pid. -- If you are writing a GTK+ application, and the program you are spawning -- is a graphical application, too, then you may want to use -- gdk_spawn_on_screen_with_pipes instead to ensure that the spawned -- program opens its windows on the right screen. -- "working_directory": child's current working directory, or null to -- inherit parent's, in the GLib file name encoding -- "argv": child's argument vector, in the GLib file name encoding -- "envp": child's environment, or null to inherit parent's, in the GLib -- file name encoding -- "flags": flags from Glib.Spawn.GSpawn_Flags -- "child_setup": function to run in the child just before exec -- "child_pid": return location for child process ID, or null -- "standard_input": return location for file descriptor to write to -- child's stdin, or null -- "standard_output": return location for file descriptor to read child's -- stdout, or null -- "standard_error": return location for file descriptor to read child's -- stderr, or null generic type User_Data is limited private; function Generic_Spawn_Async_With_Fds (Working_Directory : Gtkada.Types.Chars_Ptr := Gtkada.Types.Null_Ptr; Argv : access Gtkada.Types.Chars_Ptr_Array; Envp : access Gtkada.Types.Chars_Ptr_Array; Flags : GSpawn_Flags; Child_Setup : access procedure (Data : access User_Data); Data : access User_Data; Child_Pid : access GPid; Stdin_Fd : Glib.Gint; Stdout_Fd : Glib.Gint; Stderr_Fd : Glib.Gint; Error : access Glib.Error.GError) return Glib.Gboolean; pragma Import (C, Generic_Spawn_Async_With_Fds, "gnat_spawn_async_with_fds"); -- Identical to g_spawn_async_with_pipes() but instead of creating pipes -- for the stdin/stdout/stderr, you can pass existing file descriptors -- into this function through the stdin_fd , stdout_fd and -- stderr_fd parameters. The following flags also have their behaviour -- slightly tweaked as a result: G_SPAWN_STDOUT_TO_DEV_NULL means that -- the child's standard output will be discarded, instead of going to the -- same location as the parent's standard output. If you use this flag, -- standard_output must be -1. G_SPAWN_STDERR_TO_DEV_NULL means that the -- child's standard error will be discarded, instead of going to the same -- location as the parent's standard error. If you use this flag, -- standard_error must be -1. G_SPAWN_CHILD_INHERITS_STDIN means that the -- child will inherit the parent's standard input (by default, the child's -- standard input is attached to /dev/null). If you use this flag, -- standard_input must be -1. -- It is valid to pass the same fd in multiple parameters (e.g. you can -- pass a single fd for both stdout and stderr). -- Parameters -- "working_directory" child's current working directory, or NULL to -- inherit parent's, in the GLib file name encoding. -- "argv" child's argument vector, in the GLib file name encoding. -- "envp" child's environment, or NULL to inherit parent's, in the GLib -- file name encoding. -- "flags" flags from GSpawnFlags -- "child_setup" function to run in the child just before exec(). -- "user_data" user data for child_setup -- "child_pid" return location for child process ID, or NULL. -- "stdin_fd" file descriptor to use for child's stdin, or -1 -- "stdout_fd" file descriptor to use for child's stdout, or -1 -- "stderr_fd" file descriptor to use for child's stderr, or -1 -- "error" return location for error -- Returns -- TRUE on success, FALSE if an error was set -- Since: 2.58 generic type User_Data is limited private; function Generic_Spawn_Sync (Working_Directory : Gtkada.Types.Chars_Ptr := Gtkada.Types.Null_Ptr; Argv : access Gtkada.Types.Chars_Ptr_Array; Envp : access Gtkada.Types.Chars_Ptr_Array; Flags : GSpawn_Flags; Child_Setup : access procedure (Data : access User_Data); Data : access User_Data; Child_Pid : access GPid; Standard_Output : access Gtkada.Types.Chars_Ptr_Array; Standard_Error : access Gtkada.Types.Chars_Ptr_Array; Exit_Status : access Glib.Gint; Error : access Glib.Error.GError) return Glib.Gboolean; pragma Import (C, Generic_Spawn_Sync, "gnat_spawn_sync"); -- Executes a child synchronously (waits for the child to exit before -- returning). All output from the child is stored in Standard_Output and -- Standard_Error, if those parameters are non-null. Note that you must set -- the Glib.Spawn.G_Spawn_Stdout_To_Dev_Null and -- Glib.Spawn.G_Spawn_Stderr_To_Dev_Null flags when passing null for -- Standard_Output and Standard_Error. -- If Exit_Status is non-null, the platform-specific exit status of the -- child is stored there; see the documentation of -- Glib.Spawn.Spawn_Check_Exit_Status for how to use and interpret this. -- Note that it is invalid to pass Glib.Spawn.G_Spawn_Do_Not_Reap_Child in -- Flags. -- If an error occurs, no data is returned in Standard_Output, -- Standard_Error, or Exit_Status. -- This function calls Glib.Spawn.Spawn_Async_With_Pipes internally; see -- that function for full details on the other parameters and details on -- how these functions work on Windows. -- "working_directory": child's current working directory, or null to -- inherit parent's -- "argv": child's argument vector -- "envp": child's environment, or null to inherit parent's -- "flags": flags from Glib.Spawn.GSpawn_Flags -- "child_setup": function to run in the child just before exec -- "standard_output": return location for child output, or null -- "standard_error": return location for child error messages, or null -- "exit_status": return location for child exit status, as returned by -- waitpid, or null generic type User_Data is limited private; function Generic_Spawn_Command_Line_Sync (Command_Line : Gtkada.Types.Chars_Ptr; Standard_Output : access Gtkada.Types.Chars_Ptr_Array; Standard_Error : access Gtkada.Types.Chars_Ptr_Array; Exit_Status : access Glib.Gint; Error : access Glib.Error.GError) return Glib.Gboolean; pragma Import (C, Generic_Spawn_Command_Line_Sync, "gnat_spawn_command_line_sync"); -- A simple version of g_spawn_sync() with little-used parameters removed, -- taking a command line instead of an argument vector. See g_spawn_sync() -- for full details. command_line will be parsed by g_shell_parse_argv(). -- Unlike g_spawn_sync(), the G_SPAWN_SEARCH_PATH flag is enabled. -- Note that G_SPAWN_SEARCH_PATH can have security implications, so -- consider using g_spawn_sync() directly if appropriate. Possible errors -- are those from g_spawn_sync() and those from g_shell_parse_argv(). -- If exit_status is non-NULL, the platform-specific exit status of the -- child is stored there; see the documentation of -- g_spawn_check_exit_status() for how to use and interpret this. -- On Windows, please note the implications of g_shell_parse_argv() -- parsing command_line . Parsing is done according to Unix shell rules, -- not Windows command interpreter rules. Space is a separator, -- and backslashes are special. Thus you cannot simply pass a -- command_line containing canonical Windows paths, like -- "c:\program files\app\app.exe", as the backslashes will be eaten, -- and the space will act as a separator. You need to enclose such paths -- with single quotes, like "'c:\program files\app\app.exe' -- 'e:\folder\argument.txt'". -- Parameters -- "command_line" a command line. -- "standard_output" return location for child output. -- "standard_error" return location for child errors. -- "exit_status" return location for child exit status, as returned -- by waitpid(). -- "error" return location for errors -- Returns -- TRUE on success, FALSE if an error was set function Spawn_Command_Line_Async (Command_Line : Gtkada.Types.Chars_Ptr; Error : access Glib.Error.GError) return Boolean; -- A simple version of Glib.Spawn.Spawn_Async that parses a command line -- with g_shell_parse_argv and passes it to Glib.Spawn.Spawn_Async. Runs a -- command line in the background. Unlike Glib.Spawn.Spawn_Async, the -- Glib.Spawn.G_Spawn_Search_Path flag is enabled, other flags are not. -- Note that Glib.Spawn.G_Spawn_Search_Path can have security implications, -- so consider using Glib.Spawn.Spawn_Async directly if appropriate. -- Possible errors are those from g_shell_parse_argv and -- Glib.Spawn.Spawn_Async. -- The same concerns on Windows apply as for g_spawn_command_line_sync. -- "command_line": a command line function Spawn_Check_Exit_Status (Exit_Status : Glib.Gint; Error : access Glib.Error.GError) return Boolean; -- Set Error if Exit_Status indicates the child exited abnormally (e.g. -- with a nonzero exit code, or via a fatal signal). -- The Glib.Spawn.Spawn_Sync and g_child_watch_add family of APIs return -- an exit status for subprocesses encoded in a platform-specific way. On -- Unix, this is guaranteed to be in the same format waitpid returns, and -- on Windows it is guaranteed to be the result of GetExitCodeProcess. -- Prior to the introduction of this function in GLib 2.34, interpreting -- Exit_Status required use of platform-specific APIs, which is problematic -- for software using GLib as a cross-platform layer. -- Additionally, many programs simply want to determine whether or not the -- child exited successfully, and either propagate a Gerror.Gerror or print -- a message to standard error. In that common case, this function can be -- used. Note that the error message in Error will contain human-readable -- information about the exit status. -- The Domain and Code of Error have special semantics in the case where -- the process has an "exit code", as opposed to being killed by a signal. -- On Unix, this happens if WIFEXITED would be true of Exit_Status. On -- Windows, it is always the case. -- The special semantics are that the actual exit code will be the code -- set in Error, and the domain will be G_SPAWN_EXIT_ERROR. This allows you -- to differentiate between different exit codes. -- If the process was terminated by some means other than an exit status, -- the domain will be G_SPAWN_ERROR, and the code will be -- Glib.Spawn.G_Spawn_Error_Failed. -- This function just offers convenience; you can of course also check the -- available platform via a macro such as G_OS_UNIX, and use WIFEXITED and -- WEXITSTATUS on Exit_Status directly. Do not attempt to scan or parse the -- error message string; it may be translated and/or change in future -- versions of GLib. -- Since: gtk+ 2.34 -- "exit_status": An exit code as returned from Glib.Spawn.Spawn_Sync --------------- -- Functions -- --------------- function Get_Environ return GNAT.Strings.String_List; -- Gets the list of environment variables for the current process. -- The list is null terminated and each item in the list is of the form -- 'NAME=VALUE'. -- This is equivalent to direct access to the 'environ' global variable, -- except portable. -- The return value is freshly allocated and it should be freed with -- g_strfreev when it is no longer needed. -- Since: gtk+ 2.28 procedure Spawn_Close_Pid (Pid : GPid); -- On some platforms, notably Windows, the GPid type represents a resource -- which must be closed to prevent resource leaking. -- Glib.Spawn.Spawn_Close_Pid is provided for this purpose. It should be -- used on all platforms, even though it doesn't do anything under UNIX. -- "pid": The process reference to close end Glib.Spawn; gtkada-24.0.0/src/generated/glib-string.adb000066400000000000000000000221771446021174000204560ustar00rootroot00000000000000------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ pragma Style_Checks (Off); pragma Warnings (Off, "*is already use-visible*"); with Gtkada.Bindings; use Gtkada.Bindings; package body Glib.String is function From_Object_Free (B : access Gstring) return Gstring is Result : constant Gstring := B.all; begin Glib.g_free (B.all'Address); return Result; end From_Object_Free; ------------ -- Append -- ------------ function Append (Self : Gstring; Val : UTF8_String) return Gstring is function Internal (Self : Gstring; Val : Gtkada.Types.Chars_Ptr) return access Gstring; pragma Import (C, Internal, "g_string_append"); Tmp_Val : Gtkada.Types.Chars_Ptr := New_String (Val); Tmp_Return : access Gstring; begin Tmp_Return := Internal (Self, Tmp_Val); Free (Tmp_Val); return From_Object_Free (Tmp_Return); end Append; ---------------- -- Append_Len -- ---------------- function Append_Len (Self : Gstring; Val : UTF8_String; Len : Gssize) return Gstring is function Internal (Self : Gstring; Val : Gtkada.Types.Chars_Ptr; Len : Gssize) return access Gstring; pragma Import (C, Internal, "g_string_append_len"); Tmp_Val : Gtkada.Types.Chars_Ptr := New_String (Val); Tmp_Return : access Gstring; begin Tmp_Return := Internal (Self, Tmp_Val, Len); Free (Tmp_Val); return From_Object_Free (Tmp_Return); end Append_Len; ------------------------ -- Append_Uri_Escaped -- ------------------------ function Append_Uri_Escaped (Self : Gstring; Unescaped : UTF8_String; Reserved_Chars_Allowed : UTF8_String; Allow_Utf8 : Boolean) return Gstring is function Internal (Self : Gstring; Unescaped : Gtkada.Types.Chars_Ptr; Reserved_Chars_Allowed : Gtkada.Types.Chars_Ptr; Allow_Utf8 : Glib.Gboolean) return access Gstring; pragma Import (C, Internal, "g_string_append_uri_escaped"); Tmp_Unescaped : Gtkada.Types.Chars_Ptr := New_String (Unescaped); Tmp_Reserved_Chars_Allowed : Gtkada.Types.Chars_Ptr := New_String (Reserved_Chars_Allowed); Tmp_Return : access Gstring; begin Tmp_Return := Internal (Self, Tmp_Unescaped, Tmp_Reserved_Chars_Allowed, Boolean'Pos (Allow_Utf8)); Free (Tmp_Reserved_Chars_Allowed); Free (Tmp_Unescaped); return From_Object_Free (Tmp_Return); end Append_Uri_Escaped; ------------ -- Assign -- ------------ function Assign (Self : Gstring; Rval : UTF8_String) return Gstring is function Internal (Self : Gstring; Rval : Gtkada.Types.Chars_Ptr) return access Gstring; pragma Import (C, Internal, "g_string_assign"); Tmp_Rval : Gtkada.Types.Chars_Ptr := New_String (Rval); Tmp_Return : access Gstring; begin Tmp_Return := Internal (Self, Tmp_Rval); Free (Tmp_Rval); return From_Object_Free (Tmp_Return); end Assign; ----------- -- Equal -- ----------- function Equal (Self : Gstring; V2 : Gstring) return Boolean is function Internal (Self : Gstring; V2 : Gstring) return Glib.Gboolean; pragma Import (C, Internal, "g_string_equal"); begin return Internal (Self, V2) /= 0; end Equal; ---------- -- Free -- ---------- function Free (Self : Gstring; Free_Segment : Boolean) return UTF8_String is function Internal (Self : Gstring; Free_Segment : Glib.Gboolean) return Gtkada.Types.Chars_Ptr; pragma Import (C, Internal, "g_string_free"); begin return Gtkada.Bindings.Value_And_Free (Internal (Self, Boolean'Pos (Free_Segment))); end Free; ------------ -- Insert -- ------------ function Insert (Self : Gstring; Pos : Gssize; Val : UTF8_String) return Gstring is function Internal (Self : Gstring; Pos : Gssize; Val : Gtkada.Types.Chars_Ptr) return access Gstring; pragma Import (C, Internal, "g_string_insert"); Tmp_Val : Gtkada.Types.Chars_Ptr := New_String (Val); Tmp_Return : access Gstring; begin Tmp_Return := Internal (Self, Pos, Tmp_Val); Free (Tmp_Val); return From_Object_Free (Tmp_Return); end Insert; ---------------- -- Insert_Len -- ---------------- function Insert_Len (Self : Gstring; Pos : Gssize; Val : UTF8_String; Len : Gssize) return Gstring is function Internal (Self : Gstring; Pos : Gssize; Val : Gtkada.Types.Chars_Ptr; Len : Gssize) return access Gstring; pragma Import (C, Internal, "g_string_insert_len"); Tmp_Val : Gtkada.Types.Chars_Ptr := New_String (Val); Tmp_Return : access Gstring; begin Tmp_Return := Internal (Self, Pos, Tmp_Val, Len); Free (Tmp_Val); return From_Object_Free (Tmp_Return); end Insert_Len; --------------- -- Overwrite -- --------------- function Overwrite (Self : Gstring; Pos : Gsize; Val : UTF8_String) return Gstring is function Internal (Self : Gstring; Pos : Gsize; Val : Gtkada.Types.Chars_Ptr) return access Gstring; pragma Import (C, Internal, "g_string_overwrite"); Tmp_Val : Gtkada.Types.Chars_Ptr := New_String (Val); Tmp_Return : access Gstring; begin Tmp_Return := Internal (Self, Pos, Tmp_Val); Free (Tmp_Val); return From_Object_Free (Tmp_Return); end Overwrite; ------------------- -- Overwrite_Len -- ------------------- function Overwrite_Len (Self : Gstring; Pos : Gsize; Val : UTF8_String; Len : Gssize) return Gstring is function Internal (Self : Gstring; Pos : Gsize; Val : Gtkada.Types.Chars_Ptr; Len : Gssize) return access Gstring; pragma Import (C, Internal, "g_string_overwrite_len"); Tmp_Val : Gtkada.Types.Chars_Ptr := New_String (Val); Tmp_Return : access Gstring; begin Tmp_Return := Internal (Self, Pos, Tmp_Val, Len); Free (Tmp_Val); return From_Object_Free (Tmp_Return); end Overwrite_Len; ------------- -- Prepend -- ------------- function Prepend (Self : Gstring; Val : UTF8_String) return Gstring is function Internal (Self : Gstring; Val : Gtkada.Types.Chars_Ptr) return access Gstring; pragma Import (C, Internal, "g_string_prepend"); Tmp_Val : Gtkada.Types.Chars_Ptr := New_String (Val); Tmp_Return : access Gstring; begin Tmp_Return := Internal (Self, Tmp_Val); Free (Tmp_Val); return From_Object_Free (Tmp_Return); end Prepend; ----------------- -- Prepend_Len -- ----------------- function Prepend_Len (Self : Gstring; Val : UTF8_String; Len : Gssize) return Gstring is function Internal (Self : Gstring; Val : Gtkada.Types.Chars_Ptr; Len : Gssize) return access Gstring; pragma Import (C, Internal, "g_string_prepend_len"); Tmp_Val : Gtkada.Types.Chars_Ptr := New_String (Val); Tmp_Return : access Gstring; begin Tmp_Return := Internal (Self, Tmp_Val, Len); Free (Tmp_Val); return From_Object_Free (Tmp_Return); end Prepend_Len; end Glib.String; gtkada-24.0.0/src/generated/glib-string.ads000066400000000000000000000255441446021174000205000ustar00rootroot00000000000000------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ -- -- The GString struct contains the public fields of a GString. -- -- pragma Warnings (Off, "*is already use-visible*"); with Gtkada.Types; use Gtkada.Types; package Glib.String is type Gstring is record Str : Gtkada.Types.Chars_Ptr; Len : Gsize; Allocated_Len : Gsize; end record; pragma Convention (C, Gstring); function From_Object_Free (B : access Gstring) return Gstring; pragma Inline (From_Object_Free); -- The GString struct contains the public fields of a GString. ------------------ -- Constructors -- ------------------ function Get_Type return Glib.GType; pragma Import (C, Get_Type, "g_gstring_get_type"); ------------- -- Methods -- ------------- function Append (Self : Gstring; Val : UTF8_String) return Gstring; -- Adds a string onto the end of a Glib.String.Gstring, expanding it if -- necessary. -- "val": the string to append onto the end of String function Append_C (Self : Gstring; C : Gchar) return Gstring; pragma Import (C, Append_C, "g_string_append_c"); -- Adds a byte onto the end of a Glib.String.Gstring, expanding it if -- necessary. -- "c": the byte to append onto the end of String function Append_Len (Self : Gstring; Val : UTF8_String; Len : Gssize) return Gstring; -- Appends Len bytes of Val to String. Because Len is provided, Val may -- contain embedded nuls and need not be nul-terminated. -- Since this function does not stop at nul bytes, it is the caller's -- responsibility to ensure that Val has at least Len addressable bytes. -- "val": bytes to append -- "len": number of bytes of Val to use function Append_Unichar (Self : Gstring; Wc : Gunichar) return Gstring; pragma Import (C, Append_Unichar, "g_string_append_unichar"); -- Converts a Unicode character into UTF-8, and appends it to the string. -- "wc": a Unicode character function Append_Uri_Escaped (Self : Gstring; Unescaped : UTF8_String; Reserved_Chars_Allowed : UTF8_String; Allow_Utf8 : Boolean) return Gstring; -- Appends Unescaped to String, escaped any characters that are reserved -- in URIs using URI-style escape sequences. -- Since: gtk+ 2.16 -- "unescaped": a string -- "reserved_chars_allowed": a string of reserved characters allowed to be -- used, or null -- "allow_utf8": set True if the escaped string may include UTF8 -- characters function Ascii_Down (Self : Gstring) return Gstring; pragma Import (C, Ascii_Down, "g_string_ascii_down"); -- Converts all uppercase ASCII letters to lowercase ASCII letters. function Ascii_Up (Self : Gstring) return Gstring; pragma Import (C, Ascii_Up, "g_string_ascii_up"); -- Converts all lowercase ASCII letters to uppercase ASCII letters. function Assign (Self : Gstring; Rval : UTF8_String) return Gstring; -- Copies the bytes from a string into a Glib.String.Gstring, destroying -- any previous contents. It is rather like the standard strcpy function, -- except that you do not have to worry about having enough space to copy -- the string. -- "rval": the string to copy into String function Down (Self : Gstring) return Gstring; pragma Import (C, Down, "g_string_down"); pragma Obsolescent (Down); -- Converts a Glib.String.Gstring to lowercase. -- Deprecated since 2.2, 1 function Equal (Self : Gstring; V2 : Gstring) return Boolean; -- Compares two strings for equality, returning True if they are equal. -- For use with GHash_Table. -- "v2": another Glib.String.Gstring function Erase (Self : Gstring; Pos : Gssize; Len : Gssize) return Gstring; pragma Import (C, Erase, "g_string_erase"); -- Removes Len bytes from a Glib.String.Gstring, starting at position Pos. -- The rest of the Glib.String.Gstring is shifted down to fill the gap. -- "pos": the position of the content to remove -- "len": the number of bytes to remove, or -1 to remove all following -- bytes function Free (Self : Gstring; Free_Segment : Boolean) return UTF8_String; -- Frees the memory allocated for the Glib.String.Gstring. If Free_Segment -- is True it also frees the character data. If it's False, the caller -- gains ownership of the buffer and must free it after use with g_free. -- "free_segment": if True, the actual character data is freed as well function Hash (Self : Gstring) return Guint; pragma Import (C, Hash, "g_string_hash"); -- Creates a hash code for Str; for use with GHash_Table. function Insert (Self : Gstring; Pos : Gssize; Val : UTF8_String) return Gstring; -- Inserts a copy of a string into a Glib.String.Gstring, expanding it if -- necessary. -- "pos": the position to insert the copy of the string -- "val": the string to insert function Insert_C (Self : Gstring; Pos : Gssize; C : Gchar) return Gstring; pragma Import (C, Insert_C, "g_string_insert_c"); -- Inserts a byte into a Glib.String.Gstring, expanding it if necessary. -- "pos": the position to insert the byte -- "c": the byte to insert function Insert_Len (Self : Gstring; Pos : Gssize; Val : UTF8_String; Len : Gssize) return Gstring; -- Inserts Len bytes of Val into String at Pos. Because Len is provided, -- Val may contain embedded nuls and need not be nul-terminated. If Pos is -- -1, bytes are inserted at the end of the string. -- Since this function does not stop at nul bytes, it is the caller's -- responsibility to ensure that Val has at least Len addressable bytes. -- "pos": position in String where insertion should happen, or -1 for at -- the end -- "val": bytes to insert -- "len": number of bytes of Val to insert function Insert_Unichar (Self : Gstring; Pos : Gssize; Wc : Gunichar) return Gstring; pragma Import (C, Insert_Unichar, "g_string_insert_unichar"); -- Converts a Unicode character into UTF-8, and insert it into the string -- at the given position. -- "pos": the position at which to insert character, or -1 to append at -- the end of the string -- "wc": a Unicode character function Overwrite (Self : Gstring; Pos : Gsize; Val : UTF8_String) return Gstring; -- Overwrites part of a string, lengthening it if necessary. -- Since: gtk+ 2.14 -- "pos": the position at which to start overwriting -- "val": the string that will overwrite the String starting at Pos function Overwrite_Len (Self : Gstring; Pos : Gsize; Val : UTF8_String; Len : Gssize) return Gstring; -- Overwrites part of a string, lengthening it if necessary. This function -- will work with embedded nuls. -- Since: gtk+ 2.14 -- "pos": the position at which to start overwriting -- "val": the string that will overwrite the String starting at Pos -- "len": the number of bytes to write from Val function Prepend (Self : Gstring; Val : UTF8_String) return Gstring; -- Adds a string on to the start of a Glib.String.Gstring, expanding it if -- necessary. -- "val": the string to prepend on the start of String function Prepend_C (Self : Gstring; C : Gchar) return Gstring; pragma Import (C, Prepend_C, "g_string_prepend_c"); -- Adds a byte onto the start of a Glib.String.Gstring, expanding it if -- necessary. -- "c": the byte to prepend on the start of the Glib.String.Gstring function Prepend_Len (Self : Gstring; Val : UTF8_String; Len : Gssize) return Gstring; -- Prepends Len bytes of Val to String. Because Len is provided, Val may -- contain embedded nuls and need not be nul-terminated. -- Since this function does not stop at nul bytes, it is the caller's -- responsibility to ensure that Val has at least Len addressable bytes. -- "val": bytes to prepend -- "len": number of bytes in Val to prepend function Prepend_Unichar (Self : Gstring; Wc : Gunichar) return Gstring; pragma Import (C, Prepend_Unichar, "g_string_prepend_unichar"); -- Converts a Unicode character into UTF-8, and prepends it to the string. -- "wc": a Unicode character function Set_Size (Self : Gstring; Len : Gsize) return Gstring; pragma Import (C, Set_Size, "g_string_set_size"); -- Sets the length of a Glib.String.Gstring. If the length is less than -- the current length, the string will be truncated. If the length is -- greater than the current length, the contents of the newly added area -- are undefined. (However, as always, string->str[string->len] will be a -- nul byte.) -- "len": the new length function Truncate (Self : Gstring; Len : Gsize) return Gstring; pragma Import (C, Truncate, "g_string_truncate"); -- Cuts off the end of the GString, leaving the first Len bytes. -- "len": the new size of String function Up (Self : Gstring) return Gstring; pragma Import (C, Up, "g_string_up"); pragma Obsolescent (Up); -- Converts a Glib.String.Gstring to uppercase. -- Deprecated since 2.2, 1 end Glib.String; gtkada-24.0.0/src/generated/glib-utils.adb000066400000000000000000000044351446021174000203050ustar00rootroot00000000000000------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ pragma Style_Checks (Off); pragma Warnings (Off, "*is already use-visible*"); with Gtkada.Types; use Gtkada.Types; package body Glib.Utils is ------------------ -- Get_Home_Dir -- ------------------ function Get_Home_Dir return UTF8_String is function Internal return Gtkada.Types.Chars_Ptr; pragma Import (C, Internal, "glib_get_home_dir"); Tmp : constant Gtkada.Types.Chars_Ptr := Internal; Result : constant String := Gtkada.Types.Value (Tmp); begin Gtkada.Types.g_free (Tmp); return Result; end Get_Home_Dir; end Glib.Utils; gtkada-24.0.0/src/generated/glib-utils.ads000066400000000000000000000061031446021174000203200ustar00rootroot00000000000000------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ pragma Warnings (Off, "*is already use-visible*"); package Glib.Utils is ---------------------- -- GtkAda additions -- ---------------------- function Get_Home_Dir return UTF8_String; -- Gets the current user's home directory. As with most UNIX tools, this -- function will return the value of the HOME environment variable if it -- is set to an existing absolute path name, falling back to the passwd -- file in the case that it is unset. If the path given in HOME is -- non-absolute, does not exist, or is not a directory, the result is -- undefined. Before version 2.36 this function would ignore the HOME -- environment variable, taking the value from the passwd database -- instead. This was changed to increase the compatibility of GLib with -- other programs (and the XDG basedir specification) and to increase -- testability of programs based on GLib (by making it easier to run them -- from test frameworks). If your program has a strong requirement for -- either the new or the old behaviour (and if you don't wish to increase -- your GLib dependency to ensure that the new behaviour is in effect) -- then you should either directly check the HOME environment variable -- yourself or unset it before calling any functions in GLib. -- -- Returns: -- the current user's home directory. end Glib.Utils; gtkada-24.0.0/src/generated/glib-variant.adb000066400000000000000000001417451446021174000206170ustar00rootroot00000000000000------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ pragma Style_Checks (Off); pragma Warnings (Off, "*is already use-visible*"); with Gtkada.Bindings; use Gtkada.Bindings; pragma Warnings(Off); -- might be unused with Gtkada.Types; use Gtkada.Types; pragma Warnings(On); package body Glib.Variant is function From_Object_Free (B : access Gvariant'Class) return Gvariant is Result : constant Gvariant := Gvariant (B.all); begin Glib.g_free (B.all'Address); return Result; end From_Object_Free; function From_Object (Object : System.Address) return Gvariant is S : Gvariant; begin S.Set_Object (Object); return S; end From_Object; ----------- -- G_New -- ----------- procedure G_New (Self : out Gvariant_Type; Type_String : UTF8_String) is function Internal (Type_String : Gtkada.Types.Chars_Ptr) return Gvariant_Type; pragma Import (C, Internal, "g_variant_type_new"); Tmp_Type_String : Gtkada.Types.Chars_Ptr := New_String (Type_String); Tmp_Return : Gvariant_Type; begin Tmp_Return := Internal (Tmp_Type_String); Free (Tmp_Type_String); Self := Tmp_Return; end G_New; ------------------- -- G_New_Boolean -- ------------------- procedure G_New_Boolean (Self : out Gvariant; Value : Boolean) is function Internal (Value : Glib.Gboolean) return System.Address; pragma Import (C, Internal, "g_variant_new_boolean"); begin Self.Set_Object (Internal (Boolean'Pos (Value))); end G_New_Boolean; ---------------- -- G_New_Byte -- ---------------- procedure G_New_Byte (Self : out Gvariant; Value : Guchar) is function Internal (Value : Guchar) return System.Address; pragma Import (C, Internal, "g_variant_new_byte"); begin Self.Set_Object (Internal (Value)); end G_New_Byte; ---------------------- -- G_New_Bytestring -- ---------------------- procedure G_New_Bytestring (Self : out Gvariant; String : Gint_Array) is function Internal (String : System.Address) return System.Address; pragma Import (C, Internal, "g_variant_new_bytestring"); begin Self.Set_Object (Internal (String (String'First)'Address)); end G_New_Bytestring; ---------------------------- -- G_New_Bytestring_Array -- ---------------------------- procedure G_New_Bytestring_Array (Self : out Gvariant; Strv : GNAT.Strings.String_List; Length : Gssize) is function Internal (Strv : Gtkada.Types.chars_ptr_array; Length : Gssize) return System.Address; pragma Import (C, Internal, "g_variant_new_bytestring_array"); Tmp_Strv : Gtkada.Types.chars_ptr_array := From_String_List (Strv); Tmp_Return : System.Address; begin Tmp_Return := Internal (Tmp_Strv, Length); Gtkada.Types.Free (Tmp_Strv); Self.Set_Object (Tmp_Return); end G_New_Bytestring_Array; ---------------------- -- G_New_Dict_Entry -- ---------------------- procedure G_New_Dict_Entry (Self : out Gvariant; Key : Gvariant; Value : Gvariant) is function Internal (Key : System.Address; Value : System.Address) return System.Address; pragma Import (C, Internal, "g_variant_new_dict_entry"); begin Self.Set_Object (Internal (Get_Object (Key), Get_Object (Value))); end G_New_Dict_Entry; ---------------------- -- G_New_Dict_Entry -- ---------------------- procedure G_New_Dict_Entry (Self : out Gvariant_Type; Key : Gvariant_Type; Value : Gvariant_Type) is function Internal (Key : Gvariant_Type; Value : Gvariant_Type) return Gvariant_Type; pragma Import (C, Internal, "g_variant_type_new_dict_entry"); begin Self := Internal (Key, Value); end G_New_Dict_Entry; ------------------ -- G_New_Double -- ------------------ procedure G_New_Double (Self : out Gvariant; Value : Gdouble) is function Internal (Value : Gdouble) return System.Address; pragma Import (C, Internal, "g_variant_new_double"); begin Self.Set_Object (Internal (Value)); end G_New_Double; ------------------ -- G_New_Handle -- ------------------ procedure G_New_Handle (Self : out Gvariant; Value : Gint32) is function Internal (Value : Gint32) return System.Address; pragma Import (C, Internal, "g_variant_new_handle"); begin Self.Set_Object (Internal (Value)); end G_New_Handle; ----------------- -- G_New_Int16 -- ----------------- procedure G_New_Int16 (Self : out Gvariant; Value : Gint16) is function Internal (Value : Gint16) return System.Address; pragma Import (C, Internal, "g_variant_new_int16"); begin Self.Set_Object (Internal (Value)); end G_New_Int16; ----------------- -- G_New_Int32 -- ----------------- procedure G_New_Int32 (Self : out Gvariant; Value : Gint32) is function Internal (Value : Gint32) return System.Address; pragma Import (C, Internal, "g_variant_new_int32"); begin Self.Set_Object (Internal (Value)); end G_New_Int32; ----------------- -- G_New_Int64 -- ----------------- procedure G_New_Int64 (Self : out Gvariant; Value : Gint64) is function Internal (Value : Gint64) return System.Address; pragma Import (C, Internal, "g_variant_new_int64"); begin Self.Set_Object (Internal (Value)); end G_New_Int64; ----------------------- -- G_New_Object_Path -- ----------------------- procedure G_New_Object_Path (Self : out Gvariant; Object_Path : UTF8_String) is function Internal (Object_Path : Gtkada.Types.Chars_Ptr) return System.Address; pragma Import (C, Internal, "g_variant_new_object_path"); Tmp_Object_Path : Gtkada.Types.Chars_Ptr := New_String (Object_Path); Tmp_Return : System.Address; begin Tmp_Return := Internal (Tmp_Object_Path); Free (Tmp_Object_Path); Self.Set_Object (Tmp_Return); end G_New_Object_Path; ---------------- -- G_New_Objv -- ---------------- procedure G_New_Objv (Self : out Gvariant; Strv : GNAT.Strings.String_List; Length : Gssize) is function Internal (Strv : Gtkada.Types.chars_ptr_array; Length : Gssize) return System.Address; pragma Import (C, Internal, "g_variant_new_objv"); Tmp_Strv : Gtkada.Types.chars_ptr_array := From_String_List (Strv); Tmp_Return : System.Address; begin Tmp_Return := Internal (Tmp_Strv, Length); Gtkada.Types.Free (Tmp_Strv); Self.Set_Object (Tmp_Return); end G_New_Objv; --------------------- -- G_New_Signature -- --------------------- procedure G_New_Signature (Self : out Gvariant; Signature : UTF8_String) is function Internal (Signature : Gtkada.Types.Chars_Ptr) return System.Address; pragma Import (C, Internal, "g_variant_new_signature"); Tmp_Signature : Gtkada.Types.Chars_Ptr := New_String (Signature); Tmp_Return : System.Address; begin Tmp_Return := Internal (Tmp_Signature); Free (Tmp_Signature); Self.Set_Object (Tmp_Return); end G_New_Signature; ------------------ -- G_New_String -- ------------------ procedure G_New_String (Self : out Gvariant; String : UTF8_String) is function Internal (String : Gtkada.Types.Chars_Ptr) return System.Address; pragma Import (C, Internal, "g_variant_new_string"); Tmp_String : Gtkada.Types.Chars_Ptr := New_String (String); Tmp_Return : System.Address; begin Tmp_Return := Internal (Tmp_String); Free (Tmp_String); Self.Set_Object (Tmp_Return); end G_New_String; ---------------- -- G_New_Strv -- ---------------- procedure G_New_Strv (Self : out Gvariant; Strv : GNAT.Strings.String_List; Length : Gssize) is function Internal (Strv : Gtkada.Types.chars_ptr_array; Length : Gssize) return System.Address; pragma Import (C, Internal, "g_variant_new_strv"); Tmp_Strv : Gtkada.Types.chars_ptr_array := From_String_List (Strv); Tmp_Return : System.Address; begin Tmp_Return := Internal (Tmp_Strv, Length); Gtkada.Types.Free (Tmp_Strv); Self.Set_Object (Tmp_Return); end G_New_Strv; ----------------------- -- G_New_Take_String -- ----------------------- procedure G_New_Take_String (Self : out Gvariant; String : UTF8_String) is function Internal (String : Gtkada.Types.Chars_Ptr) return System.Address; pragma Import (C, Internal, "g_variant_new_take_string"); Tmp_String : Gtkada.Types.Chars_Ptr := New_String (String); Tmp_Return : System.Address; begin Tmp_Return := Internal (Tmp_String); Free (Tmp_String); Self.Set_Object (Tmp_Return); end G_New_Take_String; ------------------ -- G_New_Uint16 -- ------------------ procedure G_New_Uint16 (Self : out Gvariant; Value : Guint16) is function Internal (Value : Guint16) return System.Address; pragma Import (C, Internal, "g_variant_new_uint16"); begin Self.Set_Object (Internal (Value)); end G_New_Uint16; ------------------ -- G_New_Uint32 -- ------------------ procedure G_New_Uint32 (Self : out Gvariant; Value : Guint32) is function Internal (Value : Guint32) return System.Address; pragma Import (C, Internal, "g_variant_new_uint32"); begin Self.Set_Object (Internal (Value)); end G_New_Uint32; ------------------ -- G_New_Uint64 -- ------------------ procedure G_New_Uint64 (Self : out Gvariant; Value : Guint64) is function Internal (Value : Guint64) return System.Address; pragma Import (C, Internal, "g_variant_new_uint64"); begin Self.Set_Object (Internal (Value)); end G_New_Uint64; ------------------- -- G_New_Variant -- ------------------- procedure G_New_Variant (Self : out Gvariant; Value : Gvariant) is function Internal (Value : System.Address) return System.Address; pragma Import (C, Internal, "g_variant_new_variant"); begin Self.Set_Object (Internal (Get_Object (Value))); end G_New_Variant; -------------------------- -- Gvariant_New_Boolean -- -------------------------- function Gvariant_New_Boolean (Value : Boolean) return Gvariant is function Internal (Value : Glib.Gboolean) return System.Address; pragma Import (C, Internal, "g_variant_new_boolean"); Self : Gvariant; begin Self.Set_Object (Internal (Boolean'Pos (Value))); return Self; end Gvariant_New_Boolean; ----------------------- -- Gvariant_New_Byte -- ----------------------- function Gvariant_New_Byte (Value : Guchar) return Gvariant is function Internal (Value : Guchar) return System.Address; pragma Import (C, Internal, "g_variant_new_byte"); Self : Gvariant; begin Self.Set_Object (Internal (Value)); return Self; end Gvariant_New_Byte; ----------------------------- -- Gvariant_New_Bytestring -- ----------------------------- function Gvariant_New_Bytestring (String : Gint_Array) return Gvariant is function Internal (String : System.Address) return System.Address; pragma Import (C, Internal, "g_variant_new_bytestring"); Self : Gvariant; begin Self.Set_Object (Internal (String (String'First)'Address)); return Self; end Gvariant_New_Bytestring; ----------------------------------- -- Gvariant_New_Bytestring_Array -- ----------------------------------- function Gvariant_New_Bytestring_Array (Strv : GNAT.Strings.String_List; Length : Gssize) return Gvariant is function Internal (Strv : Gtkada.Types.chars_ptr_array; Length : Gssize) return System.Address; pragma Import (C, Internal, "g_variant_new_bytestring_array"); Tmp_Strv : Gtkada.Types.chars_ptr_array := From_String_List (Strv); Tmp_Return : System.Address; Self : Gvariant; begin Tmp_Return := Internal (Tmp_Strv, Length); Gtkada.Types.Free (Tmp_Strv); Self.Set_Object (Tmp_Return); return Self; end Gvariant_New_Bytestring_Array; ----------------------------- -- Gvariant_New_Dict_Entry -- ----------------------------- function Gvariant_New_Dict_Entry (Key : Gvariant; Value : Gvariant) return Gvariant is function Internal (Key : System.Address; Value : System.Address) return System.Address; pragma Import (C, Internal, "g_variant_new_dict_entry"); Self : Gvariant; begin Self.Set_Object (Internal (Get_Object (Key), Get_Object (Value))); return Self; end Gvariant_New_Dict_Entry; ------------------------- -- Gvariant_New_Double -- ------------------------- function Gvariant_New_Double (Value : Gdouble) return Gvariant is function Internal (Value : Gdouble) return System.Address; pragma Import (C, Internal, "g_variant_new_double"); Self : Gvariant; begin Self.Set_Object (Internal (Value)); return Self; end Gvariant_New_Double; ------------------------- -- Gvariant_New_Handle -- ------------------------- function Gvariant_New_Handle (Value : Gint32) return Gvariant is function Internal (Value : Gint32) return System.Address; pragma Import (C, Internal, "g_variant_new_handle"); Self : Gvariant; begin Self.Set_Object (Internal (Value)); return Self; end Gvariant_New_Handle; ------------------------ -- Gvariant_New_Int16 -- ------------------------ function Gvariant_New_Int16 (Value : Gint16) return Gvariant is function Internal (Value : Gint16) return System.Address; pragma Import (C, Internal, "g_variant_new_int16"); Self : Gvariant; begin Self.Set_Object (Internal (Value)); return Self; end Gvariant_New_Int16; ------------------------ -- Gvariant_New_Int32 -- ------------------------ function Gvariant_New_Int32 (Value : Gint32) return Gvariant is function Internal (Value : Gint32) return System.Address; pragma Import (C, Internal, "g_variant_new_int32"); Self : Gvariant; begin Self.Set_Object (Internal (Value)); return Self; end Gvariant_New_Int32; ------------------------ -- Gvariant_New_Int64 -- ------------------------ function Gvariant_New_Int64 (Value : Gint64) return Gvariant is function Internal (Value : Gint64) return System.Address; pragma Import (C, Internal, "g_variant_new_int64"); Self : Gvariant; begin Self.Set_Object (Internal (Value)); return Self; end Gvariant_New_Int64; ------------------------------ -- Gvariant_New_Object_Path -- ------------------------------ function Gvariant_New_Object_Path (Object_Path : UTF8_String) return Gvariant is function Internal (Object_Path : Gtkada.Types.Chars_Ptr) return System.Address; pragma Import (C, Internal, "g_variant_new_object_path"); Tmp_Object_Path : Gtkada.Types.Chars_Ptr := New_String (Object_Path); Tmp_Return : System.Address; Self : Gvariant; begin Tmp_Return := Internal (Tmp_Object_Path); Free (Tmp_Object_Path); Self.Set_Object (Tmp_Return); return Self; end Gvariant_New_Object_Path; ----------------------- -- Gvariant_New_Objv -- ----------------------- function Gvariant_New_Objv (Strv : GNAT.Strings.String_List; Length : Gssize) return Gvariant is function Internal (Strv : Gtkada.Types.chars_ptr_array; Length : Gssize) return System.Address; pragma Import (C, Internal, "g_variant_new_objv"); Tmp_Strv : Gtkada.Types.chars_ptr_array := From_String_List (Strv); Tmp_Return : System.Address; Self : Gvariant; begin Tmp_Return := Internal (Tmp_Strv, Length); Gtkada.Types.Free (Tmp_Strv); Self.Set_Object (Tmp_Return); return Self; end Gvariant_New_Objv; ---------------------------- -- Gvariant_New_Signature -- ---------------------------- function Gvariant_New_Signature (Signature : UTF8_String) return Gvariant is function Internal (Signature : Gtkada.Types.Chars_Ptr) return System.Address; pragma Import (C, Internal, "g_variant_new_signature"); Tmp_Signature : Gtkada.Types.Chars_Ptr := New_String (Signature); Tmp_Return : System.Address; Self : Gvariant; begin Tmp_Return := Internal (Tmp_Signature); Free (Tmp_Signature); Self.Set_Object (Tmp_Return); return Self; end Gvariant_New_Signature; ------------------------- -- Gvariant_New_String -- ------------------------- function Gvariant_New_String (String : UTF8_String) return Gvariant is function Internal (String : Gtkada.Types.Chars_Ptr) return System.Address; pragma Import (C, Internal, "g_variant_new_string"); Tmp_String : Gtkada.Types.Chars_Ptr := New_String (String); Tmp_Return : System.Address; Self : Gvariant; begin Tmp_Return := Internal (Tmp_String); Free (Tmp_String); Self.Set_Object (Tmp_Return); return Self; end Gvariant_New_String; ----------------------- -- Gvariant_New_Strv -- ----------------------- function Gvariant_New_Strv (Strv : GNAT.Strings.String_List; Length : Gssize) return Gvariant is function Internal (Strv : Gtkada.Types.chars_ptr_array; Length : Gssize) return System.Address; pragma Import (C, Internal, "g_variant_new_strv"); Tmp_Strv : Gtkada.Types.chars_ptr_array := From_String_List (Strv); Tmp_Return : System.Address; Self : Gvariant; begin Tmp_Return := Internal (Tmp_Strv, Length); Gtkada.Types.Free (Tmp_Strv); Self.Set_Object (Tmp_Return); return Self; end Gvariant_New_Strv; ------------------------------ -- Gvariant_New_Take_String -- ------------------------------ function Gvariant_New_Take_String (String : UTF8_String) return Gvariant is function Internal (String : Gtkada.Types.Chars_Ptr) return System.Address; pragma Import (C, Internal, "g_variant_new_take_string"); Tmp_String : Gtkada.Types.Chars_Ptr := New_String (String); Tmp_Return : System.Address; Self : Gvariant; begin Tmp_Return := Internal (Tmp_String); Free (Tmp_String); Self.Set_Object (Tmp_Return); return Self; end Gvariant_New_Take_String; ------------------------- -- Gvariant_New_Uint16 -- ------------------------- function Gvariant_New_Uint16 (Value : Guint16) return Gvariant is function Internal (Value : Guint16) return System.Address; pragma Import (C, Internal, "g_variant_new_uint16"); Self : Gvariant; begin Self.Set_Object (Internal (Value)); return Self; end Gvariant_New_Uint16; ------------------------- -- Gvariant_New_Uint32 -- ------------------------- function Gvariant_New_Uint32 (Value : Guint32) return Gvariant is function Internal (Value : Guint32) return System.Address; pragma Import (C, Internal, "g_variant_new_uint32"); Self : Gvariant; begin Self.Set_Object (Internal (Value)); return Self; end Gvariant_New_Uint32; ------------------------- -- Gvariant_New_Uint64 -- ------------------------- function Gvariant_New_Uint64 (Value : Guint64) return Gvariant is function Internal (Value : Guint64) return System.Address; pragma Import (C, Internal, "g_variant_new_uint64"); Self : Gvariant; begin Self.Set_Object (Internal (Value)); return Self; end Gvariant_New_Uint64; -------------------------- -- Gvariant_New_Variant -- -------------------------- function Gvariant_New_Variant (Value : Gvariant) return Gvariant is function Internal (Value : System.Address) return System.Address; pragma Import (C, Internal, "g_variant_new_variant"); Self : Gvariant; begin Self.Set_Object (Internal (Get_Object (Value))); return Self; end Gvariant_New_Variant; ----------------------- -- Gvariant_Type_New -- ----------------------- function Gvariant_Type_New (Type_String : UTF8_String) return Gvariant_Type is function Internal (Type_String : Gtkada.Types.Chars_Ptr) return Gvariant_Type; pragma Import (C, Internal, "g_variant_type_new"); Tmp_Type_String : Gtkada.Types.Chars_Ptr := New_String (Type_String); Tmp_Return : Gvariant_Type; Self : Gvariant_Type; begin Tmp_Return := Internal (Tmp_Type_String); Free (Tmp_Type_String); Self := Tmp_Return; return Self; end Gvariant_Type_New; ---------------------------------- -- Gvariant_Type_New_Dict_Entry -- ---------------------------------- function Gvariant_Type_New_Dict_Entry (Key : Gvariant_Type; Value : Gvariant_Type) return Gvariant_Type is function Internal (Key : Gvariant_Type; Value : Gvariant_Type) return Gvariant_Type; pragma Import (C, Internal, "g_variant_type_new_dict_entry"); Self : Gvariant_Type; begin Self := Internal (Key, Value); return Self; end Gvariant_Type_New_Dict_Entry; -------------- -- Byteswap -- -------------- function Byteswap (Self : Gvariant) return Gvariant is function Internal (Self : System.Address) return System.Address; pragma Import (C, Internal, "g_variant_byteswap"); begin return From_Object (Internal (Get_Object (Self))); end Byteswap; ------------------------- -- Check_Format_String -- ------------------------- function Check_Format_String (Self : Gvariant; Format_String : UTF8_String; Copy_Only : Boolean) return Boolean is function Internal (Self : System.Address; Format_String : Gtkada.Types.Chars_Ptr; Copy_Only : Glib.Gboolean) return Glib.Gboolean; pragma Import (C, Internal, "g_variant_check_format_string"); Tmp_Format_String : Gtkada.Types.Chars_Ptr := New_String (Format_String); Tmp_Return : Glib.Gboolean; begin Tmp_Return := Internal (Get_Object (Self), Tmp_Format_String, Boolean'Pos (Copy_Only)); Free (Tmp_Format_String); return Tmp_Return /= 0; end Check_Format_String; -------------- -- Classify -- -------------- function Classify (Self : Gvariant) return GVariant_Class is function Internal (Self : System.Address) return GVariant_Class; pragma Import (C, Internal, "g_variant_classify"); begin return Internal (Get_Object (Self)); end Classify; -------------------------- -- Dup_Bytestring_Array -- -------------------------- function Dup_Bytestring_Array (Self : Gvariant; Length : access Gsize) return GNAT.Strings.String_List is function Internal (Self : System.Address; Acc_Length : access Gsize) return chars_ptr_array_access; pragma Import (C, Internal, "g_variant_dup_bytestring_array"); Acc_Length : aliased Gsize; Tmp_Return : chars_ptr_array_access; begin Tmp_Return := Internal (Get_Object (Self), Acc_Length'Access); if Length /= null then Length.all := Acc_Length; end if; return To_String_List_And_Free (Tmp_Return); end Dup_Bytestring_Array; -------------- -- Dup_Objv -- -------------- function Dup_Objv (Self : Gvariant; Length : access Gsize) return GNAT.Strings.String_List is function Internal (Self : System.Address; Acc_Length : access Gsize) return chars_ptr_array_access; pragma Import (C, Internal, "g_variant_dup_objv"); Acc_Length : aliased Gsize; Tmp_Return : chars_ptr_array_access; begin Tmp_Return := Internal (Get_Object (Self), Acc_Length'Access); if Length /= null then Length.all := Acc_Length; end if; return To_String_List_And_Free (Tmp_Return); end Dup_Objv; ---------------- -- Dup_String -- ---------------- function Dup_String (Self : Gvariant; Length : access Gsize) return UTF8_String is function Internal (Self : System.Address; Acc_Length : access Gsize) return Gtkada.Types.Chars_Ptr; pragma Import (C, Internal, "g_variant_dup_string"); Acc_Length : aliased Gsize; Tmp_Return : Gtkada.Types.Chars_Ptr; begin Tmp_Return := Internal (Get_Object (Self), Acc_Length'Access); Length.all := Acc_Length; return Gtkada.Bindings.Value_And_Free (Tmp_Return); end Dup_String; ---------------- -- Dup_String -- ---------------- function Dup_String (Self : Gvariant_Type) return UTF8_String is function Internal (Self : Gvariant_Type) return Gtkada.Types.Chars_Ptr; pragma Import (C, Internal, "g_variant_type_dup_string"); begin return Gtkada.Bindings.Value_And_Free (Internal (Self)); end Dup_String; -------------- -- Dup_Strv -- -------------- function Dup_Strv (Self : Gvariant; Length : access Gsize) return GNAT.Strings.String_List is function Internal (Self : System.Address; Acc_Length : access Gsize) return chars_ptr_array_access; pragma Import (C, Internal, "g_variant_dup_strv"); Acc_Length : aliased Gsize; Tmp_Return : chars_ptr_array_access; begin Tmp_Return := Internal (Get_Object (Self), Acc_Length'Access); if Length /= null then Length.all := Acc_Length; end if; return To_String_List_And_Free (Tmp_Return); end Dup_Strv; ----------------- -- Get_Boolean -- ----------------- function Get_Boolean (Self : Gvariant) return Boolean is function Internal (Self : System.Address) return Glib.Gboolean; pragma Import (C, Internal, "g_variant_get_boolean"); begin return Internal (Get_Object (Self)) /= 0; end Get_Boolean; -------------- -- Get_Byte -- -------------- function Get_Byte (Self : Gvariant) return Guchar is function Internal (Self : System.Address) return Guchar; pragma Import (C, Internal, "g_variant_get_byte"); begin return Internal (Get_Object (Self)); end Get_Byte; -------------------------- -- Get_Bytestring_Array -- -------------------------- function Get_Bytestring_Array (Self : Gvariant; Length : access Gsize) return GNAT.Strings.String_List is function Internal (Self : System.Address; Acc_Length : access Gsize) return chars_ptr_array_access; pragma Import (C, Internal, "g_variant_get_bytestring_array"); Acc_Length : aliased Gsize; Tmp_Return : chars_ptr_array_access; begin Tmp_Return := Internal (Get_Object (Self), Acc_Length'Access); if Length /= null then Length.all := Acc_Length; end if; return To_String_List_And_Free (Tmp_Return); end Get_Bytestring_Array; --------------------- -- Get_Child_Value -- --------------------- function Get_Child_Value (Self : Gvariant; Index : Gsize) return Gvariant is function Internal (Self : System.Address; Index : Gsize) return System.Address; pragma Import (C, Internal, "g_variant_get_child_value"); begin return From_Object (Internal (Get_Object (Self), Index)); end Get_Child_Value; ---------------- -- Get_Double -- ---------------- function Get_Double (Self : Gvariant) return Gdouble is function Internal (Self : System.Address) return Gdouble; pragma Import (C, Internal, "g_variant_get_double"); begin return Internal (Get_Object (Self)); end Get_Double; ---------------- -- Get_Handle -- ---------------- function Get_Handle (Self : Gvariant) return Gint32 is function Internal (Self : System.Address) return Gint32; pragma Import (C, Internal, "g_variant_get_handle"); begin return Internal (Get_Object (Self)); end Get_Handle; --------------- -- Get_Int16 -- --------------- function Get_Int16 (Self : Gvariant) return Gint16 is function Internal (Self : System.Address) return Gint16; pragma Import (C, Internal, "g_variant_get_int16"); begin return Internal (Get_Object (Self)); end Get_Int16; --------------- -- Get_Int32 -- --------------- function Get_Int32 (Self : Gvariant) return Gint32 is function Internal (Self : System.Address) return Gint32; pragma Import (C, Internal, "g_variant_get_int32"); begin return Internal (Get_Object (Self)); end Get_Int32; --------------- -- Get_Int64 -- --------------- function Get_Int64 (Self : Gvariant) return Gint64 is function Internal (Self : System.Address) return Gint64; pragma Import (C, Internal, "g_variant_get_int64"); begin return Internal (Get_Object (Self)); end Get_Int64; --------------- -- Get_Maybe -- --------------- function Get_Maybe (Self : Gvariant) return Gvariant is function Internal (Self : System.Address) return System.Address; pragma Import (C, Internal, "g_variant_get_maybe"); begin return From_Object (Internal (Get_Object (Self))); end Get_Maybe; --------------------- -- Get_Normal_Form -- --------------------- function Get_Normal_Form (Self : Gvariant) return Gvariant is function Internal (Self : System.Address) return System.Address; pragma Import (C, Internal, "g_variant_get_normal_form"); begin return From_Object (Internal (Get_Object (Self))); end Get_Normal_Form; -------------- -- Get_Objv -- -------------- function Get_Objv (Self : Gvariant; Length : access Gsize) return GNAT.Strings.String_List is function Internal (Self : System.Address; Acc_Length : access Gsize) return chars_ptr_array_access; pragma Import (C, Internal, "g_variant_get_objv"); Acc_Length : aliased Gsize; Tmp_Return : chars_ptr_array_access; begin Tmp_Return := Internal (Get_Object (Self), Acc_Length'Access); if Length /= null then Length.all := Acc_Length; end if; return To_String_List_And_Free (Tmp_Return); end Get_Objv; -------------- -- Get_Size -- -------------- function Get_Size (Self : Gvariant) return Gsize is function Internal (Self : System.Address) return Gsize; pragma Import (C, Internal, "g_variant_get_size"); begin return Internal (Get_Object (Self)); end Get_Size; ---------------- -- Get_String -- ---------------- function Get_String (Self : Gvariant; Length : access Gsize) return UTF8_String is function Internal (Self : System.Address; Acc_Length : access Gsize) return Gtkada.Types.Chars_Ptr; pragma Import (C, Internal, "g_variant_get_string"); Acc_Length : aliased Gsize; Tmp_Return : Gtkada.Types.Chars_Ptr; begin Tmp_Return := Internal (Get_Object (Self), Acc_Length'Access); if Length /= null then Length.all := Acc_Length; end if; return Gtkada.Bindings.Value_Allowing_Null (Tmp_Return); end Get_String; -------------- -- Get_Strv -- -------------- function Get_Strv (Self : Gvariant; Length : access Gsize) return GNAT.Strings.String_List is function Internal (Self : System.Address; Acc_Length : access Gsize) return chars_ptr_array_access; pragma Import (C, Internal, "g_variant_get_strv"); Acc_Length : aliased Gsize; Tmp_Return : chars_ptr_array_access; begin Tmp_Return := Internal (Get_Object (Self), Acc_Length'Access); if Length /= null then Length.all := Acc_Length; end if; return To_String_List_And_Free (Tmp_Return); end Get_Strv; -------------- -- Get_Type -- -------------- function Get_Type (Self : Gvariant) return Gvariant_Type is function Internal (Self : System.Address) return Gvariant_Type; pragma Import (C, Internal, "g_variant_get_type"); begin return Internal (Get_Object (Self)); end Get_Type; --------------------- -- Get_Type_String -- --------------------- function Get_Type_String (Self : Gvariant) return UTF8_String is function Internal (Self : System.Address) return Gtkada.Types.Chars_Ptr; pragma Import (C, Internal, "g_variant_get_type_string"); begin return Gtkada.Bindings.Value_Allowing_Null (Internal (Get_Object (Self))); end Get_Type_String; ---------------- -- Get_Uint16 -- ---------------- function Get_Uint16 (Self : Gvariant) return Guint16 is function Internal (Self : System.Address) return Guint16; pragma Import (C, Internal, "g_variant_get_uint16"); begin return Internal (Get_Object (Self)); end Get_Uint16; ---------------- -- Get_Uint32 -- ---------------- function Get_Uint32 (Self : Gvariant) return Guint32 is function Internal (Self : System.Address) return Guint32; pragma Import (C, Internal, "g_variant_get_uint32"); begin return Internal (Get_Object (Self)); end Get_Uint32; ---------------- -- Get_Uint64 -- ---------------- function Get_Uint64 (Self : Gvariant) return Guint64 is function Internal (Self : System.Address) return Guint64; pragma Import (C, Internal, "g_variant_get_uint64"); begin return Internal (Get_Object (Self)); end Get_Uint64; ----------------- -- Get_Variant -- ----------------- function Get_Variant (Self : Gvariant) return Gvariant is function Internal (Self : System.Address) return System.Address; pragma Import (C, Internal, "g_variant_get_variant"); begin return From_Object (Internal (Get_Object (Self))); end Get_Variant; ---------- -- Hash -- ---------- function Hash (Self : Gvariant) return Guint is function Internal (Self : System.Address) return Guint; pragma Import (C, Internal, "g_variant_hash"); begin return Internal (Get_Object (Self)); end Hash; ---------- -- Init -- ---------- function Init (Self : Gvariant_Iter; Value : Gvariant) return Gsize is function Internal (Self : Gvariant_Iter; Value : System.Address) return Gsize; pragma Import (C, Internal, "g_variant_iter_init"); begin return Internal (Self, Get_Object (Value)); end Init; -------------- -- Is_Array -- -------------- function Is_Array (Self : Gvariant_Type) return Boolean is function Internal (Self : Gvariant_Type) return Glib.Gboolean; pragma Import (C, Internal, "g_variant_type_is_array"); begin return Internal (Self) /= 0; end Is_Array; -------------- -- Is_Basic -- -------------- function Is_Basic (Self : Gvariant_Type) return Boolean is function Internal (Self : Gvariant_Type) return Glib.Gboolean; pragma Import (C, Internal, "g_variant_type_is_basic"); begin return Internal (Self) /= 0; end Is_Basic; ------------------ -- Is_Container -- ------------------ function Is_Container (Self : Gvariant) return Boolean is function Internal (Self : System.Address) return Glib.Gboolean; pragma Import (C, Internal, "g_variant_is_container"); begin return Internal (Get_Object (Self)) /= 0; end Is_Container; ------------------ -- Is_Container -- ------------------ function Is_Container (Self : Gvariant_Type) return Boolean is function Internal (Self : Gvariant_Type) return Glib.Gboolean; pragma Import (C, Internal, "g_variant_type_is_container"); begin return Internal (Self) /= 0; end Is_Container; ----------------- -- Is_Definite -- ----------------- function Is_Definite (Self : Gvariant_Type) return Boolean is function Internal (Self : Gvariant_Type) return Glib.Gboolean; pragma Import (C, Internal, "g_variant_type_is_definite"); begin return Internal (Self) /= 0; end Is_Definite; ------------------- -- Is_Dict_Entry -- ------------------- function Is_Dict_Entry (Self : Gvariant_Type) return Boolean is function Internal (Self : Gvariant_Type) return Glib.Gboolean; pragma Import (C, Internal, "g_variant_type_is_dict_entry"); begin return Internal (Self) /= 0; end Is_Dict_Entry; ----------------- -- Is_Floating -- ----------------- function Is_Floating (Self : Gvariant) return Boolean is function Internal (Self : System.Address) return Glib.Gboolean; pragma Import (C, Internal, "g_variant_is_floating"); begin return Internal (Get_Object (Self)) /= 0; end Is_Floating; -------------- -- Is_Maybe -- -------------- function Is_Maybe (Self : Gvariant_Type) return Boolean is function Internal (Self : Gvariant_Type) return Glib.Gboolean; pragma Import (C, Internal, "g_variant_type_is_maybe"); begin return Internal (Self) /= 0; end Is_Maybe; -------------------- -- Is_Normal_Form -- -------------------- function Is_Normal_Form (Self : Gvariant) return Boolean is function Internal (Self : System.Address) return Glib.Gboolean; pragma Import (C, Internal, "g_variant_is_normal_form"); begin return Internal (Get_Object (Self)) /= 0; end Is_Normal_Form; ---------------- -- Is_Of_Type -- ---------------- function Is_Of_Type (Self : Gvariant; The_Type : Gvariant_Type) return Boolean is function Internal (Self : System.Address; The_Type : Gvariant_Type) return Glib.Gboolean; pragma Import (C, Internal, "g_variant_is_of_type"); begin return Internal (Get_Object (Self), The_Type) /= 0; end Is_Of_Type; ------------------- -- Is_Subtype_Of -- ------------------- function Is_Subtype_Of (Self : Gvariant_Type; Supertype : Gvariant_Type) return Boolean is function Internal (Self : Gvariant_Type; Supertype : Gvariant_Type) return Glib.Gboolean; pragma Import (C, Internal, "g_variant_type_is_subtype_of"); begin return Internal (Self, Supertype) /= 0; end Is_Subtype_Of; -------------- -- Is_Tuple -- -------------- function Is_Tuple (Self : Gvariant_Type) return Boolean is function Internal (Self : Gvariant_Type) return Glib.Gboolean; pragma Import (C, Internal, "g_variant_type_is_tuple"); begin return Internal (Self) /= 0; end Is_Tuple; ---------------- -- Is_Variant -- ---------------- function Is_Variant (Self : Gvariant_Type) return Boolean is function Internal (Self : Gvariant_Type) return Glib.Gboolean; pragma Import (C, Internal, "g_variant_type_is_variant"); begin return Internal (Self) /= 0; end Is_Variant; -------------- -- Iter_New -- -------------- function Iter_New (Self : Gvariant) return Gvariant_Iter is function Internal (Self : System.Address) return Gvariant_Iter; pragma Import (C, Internal, "g_variant_iter_new"); begin return Internal (Get_Object (Self)); end Iter_New; ------------------ -- Lookup_Value -- ------------------ function Lookup_Value (Self : Gvariant; Key : UTF8_String; Expected_Type : Gvariant_Type) return Gvariant is function Internal (Self : System.Address; Key : Gtkada.Types.Chars_Ptr; Expected_Type : Gvariant_Type) return System.Address; pragma Import (C, Internal, "g_variant_lookup_value"); Tmp_Key : Gtkada.Types.Chars_Ptr := New_String (Key); Tmp_Return : System.Address; begin Tmp_Return := Internal (Get_Object (Self), Tmp_Key, Expected_Type); Free (Tmp_Key); return From_Object (Tmp_Return); end Lookup_Value; ---------------- -- N_Children -- ---------------- function N_Children (Self : Gvariant) return Gsize is function Internal (Self : System.Address) return Gsize; pragma Import (C, Internal, "g_variant_n_children"); begin return Internal (Get_Object (Self)); end N_Children; ---------------- -- Next_Value -- ---------------- function Next_Value (Self : Gvariant_Iter) return Gvariant is function Internal (Self : Gvariant_Iter) return System.Address; pragma Import (C, Internal, "g_variant_iter_next_value"); begin return From_Object (Internal (Self)); end Next_Value; ----------------- -- Peek_String -- ----------------- function Peek_String (Self : Gvariant_Type) return UTF8_String is function Internal (Self : Gvariant_Type) return Gtkada.Types.Chars_Ptr; pragma Import (C, Internal, "g_variant_type_peek_string"); begin return Gtkada.Bindings.Value_Allowing_Null (Internal (Self)); end Peek_String; ----------- -- Print -- ----------- function Print (Self : Gvariant; Type_Annotate : Boolean) return UTF8_String is function Internal (Self : System.Address; Type_Annotate : Glib.Gboolean) return Gtkada.Types.Chars_Ptr; pragma Import (C, Internal, "g_variant_print"); begin return Gtkada.Bindings.Value_And_Free (Internal (Get_Object (Self), Boolean'Pos (Type_Annotate))); end Print; ------------------ -- Print_String -- ------------------ function Print_String (Self : Gvariant; String : Glib.String.Gstring; Type_Annotate : Boolean) return Glib.String.Gstring is function Internal (Self : System.Address; String : Glib.String.Gstring; Type_Annotate : Glib.Gboolean) return access Glib.String.Gstring; pragma Import (C, Internal, "g_variant_print_string"); begin return From_Object_Free (Internal (Get_Object (Self), String, Boolean'Pos (Type_Annotate))); end Print_String; --------- -- Ref -- --------- function Ref (Self : Gvariant) return Gvariant is function Internal (Self : System.Address) return System.Address; pragma Import (C, Internal, "g_variant_ref"); begin return From_Object (Internal (Get_Object (Self))); end Ref; -------------- -- Ref_Sink -- -------------- function Ref_Sink (Self : Gvariant) return Gvariant is function Internal (Self : System.Address) return System.Address; pragma Import (C, Internal, "g_variant_ref_sink"); begin return From_Object (Internal (Get_Object (Self))); end Ref_Sink; ----------- -- Store -- ----------- procedure Store (Self : Gvariant; Data : System.Address) is procedure Internal (Self : System.Address; Data : System.Address); pragma Import (C, Internal, "g_variant_store"); begin Internal (Get_Object (Self), Data); end Store; -------------- -- Take_Ref -- -------------- function Take_Ref (Self : Gvariant) return Gvariant is function Internal (Self : System.Address) return System.Address; pragma Import (C, Internal, "g_variant_take_ref"); begin return From_Object (Internal (Get_Object (Self))); end Take_Ref; ----------- -- Unref -- ----------- procedure Unref (Self : Gvariant) is procedure Internal (Self : System.Address); pragma Import (C, Internal, "g_variant_unref"); begin Internal (Get_Object (Self)); end Unref; -------------------- -- Is_Object_Path -- -------------------- function Is_Object_Path (String : UTF8_String) return Boolean is function Internal (String : Gtkada.Types.Chars_Ptr) return Glib.Gboolean; pragma Import (C, Internal, "g_variant_is_object_path"); Tmp_String : Gtkada.Types.Chars_Ptr := New_String (String); Tmp_Return : Glib.Gboolean; begin Tmp_Return := Internal (Tmp_String); Free (Tmp_String); return Tmp_Return /= 0; end Is_Object_Path; ------------------ -- Is_Signature -- ------------------ function Is_Signature (String : UTF8_String) return Boolean is function Internal (String : Gtkada.Types.Chars_Ptr) return Glib.Gboolean; pragma Import (C, Internal, "g_variant_is_signature"); Tmp_String : Gtkada.Types.Chars_Ptr := New_String (String); Tmp_Return : Glib.Gboolean; begin Tmp_Return := Internal (Tmp_String); Free (Tmp_String); return Tmp_Return /= 0; end Is_Signature; ----------- -- Parse -- ----------- function Parse (The_Type : Gvariant_Type; Text : UTF8_String; Limit : UTF8_String := ""; Endptr : GNAT.Strings.String_List) return Gvariant is function Internal (The_Type : Gvariant_Type; Text : Gtkada.Types.Chars_Ptr; Limit : Gtkada.Types.Chars_Ptr; Endptr : Gtkada.Types.chars_ptr_array) return System.Address; pragma Import (C, Internal, "g_variant_parse"); Tmp_Text : Gtkada.Types.Chars_Ptr := New_String (Text); Tmp_Limit : Gtkada.Types.Chars_Ptr; Tmp_Endptr : Gtkada.Types.chars_ptr_array := From_String_List (Endptr); Tmp_Return : System.Address; begin if Limit = "" then Tmp_Limit := Gtkada.Types.Null_Ptr; else Tmp_Limit := New_String (Limit); end if; Tmp_Return := Internal (The_Type, Tmp_Text, Tmp_Limit, Tmp_Endptr); Gtkada.Types.Free (Tmp_Endptr); Free (Tmp_Limit); Free (Tmp_Text); return From_Object (Tmp_Return); end Parse; ------------------------------- -- Parse_Error_Print_Context -- ------------------------------- function Parse_Error_Print_Context (Error : Glib.Error.GError; Source_Str : UTF8_String) return UTF8_String is function Internal (Error : Glib.Error.GError; Source_Str : Gtkada.Types.Chars_Ptr) return Gtkada.Types.Chars_Ptr; pragma Import (C, Internal, "g_variant_parse_error_print_context"); Tmp_Source_Str : Gtkada.Types.Chars_Ptr := New_String (Source_Str); Tmp_Return : Gtkada.Types.Chars_Ptr; begin Tmp_Return := Internal (Error, Tmp_Source_Str); Free (Tmp_Source_Str); return Gtkada.Bindings.Value_And_Free (Tmp_Return); end Parse_Error_Print_Context; ----------------------- -- Parse_Error_Quark -- ----------------------- function Parse_Error_Quark return Glib.GQuark is function Internal return Glib.GQuark; pragma Import (C, Internal, "g_variant_parse_error_quark"); begin return Internal; end Parse_Error_Quark; ---------------------------- -- Parser_Get_Error_Quark -- ---------------------------- function Parser_Get_Error_Quark return Glib.GQuark is function Internal return Glib.GQuark; pragma Import (C, Internal, "g_variant_parser_get_error_quark"); begin return Internal; end Parser_Get_Error_Quark; --------------------- -- String_Is_Valid -- --------------------- function String_Is_Valid (Type_String : UTF8_String) return Boolean is function Internal (Type_String : Gtkada.Types.Chars_Ptr) return Glib.Gboolean; pragma Import (C, Internal, "g_variant_type_string_is_valid"); Tmp_Type_String : Gtkada.Types.Chars_Ptr := New_String (Type_String); Tmp_Return : Glib.Gboolean; begin Tmp_Return := Internal (Tmp_Type_String); Free (Tmp_Type_String); return Tmp_Return /= 0; end String_Is_Valid; end Glib.Variant; gtkada-24.0.0/src/generated/glib-variant.ads000066400000000000000000002021441446021174000206270ustar00rootroot00000000000000------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ -- -- Glib.Variant.Gvariant is a variant datatype; it stores a value along with -- information about the type of that value. The range of possible values is -- determined by the type. The type system used by Glib.Variant.Gvariant is -- Glib.Variant.Gvariant_Type. -- -- Glib.Variant.Gvariant instances always have a type and a value (which are -- given at construction time). The type and value of a Glib.Variant.Gvariant -- instance can never change other than by the Glib.Variant.Gvariant itself -- being destroyed. A Glib.Variant.Gvariant cannot contain a pointer. -- -- Glib.Variant.Gvariant is reference counted using Glib.Variant.Ref and -- Glib.Variant.Unref. Glib.Variant.Gvariant also has floating reference -- counts -- see Glib.Variant.Ref_Sink. -- -- Glib.Variant.Gvariant is completely threadsafe. A Glib.Variant.Gvariant -- instance can be concurrently accessed in any way from any number of threads -- without problems. -- -- Glib.Variant.Gvariant is heavily optimised for dealing with data in -- serialised form. It works particularly well with data located in -- memory-mapped files. It can perform nearly all deserialisation operations -- in a small constant time, usually touching only a single memory page. -- Serialised Glib.Variant.Gvariant data can also be sent over the network. -- -- Glib.Variant.Gvariant is largely compatible with D-Bus. Almost all types -- of Glib.Variant.Gvariant instances can be sent over D-Bus. See -- Glib.Variant.Gvariant_Type for exceptions. (However, -- Glib.Variant.Gvariant's serialisation format is not the same as the -- serialisation format of a D-Bus message body: use -- Gdbus.Message.Gdbus_Message, in the gio library, for those.) -- -- For space-efficiency, the Glib.Variant.Gvariant serialisation format does -- not automatically include the variant's length, type or endianness, which -- must either be implied from context (such as knowledge that a particular -- file format always contains a little-endian G_VARIANT_TYPE_VARIANT which -- occupies the whole length of the file) or supplied out-of-band (for -- instance, a length, type and/or endianness indicator could be placed at the -- beginning of a file, network message or network stream). -- -- A Glib.Variant.Gvariant's size is limited mainly by any lower level -- operating system constraints, such as the number of bits in Gsize. For -- example, it is reasonable to have a 2GB file mapped into memory with -- Gmapped.File.Gmapped_File, and call g_variant_new_from_data on it. -- -- For convenience to C programmers, Glib.Variant.Gvariant features powerful -- varargs-based value construction and destruction. This feature is designed -- to be embedded in other libraries. -- -- There is a Python-inspired text language for describing -- Glib.Variant.Gvariant values. Glib.Variant.Gvariant includes a printer for -- this language and a parser with type inferencing. -- -- ## Memory Use -- -- Glib.Variant.Gvariant tries to be quite efficient with respect to memory -- use. This section gives a rough idea of how much memory is used by the -- current implementation. The information here is subject to change in the -- future. -- -- The memory allocated by Glib.Variant.Gvariant can be grouped into 4 broad -- purposes: memory for serialised data, memory for the type information -- cache, buffer management memory and memory for the Glib.Variant.Gvariant -- structure itself. -- -- ## Serialised Data Memory -- -- This is the memory that is used for storing GVariant data in serialised -- form. This is what would be sent over the network or what would end up on -- disk, not counting any indicator of the endianness, or of the length or -- type of the top-level variant. -- -- The amount of memory required to store a boolean is 1 byte. 16, 32 and 64 -- bit integers and double precision floating point numbers use their -- "natural" size. Strings (including object path and signature strings) are -- stored with a nul terminator, and as such use the length of the string plus -- 1 byte. -- -- Maybe types use no space at all to represent the null value and use the -- same amount of space (sometimes plus one byte) as the equivalent -- non-maybe-typed value to represent the non-null case. -- -- Arrays use the amount of space required to store each of their members, -- concatenated. Additionally, if the items stored in an array are not of a -- fixed-size (ie: strings, other arrays, etc) then an additional framing -- offset is stored for each item. The size of this offset is either 1, 2 or 4 -- bytes depending on the overall size of the container. Additionally, extra -- padding bytes are added as required for alignment of child values. -- -- Tuples (including dictionary entries) use the amount of space required to -- store each of their members, concatenated, plus one framing offset (as per -- arrays) for each non-fixed-sized item in the tuple, except for the last -- one. Additionally, extra padding bytes are added as required for alignment -- of child values. -- -- Variants use the same amount of space as the item inside of the variant, -- plus 1 byte, plus the length of the type string for the item inside the -- variant. -- -- As an example, consider a dictionary mapping strings to variants. In the -- case that the dictionary is empty, 0 bytes are required for the -- serialisation. -- -- If we add an item "width" that maps to the int32 value of 500 then we will -- use 4 byte to store the int32 (so 6 for the variant containing it) and 6 -- bytes for the string. The variant must be aligned to 8 after the 6 bytes of -- the string, so that's 2 extra bytes. 6 (string) + 2 (padding) + 6 (variant) -- is 14 bytes used for the dictionary entry. An additional 1 byte is added to -- the array as a framing offset making a total of 15 bytes. -- -- If we add another entry, "title" that maps to a nullable string that -- happens to have a value of null, then we use 0 bytes for the null value -- (and 3 bytes for the variant to contain it along with its type string) plus -- 6 bytes for the string. Again, we need 2 padding bytes. That makes a total -- of 6 + 2 + 3 = 11 bytes. -- -- We now require extra padding between the two items in the array. After the -- 14 bytes of the first item, that's 2 bytes required. We now require 2 -- framing offsets for an extra two bytes. 14 + 2 + 11 + 2 = 29 bytes to -- encode the entire two-item dictionary. -- -- ## Type Information Cache -- -- For each GVariant type that currently exists in the program a type -- information structure is kept in the type information cache. The type -- information structure is required for rapid deserialisation. -- -- Continuing with the above example, if a Glib.Variant.Gvariant exists with -- the type "a{sv}" then a type information struct will exist for "a{sv}", -- "{sv}", "s", and "v". Multiple uses of the same type will share the same -- type information. Additionally, all single-digit types are stored in -- read-only static memory and do not contribute to the writable memory -- footprint of a program using Glib.Variant.Gvariant. -- -- Aside from the type information structures stored in read-only memory, -- there are two forms of type information. One is used for container types -- where there is a single element type: arrays and maybe types. The other is -- used for container types where there are multiple element types: tuples and -- dictionary entries. -- -- Array type info structures are 6 * sizeof (void *), plus the memory -- required to store the type string itself. This means that on 32-bit -- systems, the cache entry for "a{sv}" would require 30 bytes of memory (plus -- malloc overhead). -- -- Tuple type info structures are 6 * sizeof (void *), plus 4 * sizeof (void -- *) for each item in the tuple, plus the memory required to store the type -- string itself. A 2-item tuple, for example, would have a type information -- structure that consumed writable memory in the size of 14 * sizeof (void *) -- (plus type string) This means that on 32-bit systems, the cache entry for -- "{sv}" would require 61 bytes of memory (plus malloc overhead). -- -- This means that in total, for our "a{sv}" example, 91 bytes of type -- information would be allocated. -- -- The type information cache, additionally, uses a GHash_Table to store and -- lookup the cached items and stores a pointer to this hash table in static -- storage. The hash table is freed when there are zero items in the type -- cache. -- -- Although these sizes may seem large it is important to remember that a -- program will probably only have a very small number of different types of -- values in it and that only one type information structure is required for -- many different values of the same type. -- -- ## Buffer Management Memory -- -- Glib.Variant.Gvariant uses an internal buffer management structure to deal -- with the various different possible sources of serialised data that it -- uses. The buffer is responsible for ensuring that the correct call is made -- when the data is no longer in use by Glib.Variant.Gvariant. This may -- involve a g_free or a g_slice_free or even g_mapped_file_unref. -- -- One buffer management structure is used for each chunk of serialised data. -- The size of the buffer management structure is 4 * (void *). On 32-bit -- systems, that's 16 bytes. -- -- ## GVariant structure -- -- The size of a Glib.Variant.Gvariant structure is 6 * (void *). On 32-bit -- systems, that's 24 bytes. -- -- Glib.Variant.Gvariant structures only exist if they are explicitly created -- with API calls. For example, if a Glib.Variant.Gvariant is constructed out -- of serialised data for the example given above (with the dictionary) then -- although there are 9 individual values that comprise the entire dictionary -- (two keys, two values, two variants containing the values, two dictionary -- entries, plus the dictionary itself), only 1 Glib.Variant.Gvariant instance -- exists -- the one referring to the dictionary. -- -- If calls are made to start accessing the other values then -- Glib.Variant.Gvariant instances will exist for those values only for as -- long as they are in use (ie: until you call Glib.Variant.Unref). The type -- information is shared. The serialised data and the buffer management -- structure for that serialised data is shared by the child. -- -- ## Summary -- -- To put the entire example together, for our dictionary mapping strings to -- variants (with two entries, as given above), we are using 91 bytes of -- memory for type information, 29 byes of memory for the serialised data, 16 -- bytes for buffer management and 24 bytes for the Glib.Variant.Gvariant -- instance, or a total of 160 bytes, plus malloc overhead. If we were to use -- Glib.Variant.Get_Child_Value to access the two dictionary entries, we would -- use an additional 48 bytes. If we were to have other dictionaries of the -- same type, we would use more memory for the serialised data and buffer -- management for those dictionaries, but the type information would be -- shared. -- -- pragma Warnings (Off, "*is already use-visible*"); with GNAT.Strings; use GNAT.Strings; with Glib.Error; use Glib.Error; with Glib.Generic_Properties; use Glib.Generic_Properties; with Glib.String; use Glib.String; package Glib.Variant is type Gvariant is new Glib.C_Boxed with null record; Null_Gvariant : constant Gvariant; function From_Object (Object : System.Address) return Gvariant; function From_Object_Free (B : access Gvariant'Class) return Gvariant; pragma Inline (From_Object_Free, From_Object); type GVariant_Class is ( Class_Tuple, Class_Array, Class_Boolean, Class_Double, Class_Signature, Class_Handle, Class_Int32, Class_Maybe, Class_Int16, Class_Object_Path, Class_Uint16, Class_String, Class_Uint64, Class_Uint32, Class_Variant, Class_Int64, Class_Byte, Class_Dict_Entry); pragma Convention (C, GVariant_Class); -- The range of possible top-level types of Glib.Variant.Gvariant -- instances. for GVariant_Class use ( Class_Tuple => 40, Class_Array => 97, Class_Boolean => 98, Class_Double => 100, Class_Signature => 103, Class_Handle => 104, Class_Int32 => 105, Class_Maybe => 109, Class_Int16 => 110, Class_Object_Path => 111, Class_Uint16 => 113, Class_String => 115, Class_Uint64 => 116, Class_Uint32 => 117, Class_Variant => 118, Class_Int64 => 120, Class_Byte => 121, Class_Dict_Entry => 123); type Gvariant_Iter is new Glib.C_Proxy; type Gvariant_Type is new Glib.C_Proxy; ---------------------------- -- Enumeration Properties -- ---------------------------- package GVariant_Class_Properties is new Generic_Internal_Discrete_Property (GVariant_Class); type Property_GVariant_Class is new GVariant_Class_Properties.Property; ------------------ -- Constructors -- ------------------ procedure G_New_Boolean (Self : out Gvariant; Value : Boolean); -- Creates a new boolean Glib.Variant.Gvariant instance -- either True or -- False. -- Since: gtk+ 2.24 -- "value": a Boolean value function Gvariant_New_Boolean (Value : Boolean) return Gvariant; -- Creates a new boolean Glib.Variant.Gvariant instance -- either True or -- False. -- Since: gtk+ 2.24 -- "value": a Boolean value procedure G_New_Byte (Self : out Gvariant; Value : Guchar); -- Creates a new byte Glib.Variant.Gvariant instance. -- Since: gtk+ 2.24 -- "value": a Guint8 value function Gvariant_New_Byte (Value : Guchar) return Gvariant; -- Creates a new byte Glib.Variant.Gvariant instance. -- Since: gtk+ 2.24 -- "value": a Guint8 value procedure G_New_Bytestring (Self : out Gvariant; String : Gint_Array); -- Creates an array-of-bytes Glib.Variant.Gvariant with the contents of -- String. This function is just like g_variant_new_string except that the -- string need not be valid utf8. -- The nul terminator character at the end of the string is stored in the -- array. -- Since: gtk+ 2.26 -- "string": a normal nul-terminated string in no particular encoding function Gvariant_New_Bytestring (String : Gint_Array) return Gvariant; -- Creates an array-of-bytes Glib.Variant.Gvariant with the contents of -- String. This function is just like g_variant_new_string except that the -- string need not be valid utf8. -- The nul terminator character at the end of the string is stored in the -- array. -- Since: gtk+ 2.26 -- "string": a normal nul-terminated string in no particular encoding procedure G_New_Bytestring_Array (Self : out Gvariant; Strv : GNAT.Strings.String_List; Length : Gssize); -- Constructs an array of bytestring Glib.Variant.Gvariant from the given -- array of strings. -- If Length is -1 then Strv is null-terminated. -- Since: gtk+ 2.26 -- "strv": an array of strings -- "length": the length of Strv, or -1 function Gvariant_New_Bytestring_Array (Strv : GNAT.Strings.String_List; Length : Gssize) return Gvariant; -- Constructs an array of bytestring Glib.Variant.Gvariant from the given -- array of strings. -- If Length is -1 then Strv is null-terminated. -- Since: gtk+ 2.26 -- "strv": an array of strings -- "length": the length of Strv, or -1 procedure G_New_Dict_Entry (Self : out Gvariant; Key : Gvariant; Value : Gvariant); -- Creates a new dictionary entry Glib.Variant.Gvariant. Key and Value -- must be non-null. Key must be a value of a basic type (ie: not a -- container). -- If the Key or Value are floating references (see -- Glib.Variant.Ref_Sink), the new instance takes ownership of them as if -- via Glib.Variant.Ref_Sink. -- Since: gtk+ 2.24 -- "key": a basic Glib.Variant.Gvariant, the key -- "value": a Glib.Variant.Gvariant, the value procedure G_New_Dict_Entry (Self : out Gvariant_Type; Key : Gvariant_Type; Value : Gvariant_Type); -- Constructs the type corresponding to a dictionary entry with a key of -- type Key and a value of type Value. -- It is appropriate to call Glib.Variant.Free on the return value. -- "key": a basic Glib.Variant.Gvariant_Type -- "value": a Glib.Variant.Gvariant_Type function Gvariant_New_Dict_Entry (Key : Gvariant; Value : Gvariant) return Gvariant; -- Creates a new dictionary entry Glib.Variant.Gvariant. Key and Value -- must be non-null. Key must be a value of a basic type (ie: not a -- container). -- If the Key or Value are floating references (see -- Glib.Variant.Ref_Sink), the new instance takes ownership of them as if -- via Glib.Variant.Ref_Sink. -- Since: gtk+ 2.24 -- "key": a basic Glib.Variant.Gvariant, the key -- "value": a Glib.Variant.Gvariant, the value procedure G_New_Double (Self : out Gvariant; Value : Gdouble); -- Creates a new double Glib.Variant.Gvariant instance. -- Since: gtk+ 2.24 -- "value": a Gdouble floating point value function Gvariant_New_Double (Value : Gdouble) return Gvariant; -- Creates a new double Glib.Variant.Gvariant instance. -- Since: gtk+ 2.24 -- "value": a Gdouble floating point value procedure G_New_Handle (Self : out Gvariant; Value : Gint32); -- Creates a new handle Glib.Variant.Gvariant instance. -- By convention, handles are indexes into an array of file descriptors -- that are sent alongside a D-Bus message. If you're not interacting with -- D-Bus, you probably don't need them. -- Since: gtk+ 2.24 -- "value": a Gint32 value function Gvariant_New_Handle (Value : Gint32) return Gvariant; -- Creates a new handle Glib.Variant.Gvariant instance. -- By convention, handles are indexes into an array of file descriptors -- that are sent alongside a D-Bus message. If you're not interacting with -- D-Bus, you probably don't need them. -- Since: gtk+ 2.24 -- "value": a Gint32 value procedure G_New_Int16 (Self : out Gvariant; Value : Gint16); -- Creates a new int16 Glib.Variant.Gvariant instance. -- Since: gtk+ 2.24 -- "value": a Gint16 value function Gvariant_New_Int16 (Value : Gint16) return Gvariant; -- Creates a new int16 Glib.Variant.Gvariant instance. -- Since: gtk+ 2.24 -- "value": a Gint16 value procedure G_New_Int32 (Self : out Gvariant; Value : Gint32); -- Creates a new int32 Glib.Variant.Gvariant instance. -- Since: gtk+ 2.24 -- "value": a Gint32 value function Gvariant_New_Int32 (Value : Gint32) return Gvariant; -- Creates a new int32 Glib.Variant.Gvariant instance. -- Since: gtk+ 2.24 -- "value": a Gint32 value procedure G_New_Int64 (Self : out Gvariant; Value : Gint64); -- Creates a new int64 Glib.Variant.Gvariant instance. -- Since: gtk+ 2.24 -- "value": a Gint64 value function Gvariant_New_Int64 (Value : Gint64) return Gvariant; -- Creates a new int64 Glib.Variant.Gvariant instance. -- Since: gtk+ 2.24 -- "value": a Gint64 value procedure G_New_Object_Path (Self : out Gvariant; Object_Path : UTF8_String); -- Creates a D-Bus object path Glib.Variant.Gvariant with the contents of -- String. String must be a valid D-Bus object path. Use -- Glib.Variant.Is_Object_Path if you're not sure. -- Since: gtk+ 2.24 -- "object_path": a normal C nul-terminated string function Gvariant_New_Object_Path (Object_Path : UTF8_String) return Gvariant; -- Creates a D-Bus object path Glib.Variant.Gvariant with the contents of -- String. String must be a valid D-Bus object path. Use -- Glib.Variant.Is_Object_Path if you're not sure. -- Since: gtk+ 2.24 -- "object_path": a normal C nul-terminated string procedure G_New_Objv (Self : out Gvariant; Strv : GNAT.Strings.String_List; Length : Gssize); -- Constructs an array of object paths Glib.Variant.Gvariant from the -- given array of strings. -- Each string must be a valid Glib.Variant.Gvariant object path; see -- Glib.Variant.Is_Object_Path. -- If Length is -1 then Strv is null-terminated. -- Since: gtk+ 2.30 -- "strv": an array of strings -- "length": the length of Strv, or -1 function Gvariant_New_Objv (Strv : GNAT.Strings.String_List; Length : Gssize) return Gvariant; -- Constructs an array of object paths Glib.Variant.Gvariant from the -- given array of strings. -- Each string must be a valid Glib.Variant.Gvariant object path; see -- Glib.Variant.Is_Object_Path. -- If Length is -1 then Strv is null-terminated. -- Since: gtk+ 2.30 -- "strv": an array of strings -- "length": the length of Strv, or -1 procedure G_New_Signature (Self : out Gvariant; Signature : UTF8_String); -- Creates a D-Bus type signature Glib.Variant.Gvariant with the contents -- of String. String must be a valid D-Bus type signature. Use -- Glib.Variant.Is_Signature if you're not sure. -- Since: gtk+ 2.24 -- "signature": a normal C nul-terminated string function Gvariant_New_Signature (Signature : UTF8_String) return Gvariant; -- Creates a D-Bus type signature Glib.Variant.Gvariant with the contents -- of String. String must be a valid D-Bus type signature. Use -- Glib.Variant.Is_Signature if you're not sure. -- Since: gtk+ 2.24 -- "signature": a normal C nul-terminated string procedure G_New_String (Self : out Gvariant; String : UTF8_String); -- Creates a string Glib.Variant.Gvariant with the contents of String. -- String must be valid utf8. -- Since: gtk+ 2.24 -- "string": a normal utf8 nul-terminated string function Gvariant_New_String (String : UTF8_String) return Gvariant; -- Creates a string Glib.Variant.Gvariant with the contents of String. -- String must be valid utf8. -- Since: gtk+ 2.24 -- "string": a normal utf8 nul-terminated string procedure G_New_Strv (Self : out Gvariant; Strv : GNAT.Strings.String_List; Length : Gssize); -- Constructs an array of strings Glib.Variant.Gvariant from the given -- array of strings. -- If Length is -1 then Strv is null-terminated. -- Since: gtk+ 2.24 -- "strv": an array of strings -- "length": the length of Strv, or -1 function Gvariant_New_Strv (Strv : GNAT.Strings.String_List; Length : Gssize) return Gvariant; -- Constructs an array of strings Glib.Variant.Gvariant from the given -- array of strings. -- If Length is -1 then Strv is null-terminated. -- Since: gtk+ 2.24 -- "strv": an array of strings -- "length": the length of Strv, or -1 procedure G_New_Take_String (Self : out Gvariant; String : UTF8_String); -- Creates a string Glib.Variant.Gvariant with the contents of String. -- String must be valid utf8. -- This function consumes String. g_free will be called on String when it -- is no longer required. -- You must not modify or access String in any other way after passing it -- to this function. It is even possible that String is immediately freed. -- Since: gtk+ 2.38 -- "string": a normal utf8 nul-terminated string function Gvariant_New_Take_String (String : UTF8_String) return Gvariant; -- Creates a string Glib.Variant.Gvariant with the contents of String. -- String must be valid utf8. -- This function consumes String. g_free will be called on String when it -- is no longer required. -- You must not modify or access String in any other way after passing it -- to this function. It is even possible that String is immediately freed. -- Since: gtk+ 2.38 -- "string": a normal utf8 nul-terminated string procedure G_New_Uint16 (Self : out Gvariant; Value : Guint16); -- Creates a new uint16 Glib.Variant.Gvariant instance. -- Since: gtk+ 2.24 -- "value": a Guint16 value function Gvariant_New_Uint16 (Value : Guint16) return Gvariant; -- Creates a new uint16 Glib.Variant.Gvariant instance. -- Since: gtk+ 2.24 -- "value": a Guint16 value procedure G_New_Uint32 (Self : out Gvariant; Value : Guint32); -- Creates a new uint32 Glib.Variant.Gvariant instance. -- Since: gtk+ 2.24 -- "value": a Guint32 value function Gvariant_New_Uint32 (Value : Guint32) return Gvariant; -- Creates a new uint32 Glib.Variant.Gvariant instance. -- Since: gtk+ 2.24 -- "value": a Guint32 value procedure G_New_Uint64 (Self : out Gvariant; Value : Guint64); -- Creates a new uint64 Glib.Variant.Gvariant instance. -- Since: gtk+ 2.24 -- "value": a Guint64 value function Gvariant_New_Uint64 (Value : Guint64) return Gvariant; -- Creates a new uint64 Glib.Variant.Gvariant instance. -- Since: gtk+ 2.24 -- "value": a Guint64 value procedure G_New_Variant (Self : out Gvariant; Value : Gvariant); -- Boxes Value. The result is a Glib.Variant.Gvariant instance -- representing a variant containing the original value. -- If Child is a floating reference (see Glib.Variant.Ref_Sink), the new -- instance takes ownership of Child. -- Since: gtk+ 2.24 -- "value": a Glib.Variant.Gvariant instance function Gvariant_New_Variant (Value : Gvariant) return Gvariant; -- Boxes Value. The result is a Glib.Variant.Gvariant instance -- representing a variant containing the original value. -- If Child is a floating reference (see Glib.Variant.Ref_Sink), the new -- instance takes ownership of Child. -- Since: gtk+ 2.24 -- "value": a Glib.Variant.Gvariant instance procedure G_New (Self : out Gvariant_Type; Type_String : UTF8_String); -- Creates a new Glib.Variant.Gvariant_Type corresponding to the type -- string given by Type_String. It is appropriate to call Glib.Variant.Free -- on the return value. -- It is a programmer error to call this function with an invalid type -- string. Use Glib.Variant.String_Is_Valid if you are unsure. -- Since: gtk+ 2.24 -- "type_string": a valid GVariant type string function Gvariant_Type_New (Type_String : UTF8_String) return Gvariant_Type; -- Creates a new Glib.Variant.Gvariant_Type corresponding to the type -- string given by Type_String. It is appropriate to call Glib.Variant.Free -- on the return value. -- It is a programmer error to call this function with an invalid type -- string. Use Glib.Variant.String_Is_Valid if you are unsure. -- Since: gtk+ 2.24 -- "type_string": a valid GVariant type string function Gvariant_Type_New_Dict_Entry (Key : Gvariant_Type; Value : Gvariant_Type) return Gvariant_Type; -- Constructs the type corresponding to a dictionary entry with a key of -- type Key and a value of type Value. -- It is appropriate to call Glib.Variant.Free on the return value. -- "key": a basic Glib.Variant.Gvariant_Type -- "value": a Glib.Variant.Gvariant_Type function Get_Type return Glib.GType; pragma Import (C, Get_Type, "g_variant_type_get_gtype"); ------------- -- Methods -- ------------- function Byteswap (Self : Gvariant) return Gvariant; -- Performs a byteswapping operation on the contents of Value. The result -- is that all multi-byte numeric data contained in Value is byteswapped. -- That includes 16, 32, and 64bit signed and unsigned integers as well as -- file handles and double precision floating point values. -- This function is an identity mapping on any value that does not contain -- multi-byte numeric data. That include strings, booleans, bytes and -- containers containing only these things (recursively). -- The returned value is always in normal form and is marked as trusted. -- Since: gtk+ 2.24 function Check_Format_String (Self : Gvariant; Format_String : UTF8_String; Copy_Only : Boolean) return Boolean; -- Checks if calling g_variant_get with Format_String on Value would be -- valid from a type-compatibility standpoint. Format_String is assumed to -- be a valid format string (from a syntactic standpoint). -- If Copy_Only is True then this function additionally checks that it -- would be safe to call Glib.Variant.Unref on Value immediately after the -- call to g_variant_get without invalidating the result. This is only -- possible if deep copies are made (ie: there are no pointers to the data -- inside of the soon-to-be-freed Glib.Variant.Gvariant instance). If this -- check fails then a g_critical is printed and False is returned. -- This function is meant to be used by functions that wish to provide -- varargs accessors to Glib.Variant.Gvariant values of uncertain values -- (eg: g_variant_lookup or g_menu_model_get_item_attribute). -- Since: gtk+ 2.34 -- "format_string": a valid Glib.Variant.Gvariant format string -- "copy_only": True to ensure the format string makes deep copies function Classify (Self : Gvariant) return GVariant_Class; -- Classifies Value according to its top-level type. -- Since: gtk+ 2.24 function Dup_Bytestring_Array (Self : Gvariant; Length : access Gsize) return GNAT.Strings.String_List; -- Gets the contents of an array of array of bytes Glib.Variant.Gvariant. -- This call makes a deep copy; the return result should be released with -- g_strfreev. -- If Length is non-null then the number of elements in the result is -- stored there. In any case, the resulting array will be null-terminated. -- For an empty array, Length will be set to 0 and a pointer to a null -- pointer will be returned. -- Since: gtk+ 2.26 -- "length": the length of the result, or null function Dup_Objv (Self : Gvariant; Length : access Gsize) return GNAT.Strings.String_List; -- Gets the contents of an array of object paths Glib.Variant.Gvariant. -- This call makes a deep copy; the return result should be released with -- g_strfreev. -- If Length is non-null then the number of elements in the result is -- stored there. In any case, the resulting array will be null-terminated. -- For an empty array, Length will be set to 0 and a pointer to a null -- pointer will be returned. -- Since: gtk+ 2.30 -- "length": the length of the result, or null function Dup_String (Self : Gvariant; Length : access Gsize) return UTF8_String; -- Similar to Glib.Variant.Get_String except that instead of returning a -- constant string, the string is duplicated. -- The string will always be utf8 encoded. -- The return value must be freed using g_free. -- Since: gtk+ 2.24 -- "length": a pointer to a Gsize, to store the length function Dup_String (Self : Gvariant_Type) return UTF8_String; -- Returns a newly-allocated copy of the type string corresponding to -- Type. The returned string is nul-terminated. It is appropriate to call -- g_free on the return value. function Dup_Strv (Self : Gvariant; Length : access Gsize) return GNAT.Strings.String_List; -- Gets the contents of an array of strings Glib.Variant.Gvariant. This -- call makes a deep copy; the return result should be released with -- g_strfreev. -- If Length is non-null then the number of elements in the result is -- stored there. In any case, the resulting array will be null-terminated. -- For an empty array, Length will be set to 0 and a pointer to a null -- pointer will be returned. -- Since: gtk+ 2.24 -- "length": the length of the result, or null function Get_Boolean (Self : Gvariant) return Boolean; -- Returns the boolean value of Value. -- It is an error to call this function with a Value of any type other -- than G_VARIANT_TYPE_BOOLEAN. -- Since: gtk+ 2.24 function Get_Byte (Self : Gvariant) return Guchar; -- Returns the byte value of Value. -- It is an error to call this function with a Value of any type other -- than G_VARIANT_TYPE_BYTE. -- Since: gtk+ 2.24 function Get_Bytestring_Array (Self : Gvariant; Length : access Gsize) return GNAT.Strings.String_List; -- Gets the contents of an array of array of bytes Glib.Variant.Gvariant. -- This call makes a shallow copy; the return result should be released -- with g_free, but the individual strings must not be modified. -- If Length is non-null then the number of elements in the result is -- stored there. In any case, the resulting array will be null-terminated. -- For an empty array, Length will be set to 0 and a pointer to a null -- pointer will be returned. -- Since: gtk+ 2.26 -- "length": the length of the result, or null function Get_Child_Value (Self : Gvariant; Index : Gsize) return Gvariant; -- Reads a child item out of a container Glib.Variant.Gvariant instance. -- This includes variants, maybes, arrays, tuples and dictionary entries. -- It is an error to call this function on any other type of -- Glib.Variant.Gvariant. -- It is an error if Index_ is greater than the number of child items in -- the container. See Glib.Variant.N_Children. -- The returned value is never floating. You should free it with -- Glib.Variant.Unref when you're done with it. -- This function is O(1). -- Since: gtk+ 2.24 -- "index_": the index of the child to fetch function Get_Double (Self : Gvariant) return Gdouble; -- Returns the double precision floating point value of Value. -- It is an error to call this function with a Value of any type other -- than G_VARIANT_TYPE_DOUBLE. -- Since: gtk+ 2.24 function Get_Handle (Self : Gvariant) return Gint32; -- Returns the 32-bit signed integer value of Value. -- It is an error to call this function with a Value of any type other -- than G_VARIANT_TYPE_HANDLE. -- By convention, handles are indexes into an array of file descriptors -- that are sent alongside a D-Bus message. If you're not interacting with -- D-Bus, you probably don't need them. -- Since: gtk+ 2.24 function Get_Int16 (Self : Gvariant) return Gint16; -- Returns the 16-bit signed integer value of Value. -- It is an error to call this function with a Value of any type other -- than G_VARIANT_TYPE_INT16. -- Since: gtk+ 2.24 function Get_Int32 (Self : Gvariant) return Gint32; -- Returns the 32-bit signed integer value of Value. -- It is an error to call this function with a Value of any type other -- than G_VARIANT_TYPE_INT32. -- Since: gtk+ 2.24 function Get_Int64 (Self : Gvariant) return Gint64; -- Returns the 64-bit signed integer value of Value. -- It is an error to call this function with a Value of any type other -- than G_VARIANT_TYPE_INT64. -- Since: gtk+ 2.24 function Get_Maybe (Self : Gvariant) return Gvariant; -- Given a maybe-typed Glib.Variant.Gvariant instance, extract its value. -- If the value is Nothing, then this function returns null. -- Since: gtk+ 2.24 function Get_Normal_Form (Self : Gvariant) return Gvariant; -- Gets a Glib.Variant.Gvariant instance that has the same value as Value -- and is trusted to be in normal form. -- If Value is already trusted to be in normal form then a new reference -- to Value is returned. -- If Value is not already trusted, then it is scanned to check if it is -- in normal form. If it is found to be in normal form then it is marked as -- trusted and a new reference to it is returned. -- If Value is found not to be in normal form then a new trusted -- Glib.Variant.Gvariant is created with the same value as Value. -- It makes sense to call this function if you've received -- Glib.Variant.Gvariant data from untrusted sources and you want to ensure -- your serialised output is definitely in normal form. -- Since: gtk+ 2.24 function Get_Objv (Self : Gvariant; Length : access Gsize) return GNAT.Strings.String_List; -- Gets the contents of an array of object paths Glib.Variant.Gvariant. -- This call makes a shallow copy; the return result should be released -- with g_free, but the individual strings must not be modified. -- If Length is non-null then the number of elements in the result is -- stored there. In any case, the resulting array will be null-terminated. -- For an empty array, Length will be set to 0 and a pointer to a null -- pointer will be returned. -- Since: gtk+ 2.30 -- "length": the length of the result, or null function Get_Size (Self : Gvariant) return Gsize; -- Determines the number of bytes that would be required to store Value -- with Glib.Variant.Store. -- If Value has a fixed-sized type then this function always returned that -- fixed size. -- In the case that Value is already in serialised form or the size has -- already been calculated (ie: this function has been called before) then -- this function is O(1). Otherwise, the size is calculated, an operation -- which is approximately O(n) in the number of values involved. -- Since: gtk+ 2.24 function Get_String (Self : Gvariant; Length : access Gsize) return UTF8_String; -- Returns the string value of a Glib.Variant.Gvariant instance with a -- string type. This includes the types G_VARIANT_TYPE_STRING, -- G_VARIANT_TYPE_OBJECT_PATH and G_VARIANT_TYPE_SIGNATURE. -- The string will always be utf8 encoded. -- If Length is non-null then the length of the string (in bytes) is -- returned there. For trusted values, this information is already known. -- For untrusted values, a strlen will be performed. -- It is an error to call this function with a Value of any type other -- than those three. -- The return value remains valid as long as Value exists. -- Since: gtk+ 2.24 -- "length": a pointer to a Gsize, to store the length function Get_Strv (Self : Gvariant; Length : access Gsize) return GNAT.Strings.String_List; -- Gets the contents of an array of strings Glib.Variant.Gvariant. This -- call makes a shallow copy; the return result should be released with -- g_free, but the individual strings must not be modified. -- If Length is non-null then the number of elements in the result is -- stored there. In any case, the resulting array will be null-terminated. -- For an empty array, Length will be set to 0 and a pointer to a null -- pointer will be returned. -- Since: gtk+ 2.24 -- "length": the length of the result, or null function Get_Type (Self : Gvariant) return Gvariant_Type; -- Determines the type of Value. -- The return value is valid for the lifetime of Value and must not be -- freed. -- Since: gtk+ 2.24 function Get_Type_String (Self : Gvariant) return UTF8_String; -- Returns the type string of Value. Unlike the result of calling -- Glib.Variant.Peek_String, this string is nul-terminated. This string -- belongs to Glib.Variant.Gvariant and must not be freed. -- Since: gtk+ 2.24 function Get_Uint16 (Self : Gvariant) return Guint16; -- Returns the 16-bit unsigned integer value of Value. -- It is an error to call this function with a Value of any type other -- than G_VARIANT_TYPE_UINT16. -- Since: gtk+ 2.24 function Get_Uint32 (Self : Gvariant) return Guint32; -- Returns the 32-bit unsigned integer value of Value. -- It is an error to call this function with a Value of any type other -- than G_VARIANT_TYPE_UINT32. -- Since: gtk+ 2.24 function Get_Uint64 (Self : Gvariant) return Guint64; -- Returns the 64-bit unsigned integer value of Value. -- It is an error to call this function with a Value of any type other -- than G_VARIANT_TYPE_UINT64. -- Since: gtk+ 2.24 function Get_Variant (Self : Gvariant) return Gvariant; -- Unboxes Value. The result is the Glib.Variant.Gvariant instance that -- was contained in Value. -- Since: gtk+ 2.24 function Hash (Self : Gvariant) return Guint; -- Generates a hash value for a Glib.Variant.Gvariant instance. -- The output of this function is guaranteed to be the same for a given -- value only per-process. It may change between different processor -- architectures or even different versions of GLib. Do not use this -- function as a basis for building protocols or file formats. -- The type of Value is gconstpointer only to allow use of this function -- with GHash_Table. Value must be a Glib.Variant.Gvariant. -- Since: gtk+ 2.24 function Is_Container (Self : Gvariant) return Boolean; -- Checks if Value is a container. -- Since: gtk+ 2.24 function Is_Container (Self : Gvariant_Type) return Boolean; -- Determines if the given Type is a container type. -- Container types are any array, maybe, tuple, or dictionary entry types -- plus the variant type. -- This function returns True for any indefinite type for which every -- definite subtype is a container -- G_VARIANT_TYPE_ARRAY, for example. function Is_Floating (Self : Gvariant) return Boolean; -- Checks whether Value has a floating reference count. -- This function should only ever be used to assert that a given variant -- is or is not floating, or for debug purposes. To acquire a reference to -- a variant that might be floating, always use Glib.Variant.Ref_Sink or -- Glib.Variant.Take_Ref. -- See Glib.Variant.Ref_Sink for more information about floating reference -- counts. -- Since: gtk+ 2.26 function Is_Normal_Form (Self : Gvariant) return Boolean; -- Checks if Value is in normal form. -- The main reason to do this is to detect if a given chunk of serialised -- data is in normal form: load the data into a Glib.Variant.Gvariant using -- g_variant_new_from_data and then use this function to check. -- If Value is found to be in normal form then it will be marked as being -- trusted. If the value was already marked as being trusted then this -- function will immediately return True. -- Since: gtk+ 2.24 function Is_Of_Type (Self : Gvariant; The_Type : Gvariant_Type) return Boolean; -- Checks if a value has a type matching the provided type. -- Since: gtk+ 2.24 -- "type": a Glib.Variant.Gvariant_Type function Iter_New (Self : Gvariant) return Gvariant_Iter; -- Creates a heap-allocated Glib.Variant.Gvariant_Iter for iterating over -- the items in Value. -- Use g_variant_iter_free to free the return value when you no longer -- need it. -- A reference is taken to Value and will be released only when -- g_variant_iter_free is called. -- Since: gtk+ 2.24 function Lookup_Value (Self : Gvariant; Key : UTF8_String; Expected_Type : Gvariant_Type) return Gvariant; -- Looks up a value in a dictionary Glib.Variant.Gvariant. -- This function works with dictionaries of the type a{s*} (and equally -- well with type a{o*}, but we only further discuss the string case for -- sake of clarity). -- In the event that Dictionary has the type a{sv}, the Expected_Type -- string specifies what type of value is expected to be inside of the -- variant. If the value inside the variant has a different type then null -- is returned. In the event that Dictionary has a value type other than v -- then Expected_Type must directly match the key type and it is used to -- unpack the value directly or an error occurs. -- In either case, if Key is not found in Dictionary, null is returned. -- If the key is found and the value has the correct type, it is returned. -- If Expected_Type was specified then any non-null return value will have -- this type. -- This function is currently implemented with a linear scan. If you plan -- to do many lookups then Gvariant.Dict.Gvariant_Dict may be more -- efficient. -- Since: gtk+ 2.28 -- "key": the key to lookup in the dictionary -- "expected_type": a Glib.Variant.Gvariant_Type, or null function N_Children (Self : Gvariant) return Gsize; -- Determines the number of children in a container Glib.Variant.Gvariant -- instance. This includes variants, maybes, arrays, tuples and dictionary -- entries. It is an error to call this function on any other type of -- Glib.Variant.Gvariant. -- For variants, the return value is always 1. For values with maybe -- types, it is always zero or one. For arrays, it is the length of the -- array. For tuples it is the number of tuple items (which depends only on -- the type). For dictionary entries, it is always 2 -- This function is O(1). -- Since: gtk+ 2.24 function Print (Self : Gvariant; Type_Annotate : Boolean) return UTF8_String; -- Pretty-prints Value in the format understood by Glib.Variant.Parse. -- The format is described [here][gvariant-text]. -- If Type_Annotate is True, then type information is included in the -- output. -- Since: gtk+ 2.24 -- "type_annotate": True if type information should be included in the -- output function Print_String (Self : Gvariant; String : Glib.String.Gstring; Type_Annotate : Boolean) return Glib.String.Gstring; -- Behaves as Glib.Variant.Print, but operates on a Glib.String.Gstring. -- If String is non-null then it is appended to and returned. Else, a new -- empty Glib.String.Gstring is allocated and it is returned. -- Since: gtk+ 2.24 -- "string": a Glib.String.Gstring, or null -- "type_annotate": True if type information should be included in the -- output function Ref (Self : Gvariant) return Gvariant; -- Increases the reference count of Value. -- Since: gtk+ 2.24 function Ref_Sink (Self : Gvariant) return Gvariant; -- Glib.Variant.Gvariant uses a floating reference count system. All -- functions with names starting with `g_variant_new_` return floating -- references. -- Calling Glib.Variant.Ref_Sink on a Glib.Variant.Gvariant with a -- floating reference will convert the floating reference into a full -- reference. Calling Glib.Variant.Ref_Sink on a non-floating -- Glib.Variant.Gvariant results in an additional normal reference being -- added. -- In other words, if the Value is floating, then this call "assumes -- ownership" of the floating reference, converting it to a normal -- reference. If the Value is not floating, then this call adds a new -- normal reference increasing the reference count by one. -- All calls that result in a Glib.Variant.Gvariant instance being -- inserted into a container will call Glib.Variant.Ref_Sink on the -- instance. This means that if the value was just created (and has only -- its floating reference) then the container will assume sole ownership of -- the value at that point and the caller will not need to unreference it. -- This makes certain common styles of programming much easier while still -- maintaining normal refcounting semantics in situations where values are -- not floating. -- Since: gtk+ 2.24 procedure Store (Self : Gvariant; Data : System.Address); -- Stores the serialised form of Value at Data. Data should be large -- enough. See Glib.Variant.Get_Size. -- The stored data is in machine native byte order but may not be in -- fully-normalised form if read from an untrusted source. See -- Glib.Variant.Get_Normal_Form for a solution. -- As with g_variant_get_data, to be able to deserialise the serialised -- variant successfully, its type and (if the destination machine might be -- different) its endianness must also be available. -- This function is approximately O(n) in the size of Data. -- Since: gtk+ 2.24 -- "data": the location to store the serialised data at function Take_Ref (Self : Gvariant) return Gvariant; -- If Value is floating, sink it. Otherwise, do nothing. -- Typically you want to use Glib.Variant.Ref_Sink in order to -- automatically do the correct thing with respect to floating or -- non-floating references, but there is one specific scenario where this -- function is helpful. -- The situation where this function is helpful is when creating an API -- that allows the user to provide a callback function that returns a -- Glib.Variant.Gvariant. We certainly want to allow the user the -- flexibility to return a non-floating reference from this callback (for -- the case where the value that is being returned already exists). -- At the same time, the style of the Glib.Variant.Gvariant API makes it -- likely that for newly-created Glib.Variant.Gvariant instances, the user -- can be saved some typing if they are allowed to return a -- Glib.Variant.Gvariant with a floating reference. -- Using this function on the return value of the user's callback allows -- the user to do whichever is more convenient for them. The caller will -- alway receives exactly one full reference to the value: either the one -- that was returned in the first place, or a floating reference that has -- been converted to a full reference. -- This function has an odd interaction when combined with -- Glib.Variant.Ref_Sink running at the same time in another thread on the -- same Glib.Variant.Gvariant instance. If Glib.Variant.Ref_Sink runs first -- then the result will be that the floating reference is converted to a -- hard reference. If Glib.Variant.Take_Ref runs first then the result will -- be that the floating reference is converted to a hard reference and an -- additional reference on top of that one is added. It is best to avoid -- this situation. procedure Unref (Self : Gvariant); -- Decreases the reference count of Value. When its reference count drops -- to 0, the memory used by the variant is freed. -- Since: gtk+ 2.24 function Init (Self : Gvariant_Iter; Value : Gvariant) return Gsize; -- Initialises (without allocating) a Glib.Variant.Gvariant_Iter. Iter may -- be completely uninitialised prior to this call; its old value is -- ignored. -- The iterator remains valid for as long as Value exists, and need not be -- freed in any way. -- Since: gtk+ 2.24 -- "value": a container Glib.Variant.Gvariant function Next_Value (Self : Gvariant_Iter) return Gvariant; -- Gets the next item in the container. If no more items remain then null -- is returned. -- Use Glib.Variant.Unref to drop your reference on the return value when -- you no longer need it. -- Here is an example for iterating with Glib.Variant.Next_Value: |[ // recursively iterate a container void -- iterate_container_recursive (GVariant *container) { GVariantIter iter; -- GVariant *child; -- g_variant_iter_init (&iter, container); while ((child = -- g_variant_iter_next_value (&iter))) { g_print ("type '%s'\n", -- g_variant_get_type_string (child)); -- if (g_variant_is_container (child)) iterate_container_recursive -- (child); -- g_variant_unref (child); } } ]| -- Since: gtk+ 2.24 function Copy (Self : Gvariant_Type) return Gvariant_Type; pragma Import (C, Copy, "g_variant_type_copy"); -- Makes a copy of a Glib.Variant.Gvariant_Type. It is appropriate to call -- Glib.Variant.Free on the return value. Type may not be null. function Element (Self : Gvariant_Type) return Gvariant_Type; pragma Import (C, Element, "g_variant_type_element"); -- Determines the element type of an array or maybe type. -- This function may only be used with array or maybe types. function First (Self : Gvariant_Type) return Gvariant_Type; pragma Import (C, First, "g_variant_type_first"); -- Determines the first item type of a tuple or dictionary entry type. -- This function may only be used with tuple or dictionary entry types, -- but must not be used with the generic tuple type G_VARIANT_TYPE_TUPLE. -- In the case of a dictionary entry type, this returns the type of the -- key. -- null is returned in case of Type being G_VARIANT_TYPE_UNIT. -- This call, together with Glib.Variant.Next provides an iterator -- interface over tuple and dictionary entry types. procedure Free (Self : Gvariant_Type); pragma Import (C, Free, "g_variant_type_free"); -- Frees a Glib.Variant.Gvariant_Type that was allocated with -- Glib.Variant.Copy, g_variant_type_new or one of the container type -- constructor functions. -- In the case that Type is null, this function does nothing. -- Since 2.24 function Get_String_Length (Self : Gvariant_Type) return Gsize; pragma Import (C, Get_String_Length, "g_variant_type_get_string_length"); -- Returns the length of the type string corresponding to the given Type. -- This function must be used to determine the valid extent of the memory -- region returned by Glib.Variant.Peek_String. function Is_Array (Self : Gvariant_Type) return Boolean; -- Determines if the given Type is an array type. This is true if the type -- string for Type starts with an 'a'. -- This function returns True for any indefinite type for which every -- definite subtype is an array type -- G_VARIANT_TYPE_ARRAY, for example. function Is_Basic (Self : Gvariant_Type) return Boolean; -- Determines if the given Type is a basic type. -- Basic types are booleans, bytes, integers, doubles, strings, object -- paths and signatures. -- Only a basic type may be used as the key of a dictionary entry. -- This function returns False for all indefinite types except -- G_VARIANT_TYPE_BASIC. function Is_Definite (Self : Gvariant_Type) return Boolean; -- Determines if the given Type is definite (ie: not indefinite). -- A type is definite if its type string does not contain any indefinite -- type characters ('*', '?', or 'r'). -- A Glib.Variant.Gvariant instance may not have an indefinite type, so -- calling this function on the result of Glib.Variant.Get_Type will always -- result in True being returned. Calling this function on an indefinite -- type like G_VARIANT_TYPE_ARRAY, however, will result in False being -- returned. function Is_Dict_Entry (Self : Gvariant_Type) return Boolean; -- Determines if the given Type is a dictionary entry type. This is true -- if the type string for Type starts with a '{'. -- This function returns True for any indefinite type for which every -- definite subtype is a dictionary entry type -- -- G_VARIANT_TYPE_DICT_ENTRY, for example. function Is_Maybe (Self : Gvariant_Type) return Boolean; -- Determines if the given Type is a maybe type. This is true if the type -- string for Type starts with an 'm'. -- This function returns True for any indefinite type for which every -- definite subtype is a maybe type -- G_VARIANT_TYPE_MAYBE, for example. function Is_Subtype_Of (Self : Gvariant_Type; Supertype : Gvariant_Type) return Boolean; -- Checks if Type is a subtype of Supertype. -- This function returns True if Type is a subtype of Supertype. All types -- are considered to be subtypes of themselves. Aside from that, only -- indefinite types can have subtypes. -- "supertype": a Glib.Variant.Gvariant_Type function Is_Tuple (Self : Gvariant_Type) return Boolean; -- Determines if the given Type is a tuple type. This is true if the type -- string for Type starts with a '(' or if Type is G_VARIANT_TYPE_TUPLE. -- This function returns True for any indefinite type for which every -- definite subtype is a tuple type -- G_VARIANT_TYPE_TUPLE, for example. function Is_Variant (Self : Gvariant_Type) return Boolean; -- Determines if the given Type is the variant type. function Key (Self : Gvariant_Type) return Gvariant_Type; pragma Import (C, Key, "g_variant_type_key"); -- Determines the key type of a dictionary entry type. -- This function may only be used with a dictionary entry type. Other than -- the additional restriction, this call is equivalent to -- Glib.Variant.First. function N_Items (Self : Gvariant_Type) return Gsize; pragma Import (C, N_Items, "g_variant_type_n_items"); -- Determines the number of items contained in a tuple or dictionary entry -- type. -- This function may only be used with tuple or dictionary entry types, -- but must not be used with the generic tuple type G_VARIANT_TYPE_TUPLE. -- In the case of a dictionary entry type, this function will always -- return 2. function Next (Self : Gvariant_Type) return Gvariant_Type; pragma Import (C, Next, "g_variant_type_next"); -- Determines the next item type of a tuple or dictionary entry type. -- Type must be the result of a previous call to Glib.Variant.First or -- Glib.Variant.Next. -- If called on the key type of a dictionary entry then this call returns -- the value type. If called on the value type of a dictionary entry then -- this call returns null. -- For tuples, null is returned when Type is the last item in a tuple. function Peek_String (Self : Gvariant_Type) return UTF8_String; -- Returns the type string corresponding to the given Type. The result is -- not nul-terminated; in order to determine its length you must call -- Glib.Variant.Get_String_Length. -- To get a nul-terminated string, see Glib.Variant.Dup_String. function Value (Self : Gvariant_Type) return Gvariant_Type; pragma Import (C, Value, "g_variant_type_value"); -- Determines the value type of a dictionary entry type. -- This function may only be used with a dictionary entry type. ---------------------- -- GtkAda additions -- ---------------------- Gvariant_Type_Boolean : constant Gvariant_Type;-- value is 0 or 1 Gvariant_Type_Byte : constant Gvariant_Type;-- from 0 to 255 Gvariant_Type_Int16 : constant Gvariant_Type;-- from -32768..32767 Gvariant_Type_Uint16 : constant Gvariant_Type;-- from 0 to 65535 Gvariant_Type_Int32 : constant Gvariant_Type; Gvariant_Type_Uint32 : constant Gvariant_Type; Gvariant_Type_Int64 : constant Gvariant_Type; Gvariant_Type_Uint64 : constant Gvariant_Type; Gvariant_Type_Double : constant Gvariant_Type; Gvariant_Type_String : constant Gvariant_Type; pragma Import (C, Gvariant_Type_Boolean, "ada_gvariant_type_boolean"); pragma Import (C, Gvariant_Type_Byte, "ada_gvariant_type_byte"); pragma Import (C, Gvariant_Type_Int16, "ada_gvariant_type_int16"); pragma Import (C, Gvariant_Type_Uint16, "ada_gvariant_type_uint16"); pragma Import (C, Gvariant_Type_Int32, "ada_gvariant_type_int32"); pragma Import (C, Gvariant_Type_Uint32, "ada_gvariant_type_uint32"); pragma Import (C, Gvariant_Type_Int64, "ada_gvariant_type_int64"); pragma Import (C, Gvariant_Type_Uint64, "ada_gvariant_type_uint64"); pragma Import (C, Gvariant_Type_Double, "ada_gvariant_type_double"); pragma Import (C, Gvariant_Type_String, "ada_gvariant_type_string"); --------------- -- Functions -- --------------- function Is_Object_Path (String : UTF8_String) return Boolean; -- Determines if a given string is a valid D-Bus object path. You should -- ensure that a string is a valid D-Bus object path before passing it to -- g_variant_new_object_path. -- A valid object path starts with '/' followed by zero or more sequences -- of characters separated by '/' characters. Each sequence must contain -- only the characters "[A-Z][a-z][0-9]_". No sequence (including the one -- following the final '/' character) may be empty. -- Since: gtk+ 2.24 -- "string": a normal C nul-terminated string function Is_Signature (String : UTF8_String) return Boolean; -- Determines if a given string is a valid D-Bus type signature. You -- should ensure that a string is a valid D-Bus type signature before -- passing it to g_variant_new_signature. -- D-Bus type signatures consist of zero or more definite -- Glib.Variant.Gvariant_Type strings in sequence. -- Since: gtk+ 2.24 -- "string": a normal C nul-terminated string function Parse (The_Type : Gvariant_Type; Text : UTF8_String; Limit : UTF8_String := ""; Endptr : GNAT.Strings.String_List) return Gvariant; -- Parses a Glib.Variant.Gvariant from a text representation. -- A single Glib.Variant.Gvariant is parsed from the content of Text. -- The format is described [here][gvariant-text]. -- The memory at Limit will never be accessed and the parser behaves as if -- the character at Limit is the nul terminator. This has the effect of -- bounding Text. -- If Endptr is non-null then Text is permitted to contain data following -- the value that this function parses and Endptr will be updated to point -- to the first character past the end of the text parsed by this function. -- If Endptr is null and there is extra data then an error is returned. -- If Type is non-null then the value will be parsed to have that type. -- This may result in additional parse errors (in the case that the parsed -- value doesn't fit the type) but may also result in fewer errors (in the -- case that the type would have been ambiguous, such as with empty -- arrays). -- In the event that the parsing is successful, the resulting -- Glib.Variant.Gvariant is returned. -- In case of any error, null will be returned. If Error is non-null then -- it will be set to reflect the error that occurred. -- Officially, the language understood by the parser is "any string -- produced by Glib.Variant.Print". -- "type": a Glib.Variant.Gvariant_Type, or null -- "text": a string containing a GVariant in text form -- "limit": a pointer to the end of Text, or null -- "endptr": a location to store the end pointer, or null function Parse_Error_Print_Context (Error : Glib.Error.GError; Source_Str : UTF8_String) return UTF8_String; -- Pretty-prints a message showing the context of a Glib.Variant.Gvariant -- parse error within the string for which parsing was attempted. -- The resulting string is suitable for output to the console or other -- monospace media where newlines are treated in the usual way. -- The message will typically look something like one of the following: -- |[ unterminated string constant: (1, 2, 3, 'abc ^^^^ ]| -- or -- |[ unable to find a common type: [1, 2, 3, 'str'] ^ ^^^^^ ]| -- The format of the message may change in a future version. -- Error must have come from a failed attempt to Glib.Variant.Parse and -- Source_Str must be exactly the same string that caused the error. If -- Source_Str was not nul-terminated when you passed it to -- Glib.Variant.Parse then you must add nul termination before using this -- function. -- Since: gtk+ 2.40 -- "error": a Gerror.Gerror from the GVariant_Parse_Error domain -- "source_str": the string that was given to the parser function Parse_Error_Quark return Glib.GQuark; function Parser_Get_Error_Quark return Glib.GQuark; pragma Obsolescent (Parser_Get_Error_Quark); -- Same as g_variant_error_quark. -- Deprecated since None, 1 function String_Is_Valid (Type_String : UTF8_String) return Boolean; -- Checks if Type_String is a valid GVariant type string. This call is -- equivalent to calling g_variant_type_string_scan and confirming that the -- following character is a nul terminator. -- "type_string": a pointer to any string private Null_Gvariant : constant Gvariant := (Glib.C_Boxed with null record); end Glib.Variant; gtkada-24.0.0/src/generated/gtk-about_dialog.adb000066400000000000000000000623021446021174000214430ustar00rootroot00000000000000------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ pragma Style_Checks (Off); pragma Warnings (Off, "*is already use-visible*"); with Ada.Unchecked_Conversion; with Glib.Type_Conversion_Hooks; use Glib.Type_Conversion_Hooks; with Glib.Values; use Glib.Values; with Gtk.Arguments; use Gtk.Arguments; with Gtkada.Bindings; use Gtkada.Bindings; pragma Warnings(Off); -- might be unused with Gtkada.Types; use Gtkada.Types; pragma Warnings(On); package body Gtk.About_Dialog is package Type_Conversion_Gtk_About_Dialog is new Glib.Type_Conversion_Hooks.Hook_Registrator (Get_Type'Access, Gtk_About_Dialog_Record); pragma Unreferenced (Type_Conversion_Gtk_About_Dialog); -------------------------- -- Gtk_About_Dialog_New -- -------------------------- function Gtk_About_Dialog_New return Gtk_About_Dialog is About : constant Gtk_About_Dialog := new Gtk_About_Dialog_Record; begin Gtk.About_Dialog.Initialize (About); return About; end Gtk_About_Dialog_New; ------------- -- Gtk_New -- ------------- procedure Gtk_New (About : out Gtk_About_Dialog) is begin About := new Gtk_About_Dialog_Record; Gtk.About_Dialog.Initialize (About); end Gtk_New; ---------------- -- Initialize -- ---------------- procedure Initialize (About : not null access Gtk_About_Dialog_Record'Class) is function Internal return System.Address; pragma Import (C, Internal, "gtk_about_dialog_new"); begin if not About.Is_Created then Set_Object (About, Internal); end if; end Initialize; ------------------------ -- Add_Credit_Section -- ------------------------ procedure Add_Credit_Section (About : not null access Gtk_About_Dialog_Record; Section_Name : UTF8_String; People : GNAT.Strings.String_List) is procedure Internal (About : System.Address; Section_Name : Gtkada.Types.Chars_Ptr; People : Gtkada.Types.chars_ptr_array); pragma Import (C, Internal, "gtk_about_dialog_add_credit_section"); Tmp_Section_Name : Gtkada.Types.Chars_Ptr := New_String (Section_Name); Tmp_People : Gtkada.Types.chars_ptr_array := From_String_List (People); begin Internal (Get_Object (About), Tmp_Section_Name, Tmp_People); Gtkada.Types.Free (Tmp_People); Free (Tmp_Section_Name); end Add_Credit_Section; ----------------- -- Get_Artists -- ----------------- function Get_Artists (About : not null access Gtk_About_Dialog_Record) return GNAT.Strings.String_List is function Internal (About : System.Address) return chars_ptr_array_access; pragma Import (C, Internal, "gtk_about_dialog_get_artists"); begin return To_String_List (Internal (Get_Object (About)).all); end Get_Artists; ----------------- -- Get_Authors -- ----------------- function Get_Authors (About : not null access Gtk_About_Dialog_Record) return GNAT.Strings.String_List is function Internal (About : System.Address) return chars_ptr_array_access; pragma Import (C, Internal, "gtk_about_dialog_get_authors"); begin return To_String_List (Internal (Get_Object (About)).all); end Get_Authors; ------------------ -- Get_Comments -- ------------------ function Get_Comments (About : not null access Gtk_About_Dialog_Record) return UTF8_String is function Internal (About : System.Address) return Gtkada.Types.Chars_Ptr; pragma Import (C, Internal, "gtk_about_dialog_get_comments"); begin return Gtkada.Bindings.Value_Allowing_Null (Internal (Get_Object (About))); end Get_Comments; ------------------- -- Get_Copyright -- ------------------- function Get_Copyright (About : not null access Gtk_About_Dialog_Record) return UTF8_String is function Internal (About : System.Address) return Gtkada.Types.Chars_Ptr; pragma Import (C, Internal, "gtk_about_dialog_get_copyright"); begin return Gtkada.Bindings.Value_Allowing_Null (Internal (Get_Object (About))); end Get_Copyright; --------------------- -- Get_Documenters -- --------------------- function Get_Documenters (About : not null access Gtk_About_Dialog_Record) return GNAT.Strings.String_List is function Internal (About : System.Address) return chars_ptr_array_access; pragma Import (C, Internal, "gtk_about_dialog_get_documenters"); begin return To_String_List (Internal (Get_Object (About)).all); end Get_Documenters; ----------------- -- Get_License -- ----------------- function Get_License (About : not null access Gtk_About_Dialog_Record) return UTF8_String is function Internal (About : System.Address) return Gtkada.Types.Chars_Ptr; pragma Import (C, Internal, "gtk_about_dialog_get_license"); begin return Gtkada.Bindings.Value_Allowing_Null (Internal (Get_Object (About))); end Get_License; ---------------------- -- Get_License_Type -- ---------------------- function Get_License_Type (About : not null access Gtk_About_Dialog_Record) return Gtk_License is function Internal (About : System.Address) return Gtk_License; pragma Import (C, Internal, "gtk_about_dialog_get_license_type"); begin return Internal (Get_Object (About)); end Get_License_Type; -------------- -- Get_Logo -- -------------- function Get_Logo (About : not null access Gtk_About_Dialog_Record) return Gdk.Pixbuf.Gdk_Pixbuf is function Internal (About : System.Address) return System.Address; pragma Import (C, Internal, "gtk_about_dialog_get_logo"); Stub_Gdk_Pixbuf : Gdk.Pixbuf.Gdk_Pixbuf_Record; begin return Gdk.Pixbuf.Gdk_Pixbuf (Get_User_Data (Internal (Get_Object (About)), Stub_Gdk_Pixbuf)); end Get_Logo; ------------------------ -- Get_Logo_Icon_Name -- ------------------------ function Get_Logo_Icon_Name (About : not null access Gtk_About_Dialog_Record) return UTF8_String is function Internal (About : System.Address) return Gtkada.Types.Chars_Ptr; pragma Import (C, Internal, "gtk_about_dialog_get_logo_icon_name"); begin return Gtkada.Bindings.Value_Allowing_Null (Internal (Get_Object (About))); end Get_Logo_Icon_Name; ---------------------- -- Get_Program_Name -- ---------------------- function Get_Program_Name (About : not null access Gtk_About_Dialog_Record) return UTF8_String is function Internal (About : System.Address) return Gtkada.Types.Chars_Ptr; pragma Import (C, Internal, "gtk_about_dialog_get_program_name"); begin return Gtkada.Bindings.Value_Allowing_Null (Internal (Get_Object (About))); end Get_Program_Name; ---------------------------- -- Get_Translator_Credits -- ---------------------------- function Get_Translator_Credits (About : not null access Gtk_About_Dialog_Record) return UTF8_String is function Internal (About : System.Address) return Gtkada.Types.Chars_Ptr; pragma Import (C, Internal, "gtk_about_dialog_get_translator_credits"); begin return Gtkada.Bindings.Value_Allowing_Null (Internal (Get_Object (About))); end Get_Translator_Credits; ----------------- -- Get_Version -- ----------------- function Get_Version (About : not null access Gtk_About_Dialog_Record) return UTF8_String is function Internal (About : System.Address) return Gtkada.Types.Chars_Ptr; pragma Import (C, Internal, "gtk_about_dialog_get_version"); begin return Gtkada.Bindings.Value_Allowing_Null (Internal (Get_Object (About))); end Get_Version; ----------------- -- Get_Website -- ----------------- function Get_Website (About : not null access Gtk_About_Dialog_Record) return UTF8_String is function Internal (About : System.Address) return Gtkada.Types.Chars_Ptr; pragma Import (C, Internal, "gtk_about_dialog_get_website"); begin return Gtkada.Bindings.Value_Allowing_Null (Internal (Get_Object (About))); end Get_Website; ----------------------- -- Get_Website_Label -- ----------------------- function Get_Website_Label (About : not null access Gtk_About_Dialog_Record) return UTF8_String is function Internal (About : System.Address) return Gtkada.Types.Chars_Ptr; pragma Import (C, Internal, "gtk_about_dialog_get_website_label"); begin return Gtkada.Bindings.Value_Allowing_Null (Internal (Get_Object (About))); end Get_Website_Label; ---------------------- -- Get_Wrap_License -- ---------------------- function Get_Wrap_License (About : not null access Gtk_About_Dialog_Record) return Boolean is function Internal (About : System.Address) return Glib.Gboolean; pragma Import (C, Internal, "gtk_about_dialog_get_wrap_license"); begin return Internal (Get_Object (About)) /= 0; end Get_Wrap_License; ----------------- -- Set_Artists -- ----------------- procedure Set_Artists (About : not null access Gtk_About_Dialog_Record; Artists : GNAT.Strings.String_List) is procedure Internal (About : System.Address; Artists : Gtkada.Types.chars_ptr_array); pragma Import (C, Internal, "gtk_about_dialog_set_artists"); Tmp_Artists : Gtkada.Types.chars_ptr_array := From_String_List (Artists); begin Internal (Get_Object (About), Tmp_Artists); Gtkada.Types.Free (Tmp_Artists); end Set_Artists; ----------------- -- Set_Authors -- ----------------- procedure Set_Authors (About : not null access Gtk_About_Dialog_Record; Authors : GNAT.Strings.String_List) is procedure Internal (About : System.Address; Authors : Gtkada.Types.chars_ptr_array); pragma Import (C, Internal, "gtk_about_dialog_set_authors"); Tmp_Authors : Gtkada.Types.chars_ptr_array := From_String_List (Authors); begin Internal (Get_Object (About), Tmp_Authors); Gtkada.Types.Free (Tmp_Authors); end Set_Authors; ------------------ -- Set_Comments -- ------------------ procedure Set_Comments (About : not null access Gtk_About_Dialog_Record; Comments : UTF8_String := "") is procedure Internal (About : System.Address; Comments : Gtkada.Types.Chars_Ptr); pragma Import (C, Internal, "gtk_about_dialog_set_comments"); Tmp_Comments : Gtkada.Types.Chars_Ptr; begin if Comments = "" then Tmp_Comments := Gtkada.Types.Null_Ptr; else Tmp_Comments := New_String (Comments); end if; Internal (Get_Object (About), Tmp_Comments); Free (Tmp_Comments); end Set_Comments; ------------------- -- Set_Copyright -- ------------------- procedure Set_Copyright (About : not null access Gtk_About_Dialog_Record; Copyright : UTF8_String := "") is procedure Internal (About : System.Address; Copyright : Gtkada.Types.Chars_Ptr); pragma Import (C, Internal, "gtk_about_dialog_set_copyright"); Tmp_Copyright : Gtkada.Types.Chars_Ptr; begin if Copyright = "" then Tmp_Copyright := Gtkada.Types.Null_Ptr; else Tmp_Copyright := New_String (Copyright); end if; Internal (Get_Object (About), Tmp_Copyright); Free (Tmp_Copyright); end Set_Copyright; --------------------- -- Set_Documenters -- --------------------- procedure Set_Documenters (About : not null access Gtk_About_Dialog_Record; Documenters : GNAT.Strings.String_List) is procedure Internal (About : System.Address; Documenters : Gtkada.Types.chars_ptr_array); pragma Import (C, Internal, "gtk_about_dialog_set_documenters"); Tmp_Documenters : Gtkada.Types.chars_ptr_array := From_String_List (Documenters); begin Internal (Get_Object (About), Tmp_Documenters); Gtkada.Types.Free (Tmp_Documenters); end Set_Documenters; ----------------- -- Set_License -- ----------------- procedure Set_License (About : not null access Gtk_About_Dialog_Record; License : UTF8_String := "") is procedure Internal (About : System.Address; License : Gtkada.Types.Chars_Ptr); pragma Import (C, Internal, "gtk_about_dialog_set_license"); Tmp_License : Gtkada.Types.Chars_Ptr; begin if License = "" then Tmp_License := Gtkada.Types.Null_Ptr; else Tmp_License := New_String (License); end if; Internal (Get_Object (About), Tmp_License); Free (Tmp_License); end Set_License; ---------------------- -- Set_License_Type -- ---------------------- procedure Set_License_Type (About : not null access Gtk_About_Dialog_Record; License_Type : Gtk_License) is procedure Internal (About : System.Address; License_Type : Gtk_License); pragma Import (C, Internal, "gtk_about_dialog_set_license_type"); begin Internal (Get_Object (About), License_Type); end Set_License_Type; -------------- -- Set_Logo -- -------------- procedure Set_Logo (About : not null access Gtk_About_Dialog_Record; Logo : access Gdk.Pixbuf.Gdk_Pixbuf_Record'Class) is procedure Internal (About : System.Address; Logo : System.Address); pragma Import (C, Internal, "gtk_about_dialog_set_logo"); begin Internal (Get_Object (About), Get_Object_Or_Null (GObject (Logo))); end Set_Logo; ------------------------ -- Set_Logo_Icon_Name -- ------------------------ procedure Set_Logo_Icon_Name (About : not null access Gtk_About_Dialog_Record; Icon_Name : UTF8_String := "") is procedure Internal (About : System.Address; Icon_Name : Gtkada.Types.Chars_Ptr); pragma Import (C, Internal, "gtk_about_dialog_set_logo_icon_name"); Tmp_Icon_Name : Gtkada.Types.Chars_Ptr; begin if Icon_Name = "" then Tmp_Icon_Name := Gtkada.Types.Null_Ptr; else Tmp_Icon_Name := New_String (Icon_Name); end if; Internal (Get_Object (About), Tmp_Icon_Name); Free (Tmp_Icon_Name); end Set_Logo_Icon_Name; ---------------------- -- Set_Program_Name -- ---------------------- procedure Set_Program_Name (About : not null access Gtk_About_Dialog_Record; Name : UTF8_String) is procedure Internal (About : System.Address; Name : Gtkada.Types.Chars_Ptr); pragma Import (C, Internal, "gtk_about_dialog_set_program_name"); Tmp_Name : Gtkada.Types.Chars_Ptr := New_String (Name); begin Internal (Get_Object (About), Tmp_Name); Free (Tmp_Name); end Set_Program_Name; ---------------------------- -- Set_Translator_Credits -- ---------------------------- procedure Set_Translator_Credits (About : not null access Gtk_About_Dialog_Record; Translator_Credits : UTF8_String := "") is procedure Internal (About : System.Address; Translator_Credits : Gtkada.Types.Chars_Ptr); pragma Import (C, Internal, "gtk_about_dialog_set_translator_credits"); Tmp_Translator_Credits : Gtkada.Types.Chars_Ptr; begin if Translator_Credits = "" then Tmp_Translator_Credits := Gtkada.Types.Null_Ptr; else Tmp_Translator_Credits := New_String (Translator_Credits); end if; Internal (Get_Object (About), Tmp_Translator_Credits); Free (Tmp_Translator_Credits); end Set_Translator_Credits; ----------------- -- Set_Version -- ----------------- procedure Set_Version (About : not null access Gtk_About_Dialog_Record; Version : UTF8_String := "") is procedure Internal (About : System.Address; Version : Gtkada.Types.Chars_Ptr); pragma Import (C, Internal, "gtk_about_dialog_set_version"); Tmp_Version : Gtkada.Types.Chars_Ptr; begin if Version = "" then Tmp_Version := Gtkada.Types.Null_Ptr; else Tmp_Version := New_String (Version); end if; Internal (Get_Object (About), Tmp_Version); Free (Tmp_Version); end Set_Version; ----------------- -- Set_Website -- ----------------- procedure Set_Website (About : not null access Gtk_About_Dialog_Record; Website : UTF8_String := "") is procedure Internal (About : System.Address; Website : Gtkada.Types.Chars_Ptr); pragma Import (C, Internal, "gtk_about_dialog_set_website"); Tmp_Website : Gtkada.Types.Chars_Ptr; begin if Website = "" then Tmp_Website := Gtkada.Types.Null_Ptr; else Tmp_Website := New_String (Website); end if; Internal (Get_Object (About), Tmp_Website); Free (Tmp_Website); end Set_Website; ----------------------- -- Set_Website_Label -- ----------------------- procedure Set_Website_Label (About : not null access Gtk_About_Dialog_Record; Website_Label : UTF8_String) is procedure Internal (About : System.Address; Website_Label : Gtkada.Types.Chars_Ptr); pragma Import (C, Internal, "gtk_about_dialog_set_website_label"); Tmp_Website_Label : Gtkada.Types.Chars_Ptr := New_String (Website_Label); begin Internal (Get_Object (About), Tmp_Website_Label); Free (Tmp_Website_Label); end Set_Website_Label; ---------------------- -- Set_Wrap_License -- ---------------------- procedure Set_Wrap_License (About : not null access Gtk_About_Dialog_Record; Wrap_License : Boolean) is procedure Internal (About : System.Address; Wrap_License : Glib.Gboolean); pragma Import (C, Internal, "gtk_about_dialog_set_wrap_license"); begin Internal (Get_Object (About), Boolean'Pos (Wrap_License)); end Set_Wrap_License; use type System.Address; function Cb_To_Address is new Ada.Unchecked_Conversion (Cb_Gtk_About_Dialog_UTF8_String_Boolean, System.Address); function Address_To_Cb is new Ada.Unchecked_Conversion (System.Address, Cb_Gtk_About_Dialog_UTF8_String_Boolean); function Cb_To_Address is new Ada.Unchecked_Conversion (Cb_GObject_UTF8_String_Boolean, System.Address); function Address_To_Cb is new Ada.Unchecked_Conversion (System.Address, Cb_GObject_UTF8_String_Boolean); procedure Connect (Object : access Gtk_About_Dialog_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_Gtk_About_Dialog_UTF8_String_Boolean; After : Boolean); procedure Connect_Slot (Object : access Gtk_About_Dialog_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_GObject_UTF8_String_Boolean; After : Boolean; Slot : access Glib.Object.GObject_Record'Class := null); procedure Marsh_GObject_UTF8_String_Boolean (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address); pragma Convention (C, Marsh_GObject_UTF8_String_Boolean); procedure Marsh_Gtk_About_Dialog_UTF8_String_Boolean (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address); pragma Convention (C, Marsh_Gtk_About_Dialog_UTF8_String_Boolean); ------------- -- Connect -- ------------- procedure Connect (Object : access Gtk_About_Dialog_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_Gtk_About_Dialog_UTF8_String_Boolean; After : Boolean) is begin Unchecked_Do_Signal_Connect (Object => Object, C_Name => C_Name, Marshaller => Marsh_Gtk_About_Dialog_UTF8_String_Boolean'Access, Handler => Cb_To_Address (Handler),-- Set in the closure After => After); end Connect; ------------------ -- Connect_Slot -- ------------------ procedure Connect_Slot (Object : access Gtk_About_Dialog_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_GObject_UTF8_String_Boolean; After : Boolean; Slot : access Glib.Object.GObject_Record'Class := null) is begin Unchecked_Do_Signal_Connect (Object => Object, C_Name => C_Name, Marshaller => Marsh_GObject_UTF8_String_Boolean'Access, Handler => Cb_To_Address (Handler),-- Set in the closure Slot_Object => Slot, After => After); end Connect_Slot; --------------------------------------- -- Marsh_GObject_UTF8_String_Boolean -- --------------------------------------- procedure Marsh_GObject_UTF8_String_Boolean (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address) is pragma Unreferenced (N_Params, Invocation_Hint, User_Data); H : constant Cb_GObject_UTF8_String_Boolean := Address_To_Cb (Get_Callback (Closure)); Obj : constant Glib.Object.GObject := Glib.Object.Convert (Get_Data (Closure)); V : aliased Boolean := H (Obj, Unchecked_To_UTF8_String (Params, 1)); begin Set_Value (Return_Value, V'Address); exception when E : others => Process_Exception (E); end Marsh_GObject_UTF8_String_Boolean; ------------------------------------------------ -- Marsh_Gtk_About_Dialog_UTF8_String_Boolean -- ------------------------------------------------ procedure Marsh_Gtk_About_Dialog_UTF8_String_Boolean (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address) is pragma Unreferenced (N_Params, Invocation_Hint, User_Data); H : constant Cb_Gtk_About_Dialog_UTF8_String_Boolean := Address_To_Cb (Get_Callback (Closure)); Obj : constant Gtk_About_Dialog := Gtk_About_Dialog (Unchecked_To_Object (Params, 0)); V : aliased Boolean := H (Obj, Unchecked_To_UTF8_String (Params, 1)); begin Set_Value (Return_Value, V'Address); exception when E : others => Process_Exception (E); end Marsh_Gtk_About_Dialog_UTF8_String_Boolean; ---------------------- -- On_Activate_Link -- ---------------------- procedure On_Activate_Link (Self : not null access Gtk_About_Dialog_Record; Call : Cb_Gtk_About_Dialog_UTF8_String_Boolean; After : Boolean := False) is begin Connect (Self, "activate-link" & ASCII.NUL, Call, After); end On_Activate_Link; ---------------------- -- On_Activate_Link -- ---------------------- procedure On_Activate_Link (Self : not null access Gtk_About_Dialog_Record; Call : Cb_GObject_UTF8_String_Boolean; Slot : not null access Glib.Object.GObject_Record'Class; After : Boolean := False) is begin Connect_Slot (Self, "activate-link" & ASCII.NUL, Call, After, Slot); end On_Activate_Link; end Gtk.About_Dialog; gtkada-24.0.0/src/generated/gtk-about_dialog.ads000066400000000000000000000525441446021174000214730ustar00rootroot00000000000000------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ -- -- The GtkAboutDialog offers a simple way to display information about a -- program like its logo, name, copyright, website and license. It is also -- possible to give credits to the authors, documenters, translators and -- artists who have worked on the program. An about dialog is typically opened -- when the user selects the `About` option from the `Help` menu. All parts of -- the dialog are optional. -- -- About dialogs often contain links and email addresses. GtkAboutDialog -- displays these as clickable links. By default, it calls -- gtk_show_uri_on_window when a user clicks one. The behaviour can be -- overridden with the Gtk.About_Dialog.Gtk_About_Dialog::activate-link -- signal. -- -- To specify a person with an email address, use a string like "Edgar Allan -- Poe ". To specify a website with a title, use a string like -- "GTK+ team http://www.gtk.org". -- -- To make constructing a GtkAboutDialog as convenient as possible, you can -- use the function gtk_show_about_dialog which constructs and shows a dialog -- and keeps it around so that it can be shown again. -- -- Note that GTK+ sets a default title of `_("About %s")` on the dialog -- window (where \%s is replaced by the name of the application, but in order -- to ensure proper translation of the title, applications should set the -- title property explicitly when constructing a GtkAboutDialog, as shown in -- the following example: |[ GdkPixbuf *example_logo = -- gdk_pixbuf_new_from_file ("./logo.png", NULL); gtk_show_about_dialog (NULL, -- "program-name", "ExampleCode", "logo", example_logo, "title", _("About -- ExampleCode"), NULL); ]| -- -- It is also possible to show a Gtk.About_Dialog.Gtk_About_Dialog like any -- other Gtk.Dialog.Gtk_Dialog, e.g. using Gtk.Dialog.Run. In this case, you -- might need to know that the "Close" button returns the GTK_RESPONSE_CANCEL -- response id. -- -- -- Windows -- create_about.adb pragma Warnings (Off, "*is already use-visible*"); with GNAT.Strings; use GNAT.Strings; with Gdk.Pixbuf; use Gdk.Pixbuf; with Glib; use Glib; with Glib.Generic_Properties; use Glib.Generic_Properties; with Glib.Object; use Glib.Object; with Glib.Properties; use Glib.Properties; with Glib.Types; use Glib.Types; with Gtk.Buildable; use Gtk.Buildable; with Gtk.Dialog; use Gtk.Dialog; package Gtk.About_Dialog is type Gtk_About_Dialog_Record is new Gtk_Dialog_Record with null record; type Gtk_About_Dialog is access all Gtk_About_Dialog_Record'Class; type Gtk_License is ( License_Unknown, License_Custom, License_Gpl_2_0, License_Gpl_3_0, License_Lgpl_2_1, License_Lgpl_3_0, License_Bsd, License_Mit_X11, License_Artistic, License_Gpl_2_0_Only, License_Gpl_3_0_Only, License_Lgpl_2_1_Only, License_Lgpl_3_0_Only, License_Agpl_3_0, License_Agpl_3_0_Only, License_Bsd_3, License_Apache_2_0, License_Mpl_2_0); pragma Convention (C, Gtk_License); -- The type of license for an application. -- -- This enumeration can be expanded at later date. ---------------------------- -- Enumeration Properties -- ---------------------------- package Gtk_License_Properties is new Generic_Internal_Discrete_Property (Gtk_License); type Property_Gtk_License is new Gtk_License_Properties.Property; ------------------ -- Constructors -- ------------------ procedure Gtk_New (About : out Gtk_About_Dialog); procedure Initialize (About : not null access Gtk_About_Dialog_Record'Class); -- Creates a new Gtk.About_Dialog.Gtk_About_Dialog. -- Since: gtk+ 2.6 -- Initialize does nothing if the object was already created with another -- call to Initialize* or G_New. function Gtk_About_Dialog_New return Gtk_About_Dialog; -- Creates a new Gtk.About_Dialog.Gtk_About_Dialog. -- Since: gtk+ 2.6 function Get_Type return Glib.GType; pragma Import (C, Get_Type, "gtk_about_dialog_get_type"); ------------- -- Methods -- ------------- procedure Add_Credit_Section (About : not null access Gtk_About_Dialog_Record; Section_Name : UTF8_String; People : GNAT.Strings.String_List); -- Creates a new section in the Credits page. -- Since: gtk+ 3.4 -- "section_name": The name of the section -- "people": The people who belong to that section function Get_Artists (About : not null access Gtk_About_Dialog_Record) return GNAT.Strings.String_List; -- Returns the string which are displayed in the artists tab of the -- secondary credits dialog. -- Since: gtk+ 2.6 procedure Set_Artists (About : not null access Gtk_About_Dialog_Record; Artists : GNAT.Strings.String_List); -- Sets the strings which are displayed in the artists tab of the -- secondary credits dialog. -- Since: gtk+ 2.6 -- "artists": a null-terminated array of strings function Get_Authors (About : not null access Gtk_About_Dialog_Record) return GNAT.Strings.String_List; -- Returns the string which are displayed in the authors tab of the -- secondary credits dialog. -- Since: gtk+ 2.6 procedure Set_Authors (About : not null access Gtk_About_Dialog_Record; Authors : GNAT.Strings.String_List); -- Sets the strings which are displayed in the authors tab of the -- secondary credits dialog. -- Since: gtk+ 2.6 -- "authors": a null-terminated array of strings function Get_Comments (About : not null access Gtk_About_Dialog_Record) return UTF8_String; -- Returns the comments string. -- Since: gtk+ 2.6 procedure Set_Comments (About : not null access Gtk_About_Dialog_Record; Comments : UTF8_String := ""); -- Sets the comments string to display in the about dialog. This should be -- a short string of one or two lines. -- Since: gtk+ 2.6 -- "comments": a comments string function Get_Copyright (About : not null access Gtk_About_Dialog_Record) return UTF8_String; -- Returns the copyright string. -- Since: gtk+ 2.6 procedure Set_Copyright (About : not null access Gtk_About_Dialog_Record; Copyright : UTF8_String := ""); -- Sets the copyright string to display in the about dialog. This should -- be a short string of one or two lines. -- Since: gtk+ 2.6 -- "copyright": the copyright string function Get_Documenters (About : not null access Gtk_About_Dialog_Record) return GNAT.Strings.String_List; -- Returns the string which are displayed in the documenters tab of the -- secondary credits dialog. -- Since: gtk+ 2.6 procedure Set_Documenters (About : not null access Gtk_About_Dialog_Record; Documenters : GNAT.Strings.String_List); -- Sets the strings which are displayed in the documenters tab of the -- secondary credits dialog. -- Since: gtk+ 2.6 -- "documenters": a null-terminated array of strings function Get_License (About : not null access Gtk_About_Dialog_Record) return UTF8_String; -- Returns the license information. -- Since: gtk+ 2.6 procedure Set_License (About : not null access Gtk_About_Dialog_Record; License : UTF8_String := ""); -- Sets the license information to be displayed in the secondary license -- dialog. If License is null, the license button is hidden. -- Since: gtk+ 2.6 -- "license": the license information or null function Get_License_Type (About : not null access Gtk_About_Dialog_Record) return Gtk_License; -- Retrieves the license set using Gtk.About_Dialog.Set_License_Type -- Since: gtk+ 3.0 procedure Set_License_Type (About : not null access Gtk_About_Dialog_Record; License_Type : Gtk_License); -- Sets the license of the application showing the About dialog from a -- list of known licenses. -- This function overrides the license set using -- Gtk.About_Dialog.Set_License. -- Since: gtk+ 3.0 -- "license_type": the type of license function Get_Logo (About : not null access Gtk_About_Dialog_Record) return Gdk.Pixbuf.Gdk_Pixbuf; -- Returns the pixbuf displayed as logo in the about dialog. -- Since: gtk+ 2.6 procedure Set_Logo (About : not null access Gtk_About_Dialog_Record; Logo : access Gdk.Pixbuf.Gdk_Pixbuf_Record'Class); -- Sets the pixbuf to be displayed as logo in the about dialog. If it is -- null, the default window icon set with Gtk.Window.Set_Default_Icon will -- be used. -- Since: gtk+ 2.6 -- "logo": a Gdk.Pixbuf.Gdk_Pixbuf, or null function Get_Logo_Icon_Name (About : not null access Gtk_About_Dialog_Record) return UTF8_String; -- Returns the icon name displayed as logo in the about dialog. -- Since: gtk+ 2.6 procedure Set_Logo_Icon_Name (About : not null access Gtk_About_Dialog_Record; Icon_Name : UTF8_String := ""); -- Sets the pixbuf to be displayed as logo in the about dialog. If it is -- null, the default window icon set with Gtk.Window.Set_Default_Icon will -- be used. -- Since: gtk+ 2.6 -- "icon_name": an icon name, or null function Get_Program_Name (About : not null access Gtk_About_Dialog_Record) return UTF8_String; -- Returns the program name displayed in the about dialog. -- Since: gtk+ 2.12 procedure Set_Program_Name (About : not null access Gtk_About_Dialog_Record; Name : UTF8_String); -- Sets the name to display in the about dialog. If this is not set, it -- defaults to g_get_application_name. -- Since: gtk+ 2.12 -- "name": the program name function Get_Translator_Credits (About : not null access Gtk_About_Dialog_Record) return UTF8_String; -- Returns the translator credits string which is displayed in the -- translators tab of the secondary credits dialog. -- Since: gtk+ 2.6 procedure Set_Translator_Credits (About : not null access Gtk_About_Dialog_Record; Translator_Credits : UTF8_String := ""); -- Sets the translator credits string which is displayed in the -- translators tab of the secondary credits dialog. -- The intended use for this string is to display the translator of the -- language which is currently used in the user interface. Using gettext, a -- simple way to achieve that is to mark the string for translation: |[ GtkWidget *about = gtk_about_dialog_new (); -- gtk_about_dialog_set_translator_credits (GTK_ABOUT_DIALOG (about), -- _("translator-credits")); ]| It is a good idea to use the customary -- msgid "translator-credits" for this purpose, since translators will -- already know the purpose of that msgid, and since -- Gtk.About_Dialog.Gtk_About_Dialog will detect if "translator-credits" is -- untranslated and hide the tab. -- Since: gtk+ 2.6 -- "translator_credits": the translator credits function Get_Version (About : not null access Gtk_About_Dialog_Record) return UTF8_String; -- Returns the version string. -- Since: gtk+ 2.6 procedure Set_Version (About : not null access Gtk_About_Dialog_Record; Version : UTF8_String := ""); -- Sets the version string to display in the about dialog. -- Since: gtk+ 2.6 -- "version": the version string function Get_Website (About : not null access Gtk_About_Dialog_Record) return UTF8_String; -- Returns the website URL. -- Since: gtk+ 2.6 procedure Set_Website (About : not null access Gtk_About_Dialog_Record; Website : UTF8_String := ""); -- Sets the URL to use for the website link. -- Since: gtk+ 2.6 -- "website": a URL string starting with "http://" function Get_Website_Label (About : not null access Gtk_About_Dialog_Record) return UTF8_String; -- Returns the label used for the website link. -- Since: gtk+ 2.6 procedure Set_Website_Label (About : not null access Gtk_About_Dialog_Record; Website_Label : UTF8_String); -- Sets the label to be used for the website link. -- Since: gtk+ 2.6 -- "website_label": the label used for the website link function Get_Wrap_License (About : not null access Gtk_About_Dialog_Record) return Boolean; -- Returns whether the license text in About is automatically wrapped. -- Since: gtk+ 2.8 procedure Set_Wrap_License (About : not null access Gtk_About_Dialog_Record; Wrap_License : Boolean); -- Sets whether the license text in About is automatically wrapped. -- Since: gtk+ 2.8 -- "wrap_license": whether to wrap the license ---------------- -- Properties -- ---------------- -- The following properties are defined for this widget. See -- Glib.Properties for more information on properties) Artists_Property : constant Glib.Properties.Property_String := Glib.Properties.Build ("artists");-- Unknown type: unspecified Authors_Property : constant Glib.Properties.Property_String := Glib.Properties.Build ("authors");-- Unknown type: unspecified Documenters_Property : constant Glib.Properties.Property_String := Glib.Properties.Build ("documenters");-- Unknown type: unspecified Comments_Property : constant Glib.Properties.Property_String; -- Comments about the program. This string is displayed in a label in the -- main dialog, thus it should be a short explanation of the main purpose -- of the program, not a detailed list of features. Copyright_Property : constant Glib.Properties.Property_String; -- Copyright information for the program. License_Property : constant Glib.Properties.Property_String; -- The license of the program. This string is displayed in a text view in -- a secondary dialog, therefore it is fine to use a long multi-paragraph -- text. Note that the text is only wrapped in the text view if the -- "wrap-license" property is set to True; otherwise the text itself must -- contain the intended linebreaks. When setting this property to a -- non-null value, the Gtk.About_Dialog.Gtk_About_Dialog:license-type -- property is set to Gtk.About_Dialog.License_Custom as a side effect. License_Type_Property : constant Gtk.About_Dialog.Property_Gtk_License; -- Type: Gtk_License -- The license of the program, as a value of the GtkLicense enumeration. -- -- The Gtk.About_Dialog.Gtk_About_Dialog will automatically fill out a -- standard disclaimer and link the user to the appropriate online resource -- for the license text. -- -- If Gtk.About_Dialog.License_Unknown is used, the link used will be the -- same specified in the Gtk.About_Dialog.Gtk_About_Dialog:website -- property. -- -- If Gtk.About_Dialog.License_Custom is used, the current contents of the -- Gtk.About_Dialog.Gtk_About_Dialog:license property are used. -- -- For any other Gtk.About_Dialog.Gtk_License value, the contents of the -- Gtk.About_Dialog.Gtk_About_Dialog:license property are also set by this -- property as a side effect. Logo_Property : constant Glib.Properties.Property_Object; -- Type: Gdk.Pixbuf.Gdk_Pixbuf -- A logo for the about box. If it is null, the default window icon set -- with Gtk.Window.Set_Default_Icon will be used. Logo_Icon_Name_Property : constant Glib.Properties.Property_String; -- A named icon to use as the logo for the about box. This property -- overrides the Gtk.About_Dialog.Gtk_About_Dialog:logo property. Program_Name_Property : constant Glib.Properties.Property_String; -- The name of the program. If this is not set, it defaults to -- g_get_application_name. Translator_Credits_Property : constant Glib.Properties.Property_String; -- Credits to the translators. This string should be marked as -- translatable. The string may contain email addresses and URLs, which -- will be displayed as links, see the introduction for more details. Version_Property : constant Glib.Properties.Property_String; -- The version of the program. Website_Property : constant Glib.Properties.Property_String; -- The URL for the link to the website of the program. This should be a -- string starting with "http://. Website_Label_Property : constant Glib.Properties.Property_String; -- The label for the link to the website of the program. Wrap_License_Property : constant Glib.Properties.Property_Boolean; -- Whether to wrap the text in the license dialog. ------------- -- Signals -- ------------- type Cb_Gtk_About_Dialog_UTF8_String_Boolean is not null access function (Self : access Gtk_About_Dialog_Record'Class; URI : UTF8_String) return Boolean; type Cb_GObject_UTF8_String_Boolean is not null access function (Self : access Glib.Object.GObject_Record'Class; URI : UTF8_String) return Boolean; Signal_Activate_Link : constant Glib.Signal_Name := "activate-link"; procedure On_Activate_Link (Self : not null access Gtk_About_Dialog_Record; Call : Cb_Gtk_About_Dialog_UTF8_String_Boolean; After : Boolean := False); procedure On_Activate_Link (Self : not null access Gtk_About_Dialog_Record; Call : Cb_GObject_UTF8_String_Boolean; Slot : not null access Glib.Object.GObject_Record'Class; After : Boolean := False); -- The signal which gets emitted to activate a URI. Applications may -- connect to it to override the default behaviour, which is to call -- gtk_show_uri_on_window. -- -- Callback parameters: -- -- "uri": the URI that is activated -- -- Returns True if the link has been activated ---------------- -- Interfaces -- ---------------- -- This class implements several interfaces. See Glib.Types -- -- - "Buildable" package Implements_Gtk_Buildable is new Glib.Types.Implements (Gtk.Buildable.Gtk_Buildable, Gtk_About_Dialog_Record, Gtk_About_Dialog); function "+" (Widget : access Gtk_About_Dialog_Record'Class) return Gtk.Buildable.Gtk_Buildable renames Implements_Gtk_Buildable.To_Interface; function "-" (Interf : Gtk.Buildable.Gtk_Buildable) return Gtk_About_Dialog renames Implements_Gtk_Buildable.To_Object; private Wrap_License_Property : constant Glib.Properties.Property_Boolean := Glib.Properties.Build ("wrap-license"); Website_Label_Property : constant Glib.Properties.Property_String := Glib.Properties.Build ("website-label"); Website_Property : constant Glib.Properties.Property_String := Glib.Properties.Build ("website"); Version_Property : constant Glib.Properties.Property_String := Glib.Properties.Build ("version"); Translator_Credits_Property : constant Glib.Properties.Property_String := Glib.Properties.Build ("translator-credits"); Program_Name_Property : constant Glib.Properties.Property_String := Glib.Properties.Build ("program-name"); Logo_Icon_Name_Property : constant Glib.Properties.Property_String := Glib.Properties.Build ("logo-icon-name"); Logo_Property : constant Glib.Properties.Property_Object := Glib.Properties.Build ("logo"); License_Type_Property : constant Gtk.About_Dialog.Property_Gtk_License := Gtk.About_Dialog.Build ("license-type"); License_Property : constant Glib.Properties.Property_String := Glib.Properties.Build ("license"); Copyright_Property : constant Glib.Properties.Property_String := Glib.Properties.Build ("copyright"); Comments_Property : constant Glib.Properties.Property_String := Glib.Properties.Build ("comments"); end Gtk.About_Dialog; gtkada-24.0.0/src/generated/gtk-accel_group.adb000066400000000000000000000663051446021174000213040ustar00rootroot00000000000000------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ pragma Style_Checks (Off); pragma Warnings (Off, "*is already use-visible*"); with Ada.Unchecked_Conversion; with Glib.Type_Conversion_Hooks; use Glib.Type_Conversion_Hooks; with Glib.Values; use Glib.Values; with Gtk.Arguments; use Gtk.Arguments; with Gtkada.Bindings; use Gtkada.Bindings; with Gtkada.Types; use Gtkada.Types; package body Gtk.Accel_Group is function From_Object_Free (B : access Gtk_Accel_Key) return Gtk_Accel_Key is Result : constant Gtk_Accel_Key := B.all; begin Glib.g_free (B.all'Address); return Result; end From_Object_Free; function C_Gtk_Accel_Group_Find (Accel_Group : System.Address; Find_Func : System.Address; Data : System.Address) return access Gtk_Accel_Key; pragma Import (C, C_Gtk_Accel_Group_Find, "gtk_accel_group_find"); -- Finds the first entry in an accelerator group for which Find_Func -- returns True and returns its Gtk.Accel_Group.Gtk_Accel_Key. -- "find_func": a function to filter the entries of Accel_Group with -- "data": data to pass to Find_Func function To_Gtk_Accel_Group_Find_Func is new Ada.Unchecked_Conversion (System.Address, Gtk_Accel_Group_Find_Func); function To_Address is new Ada.Unchecked_Conversion (Gtk_Accel_Group_Find_Func, System.Address); function Internal_Gtk_Accel_Group_Find_Func (Key : access Gtk.Accel_Group.Gtk_Accel_Key; Closure : System.Address; Data : System.Address) return Glib.Gboolean; pragma Convention (C, Internal_Gtk_Accel_Group_Find_Func); ---------------------------------------- -- Internal_Gtk_Accel_Group_Find_Func -- ---------------------------------------- function Internal_Gtk_Accel_Group_Find_Func (Key : access Gtk.Accel_Group.Gtk_Accel_Key; Closure : System.Address; Data : System.Address) return Glib.Gboolean is Func : constant Gtk_Accel_Group_Find_Func := To_Gtk_Accel_Group_Find_Func (Data); begin return Boolean'Pos (Func (Key.all, Closure)); end Internal_Gtk_Accel_Group_Find_Func; package Type_Conversion_Gtk_Accel_Group is new Glib.Type_Conversion_Hooks.Hook_Registrator (Get_Type'Access, Gtk_Accel_Group_Record); pragma Unreferenced (Type_Conversion_Gtk_Accel_Group); ------------------------- -- Gtk_Accel_Group_New -- ------------------------- function Gtk_Accel_Group_New return Gtk_Accel_Group is Accel_Group : constant Gtk_Accel_Group := new Gtk_Accel_Group_Record; begin Gtk.Accel_Group.Initialize (Accel_Group); return Accel_Group; end Gtk_Accel_Group_New; ------------- -- Gtk_New -- ------------- procedure Gtk_New (Accel_Group : out Gtk_Accel_Group) is begin Accel_Group := new Gtk_Accel_Group_Record; Gtk.Accel_Group.Initialize (Accel_Group); end Gtk_New; ---------------- -- Initialize -- ---------------- procedure Initialize (Accel_Group : not null access Gtk_Accel_Group_Record'Class) is function Internal return System.Address; pragma Import (C, Internal, "gtk_accel_group_new"); begin if not Accel_Group.Is_Created then Set_Object (Accel_Group, Internal); end if; end Initialize; -------------- -- Activate -- -------------- function Activate (Accel_Group : not null access Gtk_Accel_Group_Record; Accel_Quark : Glib.GQuark; Acceleratable : not null access Glib.Object.GObject_Record'Class; Accel_Key : Gdk.Types.Gdk_Key_Type; Accel_Mods : Gdk.Types.Gdk_Modifier_Type) return Boolean is function Internal (Accel_Group : System.Address; Accel_Quark : Glib.GQuark; Acceleratable : System.Address; Accel_Key : Gdk.Types.Gdk_Key_Type; Accel_Mods : Gdk.Types.Gdk_Modifier_Type) return Glib.Gboolean; pragma Import (C, Internal, "gtk_accel_group_activate"); begin return Internal (Get_Object (Accel_Group), Accel_Quark, Get_Object (Acceleratable), Accel_Key, Accel_Mods) /= 0; end Activate; ------------- -- Connect -- ------------- procedure Connect (Accel_Group : not null access Gtk_Accel_Group_Record; Accel_Key : Gdk.Types.Gdk_Key_Type; Accel_Mods : Gdk.Types.Gdk_Modifier_Type; Accel_Flags : Gtk_Accel_Flags; Closure : C_Gtk_Accel_Group_Activate) is procedure Internal (Accel_Group : System.Address; Accel_Key : Gdk.Types.Gdk_Key_Type; Accel_Mods : Gdk.Types.Gdk_Modifier_Type; Accel_Flags : Gtk_Accel_Flags; Closure : C_Gtk_Accel_Group_Activate); pragma Import (C, Internal, "gtk_accel_group_connect"); begin Internal (Get_Object (Accel_Group), Accel_Key, Accel_Mods, Accel_Flags, Closure); end Connect; --------------------- -- Connect_By_Path -- --------------------- procedure Connect_By_Path (Accel_Group : not null access Gtk_Accel_Group_Record; Accel_Path : UTF8_String; Closure : C_Gtk_Accel_Group_Activate) is procedure Internal (Accel_Group : System.Address; Accel_Path : Gtkada.Types.Chars_Ptr; Closure : C_Gtk_Accel_Group_Activate); pragma Import (C, Internal, "gtk_accel_group_connect_by_path"); Tmp_Accel_Path : Gtkada.Types.Chars_Ptr := New_String (Accel_Path); begin Internal (Get_Object (Accel_Group), Tmp_Accel_Path, Closure); Free (Tmp_Accel_Path); end Connect_By_Path; ---------------- -- Disconnect -- ---------------- function Disconnect (Accel_Group : not null access Gtk_Accel_Group_Record; Closure : C_Gtk_Accel_Group_Activate) return Boolean is function Internal (Accel_Group : System.Address; Closure : C_Gtk_Accel_Group_Activate) return Glib.Gboolean; pragma Import (C, Internal, "gtk_accel_group_disconnect"); begin return Internal (Get_Object (Accel_Group), Closure) /= 0; end Disconnect; -------------------- -- Disconnect_Key -- -------------------- function Disconnect_Key (Accel_Group : not null access Gtk_Accel_Group_Record; Accel_Key : Gdk.Types.Gdk_Key_Type; Accel_Mods : Gdk.Types.Gdk_Modifier_Type) return Boolean is function Internal (Accel_Group : System.Address; Accel_Key : Gdk.Types.Gdk_Key_Type; Accel_Mods : Gdk.Types.Gdk_Modifier_Type) return Glib.Gboolean; pragma Import (C, Internal, "gtk_accel_group_disconnect_key"); begin return Internal (Get_Object (Accel_Group), Accel_Key, Accel_Mods) /= 0; end Disconnect_Key; ---------- -- Find -- ---------- function Find (Accel_Group : not null access Gtk_Accel_Group_Record; Find_Func : Gtk_Accel_Group_Find_Func) return Gtk_Accel_Key is begin if Find_Func = null then return C_Gtk_Accel_Group_Find (Get_Object (Accel_Group), System.Null_Address, System.Null_Address).all; else return C_Gtk_Accel_Group_Find (Get_Object (Accel_Group), Internal_Gtk_Accel_Group_Find_Func'Address, To_Address (Find_Func)).all; end if; end Find; ------------------- -- Get_Is_Locked -- ------------------- function Get_Is_Locked (Accel_Group : not null access Gtk_Accel_Group_Record) return Boolean is function Internal (Accel_Group : System.Address) return Glib.Gboolean; pragma Import (C, Internal, "gtk_accel_group_get_is_locked"); begin return Internal (Get_Object (Accel_Group)) /= 0; end Get_Is_Locked; ----------------------- -- Get_Modifier_Mask -- ----------------------- function Get_Modifier_Mask (Accel_Group : not null access Gtk_Accel_Group_Record) return Gdk.Types.Gdk_Modifier_Type is function Internal (Accel_Group : System.Address) return Gdk.Types.Gdk_Modifier_Type; pragma Import (C, Internal, "gtk_accel_group_get_modifier_mask"); begin return Internal (Get_Object (Accel_Group)); end Get_Modifier_Mask; ---------- -- Lock -- ---------- procedure Lock (Accel_Group : not null access Gtk_Accel_Group_Record) is procedure Internal (Accel_Group : System.Address); pragma Import (C, Internal, "gtk_accel_group_lock"); begin Internal (Get_Object (Accel_Group)); end Lock; ------------ -- Unlock -- ------------ procedure Unlock (Accel_Group : not null access Gtk_Accel_Group_Record) is procedure Internal (Accel_Group : System.Address); pragma Import (C, Internal, "gtk_accel_group_unlock"); begin Internal (Get_Object (Accel_Group)); end Unlock; --------------------------- -- Accel_Groups_Activate -- --------------------------- function Accel_Groups_Activate (Object : not null access Glib.Object.GObject_Record'Class; Accel_Key : Gdk.Types.Gdk_Key_Type; Accel_Mods : Gdk.Types.Gdk_Modifier_Type) return Boolean is function Internal (Object : System.Address; Accel_Key : Gdk.Types.Gdk_Key_Type; Accel_Mods : Gdk.Types.Gdk_Modifier_Type) return Glib.Gboolean; pragma Import (C, Internal, "gtk_accel_groups_activate"); begin return Internal (Get_Object (Object), Accel_Key, Accel_Mods) /= 0; end Accel_Groups_Activate; --------------------------- -- Accelerator_Get_Label -- --------------------------- function Accelerator_Get_Label (Accelerator_Key : Gdk.Types.Gdk_Key_Type; Accelerator_Mods : Gdk.Types.Gdk_Modifier_Type) return UTF8_String is function Internal (Accelerator_Key : Gdk.Types.Gdk_Key_Type; Accelerator_Mods : Gdk.Types.Gdk_Modifier_Type) return Gtkada.Types.Chars_Ptr; pragma Import (C, Internal, "gtk_accelerator_get_label"); begin return Gtkada.Bindings.Value_And_Free (Internal (Accelerator_Key, Accelerator_Mods)); end Accelerator_Get_Label; ---------------------- -- Accelerator_Name -- ---------------------- function Accelerator_Name (Accelerator_Key : Gdk.Types.Gdk_Key_Type; Accelerator_Mods : Gdk.Types.Gdk_Modifier_Type) return UTF8_String is function Internal (Accelerator_Key : Gdk.Types.Gdk_Key_Type; Accelerator_Mods : Gdk.Types.Gdk_Modifier_Type) return Gtkada.Types.Chars_Ptr; pragma Import (C, Internal, "gtk_accelerator_name"); begin return Gtkada.Bindings.Value_And_Free (Internal (Accelerator_Key, Accelerator_Mods)); end Accelerator_Name; ----------------------- -- Accelerator_Parse -- ----------------------- procedure Accelerator_Parse (Accelerator : UTF8_String; Accelerator_Key : out Gdk.Types.Gdk_Key_Type; Accelerator_Mods : out Gdk.Types.Gdk_Modifier_Type) is procedure Internal (Accelerator : Gtkada.Types.Chars_Ptr; Accelerator_Key : out Gdk.Types.Gdk_Key_Type; Accelerator_Mods : out Gdk.Types.Gdk_Modifier_Type); pragma Import (C, Internal, "gtk_accelerator_parse"); Tmp_Accelerator : Gtkada.Types.Chars_Ptr := New_String (Accelerator); begin Internal (Tmp_Accelerator, Accelerator_Key, Accelerator_Mods); Free (Tmp_Accelerator); end Accelerator_Parse; ----------------------- -- Accelerator_Valid -- ----------------------- function Accelerator_Valid (Keyval : Gdk.Types.Gdk_Key_Type; Modifiers : Gdk.Types.Gdk_Modifier_Type) return Boolean is function Internal (Keyval : Gdk.Types.Gdk_Key_Type; Modifiers : Gdk.Types.Gdk_Modifier_Type) return Glib.Gboolean; pragma Import (C, Internal, "gtk_accelerator_valid"); begin return Internal (Keyval, Modifiers) /= 0; end Accelerator_Valid; ------------------------ -- From_Accel_Closure -- ------------------------ function From_Accel_Closure (Closure : C_Gtk_Accel_Group_Activate) return Gtk_Accel_Group is function Internal (Closure : C_Gtk_Accel_Group_Activate) return System.Address; pragma Import (C, Internal, "gtk_accel_group_from_accel_closure"); Stub_Gtk_Accel_Group : Gtk_Accel_Group_Record; begin return Gtk.Accel_Group.Gtk_Accel_Group (Get_User_Data (Internal (Closure), Stub_Gtk_Accel_Group)); end From_Accel_Closure; ----------------- -- From_Object -- ----------------- function From_Object (Object : not null access Glib.Object.GObject_Record'Class) return Glib.Object.Object_List.GSlist is function Internal (Object : System.Address) return System.Address; pragma Import (C, Internal, "gtk_accel_groups_from_object"); Tmp_Return : Glib.Object.Object_List.GSlist; begin Glib.Object.Object_List.Set_Object (Tmp_Return, Internal (Get_Object (Object))); return Tmp_Return; end From_Object; -------------------------- -- Get_Default_Mod_Mask -- -------------------------- function Get_Default_Mod_Mask return Gdk.Types.Gdk_Modifier_Type is function Internal return Gdk.Types.Gdk_Modifier_Type; pragma Import (C, Internal, "gtk_accelerator_get_default_mod_mask"); begin return Internal; end Get_Default_Mod_Mask; -------------------------- -- Set_Default_Mod_Mask -- -------------------------- procedure Set_Default_Mod_Mask (Default_Mod_Mask : Gdk.Types.Gdk_Modifier_Type) is procedure Internal (Default_Mod_Mask : Gdk.Types.Gdk_Modifier_Type); pragma Import (C, Internal, "gtk_accelerator_set_default_mod_mask"); begin Internal (Default_Mod_Mask); end Set_Default_Mod_Mask; use type System.Address; function Cb_To_Address is new Ada.Unchecked_Conversion (Cb_Gtk_Accel_Group_GObject_Guint_Gdk_Modifier_Type_Boolean, System.Address); function Address_To_Cb is new Ada.Unchecked_Conversion (System.Address, Cb_Gtk_Accel_Group_GObject_Guint_Gdk_Modifier_Type_Boolean); function Cb_To_Address is new Ada.Unchecked_Conversion (Cb_GObject_GObject_Guint_Gdk_Modifier_Type_Boolean, System.Address); function Address_To_Cb is new Ada.Unchecked_Conversion (System.Address, Cb_GObject_GObject_Guint_Gdk_Modifier_Type_Boolean); function Cb_To_Address is new Ada.Unchecked_Conversion (Cb_Gtk_Accel_Group_Guint_Gdk_Modifier_Type_Address_Void, System.Address); function Address_To_Cb is new Ada.Unchecked_Conversion (System.Address, Cb_Gtk_Accel_Group_Guint_Gdk_Modifier_Type_Address_Void); function Cb_To_Address is new Ada.Unchecked_Conversion (Cb_GObject_Guint_Gdk_Modifier_Type_Address_Void, System.Address); function Address_To_Cb is new Ada.Unchecked_Conversion (System.Address, Cb_GObject_Guint_Gdk_Modifier_Type_Address_Void); procedure Connect (Object : access Gtk_Accel_Group_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_Gtk_Accel_Group_GObject_Guint_Gdk_Modifier_Type_Boolean; After : Boolean); procedure Connect (Object : access Gtk_Accel_Group_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_Gtk_Accel_Group_Guint_Gdk_Modifier_Type_Address_Void; After : Boolean); procedure Connect_Slot (Object : access Gtk_Accel_Group_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_GObject_GObject_Guint_Gdk_Modifier_Type_Boolean; After : Boolean; Slot : access Glib.Object.GObject_Record'Class := null); procedure Connect_Slot (Object : access Gtk_Accel_Group_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_GObject_Guint_Gdk_Modifier_Type_Address_Void; After : Boolean; Slot : access Glib.Object.GObject_Record'Class := null); procedure Marsh_GObject_GObject_Guint_Gdk_Modifier_Type_Boolean (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address); pragma Convention (C, Marsh_GObject_GObject_Guint_Gdk_Modifier_Type_Boolean); procedure Marsh_GObject_Guint_Gdk_Modifier_Type_Address_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address); pragma Convention (C, Marsh_GObject_Guint_Gdk_Modifier_Type_Address_Void); procedure Marsh_Gtk_Accel_Group_GObject_Guint_Gdk_Modifier_Type_Boolean (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address); pragma Convention (C, Marsh_Gtk_Accel_Group_GObject_Guint_Gdk_Modifier_Type_Boolean); procedure Marsh_Gtk_Accel_Group_Guint_Gdk_Modifier_Type_Address_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address); pragma Convention (C, Marsh_Gtk_Accel_Group_Guint_Gdk_Modifier_Type_Address_Void); ------------- -- Connect -- ------------- procedure Connect (Object : access Gtk_Accel_Group_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_Gtk_Accel_Group_GObject_Guint_Gdk_Modifier_Type_Boolean; After : Boolean) is begin Unchecked_Do_Signal_Connect (Object => Object, C_Name => C_Name, Marshaller => Marsh_Gtk_Accel_Group_GObject_Guint_Gdk_Modifier_Type_Boolean'Access, Handler => Cb_To_Address (Handler),-- Set in the closure After => After); end Connect; ------------- -- Connect -- ------------- procedure Connect (Object : access Gtk_Accel_Group_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_Gtk_Accel_Group_Guint_Gdk_Modifier_Type_Address_Void; After : Boolean) is begin Unchecked_Do_Signal_Connect (Object => Object, C_Name => C_Name, Marshaller => Marsh_Gtk_Accel_Group_Guint_Gdk_Modifier_Type_Address_Void'Access, Handler => Cb_To_Address (Handler),-- Set in the closure After => After); end Connect; ------------------ -- Connect_Slot -- ------------------ procedure Connect_Slot (Object : access Gtk_Accel_Group_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_GObject_GObject_Guint_Gdk_Modifier_Type_Boolean; After : Boolean; Slot : access Glib.Object.GObject_Record'Class := null) is begin Unchecked_Do_Signal_Connect (Object => Object, C_Name => C_Name, Marshaller => Marsh_GObject_GObject_Guint_Gdk_Modifier_Type_Boolean'Access, Handler => Cb_To_Address (Handler),-- Set in the closure Slot_Object => Slot, After => After); end Connect_Slot; ------------------ -- Connect_Slot -- ------------------ procedure Connect_Slot (Object : access Gtk_Accel_Group_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_GObject_Guint_Gdk_Modifier_Type_Address_Void; After : Boolean; Slot : access Glib.Object.GObject_Record'Class := null) is begin Unchecked_Do_Signal_Connect (Object => Object, C_Name => C_Name, Marshaller => Marsh_GObject_Guint_Gdk_Modifier_Type_Address_Void'Access, Handler => Cb_To_Address (Handler),-- Set in the closure Slot_Object => Slot, After => After); end Connect_Slot; ----------------------------------------------------------- -- Marsh_GObject_GObject_Guint_Gdk_Modifier_Type_Boolean -- ----------------------------------------------------------- procedure Marsh_GObject_GObject_Guint_Gdk_Modifier_Type_Boolean (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address) is pragma Unreferenced (N_Params, Invocation_Hint, User_Data); H : constant Cb_GObject_GObject_Guint_Gdk_Modifier_Type_Boolean := Address_To_Cb (Get_Callback (Closure)); Obj : constant Glib.Object.GObject := Glib.Object.Convert (Get_Data (Closure)); V : aliased Boolean := H (Obj, Unchecked_To_Object (Params, 1), Unchecked_To_Guint (Params, 2), Unchecked_To_Gdk_Modifier_Type (Params, 3)); begin Set_Value (Return_Value, V'Address); exception when E : others => Process_Exception (E); end Marsh_GObject_GObject_Guint_Gdk_Modifier_Type_Boolean; -------------------------------------------------------- -- Marsh_GObject_Guint_Gdk_Modifier_Type_Address_Void -- -------------------------------------------------------- procedure Marsh_GObject_Guint_Gdk_Modifier_Type_Address_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address) is pragma Unreferenced (Return_Value, N_Params, Invocation_Hint, User_Data); H : constant Cb_GObject_Guint_Gdk_Modifier_Type_Address_Void := Address_To_Cb (Get_Callback (Closure)); Obj : constant Glib.Object.GObject := Glib.Object.Convert (Get_Data (Closure)); begin H (Obj, Unchecked_To_Guint (Params, 1), Unchecked_To_Gdk_Modifier_Type (Params, 2), Unchecked_To_Address (Params, 3)); exception when E : others => Process_Exception (E); end Marsh_GObject_Guint_Gdk_Modifier_Type_Address_Void; ------------------------------------------------------------------- -- Marsh_Gtk_Accel_Group_GObject_Guint_Gdk_Modifier_Type_Boolean -- ------------------------------------------------------------------- procedure Marsh_Gtk_Accel_Group_GObject_Guint_Gdk_Modifier_Type_Boolean (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address) is pragma Unreferenced (N_Params, Invocation_Hint, User_Data); H : constant Cb_Gtk_Accel_Group_GObject_Guint_Gdk_Modifier_Type_Boolean := Address_To_Cb (Get_Callback (Closure)); Obj : constant Gtk_Accel_Group := Gtk_Accel_Group (Unchecked_To_Object (Params, 0)); V : aliased Boolean := H (Obj, Unchecked_To_Object (Params, 1), Unchecked_To_Guint (Params, 2), Unchecked_To_Gdk_Modifier_Type (Params, 3)); begin Set_Value (Return_Value, V'Address); exception when E : others => Process_Exception (E); end Marsh_Gtk_Accel_Group_GObject_Guint_Gdk_Modifier_Type_Boolean; ---------------------------------------------------------------- -- Marsh_Gtk_Accel_Group_Guint_Gdk_Modifier_Type_Address_Void -- ---------------------------------------------------------------- procedure Marsh_Gtk_Accel_Group_Guint_Gdk_Modifier_Type_Address_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address) is pragma Unreferenced (Return_Value, N_Params, Invocation_Hint, User_Data); H : constant Cb_Gtk_Accel_Group_Guint_Gdk_Modifier_Type_Address_Void := Address_To_Cb (Get_Callback (Closure)); Obj : constant Gtk_Accel_Group := Gtk_Accel_Group (Unchecked_To_Object (Params, 0)); begin H (Obj, Unchecked_To_Guint (Params, 1), Unchecked_To_Gdk_Modifier_Type (Params, 2), Unchecked_To_Address (Params, 3)); exception when E : others => Process_Exception (E); end Marsh_Gtk_Accel_Group_Guint_Gdk_Modifier_Type_Address_Void; ----------------------- -- On_Accel_Activate -- ----------------------- procedure On_Accel_Activate (Self : not null access Gtk_Accel_Group_Record; Call : Cb_Gtk_Accel_Group_GObject_Guint_Gdk_Modifier_Type_Boolean; After : Boolean := False) is begin Connect (Self, "accel-activate" & ASCII.NUL, Call, After); end On_Accel_Activate; ----------------------- -- On_Accel_Activate -- ----------------------- procedure On_Accel_Activate (Self : not null access Gtk_Accel_Group_Record; Call : Cb_GObject_GObject_Guint_Gdk_Modifier_Type_Boolean; Slot : not null access Glib.Object.GObject_Record'Class; After : Boolean := False) is begin Connect_Slot (Self, "accel-activate" & ASCII.NUL, Call, After, Slot); end On_Accel_Activate; ---------------------- -- On_Accel_Changed -- ---------------------- procedure On_Accel_Changed (Self : not null access Gtk_Accel_Group_Record; Call : Cb_Gtk_Accel_Group_Guint_Gdk_Modifier_Type_Address_Void; After : Boolean := False) is begin Connect (Self, "accel-changed" & ASCII.NUL, Call, After); end On_Accel_Changed; ---------------------- -- On_Accel_Changed -- ---------------------- procedure On_Accel_Changed (Self : not null access Gtk_Accel_Group_Record; Call : Cb_GObject_Guint_Gdk_Modifier_Type_Address_Void; Slot : not null access Glib.Object.GObject_Record'Class; After : Boolean := False) is begin Connect_Slot (Self, "accel-changed" & ASCII.NUL, Call, After, Slot); end On_Accel_Changed; end Gtk.Accel_Group; gtkada-24.0.0/src/generated/gtk-accel_group.ads000066400000000000000000000460251446021174000213220ustar00rootroot00000000000000------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ -- -- A Gtk.Accel_Group.Gtk_Accel_Group represents a group of keyboard -- accelerators, typically attached to a toplevel Gtk.Window.Gtk_Window (with -- Gtk.Window.Add_Accel_Group). Usually you won't need to create a -- Gtk.Accel_Group.Gtk_Accel_Group directly; instead, when using -- Gtk.UI_Manager.Gtk_UI_Manager, GTK+ automatically sets up the accelerators -- for your menus in the ui manager's Gtk.Accel_Group.Gtk_Accel_Group. -- -- Note that "accelerators" are different from "mnemonics". Accelerators are -- shortcuts for activating a menu item; they appear alongside the menu item -- they're a shortcut for. For example "Ctrl+Q" might appear alongside the -- "Quit" menu item. Mnemonics are shortcuts for GUI elements such as text -- entries or buttons; they appear as underlined characters. See -- Gtk.Label.Gtk_New_With_Mnemonic. Menu items can have both accelerators and -- mnemonics, of course. -- -- pragma Warnings (Off, "*is already use-visible*"); with Gdk.Types; use Gdk.Types; with Glib; use Glib; with Glib.Generic_Properties; use Glib.Generic_Properties; with Glib.Object; use Glib.Object; with Glib.Properties; use Glib.Properties; package Gtk.Accel_Group is type Gtk_Accel_Group_Record is new GObject_Record with null record; type Gtk_Accel_Group is access all Gtk_Accel_Group_Record'Class; type Gtk_Accel_Flags is mod 2 ** Integer'Size; pragma Convention (C, Gtk_Accel_Flags); -- Accelerator flags used with Gtk.Accel_Group.Connect. Accel_Visible : constant Gtk_Accel_Flags := 1; Accel_Locked : constant Gtk_Accel_Flags := 2; Accel_Mask : constant Gtk_Accel_Flags := 7; type Gtk_Accel_Key is record Accel_Key : Gdk.Types.Gdk_Key_Type; Accel_Mods : Gdk.Types.Gdk_Modifier_Type; Accel_Flags : Gtk_Accel_Flags; end record; pragma Convention (C, Gtk_Accel_Key); function From_Object_Free (B : access Gtk_Accel_Key) return Gtk_Accel_Key; pragma Inline (From_Object_Free); type Gtk_Accel_Group_Activate is access function (Accel_Group : access Gtk_Accel_Group_Record'Class; Acceleratable : Glib.Object.GObject; Keyval : Gdk.Types.Gdk_Key_Type; Modifier : Gdk.Types.Gdk_Modifier_Type) return Boolean; type C_Gtk_Accel_Group_Activate is access function (Accel_Group : System.Address; Acceleratable : System.Address; Keyval : Gdk.Types.Gdk_Key_Type; Modifier : Gdk.Types.Gdk_Modifier_Type) return Boolean; pragma Convention (C, C_Gtk_Accel_Group_Activate); -- Same as Gtk_Accel_Group_Activate, but passing directly the C values. -- You must use Get_User_Data to convert to the Ada types. --------------- -- Callbacks -- --------------- type Gtk_Accel_Group_Find_Func is access function (Key : Gtk_Accel_Key; Closure : System.Address) return Boolean; -- Since: gtk+ 2.2 ---------------------------- -- Enumeration Properties -- ---------------------------- package Gtk_Accel_Flags_Properties is new Generic_Internal_Discrete_Property (Gtk_Accel_Flags); type Property_Gtk_Accel_Flags is new Gtk_Accel_Flags_Properties.Property; ------------------ -- Constructors -- ------------------ procedure Gtk_New (Accel_Group : out Gtk_Accel_Group); procedure Initialize (Accel_Group : not null access Gtk_Accel_Group_Record'Class); -- Creates a new Gtk.Accel_Group.Gtk_Accel_Group. Remember to call -- Gtk.Window.Add_Accel_Group to active the group. -- Initialize does nothing if the object was already created with another -- call to Initialize* or G_New. function Gtk_Accel_Group_New return Gtk_Accel_Group; -- Creates a new Gtk.Accel_Group.Gtk_Accel_Group. Remember to call -- Gtk.Window.Add_Accel_Group to active the group. function Get_Type return Glib.GType; pragma Import (C, Get_Type, "gtk_accel_group_get_type"); ------------- -- Methods -- ------------- function Activate (Accel_Group : not null access Gtk_Accel_Group_Record; Accel_Quark : Glib.GQuark; Acceleratable : not null access Glib.Object.GObject_Record'Class; Accel_Key : Gdk.Types.Gdk_Key_Type; Accel_Mods : Gdk.Types.Gdk_Modifier_Type) return Boolean; -- Finds the first accelerator in Accel_Group that matches Accel_Key and -- Accel_Mods, and activates it. -- "accel_quark": the quark for the accelerator name -- "acceleratable": the Glib.Object.GObject, usually a -- Gtk.Window.Gtk_Window, on which to activate the accelerator -- "accel_key": accelerator keyval from a key event -- "accel_mods": keyboard state mask from a key event procedure Connect (Accel_Group : not null access Gtk_Accel_Group_Record; Accel_Key : Gdk.Types.Gdk_Key_Type; Accel_Mods : Gdk.Types.Gdk_Modifier_Type; Accel_Flags : Gtk_Accel_Flags; Closure : C_Gtk_Accel_Group_Activate); -- Installs an accelerator in this group. When Accel_Group is being -- activated in response to a call to -- Gtk.Accel_Group.Accel_Groups_Activate, Closure will be invoked if the -- Accel_Key and Accel_Mods from Gtk.Accel_Group.Accel_Groups_Activate -- match those of this connection. -- The signature used for the Closure is that of Gtk_Accel_Group_Activate. -- Note that, due to implementation details, a single closure can only be -- connected to one accelerator group. -- "accel_key": key value of the accelerator -- "accel_mods": modifier combination of the accelerator -- "accel_flags": a flag mask to configure this accelerator -- "closure": closure to be executed upon accelerator activation procedure Connect_By_Path (Accel_Group : not null access Gtk_Accel_Group_Record; Accel_Path : UTF8_String; Closure : C_Gtk_Accel_Group_Activate); -- Installs an accelerator in this group, using an accelerator path to -- look up the appropriate key and modifiers (see Gtk.Accel_Map.Add_Entry). -- When Accel_Group is being activated in response to a call to -- Gtk.Accel_Group.Accel_Groups_Activate, Closure will be invoked if the -- Accel_Key and Accel_Mods from Gtk.Accel_Group.Accel_Groups_Activate -- match the key and modifiers for the path. -- The signature used for the Closure is that of Gtk_Accel_Group_Activate. -- Note that Accel_Path string will be stored in a Glib.GQuark. Therefore, -- if you pass a static string, you can save some memory by interning it -- first with g_intern_static_string. -- "accel_path": path used for determining key and modifiers -- "closure": closure to be executed upon accelerator activation function Disconnect (Accel_Group : not null access Gtk_Accel_Group_Record; Closure : C_Gtk_Accel_Group_Activate) return Boolean; -- Removes an accelerator previously installed through -- Gtk.Accel_Group.Connect. -- Since 2.20 Closure can be null. -- "closure": the closure to remove from this accelerator group, or null -- to remove all closures function Disconnect_Key (Accel_Group : not null access Gtk_Accel_Group_Record; Accel_Key : Gdk.Types.Gdk_Key_Type; Accel_Mods : Gdk.Types.Gdk_Modifier_Type) return Boolean; -- Removes an accelerator previously installed through -- Gtk.Accel_Group.Connect. -- "accel_key": key value of the accelerator -- "accel_mods": modifier combination of the accelerator function Find (Accel_Group : not null access Gtk_Accel_Group_Record; Find_Func : Gtk_Accel_Group_Find_Func) return Gtk_Accel_Key; -- Finds the first entry in an accelerator group for which Find_Func -- returns True and returns its Gtk.Accel_Group.Gtk_Accel_Key. -- "find_func": a function to filter the entries of Accel_Group with function Get_Is_Locked (Accel_Group : not null access Gtk_Accel_Group_Record) return Boolean; -- Locks are added and removed using Gtk.Accel_Group.Lock and -- Gtk.Accel_Group.Unlock. -- Since: gtk+ 2.14 function Get_Modifier_Mask (Accel_Group : not null access Gtk_Accel_Group_Record) return Gdk.Types.Gdk_Modifier_Type; -- Gets a Gdk.Types.Gdk_Modifier_Type representing the mask for this -- Accel_Group. For example, GDK_CONTROL_MASK, GDK_SHIFT_MASK, etc. -- Since: gtk+ 2.14 procedure Lock (Accel_Group : not null access Gtk_Accel_Group_Record); -- Locks the given accelerator group. -- Locking an acelerator group prevents the accelerators contained within -- it to be changed during runtime. Refer to Gtk.Accel_Map.Change_Entry -- about runtime accelerator changes. -- If called more than once, Accel_Group remains locked until -- Gtk.Accel_Group.Unlock has been called an equivalent number of times. procedure Unlock (Accel_Group : not null access Gtk_Accel_Group_Record); -- Undoes the last call to Gtk.Accel_Group.Lock on this Accel_Group. --------------- -- Functions -- --------------- function From_Accel_Closure (Closure : C_Gtk_Accel_Group_Activate) return Gtk_Accel_Group; -- Finds the Gtk.Accel_Group.Gtk_Accel_Group to which Closure is -- connected; see Gtk.Accel_Group.Connect. -- "closure": a GClosure function Accel_Groups_Activate (Object : not null access Glib.Object.GObject_Record'Class; Accel_Key : Gdk.Types.Gdk_Key_Type; Accel_Mods : Gdk.Types.Gdk_Modifier_Type) return Boolean; -- Finds the first accelerator in any Gtk.Accel_Group.Gtk_Accel_Group -- attached to Object that matches Accel_Key and Accel_Mods, and activates -- that accelerator. -- "object": the Glib.Object.GObject, usually a Gtk.Window.Gtk_Window, on -- which to activate the accelerator -- "accel_key": accelerator keyval from a key event -- "accel_mods": keyboard state mask from a key event function From_Object (Object : not null access Glib.Object.GObject_Record'Class) return Glib.Object.Object_List.GSlist; -- Gets a list of all accel groups which are attached to Object. -- "object": a Glib.Object.GObject, usually a Gtk.Window.Gtk_Window function Accelerator_Valid (Keyval : Gdk.Types.Gdk_Key_Type; Modifiers : Gdk.Types.Gdk_Modifier_Type) return Boolean; -- Determines whether a given keyval and modifier mask constitute a valid -- keyboard accelerator. For example, the GDK_KEY_a keyval plus -- GDK_CONTROL_MASK is valid - this is a "Ctrl+a" accelerator. But, you -- can't, for instance, use the GDK_KEY_Control_L keyval as an accelerator. -- "keyval": a GDK keyval -- "modifiers": modifier mask procedure Accelerator_Parse (Accelerator : UTF8_String; Accelerator_Key : out Gdk.Types.Gdk_Key_Type; Accelerator_Mods : out Gdk.Types.Gdk_Modifier_Type); -- Parses a string representing an accelerator. The format looks like -- "a" or "F1" or "z" (the last one is for -- key release). -- The parser is fairly liberal and allows lower or upper case, and also -- abbreviations such as "" and "". Key names are parsed using -- gdk_keyval_from_name. For character keys the name is not the symbol, but -- the lowercase name, e.g. one would use "minus" instead of -- "-". -- If the parse fails, Accelerator_Key and Accelerator_Mods will be set to -- 0 (zero). -- "accelerator": string representing an accelerator -- "accelerator_key": return location for accelerator keyval, or null -- "accelerator_mods": return location for accelerator modifier mask, null function Accelerator_Name (Accelerator_Key : Gdk.Types.Gdk_Key_Type; Accelerator_Mods : Gdk.Types.Gdk_Modifier_Type) return UTF8_String; -- Converts an accelerator keyval and modifier mask into a string -- parseable by Gtk.Accel_Group.Accelerator_Parse. For example, if you pass -- in GDK_KEY_q and GDK_CONTROL_MASK, this function returns "q". -- If you need to display accelerators in the user interface, see -- Gtk.Accel_Group.Accelerator_Get_Label. -- "accelerator_key": accelerator keyval -- "accelerator_mods": accelerator modifier mask function Accelerator_Get_Label (Accelerator_Key : Gdk.Types.Gdk_Key_Type; Accelerator_Mods : Gdk.Types.Gdk_Modifier_Type) return UTF8_String; -- Converts an accelerator keyval and modifier mask into a string which -- can be used to represent the accelerator to the user. -- Since: gtk+ 2.6 -- "accelerator_key": accelerator keyval -- "accelerator_mods": accelerator modifier mask procedure Set_Default_Mod_Mask (Default_Mod_Mask : Gdk.Types.Gdk_Modifier_Type); -- Sets the modifiers that will be considered significant for keyboard -- accelerators. The default mod mask depends on the GDK backend in use, -- but will typically include GDK_CONTROL_MASK | GDK_SHIFT_MASK | -- GDK_MOD1_MASK | GDK_SUPER_MASK | GDK_HYPER_MASK | GDK_META_MASK. In -- other words, Control, Shift, Alt, Super, Hyper and Meta. Other modifiers -- will by default be ignored by Gtk.Accel_Group.Gtk_Accel_Group. -- You must include at least the three modifiers Control, Shift and Alt in -- any value you pass to this function. -- The default mod mask should be changed on application startup, before -- using any accelerator groups. -- "default_mod_mask": accelerator modifier mask function Get_Default_Mod_Mask return Gdk.Types.Gdk_Modifier_Type; -- Gets the modifier mask. -- The modifier mask determines which modifiers are considered significant -- for keyboard accelerators. See Gtk.Accel_Group.Set_Default_Mod_Mask. ---------------- -- Properties -- ---------------- -- The following properties are defined for this widget. See -- Glib.Properties for more information on properties) Is_Locked_Property : constant Glib.Properties.Property_Boolean; Modifier_Mask_Property : constant Glib.Properties.Property_Boxed; -- Type: Gdk.Types.Gdk_Modifier_Type ------------- -- Signals -- ------------- type Cb_Gtk_Accel_Group_GObject_Guint_Gdk_Modifier_Type_Boolean is not null access function (Self : access Gtk_Accel_Group_Record'Class; Acceleratable : not null access Glib.Object.GObject_Record'Class; Keyval : Guint; Modifier : Gdk.Types.Gdk_Modifier_Type) return Boolean; type Cb_GObject_GObject_Guint_Gdk_Modifier_Type_Boolean is not null access function (Self : access Glib.Object.GObject_Record'Class; Acceleratable : not null access Glib.Object.GObject_Record'Class; Keyval : Guint; Modifier : Gdk.Types.Gdk_Modifier_Type) return Boolean; Signal_Accel_Activate : constant Glib.Signal_Name := "accel-activate"; procedure On_Accel_Activate (Self : not null access Gtk_Accel_Group_Record; Call : Cb_Gtk_Accel_Group_GObject_Guint_Gdk_Modifier_Type_Boolean; After : Boolean := False); procedure On_Accel_Activate (Self : not null access Gtk_Accel_Group_Record; Call : Cb_GObject_GObject_Guint_Gdk_Modifier_Type_Boolean; Slot : not null access Glib.Object.GObject_Record'Class; After : Boolean := False); -- The accel-activate signal is an implementation detail of -- Gtk.Accel_Group.Gtk_Accel_Group and not meant to be used by -- applications. -- -- Callback parameters: -- -- "acceleratable": the object on which the accelerator was activated -- -- "keyval": the accelerator keyval -- -- "modifier": the modifier combination of the accelerator -- -- Returns True if the accelerator was activated type Cb_Gtk_Accel_Group_Guint_Gdk_Modifier_Type_Address_Void is not null access procedure (Self : access Gtk_Accel_Group_Record'Class; Keyval : Guint; Modifier : Gdk.Types.Gdk_Modifier_Type; Accel_Closure : System.Address); type Cb_GObject_Guint_Gdk_Modifier_Type_Address_Void is not null access procedure (Self : access Glib.Object.GObject_Record'Class; Keyval : Guint; Modifier : Gdk.Types.Gdk_Modifier_Type; Accel_Closure : System.Address); Signal_Accel_Changed : constant Glib.Signal_Name := "accel-changed"; procedure On_Accel_Changed (Self : not null access Gtk_Accel_Group_Record; Call : Cb_Gtk_Accel_Group_Guint_Gdk_Modifier_Type_Address_Void; After : Boolean := False); procedure On_Accel_Changed (Self : not null access Gtk_Accel_Group_Record; Call : Cb_GObject_Guint_Gdk_Modifier_Type_Address_Void; Slot : not null access Glib.Object.GObject_Record'Class; After : Boolean := False); -- The accel-changed signal is emitted when an entry is added to or -- removed from the accel group. -- -- Widgets like Gtk.Accel_Label.Gtk_Accel_Label which display an -- associated accelerator should connect to this signal, and rebuild their -- visual representation if the Accel_Closure is theirs. -- -- Callback parameters: -- -- "keyval": the accelerator keyval -- -- "modifier": the modifier combination of the accelerator -- -- "accel_closure": the GClosure of the accelerator private Modifier_Mask_Property : constant Glib.Properties.Property_Boxed := Glib.Properties.Build ("modifier-mask"); Is_Locked_Property : constant Glib.Properties.Property_Boolean := Glib.Properties.Build ("is-locked"); end Gtk.Accel_Group; gtkada-24.0.0/src/generated/gtk-accel_label.adb000066400000000000000000000160051446021174000212170ustar00rootroot00000000000000------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ pragma Style_Checks (Off); pragma Warnings (Off, "*is already use-visible*"); with Glib.Type_Conversion_Hooks; use Glib.Type_Conversion_Hooks; pragma Warnings(Off); -- might be unused with Gtkada.Types; use Gtkada.Types; pragma Warnings(On); package body Gtk.Accel_Label is package Type_Conversion_Gtk_Accel_Label is new Glib.Type_Conversion_Hooks.Hook_Registrator (Get_Type'Access, Gtk_Accel_Label_Record); pragma Unreferenced (Type_Conversion_Gtk_Accel_Label); ------------------------- -- Gtk_Accel_Label_New -- ------------------------- function Gtk_Accel_Label_New (String : UTF8_String) return Gtk_Accel_Label is Accel_Label : constant Gtk_Accel_Label := new Gtk_Accel_Label_Record; begin Gtk.Accel_Label.Initialize (Accel_Label, String); return Accel_Label; end Gtk_Accel_Label_New; ------------- -- Gtk_New -- ------------- procedure Gtk_New (Accel_Label : out Gtk_Accel_Label; String : UTF8_String) is begin Accel_Label := new Gtk_Accel_Label_Record; Gtk.Accel_Label.Initialize (Accel_Label, String); end Gtk_New; ---------------- -- Initialize -- ---------------- procedure Initialize (Accel_Label : not null access Gtk_Accel_Label_Record'Class; String : UTF8_String) is function Internal (String : Gtkada.Types.Chars_Ptr) return System.Address; pragma Import (C, Internal, "gtk_accel_label_new"); Tmp_String : Gtkada.Types.Chars_Ptr := New_String (String); Tmp_Return : System.Address; begin if not Accel_Label.Is_Created then Tmp_Return := Internal (Tmp_String); Free (Tmp_String); Set_Object (Accel_Label, Tmp_Return); end if; end Initialize; --------------- -- Get_Accel -- --------------- procedure Get_Accel (Accel_Label : not null access Gtk_Accel_Label_Record; Accelerator_Key : out Gdk.Types.Gdk_Key_Type; Accelerator_Mods : out Gdk.Types.Gdk_Modifier_Type) is procedure Internal (Accel_Label : System.Address; Accelerator_Key : out Gdk.Types.Gdk_Key_Type; Accelerator_Mods : out Gdk.Types.Gdk_Modifier_Type); pragma Import (C, Internal, "gtk_accel_label_get_accel"); begin Internal (Get_Object (Accel_Label), Accelerator_Key, Accelerator_Mods); end Get_Accel; ---------------------- -- Get_Accel_Widget -- ---------------------- function Get_Accel_Widget (Accel_Label : not null access Gtk_Accel_Label_Record) return Gtk.Widget.Gtk_Widget is function Internal (Accel_Label : System.Address) return System.Address; pragma Import (C, Internal, "gtk_accel_label_get_accel_widget"); Stub_Gtk_Widget : Gtk.Widget.Gtk_Widget_Record; begin return Gtk.Widget.Gtk_Widget (Get_User_Data (Internal (Get_Object (Accel_Label)), Stub_Gtk_Widget)); end Get_Accel_Widget; --------------------- -- Get_Accel_Width -- --------------------- function Get_Accel_Width (Accel_Label : not null access Gtk_Accel_Label_Record) return Guint is function Internal (Accel_Label : System.Address) return Guint; pragma Import (C, Internal, "gtk_accel_label_get_accel_width"); begin return Internal (Get_Object (Accel_Label)); end Get_Accel_Width; ------------- -- Refetch -- ------------- function Refetch (Accel_Label : not null access Gtk_Accel_Label_Record) return Boolean is function Internal (Accel_Label : System.Address) return Glib.Gboolean; pragma Import (C, Internal, "gtk_accel_label_refetch"); begin return Internal (Get_Object (Accel_Label)) /= 0; end Refetch; --------------- -- Set_Accel -- --------------- procedure Set_Accel (Accel_Label : not null access Gtk_Accel_Label_Record; Accelerator_Key : Gdk.Types.Gdk_Key_Type; Accelerator_Mods : Gdk.Types.Gdk_Modifier_Type) is procedure Internal (Accel_Label : System.Address; Accelerator_Key : Gdk.Types.Gdk_Key_Type; Accelerator_Mods : Gdk.Types.Gdk_Modifier_Type); pragma Import (C, Internal, "gtk_accel_label_set_accel"); begin Internal (Get_Object (Accel_Label), Accelerator_Key, Accelerator_Mods); end Set_Accel; ----------------------- -- Set_Accel_Closure -- ----------------------- procedure Set_Accel_Closure (Accel_Label : not null access Gtk_Accel_Label_Record; Accel_Closure : System.Address) is procedure Internal (Accel_Label : System.Address; Accel_Closure : System.Address); pragma Import (C, Internal, "gtk_accel_label_set_accel_closure"); begin Internal (Get_Object (Accel_Label), Accel_Closure); end Set_Accel_Closure; ---------------------- -- Set_Accel_Widget -- ---------------------- procedure Set_Accel_Widget (Accel_Label : not null access Gtk_Accel_Label_Record; Accel_Widget : access Gtk.Widget.Gtk_Widget_Record'Class) is procedure Internal (Accel_Label : System.Address; Accel_Widget : System.Address); pragma Import (C, Internal, "gtk_accel_label_set_accel_widget"); begin Internal (Get_Object (Accel_Label), Get_Object_Or_Null (GObject (Accel_Widget))); end Set_Accel_Widget; end Gtk.Accel_Label; gtkada-24.0.0/src/generated/gtk-accel_label.ads000066400000000000000000000235661446021174000212520ustar00rootroot00000000000000------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ -- -- The Gtk.Accel_Label.Gtk_Accel_Label widget is a subclass of -- Gtk.Label.Gtk_Label that also displays an accelerator key on the right of -- the label text, e.g. "Ctrl+S". It is commonly used in menus to show the -- keyboard short-cuts for commands. -- -- The accelerator key to display is typically not set explicitly (although -- it can be, with Gtk.Accel_Label.Set_Accel). Instead, the -- Gtk.Accel_Label.Gtk_Accel_Label displays the accelerators which have been -- added to a particular widget. This widget is set by calling -- Gtk.Accel_Label.Set_Accel_Widget. -- -- For example, a Gtk.Menu_Item.Gtk_Menu_Item widget may have an accelerator -- added to emit the "activate" signal when the "Ctrl+S" key combination is -- pressed. A Gtk.Accel_Label.Gtk_Accel_Label is created and added to the -- Gtk.Menu_Item.Gtk_Menu_Item, and Gtk.Accel_Label.Set_Accel_Widget is called -- with the Gtk.Menu_Item.Gtk_Menu_Item as the second argument. The -- Gtk.Accel_Label.Gtk_Accel_Label will now display "Ctrl+S" after its label. -- -- Note that creating a Gtk.Menu_Item.Gtk_Menu_Item with -- Gtk.Menu_Item.Gtk_New_With_Label (or one of the similar functions for -- Gtk.Check_Menu_Item.Gtk_Check_Menu_Item and -- Gtk.Radio_Menu_Item.Gtk_Radio_Menu_Item) automatically adds a -- Gtk.Accel_Label.Gtk_Accel_Label to the Gtk.Menu_Item.Gtk_Menu_Item and -- calls Gtk.Accel_Label.Set_Accel_Widget to set it up for you. -- -- A Gtk.Accel_Label.Gtk_Accel_Label will only display accelerators which -- have Gtk.Target_List.Accel_Visible set (see -- Gtk.Accel_Group.Gtk_Accel_Flags). A Gtk.Accel_Label.Gtk_Accel_Label can -- display multiple accelerators and even signal names, though it is almost -- always used to display just one accelerator key. -- -- ## Creating a simple menu item with an accelerator key. -- -- |[ GtkWidget *window = gtk_window_new -- (GTK_WINDOW_TOPLEVEL); GtkWidget *menu = gtk_menu_new (); GtkWidget -- *save_item; GtkAccelGroup *accel_group; -- -- // Create a GtkAccelGroup and add it to the window. accel_group = -- gtk_accel_group_new (); gtk_window_add_accel_group (GTK_WINDOW (window), -- accel_group); -- -- // Create the menu item using the convenience function. save_item = -- gtk_menu_item_new_with_label ("Save"); gtk_widget_show (save_item); -- gtk_container_add (GTK_CONTAINER (menu), save_item); -- -- // Now add the accelerator to the GtkMenuItem. Note that since we // -- called Gtk.Menu_Item.Gtk_New_With_Label to create the GtkMenuItem // the -- GtkAccelLabel is automatically set up to display the // GtkMenuItem -- accelerators. We just need to make sure we use // GTK_ACCEL_VISIBLE here. -- gtk_widget_add_accelerator (save_item, "activate", accel_group, GDK_KEY_s, -- GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); ]| -- -- # CSS nodes -- -- |[ label ╰── accelerator ]| -- -- Like Gtk.Label.Gtk_Label, GtkAccelLabel has a main CSS node with the name -- label. It adds a subnode with name accelerator. -- -- pragma Warnings (Off, "*is already use-visible*"); with Gdk.Types; use Gdk.Types; with Glib; use Glib; with Glib.Properties; use Glib.Properties; with Glib.Types; use Glib.Types; with Gtk.Buildable; use Gtk.Buildable; with Gtk.Label; use Gtk.Label; with Gtk.Widget; use Gtk.Widget; package Gtk.Accel_Label is type Gtk_Accel_Label_Record is new Gtk_Label_Record with null record; type Gtk_Accel_Label is access all Gtk_Accel_Label_Record'Class; ------------------ -- Constructors -- ------------------ procedure Gtk_New (Accel_Label : out Gtk_Accel_Label; String : UTF8_String); procedure Initialize (Accel_Label : not null access Gtk_Accel_Label_Record'Class; String : UTF8_String); -- Creates a new Gtk.Accel_Label.Gtk_Accel_Label. -- Initialize does nothing if the object was already created with another -- call to Initialize* or G_New. -- "string": the label string. Must be non-null. function Gtk_Accel_Label_New (String : UTF8_String) return Gtk_Accel_Label; -- Creates a new Gtk.Accel_Label.Gtk_Accel_Label. -- "string": the label string. Must be non-null. function Get_Type return Glib.GType; pragma Import (C, Get_Type, "gtk_accel_label_get_type"); ------------- -- Methods -- ------------- procedure Get_Accel (Accel_Label : not null access Gtk_Accel_Label_Record; Accelerator_Key : out Gdk.Types.Gdk_Key_Type; Accelerator_Mods : out Gdk.Types.Gdk_Modifier_Type); -- Gets the keyval and modifier mask set with Gtk.Accel_Label.Set_Accel. -- Since: gtk+ 3.12 -- "accelerator_key": return location for the keyval -- "accelerator_mods": return location for the modifier mask procedure Set_Accel (Accel_Label : not null access Gtk_Accel_Label_Record; Accelerator_Key : Gdk.Types.Gdk_Key_Type; Accelerator_Mods : Gdk.Types.Gdk_Modifier_Type); -- Manually sets a keyval and modifier mask as the accelerator rendered by -- Accel_Label. -- If a keyval and modifier are explicitly set then these values are used -- regardless of any associated accel closure or widget. -- Providing an Accelerator_Key of 0 removes the manual setting. -- Since: gtk+ 3.6 -- "accelerator_key": a keyval, or 0 -- "accelerator_mods": the modifier mask for the accel function Get_Accel_Widget (Accel_Label : not null access Gtk_Accel_Label_Record) return Gtk.Widget.Gtk_Widget; -- Fetches the widget monitored by this accelerator label. See -- Gtk.Accel_Label.Set_Accel_Widget. procedure Set_Accel_Widget (Accel_Label : not null access Gtk_Accel_Label_Record; Accel_Widget : access Gtk.Widget.Gtk_Widget_Record'Class); -- Sets the widget to be monitored by this accelerator label. Passing null -- for Accel_Widget will dissociate Accel_Label from its current widget, if -- any. -- "accel_widget": the widget to be monitored, or null function Get_Accel_Width (Accel_Label : not null access Gtk_Accel_Label_Record) return Guint; -- Returns the width needed to display the accelerator key(s). This is -- used by menus to align all of the Gtk.Menu_Item.Gtk_Menu_Item widgets, -- and shouldn't be needed by applications. function Refetch (Accel_Label : not null access Gtk_Accel_Label_Record) return Boolean; -- Recreates the string representing the accelerator keys. This should not -- be needed since the string is automatically updated whenever -- accelerators are added or removed from the associated widget. procedure Set_Accel_Closure (Accel_Label : not null access Gtk_Accel_Label_Record; Accel_Closure : System.Address); -- Sets the closure to be monitored by this accelerator label. The closure -- must be connected to an accelerator group; see Gtk.Accel_Group.Connect. -- Passing null for Accel_Closure will dissociate Accel_Label from its -- current closure, if any. -- "accel_closure": the closure to monitor for accelerator changes, or -- null ---------------- -- Properties -- ---------------- -- The following properties are defined for this widget. See -- Glib.Properties for more information on properties) Accel_Closure_Property : constant Glib.Properties.Property_String := Glib.Properties.Build ("accel-closure");-- Unknown type: GObject.Closure Accel_Widget_Property : constant Glib.Properties.Property_Object; -- Type: Gtk.Widget.Gtk_Widget ---------------- -- Interfaces -- ---------------- -- This class implements several interfaces. See Glib.Types -- -- - "Buildable" package Implements_Gtk_Buildable is new Glib.Types.Implements (Gtk.Buildable.Gtk_Buildable, Gtk_Accel_Label_Record, Gtk_Accel_Label); function "+" (Widget : access Gtk_Accel_Label_Record'Class) return Gtk.Buildable.Gtk_Buildable renames Implements_Gtk_Buildable.To_Interface; function "-" (Interf : Gtk.Buildable.Gtk_Buildable) return Gtk_Accel_Label renames Implements_Gtk_Buildable.To_Object; private Accel_Widget_Property : constant Glib.Properties.Property_Object := Glib.Properties.Build ("accel-widget"); end Gtk.Accel_Label; gtkada-24.0.0/src/generated/gtk-accel_map.adb000066400000000000000000000535501446021174000207230ustar00rootroot00000000000000------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ pragma Style_Checks (Off); pragma Warnings (Off, "*is already use-visible*"); with Ada.Unchecked_Conversion; with Glib.Type_Conversion_Hooks; use Glib.Type_Conversion_Hooks; with Glib.Values; use Glib.Values; with Gtk.Arguments; use Gtk.Arguments; with Gtkada.Bindings; use Gtkada.Bindings; pragma Warnings(Off); -- might be unused with Gtkada.Types; use Gtkada.Types; pragma Warnings(On); package body Gtk.Accel_Map is procedure C_Gtk_Accel_Map_Foreach (Data : System.Address; Foreach_Func : System.Address); pragma Import (C, C_Gtk_Accel_Map_Foreach, "gtk_accel_map_foreach"); -- Loops over the entries in the accelerator map whose accel path doesn't -- match any of the filters added with Gtk.Accel_Map.Add_Filter, and -- execute Foreach_Func on each. The signature of Foreach_Func is that of -- Gtk_Accel_Map_Foreach, the Changed parameter indicates whether this -- accelerator was changed during runtime (thus, would need saving during -- an accelerator map dump). -- "data": data to be passed into Foreach_Func -- "foreach_func": function to be executed for each accel map entry which -- is not filtered out procedure C_Gtk_Accel_Map_Foreach_Unfiltered (Data : System.Address; Foreach_Func : System.Address); pragma Import (C, C_Gtk_Accel_Map_Foreach_Unfiltered, "gtk_accel_map_foreach_unfiltered"); -- Loops over all entries in the accelerator map, and execute Foreach_Func -- on each. The signature of Foreach_Func is that of Gtk_Accel_Map_Foreach, -- the Changed parameter indicates whether this accelerator was changed -- during runtime (thus, would need saving during an accelerator map dump). -- "data": data to be passed into Foreach_Func -- "foreach_func": function to be executed for each accel map entry function To_Gtk_Accel_Map_Foreach is new Ada.Unchecked_Conversion (System.Address, Gtk_Accel_Map_Foreach); function To_Address is new Ada.Unchecked_Conversion (Gtk_Accel_Map_Foreach, System.Address); procedure Internal_Gtk_Accel_Map_Foreach (Data : System.Address; Accel_Path : Gtkada.Types.Chars_Ptr; Accel_Key : Gdk.Types.Gdk_Key_Type; Accel_Mods : Gdk.Types.Gdk_Modifier_Type; Changed : Glib.Gboolean); pragma Convention (C, Internal_Gtk_Accel_Map_Foreach); -- "data": User data passed to Gtk.Accel_Map.Foreach or -- Gtk.Accel_Map.Foreach_Unfiltered -- "accel_path": Accel path of the current accelerator -- "accel_key": Key of the current accelerator -- "accel_mods": Modifiers of the current accelerator -- "changed": Changed flag of the accelerator (if True, accelerator has -- changed during runtime and would need to be saved during an accelerator -- dump) ------------------------------------ -- Internal_Gtk_Accel_Map_Foreach -- ------------------------------------ procedure Internal_Gtk_Accel_Map_Foreach (Data : System.Address; Accel_Path : Gtkada.Types.Chars_Ptr; Accel_Key : Gdk.Types.Gdk_Key_Type; Accel_Mods : Gdk.Types.Gdk_Modifier_Type; Changed : Glib.Gboolean) is Func : constant Gtk_Accel_Map_Foreach := To_Gtk_Accel_Map_Foreach (Data); begin Func (Gtkada.Bindings.Value_Allowing_Null (Accel_Path), Accel_Key, Accel_Mods, Changed /= 0); end Internal_Gtk_Accel_Map_Foreach; package Type_Conversion_Gtk_Accel_Map is new Glib.Type_Conversion_Hooks.Hook_Registrator (Get_Type'Access, Gtk_Accel_Map_Record); pragma Unreferenced (Type_Conversion_Gtk_Accel_Map); ------------- -- Foreach -- ------------- procedure Foreach (Foreach_Func : Gtk_Accel_Map_Foreach) is begin if Foreach_Func = null then C_Gtk_Accel_Map_Foreach (System.Null_Address, System.Null_Address); else C_Gtk_Accel_Map_Foreach (To_Address (Foreach_Func), Internal_Gtk_Accel_Map_Foreach'Address); end if; end Foreach; ------------------------ -- Foreach_Unfiltered -- ------------------------ procedure Foreach_Unfiltered (Foreach_Func : Gtk_Accel_Map_Foreach) is begin if Foreach_Func = null then C_Gtk_Accel_Map_Foreach_Unfiltered (System.Null_Address, System.Null_Address); else C_Gtk_Accel_Map_Foreach_Unfiltered (To_Address (Foreach_Func), Internal_Gtk_Accel_Map_Foreach'Address); end if; end Foreach_Unfiltered; package body Foreach_Unfiltered_User_Data is package Users is new Glib.Object.User_Data_Closure (User_Data_Type, Destroy); function To_Gtk_Accel_Map_Foreach is new Ada.Unchecked_Conversion (System.Address, Gtk_Accel_Map_Foreach); function To_Address is new Ada.Unchecked_Conversion (Gtk_Accel_Map_Foreach, System.Address); procedure Internal_Cb (Data : System.Address; Accel_Path : Gtkada.Types.Chars_Ptr; Accel_Key : Gdk.Types.Gdk_Key_Type; Accel_Mods : Gdk.Types.Gdk_Modifier_Type; Changed : Glib.Gboolean); pragma Convention (C, Internal_Cb); -- "data": User data passed to Gtk.Accel_Map.Foreach or -- Gtk.Accel_Map.Foreach_Unfiltered -- "accel_path": Accel path of the current accelerator -- "accel_key": Key of the current accelerator -- "accel_mods": Modifiers of the current accelerator -- "changed": Changed flag of the accelerator (if True, accelerator has -- changed during runtime and would need to be saved during an -- accelerator dump) ------------------------ -- Foreach_Unfiltered -- ------------------------ procedure Foreach_Unfiltered (Data : User_Data_Type; Foreach_Func : Gtk_Accel_Map_Foreach) is D : System.Address; begin if Foreach_Func = null then C_Gtk_Accel_Map_Foreach_Unfiltered (System.Null_Address, System.Null_Address); else D := Users.Build (To_Address (Foreach_Func), Data); C_Gtk_Accel_Map_Foreach_Unfiltered (D, Internal_Cb'Address); Users.Free_Data (D); end if; end Foreach_Unfiltered; ----------------- -- Internal_Cb -- ----------------- procedure Internal_Cb (Data : System.Address; Accel_Path : Gtkada.Types.Chars_Ptr; Accel_Key : Gdk.Types.Gdk_Key_Type; Accel_Mods : Gdk.Types.Gdk_Modifier_Type; Changed : Glib.Gboolean) is D : constant Users.Internal_Data_Access := Users.Convert (Data); begin To_Gtk_Accel_Map_Foreach (D.Func) (D.Data.all, Gtkada.Bindings.Value_Allowing_Null (Accel_Path), Accel_Key, Accel_Mods, Changed /= 0); end Internal_Cb; end Foreach_Unfiltered_User_Data; package body Foreach_User_Data is package Users is new Glib.Object.User_Data_Closure (User_Data_Type, Destroy); function To_Gtk_Accel_Map_Foreach is new Ada.Unchecked_Conversion (System.Address, Gtk_Accel_Map_Foreach); function To_Address is new Ada.Unchecked_Conversion (Gtk_Accel_Map_Foreach, System.Address); procedure Internal_Cb (Data : System.Address; Accel_Path : Gtkada.Types.Chars_Ptr; Accel_Key : Gdk.Types.Gdk_Key_Type; Accel_Mods : Gdk.Types.Gdk_Modifier_Type; Changed : Glib.Gboolean); pragma Convention (C, Internal_Cb); -- "data": User data passed to Gtk.Accel_Map.Foreach or -- Gtk.Accel_Map.Foreach_Unfiltered -- "accel_path": Accel path of the current accelerator -- "accel_key": Key of the current accelerator -- "accel_mods": Modifiers of the current accelerator -- "changed": Changed flag of the accelerator (if True, accelerator has -- changed during runtime and would need to be saved during an -- accelerator dump) ------------- -- Foreach -- ------------- procedure Foreach (Data : User_Data_Type; Foreach_Func : Gtk_Accel_Map_Foreach) is D : System.Address; begin if Foreach_Func = null then C_Gtk_Accel_Map_Foreach (System.Null_Address, System.Null_Address); else D := Users.Build (To_Address (Foreach_Func), Data); C_Gtk_Accel_Map_Foreach (D, Internal_Cb'Address); Users.Free_Data (D); end if; end Foreach; ----------------- -- Internal_Cb -- ----------------- procedure Internal_Cb (Data : System.Address; Accel_Path : Gtkada.Types.Chars_Ptr; Accel_Key : Gdk.Types.Gdk_Key_Type; Accel_Mods : Gdk.Types.Gdk_Modifier_Type; Changed : Glib.Gboolean) is D : constant Users.Internal_Data_Access := Users.Convert (Data); begin To_Gtk_Accel_Map_Foreach (D.Func) (D.Data.all, Gtkada.Bindings.Value_Allowing_Null (Accel_Path), Accel_Key, Accel_Mods, Changed /= 0); end Internal_Cb; end Foreach_User_Data; --------------- -- Add_Entry -- --------------- procedure Add_Entry (Accel_Path : UTF8_String; Accel_Key : Gdk.Types.Gdk_Key_Type; Accel_Mods : Gdk.Types.Gdk_Modifier_Type) is procedure Internal (Accel_Path : Gtkada.Types.Chars_Ptr; Accel_Key : Gdk.Types.Gdk_Key_Type; Accel_Mods : Gdk.Types.Gdk_Modifier_Type); pragma Import (C, Internal, "gtk_accel_map_add_entry"); Tmp_Accel_Path : Gtkada.Types.Chars_Ptr := New_String (Accel_Path); begin Internal (Tmp_Accel_Path, Accel_Key, Accel_Mods); Free (Tmp_Accel_Path); end Add_Entry; ---------------- -- Add_Filter -- ---------------- procedure Add_Filter (Filter_Pattern : UTF8_String) is procedure Internal (Filter_Pattern : Gtkada.Types.Chars_Ptr); pragma Import (C, Internal, "gtk_accel_map_add_filter"); Tmp_Filter_Pattern : Gtkada.Types.Chars_Ptr := New_String (Filter_Pattern); begin Internal (Tmp_Filter_Pattern); Free (Tmp_Filter_Pattern); end Add_Filter; ------------------ -- Change_Entry -- ------------------ function Change_Entry (Accel_Path : UTF8_String; Accel_Key : Gdk.Types.Gdk_Key_Type; Accel_Mods : Gdk.Types.Gdk_Modifier_Type; Replace : Boolean) return Boolean is function Internal (Accel_Path : Gtkada.Types.Chars_Ptr; Accel_Key : Gdk.Types.Gdk_Key_Type; Accel_Mods : Gdk.Types.Gdk_Modifier_Type; Replace : Glib.Gboolean) return Glib.Gboolean; pragma Import (C, Internal, "gtk_accel_map_change_entry"); Tmp_Accel_Path : Gtkada.Types.Chars_Ptr := New_String (Accel_Path); Tmp_Return : Glib.Gboolean; begin Tmp_Return := Internal (Tmp_Accel_Path, Accel_Key, Accel_Mods, Boolean'Pos (Replace)); Free (Tmp_Accel_Path); return Tmp_Return /= 0; end Change_Entry; --------- -- Get -- --------- function Get return Gtk_Accel_Map is function Internal return System.Address; pragma Import (C, Internal, "gtk_accel_map_get"); Stub_Gtk_Accel_Map : Gtk_Accel_Map_Record; begin return Gtk.Accel_Map.Gtk_Accel_Map (Get_User_Data (Internal, Stub_Gtk_Accel_Map)); end Get; ---------- -- Load -- ---------- procedure Load (File_Name : UTF8_String) is procedure Internal (File_Name : Gtkada.Types.Chars_Ptr); pragma Import (C, Internal, "gtk_accel_map_load"); Tmp_File_Name : Gtkada.Types.Chars_Ptr := New_String (File_Name); begin Internal (Tmp_File_Name); Free (Tmp_File_Name); end Load; ------------- -- Load_Fd -- ------------- procedure Load_Fd (Fd : Glib.Gint) is procedure Internal (Fd : Glib.Gint); pragma Import (C, Internal, "gtk_accel_map_load_fd"); begin Internal (Fd); end Load_Fd; --------------- -- Lock_Path -- --------------- procedure Lock_Path (Accel_Path : UTF8_String) is procedure Internal (Accel_Path : Gtkada.Types.Chars_Ptr); pragma Import (C, Internal, "gtk_accel_map_lock_path"); Tmp_Accel_Path : Gtkada.Types.Chars_Ptr := New_String (Accel_Path); begin Internal (Tmp_Accel_Path); Free (Tmp_Accel_Path); end Lock_Path; ------------------ -- Lookup_Entry -- ------------------ procedure Lookup_Entry (Accel_Path : UTF8_String; Key : out Gtk.Accel_Group.Gtk_Accel_Key; Found : out Boolean) is function Internal (Accel_Path : Gtkada.Types.Chars_Ptr; Acc_Key : access Gtk.Accel_Group.Gtk_Accel_Key) return Glib.Gboolean; pragma Import (C, Internal, "gtk_accel_map_lookup_entry"); Acc_Key : aliased Gtk.Accel_Group.Gtk_Accel_Key; Tmp_Accel_Path : Gtkada.Types.Chars_Ptr := New_String (Accel_Path); Tmp_Acc_Key : aliased Gtk.Accel_Group.Gtk_Accel_Key; Tmp_Return : Glib.Gboolean; begin Tmp_Return := Internal (Tmp_Accel_Path, Tmp_Acc_Key'Access); Acc_Key := Tmp_Acc_Key; Free (Tmp_Accel_Path); Key := Acc_Key; Found := Tmp_Return /= 0; end Lookup_Entry; ---------- -- Save -- ---------- procedure Save (File_Name : UTF8_String) is procedure Internal (File_Name : Gtkada.Types.Chars_Ptr); pragma Import (C, Internal, "gtk_accel_map_save"); Tmp_File_Name : Gtkada.Types.Chars_Ptr := New_String (File_Name); begin Internal (Tmp_File_Name); Free (Tmp_File_Name); end Save; ------------- -- Save_Fd -- ------------- procedure Save_Fd (Fd : Glib.Gint) is procedure Internal (Fd : Glib.Gint); pragma Import (C, Internal, "gtk_accel_map_save_fd"); begin Internal (Fd); end Save_Fd; ----------------- -- Unlock_Path -- ----------------- procedure Unlock_Path (Accel_Path : UTF8_String) is procedure Internal (Accel_Path : Gtkada.Types.Chars_Ptr); pragma Import (C, Internal, "gtk_accel_map_unlock_path"); Tmp_Accel_Path : Gtkada.Types.Chars_Ptr := New_String (Accel_Path); begin Internal (Tmp_Accel_Path); Free (Tmp_Accel_Path); end Unlock_Path; use type System.Address; function Cb_To_Address is new Ada.Unchecked_Conversion (Cb_Gtk_Accel_Map_UTF8_String_Gdk_Key_Type_Gdk_Modifier_Type_Void, System.Address); function Address_To_Cb is new Ada.Unchecked_Conversion (System.Address, Cb_Gtk_Accel_Map_UTF8_String_Gdk_Key_Type_Gdk_Modifier_Type_Void); function Cb_To_Address is new Ada.Unchecked_Conversion (Cb_GObject_UTF8_String_Gdk_Key_Type_Gdk_Modifier_Type_Void, System.Address); function Address_To_Cb is new Ada.Unchecked_Conversion (System.Address, Cb_GObject_UTF8_String_Gdk_Key_Type_Gdk_Modifier_Type_Void); procedure Connect (Object : access Gtk_Accel_Map_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_Gtk_Accel_Map_UTF8_String_Gdk_Key_Type_Gdk_Modifier_Type_Void; After : Boolean); procedure Connect_Slot (Object : access Gtk_Accel_Map_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_GObject_UTF8_String_Gdk_Key_Type_Gdk_Modifier_Type_Void; After : Boolean; Slot : access Glib.Object.GObject_Record'Class := null); procedure Marsh_GObject_UTF8_String_Gdk_Key_Type_Gdk_Modifier_Type_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address); pragma Convention (C, Marsh_GObject_UTF8_String_Gdk_Key_Type_Gdk_Modifier_Type_Void); procedure Marsh_Gtk_Accel_Map_UTF8_String_Gdk_Key_Type_Gdk_Modifier_Type_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address); pragma Convention (C, Marsh_Gtk_Accel_Map_UTF8_String_Gdk_Key_Type_Gdk_Modifier_Type_Void); ------------- -- Connect -- ------------- procedure Connect (Object : access Gtk_Accel_Map_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_Gtk_Accel_Map_UTF8_String_Gdk_Key_Type_Gdk_Modifier_Type_Void; After : Boolean) is begin Unchecked_Do_Signal_Connect (Object => Object, C_Name => C_Name, Marshaller => Marsh_Gtk_Accel_Map_UTF8_String_Gdk_Key_Type_Gdk_Modifier_Type_Void'Access, Handler => Cb_To_Address (Handler),-- Set in the closure After => After); end Connect; ------------------ -- Connect_Slot -- ------------------ procedure Connect_Slot (Object : access Gtk_Accel_Map_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_GObject_UTF8_String_Gdk_Key_Type_Gdk_Modifier_Type_Void; After : Boolean; Slot : access Glib.Object.GObject_Record'Class := null) is begin Unchecked_Do_Signal_Connect (Object => Object, C_Name => C_Name, Marshaller => Marsh_GObject_UTF8_String_Gdk_Key_Type_Gdk_Modifier_Type_Void'Access, Handler => Cb_To_Address (Handler),-- Set in the closure Slot_Object => Slot, After => After); end Connect_Slot; ------------------------------------------------------------------- -- Marsh_GObject_UTF8_String_Gdk_Key_Type_Gdk_Modifier_Type_Void -- ------------------------------------------------------------------- procedure Marsh_GObject_UTF8_String_Gdk_Key_Type_Gdk_Modifier_Type_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address) is pragma Unreferenced (Return_Value, N_Params, Invocation_Hint, User_Data); H : constant Cb_GObject_UTF8_String_Gdk_Key_Type_Gdk_Modifier_Type_Void := Address_To_Cb (Get_Callback (Closure)); Obj : constant Glib.Object.GObject := Glib.Object.Convert (Get_Data (Closure)); begin H (Obj, Unchecked_To_UTF8_String (Params, 1), Unchecked_To_Gdk_Key_Type (Params, 2), Unchecked_To_Gdk_Modifier_Type (Params, 3)); exception when E : others => Process_Exception (E); end Marsh_GObject_UTF8_String_Gdk_Key_Type_Gdk_Modifier_Type_Void; ------------------------------------------------------------------------- -- Marsh_Gtk_Accel_Map_UTF8_String_Gdk_Key_Type_Gdk_Modifier_Type_Void -- ------------------------------------------------------------------------- procedure Marsh_Gtk_Accel_Map_UTF8_String_Gdk_Key_Type_Gdk_Modifier_Type_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address) is pragma Unreferenced (Return_Value, N_Params, Invocation_Hint, User_Data); H : constant Cb_Gtk_Accel_Map_UTF8_String_Gdk_Key_Type_Gdk_Modifier_Type_Void := Address_To_Cb (Get_Callback (Closure)); Obj : constant Gtk_Accel_Map := Gtk_Accel_Map (Unchecked_To_Object (Params, 0)); begin H (Obj, Unchecked_To_UTF8_String (Params, 1), Unchecked_To_Gdk_Key_Type (Params, 2), Unchecked_To_Gdk_Modifier_Type (Params, 3)); exception when E : others => Process_Exception (E); end Marsh_Gtk_Accel_Map_UTF8_String_Gdk_Key_Type_Gdk_Modifier_Type_Void; ---------------- -- On_Changed -- ---------------- procedure On_Changed (Self : not null access Gtk_Accel_Map_Record; Call : Cb_Gtk_Accel_Map_UTF8_String_Gdk_Key_Type_Gdk_Modifier_Type_Void; After : Boolean := False) is begin Connect (Self, "changed" & ASCII.NUL, Call, After); end On_Changed; ---------------- -- On_Changed -- ---------------- procedure On_Changed (Self : not null access Gtk_Accel_Map_Record; Call : Cb_GObject_UTF8_String_Gdk_Key_Type_Gdk_Modifier_Type_Void; Slot : not null access Glib.Object.GObject_Record'Class; After : Boolean := False) is begin Connect_Slot (Self, "changed" & ASCII.NUL, Call, After, Slot); end On_Changed; end Gtk.Accel_Map; gtkada-24.0.0/src/generated/gtk-accel_map.ads000066400000000000000000000404071446021174000207410ustar00rootroot00000000000000------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ -- -- Accelerator maps are used to define runtime configurable accelerators. -- Functions for manipulating them are are usually used by higher level -- convenience mechanisms like Gtk.UI_Manager.Gtk_UI_Manager and are thus -- considered "low-level". You'll want to use them if you're manually creating -- menus that should have user-configurable accelerators. -- -- An accelerator is uniquely defined by: - accelerator path - accelerator -- key - accelerator modifiers -- -- The accelerator path must consist of -- "/Category1/Category2/.../Action", where WINDOWTYPE should be a -- unique application-specific identifier that corresponds to the kind of -- window the accelerator is being used in, e.g. "Gimp-Image", -- "Abiword-Document" or "Gnumeric-Settings". The "Category1/.../Action" -- portion is most appropriately chosen by the action the accelerator -- triggers, i.e. for accelerators on menu items, choose the item's menu path, -- e.g. "File/Save As", "Image/View/Zoom" or "Edit/Select All". So a full -- valid accelerator path may look like: "/File/Dialogs/Tool -- Options...". -- -- All accelerators are stored inside one global Gtk.Accel_Map.Gtk_Accel_Map -- that can be obtained using Gtk.Accel_Map.Get. See [Monitoring -- changes][monitoring-changes] for additional details. -- -- # Manipulating accelerators -- -- New accelerators can be added using Gtk.Accel_Map.Add_Entry. To search for -- specific accelerator, use Gtk.Accel_Map.Lookup_Entry. Modifications of -- existing accelerators should be done using Gtk.Accel_Map.Change_Entry. -- -- In order to avoid having some accelerators changed, they can be locked -- using Gtk.Accel_Map.Lock_Path. Unlocking is done using -- Gtk.Accel_Map.Unlock_Path. -- -- # Saving and loading accelerator maps -- -- Accelerator maps can be saved to and loaded from some external resource. -- For simple saving and loading from file, Gtk.Accel_Map.Save and -- Gtk.Accel_Map.Load are provided. Saving and loading can also be done by -- providing file descriptor to Gtk.Accel_Map.Save_Fd and -- Gtk.Accel_Map.Load_Fd. -- -- # Monitoring changes -- -- Gtk.Accel_Map.Gtk_Accel_Map object is only useful for monitoring changes -- of accelerators. By connecting to Gtk.Accel_Map.Gtk_Accel_Map::changed -- signal, one can monitor changes of all accelerators. It is also possible to -- monitor only single accelerator path by using it as a detail of the -- Gtk.Accel_Map.Gtk_Accel_Map::changed signal. -- -- pragma Warnings (Off, "*is already use-visible*"); with Gdk.Types; use Gdk.Types; with Glib; use Glib; with Glib.Object; use Glib.Object; with Gtk.Accel_Group; use Gtk.Accel_Group; package Gtk.Accel_Map is type Gtk_Accel_Map_Record is new GObject_Record with null record; type Gtk_Accel_Map is access all Gtk_Accel_Map_Record'Class; --------------- -- Callbacks -- --------------- type Gtk_Accel_Map_Foreach is access procedure (Accel_Path : UTF8_String; Accel_Key : Gdk.Types.Gdk_Key_Type; Accel_Mods : Gdk.Types.Gdk_Modifier_Type; Changed : Boolean); -- "accel_path": Accel path of the current accelerator -- "accel_key": Key of the current accelerator -- "accel_mods": Modifiers of the current accelerator -- "changed": Changed flag of the accelerator (if True, accelerator has -- changed during runtime and would need to be saved during an accelerator -- dump) ------------------ -- Constructors -- ------------------ function Get_Type return Glib.GType; pragma Import (C, Get_Type, "gtk_accel_map_get_type"); ------------- -- Methods -- ------------- procedure Foreach (Foreach_Func : Gtk_Accel_Map_Foreach); -- Loops over the entries in the accelerator map whose accel path doesn't -- match any of the filters added with Gtk.Accel_Map.Add_Filter, and -- execute Foreach_Func on each. The signature of Foreach_Func is that of -- Gtk_Accel_Map_Foreach, the Changed parameter indicates whether this -- accelerator was changed during runtime (thus, would need saving during -- an accelerator map dump). -- "foreach_func": function to be executed for each accel map entry which -- is not filtered out generic type User_Data_Type (<>) is private; with procedure Destroy (Data : in out User_Data_Type) is null; package Foreach_User_Data is type Gtk_Accel_Map_Foreach is access procedure (Data : User_Data_Type; Accel_Path : UTF8_String; Accel_Key : Gdk.Types.Gdk_Key_Type; Accel_Mods : Gdk.Types.Gdk_Modifier_Type; Changed : Boolean); -- "data": User data passed to Gtk.Accel_Map.Foreach or -- gtk_accel_map_foreach_unfiltered -- "accel_path": Accel path of the current accelerator -- "accel_key": Key of the current accelerator -- "accel_mods": Modifiers of the current accelerator -- "changed": Changed flag of the accelerator (if True, accelerator has -- changed during runtime and would need to be saved during an accelerator -- dump) procedure Foreach (Data : User_Data_Type; Foreach_Func : Gtk_Accel_Map_Foreach); -- Loops over the entries in the accelerator map whose accel path -- doesn't match any of the filters added with Gtk.Accel_Map.Add_Filter, -- and execute Foreach_Func on each. The signature of Foreach_Func is -- that of Gtk_Accel_Map_Foreach, the Changed parameter indicates -- whether this accelerator was changed during runtime (thus, would need -- saving during an accelerator map dump). -- "data": data to be passed into Foreach_Func -- "foreach_func": function to be executed for each accel map entry -- which is not filtered out end Foreach_User_Data; procedure Foreach_Unfiltered (Foreach_Func : Gtk_Accel_Map_Foreach); -- Loops over all entries in the accelerator map, and execute Foreach_Func -- on each. The signature of Foreach_Func is that of Gtk_Accel_Map_Foreach, -- the Changed parameter indicates whether this accelerator was changed -- during runtime (thus, would need saving during an accelerator map dump). -- "foreach_func": function to be executed for each accel map entry generic type User_Data_Type (<>) is private; with procedure Destroy (Data : in out User_Data_Type) is null; package Foreach_Unfiltered_User_Data is type Gtk_Accel_Map_Foreach is access procedure (Data : User_Data_Type; Accel_Path : UTF8_String; Accel_Key : Gdk.Types.Gdk_Key_Type; Accel_Mods : Gdk.Types.Gdk_Modifier_Type; Changed : Boolean); -- "data": User data passed to Gtk.Accel_Map.Foreach or -- Gtk.Accel_Map.Foreach_Unfiltered -- "accel_path": Accel path of the current accelerator -- "accel_key": Key of the current accelerator -- "accel_mods": Modifiers of the current accelerator -- "changed": Changed flag of the accelerator (if True, accelerator has -- changed during runtime and would need to be saved during an accelerator -- dump) procedure Foreach_Unfiltered (Data : User_Data_Type; Foreach_Func : Gtk_Accel_Map_Foreach); -- Loops over all entries in the accelerator map, and execute -- Foreach_Func on each. The signature of Foreach_Func is that of -- Gtk_Accel_Map_Foreach, the Changed parameter indicates whether this -- accelerator was changed during runtime (thus, would need saving -- during an accelerator map dump). -- "data": data to be passed into Foreach_Func -- "foreach_func": function to be executed for each accel map entry end Foreach_Unfiltered_User_Data; --------------- -- Functions -- --------------- procedure Add_Entry (Accel_Path : UTF8_String; Accel_Key : Gdk.Types.Gdk_Key_Type; Accel_Mods : Gdk.Types.Gdk_Modifier_Type); -- Registers a new accelerator with the global accelerator map. This -- function should only be called once per Accel_Path with the canonical -- Accel_Key and Accel_Mods for this path. To change the accelerator during -- runtime programatically, use Gtk.Accel_Map.Change_Entry. -- Set Accel_Key and Accel_Mods to 0 to request a removal of the -- accelerator. -- Note that Accel_Path string will be stored in a Glib.GQuark. Therefore, -- if you pass a static string, you can save some memory by interning it -- first with g_intern_static_string. -- "accel_path": valid accelerator path -- "accel_key": the accelerator key -- "accel_mods": the accelerator modifiers procedure Add_Filter (Filter_Pattern : UTF8_String); -- Adds a filter to the global list of accel path filters. -- Accel map entries whose accel path matches one of the filters are -- skipped by Gtk.Accel_Map.Foreach. -- This function is intended for GTK+ modules that create their own menus, -- but don't want them to be saved into the applications accelerator map -- dump. -- "filter_pattern": a pattern (see Gpattern.Spec.Gpattern_Spec) function Change_Entry (Accel_Path : UTF8_String; Accel_Key : Gdk.Types.Gdk_Key_Type; Accel_Mods : Gdk.Types.Gdk_Modifier_Type; Replace : Boolean) return Boolean; -- Changes the Accel_Key and Accel_Mods currently associated with -- Accel_Path. Due to conflicts with other accelerators, a change may not -- always be possible, Replace indicates whether other accelerators may be -- deleted to resolve such conflicts. A change will only occur if all -- conflicts could be resolved (which might not be the case if conflicting -- accelerators are locked). Successful changes are indicated by a True -- return value. -- Note that Accel_Path string will be stored in a Glib.GQuark. Therefore, -- if you pass a static string, you can save some memory by interning it -- first with g_intern_static_string. -- "accel_path": a valid accelerator path -- "accel_key": the new accelerator key -- "accel_mods": the new accelerator modifiers -- "replace": True if other accelerators may be deleted upon conflicts function Get return Gtk_Accel_Map; -- Gets the singleton global Gtk.Accel_Map.Gtk_Accel_Map object. This -- object is useful only for notification of changes to the accelerator map -- via the ::changed signal; it isn't a parameter to the other accelerator -- map functions. -- Since: gtk+ 2.4 procedure Load (File_Name : UTF8_String); -- Parses a file previously saved with Gtk.Accel_Map.Save for accelerator -- specifications, and propagates them accordingly. -- "file_name": a file containing accelerator specifications, in the GLib -- file name encoding procedure Load_Fd (Fd : Glib.Gint); -- Filedescriptor variant of Gtk.Accel_Map.Load. -- Note that the file descriptor will not be closed by this function. -- "fd": a valid readable file descriptor procedure Lock_Path (Accel_Path : UTF8_String); -- Locks the given accelerator path. If the accelerator map doesn't yet -- contain an entry for Accel_Path, a new one is created. -- Locking an accelerator path prevents its accelerator from being changed -- during runtime. A locked accelerator path can be unlocked by -- Gtk.Accel_Map.Unlock_Path. Refer to Gtk.Accel_Map.Change_Entry for -- information about runtime accelerator changes. -- If called more than once, Accel_Path remains locked until -- Gtk.Accel_Map.Unlock_Path has been called an equivalent number of times. -- Note that locking of individual accelerator paths is independent from -- locking the Gtk.Accel_Group.Gtk_Accel_Group containing them. For runtime -- accelerator changes to be possible, both the accelerator path and its -- Gtk.Accel_Group.Gtk_Accel_Group have to be unlocked. -- Since: gtk+ 2.4 -- "accel_path": a valid accelerator path procedure Lookup_Entry (Accel_Path : UTF8_String; Key : out Gtk.Accel_Group.Gtk_Accel_Key; Found : out Boolean); -- Looks up the accelerator entry for Accel_Path and fills in Key. -- "accel_path": a valid accelerator path -- "key": the accelerator key to be filled in (optional) procedure Save (File_Name : UTF8_String); -- Saves current accelerator specifications (accelerator path, key and -- modifiers) to File_Name. The file is written in a format suitable to be -- read back in by Gtk.Accel_Map.Load. -- "file_name": the name of the file to contain accelerator -- specifications, in the GLib file name encoding procedure Save_Fd (Fd : Glib.Gint); -- Filedescriptor variant of Gtk.Accel_Map.Save. -- Note that the file descriptor will not be closed by this function. -- "fd": a valid writable file descriptor procedure Unlock_Path (Accel_Path : UTF8_String); -- Undoes the last call to Gtk.Accel_Map.Lock_Path on this Accel_Path. -- Refer to Gtk.Accel_Map.Lock_Path for information about accelerator path -- locking. -- Since: gtk+ 2.4 -- "accel_path": a valid accelerator path ------------- -- Signals -- ------------- type Cb_Gtk_Accel_Map_UTF8_String_Gdk_Key_Type_Gdk_Modifier_Type_Void is not null access procedure (Self : access Gtk_Accel_Map_Record'Class; Accel_Path : UTF8_String; Accel_Key : Gdk.Types.Gdk_Key_Type; Accel_Mods : Gdk.Types.Gdk_Modifier_Type); type Cb_GObject_UTF8_String_Gdk_Key_Type_Gdk_Modifier_Type_Void is not null access procedure (Self : access Glib.Object.GObject_Record'Class; Accel_Path : UTF8_String; Accel_Key : Gdk.Types.Gdk_Key_Type; Accel_Mods : Gdk.Types.Gdk_Modifier_Type); Signal_Changed : constant Glib.Signal_Name := "changed"; procedure On_Changed (Self : not null access Gtk_Accel_Map_Record; Call : Cb_Gtk_Accel_Map_UTF8_String_Gdk_Key_Type_Gdk_Modifier_Type_Void; After : Boolean := False); procedure On_Changed (Self : not null access Gtk_Accel_Map_Record; Call : Cb_GObject_UTF8_String_Gdk_Key_Type_Gdk_Modifier_Type_Void; Slot : not null access Glib.Object.GObject_Record'Class; After : Boolean := False); -- Notifies of a change in the global accelerator map. The path is also -- used as the detail for the signal, so it is possible to connect to -- changed::`accel_path`. -- -- Callback parameters: -- -- "accel_path": the path of the accelerator that changed -- -- "accel_key": the key value for the new accelerator -- -- "accel_mods": the modifier mask for the new accelerator end Gtk.Accel_Map; gtkada-24.0.0/src/generated/gtk-action.adb000066400000000000000000000661241446021174000202750ustar00rootroot00000000000000------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ pragma Style_Checks (Off); pragma Warnings (Off, "*is already use-visible*"); with Ada.Unchecked_Conversion; with Glib.Type_Conversion_Hooks; use Glib.Type_Conversion_Hooks; with Glib.Values; use Glib.Values; with Gtk.Arguments; use Gtk.Arguments; with Gtkada.Bindings; use Gtkada.Bindings; pragma Warnings(Off); -- might be unused with Gtkada.Types; use Gtkada.Types; pragma Warnings(On); package body Gtk.Action is package Type_Conversion_Gtk_Action is new Glib.Type_Conversion_Hooks.Hook_Registrator (Get_Type'Access, Gtk_Action_Record); pragma Unreferenced (Type_Conversion_Gtk_Action); -------------------- -- Gtk_Action_New -- -------------------- function Gtk_Action_New (Name : UTF8_String; Label : UTF8_String := ""; Tooltip : UTF8_String := ""; Stock_Id : UTF8_String := "") return Gtk_Action is Action : constant Gtk_Action := new Gtk_Action_Record; begin Gtk.Action.Initialize (Action, Name, Label, Tooltip, Stock_Id); return Action; end Gtk_Action_New; ------------- -- Gtk_New -- ------------- procedure Gtk_New (Action : out Gtk_Action; Name : UTF8_String; Label : UTF8_String := ""; Tooltip : UTF8_String := ""; Stock_Id : UTF8_String := "") is begin Action := new Gtk_Action_Record; Gtk.Action.Initialize (Action, Name, Label, Tooltip, Stock_Id); end Gtk_New; ---------------- -- Initialize -- ---------------- procedure Initialize (Action : not null access Gtk_Action_Record'Class; Name : UTF8_String; Label : UTF8_String := ""; Tooltip : UTF8_String := ""; Stock_Id : UTF8_String := "") is function Internal (Name : Gtkada.Types.Chars_Ptr; Label : Gtkada.Types.Chars_Ptr; Tooltip : Gtkada.Types.Chars_Ptr; Stock_Id : Gtkada.Types.Chars_Ptr) return System.Address; pragma Import (C, Internal, "gtk_action_new"); Tmp_Name : Gtkada.Types.Chars_Ptr := New_String (Name); Tmp_Label : Gtkada.Types.Chars_Ptr; Tmp_Tooltip : Gtkada.Types.Chars_Ptr; Tmp_Stock_Id : Gtkada.Types.Chars_Ptr; Tmp_Return : System.Address; begin if not Action.Is_Created then if Label = "" then Tmp_Label := Gtkada.Types.Null_Ptr; else Tmp_Label := New_String (Label); end if; if Tooltip = "" then Tmp_Tooltip := Gtkada.Types.Null_Ptr; else Tmp_Tooltip := New_String (Tooltip); end if; if Stock_Id = "" then Tmp_Stock_Id := Gtkada.Types.Null_Ptr; else Tmp_Stock_Id := New_String (Stock_Id); end if; Tmp_Return := Internal (Tmp_Name, Tmp_Label, Tmp_Tooltip, Tmp_Stock_Id); Free (Tmp_Stock_Id); Free (Tmp_Tooltip); Free (Tmp_Label); Free (Tmp_Name); Set_Object (Action, Tmp_Return); end if; end Initialize; -------------- -- Activate -- -------------- procedure Activate (Action : not null access Gtk_Action_Record) is procedure Internal (Action : System.Address); pragma Import (C, Internal, "gtk_action_activate"); begin Internal (Get_Object (Action)); end Activate; -------------------- -- Block_Activate -- -------------------- procedure Block_Activate (Action : not null access Gtk_Action_Record) is procedure Internal (Action : System.Address); pragma Import (C, Internal, "gtk_action_block_activate"); begin Internal (Get_Object (Action)); end Block_Activate; ------------------------- -- Connect_Accelerator -- ------------------------- procedure Connect_Accelerator (Action : not null access Gtk_Action_Record) is procedure Internal (Action : System.Address); pragma Import (C, Internal, "gtk_action_connect_accelerator"); begin Internal (Get_Object (Action)); end Connect_Accelerator; ----------------- -- Create_Icon -- ----------------- function Create_Icon (Action : not null access Gtk_Action_Record; Icon_Size : Gtk.Enums.Gtk_Icon_Size) return Gtk.Widget.Gtk_Widget is function Internal (Action : System.Address; Icon_Size : Gtk.Enums.Gtk_Icon_Size) return System.Address; pragma Import (C, Internal, "gtk_action_create_icon"); Stub_Gtk_Widget : Gtk.Widget.Gtk_Widget_Record; begin return Gtk.Widget.Gtk_Widget (Get_User_Data (Internal (Get_Object (Action), Icon_Size), Stub_Gtk_Widget)); end Create_Icon; ----------------- -- Create_Menu -- ----------------- function Create_Menu (Action : not null access Gtk_Action_Record) return Gtk.Widget.Gtk_Widget is function Internal (Action : System.Address) return System.Address; pragma Import (C, Internal, "gtk_action_create_menu"); Stub_Gtk_Widget : Gtk.Widget.Gtk_Widget_Record; begin return Gtk.Widget.Gtk_Widget (Get_User_Data (Internal (Get_Object (Action)), Stub_Gtk_Widget)); end Create_Menu; ---------------------- -- Create_Menu_Item -- ---------------------- function Create_Menu_Item (Action : not null access Gtk_Action_Record) return Gtk.Widget.Gtk_Widget is function Internal (Action : System.Address) return System.Address; pragma Import (C, Internal, "gtk_action_create_menu_item"); Stub_Gtk_Widget : Gtk.Widget.Gtk_Widget_Record; begin return Gtk.Widget.Gtk_Widget (Get_User_Data (Internal (Get_Object (Action)), Stub_Gtk_Widget)); end Create_Menu_Item; ---------------------- -- Create_Tool_Item -- ---------------------- function Create_Tool_Item (Action : not null access Gtk_Action_Record) return Gtk.Widget.Gtk_Widget is function Internal (Action : System.Address) return System.Address; pragma Import (C, Internal, "gtk_action_create_tool_item"); Stub_Gtk_Widget : Gtk.Widget.Gtk_Widget_Record; begin return Gtk.Widget.Gtk_Widget (Get_User_Data (Internal (Get_Object (Action)), Stub_Gtk_Widget)); end Create_Tool_Item; ---------------------------- -- Disconnect_Accelerator -- ---------------------------- procedure Disconnect_Accelerator (Action : not null access Gtk_Action_Record) is procedure Internal (Action : System.Address); pragma Import (C, Internal, "gtk_action_disconnect_accelerator"); begin Internal (Get_Object (Action)); end Disconnect_Accelerator; -------------------- -- Get_Accel_Path -- -------------------- function Get_Accel_Path (Action : not null access Gtk_Action_Record) return UTF8_String is function Internal (Action : System.Address) return Gtkada.Types.Chars_Ptr; pragma Import (C, Internal, "gtk_action_get_accel_path"); begin return Gtkada.Bindings.Value_Allowing_Null (Internal (Get_Object (Action))); end Get_Accel_Path; --------------------------- -- Get_Always_Show_Image -- --------------------------- function Get_Always_Show_Image (Action : not null access Gtk_Action_Record) return Boolean is function Internal (Action : System.Address) return Glib.Gboolean; pragma Import (C, Internal, "gtk_action_get_always_show_image"); begin return Internal (Get_Object (Action)) /= 0; end Get_Always_Show_Image; --------------- -- Get_Gicon -- --------------- function Get_Gicon (Action : not null access Gtk_Action_Record) return Glib.G_Icon.G_Icon is function Internal (Action : System.Address) return Glib.G_Icon.G_Icon; pragma Import (C, Internal, "gtk_action_get_gicon"); begin return Internal (Get_Object (Action)); end Get_Gicon; ------------------- -- Get_Icon_Name -- ------------------- function Get_Icon_Name (Action : not null access Gtk_Action_Record) return UTF8_String is function Internal (Action : System.Address) return Gtkada.Types.Chars_Ptr; pragma Import (C, Internal, "gtk_action_get_icon_name"); begin return Gtkada.Bindings.Value_Allowing_Null (Internal (Get_Object (Action))); end Get_Icon_Name; ---------------------- -- Get_Is_Important -- ---------------------- function Get_Is_Important (Action : not null access Gtk_Action_Record) return Boolean is function Internal (Action : System.Address) return Glib.Gboolean; pragma Import (C, Internal, "gtk_action_get_is_important"); begin return Internal (Get_Object (Action)) /= 0; end Get_Is_Important; --------------- -- Get_Label -- --------------- function Get_Label (Action : not null access Gtk_Action_Record) return UTF8_String is function Internal (Action : System.Address) return Gtkada.Types.Chars_Ptr; pragma Import (C, Internal, "gtk_action_get_label"); begin return Gtkada.Bindings.Value_Allowing_Null (Internal (Get_Object (Action))); end Get_Label; -------------- -- Get_Name -- -------------- function Get_Name (Action : not null access Gtk_Action_Record) return UTF8_String is function Internal (Action : System.Address) return Gtkada.Types.Chars_Ptr; pragma Import (C, Internal, "gtk_action_get_name"); begin return Gtkada.Bindings.Value_Allowing_Null (Internal (Get_Object (Action))); end Get_Name; ----------------- -- Get_Proxies -- ----------------- function Get_Proxies (Action : not null access Gtk_Action_Record) return Gtk.Widget.Widget_SList.GSlist is function Internal (Action : System.Address) return System.Address; pragma Import (C, Internal, "gtk_action_get_proxies"); Tmp_Return : Gtk.Widget.Widget_SList.GSlist; begin Gtk.Widget.Widget_SList.Set_Object (Tmp_Return, Internal (Get_Object (Action))); return Tmp_Return; end Get_Proxies; ------------------- -- Get_Sensitive -- ------------------- function Get_Sensitive (Action : not null access Gtk_Action_Record) return Boolean is function Internal (Action : System.Address) return Glib.Gboolean; pragma Import (C, Internal, "gtk_action_get_sensitive"); begin return Internal (Get_Object (Action)) /= 0; end Get_Sensitive; --------------------- -- Get_Short_Label -- --------------------- function Get_Short_Label (Action : not null access Gtk_Action_Record) return UTF8_String is function Internal (Action : System.Address) return Gtkada.Types.Chars_Ptr; pragma Import (C, Internal, "gtk_action_get_short_label"); begin return Gtkada.Bindings.Value_Allowing_Null (Internal (Get_Object (Action))); end Get_Short_Label; ------------------ -- Get_Stock_Id -- ------------------ function Get_Stock_Id (Action : not null access Gtk_Action_Record) return UTF8_String is function Internal (Action : System.Address) return Gtkada.Types.Chars_Ptr; pragma Import (C, Internal, "gtk_action_get_stock_id"); begin return Gtkada.Bindings.Value_Allowing_Null (Internal (Get_Object (Action))); end Get_Stock_Id; ----------------- -- Get_Tooltip -- ----------------- function Get_Tooltip (Action : not null access Gtk_Action_Record) return UTF8_String is function Internal (Action : System.Address) return Gtkada.Types.Chars_Ptr; pragma Import (C, Internal, "gtk_action_get_tooltip"); begin return Gtkada.Bindings.Value_Allowing_Null (Internal (Get_Object (Action))); end Get_Tooltip; ----------------- -- Get_Visible -- ----------------- function Get_Visible (Action : not null access Gtk_Action_Record) return Boolean is function Internal (Action : System.Address) return Glib.Gboolean; pragma Import (C, Internal, "gtk_action_get_visible"); begin return Internal (Get_Object (Action)) /= 0; end Get_Visible; ---------------------------- -- Get_Visible_Horizontal -- ---------------------------- function Get_Visible_Horizontal (Action : not null access Gtk_Action_Record) return Boolean is function Internal (Action : System.Address) return Glib.Gboolean; pragma Import (C, Internal, "gtk_action_get_visible_horizontal"); begin return Internal (Get_Object (Action)) /= 0; end Get_Visible_Horizontal; -------------------------- -- Get_Visible_Vertical -- -------------------------- function Get_Visible_Vertical (Action : not null access Gtk_Action_Record) return Boolean is function Internal (Action : System.Address) return Glib.Gboolean; pragma Import (C, Internal, "gtk_action_get_visible_vertical"); begin return Internal (Get_Object (Action)) /= 0; end Get_Visible_Vertical; ------------------ -- Is_Sensitive -- ------------------ function Is_Sensitive (Action : not null access Gtk_Action_Record) return Boolean is function Internal (Action : System.Address) return Glib.Gboolean; pragma Import (C, Internal, "gtk_action_is_sensitive"); begin return Internal (Get_Object (Action)) /= 0; end Is_Sensitive; ---------------- -- Is_Visible -- ---------------- function Is_Visible (Action : not null access Gtk_Action_Record) return Boolean is function Internal (Action : System.Address) return Glib.Gboolean; pragma Import (C, Internal, "gtk_action_is_visible"); begin return Internal (Get_Object (Action)) /= 0; end Is_Visible; --------------------- -- Set_Accel_Group -- --------------------- procedure Set_Accel_Group (Action : not null access Gtk_Action_Record; Accel_Group : access Gtk.Accel_Group.Gtk_Accel_Group_Record'Class) is procedure Internal (Action : System.Address; Accel_Group : System.Address); pragma Import (C, Internal, "gtk_action_set_accel_group"); begin Internal (Get_Object (Action), Get_Object_Or_Null (GObject (Accel_Group))); end Set_Accel_Group; -------------------- -- Set_Accel_Path -- -------------------- procedure Set_Accel_Path (Action : not null access Gtk_Action_Record; Accel_Path : UTF8_String) is procedure Internal (Action : System.Address; Accel_Path : Gtkada.Types.Chars_Ptr); pragma Import (C, Internal, "gtk_action_set_accel_path"); Tmp_Accel_Path : Gtkada.Types.Chars_Ptr := New_String (Accel_Path); begin Internal (Get_Object (Action), Tmp_Accel_Path); Free (Tmp_Accel_Path); end Set_Accel_Path; --------------------------- -- Set_Always_Show_Image -- --------------------------- procedure Set_Always_Show_Image (Action : not null access Gtk_Action_Record; Always_Show : Boolean) is procedure Internal (Action : System.Address; Always_Show : Glib.Gboolean); pragma Import (C, Internal, "gtk_action_set_always_show_image"); begin Internal (Get_Object (Action), Boolean'Pos (Always_Show)); end Set_Always_Show_Image; --------------- -- Set_Gicon -- --------------- procedure Set_Gicon (Action : not null access Gtk_Action_Record; Icon : Glib.G_Icon.G_Icon) is procedure Internal (Action : System.Address; Icon : Glib.G_Icon.G_Icon); pragma Import (C, Internal, "gtk_action_set_gicon"); begin Internal (Get_Object (Action), Icon); end Set_Gicon; ------------------- -- Set_Icon_Name -- ------------------- procedure Set_Icon_Name (Action : not null access Gtk_Action_Record; Icon_Name : UTF8_String) is procedure Internal (Action : System.Address; Icon_Name : Gtkada.Types.Chars_Ptr); pragma Import (C, Internal, "gtk_action_set_icon_name"); Tmp_Icon_Name : Gtkada.Types.Chars_Ptr := New_String (Icon_Name); begin Internal (Get_Object (Action), Tmp_Icon_Name); Free (Tmp_Icon_Name); end Set_Icon_Name; ---------------------- -- Set_Is_Important -- ---------------------- procedure Set_Is_Important (Action : not null access Gtk_Action_Record; Is_Important : Boolean) is procedure Internal (Action : System.Address; Is_Important : Glib.Gboolean); pragma Import (C, Internal, "gtk_action_set_is_important"); begin Internal (Get_Object (Action), Boolean'Pos (Is_Important)); end Set_Is_Important; --------------- -- Set_Label -- --------------- procedure Set_Label (Action : not null access Gtk_Action_Record; Label : UTF8_String) is procedure Internal (Action : System.Address; Label : Gtkada.Types.Chars_Ptr); pragma Import (C, Internal, "gtk_action_set_label"); Tmp_Label : Gtkada.Types.Chars_Ptr := New_String (Label); begin Internal (Get_Object (Action), Tmp_Label); Free (Tmp_Label); end Set_Label; ------------------- -- Set_Sensitive -- ------------------- procedure Set_Sensitive (Action : not null access Gtk_Action_Record; Sensitive : Boolean) is procedure Internal (Action : System.Address; Sensitive : Glib.Gboolean); pragma Import (C, Internal, "gtk_action_set_sensitive"); begin Internal (Get_Object (Action), Boolean'Pos (Sensitive)); end Set_Sensitive; --------------------- -- Set_Short_Label -- --------------------- procedure Set_Short_Label (Action : not null access Gtk_Action_Record; Short_Label : UTF8_String) is procedure Internal (Action : System.Address; Short_Label : Gtkada.Types.Chars_Ptr); pragma Import (C, Internal, "gtk_action_set_short_label"); Tmp_Short_Label : Gtkada.Types.Chars_Ptr := New_String (Short_Label); begin Internal (Get_Object (Action), Tmp_Short_Label); Free (Tmp_Short_Label); end Set_Short_Label; ------------------ -- Set_Stock_Id -- ------------------ procedure Set_Stock_Id (Action : not null access Gtk_Action_Record; Stock_Id : UTF8_String) is procedure Internal (Action : System.Address; Stock_Id : Gtkada.Types.Chars_Ptr); pragma Import (C, Internal, "gtk_action_set_stock_id"); Tmp_Stock_Id : Gtkada.Types.Chars_Ptr := New_String (Stock_Id); begin Internal (Get_Object (Action), Tmp_Stock_Id); Free (Tmp_Stock_Id); end Set_Stock_Id; ----------------- -- Set_Tooltip -- ----------------- procedure Set_Tooltip (Action : not null access Gtk_Action_Record; Tooltip : UTF8_String) is procedure Internal (Action : System.Address; Tooltip : Gtkada.Types.Chars_Ptr); pragma Import (C, Internal, "gtk_action_set_tooltip"); Tmp_Tooltip : Gtkada.Types.Chars_Ptr := New_String (Tooltip); begin Internal (Get_Object (Action), Tmp_Tooltip); Free (Tmp_Tooltip); end Set_Tooltip; ----------------- -- Set_Visible -- ----------------- procedure Set_Visible (Action : not null access Gtk_Action_Record; Visible : Boolean) is procedure Internal (Action : System.Address; Visible : Glib.Gboolean); pragma Import (C, Internal, "gtk_action_set_visible"); begin Internal (Get_Object (Action), Boolean'Pos (Visible)); end Set_Visible; ---------------------------- -- Set_Visible_Horizontal -- ---------------------------- procedure Set_Visible_Horizontal (Action : not null access Gtk_Action_Record; Visible_Horizontal : Boolean) is procedure Internal (Action : System.Address; Visible_Horizontal : Glib.Gboolean); pragma Import (C, Internal, "gtk_action_set_visible_horizontal"); begin Internal (Get_Object (Action), Boolean'Pos (Visible_Horizontal)); end Set_Visible_Horizontal; -------------------------- -- Set_Visible_Vertical -- -------------------------- procedure Set_Visible_Vertical (Action : not null access Gtk_Action_Record; Visible_Vertical : Boolean) is procedure Internal (Action : System.Address; Visible_Vertical : Glib.Gboolean); pragma Import (C, Internal, "gtk_action_set_visible_vertical"); begin Internal (Get_Object (Action), Boolean'Pos (Visible_Vertical)); end Set_Visible_Vertical; ---------------------- -- Unblock_Activate -- ---------------------- procedure Unblock_Activate (Action : not null access Gtk_Action_Record) is procedure Internal (Action : System.Address); pragma Import (C, Internal, "gtk_action_unblock_activate"); begin Internal (Get_Object (Action)); end Unblock_Activate; use type System.Address; function Cb_To_Address is new Ada.Unchecked_Conversion (Cb_Gtk_Action_Void, System.Address); function Address_To_Cb is new Ada.Unchecked_Conversion (System.Address, Cb_Gtk_Action_Void); function Cb_To_Address is new Ada.Unchecked_Conversion (Cb_GObject_Void, System.Address); function Address_To_Cb is new Ada.Unchecked_Conversion (System.Address, Cb_GObject_Void); procedure Connect (Object : access Gtk_Action_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_Gtk_Action_Void; After : Boolean); procedure Connect_Slot (Object : access Gtk_Action_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_GObject_Void; After : Boolean; Slot : access Glib.Object.GObject_Record'Class := null); procedure Marsh_GObject_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address); pragma Convention (C, Marsh_GObject_Void); procedure Marsh_Gtk_Action_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address); pragma Convention (C, Marsh_Gtk_Action_Void); ------------- -- Connect -- ------------- procedure Connect (Object : access Gtk_Action_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_Gtk_Action_Void; After : Boolean) is begin Unchecked_Do_Signal_Connect (Object => Object, C_Name => C_Name, Marshaller => Marsh_Gtk_Action_Void'Access, Handler => Cb_To_Address (Handler),-- Set in the closure After => After); end Connect; ------------------ -- Connect_Slot -- ------------------ procedure Connect_Slot (Object : access Gtk_Action_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_GObject_Void; After : Boolean; Slot : access Glib.Object.GObject_Record'Class := null) is begin Unchecked_Do_Signal_Connect (Object => Object, C_Name => C_Name, Marshaller => Marsh_GObject_Void'Access, Handler => Cb_To_Address (Handler),-- Set in the closure Slot_Object => Slot, After => After); end Connect_Slot; ------------------------ -- Marsh_GObject_Void -- ------------------------ procedure Marsh_GObject_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address) is pragma Unreferenced (Return_Value, N_Params, Params, Invocation_Hint, User_Data); H : constant Cb_GObject_Void := Address_To_Cb (Get_Callback (Closure)); Obj : constant Glib.Object.GObject := Glib.Object.Convert (Get_Data (Closure)); begin H (Obj); exception when E : others => Process_Exception (E); end Marsh_GObject_Void; --------------------------- -- Marsh_Gtk_Action_Void -- --------------------------- procedure Marsh_Gtk_Action_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address) is pragma Unreferenced (Return_Value, N_Params, Invocation_Hint, User_Data); H : constant Cb_Gtk_Action_Void := Address_To_Cb (Get_Callback (Closure)); Obj : constant Gtk_Action := Gtk_Action (Unchecked_To_Object (Params, 0)); begin H (Obj); exception when E : others => Process_Exception (E); end Marsh_Gtk_Action_Void; ----------------- -- On_Activate -- ----------------- procedure On_Activate (Self : not null access Gtk_Action_Record; Call : Cb_Gtk_Action_Void; After : Boolean := False) is begin Connect (Self, "activate" & ASCII.NUL, Call, After); end On_Activate; ----------------- -- On_Activate -- ----------------- procedure On_Activate (Self : not null access Gtk_Action_Record; Call : Cb_GObject_Void; Slot : not null access Glib.Object.GObject_Record'Class; After : Boolean := False) is begin Connect_Slot (Self, "activate" & ASCII.NUL, Call, After, Slot); end On_Activate; end Gtk.Action; gtkada-24.0.0/src/generated/gtk-action.ads000066400000000000000000000641361446021174000203170ustar00rootroot00000000000000------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ -- -- > In GTK+ 3.10, GtkAction has been deprecated. Use Glib.Action.Gaction > -- instead, and associate actions with Gtk.Actionable.Gtk_Actionable widgets. -- Use > Glib.Menu_Model.Gmenu_Model for creating menus with -- Gtk.Menu.Gtk_New_From_Model. -- -- Actions represent operations that the user can be perform, along with some -- information how it should be presented in the interface. Each action -- provides methods to create icons, menu items and toolbar items representing -- itself. -- -- As well as the callback that is called when the action gets activated, the -- following also gets associated with the action: -- -- - a name (not translated, for path lookup) -- -- - a label (translated, for display) -- -- - an accelerator -- -- - whether label indicates a stock id -- -- - a tooltip (optional, translated) -- -- - a toolbar label (optional, shorter than label) -- -- The action will also have some state information: -- -- - visible (shown/hidden) -- -- - sensitive (enabled/disabled) -- -- Apart from regular actions, there are [toggle actions][GtkToggleAction], -- which can be toggled between two states and [radio -- actions][GtkRadioAction], of which only one in a group can be in the -- "active" state. Other actions can be implemented as Gtk.Action.Gtk_Action -- subclasses. -- -- Each action can have one or more proxy widgets. To act as an action proxy, -- widget needs to implement Gtk.Activatable.Gtk_Activatable interface. -- Proxies mirror the state of the action and should change when the action's -- state changes. Properties that are always mirrored by proxies are -- Gtk.Action.Gtk_Action:sensitive and Gtk.Action.Gtk_Action:visible. -- Gtk.Action.Gtk_Action:gicon, Gtk.Action.Gtk_Action:icon-name, -- Gtk.Action.Gtk_Action:label, Gtk.Action.Gtk_Action:short-label and -- Gtk.Action.Gtk_Action:stock-id properties are only mirorred if proxy widget -- has Gtk.Activatable.Gtk_Activatable:use-action-appearance property set to -- True. -- -- When the proxy is activated, it should activate its action. -- -- pragma Warnings (Off, "*is already use-visible*"); with Glib; use Glib; with Glib.G_Icon; use Glib.G_Icon; with Glib.Object; use Glib.Object; with Glib.Properties; use Glib.Properties; with Glib.Types; use Glib.Types; with Gtk.Accel_Group; use Gtk.Accel_Group; with Gtk.Buildable; use Gtk.Buildable; with Gtk.Enums; use Gtk.Enums; with Gtk.Widget; use Gtk.Widget; package Gtk.Action is type Gtk_Action_Record is new GObject_Record with null record; type Gtk_Action is access all Gtk_Action_Record'Class; ------------------ -- Constructors -- ------------------ procedure Gtk_New (Action : out Gtk_Action; Name : UTF8_String; Label : UTF8_String := ""; Tooltip : UTF8_String := ""; Stock_Id : UTF8_String := ""); procedure Initialize (Action : not null access Gtk_Action_Record'Class; Name : UTF8_String; Label : UTF8_String := ""; Tooltip : UTF8_String := ""; Stock_Id : UTF8_String := ""); -- Creates a new Gtk.Action.Gtk_Action object. To add the action to a -- Gtk.Action_Group.Gtk_Action_Group and set the accelerator for the -- action, call Gtk.Action_Group.Add_Action_With_Accel. See the [UI -- Definition section][XML-UI] for information on allowed action names. -- Since: gtk+ 2.4 -- Initialize does nothing if the object was already created with another -- call to Initialize* or G_New. -- "name": A unique name for the action -- "label": the label displayed in menu items and on buttons, or null -- "tooltip": a tooltip for the action, or null -- "stock_id": the stock icon to display in widgets representing the -- action, or null function Gtk_Action_New (Name : UTF8_String; Label : UTF8_String := ""; Tooltip : UTF8_String := ""; Stock_Id : UTF8_String := "") return Gtk_Action; -- Creates a new Gtk.Action.Gtk_Action object. To add the action to a -- Gtk.Action_Group.Gtk_Action_Group and set the accelerator for the -- action, call Gtk.Action_Group.Add_Action_With_Accel. See the [UI -- Definition section][XML-UI] for information on allowed action names. -- Since: gtk+ 2.4 -- "name": A unique name for the action -- "label": the label displayed in menu items and on buttons, or null -- "tooltip": a tooltip for the action, or null -- "stock_id": the stock icon to display in widgets representing the -- action, or null function Get_Type return Glib.GType; pragma Import (C, Get_Type, "gtk_action_get_type"); ------------- -- Methods -- ------------- procedure Activate (Action : not null access Gtk_Action_Record); pragma Obsolescent (Activate); -- Emits the "activate" signal on the specified action, if it isn't -- insensitive. This gets called by the proxy widgets when they get -- activated. -- It can also be used to manually activate an action. -- Since: gtk+ 2.4 -- Deprecated since 3.10, 1 procedure Block_Activate (Action : not null access Gtk_Action_Record); pragma Obsolescent (Block_Activate); -- Disable activation signals from the action -- This is needed when updating the state of your proxy -- Gtk.Activatable.Gtk_Activatable widget could result in calling -- Gtk.Action.Activate, this is a convenience function to avoid recursing -- in those cases (updating toggle state for instance). -- Since: gtk+ 2.16 -- Deprecated since 3.10, 1 procedure Connect_Accelerator (Action : not null access Gtk_Action_Record); pragma Obsolescent (Connect_Accelerator); -- Installs the accelerator for Action if Action has an accel path and -- group. See Gtk.Action.Set_Accel_Path and Gtk.Action.Set_Accel_Group -- Since multiple proxies may independently trigger the installation of -- the accelerator, the Action counts the number of times this function has -- been called and doesn't remove the accelerator until -- Gtk.Action.Disconnect_Accelerator has been called as many times. -- Since: gtk+ 2.4 -- Deprecated since 3.10, 1 function Create_Icon (Action : not null access Gtk_Action_Record; Icon_Size : Gtk.Enums.Gtk_Icon_Size) return Gtk.Widget.Gtk_Widget; pragma Obsolescent (Create_Icon); -- This function is intended for use by action implementations to create -- icons displayed in the proxy widgets. -- Since: gtk+ 2.4 -- Deprecated since 3.10, 1 -- "icon_size": the size of the icon (Gtk.Enums.Gtk_Icon_Size) that should -- be created. function Create_Menu (Action : not null access Gtk_Action_Record) return Gtk.Widget.Gtk_Widget; pragma Obsolescent (Create_Menu); -- If Action provides a Gtk.Menu.Gtk_Menu widget as a submenu for the menu -- item or the toolbar item it creates, this function returns an instance -- of that menu. -- Since: gtk+ 2.12 -- Deprecated since 3.10, 1 function Create_Menu_Item (Action : not null access Gtk_Action_Record) return Gtk.Widget.Gtk_Widget; pragma Obsolescent (Create_Menu_Item); -- Creates a menu item widget that proxies for the given action. -- Since: gtk+ 2.4 -- Deprecated since 3.10, 1 function Create_Tool_Item (Action : not null access Gtk_Action_Record) return Gtk.Widget.Gtk_Widget; pragma Obsolescent (Create_Tool_Item); -- Creates a toolbar item widget that proxies for the given action. -- Since: gtk+ 2.4 -- Deprecated since 3.10, 1 procedure Disconnect_Accelerator (Action : not null access Gtk_Action_Record); pragma Obsolescent (Disconnect_Accelerator); -- Undoes the effect of one call to Gtk.Action.Connect_Accelerator. -- Since: gtk+ 2.4 -- Deprecated since 3.10, 1 function Get_Accel_Path (Action : not null access Gtk_Action_Record) return UTF8_String; pragma Obsolescent (Get_Accel_Path); -- Returns the accel path for this action. -- Since: gtk+ 2.6 -- Deprecated since 3.10, 1 procedure Set_Accel_Path (Action : not null access Gtk_Action_Record; Accel_Path : UTF8_String); pragma Obsolescent (Set_Accel_Path); -- Sets the accel path for this action. All proxy widgets associated with -- the action will have this accel path, so that their accelerators are -- consistent. -- Note that Accel_Path string will be stored in a Glib.GQuark. Therefore, -- if you pass a static string, you can save some memory by interning it -- first with g_intern_static_string. -- Since: gtk+ 2.4 -- Deprecated since 3.10, 1 -- "accel_path": the accelerator path function Get_Always_Show_Image (Action : not null access Gtk_Action_Record) return Boolean; pragma Obsolescent (Get_Always_Show_Image); -- Returns whether Action's menu item proxies will always show their -- image, if available. -- Since: gtk+ 2.20 -- Deprecated since 3.10, 1 procedure Set_Always_Show_Image (Action : not null access Gtk_Action_Record; Always_Show : Boolean); pragma Obsolescent (Set_Always_Show_Image); -- Sets whether Action's menu item proxies will ignore the -- Gtk.Settings.Gtk_Settings:gtk-menu-images setting and always show their -- image, if available. -- Use this if the menu item would be useless or hard to use without their -- image. -- Since: gtk+ 2.20 -- Deprecated since 3.10, 1 -- "always_show": True if menuitem proxies should always show their image function Get_Gicon (Action : not null access Gtk_Action_Record) return Glib.G_Icon.G_Icon; pragma Obsolescent (Get_Gicon); -- Gets the gicon of Action. -- Since: gtk+ 2.16 -- Deprecated since 3.10, 1 procedure Set_Gicon (Action : not null access Gtk_Action_Record; Icon : Glib.G_Icon.G_Icon); pragma Obsolescent (Set_Gicon); -- Sets the icon of Action. -- Since: gtk+ 2.16 -- Deprecated since 3.10, 1 -- "icon": the Glib.G_Icon.G_Icon to set function Get_Icon_Name (Action : not null access Gtk_Action_Record) return UTF8_String; pragma Obsolescent (Get_Icon_Name); -- Gets the icon name of Action. -- Since: gtk+ 2.16 -- Deprecated since 3.10, 1 procedure Set_Icon_Name (Action : not null access Gtk_Action_Record; Icon_Name : UTF8_String); pragma Obsolescent (Set_Icon_Name); -- Sets the icon name on Action -- Since: gtk+ 2.16 -- Deprecated since 3.10, 1 -- "icon_name": the icon name to set function Get_Is_Important (Action : not null access Gtk_Action_Record) return Boolean; pragma Obsolescent (Get_Is_Important); -- Checks whether Action is important or not -- Since: gtk+ 2.16 -- Deprecated since 3.10, 1 procedure Set_Is_Important (Action : not null access Gtk_Action_Record; Is_Important : Boolean); pragma Obsolescent (Set_Is_Important); -- Sets whether the action is important, this attribute is used primarily -- by toolbar items to decide whether to show a label or not. -- Since: gtk+ 2.16 -- Deprecated since 3.10, 1 -- "is_important": True to make the action important function Get_Label (Action : not null access Gtk_Action_Record) return UTF8_String; pragma Obsolescent (Get_Label); -- Gets the label text of Action. -- Since: gtk+ 2.16 -- Deprecated since 3.10, 1 procedure Set_Label (Action : not null access Gtk_Action_Record; Label : UTF8_String); pragma Obsolescent (Set_Label); -- Sets the label of Action. -- Since: gtk+ 2.16 -- Deprecated since 3.10, 1 -- "label": the label text to set function Get_Name (Action : not null access Gtk_Action_Record) return UTF8_String; pragma Obsolescent (Get_Name); -- Returns the name of the action. -- Since: gtk+ 2.4 -- Deprecated since 3.10, 1 function Get_Proxies (Action : not null access Gtk_Action_Record) return Gtk.Widget.Widget_SList.GSlist; pragma Obsolescent (Get_Proxies); -- Returns the proxy widgets for an action. See also -- Gtk.Activatable.Get_Related_Action. -- Since: gtk+ 2.4 -- Deprecated since 3.10, 1 function Get_Sensitive (Action : not null access Gtk_Action_Record) return Boolean; pragma Obsolescent (Get_Sensitive); -- Returns whether the action itself is sensitive. Note that this doesn't -- necessarily mean effective sensitivity. See Gtk.Action.Is_Sensitive for -- that. -- Since: gtk+ 2.4 -- Deprecated since 3.10, 1 procedure Set_Sensitive (Action : not null access Gtk_Action_Record; Sensitive : Boolean); pragma Obsolescent (Set_Sensitive); -- Sets the :sensitive property of the action to Sensitive. Note that this -- doesn't necessarily mean effective sensitivity. See -- Gtk.Action.Is_Sensitive for that. -- Since: gtk+ 2.6 -- Deprecated since 3.10, 1 -- "sensitive": True to make the action sensitive function Get_Short_Label (Action : not null access Gtk_Action_Record) return UTF8_String; pragma Obsolescent (Get_Short_Label); -- Gets the short label text of Action. -- Since: gtk+ 2.16 -- Deprecated since 3.10, 1 procedure Set_Short_Label (Action : not null access Gtk_Action_Record; Short_Label : UTF8_String); pragma Obsolescent (Set_Short_Label); -- Sets a shorter label text on Action. -- Since: gtk+ 2.16 -- Deprecated since 3.10, 1 -- "short_label": the label text to set function Get_Stock_Id (Action : not null access Gtk_Action_Record) return UTF8_String; pragma Obsolescent (Get_Stock_Id); -- Gets the stock id of Action. -- Since: gtk+ 2.16 -- Deprecated since 3.10, 1 procedure Set_Stock_Id (Action : not null access Gtk_Action_Record; Stock_Id : UTF8_String); pragma Obsolescent (Set_Stock_Id); -- Sets the stock id on Action -- Since: gtk+ 2.16 -- Deprecated since 3.10, 1 -- "stock_id": the stock id function Get_Tooltip (Action : not null access Gtk_Action_Record) return UTF8_String; pragma Obsolescent (Get_Tooltip); -- Gets the tooltip text of Action. -- Since: gtk+ 2.16 -- Deprecated since 3.10, 1 procedure Set_Tooltip (Action : not null access Gtk_Action_Record; Tooltip : UTF8_String); pragma Obsolescent (Set_Tooltip); -- Sets the tooltip text on Action -- Since: gtk+ 2.16 -- Deprecated since 3.10, 1 -- "tooltip": the tooltip text function Get_Visible (Action : not null access Gtk_Action_Record) return Boolean; pragma Obsolescent (Get_Visible); -- Returns whether the action itself is visible. Note that this doesn't -- necessarily mean effective visibility. See Gtk.Action.Is_Sensitive for -- that. -- Since: gtk+ 2.4 -- Deprecated since 3.10, 1 procedure Set_Visible (Action : not null access Gtk_Action_Record; Visible : Boolean); pragma Obsolescent (Set_Visible); -- Sets the :visible property of the action to Visible. Note that this -- doesn't necessarily mean effective visibility. See Gtk.Action.Is_Visible -- for that. -- Since: gtk+ 2.6 -- Deprecated since 3.10, 1 -- "visible": True to make the action visible function Get_Visible_Horizontal (Action : not null access Gtk_Action_Record) return Boolean; pragma Obsolescent (Get_Visible_Horizontal); -- Checks whether Action is visible when horizontal -- Since: gtk+ 2.16 -- Deprecated since 3.10, 1 procedure Set_Visible_Horizontal (Action : not null access Gtk_Action_Record; Visible_Horizontal : Boolean); pragma Obsolescent (Set_Visible_Horizontal); -- Sets whether Action is visible when horizontal -- Since: gtk+ 2.16 -- Deprecated since 3.10, 1 -- "visible_horizontal": whether the action is visible horizontally function Get_Visible_Vertical (Action : not null access Gtk_Action_Record) return Boolean; pragma Obsolescent (Get_Visible_Vertical); -- Checks whether Action is visible when horizontal -- Since: gtk+ 2.16 -- Deprecated since 3.10, 1 procedure Set_Visible_Vertical (Action : not null access Gtk_Action_Record; Visible_Vertical : Boolean); pragma Obsolescent (Set_Visible_Vertical); -- Sets whether Action is visible when vertical -- Since: gtk+ 2.16 -- Deprecated since 3.10, 1 -- "visible_vertical": whether the action is visible vertically function Is_Sensitive (Action : not null access Gtk_Action_Record) return Boolean; pragma Obsolescent (Is_Sensitive); -- Returns whether the action is effectively sensitive. -- Since: gtk+ 2.4 -- Deprecated since 3.10, 1 function Is_Visible (Action : not null access Gtk_Action_Record) return Boolean; pragma Obsolescent (Is_Visible); -- Returns whether the action is effectively visible. -- Since: gtk+ 2.4 -- Deprecated since 3.10, 1 procedure Set_Accel_Group (Action : not null access Gtk_Action_Record; Accel_Group : access Gtk.Accel_Group.Gtk_Accel_Group_Record'Class); pragma Obsolescent (Set_Accel_Group); -- Sets the Gtk.Accel_Group.Gtk_Accel_Group in which the accelerator for -- this action will be installed. -- Since: gtk+ 2.4 -- Deprecated since 3.10, 1 -- "accel_group": a Gtk.Accel_Group.Gtk_Accel_Group or null procedure Unblock_Activate (Action : not null access Gtk_Action_Record); pragma Obsolescent (Unblock_Activate); -- Reenable activation signals from the action -- Since: gtk+ 2.16 -- Deprecated since 3.10, 1 ---------------- -- Properties -- ---------------- -- The following properties are defined for this widget. See -- Glib.Properties for more information on properties) Action_Group_Property : constant Glib.Properties.Property_Object; -- Type: Gtk.Action_Group.Gtk_Action_Group -- The GtkActionGroup this GtkAction is associated with, or NULL (for -- internal use). Always_Show_Image_Property : constant Glib.Properties.Property_Boolean; -- If True, the action's menu item proxies will ignore the -- Gtk.Settings.Gtk_Settings:gtk-menu-images setting and always show their -- image, if available. -- -- Use this property if the menu item would be useless or hard to use -- without their image. G_Icon_Property : constant Glib.Properties.Property_Boxed; -- Type: Glib.G_Icon.G_Icon -- The Glib.G_Icon.G_Icon displayed in the Gtk.Action.Gtk_Action. -- -- Note that the stock icon is preferred, if the -- Gtk.Action.Gtk_Action:stock-id property holds the id of an existing -- stock icon. -- -- This is an appearance property and thus only applies if -- Gtk.Activatable.Gtk_Activatable:use-action-appearance is True. Hide_If_Empty_Property : constant Glib.Properties.Property_Boolean; -- When TRUE, empty menu proxies for this action are hidden. Icon_Name_Property : constant Glib.Properties.Property_String; -- The name of the icon from the icon theme. -- -- Note that the stock icon is preferred, if the -- Gtk.Action.Gtk_Action:stock-id property holds the id of an existing -- stock icon, and the Glib.G_Icon.G_Icon is preferred if the -- Gtk.Action.Gtk_Action:gicon property is set. -- -- This is an appearance property and thus only applies if -- Gtk.Activatable.Gtk_Activatable:use-action-appearance is True. Is_Important_Property : constant Glib.Properties.Property_Boolean; -- Whether the action is considered important. When TRUE, toolitem proxies -- for this action show text in GTK_TOOLBAR_BOTH_HORIZ mode. Label_Property : constant Glib.Properties.Property_String; -- The label used for menu items and buttons that activate this action. If -- the label is null, GTK+ uses the stock label specified via the stock-id -- property. -- -- This is an appearance property and thus only applies if -- Gtk.Activatable.Gtk_Activatable:use-action-appearance is True. Name_Property : constant Glib.Properties.Property_String; -- A unique name for the action. Sensitive_Property : constant Glib.Properties.Property_Boolean; -- Whether the action is enabled. Short_Label_Property : constant Glib.Properties.Property_String; -- A shorter label that may be used on toolbar buttons. -- -- This is an appearance property and thus only applies if -- Gtk.Activatable.Gtk_Activatable:use-action-appearance is True. Stock_Id_Property : constant Glib.Properties.Property_String; -- The stock icon displayed in widgets representing this action. -- -- This is an appearance property and thus only applies if -- Gtk.Activatable.Gtk_Activatable:use-action-appearance is True. Tooltip_Property : constant Glib.Properties.Property_String; -- A tooltip for this action. Visible_Property : constant Glib.Properties.Property_Boolean; -- Whether the action is visible. Visible_Horizontal_Property : constant Glib.Properties.Property_Boolean; -- Whether the toolbar item is visible when the toolbar is in a horizontal -- orientation. Visible_Overflown_Property : constant Glib.Properties.Property_Boolean; -- When True, toolitem proxies for this action are represented in the -- toolbar overflow menu. Visible_Vertical_Property : constant Glib.Properties.Property_Boolean; -- Whether the toolbar item is visible when the toolbar is in a vertical -- orientation. ------------- -- Signals -- ------------- type Cb_Gtk_Action_Void is not null access procedure (Self : access Gtk_Action_Record'Class); type Cb_GObject_Void is not null access procedure (Self : access Glib.Object.GObject_Record'Class); Signal_Activate : constant Glib.Signal_Name := "activate"; procedure On_Activate (Self : not null access Gtk_Action_Record; Call : Cb_Gtk_Action_Void; After : Boolean := False); procedure On_Activate (Self : not null access Gtk_Action_Record; Call : Cb_GObject_Void; Slot : not null access Glib.Object.GObject_Record'Class; After : Boolean := False); -- The "activate" signal is emitted when the action is activated. ---------------- -- Interfaces -- ---------------- -- This class implements several interfaces. See Glib.Types -- -- - "Buildable" package Implements_Gtk_Buildable is new Glib.Types.Implements (Gtk.Buildable.Gtk_Buildable, Gtk_Action_Record, Gtk_Action); function "+" (Widget : access Gtk_Action_Record'Class) return Gtk.Buildable.Gtk_Buildable renames Implements_Gtk_Buildable.To_Interface; function "-" (Interf : Gtk.Buildable.Gtk_Buildable) return Gtk_Action renames Implements_Gtk_Buildable.To_Object; private Visible_Vertical_Property : constant Glib.Properties.Property_Boolean := Glib.Properties.Build ("visible-vertical"); Visible_Overflown_Property : constant Glib.Properties.Property_Boolean := Glib.Properties.Build ("visible-overflown"); Visible_Horizontal_Property : constant Glib.Properties.Property_Boolean := Glib.Properties.Build ("visible-horizontal"); Visible_Property : constant Glib.Properties.Property_Boolean := Glib.Properties.Build ("visible"); Tooltip_Property : constant Glib.Properties.Property_String := Glib.Properties.Build ("tooltip"); Stock_Id_Property : constant Glib.Properties.Property_String := Glib.Properties.Build ("stock-id"); Short_Label_Property : constant Glib.Properties.Property_String := Glib.Properties.Build ("short-label"); Sensitive_Property : constant Glib.Properties.Property_Boolean := Glib.Properties.Build ("sensitive"); Name_Property : constant Glib.Properties.Property_String := Glib.Properties.Build ("name"); Label_Property : constant Glib.Properties.Property_String := Glib.Properties.Build ("label"); Is_Important_Property : constant Glib.Properties.Property_Boolean := Glib.Properties.Build ("is-important"); Icon_Name_Property : constant Glib.Properties.Property_String := Glib.Properties.Build ("icon-name"); Hide_If_Empty_Property : constant Glib.Properties.Property_Boolean := Glib.Properties.Build ("hide-if-empty"); G_Icon_Property : constant Glib.Properties.Property_Boxed := Glib.Properties.Build ("gicon"); Always_Show_Image_Property : constant Glib.Properties.Property_Boolean := Glib.Properties.Build ("always-show-image"); Action_Group_Property : constant Glib.Properties.Property_Object := Glib.Properties.Build ("action-group"); end Gtk.Action; gtkada-24.0.0/src/generated/gtk-action_bar.adb000066400000000000000000000115271446021174000211160ustar00rootroot00000000000000------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ pragma Style_Checks (Off); pragma Warnings (Off, "*is already use-visible*"); with Glib.Type_Conversion_Hooks; use Glib.Type_Conversion_Hooks; package body Gtk.Action_Bar is package Type_Conversion_Gtk_Action_Bar is new Glib.Type_Conversion_Hooks.Hook_Registrator (Get_Type'Access, Gtk_Action_Bar_Record); pragma Unreferenced (Type_Conversion_Gtk_Action_Bar); ------------------------ -- Gtk_Action_Bar_New -- ------------------------ function Gtk_Action_Bar_New return Gtk_Action_Bar is Self : constant Gtk_Action_Bar := new Gtk_Action_Bar_Record; begin Gtk.Action_Bar.Initialize (Self); return Self; end Gtk_Action_Bar_New; ------------- -- Gtk_New -- ------------- procedure Gtk_New (Self : out Gtk_Action_Bar) is begin Self := new Gtk_Action_Bar_Record; Gtk.Action_Bar.Initialize (Self); end Gtk_New; ---------------- -- Initialize -- ---------------- procedure Initialize (Self : not null access Gtk_Action_Bar_Record'Class) is function Internal return System.Address; pragma Import (C, Internal, "gtk_action_bar_new"); begin if not Self.Is_Created then Set_Object (Self, Internal); end if; end Initialize; ----------------------- -- Get_Center_Widget -- ----------------------- function Get_Center_Widget (Self : not null access Gtk_Action_Bar_Record) return Gtk.Widget.Gtk_Widget is function Internal (Self : System.Address) return System.Address; pragma Import (C, Internal, "gtk_action_bar_get_center_widget"); Stub_Gtk_Widget : Gtk.Widget.Gtk_Widget_Record; begin return Gtk.Widget.Gtk_Widget (Get_User_Data (Internal (Get_Object (Self)), Stub_Gtk_Widget)); end Get_Center_Widget; -------------- -- Pack_End -- -------------- procedure Pack_End (Self : not null access Gtk_Action_Bar_Record; Child : not null access Gtk.Widget.Gtk_Widget_Record'Class) is procedure Internal (Self : System.Address; Child : System.Address); pragma Import (C, Internal, "gtk_action_bar_pack_end"); begin Internal (Get_Object (Self), Get_Object (Child)); end Pack_End; ---------------- -- Pack_Start -- ---------------- procedure Pack_Start (Self : not null access Gtk_Action_Bar_Record; Child : not null access Gtk.Widget.Gtk_Widget_Record'Class) is procedure Internal (Self : System.Address; Child : System.Address); pragma Import (C, Internal, "gtk_action_bar_pack_start"); begin Internal (Get_Object (Self), Get_Object (Child)); end Pack_Start; ----------------------- -- Set_Center_Widget -- ----------------------- procedure Set_Center_Widget (Self : not null access Gtk_Action_Bar_Record; Center_Widget : access Gtk.Widget.Gtk_Widget_Record'Class) is procedure Internal (Self : System.Address; Center_Widget : System.Address); pragma Import (C, Internal, "gtk_action_bar_set_center_widget"); begin Internal (Get_Object (Self), Get_Object_Or_Null (GObject (Center_Widget))); end Set_Center_Widget; end Gtk.Action_Bar; gtkada-24.0.0/src/generated/gtk-action_bar.ads000066400000000000000000000117701446021174000211370ustar00rootroot00000000000000------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ -- -- GtkActionBar is designed to present contextual actions. It is expected to -- be displayed below the content and expand horizontally to fill the area. -- -- It allows placing children at the start or the end. In addition, it -- contains an internal centered box which is centered with respect to the -- full width of the box, even if the children at either side take up -- different amounts of space. -- -- # CSS nodes -- -- GtkActionBar has a single CSS node with name actionbar. -- -- pragma Warnings (Off, "*is already use-visible*"); with Glib; use Glib; with Glib.Types; use Glib.Types; with Gtk.Bin; use Gtk.Bin; with Gtk.Buildable; use Gtk.Buildable; with Gtk.Widget; use Gtk.Widget; package Gtk.Action_Bar is type Gtk_Action_Bar_Record is new Gtk_Bin_Record with null record; type Gtk_Action_Bar is access all Gtk_Action_Bar_Record'Class; ------------------ -- Constructors -- ------------------ procedure Gtk_New (Self : out Gtk_Action_Bar); procedure Initialize (Self : not null access Gtk_Action_Bar_Record'Class); -- Creates a new Gtk.Action_Bar.Gtk_Action_Bar widget. -- Since: gtk+ 3.12 -- Initialize does nothing if the object was already created with another -- call to Initialize* or G_New. function Gtk_Action_Bar_New return Gtk_Action_Bar; -- Creates a new Gtk.Action_Bar.Gtk_Action_Bar widget. -- Since: gtk+ 3.12 function Get_Type return Glib.GType; pragma Import (C, Get_Type, "gtk_action_bar_get_type"); ------------- -- Methods -- ------------- function Get_Center_Widget (Self : not null access Gtk_Action_Bar_Record) return Gtk.Widget.Gtk_Widget; -- Retrieves the center bar widget of the bar. -- Since: gtk+ 3.12 procedure Set_Center_Widget (Self : not null access Gtk_Action_Bar_Record; Center_Widget : access Gtk.Widget.Gtk_Widget_Record'Class); -- Sets the center widget for the Gtk.Action_Bar.Gtk_Action_Bar. -- Since: gtk+ 3.12 -- "center_widget": a widget to use for the center procedure Pack_End (Self : not null access Gtk_Action_Bar_Record; Child : not null access Gtk.Widget.Gtk_Widget_Record'Class); -- Adds Child to Action_Bar, packed with reference to the end of the -- Action_Bar. -- Since: gtk+ 3.12 -- "child": the Gtk.Widget.Gtk_Widget to be added to Action_Bar procedure Pack_Start (Self : not null access Gtk_Action_Bar_Record; Child : not null access Gtk.Widget.Gtk_Widget_Record'Class); -- Adds Child to Action_Bar, packed with reference to the start of the -- Action_Bar. -- Since: gtk+ 3.12 -- "child": the Gtk.Widget.Gtk_Widget to be added to Action_Bar ---------------- -- Interfaces -- ---------------- -- This class implements several interfaces. See Glib.Types -- -- - "Buildable" package Implements_Gtk_Buildable is new Glib.Types.Implements (Gtk.Buildable.Gtk_Buildable, Gtk_Action_Bar_Record, Gtk_Action_Bar); function "+" (Widget : access Gtk_Action_Bar_Record'Class) return Gtk.Buildable.Gtk_Buildable renames Implements_Gtk_Buildable.To_Interface; function "-" (Interf : Gtk.Buildable.Gtk_Buildable) return Gtk_Action_Bar renames Implements_Gtk_Buildable.To_Object; end Gtk.Action_Bar; gtkada-24.0.0/src/generated/gtk-action_group.adb000066400000000000000000001114521446021174000215040ustar00rootroot00000000000000------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ pragma Style_Checks (Off); pragma Warnings (Off, "*is already use-visible*"); with Ada.Unchecked_Conversion; with Ada.Unchecked_Deallocation; with Glib.Type_Conversion_Hooks; use Glib.Type_Conversion_Hooks; with Glib.Values; use Glib.Values; with Gtk.Arguments; use Gtk.Arguments; with Gtkada.Bindings; use Gtkada.Bindings; package body Gtk.Action_Group is function Convert (R : Gtk.Action.Gtk_Action) return System.Address is begin return Get_Object (R); end Convert; function Convert (R : System.Address) return Gtk.Action.Gtk_Action is Stub : Gtk.Action.Gtk_Action_Record;begin return Gtk.Action.Gtk_Action (Glib.Object.Get_User_Data (R, Stub)); end Convert; procedure Local_Radio_Action_Callback (Group, Current, User_Data : System.Address); pragma Convention (C, Local_Radio_Action_Callback); -- Local proxy for Radio_Action_Callback procedure Local_Radio_Action_Destroy (Data : in out System.Address); pragma Convention (C, Local_Radio_Action_Destroy); -- Local proxy for the Destroy notify for Radio_Action type Local_Radio_Action_User_Data is record Callback : Radio_Action_Callback; User_Data : System.Address; Destroy : G_Destroy_Notify_Address; end record; type Local_Radio_Action_User_Data_Access is access Local_Radio_Action_User_Data; function Convert is new Ada.Unchecked_Conversion (System.Address, Local_Radio_Action_User_Data_Access); function Convert is new Ada.Unchecked_Conversion (Local_Radio_Action_User_Data_Access, System.Address); procedure Unchecked_Free is new Ada.Unchecked_Deallocation (Local_Radio_Action_User_Data, Local_Radio_Action_User_Data_Access); procedure Local_Radio_Action_Callback (Group, Current, User_Data : System.Address) is Data : constant Local_Radio_Action_User_Data_Access := Convert (User_Data); Stub : Gtk_Action_Record; G : constant Gtk_Action := Gtk_Action (Get_User_Data (Group, Stub)); C : constant Gtk_Action := Gtk_Action (Get_User_Data (Current, Stub)); begin Data.Callback (G, C, Data.User_Data); end Local_Radio_Action_Callback; procedure Local_Radio_Action_Destroy (Data : in out System.Address) is D : Local_Radio_Action_User_Data_Access := Convert (Data); begin D.Destroy (D.User_Data); Unchecked_Free (D); end Local_Radio_Action_Destroy; function Create (Name : String; Label : String := ""; Stock_Id : String := ""; Accelerator : String := ""; Tooltip : String := ""; Callback : Action_Callback := null) return Action_Entry is begin return (Name => String_Or_Null (Name), Label => String_Or_Null (Label), Stock_Id => String_Or_Null (Stock_Id), Accelerator => String_Or_Null (Accelerator), Tooltip => String_Or_Null (Tooltip), Callback => Callback); end Create; function Create (Name : String; Label : String := ""; Stock_Id : String := ""; Accelerator : String := ""; Tooltip : String := ""; Callback : Action_Callback := null; Is_Active : Boolean := True) return Toggle_Action_Entry is begin return (Name => String_Or_Null (Name), Label => String_Or_Null (Label), Stock_Id => String_Or_Null (Stock_Id), Accelerator => String_Or_Null (Accelerator), Tooltip => String_Or_Null (Tooltip), Callback => Callback, Is_Active => Boolean'Pos (Is_Active)); end Create; function Create (Name : String; Label : String; Stock_Id : String := ""; Accelerator : String := ""; Tooltip : String := ""; Value : Glib.Gint) return Radio_Action_Entry is begin return (Name => String_Or_Null (Name), Label => String_Or_Null (Label), Stock_Id => String_Or_Null (Stock_Id), Accelerator => String_Or_Null (Accelerator), Tooltip => String_Or_Null (Tooltip), Value => Value); end Create; procedure Free (Action : in out Action_Entry) is begin g_free (Action.Name); g_free (Action.Label); g_free (Action.Stock_Id); g_free (Action.Accelerator); g_free (Action.Tooltip); end Free; procedure Free (Actions : in out Action_Entry_Array) is begin for A in Actions'Range loop Free (Actions (A)); end loop; end Free; procedure Free (Action : in out Radio_Action_Entry) is begin g_free (Action.Name); g_free (Action.Label); g_free (Action.Stock_Id); g_free (Action.Accelerator); g_free (Action.Tooltip); end Free; procedure Free (Actions : in out Radio_Action_Entry_Array) is begin for A in Actions'Range loop Free (Actions (A)); end loop; end Free; procedure Free (Action : in out Toggle_Action_Entry) is begin g_free (Action.Name); g_free (Action.Label); g_free (Action.Stock_Id); g_free (Action.Accelerator); g_free (Action.Tooltip); end Free; procedure Free (Actions : in out Toggle_Action_Entry_Array) is begin for A in Actions'Range loop Free (Actions (A)); end loop; end Free; procedure Add_Actions (Action_Group : access Gtk_Action_Group_Record; Entries : Action_Entry_Array; User_Data : System.Address := System.Null_Address; Destroy : Glib.G_Destroy_Notify_Address := null) is procedure Internal (Action_Group : System.Address; Entries : System.Address; N_Entries : Guint; User_Data : System.Address; Destroy : G_Destroy_Notify_Address); pragma Import (C, Internal, "gtk_action_group_add_actions_full"); begin Internal (Get_Object (Action_Group), Entries (Entries'First)'Address, Entries'Length, User_Data, Destroy); end Add_Actions; procedure Add_Radio_Actions (Action_Group : access Gtk_Action_Group_Record; Entries : Radio_Action_Entry_Array; Value : Glib.Gint; On_Change : Radio_Action_Callback; User_Data : System.Address := System.Null_Address; Destroy : Glib.G_Destroy_Notify_Address := null) is procedure Internal (Action_Group : System.Address; Entries : System.Address; N_Entries : Guint; Value : Gint; On_Change : System.Address; User_Data : System.Address; Destroy : System.Address); pragma Import (C, Internal, "gtk_action_group_add_radio_actions_full"); Data : constant Local_Radio_Action_User_Data_Access := new Local_Radio_Action_User_Data' (Callback => On_Change, User_Data => User_Data, Destroy => Destroy); begin Internal (Get_Object (Action_Group), Entries (Entries'First)'Address, Entries'Length, Value, Local_Radio_Action_Callback'Address, Convert (Data), Local_Radio_Action_Destroy'Address); end Add_Radio_Actions; procedure Add_Toggle_Actions (Action_Group : access Gtk_Action_Group_Record; Entries : Toggle_Action_Entry_Array; User_Data : System.Address := System.Null_Address; Destroy : G_Destroy_Notify_Address := null) is procedure Internal (Action_Group : System.Address; Entries : System.Address; N_Entries : Guint; User_Data : System.Address; Destroy : G_Destroy_Notify_Address); pragma Import (C, Internal, "gtk_action_group_add_toggle_actions_full"); begin Internal (Get_Object (Action_Group), Entries (Entries'First)'Address, Entries'Length, User_Data, Destroy); end Add_Toggle_Actions; procedure C_Gtk_Action_Group_Set_Translate_Func (Action_Group : System.Address; Func : System.Address; Data : System.Address; Notify : System.Address); pragma Import (C, C_Gtk_Action_Group_Set_Translate_Func, "gtk_action_group_set_translate_func"); pragma Obsolescent (C_Gtk_Action_Group_Set_Translate_Func); -- Sets a function to be used for translating the Label and Tooltip of -- Gtk_Action_Entrys added by gtk_action_group_add_actions. -- If you're using gettext, it is enough to set the translation domain -- with Gtk.Action_Group.Set_Translation_Domain. -- Since: gtk+ 2.4 -- Deprecated since 3.10, 1 -- "func": a Gtk_Translate_Func -- "data": data to be passed to Func and Notify -- "notify": a Glib.G_Destroy_Notify_Address function to be called when -- Action_Group is destroyed and when the translation function is changed -- again function To_Gtk_Translate_Func is new Ada.Unchecked_Conversion (System.Address, Gtk_Translate_Func); function To_Address is new Ada.Unchecked_Conversion (Gtk_Translate_Func, System.Address); function Internal_Gtk_Translate_Func (Path : Gtkada.Types.Chars_Ptr; Func_Data : System.Address) return Gtkada.Types.Chars_Ptr; pragma Obsolescent (Internal_Gtk_Translate_Func); pragma Convention (C, Internal_Gtk_Translate_Func); -- Deprecated since 3.10, 1 -- "path": The id of the message. In Gtk.Action_Group.Gtk_Action_Group -- this will be a label or tooltip from a Gtk_Action_Entry. -- "func_data": user data passed in when registering the function --------------------------------- -- Internal_Gtk_Translate_Func -- --------------------------------- function Internal_Gtk_Translate_Func (Path : Gtkada.Types.Chars_Ptr; Func_Data : System.Address) return Gtkada.Types.Chars_Ptr is Func : constant Gtk_Translate_Func := To_Gtk_Translate_Func (Func_Data); begin return New_String (Func (Gtkada.Bindings.Value_Allowing_Null (Path))); end Internal_Gtk_Translate_Func; package Type_Conversion_Gtk_Action_Group is new Glib.Type_Conversion_Hooks.Hook_Registrator (Get_Type'Access, Gtk_Action_Group_Record); pragma Unreferenced (Type_Conversion_Gtk_Action_Group); -------------------------- -- Gtk_Action_Group_New -- -------------------------- function Gtk_Action_Group_New (Name : UTF8_String) return Gtk_Action_Group is Action_Group : constant Gtk_Action_Group := new Gtk_Action_Group_Record; begin Gtk.Action_Group.Initialize (Action_Group, Name); return Action_Group; end Gtk_Action_Group_New; ------------- -- Gtk_New -- ------------- procedure Gtk_New (Action_Group : out Gtk_Action_Group; Name : UTF8_String) is begin Action_Group := new Gtk_Action_Group_Record; Gtk.Action_Group.Initialize (Action_Group, Name); end Gtk_New; ---------------- -- Initialize -- ---------------- procedure Initialize (Action_Group : not null access Gtk_Action_Group_Record'Class; Name : UTF8_String) is function Internal (Name : Gtkada.Types.Chars_Ptr) return System.Address; pragma Import (C, Internal, "gtk_action_group_new"); Tmp_Name : Gtkada.Types.Chars_Ptr := New_String (Name); Tmp_Return : System.Address; begin if not Action_Group.Is_Created then Tmp_Return := Internal (Tmp_Name); Free (Tmp_Name); Set_Object (Action_Group, Tmp_Return); end if; end Initialize; ---------------- -- Add_Action -- ---------------- procedure Add_Action (Action_Group : not null access Gtk_Action_Group_Record; Action : not null access Gtk.Action.Gtk_Action_Record'Class) is procedure Internal (Action_Group : System.Address; Action : System.Address); pragma Import (C, Internal, "gtk_action_group_add_action"); begin Internal (Get_Object (Action_Group), Get_Object (Action)); end Add_Action; --------------------------- -- Add_Action_With_Accel -- --------------------------- procedure Add_Action_With_Accel (Action_Group : not null access Gtk_Action_Group_Record; Action : not null access Gtk.Action.Gtk_Action_Record'Class; Accelerator : UTF8_String := "") is procedure Internal (Action_Group : System.Address; Action : System.Address; Accelerator : Gtkada.Types.Chars_Ptr); pragma Import (C, Internal, "gtk_action_group_add_action_with_accel"); Tmp_Accelerator : Gtkada.Types.Chars_Ptr; begin if Accelerator = "" then Tmp_Accelerator := Gtkada.Types.Null_Ptr; else Tmp_Accelerator := New_String (Accelerator); end if; Internal (Get_Object (Action_Group), Get_Object (Action), Tmp_Accelerator); Free (Tmp_Accelerator); end Add_Action_With_Accel; --------------------- -- Get_Accel_Group -- --------------------- function Get_Accel_Group (Action_Group : not null access Gtk_Action_Group_Record) return Gtk.Accel_Group.Gtk_Accel_Group is function Internal (Action_Group : System.Address) return System.Address; pragma Import (C, Internal, "gtk_action_group_get_accel_group"); Stub_Gtk_Accel_Group : Gtk.Accel_Group.Gtk_Accel_Group_Record; begin return Gtk.Accel_Group.Gtk_Accel_Group (Get_User_Data (Internal (Get_Object (Action_Group)), Stub_Gtk_Accel_Group)); end Get_Accel_Group; ---------------- -- Get_Action -- ---------------- function Get_Action (Action_Group : not null access Gtk_Action_Group_Record; Action_Name : UTF8_String) return Gtk.Action.Gtk_Action is function Internal (Action_Group : System.Address; Action_Name : Gtkada.Types.Chars_Ptr) return System.Address; pragma Import (C, Internal, "gtk_action_group_get_action"); Tmp_Action_Name : Gtkada.Types.Chars_Ptr := New_String (Action_Name); Stub_Gtk_Action : Gtk.Action.Gtk_Action_Record; Tmp_Return : System.Address; begin Tmp_Return := Internal (Get_Object (Action_Group), Tmp_Action_Name); Free (Tmp_Action_Name); return Gtk.Action.Gtk_Action (Get_User_Data (Tmp_Return, Stub_Gtk_Action)); end Get_Action; -------------- -- Get_Name -- -------------- function Get_Name (Action_Group : not null access Gtk_Action_Group_Record) return UTF8_String is function Internal (Action_Group : System.Address) return Gtkada.Types.Chars_Ptr; pragma Import (C, Internal, "gtk_action_group_get_name"); begin return Gtkada.Bindings.Value_Allowing_Null (Internal (Get_Object (Action_Group))); end Get_Name; ------------------- -- Get_Sensitive -- ------------------- function Get_Sensitive (Action_Group : not null access Gtk_Action_Group_Record) return Boolean is function Internal (Action_Group : System.Address) return Glib.Gboolean; pragma Import (C, Internal, "gtk_action_group_get_sensitive"); begin return Internal (Get_Object (Action_Group)) /= 0; end Get_Sensitive; ----------------- -- Get_Visible -- ----------------- function Get_Visible (Action_Group : not null access Gtk_Action_Group_Record) return Boolean is function Internal (Action_Group : System.Address) return Glib.Gboolean; pragma Import (C, Internal, "gtk_action_group_get_visible"); begin return Internal (Get_Object (Action_Group)) /= 0; end Get_Visible; ------------------ -- List_Actions -- ------------------ function List_Actions (Action_Group : not null access Gtk_Action_Group_Record) return Action_List.Glist is function Internal (Action_Group : System.Address) return System.Address; pragma Import (C, Internal, "gtk_action_group_list_actions"); Tmp_Return : Action_List.Glist; begin Gtk.Action_Group.Action_List.Set_Object (Tmp_Return, Internal (Get_Object (Action_Group))); return Tmp_Return; end List_Actions; ------------------- -- Remove_Action -- ------------------- procedure Remove_Action (Action_Group : not null access Gtk_Action_Group_Record; Action : not null access Gtk.Action.Gtk_Action_Record'Class) is procedure Internal (Action_Group : System.Address; Action : System.Address); pragma Import (C, Internal, "gtk_action_group_remove_action"); begin Internal (Get_Object (Action_Group), Get_Object (Action)); end Remove_Action; --------------------- -- Set_Accel_Group -- --------------------- procedure Set_Accel_Group (Action_Group : not null access Gtk_Action_Group_Record; Accel_Group : access Gtk.Accel_Group.Gtk_Accel_Group_Record'Class) is procedure Internal (Action_Group : System.Address; Accel_Group : System.Address); pragma Import (C, Internal, "gtk_action_group_set_accel_group"); begin Internal (Get_Object (Action_Group), Get_Object_Or_Null (GObject (Accel_Group))); end Set_Accel_Group; ------------------- -- Set_Sensitive -- ------------------- procedure Set_Sensitive (Action_Group : not null access Gtk_Action_Group_Record; Sensitive : Boolean) is procedure Internal (Action_Group : System.Address; Sensitive : Glib.Gboolean); pragma Import (C, Internal, "gtk_action_group_set_sensitive"); begin Internal (Get_Object (Action_Group), Boolean'Pos (Sensitive)); end Set_Sensitive; ------------------------ -- Set_Translate_Func -- ------------------------ procedure Set_Translate_Func (Action_Group : not null access Gtk_Action_Group_Record; Func : Gtk_Translate_Func) is begin if Func = null then C_Gtk_Action_Group_Set_Translate_Func (Get_Object (Action_Group), System.Null_Address, System.Null_Address, System.Null_Address); else C_Gtk_Action_Group_Set_Translate_Func (Get_Object (Action_Group), Internal_Gtk_Translate_Func'Address, To_Address (Func), System.Null_Address); end if; end Set_Translate_Func; package body Set_Translate_Func_User_Data is package Users is new Glib.Object.User_Data_Closure (User_Data_Type, Destroy); function To_Gtk_Translate_Func is new Ada.Unchecked_Conversion (System.Address, Gtk_Translate_Func); function To_Address is new Ada.Unchecked_Conversion (Gtk_Translate_Func, System.Address); function Internal_Cb (Path : Gtkada.Types.Chars_Ptr; Func_Data : System.Address) return Gtkada.Types.Chars_Ptr; pragma Obsolescent (Internal_Cb); pragma Convention (C, Internal_Cb); -- The function used to translate messages in e.g. -- Gtk.Icon_Factory.Gtk_Icon_Factory and -- Gtk.Action_Group.Gtk_Action_Group. -- Deprecated since 3.10, 1 -- "path": The id of the message. In Gtk.Action_Group.Gtk_Action_Group -- this will be a label or tooltip from a Gtk_Action_Entry. -- "func_data": user data passed in when registering the function ----------------- -- Internal_Cb -- ----------------- function Internal_Cb (Path : Gtkada.Types.Chars_Ptr; Func_Data : System.Address) return Gtkada.Types.Chars_Ptr is D : constant Users.Internal_Data_Access := Users.Convert (Func_Data); begin return New_String (To_Gtk_Translate_Func (D.Func) (Gtkada.Bindings.Value_Allowing_Null (Path), D.Data.all)); end Internal_Cb; ------------------------ -- Set_Translate_Func -- ------------------------ procedure Set_Translate_Func (Action_Group : not null access Gtk.Action_Group.Gtk_Action_Group_Record'Class; Func : Gtk_Translate_Func; Data : User_Data_Type) is D : System.Address; begin if Func = null then C_Gtk_Action_Group_Set_Translate_Func (Get_Object (Action_Group), System.Null_Address, System.Null_Address, Users.Free_Data'Address); else D := Users.Build (To_Address (Func), Data); C_Gtk_Action_Group_Set_Translate_Func (Get_Object (Action_Group), Internal_Cb'Address, D, Users.Free_Data'Address); end if; end Set_Translate_Func; end Set_Translate_Func_User_Data; ---------------------------- -- Set_Translation_Domain -- ---------------------------- procedure Set_Translation_Domain (Action_Group : not null access Gtk_Action_Group_Record; Domain : UTF8_String := "") is procedure Internal (Action_Group : System.Address; Domain : Gtkada.Types.Chars_Ptr); pragma Import (C, Internal, "gtk_action_group_set_translation_domain"); Tmp_Domain : Gtkada.Types.Chars_Ptr; begin if Domain = "" then Tmp_Domain := Gtkada.Types.Null_Ptr; else Tmp_Domain := New_String (Domain); end if; Internal (Get_Object (Action_Group), Tmp_Domain); Free (Tmp_Domain); end Set_Translation_Domain; ----------------- -- Set_Visible -- ----------------- procedure Set_Visible (Action_Group : not null access Gtk_Action_Group_Record; Visible : Boolean) is procedure Internal (Action_Group : System.Address; Visible : Glib.Gboolean); pragma Import (C, Internal, "gtk_action_group_set_visible"); begin Internal (Get_Object (Action_Group), Boolean'Pos (Visible)); end Set_Visible; ---------------------- -- Translate_String -- ---------------------- function Translate_String (Action_Group : not null access Gtk_Action_Group_Record; String : UTF8_String) return UTF8_String is function Internal (Action_Group : System.Address; String : Gtkada.Types.Chars_Ptr) return Gtkada.Types.Chars_Ptr; pragma Import (C, Internal, "gtk_action_group_translate_string"); Tmp_String : Gtkada.Types.Chars_Ptr := New_String (String); Tmp_Return : Gtkada.Types.Chars_Ptr; begin Tmp_Return := Internal (Get_Object (Action_Group), Tmp_String); Free (Tmp_String); return Gtkada.Bindings.Value_Allowing_Null (Tmp_Return); end Translate_String; use type System.Address; function Cb_To_Address is new Ada.Unchecked_Conversion (Cb_Gtk_Action_Group_Gtk_Action_Gtk_Widget_Void, System.Address); function Address_To_Cb is new Ada.Unchecked_Conversion (System.Address, Cb_Gtk_Action_Group_Gtk_Action_Gtk_Widget_Void); function Cb_To_Address is new Ada.Unchecked_Conversion (Cb_GObject_Gtk_Action_Gtk_Widget_Void, System.Address); function Address_To_Cb is new Ada.Unchecked_Conversion (System.Address, Cb_GObject_Gtk_Action_Gtk_Widget_Void); function Cb_To_Address is new Ada.Unchecked_Conversion (Cb_Gtk_Action_Group_Gtk_Action_Void, System.Address); function Address_To_Cb is new Ada.Unchecked_Conversion (System.Address, Cb_Gtk_Action_Group_Gtk_Action_Void); function Cb_To_Address is new Ada.Unchecked_Conversion (Cb_GObject_Gtk_Action_Void, System.Address); function Address_To_Cb is new Ada.Unchecked_Conversion (System.Address, Cb_GObject_Gtk_Action_Void); procedure Connect (Object : access Gtk_Action_Group_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_Gtk_Action_Group_Gtk_Action_Gtk_Widget_Void; After : Boolean); procedure Connect (Object : access Gtk_Action_Group_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_Gtk_Action_Group_Gtk_Action_Void; After : Boolean); procedure Connect_Slot (Object : access Gtk_Action_Group_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_GObject_Gtk_Action_Gtk_Widget_Void; After : Boolean; Slot : access Glib.Object.GObject_Record'Class := null); procedure Connect_Slot (Object : access Gtk_Action_Group_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_GObject_Gtk_Action_Void; After : Boolean; Slot : access Glib.Object.GObject_Record'Class := null); procedure Marsh_GObject_Gtk_Action_Gtk_Widget_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address); pragma Convention (C, Marsh_GObject_Gtk_Action_Gtk_Widget_Void); procedure Marsh_GObject_Gtk_Action_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address); pragma Convention (C, Marsh_GObject_Gtk_Action_Void); procedure Marsh_Gtk_Action_Group_Gtk_Action_Gtk_Widget_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address); pragma Convention (C, Marsh_Gtk_Action_Group_Gtk_Action_Gtk_Widget_Void); procedure Marsh_Gtk_Action_Group_Gtk_Action_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address); pragma Convention (C, Marsh_Gtk_Action_Group_Gtk_Action_Void); ------------- -- Connect -- ------------- procedure Connect (Object : access Gtk_Action_Group_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_Gtk_Action_Group_Gtk_Action_Gtk_Widget_Void; After : Boolean) is begin Unchecked_Do_Signal_Connect (Object => Object, C_Name => C_Name, Marshaller => Marsh_Gtk_Action_Group_Gtk_Action_Gtk_Widget_Void'Access, Handler => Cb_To_Address (Handler),-- Set in the closure After => After); end Connect; ------------- -- Connect -- ------------- procedure Connect (Object : access Gtk_Action_Group_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_Gtk_Action_Group_Gtk_Action_Void; After : Boolean) is begin Unchecked_Do_Signal_Connect (Object => Object, C_Name => C_Name, Marshaller => Marsh_Gtk_Action_Group_Gtk_Action_Void'Access, Handler => Cb_To_Address (Handler),-- Set in the closure After => After); end Connect; ------------------ -- Connect_Slot -- ------------------ procedure Connect_Slot (Object : access Gtk_Action_Group_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_GObject_Gtk_Action_Gtk_Widget_Void; After : Boolean; Slot : access Glib.Object.GObject_Record'Class := null) is begin Unchecked_Do_Signal_Connect (Object => Object, C_Name => C_Name, Marshaller => Marsh_GObject_Gtk_Action_Gtk_Widget_Void'Access, Handler => Cb_To_Address (Handler),-- Set in the closure Slot_Object => Slot, After => After); end Connect_Slot; ------------------ -- Connect_Slot -- ------------------ procedure Connect_Slot (Object : access Gtk_Action_Group_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_GObject_Gtk_Action_Void; After : Boolean; Slot : access Glib.Object.GObject_Record'Class := null) is begin Unchecked_Do_Signal_Connect (Object => Object, C_Name => C_Name, Marshaller => Marsh_GObject_Gtk_Action_Void'Access, Handler => Cb_To_Address (Handler),-- Set in the closure Slot_Object => Slot, After => After); end Connect_Slot; ---------------------------------------------- -- Marsh_GObject_Gtk_Action_Gtk_Widget_Void -- ---------------------------------------------- procedure Marsh_GObject_Gtk_Action_Gtk_Widget_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address) is pragma Unreferenced (Return_Value, N_Params, Invocation_Hint, User_Data); H : constant Cb_GObject_Gtk_Action_Gtk_Widget_Void := Address_To_Cb (Get_Callback (Closure)); Obj : constant Glib.Object.GObject := Glib.Object.Convert (Get_Data (Closure)); begin H (Obj, Gtk.Action.Gtk_Action (Unchecked_To_Object (Params, 1)), Gtk.Widget.Gtk_Widget (Unchecked_To_Object (Params, 2))); exception when E : others => Process_Exception (E); end Marsh_GObject_Gtk_Action_Gtk_Widget_Void; ----------------------------------- -- Marsh_GObject_Gtk_Action_Void -- ----------------------------------- procedure Marsh_GObject_Gtk_Action_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address) is pragma Unreferenced (Return_Value, N_Params, Invocation_Hint, User_Data); H : constant Cb_GObject_Gtk_Action_Void := Address_To_Cb (Get_Callback (Closure)); Obj : constant Glib.Object.GObject := Glib.Object.Convert (Get_Data (Closure)); begin H (Obj, Gtk.Action.Gtk_Action (Unchecked_To_Object (Params, 1))); exception when E : others => Process_Exception (E); end Marsh_GObject_Gtk_Action_Void; ------------------------------------------------------- -- Marsh_Gtk_Action_Group_Gtk_Action_Gtk_Widget_Void -- ------------------------------------------------------- procedure Marsh_Gtk_Action_Group_Gtk_Action_Gtk_Widget_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address) is pragma Unreferenced (Return_Value, N_Params, Invocation_Hint, User_Data); H : constant Cb_Gtk_Action_Group_Gtk_Action_Gtk_Widget_Void := Address_To_Cb (Get_Callback (Closure)); Obj : constant Gtk_Action_Group := Gtk_Action_Group (Unchecked_To_Object (Params, 0)); begin H (Obj, Gtk.Action.Gtk_Action (Unchecked_To_Object (Params, 1)), Gtk.Widget.Gtk_Widget (Unchecked_To_Object (Params, 2))); exception when E : others => Process_Exception (E); end Marsh_Gtk_Action_Group_Gtk_Action_Gtk_Widget_Void; -------------------------------------------- -- Marsh_Gtk_Action_Group_Gtk_Action_Void -- -------------------------------------------- procedure Marsh_Gtk_Action_Group_Gtk_Action_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address) is pragma Unreferenced (Return_Value, N_Params, Invocation_Hint, User_Data); H : constant Cb_Gtk_Action_Group_Gtk_Action_Void := Address_To_Cb (Get_Callback (Closure)); Obj : constant Gtk_Action_Group := Gtk_Action_Group (Unchecked_To_Object (Params, 0)); begin H (Obj, Gtk.Action.Gtk_Action (Unchecked_To_Object (Params, 1))); exception when E : others => Process_Exception (E); end Marsh_Gtk_Action_Group_Gtk_Action_Void; ---------------------- -- On_Connect_Proxy -- ---------------------- procedure On_Connect_Proxy (Self : not null access Gtk_Action_Group_Record; Call : Cb_Gtk_Action_Group_Gtk_Action_Gtk_Widget_Void; After : Boolean := False) is begin Connect (Self, "connect-proxy" & ASCII.NUL, Call, After); end On_Connect_Proxy; ---------------------- -- On_Connect_Proxy -- ---------------------- procedure On_Connect_Proxy (Self : not null access Gtk_Action_Group_Record; Call : Cb_GObject_Gtk_Action_Gtk_Widget_Void; Slot : not null access Glib.Object.GObject_Record'Class; After : Boolean := False) is begin Connect_Slot (Self, "connect-proxy" & ASCII.NUL, Call, After, Slot); end On_Connect_Proxy; ------------------------- -- On_Disconnect_Proxy -- ------------------------- procedure On_Disconnect_Proxy (Self : not null access Gtk_Action_Group_Record; Call : Cb_Gtk_Action_Group_Gtk_Action_Gtk_Widget_Void; After : Boolean := False) is begin Connect (Self, "disconnect-proxy" & ASCII.NUL, Call, After); end On_Disconnect_Proxy; ------------------------- -- On_Disconnect_Proxy -- ------------------------- procedure On_Disconnect_Proxy (Self : not null access Gtk_Action_Group_Record; Call : Cb_GObject_Gtk_Action_Gtk_Widget_Void; Slot : not null access Glib.Object.GObject_Record'Class; After : Boolean := False) is begin Connect_Slot (Self, "disconnect-proxy" & ASCII.NUL, Call, After, Slot); end On_Disconnect_Proxy; ---------------------- -- On_Post_Activate -- ---------------------- procedure On_Post_Activate (Self : not null access Gtk_Action_Group_Record; Call : Cb_Gtk_Action_Group_Gtk_Action_Void; After : Boolean := False) is begin Connect (Self, "post-activate" & ASCII.NUL, Call, After); end On_Post_Activate; ---------------------- -- On_Post_Activate -- ---------------------- procedure On_Post_Activate (Self : not null access Gtk_Action_Group_Record; Call : Cb_GObject_Gtk_Action_Void; Slot : not null access Glib.Object.GObject_Record'Class; After : Boolean := False) is begin Connect_Slot (Self, "post-activate" & ASCII.NUL, Call, After, Slot); end On_Post_Activate; --------------------- -- On_Pre_Activate -- --------------------- procedure On_Pre_Activate (Self : not null access Gtk_Action_Group_Record; Call : Cb_Gtk_Action_Group_Gtk_Action_Void; After : Boolean := False) is begin Connect (Self, "pre-activate" & ASCII.NUL, Call, After); end On_Pre_Activate; --------------------- -- On_Pre_Activate -- --------------------- procedure On_Pre_Activate (Self : not null access Gtk_Action_Group_Record; Call : Cb_GObject_Gtk_Action_Void; Slot : not null access Glib.Object.GObject_Record'Class; After : Boolean := False) is begin Connect_Slot (Self, "pre-activate" & ASCII.NUL, Call, After, Slot); end On_Pre_Activate; end Gtk.Action_Group; gtkada-24.0.0/src/generated/gtk-action_group.ads000066400000000000000000000631631446021174000215320ustar00rootroot00000000000000------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ -- -- Actions are organised into groups. An action group is essentially a map -- from names to Gtk.Action.Gtk_Action objects. -- -- All actions that would make sense to use in a particular context should be -- in a single group. Multiple action groups may be used for a particular user -- interface. In fact, it is expected that most nontrivial applications will -- make use of multiple groups. For example, in an application that can edit -- multiple documents, one group holding global actions (e.g. quit, about, -- new), and one group per document holding actions that act on that document -- (eg. save, cut/copy/paste, etc). Each window's menus would be constructed -- from a combination of two action groups. -- -- ## Accelerators ## {Gtk.Action.Gtk_Action-Accel} -- -- Accelerators are handled by the GTK+ accelerator map. All actions are -- assigned an accelerator path (which normally has the form -- `/group-name/action-name`) and a shortcut is associated with this -- accelerator path. All menuitems and toolitems take on this accelerator -- path. The GTK+ accelerator map code makes sure that the correct shortcut is -- displayed next to the menu item. -- -- # GtkActionGroup as GtkBuildable # -- {Gtk.Action_Group.Gtk_Action_Group-BUILDER-UI} -- -- The Gtk.Action_Group.Gtk_Action_Group implementation of the -- Gtk.Buildable.Gtk_Buildable interface accepts Gtk.Action.Gtk_Action objects -- as elements in UI definitions. -- -- Note that it is probably more common to define actions and action groups -- in the code, since they are directly related to what the code can do. -- -- The GtkActionGroup implementation of the GtkBuildable interface supports a -- custom element, which has attributes named "key" and -- "modifiers" and allows to specify accelerators. This is similar to the -- element of Gtk.Widget.Gtk_Widget, the main difference is that -- it doesn't allow you to specify a signal. -- -- ## A Gtk.Dialog.Gtk_Dialog UI definition fragment. ## |[ About gtk-about ]| -- -- pragma Warnings (Off, "*is already use-visible*"); with Glib; use Glib; with Glib.Glist; use Glib.Glist; with Glib.Object; use Glib.Object; with Glib.Properties; use Glib.Properties; with Glib.Types; use Glib.Types; with Gtk.Accel_Group; use Gtk.Accel_Group; with Gtk.Action; use Gtk.Action; with Gtk.Buildable; use Gtk.Buildable; with Gtk.Widget; use Gtk.Widget; with Gtkada.Types; use Gtkada.Types; package Gtk.Action_Group is type Gtk_Action_Group_Record is new GObject_Record with null record; type Gtk_Action_Group is access all Gtk_Action_Group_Record'Class; function Convert (R : Gtk.Action.Gtk_Action) return System.Address; function Convert (R : System.Address) return Gtk.Action.Gtk_Action; package Action_List is new Generic_List (Gtk.Action.Gtk_Action); --------------- -- Callbacks -- --------------- type Gtk_Translate_Func is access function (Path : UTF8_String) return UTF8_String; -- The function used to translate messages in e.g. -- Gtk.Icon_Factory.Gtk_Icon_Factory and Gtk.Action_Group.Gtk_Action_Group. -- "path": The id of the message. In Gtk.Action_Group.Gtk_Action_Group -- this will be a label or tooltip from a Gtk_Action_Entry. ------------------ -- Constructors -- ------------------ procedure Gtk_New (Action_Group : out Gtk_Action_Group; Name : UTF8_String); procedure Initialize (Action_Group : not null access Gtk_Action_Group_Record'Class; Name : UTF8_String); -- Creates a new Gtk.Action_Group.Gtk_Action_Group object. The name of the -- action group is used when associating [keybindings][Action-Accel] with -- the actions. -- Since: gtk+ 2.4 -- Initialize does nothing if the object was already created with another -- call to Initialize* or G_New. -- "name": the name of the action group. function Gtk_Action_Group_New (Name : UTF8_String) return Gtk_Action_Group; -- Creates a new Gtk.Action_Group.Gtk_Action_Group object. The name of the -- action group is used when associating [keybindings][Action-Accel] with -- the actions. -- Since: gtk+ 2.4 -- "name": the name of the action group. function Get_Type return Glib.GType; pragma Import (C, Get_Type, "gtk_action_group_get_type"); ------------- -- Methods -- ------------- procedure Add_Action (Action_Group : not null access Gtk_Action_Group_Record; Action : not null access Gtk.Action.Gtk_Action_Record'Class); pragma Obsolescent (Add_Action); -- Adds an action object to the action group. Note that this function does -- not set up the accel path of the action, which can lead to problems if a -- user tries to modify the accelerator of a menuitem associated with the -- action. Therefore you must either set the accel path yourself with -- Gtk.Action.Set_Accel_Path, or use -- `gtk_action_group_add_action_with_accel (..., NULL)`. -- Since: gtk+ 2.4 -- Deprecated since 3.10, 1 -- "action": an action procedure Add_Action_With_Accel (Action_Group : not null access Gtk_Action_Group_Record; Action : not null access Gtk.Action.Gtk_Action_Record'Class; Accelerator : UTF8_String := ""); pragma Obsolescent (Add_Action_With_Accel); -- Adds an action object to the action group and sets up the accelerator. -- If Accelerator is null, attempts to use the accelerator associated with -- the stock_id of the action. -- Accel paths are set to `/group-name/action-name`. -- Since: gtk+ 2.4 -- Deprecated since 3.10, 1 -- "action": the action to add -- "accelerator": the accelerator for the action, in the format understood -- by Gtk.Accel_Group.Accelerator_Parse, or "" for no accelerator, or null -- to use the stock accelerator function Get_Accel_Group (Action_Group : not null access Gtk_Action_Group_Record) return Gtk.Accel_Group.Gtk_Accel_Group; pragma Obsolescent (Get_Accel_Group); -- Gets the accelerator group. -- Since: gtk+ 3.6 -- Deprecated since 3.10, 1 procedure Set_Accel_Group (Action_Group : not null access Gtk_Action_Group_Record; Accel_Group : access Gtk.Accel_Group.Gtk_Accel_Group_Record'Class); pragma Obsolescent (Set_Accel_Group); -- Sets the accelerator group to be used by every action in this group. -- Since: gtk+ 3.6 -- Deprecated since 3.10, 1 -- "accel_group": a Gtk.Accel_Group.Gtk_Accel_Group to set or null function Get_Action (Action_Group : not null access Gtk_Action_Group_Record; Action_Name : UTF8_String) return Gtk.Action.Gtk_Action; pragma Obsolescent (Get_Action); -- Looks up an action in the action group by name. -- Since: gtk+ 2.4 -- Deprecated since 3.10, 1 -- "action_name": the name of the action function Get_Name (Action_Group : not null access Gtk_Action_Group_Record) return UTF8_String; pragma Obsolescent (Get_Name); -- Gets the name of the action group. -- Since: gtk+ 2.4 -- Deprecated since 3.10, 1 function Get_Sensitive (Action_Group : not null access Gtk_Action_Group_Record) return Boolean; pragma Obsolescent (Get_Sensitive); -- Returns True if the group is sensitive. The constituent actions can -- only be logically sensitive (see Gtk.Action.Is_Sensitive) if they are -- sensitive (see Gtk.Action.Get_Sensitive) and their group is sensitive. -- Since: gtk+ 2.4 -- Deprecated since 3.10, 1 procedure Set_Sensitive (Action_Group : not null access Gtk_Action_Group_Record; Sensitive : Boolean); pragma Obsolescent (Set_Sensitive); -- Changes the sensitivity of Action_Group -- Since: gtk+ 2.4 -- Deprecated since 3.10, 1 -- "sensitive": new sensitivity function Get_Visible (Action_Group : not null access Gtk_Action_Group_Record) return Boolean; pragma Obsolescent (Get_Visible); -- Returns True if the group is visible. The constituent actions can only -- be logically visible (see Gtk.Action.Is_Visible) if they are visible -- (see Gtk.Action.Get_Visible) and their group is visible. -- Since: gtk+ 2.4 -- Deprecated since 3.10, 1 procedure Set_Visible (Action_Group : not null access Gtk_Action_Group_Record; Visible : Boolean); pragma Obsolescent (Set_Visible); -- Changes the visible of Action_Group. -- Since: gtk+ 2.4 -- Deprecated since 3.10, 1 -- "visible": new visiblity function List_Actions (Action_Group : not null access Gtk_Action_Group_Record) return Action_List.Glist; pragma Obsolescent (List_Actions); -- Lists the actions in the action group. -- Since: gtk+ 2.4 -- Deprecated since 3.10, 1 procedure Remove_Action (Action_Group : not null access Gtk_Action_Group_Record; Action : not null access Gtk.Action.Gtk_Action_Record'Class); pragma Obsolescent (Remove_Action); -- Removes an action object from the action group. -- Since: gtk+ 2.4 -- Deprecated since 3.10, 1 -- "action": an action procedure Set_Translate_Func (Action_Group : not null access Gtk_Action_Group_Record; Func : Gtk_Translate_Func); pragma Obsolescent (Set_Translate_Func); -- Sets a function to be used for translating the Label and Tooltip of -- Gtk_Action_Entrys added by gtk_action_group_add_actions. -- If you're using gettext, it is enough to set the translation domain -- with Gtk.Action_Group.Set_Translation_Domain. -- Since: gtk+ 2.4 -- Deprecated since 3.10, 1 -- "func": a Gtk_Translate_Func generic type User_Data_Type (<>) is private; with procedure Destroy (Data : in out User_Data_Type) is null; package Set_Translate_Func_User_Data is type Gtk_Translate_Func is access function (Path : UTF8_String; Func_Data : User_Data_Type) return UTF8_String; -- The function used to translate messages in e.g. -- Gtk.Icon_Factory.Gtk_Icon_Factory and Gtk.Action_Group.Gtk_Action_Group. -- "path": The id of the message. In Gtk.Action_Group.Gtk_Action_Group -- this will be a label or tooltip from a Gtk_Action_Entry. -- "func_data": user data passed in when registering the function procedure Set_Translate_Func (Action_Group : not null access Gtk.Action_Group.Gtk_Action_Group_Record'Class; Func : Gtk_Translate_Func; Data : User_Data_Type); pragma Obsolescent (Set_Translate_Func); -- Sets a function to be used for translating the Label and Tooltip of -- Gtk_Action_Entrys added by gtk_action_group_add_actions. -- If you're using gettext, it is enough to set the translation domain -- with Gtk.Action_Group.Set_Translation_Domain. -- Since: gtk+ 2.4 -- Deprecated since 3.10, 1 -- "func": a Gtk_Translate_Func -- "data": data to be passed to Func and Notify end Set_Translate_Func_User_Data; procedure Set_Translation_Domain (Action_Group : not null access Gtk_Action_Group_Record; Domain : UTF8_String := ""); pragma Obsolescent (Set_Translation_Domain); -- Sets the translation domain and uses g_dgettext for translating the -- Label and Tooltip of Gtk_Action_Entrys added by -- gtk_action_group_add_actions. -- If you're not using gettext for localization, see -- Gtk.Action_Group.Set_Translate_Func. -- Since: gtk+ 2.4 -- Deprecated since 3.10, 1 -- "domain": the translation domain to use for g_dgettext calls, or null -- to use the domain set with textdomain function Translate_String (Action_Group : not null access Gtk_Action_Group_Record; String : UTF8_String) return UTF8_String; pragma Obsolescent (Translate_String); -- Translates a string using the function set with -- Gtk.Action_Group.Set_Translate_Func. This is mainly intended for -- language bindings. -- Since: gtk+ 2.6 -- Deprecated since 3.10, 1 -- "string": a string ---------------------- -- GtkAda additions -- ---------------------- type Action_Callback is access procedure (Action : System.Address; User_Data : System.Address); pragma Convention (C, Action_Callback); -- Profile of callbacks when an action is activated. You must convert -- Action to a Gtk_Action through: -- Act : constant Gtk_Action := Convert (Action); type Action_Entry is record Name : Gtkada.Types.Chars_Ptr; Stock_Id : Gtkada.Types.Chars_Ptr; Label : Gtkada.Types.Chars_Ptr; Accelerator : Gtkada.Types.Chars_Ptr; Tooltip : Gtkada.Types.Chars_Ptr; Callback : Action_Callback; end record; pragma Convention (C, Action_Entry); type Radio_Action_Entry is record Name : Gtkada.Types.Chars_Ptr; Stock_Id : Gtkada.Types.Chars_Ptr; Label : Gtkada.Types.Chars_Ptr; Accelerator : Gtkada.Types.Chars_Ptr; Tooltip : Gtkada.Types.Chars_Ptr; Value : Glib.Gint; end record; pragma Convention (C, Radio_Action_Entry); type Toggle_Action_Entry is record Name : Gtkada.Types.Chars_Ptr; Stock_Id : Gtkada.Types.Chars_Ptr; Label : Gtkada.Types.Chars_Ptr; Accelerator : Gtkada.Types.Chars_Ptr; Tooltip : Gtkada.Types.Chars_Ptr; Callback : Action_Callback; Is_Active : Glib.Gboolean; end record; pragma Convention (C, Toggle_Action_Entry); -- An opaque structure describing an action entry type Action_Entry_Array is array (Natural range <>) of Action_Entry; type Radio_Action_Entry_Array is array (Natural range <>) of Radio_Action_Entry; type Toggle_Action_Entry_Array is array (Natural range <>) of Toggle_Action_Entry; type Radio_Action_Callback is access procedure (Group : access Gtk.Action.Gtk_Action_Record'Class; Current : access Gtk.Action.Gtk_Action_Record'Class; User_Data : System.Address); -- Called when an element of the Gtk_Radio_Action group is selected function Create (Name : String; Label : String := ""; Stock_Id : String := ""; Accelerator : String := ""; Tooltip : String := ""; Callback : Action_Callback := null) return Action_Entry; -- Create a new Action_Entry. The returned value must be freed by the -- caller. function Create (Name : String; Label : String := ""; Stock_Id : String := ""; Accelerator : String := ""; Tooltip : String := ""; Callback : Action_Callback := null; Is_Active : Boolean := True) return Toggle_Action_Entry; -- Create a new Action_Entry. The returned value must be freed by the -- caller. Is_Active is the initial state of the button. function Create (Name : String; Label : String; Stock_Id : String := ""; Accelerator : String := ""; Tooltip : String := ""; Value : Glib.Gint) return Radio_Action_Entry; -- Create a new Radio_Action_Entry. Value is the value set on the radio -- action (see Gtk.Radio_Action.Get_Current_Value) procedure Free (Action : in out Action_Entry); procedure Free (Actions : in out Action_Entry_Array); procedure Free (Action : in out Radio_Action_Entry); procedure Free (Actions : in out Radio_Action_Entry_Array); procedure Free (Action : in out Toggle_Action_Entry); procedure Free (Actions : in out Toggle_Action_Entry_Array); -- Free Action and Actions procedure Add_Actions (Action_Group : access Gtk_Action_Group_Record; Entries : Action_Entry_Array; User_Data : System.Address := System.Null_Address; Destroy : Glib.G_Destroy_Notify_Address := null); -- This is a convenience function to create a number of actions and add -- them to the action group. -- Destroy is called when User_Data is no longer needed. -- -- The "activate" signals of the actions are connected to the callbacks in -- Entries, and their accel paths are set to -- /group-name/action-name. procedure Add_Radio_Actions (Action_Group : access Gtk_Action_Group_Record; Entries : Radio_Action_Entry_Array; Value : Glib.Gint; On_Change : Radio_Action_Callback; User_Data : System.Address := System.Null_Address; Destroy : Glib.G_Destroy_Notify_Address := null); -- This is a convenience routine to create a group of radio actions and -- add them to the action group. -- -- The "changed" signal of the first radio action is connected to the -- On_Change callback and the accel paths of the actions are set to -- /group-name/action-name -- -- Value is the value of the action to activate initially, or -1 if no -- action should be activated. -- Destroy is called when User_Data is no longer necessary. procedure Add_Toggle_Actions (Action_Group : access Gtk_Action_Group_Record; Entries : Toggle_Action_Entry_Array; User_Data : System.Address := System.Null_Address; Destroy : Glib.G_Destroy_Notify_Address := null); -- This is a convenience function to create a number of toggle actions and -- add them to the action group. -- The "activate" signals of the actions are connected to the callbacks and -- their accel paths are set to /group-name/action-name. -- Destroy is called when User_Data is no longer necessary. ---------------- -- Properties -- ---------------- -- The following properties are defined for this widget. See -- Glib.Properties for more information on properties) Accel_Group_Property : constant Glib.Properties.Property_Object; -- Type: Gtk.Accel_Group.Gtk_Accel_Group -- The accelerator group the actions of this group should use. Name_Property : constant Glib.Properties.Property_String; -- A name for the action. Sensitive_Property : constant Glib.Properties.Property_Boolean; -- Whether the action group is enabled. Visible_Property : constant Glib.Properties.Property_Boolean; -- Whether the action group is visible. ------------- -- Signals -- ------------- type Cb_Gtk_Action_Group_Gtk_Action_Gtk_Widget_Void is not null access procedure (Self : access Gtk_Action_Group_Record'Class; Action : not null access Gtk.Action.Gtk_Action_Record'Class; Proxy : not null access Gtk.Widget.Gtk_Widget_Record'Class); type Cb_GObject_Gtk_Action_Gtk_Widget_Void is not null access procedure (Self : access Glib.Object.GObject_Record'Class; Action : not null access Gtk.Action.Gtk_Action_Record'Class; Proxy : not null access Gtk.Widget.Gtk_Widget_Record'Class); Signal_Connect_Proxy : constant Glib.Signal_Name := "connect-proxy"; procedure On_Connect_Proxy (Self : not null access Gtk_Action_Group_Record; Call : Cb_Gtk_Action_Group_Gtk_Action_Gtk_Widget_Void; After : Boolean := False); procedure On_Connect_Proxy (Self : not null access Gtk_Action_Group_Record; Call : Cb_GObject_Gtk_Action_Gtk_Widget_Void; Slot : not null access Glib.Object.GObject_Record'Class; After : Boolean := False); -- The ::connect-proxy signal is emitted after connecting a proxy to an -- action in the group. Note that the proxy may have been connected to a -- different action before. -- -- This is intended for simple customizations for which a custom action -- class would be too clumsy, e.g. showing tooltips for menuitems in the -- statusbar. -- -- Gtk.UI_Manager.Gtk_UI_Manager proxies the signal and provides global -- notification just before any action is connected to a proxy, which is -- probably more convenient to use. -- -- Callback parameters: -- -- "action": the action -- -- "proxy": the proxy Signal_Disconnect_Proxy : constant Glib.Signal_Name := "disconnect-proxy"; procedure On_Disconnect_Proxy (Self : not null access Gtk_Action_Group_Record; Call : Cb_Gtk_Action_Group_Gtk_Action_Gtk_Widget_Void; After : Boolean := False); procedure On_Disconnect_Proxy (Self : not null access Gtk_Action_Group_Record; Call : Cb_GObject_Gtk_Action_Gtk_Widget_Void; Slot : not null access Glib.Object.GObject_Record'Class; After : Boolean := False); -- The ::disconnect-proxy signal is emitted after disconnecting a proxy -- from an action in the group. -- -- Gtk.UI_Manager.Gtk_UI_Manager proxies the signal and provides global -- notification just before any action is connected to a proxy, which is -- probably more convenient to use. -- -- Callback parameters: -- -- "action": the action -- -- "proxy": the proxy type Cb_Gtk_Action_Group_Gtk_Action_Void is not null access procedure (Self : access Gtk_Action_Group_Record'Class; Action : not null access Gtk.Action.Gtk_Action_Record'Class); type Cb_GObject_Gtk_Action_Void is not null access procedure (Self : access Glib.Object.GObject_Record'Class; Action : not null access Gtk.Action.Gtk_Action_Record'Class); Signal_Post_Activate : constant Glib.Signal_Name := "post-activate"; procedure On_Post_Activate (Self : not null access Gtk_Action_Group_Record; Call : Cb_Gtk_Action_Group_Gtk_Action_Void; After : Boolean := False); procedure On_Post_Activate (Self : not null access Gtk_Action_Group_Record; Call : Cb_GObject_Gtk_Action_Void; Slot : not null access Glib.Object.GObject_Record'Class; After : Boolean := False); -- The ::post-activate signal is emitted just after the Action in the -- Action_Group is activated -- -- This is intended for Gtk.UI_Manager.Gtk_UI_Manager to proxy the signal -- and provide global notification just after any action is activated. Signal_Pre_Activate : constant Glib.Signal_Name := "pre-activate"; procedure On_Pre_Activate (Self : not null access Gtk_Action_Group_Record; Call : Cb_Gtk_Action_Group_Gtk_Action_Void; After : Boolean := False); procedure On_Pre_Activate (Self : not null access Gtk_Action_Group_Record; Call : Cb_GObject_Gtk_Action_Void; Slot : not null access Glib.Object.GObject_Record'Class; After : Boolean := False); -- The ::pre-activate signal is emitted just before the Action in the -- Action_Group is activated -- -- This is intended for Gtk.UI_Manager.Gtk_UI_Manager to proxy the signal -- and provide global notification just before any action is activated. ---------------- -- Interfaces -- ---------------- -- This class implements several interfaces. See Glib.Types -- -- - "Buildable" package Implements_Gtk_Buildable is new Glib.Types.Implements (Gtk.Buildable.Gtk_Buildable, Gtk_Action_Group_Record, Gtk_Action_Group); function "+" (Widget : access Gtk_Action_Group_Record'Class) return Gtk.Buildable.Gtk_Buildable renames Implements_Gtk_Buildable.To_Interface; function "-" (Interf : Gtk.Buildable.Gtk_Buildable) return Gtk_Action_Group renames Implements_Gtk_Buildable.To_Object; private Visible_Property : constant Glib.Properties.Property_Boolean := Glib.Properties.Build ("visible"); Sensitive_Property : constant Glib.Properties.Property_Boolean := Glib.Properties.Build ("sensitive"); Name_Property : constant Glib.Properties.Property_String := Glib.Properties.Build ("name"); Accel_Group_Property : constant Glib.Properties.Property_Object := Glib.Properties.Build ("accel-group"); end Gtk.Action_Group; gtkada-24.0.0/src/generated/gtk-actionable.adb000066400000000000000000000111531446021174000211110ustar00rootroot00000000000000------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ pragma Style_Checks (Off); pragma Warnings (Off, "*is already use-visible*"); with Gtkada.Bindings; use Gtkada.Bindings; package body Gtk.Actionable is --------------------- -- Get_Action_Name -- --------------------- function Get_Action_Name (Self : Gtk_Actionable) return UTF8_String is function Internal (Self : Gtk_Actionable) return Gtkada.Types.Chars_Ptr; pragma Import (C, Internal, "gtk_actionable_get_action_name"); begin return Gtkada.Bindings.Value_Allowing_Null (Internal (Self)); end Get_Action_Name; ----------------------------- -- Get_Action_Target_Value -- ----------------------------- function Get_Action_Target_Value (Self : Gtk_Actionable) return Glib.Variant.Gvariant is function Internal (Self : Gtk_Actionable) return System.Address; pragma Import (C, Internal, "gtk_actionable_get_action_target_value"); begin return From_Object (Internal (Self)); end Get_Action_Target_Value; --------------------- -- Set_Action_Name -- --------------------- procedure Set_Action_Name (Self : Gtk_Actionable; Action_Name : UTF8_String := "") is procedure Internal (Self : Gtk_Actionable; Action_Name : Gtkada.Types.Chars_Ptr); pragma Import (C, Internal, "gtk_actionable_set_action_name"); Tmp_Action_Name : Gtkada.Types.Chars_Ptr; begin if Action_Name = "" then Tmp_Action_Name := Gtkada.Types.Null_Ptr; else Tmp_Action_Name := New_String (Action_Name); end if; Internal (Self, Tmp_Action_Name); Free (Tmp_Action_Name); end Set_Action_Name; ----------------------------- -- Set_Action_Target_Value -- ----------------------------- procedure Set_Action_Target_Value (Self : Gtk_Actionable; Target_Value : Glib.Variant.Gvariant) is procedure Internal (Self : Gtk_Actionable; Target_Value : System.Address); pragma Import (C, Internal, "gtk_actionable_set_action_target_value"); begin Internal (Self, Get_Object (Target_Value)); end Set_Action_Target_Value; ------------------------------ -- Set_Detailed_Action_Name -- ------------------------------ procedure Set_Detailed_Action_Name (Self : Gtk_Actionable; Detailed_Action_Name : UTF8_String) is procedure Internal (Self : Gtk_Actionable; Detailed_Action_Name : Gtkada.Types.Chars_Ptr); pragma Import (C, Internal, "gtk_actionable_set_detailed_action_name"); Tmp_Detailed_Action_Name : Gtkada.Types.Chars_Ptr := New_String (Detailed_Action_Name); begin Internal (Self, Tmp_Detailed_Action_Name); Free (Tmp_Detailed_Action_Name); end Set_Detailed_Action_Name; function "+" (W : Gtk_Actionable) return Gtk_Actionable is begin return W; end "+"; end Gtk.Actionable; gtkada-24.0.0/src/generated/gtk-actionable.ads000066400000000000000000000264251446021174000211420ustar00rootroot00000000000000------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ -- -- This interface provides a convenient way of associating widgets with -- actions on a Gtk.Application_Window.Gtk_Application_Window or -- Gtk.Application.Gtk_Application. -- -- It primarily consists of two properties: -- Gtk.Actionable.Gtk_Actionable:action-name and -- Gtk.Actionable.Gtk_Actionable:action-target. There are also some -- convenience APIs for setting these properties. -- -- The action will be looked up in action groups that are found among the -- widgets ancestors. Most commonly, these will be the actions with the "win." -- or "app." prefix that are associated with the -- Gtk.Application_Window.Gtk_Application_Window or -- Gtk.Application.Gtk_Application, but other action groups that are added -- with gtk_widget_insert_action_group will be consulted as well. -- -- pragma Warnings (Off, "*is already use-visible*"); with Glib; use Glib; with Glib.Object; use Glib.Object; with Glib.Properties; use Glib.Properties; with Glib.Types; use Glib.Types; with Glib.Variant; use Glib.Variant; pragma Warnings(Off); -- might be unused with Gtkada.Types; use Gtkada.Types; pragma Warnings(On); package Gtk.Actionable is type Gtk_Actionable is new Glib.Types.GType_Interface; Null_Gtk_Actionable : constant Gtk_Actionable; ------------------ -- Constructors -- ------------------ function Get_Type return Glib.GType; pragma Import (C, Get_Type, "gtk_actionable_get_type"); ------------- -- Methods -- ------------- function Get_Action_Name (Self : Gtk_Actionable) return UTF8_String; -- Gets the action name for Actionable. -- See Gtk.Actionable.Set_Action_Name for more information. -- Since: gtk+ 3.4 procedure Set_Action_Name (Self : Gtk_Actionable; Action_Name : UTF8_String := ""); -- Specifies the name of the action with which this widget should be -- associated. If Action_Name is null then the widget will be unassociated -- from any previous action. -- Usually this function is used when the widget is located (or will be -- located) within the hierarchy of a -- Gtk.Application_Window.Gtk_Application_Window. -- Names are of the form "win.save" or "app.quit" for actions on the -- containing Gtk.Application_Window.Gtk_Application_Window or its -- associated Gtk.Application.Gtk_Application, respectively. This is the -- same form used for actions in the Glib.Menu.Gmenu associated with the -- window. -- Since: gtk+ 3.4 -- "action_name": an action name, or null function Get_Action_Target_Value (Self : Gtk_Actionable) return Glib.Variant.Gvariant; -- Gets the current target value of Actionable. -- See Gtk.Actionable.Set_Action_Target_Value for more information. -- Since: gtk+ 3.4 procedure Set_Action_Target_Value (Self : Gtk_Actionable; Target_Value : Glib.Variant.Gvariant); -- Sets the target value of an actionable widget. -- If Target_Value is null then the target value is unset. -- The target value has two purposes. First, it is used as the parameter -- to activation of the action associated with the -- Gtk.Actionable.Gtk_Actionable widget. Second, it is used to determine if -- the widget should be rendered as "active" — the widget is active if the -- state is equal to the given target. -- Consider the example of associating a set of buttons with a -- Glib.Action.Gaction with string state in a typical "radio button" -- situation. Each button will be associated with the same action, but with -- a different target value for that action. Clicking on a particular -- button will activate the action with the target of that button, which -- will typically cause the action's state to change to that value. Since -- the action's state is now equal to the target value of the button, the -- button will now be rendered as active (and the other buttons, with -- different targets, rendered inactive). -- Since: gtk+ 3.4 -- "target_value": a Glib.Variant.Gvariant to set as the target value, or -- null procedure Set_Detailed_Action_Name (Self : Gtk_Actionable; Detailed_Action_Name : UTF8_String); -- Sets the action-name and associated string target value of an -- actionable widget. -- Detailed_Action_Name is a string in the format accepted by -- g_action_parse_detailed_name. -- (Note that prior to version 3.22.25, this function is only usable for -- actions with a simple "s" target, and Detailed_Action_Name must be of -- the form `"action::target"` where `action` is the action name and -- `target` is the string to use as the target.) -- Since: gtk+ 3.4 -- "detailed_action_name": the detailed action name ---------------- -- Properties -- ---------------- -- The following properties are defined for this widget. See -- Glib.Properties for more information on properties) Action_Name_Property : constant Glib.Properties.Property_String; Action_Target_Property : constant Glib.Properties.Property_Object; -- Type: Glib.Variant.Gvariant ---------------- -- Interfaces -- ---------------- -- This class implements several interfaces. See Glib.Types -- -- - "Gtk_Actionable" function "+" (W : Gtk_Actionable) return Gtk_Actionable; pragma Inline ("+"); --------------------- -- Virtual Methods -- --------------------- type Virtual_Get_Action_Name is access function (Self : Gtk_Actionable) return Gtkada.Types.Chars_Ptr; pragma Convention (C, Virtual_Get_Action_Name); -- Gets the action name for Actionable. -- See Gtk.Actionable.Set_Action_Name for more information. -- Since: gtk+ 3.4 type Virtual_Get_Action_Target_Value is access function (Self : Gtk_Actionable) return System.Address; pragma Convention (C, Virtual_Get_Action_Target_Value); -- Gets the current target value of Actionable. -- See Gtk.Actionable.Set_Action_Target_Value for more information. -- Since: gtk+ 3.4 type Virtual_Set_Action_Name is access procedure (Self : Gtk_Actionable; Action_Name : Gtkada.Types.Chars_Ptr); pragma Convention (C, Virtual_Set_Action_Name); -- Specifies the name of the action with which this widget should be -- associated. If Action_Name is null then the widget will be unassociated -- from any previous action. -- Usually this function is used when the widget is located (or will be -- located) within the hierarchy of a -- Gtk.Application_Window.Gtk_Application_Window. -- Names are of the form "win.save" or "app.quit" for actions on the -- containing Gtk.Application_Window.Gtk_Application_Window or its -- associated Gtk.Application.Gtk_Application, respectively. This is the -- same form used for actions in the Glib.Menu.Gmenu associated with the -- window. -- Since: gtk+ 3.4 -- "action_name": an action name, or null type Virtual_Set_Action_Target_Value is access procedure (Self : Gtk_Actionable; Target_Value : System.Address); pragma Convention (C, Virtual_Set_Action_Target_Value); -- Sets the target value of an actionable widget. -- If Target_Value is null then the target value is unset. -- The target value has two purposes. First, it is used as the parameter -- to activation of the action associated with the -- Gtk.Actionable.Gtk_Actionable widget. Second, it is used to determine if -- the widget should be rendered as "active" — the widget is active if the -- state is equal to the given target. -- Consider the example of associating a set of buttons with a -- Glib.Action.Gaction with string state in a typical "radio button" -- situation. Each button will be associated with the same action, but with -- a different target value for that action. Clicking on a particular -- button will activate the action with the target of that button, which -- will typically cause the action's state to change to that value. Since -- the action's state is now equal to the target value of the button, the -- button will now be rendered as active (and the other buttons, with -- different targets, rendered inactive). -- Since: gtk+ 3.4 -- "target_value": a Glib.Variant.Gvariant to set as the target value, or -- null subtype Actionable_Interface_Descr is Glib.Object.Interface_Description; procedure Set_Get_Action_Name (Self : Actionable_Interface_Descr; Handler : Virtual_Get_Action_Name); pragma Import (C, Set_Get_Action_Name, "gtkada_Actionable_set_get_action_name"); procedure Set_Get_Action_Target_Value (Self : Actionable_Interface_Descr; Handler : Virtual_Get_Action_Target_Value); pragma Import (C, Set_Get_Action_Target_Value, "gtkada_Actionable_set_get_action_target_value"); procedure Set_Set_Action_Name (Self : Actionable_Interface_Descr; Handler : Virtual_Set_Action_Name); pragma Import (C, Set_Set_Action_Name, "gtkada_Actionable_set_set_action_name"); procedure Set_Set_Action_Target_Value (Self : Actionable_Interface_Descr; Handler : Virtual_Set_Action_Target_Value); pragma Import (C, Set_Set_Action_Target_Value, "gtkada_Actionable_set_set_action_target_value"); -- See Glib.Object.Add_Interface private Action_Target_Property : constant Glib.Properties.Property_Object := Glib.Properties.Build ("action-target"); Action_Name_Property : constant Glib.Properties.Property_String := Glib.Properties.Build ("action-name"); Null_Gtk_Actionable : constant Gtk_Actionable := Gtk_Actionable (Glib.Types.Null_Interface); end Gtk.Actionable; gtkada-24.0.0/src/generated/gtk-activatable.adb000066400000000000000000000113401446021174000212650ustar00rootroot00000000000000------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ pragma Style_Checks (Off); pragma Warnings (Off, "*is already use-visible*"); package body Gtk.Activatable is --------------------------- -- Do_Set_Related_Action -- --------------------------- procedure Do_Set_Related_Action (Self : Gtk_Activatable; Action : not null access Gtk.Action.Gtk_Action_Record'Class) is procedure Internal (Self : Gtk_Activatable; Action : System.Address); pragma Import (C, Internal, "gtk_activatable_do_set_related_action"); begin Internal (Self, Get_Object (Action)); end Do_Set_Related_Action; ------------------------ -- Get_Related_Action -- ------------------------ function Get_Related_Action (Self : Gtk_Activatable) return Gtk.Action.Gtk_Action is function Internal (Self : Gtk_Activatable) return System.Address; pragma Import (C, Internal, "gtk_activatable_get_related_action"); Stub_Gtk_Action : Gtk.Action.Gtk_Action_Record; begin return Gtk.Action.Gtk_Action (Get_User_Data (Internal (Self), Stub_Gtk_Action)); end Get_Related_Action; ------------------------------- -- Get_Use_Action_Appearance -- ------------------------------- function Get_Use_Action_Appearance (Self : Gtk_Activatable) return Boolean is function Internal (Self : Gtk_Activatable) return Glib.Gboolean; pragma Import (C, Internal, "gtk_activatable_get_use_action_appearance"); begin return Internal (Self) /= 0; end Get_Use_Action_Appearance; ------------------------ -- Set_Related_Action -- ------------------------ procedure Set_Related_Action (Self : Gtk_Activatable; Action : not null access Gtk.Action.Gtk_Action_Record'Class) is procedure Internal (Self : Gtk_Activatable; Action : System.Address); pragma Import (C, Internal, "gtk_activatable_set_related_action"); begin Internal (Self, Get_Object (Action)); end Set_Related_Action; ------------------------------- -- Set_Use_Action_Appearance -- ------------------------------- procedure Set_Use_Action_Appearance (Self : Gtk_Activatable; Use_Appearance : Boolean) is procedure Internal (Self : Gtk_Activatable; Use_Appearance : Glib.Gboolean); pragma Import (C, Internal, "gtk_activatable_set_use_action_appearance"); begin Internal (Self, Boolean'Pos (Use_Appearance)); end Set_Use_Action_Appearance; ---------------------------- -- Sync_Action_Properties -- ---------------------------- procedure Sync_Action_Properties (Self : Gtk_Activatable; Action : access Gtk.Action.Gtk_Action_Record'Class) is procedure Internal (Self : Gtk_Activatable; Action : System.Address); pragma Import (C, Internal, "gtk_activatable_sync_action_properties"); begin Internal (Self, Get_Object_Or_Null (GObject (Action))); end Sync_Action_Properties; function "+" (W : Gtk_Activatable) return Gtk_Activatable is begin return W; end "+"; end Gtk.Activatable; gtkada-24.0.0/src/generated/gtk-activatable.ads000066400000000000000000000334311446021174000213130ustar00rootroot00000000000000------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ -- -- Activatable widgets can be connected to a Gtk.Action.Gtk_Action and -- reflects the state of its action. A Gtk.Activatable.Gtk_Activatable can -- also provide feedback through its action, as they are responsible for -- activating their related actions. -- -- # Implementing GtkActivatable -- -- When extending a class that is already Gtk.Activatable.Gtk_Activatable; it -- is only necessary to implement the -- Gtk.Activatable.Gtk_Activatable->sync_action_properties and -- Gtk.Activatable.Gtk_Activatable->update methods and chain up to the parent -- implementation, however when introducing a new -- Gtk.Activatable.Gtk_Activatable class; the -- Gtk.Activatable.Gtk_Activatable:related-action and -- Gtk.Activatable.Gtk_Activatable:use-action-appearance properties need to be -- handled by the implementor. Handling these properties is mostly a matter of -- installing the action pointer and boolean flag on your instance, and -- calling Gtk.Activatable.Do_Set_Related_Action and -- Gtk.Activatable.Sync_Action_Properties at the appropriate times. -- -- ## A class fragment implementing Gtk.Activatable.Gtk_Activatable -- -- |[ -- -- enum { ... -- -- PROP_ACTIVATABLE_RELATED_ACTION, PROP_ACTIVATABLE_USE_ACTION_APPEARANCE } -- -- struct _FooBarPrivate { -- -- ... -- -- GtkAction *action; gboolean use_action_appearance; }; -- -- ... -- -- static void foo_bar_activatable_interface_init (GtkActivatableIface -- *iface); static void foo_bar_activatable_update (GtkActivatable -- *activatable, GtkAction *action, const gchar *property_name); static void -- foo_bar_activatable_sync_action_properties (GtkActivatable *activatable, -- GtkAction *action); ... -- -- static void foo_bar_class_init (FooBarClass *klass) { -- -- ... -- -- g_object_class_override_property (gobject_class, -- PROP_ACTIVATABLE_RELATED_ACTION, "related-action"); -- g_object_class_override_property (gobject_class, -- PROP_ACTIVATABLE_USE_ACTION_APPEARANCE, "use-action-appearance"); -- -- ... } -- -- static void foo_bar_activatable_interface_init (GtkActivatableIface -- *iface) { iface->update = foo_bar_activatable_update; -- iface->sync_action_properties = foo_bar_activatable_sync_action_properties; -- } -- -- ... Break the reference using Gtk.Activatable.Do_Set_Related_Action... -- -- static void foo_bar_dispose (GObject *object) { FooBar *bar = FOO_BAR -- (object); FooBarPrivate *priv = FOO_BAR_GET_PRIVATE (bar); -- -- ... -- -- if (priv->action) { gtk_activatable_do_set_related_action (GTK_ACTIVATABLE -- (bar), NULL); priv->action = NULL; } G_OBJECT_CLASS -- (foo_bar_parent_class)->dispose (object); } -- -- ... Handle the "related-action" and "use-action-appearance" properties ... -- -- static void foo_bar_set_property (GObject *object, guint prop_id, const -- GValue *value, GParamSpec *pspec) { FooBar *bar = FOO_BAR (object); -- FooBarPrivate *priv = FOO_BAR_GET_PRIVATE (bar); -- -- switch (prop_id) { -- -- ... -- -- case PROP_ACTIVATABLE_RELATED_ACTION: foo_bar_set_related_action (bar, -- g_value_get_object (value)); break; case -- PROP_ACTIVATABLE_USE_ACTION_APPEARANCE: foo_bar_set_use_action_appearance -- (bar, g_value_get_boolean (value)); break; default: -- G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } } -- -- static void foo_bar_get_property (GObject *object, guint prop_id, GValue -- *value, GParamSpec *pspec) { FooBar *bar = FOO_BAR (object); FooBarPrivate -- *priv = FOO_BAR_GET_PRIVATE (bar); -- -- switch (prop_id) { -- -- ... -- -- case PROP_ACTIVATABLE_RELATED_ACTION: g_value_set_object (value, -- priv->action); break; case PROP_ACTIVATABLE_USE_ACTION_APPEARANCE: -- g_value_set_boolean (value, priv->use_action_appearance); break; default: -- G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } } -- -- static void foo_bar_set_use_action_appearance (FooBar *bar, gboolean -- use_appearance) { FooBarPrivate *priv = FOO_BAR_GET_PRIVATE (bar); -- -- if (priv->use_action_appearance != use_appearance) { -- priv->use_action_appearance = use_appearance; -- gtk_activatable_sync_action_properties (GTK_ACTIVATABLE (bar), -- priv->action); } } -- -- ... call Gtk.Activatable.Do_Set_Related_Action and then assign the action -- pointer, no need to reference the action here since -- Gtk.Activatable.Do_Set_Related_Action already holds a reference here for -- you... static void foo_bar_set_related_action (FooBar *bar, GtkAction -- *action) { FooBarPrivate *priv = FOO_BAR_GET_PRIVATE (bar); -- -- if (priv->action == action) return; -- -- gtk_activatable_do_set_related_action (GTK_ACTIVATABLE (bar), action); -- -- priv->action = action; } -- -- ... Selectively reset and update activatable depending on the -- use-action-appearance property ... static void -- gtk_button_activatable_sync_action_properties (GtkActivatable *activatable, -- GtkAction *action) { GtkButtonPrivate *priv = GTK_BUTTON_GET_PRIVATE -- (activatable); -- -- if (!action) return; -- -- if (gtk_action_is_visible (action)) gtk_widget_show (GTK_WIDGET -- (activatable)); else gtk_widget_hide (GTK_WIDGET (activatable)); -- gtk_widget_set_sensitive (GTK_WIDGET (activatable), gtk_action_is_sensitive -- (action)); -- -- ... if (priv->use_action_appearance) { if (gtk_action_get_stock_id -- (action)) foo_bar_set_stock (button, gtk_action_get_stock_id (action)); -- else if (gtk_action_get_label (action)) foo_bar_set_label (button, -- gtk_action_get_label (action)); -- -- ... -- -- } } -- -- static void foo_bar_activatable_update (GtkActivatable *activatable, -- GtkAction *action, const gchar *property_name) { FooBarPrivate *priv = -- FOO_BAR_GET_PRIVATE (activatable); -- -- if (strcmp (property_name, "visible") == 0) { if (gtk_action_is_visible -- (action)) gtk_widget_show (GTK_WIDGET (activatable)); else gtk_widget_hide -- (GTK_WIDGET (activatable)); } else if (strcmp (property_name, "sensitive") -- == 0) gtk_widget_set_sensitive (GTK_WIDGET (activatable), -- gtk_action_is_sensitive (action)); -- -- ... -- -- if (!priv->use_action_appearance) return; -- -- if (strcmp (property_name, "stock-id") == 0) foo_bar_set_stock (button, -- gtk_action_get_stock_id (action)); else if (strcmp (property_name, "label") -- == 0) foo_bar_set_label (button, gtk_action_get_label (action)); -- -- ... } ]| -- -- pragma Warnings (Off, "*is already use-visible*"); with Glib; use Glib; with Glib.Properties; use Glib.Properties; with Glib.Types; use Glib.Types; with Gtk.Action; use Gtk.Action; package Gtk.Activatable is type Gtk_Activatable is new Glib.Types.GType_Interface; Null_Gtk_Activatable : constant Gtk_Activatable; ------------------ -- Constructors -- ------------------ function Get_Type return Glib.GType; pragma Import (C, Get_Type, "gtk_activatable_get_type"); ------------- -- Methods -- ------------- procedure Do_Set_Related_Action (Self : Gtk_Activatable; Action : not null access Gtk.Action.Gtk_Action_Record'Class); pragma Obsolescent (Do_Set_Related_Action); -- This is a utility function for Gtk.Activatable.Gtk_Activatable -- implementors. -- When implementing Gtk.Activatable.Gtk_Activatable you must call this -- when handling changes of the -- Gtk.Activatable.Gtk_Activatable:related-action, and you must also use -- this to break references in Glib.Object.GObject->dispose. -- This function adds a reference to the currently set related action for -- you, it also makes sure the Gtk.Activatable.Gtk_Activatable->update -- method is called when the related Gtk.Action.Gtk_Action properties -- change and registers to the action's proxy list. -- > Be careful to call this before setting the local > copy of the -- Gtk.Action.Gtk_Action property, since this function uses > -- Gtk.Activatable.Get_Related_Action to retrieve the > previous action. -- Since: gtk+ 2.16 -- Deprecated since 3.10, 1 -- "action": the Gtk.Action.Gtk_Action to set function Get_Related_Action (Self : Gtk_Activatable) return Gtk.Action.Gtk_Action; pragma Obsolescent (Get_Related_Action); -- Gets the related Gtk.Action.Gtk_Action for Activatable. -- Since: gtk+ 2.16 -- Deprecated since 3.10, 1 procedure Set_Related_Action (Self : Gtk_Activatable; Action : not null access Gtk.Action.Gtk_Action_Record'Class); pragma Obsolescent (Set_Related_Action); -- Sets the related action on the Activatable object. -- > Gtk.Activatable.Gtk_Activatable implementors need to handle the -- Gtk.Activatable.Gtk_Activatable:related-action > property and call -- Gtk.Activatable.Do_Set_Related_Action when it changes. -- Since: gtk+ 2.16 -- Deprecated since 3.10, 1 -- "action": the Gtk.Action.Gtk_Action to set function Get_Use_Action_Appearance (Self : Gtk_Activatable) return Boolean; pragma Obsolescent (Get_Use_Action_Appearance); -- Gets whether this activatable should reset its layout and appearance -- when setting the related action or when the action changes appearance. -- Since: gtk+ 2.16 -- Deprecated since 3.10, 1 procedure Set_Use_Action_Appearance (Self : Gtk_Activatable; Use_Appearance : Boolean); pragma Obsolescent (Set_Use_Action_Appearance); -- Sets whether this activatable should reset its layout and appearance -- when setting the related action or when the action changes appearance -- > Gtk.Activatable.Gtk_Activatable implementors need to handle the > -- Gtk.Activatable.Gtk_Activatable:use-action-appearance property and call -- > Gtk.Activatable.Sync_Action_Properties to update Activatable > if -- needed. -- Since: gtk+ 2.16 -- Deprecated since 3.10, 1 -- "use_appearance": whether to use the actions appearance procedure Sync_Action_Properties (Self : Gtk_Activatable; Action : access Gtk.Action.Gtk_Action_Record'Class); pragma Obsolescent (Sync_Action_Properties); -- This is called to update the activatable completely, this is called -- internally when the Gtk.Activatable.Gtk_Activatable:related-action -- property is set or unset and by the implementing class when -- Gtk.Activatable.Gtk_Activatable:use-action-appearance changes. -- Since: gtk+ 2.16 -- Deprecated since 3.10, 1 -- "action": the related Gtk.Action.Gtk_Action or null ---------------- -- Properties -- ---------------- -- The following properties are defined for this widget. See -- Glib.Properties for more information on properties) Related_Action_Property : constant Glib.Properties.Property_Object; -- Type: Gtk.Action.Gtk_Action -- The action that this activatable will activate and receive updates from -- for various states and possibly appearance. -- -- > Gtk.Activatable.Gtk_Activatable implementors need to handle the this -- property and > call Gtk.Activatable.Do_Set_Related_Action when it -- changes. Use_Action_Appearance_Property : constant Glib.Properties.Property_Boolean; -- Whether this activatable should reset its layout and appearance when -- setting the related action or when the action changes appearance. -- -- See the Gtk.Action.Gtk_Action documentation directly to find which -- properties should be ignored by the Gtk.Activatable.Gtk_Activatable when -- this property is False. -- -- > Gtk.Activatable.Gtk_Activatable implementors need to handle this -- property > and call Gtk.Activatable.Sync_Action_Properties on the -- activatable > widget when it changes. ---------------- -- Interfaces -- ---------------- -- This class implements several interfaces. See Glib.Types -- -- - "Gtk_Activatable" function "+" (W : Gtk_Activatable) return Gtk_Activatable; pragma Inline ("+"); private Use_Action_Appearance_Property : constant Glib.Properties.Property_Boolean := Glib.Properties.Build ("use-action-appearance"); Related_Action_Property : constant Glib.Properties.Property_Object := Glib.Properties.Build ("related-action"); Null_Gtk_Activatable : constant Gtk_Activatable := Gtk_Activatable (Glib.Types.Null_Interface); end Gtk.Activatable; gtkada-24.0.0/src/generated/gtk-adjustment.adb000066400000000000000000000415441446021174000211750ustar00rootroot00000000000000------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ pragma Style_Checks (Off); pragma Warnings (Off, "*is already use-visible*"); with Ada.Unchecked_Conversion; with Glib.Type_Conversion_Hooks; use Glib.Type_Conversion_Hooks; with Glib.Values; use Glib.Values; with Gtk.Arguments; use Gtk.Arguments; with Gtkada.Bindings; use Gtkada.Bindings; package body Gtk.Adjustment is package Type_Conversion_Gtk_Adjustment is new Glib.Type_Conversion_Hooks.Hook_Registrator (Get_Type'Access, Gtk_Adjustment_Record); pragma Unreferenced (Type_Conversion_Gtk_Adjustment); ------------------------ -- Gtk_Adjustment_New -- ------------------------ function Gtk_Adjustment_New (Value : Gdouble; Lower : Gdouble; Upper : Gdouble; Step_Increment : Gdouble; Page_Increment : Gdouble; Page_Size : Gdouble := 0.0) return Gtk_Adjustment is Adjustment : constant Gtk_Adjustment := new Gtk_Adjustment_Record; begin Gtk.Adjustment.Initialize (Adjustment, Value, Lower, Upper, Step_Increment, Page_Increment, Page_Size); return Adjustment; end Gtk_Adjustment_New; ------------- -- Gtk_New -- ------------- procedure Gtk_New (Adjustment : out Gtk_Adjustment; Value : Gdouble; Lower : Gdouble; Upper : Gdouble; Step_Increment : Gdouble; Page_Increment : Gdouble; Page_Size : Gdouble := 0.0) is begin Adjustment := new Gtk_Adjustment_Record; Gtk.Adjustment.Initialize (Adjustment, Value, Lower, Upper, Step_Increment, Page_Increment, Page_Size); end Gtk_New; ---------------- -- Initialize -- ---------------- procedure Initialize (Adjustment : not null access Gtk_Adjustment_Record'Class; Value : Gdouble; Lower : Gdouble; Upper : Gdouble; Step_Increment : Gdouble; Page_Increment : Gdouble; Page_Size : Gdouble := 0.0) is function Internal (Value : Gdouble; Lower : Gdouble; Upper : Gdouble; Step_Increment : Gdouble; Page_Increment : Gdouble; Page_Size : Gdouble) return System.Address; pragma Import (C, Internal, "gtk_adjustment_new"); begin if not Adjustment.Is_Created then Set_Object (Adjustment, Internal (Value, Lower, Upper, Step_Increment, Page_Increment, Page_Size)); end if; end Initialize; ------------- -- Changed -- ------------- procedure Changed (Adjustment : not null access Gtk_Adjustment_Record) is procedure Internal (Adjustment : System.Address); pragma Import (C, Internal, "gtk_adjustment_changed"); begin Internal (Get_Object (Adjustment)); end Changed; ---------------- -- Clamp_Page -- ---------------- procedure Clamp_Page (Adjustment : not null access Gtk_Adjustment_Record; Lower : Gdouble; Upper : Gdouble) is procedure Internal (Adjustment : System.Address; Lower : Gdouble; Upper : Gdouble); pragma Import (C, Internal, "gtk_adjustment_clamp_page"); begin Internal (Get_Object (Adjustment), Lower, Upper); end Clamp_Page; --------------- -- Configure -- --------------- procedure Configure (Adjustment : not null access Gtk_Adjustment_Record; Value : Gdouble; Lower : Gdouble; Upper : Gdouble; Step_Increment : Gdouble; Page_Increment : Gdouble; Page_Size : Gdouble) is procedure Internal (Adjustment : System.Address; Value : Gdouble; Lower : Gdouble; Upper : Gdouble; Step_Increment : Gdouble; Page_Increment : Gdouble; Page_Size : Gdouble); pragma Import (C, Internal, "gtk_adjustment_configure"); begin Internal (Get_Object (Adjustment), Value, Lower, Upper, Step_Increment, Page_Increment, Page_Size); end Configure; --------------- -- Get_Lower -- --------------- function Get_Lower (Adjustment : not null access Gtk_Adjustment_Record) return Gdouble is function Internal (Adjustment : System.Address) return Gdouble; pragma Import (C, Internal, "gtk_adjustment_get_lower"); begin return Internal (Get_Object (Adjustment)); end Get_Lower; --------------------------- -- Get_Minimum_Increment -- --------------------------- function Get_Minimum_Increment (Adjustment : not null access Gtk_Adjustment_Record) return Gdouble is function Internal (Adjustment : System.Address) return Gdouble; pragma Import (C, Internal, "gtk_adjustment_get_minimum_increment"); begin return Internal (Get_Object (Adjustment)); end Get_Minimum_Increment; ------------------------ -- Get_Page_Increment -- ------------------------ function Get_Page_Increment (Adjustment : not null access Gtk_Adjustment_Record) return Gdouble is function Internal (Adjustment : System.Address) return Gdouble; pragma Import (C, Internal, "gtk_adjustment_get_page_increment"); begin return Internal (Get_Object (Adjustment)); end Get_Page_Increment; ------------------- -- Get_Page_Size -- ------------------- function Get_Page_Size (Adjustment : not null access Gtk_Adjustment_Record) return Gdouble is function Internal (Adjustment : System.Address) return Gdouble; pragma Import (C, Internal, "gtk_adjustment_get_page_size"); begin return Internal (Get_Object (Adjustment)); end Get_Page_Size; ------------------------ -- Get_Step_Increment -- ------------------------ function Get_Step_Increment (Adjustment : not null access Gtk_Adjustment_Record) return Gdouble is function Internal (Adjustment : System.Address) return Gdouble; pragma Import (C, Internal, "gtk_adjustment_get_step_increment"); begin return Internal (Get_Object (Adjustment)); end Get_Step_Increment; --------------- -- Get_Upper -- --------------- function Get_Upper (Adjustment : not null access Gtk_Adjustment_Record) return Gdouble is function Internal (Adjustment : System.Address) return Gdouble; pragma Import (C, Internal, "gtk_adjustment_get_upper"); begin return Internal (Get_Object (Adjustment)); end Get_Upper; --------------- -- Get_Value -- --------------- function Get_Value (Adjustment : not null access Gtk_Adjustment_Record) return Gdouble is function Internal (Adjustment : System.Address) return Gdouble; pragma Import (C, Internal, "gtk_adjustment_get_value"); begin return Internal (Get_Object (Adjustment)); end Get_Value; --------------- -- Set_Lower -- --------------- procedure Set_Lower (Adjustment : not null access Gtk_Adjustment_Record; Lower : Gdouble) is procedure Internal (Adjustment : System.Address; Lower : Gdouble); pragma Import (C, Internal, "gtk_adjustment_set_lower"); begin Internal (Get_Object (Adjustment), Lower); end Set_Lower; ------------------------ -- Set_Page_Increment -- ------------------------ procedure Set_Page_Increment (Adjustment : not null access Gtk_Adjustment_Record; Page_Increment : Gdouble) is procedure Internal (Adjustment : System.Address; Page_Increment : Gdouble); pragma Import (C, Internal, "gtk_adjustment_set_page_increment"); begin Internal (Get_Object (Adjustment), Page_Increment); end Set_Page_Increment; ------------------- -- Set_Page_Size -- ------------------- procedure Set_Page_Size (Adjustment : not null access Gtk_Adjustment_Record; Page_Size : Gdouble) is procedure Internal (Adjustment : System.Address; Page_Size : Gdouble); pragma Import (C, Internal, "gtk_adjustment_set_page_size"); begin Internal (Get_Object (Adjustment), Page_Size); end Set_Page_Size; ------------------------ -- Set_Step_Increment -- ------------------------ procedure Set_Step_Increment (Adjustment : not null access Gtk_Adjustment_Record; Step_Increment : Gdouble) is procedure Internal (Adjustment : System.Address; Step_Increment : Gdouble); pragma Import (C, Internal, "gtk_adjustment_set_step_increment"); begin Internal (Get_Object (Adjustment), Step_Increment); end Set_Step_Increment; --------------- -- Set_Upper -- --------------- procedure Set_Upper (Adjustment : not null access Gtk_Adjustment_Record; Upper : Gdouble) is procedure Internal (Adjustment : System.Address; Upper : Gdouble); pragma Import (C, Internal, "gtk_adjustment_set_upper"); begin Internal (Get_Object (Adjustment), Upper); end Set_Upper; --------------- -- Set_Value -- --------------- procedure Set_Value (Adjustment : not null access Gtk_Adjustment_Record; Value : Gdouble) is procedure Internal (Adjustment : System.Address; Value : Gdouble); pragma Import (C, Internal, "gtk_adjustment_set_value"); begin Internal (Get_Object (Adjustment), Value); end Set_Value; ------------------- -- Value_Changed -- ------------------- procedure Value_Changed (Adjustment : not null access Gtk_Adjustment_Record) is procedure Internal (Adjustment : System.Address); pragma Import (C, Internal, "gtk_adjustment_value_changed"); begin Internal (Get_Object (Adjustment)); end Value_Changed; use type System.Address; function Cb_To_Address is new Ada.Unchecked_Conversion (Cb_Gtk_Adjustment_Void, System.Address); function Address_To_Cb is new Ada.Unchecked_Conversion (System.Address, Cb_Gtk_Adjustment_Void); function Cb_To_Address is new Ada.Unchecked_Conversion (Cb_GObject_Void, System.Address); function Address_To_Cb is new Ada.Unchecked_Conversion (System.Address, Cb_GObject_Void); procedure Connect (Object : access Gtk_Adjustment_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_Gtk_Adjustment_Void; After : Boolean); procedure Connect_Slot (Object : access Gtk_Adjustment_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_GObject_Void; After : Boolean; Slot : access Glib.Object.GObject_Record'Class := null); procedure Marsh_GObject_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address); pragma Convention (C, Marsh_GObject_Void); procedure Marsh_Gtk_Adjustment_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address); pragma Convention (C, Marsh_Gtk_Adjustment_Void); ------------- -- Connect -- ------------- procedure Connect (Object : access Gtk_Adjustment_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_Gtk_Adjustment_Void; After : Boolean) is begin Unchecked_Do_Signal_Connect (Object => Object, C_Name => C_Name, Marshaller => Marsh_Gtk_Adjustment_Void'Access, Handler => Cb_To_Address (Handler),-- Set in the closure After => After); end Connect; ------------------ -- Connect_Slot -- ------------------ procedure Connect_Slot (Object : access Gtk_Adjustment_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_GObject_Void; After : Boolean; Slot : access Glib.Object.GObject_Record'Class := null) is begin Unchecked_Do_Signal_Connect (Object => Object, C_Name => C_Name, Marshaller => Marsh_GObject_Void'Access, Handler => Cb_To_Address (Handler),-- Set in the closure Slot_Object => Slot, After => After); end Connect_Slot; ------------------------ -- Marsh_GObject_Void -- ------------------------ procedure Marsh_GObject_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address) is pragma Unreferenced (Return_Value, N_Params, Params, Invocation_Hint, User_Data); H : constant Cb_GObject_Void := Address_To_Cb (Get_Callback (Closure)); Obj : constant Glib.Object.GObject := Glib.Object.Convert (Get_Data (Closure)); begin H (Obj); exception when E : others => Process_Exception (E); end Marsh_GObject_Void; ------------------------------- -- Marsh_Gtk_Adjustment_Void -- ------------------------------- procedure Marsh_Gtk_Adjustment_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address) is pragma Unreferenced (Return_Value, N_Params, Invocation_Hint, User_Data); H : constant Cb_Gtk_Adjustment_Void := Address_To_Cb (Get_Callback (Closure)); Obj : constant Gtk_Adjustment := Gtk_Adjustment (Unchecked_To_Object (Params, 0)); begin H (Obj); exception when E : others => Process_Exception (E); end Marsh_Gtk_Adjustment_Void; ---------------- -- On_Changed -- ---------------- procedure On_Changed (Self : not null access Gtk_Adjustment_Record; Call : Cb_Gtk_Adjustment_Void; After : Boolean := False) is begin Connect (Self, "changed" & ASCII.NUL, Call, After); end On_Changed; ---------------- -- On_Changed -- ---------------- procedure On_Changed (Self : not null access Gtk_Adjustment_Record; Call : Cb_GObject_Void; Slot : not null access Glib.Object.GObject_Record'Class; After : Boolean := False) is begin Connect_Slot (Self, "changed" & ASCII.NUL, Call, After, Slot); end On_Changed; ---------------------- -- On_Value_Changed -- ---------------------- procedure On_Value_Changed (Self : not null access Gtk_Adjustment_Record; Call : Cb_Gtk_Adjustment_Void; After : Boolean := False) is begin Connect (Self, "value-changed" & ASCII.NUL, Call, After); end On_Value_Changed; ---------------------- -- On_Value_Changed -- ---------------------- procedure On_Value_Changed (Self : not null access Gtk_Adjustment_Record; Call : Cb_GObject_Void; Slot : not null access Glib.Object.GObject_Record'Class; After : Boolean := False) is begin Connect_Slot (Self, "value-changed" & ASCII.NUL, Call, After, Slot); end On_Value_Changed; end Gtk.Adjustment; gtkada-24.0.0/src/generated/gtk-adjustment.ads000066400000000000000000000370251446021174000212150ustar00rootroot00000000000000------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ -- -- The Gtk.Adjustment.Gtk_Adjustment object represents a value which has an -- associated lower and upper bound, together with step and page increments, -- and a page size. It is used within several GTK+ widgets, including -- Gtk.Spin_Button.Gtk_Spin_Button, Gtk.Viewport.Gtk_Viewport, and -- Gtk.GRange.Gtk_Range (which is a base class for Gtk.Scrollbar.Gtk_Scrollbar -- and Gtk.Scale.Gtk_Scale). -- -- The Gtk.Adjustment.Gtk_Adjustment object does not update the value itself. -- Instead it is left up to the owner of the Gtk.Adjustment.Gtk_Adjustment to -- control the value. -- -- -- -- The meaning of the most important fields can be explained on the following -- figure (imagine this is a scrollbar): -- -- [-------|=================|-------------------] -- -- lower value value + page_size upper -- -- -- Scrolling pragma Warnings (Off, "*is already use-visible*"); with Glib; use Glib; with Glib.Object; use Glib.Object; with Glib.Properties; use Glib.Properties; package Gtk.Adjustment is type Gtk_Adjustment_Record is new GObject_Record with null record; type Gtk_Adjustment is access all Gtk_Adjustment_Record'Class; ------------------ -- Constructors -- ------------------ procedure Gtk_New (Adjustment : out Gtk_Adjustment; Value : Gdouble; Lower : Gdouble; Upper : Gdouble; Step_Increment : Gdouble; Page_Increment : Gdouble; Page_Size : Gdouble := 0.0); procedure Initialize (Adjustment : not null access Gtk_Adjustment_Record'Class; Value : Gdouble; Lower : Gdouble; Upper : Gdouble; Step_Increment : Gdouble; Page_Increment : Gdouble; Page_Size : Gdouble := 0.0); -- Create a new adjustment. Value is the initial value of the adjustment. -- It must be in the range (Lower .. Upper) and the adjustment's value will -- never be outside this range. Step_Increment is the value used to make -- minor adjustments, such as when the user clicks on the arrows of a -- scrollbar. Page_Increment is used to make major adjustments, such as -- when the user clicks in the through on a scrollbar. Page_Size is -- deprecated, use the default value. -- Initialize does nothing if the object was already created with another -- call to Initialize* or G_New. -- "value": the initial value -- "lower": the minimum value -- "upper": the maximum value -- "step_increment": the step increment -- "page_increment": the page increment -- "page_size": the page size function Gtk_Adjustment_New (Value : Gdouble; Lower : Gdouble; Upper : Gdouble; Step_Increment : Gdouble; Page_Increment : Gdouble; Page_Size : Gdouble := 0.0) return Gtk_Adjustment; -- Create a new adjustment. Value is the initial value of the adjustment. -- It must be in the range (Lower .. Upper) and the adjustment's value will -- never be outside this range. Step_Increment is the value used to make -- minor adjustments, such as when the user clicks on the arrows of a -- scrollbar. Page_Increment is used to make major adjustments, such as -- when the user clicks in the through on a scrollbar. Page_Size is -- deprecated, use the default value. -- "value": the initial value -- "lower": the minimum value -- "upper": the maximum value -- "step_increment": the step increment -- "page_increment": the page increment -- "page_size": the page size function Get_Type return Glib.GType; pragma Import (C, Get_Type, "gtk_adjustment_get_type"); ------------- -- Methods -- ------------- procedure Changed (Adjustment : not null access Gtk_Adjustment_Record); pragma Obsolescent (Changed); -- Emits a Gtk.Adjustment.Gtk_Adjustment::changed signal from the -- Gtk.Adjustment.Gtk_Adjustment. This is typically called by the owner of -- the Gtk.Adjustment.Gtk_Adjustment after it has changed any of the -- Gtk.Adjustment.Gtk_Adjustment properties other than the value. -- Deprecated since 3.18, 1 procedure Clamp_Page (Adjustment : not null access Gtk_Adjustment_Record; Lower : Gdouble; Upper : Gdouble); -- Update the Adjustment value to ensure that the range between Lower and -- Upper is in the current page (i.e. between value and value + page_size). -- If the range is larger than the page size, then only the start of it -- will be in the current page. A "value_changed" signal will be emitted if -- the value is changed. -- "lower": the lower value -- "upper": the upper value procedure Configure (Adjustment : not null access Gtk_Adjustment_Record; Value : Gdouble; Lower : Gdouble; Upper : Gdouble; Step_Increment : Gdouble; Page_Increment : Gdouble; Page_Size : Gdouble); -- Sets all properties of the adjustment at once. -- Use this function to avoid multiple emissions of the -- Gtk.Adjustment.Gtk_Adjustment::changed signal. See -- Gtk.Adjustment.Set_Lower for an alternative way of compressing multiple -- emissions of Gtk.Adjustment.Gtk_Adjustment::changed into one. -- Since: gtk+ 2.14 -- "value": the new value -- "lower": the new minimum value -- "upper": the new maximum value -- "step_increment": the new step increment -- "page_increment": the new page increment -- "page_size": the new page size function Get_Lower (Adjustment : not null access Gtk_Adjustment_Record) return Gdouble; -- Retrieves the minimum value of the adjustment. -- Since: gtk+ 2.14 procedure Set_Lower (Adjustment : not null access Gtk_Adjustment_Record; Lower : Gdouble); -- Sets the minimum value of the adjustment. -- When setting multiple adjustment properties via their individual -- setters, multiple Gtk.Adjustment.Gtk_Adjustment::changed signals will be -- emitted. However, since the emission of the -- Gtk.Adjustment.Gtk_Adjustment::changed signal is tied to the emission of -- the Glib.Object.GObject::notify signals of the changed properties, it's -- possible to compress the Gtk.Adjustment.Gtk_Adjustment::changed signals -- into one by calling g_object_freeze_notify and g_object_thaw_notify -- around the calls to the individual setters. -- Alternatively, using a single g_object_set for all the properties to -- change, or using Gtk.Adjustment.Configure has the same effect of -- compressing Gtk.Adjustment.Gtk_Adjustment::changed emissions. -- Since: gtk+ 2.14 -- "lower": the new minimum value function Get_Minimum_Increment (Adjustment : not null access Gtk_Adjustment_Record) return Gdouble; -- Gets the smaller of step increment and page increment. -- Since: gtk+ 3.2 function Get_Page_Increment (Adjustment : not null access Gtk_Adjustment_Record) return Gdouble; -- Retrieves the page increment of the adjustment. -- Since: gtk+ 2.14 procedure Set_Page_Increment (Adjustment : not null access Gtk_Adjustment_Record; Page_Increment : Gdouble); -- Sets the page increment of the adjustment. -- See Gtk.Adjustment.Set_Lower about how to compress multiple emissions -- of the Gtk.Adjustment.Gtk_Adjustment::changed signal when setting -- multiple adjustment properties. -- Since: gtk+ 2.14 -- "page_increment": the new page increment function Get_Page_Size (Adjustment : not null access Gtk_Adjustment_Record) return Gdouble; -- Retrieves the page size of the adjustment. -- Since: gtk+ 2.14 procedure Set_Page_Size (Adjustment : not null access Gtk_Adjustment_Record; Page_Size : Gdouble); -- Sets the page size of the adjustment. -- See Gtk.Adjustment.Set_Lower about how to compress multiple emissions -- of the GtkAdjustment::changed signal when setting multiple adjustment -- properties. -- Since: gtk+ 2.14 -- "page_size": the new page size function Get_Step_Increment (Adjustment : not null access Gtk_Adjustment_Record) return Gdouble; -- Retrieves the step increment of the adjustment. -- Since: gtk+ 2.14 procedure Set_Step_Increment (Adjustment : not null access Gtk_Adjustment_Record; Step_Increment : Gdouble); -- Sets the step increment of the adjustment. -- See Gtk.Adjustment.Set_Lower about how to compress multiple emissions -- of the Gtk.Adjustment.Gtk_Adjustment::changed signal when setting -- multiple adjustment properties. -- Since: gtk+ 2.14 -- "step_increment": the new step increment function Get_Upper (Adjustment : not null access Gtk_Adjustment_Record) return Gdouble; -- Retrieves the maximum value of the adjustment. -- Since: gtk+ 2.14 procedure Set_Upper (Adjustment : not null access Gtk_Adjustment_Record; Upper : Gdouble); -- Sets the maximum value of the adjustment. -- Note that values will be restricted by `upper - page-size` if the -- page-size property is nonzero. -- See Gtk.Adjustment.Set_Lower about how to compress multiple emissions -- of the Gtk.Adjustment.Gtk_Adjustment::changed signal when setting -- multiple adjustment properties. -- Since: gtk+ 2.14 -- "upper": the new maximum value function Get_Value (Adjustment : not null access Gtk_Adjustment_Record) return Gdouble; -- Gets the current value of the adjustment. See Gtk.Adjustment.Set_Value. procedure Set_Value (Adjustment : not null access Gtk_Adjustment_Record; Value : Gdouble); -- Sets the Gtk.Adjustment.Gtk_Adjustment value. The value is clamped to -- lie between Gtk.Adjustment.Gtk_Adjustment:lower and -- Gtk.Adjustment.Gtk_Adjustment:upper. -- Note that for adjustments which are used in a -- Gtk.Scrollbar.Gtk_Scrollbar, the effective range of allowed values goes -- from Gtk.Adjustment.Gtk_Adjustment:lower to -- Gtk.Adjustment.Gtk_Adjustment:upper - -- Gtk.Adjustment.Gtk_Adjustment:page-size. -- "value": the new value procedure Value_Changed (Adjustment : not null access Gtk_Adjustment_Record); pragma Obsolescent (Value_Changed); -- Emits a Gtk.Adjustment.Gtk_Adjustment::value-changed signal from the -- Gtk.Adjustment.Gtk_Adjustment. This is typically called by the owner of -- the Gtk.Adjustment.Gtk_Adjustment after it has changed the -- Gtk.Adjustment.Gtk_Adjustment:value property. -- Deprecated since 3.18, 1 ---------------- -- Properties -- ---------------- -- The following properties are defined for this widget. See -- Glib.Properties for more information on properties) Lower_Property : constant Glib.Properties.Property_Double; -- Type: Gdouble -- The minimum value of the adjustment. Page_Increment_Property : constant Glib.Properties.Property_Double; -- Type: Gdouble -- The page increment of the adjustment. Page_Size_Property : constant Glib.Properties.Property_Double; -- Type: Gdouble -- The page size of the adjustment. Note that the page-size is irrelevant -- and should be set to zero if the adjustment is used for a simple scalar -- value, e.g. in a Gtk.Spin_Button.Gtk_Spin_Button. Step_Increment_Property : constant Glib.Properties.Property_Double; -- Type: Gdouble -- The step increment of the adjustment. Upper_Property : constant Glib.Properties.Property_Double; -- Type: Gdouble -- The maximum value of the adjustment. Note that values will be -- restricted by `upper - page-size` if the page-size property is nonzero. Value_Property : constant Glib.Properties.Property_Double; -- Type: Gdouble -- The value of the adjustment. ------------- -- Signals -- ------------- type Cb_Gtk_Adjustment_Void is not null access procedure (Self : access Gtk_Adjustment_Record'Class); type Cb_GObject_Void is not null access procedure (Self : access Glib.Object.GObject_Record'Class); Signal_Changed : constant Glib.Signal_Name := "changed"; procedure On_Changed (Self : not null access Gtk_Adjustment_Record; Call : Cb_Gtk_Adjustment_Void; After : Boolean := False); procedure On_Changed (Self : not null access Gtk_Adjustment_Record; Call : Cb_GObject_Void; Slot : not null access Glib.Object.GObject_Record'Class; After : Boolean := False); -- Emitted when one or more of the Gtk.Adjustment.Gtk_Adjustment -- properties have been changed, other than the -- Gtk.Adjustment.Gtk_Adjustment:value property. Signal_Value_Changed : constant Glib.Signal_Name := "value-changed"; procedure On_Value_Changed (Self : not null access Gtk_Adjustment_Record; Call : Cb_Gtk_Adjustment_Void; After : Boolean := False); procedure On_Value_Changed (Self : not null access Gtk_Adjustment_Record; Call : Cb_GObject_Void; Slot : not null access Glib.Object.GObject_Record'Class; After : Boolean := False); -- Emitted when the Gtk.Adjustment.Gtk_Adjustment:value property has been -- changed. private Value_Property : constant Glib.Properties.Property_Double := Glib.Properties.Build ("value"); Upper_Property : constant Glib.Properties.Property_Double := Glib.Properties.Build ("upper"); Step_Increment_Property : constant Glib.Properties.Property_Double := Glib.Properties.Build ("step-increment"); Page_Size_Property : constant Glib.Properties.Property_Double := Glib.Properties.Build ("page-size"); Page_Increment_Property : constant Glib.Properties.Property_Double := Glib.Properties.Build ("page-increment"); Lower_Property : constant Glib.Properties.Property_Double := Glib.Properties.Build ("lower"); end Gtk.Adjustment; gtkada-24.0.0/src/generated/gtk-alignment.adb000066400000000000000000000126251446021174000207730ustar00rootroot00000000000000------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ pragma Style_Checks (Off); pragma Warnings (Off, "*is already use-visible*"); with Glib.Type_Conversion_Hooks; use Glib.Type_Conversion_Hooks; package body Gtk.Alignment is package Type_Conversion_Gtk_Alignment is new Glib.Type_Conversion_Hooks.Hook_Registrator (Get_Type'Access, Gtk_Alignment_Record); pragma Unreferenced (Type_Conversion_Gtk_Alignment); ----------------------- -- Gtk_Alignment_New -- ----------------------- function Gtk_Alignment_New (Xalign : Gfloat; Yalign : Gfloat; Xscale : Gfloat; Yscale : Gfloat) return Gtk_Alignment is Alignment : constant Gtk_Alignment := new Gtk_Alignment_Record; begin Gtk.Alignment.Initialize (Alignment, Xalign, Yalign, Xscale, Yscale); return Alignment; end Gtk_Alignment_New; ------------- -- Gtk_New -- ------------- procedure Gtk_New (Alignment : out Gtk_Alignment; Xalign : Gfloat; Yalign : Gfloat; Xscale : Gfloat; Yscale : Gfloat) is begin Alignment := new Gtk_Alignment_Record; Gtk.Alignment.Initialize (Alignment, Xalign, Yalign, Xscale, Yscale); end Gtk_New; ---------------- -- Initialize -- ---------------- procedure Initialize (Alignment : not null access Gtk_Alignment_Record'Class; Xalign : Gfloat; Yalign : Gfloat; Xscale : Gfloat; Yscale : Gfloat) is function Internal (Xalign : Gfloat; Yalign : Gfloat; Xscale : Gfloat; Yscale : Gfloat) return System.Address; pragma Import (C, Internal, "gtk_alignment_new"); begin if not Alignment.Is_Created then Set_Object (Alignment, Internal (Xalign, Yalign, Xscale, Yscale)); end if; end Initialize; ----------------- -- Get_Padding -- ----------------- procedure Get_Padding (Alignment : not null access Gtk_Alignment_Record; Padding_Top : out Guint; Padding_Bottom : out Guint; Padding_Left : out Guint; Padding_Right : out Guint) is procedure Internal (Alignment : System.Address; Padding_Top : out Guint; Padding_Bottom : out Guint; Padding_Left : out Guint; Padding_Right : out Guint); pragma Import (C, Internal, "gtk_alignment_get_padding"); begin Internal (Get_Object (Alignment), Padding_Top, Padding_Bottom, Padding_Left, Padding_Right); end Get_Padding; --------- -- Set -- --------- procedure Set (Alignment : not null access Gtk_Alignment_Record; Xalign : Gfloat; Yalign : Gfloat; Xscale : Gfloat; Yscale : Gfloat) is procedure Internal (Alignment : System.Address; Xalign : Gfloat; Yalign : Gfloat; Xscale : Gfloat; Yscale : Gfloat); pragma Import (C, Internal, "gtk_alignment_set"); begin Internal (Get_Object (Alignment), Xalign, Yalign, Xscale, Yscale); end Set; ----------------- -- Set_Padding -- ----------------- procedure Set_Padding (Alignment : not null access Gtk_Alignment_Record; Padding_Top : Guint; Padding_Bottom : Guint; Padding_Left : Guint; Padding_Right : Guint) is procedure Internal (Alignment : System.Address; Padding_Top : Guint; Padding_Bottom : Guint; Padding_Left : Guint; Padding_Right : Guint); pragma Import (C, Internal, "gtk_alignment_set_padding"); begin Internal (Get_Object (Alignment), Padding_Top, Padding_Bottom, Padding_Left, Padding_Right); end Set_Padding; end Gtk.Alignment; gtkada-24.0.0/src/generated/gtk-alignment.ads000066400000000000000000000257441446021174000210220ustar00rootroot00000000000000------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ -- -- The Gtk.Alignment.Gtk_Alignment widget controls the alignment and size of -- its child widget. It has four settings: xscale, yscale, xalign, and yalign. -- -- The scale settings are used to specify how much the child widget should -- expand to fill the space allocated to the Gtk.Alignment.Gtk_Alignment. The -- values can range from 0 (meaning the child doesn't expand at all) to 1 -- (meaning the child expands to fill all of the available space). -- -- The align settings are used to place the child widget within the available -- area. The values range from 0 (top or left) to 1 (bottom or right). Of -- course, if the scale settings are both set to 1, the alignment settings -- have no effect. -- -- GtkAlignment has been deprecated in 3.14 and should not be used in -- newly-written code. The desired effect can be achieved by using the -- Gtk.Widget.Gtk_Widget:halign, Gtk.Widget.Gtk_Widget:valign and -- Gtk.Widget.Gtk_Widget:margin properties on the child widget. -- -- -- gtk-alignment -- create_alignment.adb pragma Warnings (Off, "*is already use-visible*"); with Glib; use Glib; with Glib.Properties; use Glib.Properties; with Glib.Types; use Glib.Types; with Gtk.Bin; use Gtk.Bin; with Gtk.Buildable; use Gtk.Buildable; package Gtk.Alignment is type Gtk_Alignment_Record is new Gtk_Bin_Record with null record; type Gtk_Alignment is access all Gtk_Alignment_Record'Class; ------------------ -- Constructors -- ------------------ procedure Gtk_New (Alignment : out Gtk_Alignment; Xalign : Gfloat; Yalign : Gfloat; Xscale : Gfloat; Yscale : Gfloat); procedure Initialize (Alignment : not null access Gtk_Alignment_Record'Class; Xalign : Gfloat; Yalign : Gfloat; Xscale : Gfloat; Yscale : Gfloat); -- Creates a new Gtk.Alignment.Gtk_Alignment. -- Initialize does nothing if the object was already created with another -- call to Initialize* or G_New. -- "xalign": the horizontal alignment of the child widget, from 0 (left) -- to 1 (right). -- "yalign": the vertical alignment of the child widget, from 0 (top) to 1 -- (bottom). -- "xscale": the amount that the child widget expands horizontally to fill -- up unused space, from 0 to 1. A value of 0 indicates that the child -- widget should never expand. A value of 1 indicates that the child widget -- will expand to fill all of the space allocated for the -- Gtk.Alignment.Gtk_Alignment. -- "yscale": the amount that the child widget expands vertically to fill -- up unused space, from 0 to 1. The values are similar to Xscale. function Gtk_Alignment_New (Xalign : Gfloat; Yalign : Gfloat; Xscale : Gfloat; Yscale : Gfloat) return Gtk_Alignment; -- Creates a new Gtk.Alignment.Gtk_Alignment. -- "xalign": the horizontal alignment of the child widget, from 0 (left) -- to 1 (right). -- "yalign": the vertical alignment of the child widget, from 0 (top) to 1 -- (bottom). -- "xscale": the amount that the child widget expands horizontally to fill -- up unused space, from 0 to 1. A value of 0 indicates that the child -- widget should never expand. A value of 1 indicates that the child widget -- will expand to fill all of the space allocated for the -- Gtk.Alignment.Gtk_Alignment. -- "yscale": the amount that the child widget expands vertically to fill -- up unused space, from 0 to 1. The values are similar to Xscale. function Get_Type return Glib.GType; pragma Import (C, Get_Type, "gtk_alignment_get_type"); ------------- -- Methods -- ------------- procedure Get_Padding (Alignment : not null access Gtk_Alignment_Record; Padding_Top : out Guint; Padding_Bottom : out Guint; Padding_Left : out Guint; Padding_Right : out Guint); pragma Obsolescent (Get_Padding); -- Gets the padding on the different sides of the widget. See -- gtk_alignment_set_padding (). -- Since: gtk+ 2.4 -- Deprecated since 3.14, 1 -- "padding_top": location to store the padding for the top of the widget, -- or null -- "padding_bottom": location to store the padding for the bottom of the -- widget, or null -- "padding_left": location to store the padding for the left of the -- widget, or null -- "padding_right": location to store the padding for the right of the -- widget, or null procedure Set_Padding (Alignment : not null access Gtk_Alignment_Record; Padding_Top : Guint; Padding_Bottom : Guint; Padding_Left : Guint; Padding_Right : Guint); pragma Obsolescent (Set_Padding); -- Sets the padding on the different sides of the widget. The padding adds -- blank space to the sides of the widget. For instance, this can be used -- to indent the child widget towards the right by adding padding on the -- left. -- Since: gtk+ 2.4 -- Deprecated since 3.14, 1 -- "padding_top": the padding at the top of the widget -- "padding_bottom": the padding at the bottom of the widget -- "padding_left": the padding at the left of the widget -- "padding_right": the padding at the right of the widget. procedure Set (Alignment : not null access Gtk_Alignment_Record; Xalign : Gfloat; Yalign : Gfloat; Xscale : Gfloat; Yscale : Gfloat); pragma Obsolescent (Set); -- Sets the Gtk.Alignment.Gtk_Alignment values. -- Deprecated since 3.14, 1 -- "xalign": the horizontal alignment of the child widget, from 0 (left) -- to 1 (right). -- "yalign": the vertical alignment of the child widget, from 0 (top) to 1 -- (bottom). -- "xscale": the amount that the child widget expands horizontally to fill -- up unused space, from 0 to 1. A value of 0 indicates that the child -- widget should never expand. A value of 1 indicates that the child widget -- will expand to fill all of the space allocated for the -- Gtk.Alignment.Gtk_Alignment. -- "yscale": the amount that the child widget expands vertically to fill -- up unused space, from 0 to 1. The values are similar to Xscale. ---------------- -- Properties -- ---------------- -- The following properties are defined for this widget. See -- Glib.Properties for more information on properties) Bottom_Padding_Property : constant Glib.Properties.Property_Uint; -- The padding to insert at the bottom of the widget. Left_Padding_Property : constant Glib.Properties.Property_Uint; -- The padding to insert at the left of the widget. Right_Padding_Property : constant Glib.Properties.Property_Uint; -- The padding to insert at the right of the widget. Top_Padding_Property : constant Glib.Properties.Property_Uint; -- The padding to insert at the top of the widget. Xalign_Property : constant Glib.Properties.Property_Float; -- Horizontal position of child in available space. A value of 0.0 will -- flush the child left (or right, in RTL locales); a value of 1.0 will -- flush the child right (or left, in RTL locales). Xscale_Property : constant Glib.Properties.Property_Float; -- If available horizontal space is bigger than needed, how much of it to -- use for the child. A value of 0.0 means none; a value of 1.0 means all. Yalign_Property : constant Glib.Properties.Property_Float; -- Vertical position of child in available space. A value of 0.0 will -- flush the child to the top; a value of 1.0 will flush the child to the -- bottom. Yscale_Property : constant Glib.Properties.Property_Float; -- If available vertical space is bigger than needed, how much of it to -- use for the child. A value of 0.0 means none; a value of 1.0 means all. ---------------- -- Interfaces -- ---------------- -- This class implements several interfaces. See Glib.Types -- -- - "Buildable" package Implements_Gtk_Buildable is new Glib.Types.Implements (Gtk.Buildable.Gtk_Buildable, Gtk_Alignment_Record, Gtk_Alignment); function "+" (Widget : access Gtk_Alignment_Record'Class) return Gtk.Buildable.Gtk_Buildable renames Implements_Gtk_Buildable.To_Interface; function "-" (Interf : Gtk.Buildable.Gtk_Buildable) return Gtk_Alignment renames Implements_Gtk_Buildable.To_Object; private Yscale_Property : constant Glib.Properties.Property_Float := Glib.Properties.Build ("yscale"); Yalign_Property : constant Glib.Properties.Property_Float := Glib.Properties.Build ("yalign"); Xscale_Property : constant Glib.Properties.Property_Float := Glib.Properties.Build ("xscale"); Xalign_Property : constant Glib.Properties.Property_Float := Glib.Properties.Build ("xalign"); Top_Padding_Property : constant Glib.Properties.Property_Uint := Glib.Properties.Build ("top-padding"); Right_Padding_Property : constant Glib.Properties.Property_Uint := Glib.Properties.Build ("right-padding"); Left_Padding_Property : constant Glib.Properties.Property_Uint := Glib.Properties.Build ("left-padding"); Bottom_Padding_Property : constant Glib.Properties.Property_Uint := Glib.Properties.Build ("bottom-padding"); end Gtk.Alignment; gtkada-24.0.0/src/generated/gtk-application.adb000066400000000000000000001200551446021174000213150ustar00rootroot00000000000000------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ pragma Style_Checks (Off); pragma Warnings (Off, "*is already use-visible*"); with Ada.Unchecked_Conversion; with Glib.Type_Conversion_Hooks; use Glib.Type_Conversion_Hooks; with Glib.Values; use Glib.Values; with Gtk.Arguments; use Gtk.Arguments; with Gtkada.Bindings; use Gtkada.Bindings; pragma Warnings(Off); -- might be unused with Gtkada.Types; use Gtkada.Types; pragma Warnings(On); package body Gtk.Application is package Type_Conversion_Gtk_Application is new Glib.Type_Conversion_Hooks.Hook_Registrator (Get_Type'Access, Gtk_Application_Record); pragma Unreferenced (Type_Conversion_Gtk_Application); ------------------------- -- Gtk_Application_New -- ------------------------- function Gtk_Application_New (Application_Id : UTF8_String := ""; Flags : Glib.Application.GApplication_Flags) return Gtk_Application is Self : constant Gtk_Application := new Gtk_Application_Record; begin Gtk.Application.Initialize (Self, Application_Id, Flags); return Self; end Gtk_Application_New; ------------- -- Gtk_New -- ------------- procedure Gtk_New (Self : out Gtk_Application; Application_Id : UTF8_String := ""; Flags : Glib.Application.GApplication_Flags) is begin Self := new Gtk_Application_Record; Gtk.Application.Initialize (Self, Application_Id, Flags); end Gtk_New; ---------------- -- Initialize -- ---------------- procedure Initialize (Self : not null access Gtk_Application_Record'Class; Application_Id : UTF8_String := ""; Flags : Glib.Application.GApplication_Flags) is function Internal (Application_Id : Gtkada.Types.Chars_Ptr; Flags : Glib.Application.GApplication_Flags) return System.Address; pragma Import (C, Internal, "gtk_application_new"); Tmp_Application_Id : Gtkada.Types.Chars_Ptr; Tmp_Return : System.Address; begin if not Self.Is_Created then if Application_Id = "" then Tmp_Application_Id := Gtkada.Types.Null_Ptr; else Tmp_Application_Id := New_String (Application_Id); end if; Tmp_Return := Internal (Tmp_Application_Id, Flags); Free (Tmp_Application_Id); Set_Object (Self, Tmp_Return); end if; end Initialize; --------------------- -- Add_Accelerator -- --------------------- procedure Add_Accelerator (Self : not null access Gtk_Application_Record; Accelerator : UTF8_String; Action_Name : UTF8_String; Parameter : Glib.Variant.Gvariant) is procedure Internal (Self : System.Address; Accelerator : Gtkada.Types.Chars_Ptr; Action_Name : Gtkada.Types.Chars_Ptr; Parameter : System.Address); pragma Import (C, Internal, "gtk_application_add_accelerator"); Tmp_Accelerator : Gtkada.Types.Chars_Ptr := New_String (Accelerator); Tmp_Action_Name : Gtkada.Types.Chars_Ptr := New_String (Action_Name); begin Internal (Get_Object (Self), Tmp_Accelerator, Tmp_Action_Name, Get_Object (Parameter)); Free (Tmp_Action_Name); Free (Tmp_Accelerator); end Add_Accelerator; ---------------- -- Add_Window -- ---------------- procedure Add_Window (Self : not null access Gtk_Application_Record; Window : not null access Gtk.Window.Gtk_Window_Record'Class) is procedure Internal (Self : System.Address; Window : System.Address); pragma Import (C, Internal, "gtk_application_add_window"); begin Internal (Get_Object (Self), Get_Object (Window)); end Add_Window; --------------------------- -- Get_Accels_For_Action -- --------------------------- function Get_Accels_For_Action (Self : not null access Gtk_Application_Record; Detailed_Action_Name : UTF8_String) return GNAT.Strings.String_List is function Internal (Self : System.Address; Detailed_Action_Name : Gtkada.Types.Chars_Ptr) return chars_ptr_array_access; pragma Import (C, Internal, "gtk_application_get_accels_for_action"); Tmp_Detailed_Action_Name : Gtkada.Types.Chars_Ptr := New_String (Detailed_Action_Name); Tmp_Return : chars_ptr_array_access; begin Tmp_Return := Internal (Get_Object (Self), Tmp_Detailed_Action_Name); Free (Tmp_Detailed_Action_Name); return To_String_List_And_Free (Tmp_Return); end Get_Accels_For_Action; --------------------------- -- Get_Actions_For_Accel -- --------------------------- function Get_Actions_For_Accel (Self : not null access Gtk_Application_Record; Accel : UTF8_String) return GNAT.Strings.String_List is function Internal (Self : System.Address; Accel : Gtkada.Types.Chars_Ptr) return chars_ptr_array_access; pragma Import (C, Internal, "gtk_application_get_actions_for_accel"); Tmp_Accel : Gtkada.Types.Chars_Ptr := New_String (Accel); Tmp_Return : chars_ptr_array_access; begin Tmp_Return := Internal (Get_Object (Self), Tmp_Accel); Free (Tmp_Accel); return To_String_List_And_Free (Tmp_Return); end Get_Actions_For_Accel; ----------------------- -- Get_Active_Window -- ----------------------- function Get_Active_Window (Self : not null access Gtk_Application_Record) return Gtk.Window.Gtk_Window is function Internal (Self : System.Address) return System.Address; pragma Import (C, Internal, "gtk_application_get_active_window"); Stub_Gtk_Window : Gtk.Window.Gtk_Window_Record; begin return Gtk.Window.Gtk_Window (Get_User_Data (Internal (Get_Object (Self)), Stub_Gtk_Window)); end Get_Active_Window; ------------------ -- Get_App_Menu -- ------------------ function Get_App_Menu (Self : not null access Gtk_Application_Record) return Glib.Menu_Model.Gmenu_Model is function Internal (Self : System.Address) return System.Address; pragma Import (C, Internal, "gtk_application_get_app_menu"); Stub_Gmenu_Model : Glib.Menu_Model.Gmenu_Model_Record; begin return Glib.Menu_Model.Gmenu_Model (Get_User_Data (Internal (Get_Object (Self)), Stub_Gmenu_Model)); end Get_App_Menu; -------------------- -- Get_Menu_By_Id -- -------------------- function Get_Menu_By_Id (Self : not null access Gtk_Application_Record; Id : UTF8_String) return Glib.Menu.Gmenu is function Internal (Self : System.Address; Id : Gtkada.Types.Chars_Ptr) return System.Address; pragma Import (C, Internal, "gtk_application_get_menu_by_id"); Tmp_Id : Gtkada.Types.Chars_Ptr := New_String (Id); Stub_Gmenu : Glib.Menu.Gmenu_Record; Tmp_Return : System.Address; begin Tmp_Return := Internal (Get_Object (Self), Tmp_Id); Free (Tmp_Id); return Glib.Menu.Gmenu (Get_User_Data (Tmp_Return, Stub_Gmenu)); end Get_Menu_By_Id; ----------------- -- Get_Menubar -- ----------------- function Get_Menubar (Self : not null access Gtk_Application_Record) return Glib.Menu_Model.Gmenu_Model is function Internal (Self : System.Address) return System.Address; pragma Import (C, Internal, "gtk_application_get_menubar"); Stub_Gmenu_Model : Glib.Menu_Model.Gmenu_Model_Record; begin return Glib.Menu_Model.Gmenu_Model (Get_User_Data (Internal (Get_Object (Self)), Stub_Gmenu_Model)); end Get_Menubar; ---------------------- -- Get_Window_By_Id -- ---------------------- function Get_Window_By_Id (Self : not null access Gtk_Application_Record; Id : Guint) return Gtk.Window.Gtk_Window is function Internal (Self : System.Address; Id : Guint) return System.Address; pragma Import (C, Internal, "gtk_application_get_window_by_id"); Stub_Gtk_Window : Gtk.Window.Gtk_Window_Record; begin return Gtk.Window.Gtk_Window (Get_User_Data (Internal (Get_Object (Self), Id), Stub_Gtk_Window)); end Get_Window_By_Id; ----------------- -- Get_Windows -- ----------------- function Get_Windows (Self : not null access Gtk_Application_Record) return Gtk.Widget.Widget_List.Glist is function Internal (Self : System.Address) return System.Address; pragma Import (C, Internal, "gtk_application_get_windows"); Tmp_Return : Gtk.Widget.Widget_List.Glist; begin Gtk.Widget.Widget_List.Set_Object (Tmp_Return, Internal (Get_Object (Self))); return Tmp_Return; end Get_Windows; ------------- -- Inhibit -- ------------- function Inhibit (Self : not null access Gtk_Application_Record; Window : access Gtk.Window.Gtk_Window_Record'Class; Flags : Gtk_Application_Inhibit_Flags; Reason : UTF8_String := "") return Guint is function Internal (Self : System.Address; Window : System.Address; Flags : Gtk_Application_Inhibit_Flags; Reason : Gtkada.Types.Chars_Ptr) return Guint; pragma Import (C, Internal, "gtk_application_inhibit"); Tmp_Reason : Gtkada.Types.Chars_Ptr; Tmp_Return : Guint; begin if Reason = "" then Tmp_Reason := Gtkada.Types.Null_Ptr; else Tmp_Reason := New_String (Reason); end if; Tmp_Return := Internal (Get_Object (Self), Get_Object_Or_Null (GObject (Window)), Flags, Tmp_Reason); Free (Tmp_Reason); return Tmp_Return; end Inhibit; ------------------ -- Is_Inhibited -- ------------------ function Is_Inhibited (Self : not null access Gtk_Application_Record; Flags : Gtk_Application_Inhibit_Flags) return Boolean is function Internal (Self : System.Address; Flags : Gtk_Application_Inhibit_Flags) return Glib.Gboolean; pragma Import (C, Internal, "gtk_application_is_inhibited"); begin return Internal (Get_Object (Self), Flags) /= 0; end Is_Inhibited; ------------------------------ -- List_Action_Descriptions -- ------------------------------ function List_Action_Descriptions (Self : not null access Gtk_Application_Record) return GNAT.Strings.String_List is function Internal (Self : System.Address) return chars_ptr_array_access; pragma Import (C, Internal, "gtk_application_list_action_descriptions"); begin return To_String_List_And_Free (Internal (Get_Object (Self))); end List_Action_Descriptions; ---------------------- -- Prefers_App_Menu -- ---------------------- function Prefers_App_Menu (Self : not null access Gtk_Application_Record) return Boolean is function Internal (Self : System.Address) return Glib.Gboolean; pragma Import (C, Internal, "gtk_application_prefers_app_menu"); begin return Internal (Get_Object (Self)) /= 0; end Prefers_App_Menu; ------------------------ -- Remove_Accelerator -- ------------------------ procedure Remove_Accelerator (Self : not null access Gtk_Application_Record; Action_Name : UTF8_String; Parameter : Glib.Variant.Gvariant) is procedure Internal (Self : System.Address; Action_Name : Gtkada.Types.Chars_Ptr; Parameter : System.Address); pragma Import (C, Internal, "gtk_application_remove_accelerator"); Tmp_Action_Name : Gtkada.Types.Chars_Ptr := New_String (Action_Name); begin Internal (Get_Object (Self), Tmp_Action_Name, Get_Object (Parameter)); Free (Tmp_Action_Name); end Remove_Accelerator; ------------------- -- Remove_Window -- ------------------- procedure Remove_Window (Self : not null access Gtk_Application_Record; Window : not null access Gtk.Window.Gtk_Window_Record'Class) is procedure Internal (Self : System.Address; Window : System.Address); pragma Import (C, Internal, "gtk_application_remove_window"); begin Internal (Get_Object (Self), Get_Object (Window)); end Remove_Window; --------------------------- -- Set_Accels_For_Action -- --------------------------- procedure Set_Accels_For_Action (Self : not null access Gtk_Application_Record; Detailed_Action_Name : UTF8_String; Accels : GNAT.Strings.String_List) is procedure Internal (Self : System.Address; Detailed_Action_Name : Gtkada.Types.Chars_Ptr; Accels : Gtkada.Types.chars_ptr_array); pragma Import (C, Internal, "gtk_application_set_accels_for_action"); Tmp_Detailed_Action_Name : Gtkada.Types.Chars_Ptr := New_String (Detailed_Action_Name); Tmp_Accels : Gtkada.Types.chars_ptr_array := From_String_List (Accels); begin Internal (Get_Object (Self), Tmp_Detailed_Action_Name, Tmp_Accels); Gtkada.Types.Free (Tmp_Accels); Free (Tmp_Detailed_Action_Name); end Set_Accels_For_Action; ------------------ -- Set_App_Menu -- ------------------ procedure Set_App_Menu (Self : not null access Gtk_Application_Record; App_Menu : access Glib.Menu_Model.Gmenu_Model_Record'Class) is procedure Internal (Self : System.Address; App_Menu : System.Address); pragma Import (C, Internal, "gtk_application_set_app_menu"); begin Internal (Get_Object (Self), Get_Object_Or_Null (GObject (App_Menu))); end Set_App_Menu; ----------------- -- Set_Menubar -- ----------------- procedure Set_Menubar (Self : not null access Gtk_Application_Record; Menubar : access Glib.Menu_Model.Gmenu_Model_Record'Class) is procedure Internal (Self : System.Address; Menubar : System.Address); pragma Import (C, Internal, "gtk_application_set_menubar"); begin Internal (Get_Object (Self), Get_Object_Or_Null (GObject (Menubar))); end Set_Menubar; --------------- -- Uninhibit -- --------------- procedure Uninhibit (Self : not null access Gtk_Application_Record; Cookie : Guint) is procedure Internal (Self : System.Address; Cookie : Guint); pragma Import (C, Internal, "gtk_application_uninhibit"); begin Internal (Get_Object (Self), Cookie); end Uninhibit; ------------------ -- Action_Added -- ------------------ procedure Action_Added (Self : not null access Gtk_Application_Record; Action_Name : UTF8_String) is procedure Internal (Self : System.Address; Action_Name : Gtkada.Types.Chars_Ptr); pragma Import (C, Internal, "g_action_group_action_added"); Tmp_Action_Name : Gtkada.Types.Chars_Ptr := New_String (Action_Name); begin Internal (Get_Object (Self), Tmp_Action_Name); Free (Tmp_Action_Name); end Action_Added; ---------------------------- -- Action_Enabled_Changed -- ---------------------------- procedure Action_Enabled_Changed (Self : not null access Gtk_Application_Record; Action_Name : UTF8_String; Enabled : Boolean) is procedure Internal (Self : System.Address; Action_Name : Gtkada.Types.Chars_Ptr; Enabled : Glib.Gboolean); pragma Import (C, Internal, "g_action_group_action_enabled_changed"); Tmp_Action_Name : Gtkada.Types.Chars_Ptr := New_String (Action_Name); begin Internal (Get_Object (Self), Tmp_Action_Name, Boolean'Pos (Enabled)); Free (Tmp_Action_Name); end Action_Enabled_Changed; -------------------- -- Action_Removed -- -------------------- procedure Action_Removed (Self : not null access Gtk_Application_Record; Action_Name : UTF8_String) is procedure Internal (Self : System.Address; Action_Name : Gtkada.Types.Chars_Ptr); pragma Import (C, Internal, "g_action_group_action_removed"); Tmp_Action_Name : Gtkada.Types.Chars_Ptr := New_String (Action_Name); begin Internal (Get_Object (Self), Tmp_Action_Name); Free (Tmp_Action_Name); end Action_Removed; -------------------------- -- Action_State_Changed -- -------------------------- procedure Action_State_Changed (Self : not null access Gtk_Application_Record; Action_Name : UTF8_String; State : Glib.Variant.Gvariant) is procedure Internal (Self : System.Address; Action_Name : Gtkada.Types.Chars_Ptr; State : System.Address); pragma Import (C, Internal, "g_action_group_action_state_changed"); Tmp_Action_Name : Gtkada.Types.Chars_Ptr := New_String (Action_Name); begin Internal (Get_Object (Self), Tmp_Action_Name, Get_Object (State)); Free (Tmp_Action_Name); end Action_State_Changed; --------------------- -- Activate_Action -- --------------------- procedure Activate_Action (Self : not null access Gtk_Application_Record; Action_Name : UTF8_String; Parameter : Glib.Variant.Gvariant) is procedure Internal (Self : System.Address; Action_Name : Gtkada.Types.Chars_Ptr; Parameter : System.Address); pragma Import (C, Internal, "g_action_group_activate_action"); Tmp_Action_Name : Gtkada.Types.Chars_Ptr := New_String (Action_Name); begin Internal (Get_Object (Self), Tmp_Action_Name, Get_Object (Parameter)); Free (Tmp_Action_Name); end Activate_Action; ---------------- -- Add_Action -- ---------------- procedure Add_Action (Self : not null access Gtk_Application_Record; Action : Glib.Action.Gaction) is procedure Internal (Self : System.Address; Action : Glib.Action.Gaction); pragma Import (C, Internal, "g_action_map_add_action"); begin Internal (Get_Object (Self), Action); end Add_Action; ------------------------ -- Add_Action_Entries -- ------------------------ procedure Add_Action_Entries (Self : not null access Gtk_Application_Record; Entries : GAction_Entry_Array; User_Data : System.Address := System.Null_Address) is procedure Internal (Self : System.Address; Entries : GAction_Entry_Array; N_Entries : Glib.Gint; User_Data : System.Address); pragma Import (C, Internal, "g_action_map_add_action_entries"); begin Internal (Get_Object (Self), Entries, Entries'Length, User_Data); end Add_Action_Entries; ------------------------- -- Change_Action_State -- ------------------------- procedure Change_Action_State (Self : not null access Gtk_Application_Record; Action_Name : UTF8_String; Value : Glib.Variant.Gvariant) is procedure Internal (Self : System.Address; Action_Name : Gtkada.Types.Chars_Ptr; Value : System.Address); pragma Import (C, Internal, "g_action_group_change_action_state"); Tmp_Action_Name : Gtkada.Types.Chars_Ptr := New_String (Action_Name); begin Internal (Get_Object (Self), Tmp_Action_Name, Get_Object (Value)); Free (Tmp_Action_Name); end Change_Action_State; ------------------------ -- Get_Action_Enabled -- ------------------------ function Get_Action_Enabled (Self : not null access Gtk_Application_Record; Action_Name : UTF8_String) return Boolean is function Internal (Self : System.Address; Action_Name : Gtkada.Types.Chars_Ptr) return Glib.Gboolean; pragma Import (C, Internal, "g_action_group_get_action_enabled"); Tmp_Action_Name : Gtkada.Types.Chars_Ptr := New_String (Action_Name); Tmp_Return : Glib.Gboolean; begin Tmp_Return := Internal (Get_Object (Self), Tmp_Action_Name); Free (Tmp_Action_Name); return Tmp_Return /= 0; end Get_Action_Enabled; ------------------------------- -- Get_Action_Parameter_Type -- ------------------------------- function Get_Action_Parameter_Type (Self : not null access Gtk_Application_Record; Action_Name : UTF8_String) return Glib.Variant.Gvariant_Type is function Internal (Self : System.Address; Action_Name : Gtkada.Types.Chars_Ptr) return Glib.Variant.Gvariant_Type; pragma Import (C, Internal, "g_action_group_get_action_parameter_type"); Tmp_Action_Name : Gtkada.Types.Chars_Ptr := New_String (Action_Name); Tmp_Return : Glib.Variant.Gvariant_Type; begin Tmp_Return := Internal (Get_Object (Self), Tmp_Action_Name); Free (Tmp_Action_Name); return Tmp_Return; end Get_Action_Parameter_Type; ---------------------- -- Get_Action_State -- ---------------------- function Get_Action_State (Self : not null access Gtk_Application_Record; Action_Name : UTF8_String) return Glib.Variant.Gvariant is function Internal (Self : System.Address; Action_Name : Gtkada.Types.Chars_Ptr) return System.Address; pragma Import (C, Internal, "g_action_group_get_action_state"); Tmp_Action_Name : Gtkada.Types.Chars_Ptr := New_String (Action_Name); Tmp_Return : System.Address; begin Tmp_Return := Internal (Get_Object (Self), Tmp_Action_Name); Free (Tmp_Action_Name); return From_Object (Tmp_Return); end Get_Action_State; --------------------------- -- Get_Action_State_Hint -- --------------------------- function Get_Action_State_Hint (Self : not null access Gtk_Application_Record; Action_Name : UTF8_String) return Glib.Variant.Gvariant is function Internal (Self : System.Address; Action_Name : Gtkada.Types.Chars_Ptr) return System.Address; pragma Import (C, Internal, "g_action_group_get_action_state_hint"); Tmp_Action_Name : Gtkada.Types.Chars_Ptr := New_String (Action_Name); Tmp_Return : System.Address; begin Tmp_Return := Internal (Get_Object (Self), Tmp_Action_Name); Free (Tmp_Action_Name); return From_Object (Tmp_Return); end Get_Action_State_Hint; --------------------------- -- Get_Action_State_Type -- --------------------------- function Get_Action_State_Type (Self : not null access Gtk_Application_Record; Action_Name : UTF8_String) return Glib.Variant.Gvariant_Type is function Internal (Self : System.Address; Action_Name : Gtkada.Types.Chars_Ptr) return Glib.Variant.Gvariant_Type; pragma Import (C, Internal, "g_action_group_get_action_state_type"); Tmp_Action_Name : Gtkada.Types.Chars_Ptr := New_String (Action_Name); Tmp_Return : Glib.Variant.Gvariant_Type; begin Tmp_Return := Internal (Get_Object (Self), Tmp_Action_Name); Free (Tmp_Action_Name); return Tmp_Return; end Get_Action_State_Type; ---------------- -- Has_Action -- ---------------- function Has_Action (Self : not null access Gtk_Application_Record; Action_Name : UTF8_String) return Boolean is function Internal (Self : System.Address; Action_Name : Gtkada.Types.Chars_Ptr) return Glib.Gboolean; pragma Import (C, Internal, "g_action_group_has_action"); Tmp_Action_Name : Gtkada.Types.Chars_Ptr := New_String (Action_Name); Tmp_Return : Glib.Gboolean; begin Tmp_Return := Internal (Get_Object (Self), Tmp_Action_Name); Free (Tmp_Action_Name); return Tmp_Return /= 0; end Has_Action; ------------------ -- List_Actions -- ------------------ function List_Actions (Self : not null access Gtk_Application_Record) return GNAT.Strings.String_List is function Internal (Self : System.Address) return chars_ptr_array_access; pragma Import (C, Internal, "g_action_group_list_actions"); begin return To_String_List_And_Free (Internal (Get_Object (Self))); end List_Actions; ------------------- -- Lookup_Action -- ------------------- function Lookup_Action (Self : not null access Gtk_Application_Record; Action_Name : UTF8_String) return Glib.Action.Gaction is function Internal (Self : System.Address; Action_Name : Gtkada.Types.Chars_Ptr) return Glib.Action.Gaction; pragma Import (C, Internal, "g_action_map_lookup_action"); Tmp_Action_Name : Gtkada.Types.Chars_Ptr := New_String (Action_Name); Tmp_Return : Glib.Action.Gaction; begin Tmp_Return := Internal (Get_Object (Self), Tmp_Action_Name); Free (Tmp_Action_Name); return Tmp_Return; end Lookup_Action; ------------------ -- Query_Action -- ------------------ function Query_Action (Self : not null access Gtk_Application_Record; Action_Name : UTF8_String; Enabled : access Boolean; Parameter_Type : access Glib.Variant.Gvariant_Type; State_Type : access Glib.Variant.Gvariant_Type; State_Hint : access Glib.Variant.Gvariant; State : access Glib.Variant.Gvariant) return Boolean is function Internal (Self : System.Address; Action_Name : Gtkada.Types.Chars_Ptr; Acc_Enabled : access Glib.Gboolean; Acc_Parameter_Type : access Glib.Variant.Gvariant_Type; Acc_State_Type : access Glib.Variant.Gvariant_Type; Acc_State_Hint : access System.Address; Acc_State : access System.Address) return Glib.Gboolean; pragma Import (C, Internal, "g_action_group_query_action"); Acc_Enabled : aliased Boolean; Acc_Parameter_Type : aliased Glib.Variant.Gvariant_Type; Acc_State_Type : aliased Glib.Variant.Gvariant_Type; Acc_State_Hint : aliased Glib.Variant.Gvariant; Acc_State : aliased Glib.Variant.Gvariant; Tmp_Action_Name : Gtkada.Types.Chars_Ptr := New_String (Action_Name); Tmp_Acc_Enabled : aliased Glib.Gboolean; Tmp_Acc_State_Hint : aliased System.Address; Tmp_Acc_State : aliased System.Address; Tmp_Return : Glib.Gboolean; begin Tmp_Return := Internal (Get_Object (Self), Tmp_Action_Name, Tmp_Acc_Enabled'Access, Acc_Parameter_Type'Access, Acc_State_Type'Access, Tmp_Acc_State_Hint'Access, Tmp_Acc_State'Access); Acc_State := From_Object (Tmp_Acc_State); Acc_State_Hint := From_Object (Tmp_Acc_State_Hint); Acc_Enabled := Tmp_Acc_Enabled /= 0; Free (Tmp_Action_Name); Enabled.all := Acc_Enabled; if Parameter_Type /= null then Parameter_Type.all := Acc_Parameter_Type; end if; if State_Type /= null then State_Type.all := Acc_State_Type; end if; if State_Hint /= null then State_Hint.all := Acc_State_Hint; end if; if State /= null then State.all := Acc_State; end if; return Tmp_Return /= 0; end Query_Action; ------------------- -- Remove_Action -- ------------------- procedure Remove_Action (Self : not null access Gtk_Application_Record; Action_Name : UTF8_String) is procedure Internal (Self : System.Address; Action_Name : Gtkada.Types.Chars_Ptr); pragma Import (C, Internal, "g_action_map_remove_action"); Tmp_Action_Name : Gtkada.Types.Chars_Ptr := New_String (Action_Name); begin Internal (Get_Object (Self), Tmp_Action_Name); Free (Tmp_Action_Name); end Remove_Action; use type System.Address; function Cb_To_Address is new Ada.Unchecked_Conversion (Cb_Gtk_Application_Void, System.Address); function Address_To_Cb is new Ada.Unchecked_Conversion (System.Address, Cb_Gtk_Application_Void); function Cb_To_Address is new Ada.Unchecked_Conversion (Cb_GObject_Void, System.Address); function Address_To_Cb is new Ada.Unchecked_Conversion (System.Address, Cb_GObject_Void); function Cb_To_Address is new Ada.Unchecked_Conversion (Cb_Gtk_Application_Gtk_Window_Void, System.Address); function Address_To_Cb is new Ada.Unchecked_Conversion (System.Address, Cb_Gtk_Application_Gtk_Window_Void); function Cb_To_Address is new Ada.Unchecked_Conversion (Cb_GObject_Gtk_Window_Void, System.Address); function Address_To_Cb is new Ada.Unchecked_Conversion (System.Address, Cb_GObject_Gtk_Window_Void); procedure Connect (Object : access Gtk_Application_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_Gtk_Application_Void; After : Boolean); procedure Connect (Object : access Gtk_Application_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_Gtk_Application_Gtk_Window_Void; After : Boolean); procedure Connect_Slot (Object : access Gtk_Application_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_GObject_Void; After : Boolean; Slot : access Glib.Object.GObject_Record'Class := null); procedure Connect_Slot (Object : access Gtk_Application_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_GObject_Gtk_Window_Void; After : Boolean; Slot : access Glib.Object.GObject_Record'Class := null); procedure Marsh_GObject_Gtk_Window_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address); pragma Convention (C, Marsh_GObject_Gtk_Window_Void); procedure Marsh_GObject_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address); pragma Convention (C, Marsh_GObject_Void); procedure Marsh_Gtk_Application_Gtk_Window_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address); pragma Convention (C, Marsh_Gtk_Application_Gtk_Window_Void); procedure Marsh_Gtk_Application_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address); pragma Convention (C, Marsh_Gtk_Application_Void); ------------- -- Connect -- ------------- procedure Connect (Object : access Gtk_Application_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_Gtk_Application_Void; After : Boolean) is begin Unchecked_Do_Signal_Connect (Object => Object, C_Name => C_Name, Marshaller => Marsh_Gtk_Application_Void'Access, Handler => Cb_To_Address (Handler),-- Set in the closure After => After); end Connect; ------------- -- Connect -- ------------- procedure Connect (Object : access Gtk_Application_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_Gtk_Application_Gtk_Window_Void; After : Boolean) is begin Unchecked_Do_Signal_Connect (Object => Object, C_Name => C_Name, Marshaller => Marsh_Gtk_Application_Gtk_Window_Void'Access, Handler => Cb_To_Address (Handler),-- Set in the closure After => After); end Connect; ------------------ -- Connect_Slot -- ------------------ procedure Connect_Slot (Object : access Gtk_Application_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_GObject_Void; After : Boolean; Slot : access Glib.Object.GObject_Record'Class := null) is begin Unchecked_Do_Signal_Connect (Object => Object, C_Name => C_Name, Marshaller => Marsh_GObject_Void'Access, Handler => Cb_To_Address (Handler),-- Set in the closure Slot_Object => Slot, After => After); end Connect_Slot; ------------------ -- Connect_Slot -- ------------------ procedure Connect_Slot (Object : access Gtk_Application_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_GObject_Gtk_Window_Void; After : Boolean; Slot : access Glib.Object.GObject_Record'Class := null) is begin Unchecked_Do_Signal_Connect (Object => Object, C_Name => C_Name, Marshaller => Marsh_GObject_Gtk_Window_Void'Access, Handler => Cb_To_Address (Handler),-- Set in the closure Slot_Object => Slot, After => After); end Connect_Slot; ----------------------------------- -- Marsh_GObject_Gtk_Window_Void -- ----------------------------------- procedure Marsh_GObject_Gtk_Window_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address) is pragma Unreferenced (Return_Value, N_Params, Invocation_Hint, User_Data); H : constant Cb_GObject_Gtk_Window_Void := Address_To_Cb (Get_Callback (Closure)); Obj : constant Glib.Object.GObject := Glib.Object.Convert (Get_Data (Closure)); begin H (Obj, Gtk.Window.Gtk_Window (Unchecked_To_Object (Params, 1))); exception when E : others => Process_Exception (E); end Marsh_GObject_Gtk_Window_Void; ------------------------ -- Marsh_GObject_Void -- ------------------------ procedure Marsh_GObject_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address) is pragma Unreferenced (Return_Value, N_Params, Params, Invocation_Hint, User_Data); H : constant Cb_GObject_Void := Address_To_Cb (Get_Callback (Closure)); Obj : constant Glib.Object.GObject := Glib.Object.Convert (Get_Data (Closure)); begin H (Obj); exception when E : others => Process_Exception (E); end Marsh_GObject_Void; ------------------------------------------- -- Marsh_Gtk_Application_Gtk_Window_Void -- ------------------------------------------- procedure Marsh_Gtk_Application_Gtk_Window_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address) is pragma Unreferenced (Return_Value, N_Params, Invocation_Hint, User_Data); H : constant Cb_Gtk_Application_Gtk_Window_Void := Address_To_Cb (Get_Callback (Closure)); Obj : constant Gtk_Application := Gtk_Application (Unchecked_To_Object (Params, 0)); begin H (Obj, Gtk.Window.Gtk_Window (Unchecked_To_Object (Params, 1))); exception when E : others => Process_Exception (E); end Marsh_Gtk_Application_Gtk_Window_Void; -------------------------------- -- Marsh_Gtk_Application_Void -- -------------------------------- procedure Marsh_Gtk_Application_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address) is pragma Unreferenced (Return_Value, N_Params, Invocation_Hint, User_Data); H : constant Cb_Gtk_Application_Void := Address_To_Cb (Get_Callback (Closure)); Obj : constant Gtk_Application := Gtk_Application (Unchecked_To_Object (Params, 0)); begin H (Obj); exception when E : others => Process_Exception (E); end Marsh_Gtk_Application_Void; ------------------ -- On_Query_End -- ------------------ procedure On_Query_End (Self : not null access Gtk_Application_Record; Call : Cb_Gtk_Application_Void; After : Boolean := False) is begin Connect (Self, "query-end" & ASCII.NUL, Call, After); end On_Query_End; ------------------ -- On_Query_End -- ------------------ procedure On_Query_End (Self : not null access Gtk_Application_Record; Call : Cb_GObject_Void; Slot : not null access Glib.Object.GObject_Record'Class; After : Boolean := False) is begin Connect_Slot (Self, "query-end" & ASCII.NUL, Call, After, Slot); end On_Query_End; --------------------- -- On_Window_Added -- --------------------- procedure On_Window_Added (Self : not null access Gtk_Application_Record; Call : Cb_Gtk_Application_Gtk_Window_Void; After : Boolean := False) is begin Connect (Self, "window-added" & ASCII.NUL, Call, After); end On_Window_Added; --------------------- -- On_Window_Added -- --------------------- procedure On_Window_Added (Self : not null access Gtk_Application_Record; Call : Cb_GObject_Gtk_Window_Void; Slot : not null access Glib.Object.GObject_Record'Class; After : Boolean := False) is begin Connect_Slot (Self, "window-added" & ASCII.NUL, Call, After, Slot); end On_Window_Added; ----------------------- -- On_Window_Removed -- ----------------------- procedure On_Window_Removed (Self : not null access Gtk_Application_Record; Call : Cb_Gtk_Application_Gtk_Window_Void; After : Boolean := False) is begin Connect (Self, "window-removed" & ASCII.NUL, Call, After); end On_Window_Removed; ----------------------- -- On_Window_Removed -- ----------------------- procedure On_Window_Removed (Self : not null access Gtk_Application_Record; Call : Cb_GObject_Gtk_Window_Void; Slot : not null access Glib.Object.GObject_Record'Class; After : Boolean := False) is begin Connect_Slot (Self, "window-removed" & ASCII.NUL, Call, After, Slot); end On_Window_Removed; end Gtk.Application; gtkada-24.0.0/src/generated/gtk-application.ads000066400000000000000000001033621446021174000213400ustar00rootroot00000000000000------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ -- -- Gtk.Application.Gtk_Application is a class that handles many important -- aspects of a GTK+ application in a convenient fashion, without enforcing a -- one-size-fits-all application model. -- -- Currently, GtkApplication handles GTK+ initialization, application -- uniqueness, session management, provides some basic scriptability and -- desktop shell integration by exporting actions and menus and manages a list -- of toplevel windows whose life-cycle is automatically tied to the -- life-cycle of your application. -- -- While GtkApplication works fine with plain Gtk_Windows, it is recommended -- to use it together with Gtk.Application_Window.Gtk_Application_Window. -- -- When GDK threads are enabled, GtkApplication will acquire the GDK lock -- when invoking actions that arrive from other processes. The GDK lock is not -- touched for local action invocations. In order to have actions invoked in a -- predictable context it is therefore recommended that the GDK lock be held -- while invoking actions locally with Glib.Action_Group.Activate_Action. The -- same applies to actions associated with -- Gtk.Application_Window.Gtk_Application_Window and to the "activate" and -- "open" Glib.Application.Gapplication methods. -- -- ## Automatic resources ## {automatic-resources} -- -- Gtk.Application.Gtk_Application will automatically load menus from the -- Gtk.Builder.Gtk_Builder resource located at "gtk/menus.ui", relative to the -- application's resource base path (see -- Glib.Application.Set_Resource_Base_Path). The menu with the ID "app-menu" -- is taken as the application's app menu and the menu with the ID "menubar" -- is taken as the application's menubar. Additional menus (most interesting -- submenus) can be named and accessed via Gtk.Application.Get_Menu_By_Id -- which allows for dynamic population of a part of the menu structure. -- -- If the resources "gtk/menus-appmenu.ui" or "gtk/menus-traditional.ui" are -- present then these files will be used in preference, depending on the value -- of Gtk.Application.Prefers_App_Menu. If the resource "gtk/menus-common.ui" -- is present it will be loaded as well. This is useful for storing items that -- are referenced from both "gtk/menus-appmenu.ui" and -- "gtk/menus-traditional.ui". -- -- It is also possible to provide the menus manually using -- Gtk.Application.Set_App_Menu and Gtk.Application.Set_Menubar. -- -- Gtk.Application.Gtk_Application will also automatically setup an icon -- search path for the default icon theme by appending "icons" to the resource -- base path. This allows your application to easily store its icons as -- resources. See Gtk.Icon_Theme.Add_Resource_Path for more information. -- -- If there is a resource located at "gtk/help-overlay.ui" which defines a -- Gtk.Shortcuts_Window.Gtk_Shortcuts_Window with ID "help_overlay" then -- GtkApplication associates an instance of this shortcuts window with each -- Gtk.Application_Window.Gtk_Application_Window and sets up keyboard -- accelerators (Control-F1 and Control-?) to open it. To create a menu item -- that displays the shortcuts window, associate the item with the action -- win.show-help-overlay. -- -- ## A simple application ## {gtkapplication} -- -- [A simple -- example](https://git.gnome.org/browse/gtk+/tree/examples/bp/bloatpad.c) -- -- GtkApplication optionally registers with a session manager of the users -- session (if you set the Gtk.Application.Gtk_Application:register-session -- property) and offers various functionality related to the session -- life-cycle. -- -- An application can block various ways to end the session with the -- Gtk.Application.Inhibit function. Typical use cases for this kind of -- inhibiting are long-running, uninterruptible operations, such as burning a -- CD or performing a disk backup. The session manager may not honor the -- inhibitor, but it can be expected to inform the user about the negative -- consequences of ending the session while inhibitors are present. -- -- ## See Also ## {seealso} [HowDoI: Using -- GtkApplication](https://wiki.gnome.org/HowDoI/GtkApplication), [Getting -- Started with GTK+: -- Basics](https://developer.gnome.org/gtk3/stable/gtk-getting-started.htmlid-1.2.3.3) -- -- pragma Warnings (Off, "*is already use-visible*"); with GNAT.Strings; use GNAT.Strings; with Glib; use Glib; with Glib.Action; use Glib.Action; with Glib.Action_Group; use Glib.Action_Group; with Glib.Action_Map; use Glib.Action_Map; with Glib.Application; use Glib.Application; with Glib.Generic_Properties; use Glib.Generic_Properties; with Glib.Menu; use Glib.Menu; with Glib.Menu_Model; use Glib.Menu_Model; with Glib.Object; use Glib.Object; with Glib.Properties; use Glib.Properties; with Glib.Types; use Glib.Types; with Glib.Variant; use Glib.Variant; with Gtk.Widget; use Gtk.Widget; with Gtk.Window; use Gtk.Window; package Gtk.Application is type Gtk_Application_Record is new Gapplication_Record with null record; type Gtk_Application is access all Gtk_Application_Record'Class; type Gtk_Application_Inhibit_Flags is mod 2 ** Integer'Size; pragma Convention (C, Gtk_Application_Inhibit_Flags); -- Types of user actions that may be blocked by Gtk.Application.Inhibit. Application_Inhibit_Logout : constant Gtk_Application_Inhibit_Flags := 1; Application_Inhibit_Switch : constant Gtk_Application_Inhibit_Flags := 2; Application_Inhibit_Suspend : constant Gtk_Application_Inhibit_Flags := 4; Application_Inhibit_Idle : constant Gtk_Application_Inhibit_Flags := 8; ---------------------------- -- Enumeration Properties -- ---------------------------- package Gtk_Application_Inhibit_Flags_Properties is new Generic_Internal_Discrete_Property (Gtk_Application_Inhibit_Flags); type Property_Gtk_Application_Inhibit_Flags is new Gtk_Application_Inhibit_Flags_Properties.Property; ------------------ -- Constructors -- ------------------ procedure Gtk_New (Self : out Gtk_Application; Application_Id : UTF8_String := ""; Flags : Glib.Application.GApplication_Flags); procedure Initialize (Self : not null access Gtk_Application_Record'Class; Application_Id : UTF8_String := ""; Flags : Glib.Application.GApplication_Flags); -- Creates a new Gtk.Application.Gtk_Application instance. -- When using Gtk.Application.Gtk_Application, it is not necessary to call -- gtk_init manually. It is called as soon as the application gets -- registered as the primary instance. -- Concretely, gtk_init is called in the default handler for the -- Glib.Application.Gapplication::startup signal. Therefore, -- Gtk.Application.Gtk_Application subclasses should chain up in their -- Glib.Application.Gapplication::startup handler before using any GTK+ -- API. -- Note that commandline arguments are not passed to gtk_init. All GTK+ -- functionality that is available via commandline arguments can also be -- achieved by setting suitable environment variables such as `G_DEBUG`, so -- this should not be a big problem. If you absolutely must support GTK+ -- commandline arguments, you can explicitly call gtk_init before creating -- the application instance. -- If non-null, the application ID must be valid. See -- Glib.Application.Id_Is_Valid. -- If no application ID is given then some features (most notably -- application uniqueness) will be disabled. A null application ID is only -- allowed with GTK+ 3.6 or later. -- Since: gtk+ 3.0 -- Initialize does nothing if the object was already created with another -- call to Initialize* or G_New. -- "application_id": The application ID. -- "flags": the application flags function Gtk_Application_New (Application_Id : UTF8_String := ""; Flags : Glib.Application.GApplication_Flags) return Gtk_Application; -- Creates a new Gtk.Application.Gtk_Application instance. -- When using Gtk.Application.Gtk_Application, it is not necessary to call -- gtk_init manually. It is called as soon as the application gets -- registered as the primary instance. -- Concretely, gtk_init is called in the default handler for the -- Glib.Application.Gapplication::startup signal. Therefore, -- Gtk.Application.Gtk_Application subclasses should chain up in their -- Glib.Application.Gapplication::startup handler before using any GTK+ -- API. -- Note that commandline arguments are not passed to gtk_init. All GTK+ -- functionality that is available via commandline arguments can also be -- achieved by setting suitable environment variables such as `G_DEBUG`, so -- this should not be a big problem. If you absolutely must support GTK+ -- commandline arguments, you can explicitly call gtk_init before creating -- the application instance. -- If non-null, the application ID must be valid. See -- Glib.Application.Id_Is_Valid. -- If no application ID is given then some features (most notably -- application uniqueness) will be disabled. A null application ID is only -- allowed with GTK+ 3.6 or later. -- Since: gtk+ 3.0 -- "application_id": The application ID. -- "flags": the application flags function Get_Type return Glib.GType; pragma Import (C, Get_Type, "gtk_application_get_type"); ------------- -- Methods -- ------------- procedure Add_Accelerator (Self : not null access Gtk_Application_Record; Accelerator : UTF8_String; Action_Name : UTF8_String; Parameter : Glib.Variant.Gvariant); pragma Obsolescent (Add_Accelerator); -- Installs an accelerator that will cause the named action to be -- activated when the key combination specificed by Accelerator is pressed. -- Accelerator must be a string that can be parsed by -- Gtk.Accel_Group.Accelerator_Parse, e.g. "q" or -- "p". -- Action_Name must be the name of an action as it would be used in the -- app menu, i.e. actions that have been added to the application are -- referred to with an "app." prefix, and window-specific actions with a -- "win." prefix. -- GtkApplication also extracts accelerators out of "accel" attributes in -- the GMenu_Models passed to Gtk.Application.Set_App_Menu and -- Gtk.Application.Set_Menubar, which is usually more convenient than -- calling this function for each accelerator. -- Since: gtk+ 3.4 -- Deprecated since 3.14, 1 -- "accelerator": accelerator string -- "action_name": the name of the action to activate -- "parameter": parameter to pass when activating the action, or null if -- the action does not accept an activation parameter procedure Add_Window (Self : not null access Gtk_Application_Record; Window : not null access Gtk.Window.Gtk_Window_Record'Class); -- Adds a window to Application. -- This call can only happen after the Application has started; typically, -- you should add new application windows in response to the emission of -- the Glib.Application.Gapplication::activate signal. -- This call is equivalent to setting the -- Gtk.Window.Gtk_Window:application property of Window to Application. -- Normally, the connection between the application and the window will -- remain until the window is destroyed, but you can explicitly remove it -- with Gtk.Application.Remove_Window. -- GTK+ will keep the Application running as long as it has any windows. -- Since: gtk+ 3.0 -- "window": a Gtk.Window.Gtk_Window function Get_Accels_For_Action (Self : not null access Gtk_Application_Record; Detailed_Action_Name : UTF8_String) return GNAT.Strings.String_List; -- Gets the accelerators that are currently associated with the given -- action. -- Since: gtk+ 3.12 -- "detailed_action_name": a detailed action name, specifying an action -- and target to obtain accelerators for procedure Set_Accels_For_Action (Self : not null access Gtk_Application_Record; Detailed_Action_Name : UTF8_String; Accels : GNAT.Strings.String_List); -- Sets zero or more keyboard accelerators that will trigger the given -- action. The first item in Accels will be the primary accelerator, which -- may be displayed in the UI. -- To remove all accelerators for an action, use an empty, zero-terminated -- array for Accels. -- For the Detailed_Action_Name, see g_action_parse_detailed_name and -- Glib.Action.Print_Detailed_Name. -- Since: gtk+ 3.12 -- "detailed_action_name": a detailed action name, specifying an action -- and target to associate accelerators with -- "accels": a list of accelerators in the format understood by -- Gtk.Accel_Group.Accelerator_Parse function Get_Actions_For_Accel (Self : not null access Gtk_Application_Record; Accel : UTF8_String) return GNAT.Strings.String_List; -- Returns the list of actions (possibly empty) that Accel maps to. Each -- item in the list is a detailed action name in the usual form. -- This might be useful to discover if an accel already exists in order to -- prevent installation of a conflicting accelerator (from an accelerator -- editor or a plugin system, for example). Note that having more than one -- action per accelerator may not be a bad thing and might make sense in -- cases where the actions never appear in the same context. -- In case there are no actions for a given accelerator, an empty array is -- returned. null is never returned. -- It is a programmer error to pass an invalid accelerator string. If you -- are unsure, check it with Gtk.Accel_Group.Accelerator_Parse first. -- Since: gtk+ 3.14 -- "accel": an accelerator that can be parsed by -- Gtk.Accel_Group.Accelerator_Parse function Get_Active_Window (Self : not null access Gtk_Application_Record) return Gtk.Window.Gtk_Window; -- Gets the "active" window for the application. -- The active window is the one that was most recently focused (within the -- application). This window may not have the focus at the moment if -- another application has it — this is just the most recently-focused -- window within this application. -- Since: gtk+ 3.6 function Get_App_Menu (Self : not null access Gtk_Application_Record) return Glib.Menu_Model.Gmenu_Model; -- Returns the menu model that has been set with -- Gtk.Application.Set_App_Menu. -- Since: gtk+ 3.4 procedure Set_App_Menu (Self : not null access Gtk_Application_Record; App_Menu : access Glib.Menu_Model.Gmenu_Model_Record'Class); -- Sets or unsets the application menu for Application. -- This can only be done in the primary instance of the application, after -- it has been registered. Glib.Application.Gapplication::startup is a good -- place to call this. -- The application menu is a single menu containing items that typically -- impact the application as a whole, rather than acting on a specific -- window or document. For example, you would expect to see "Preferences" -- or "Quit" in an application menu, but not "Save" or "Print". -- If supported, the application menu will be rendered by the desktop -- environment. -- Use the base Glib.Action_Map.Gaction_Map interface to add actions, to -- respond to the user selecting these menu items. -- Since: gtk+ 3.4 -- "app_menu": a Glib.Menu_Model.Gmenu_Model, or null function Get_Menu_By_Id (Self : not null access Gtk_Application_Record; Id : UTF8_String) return Glib.Menu.Gmenu; -- Gets a menu from automatically loaded resources. See [Automatic -- resources][automatic-resources] for more information. -- Since: gtk+ 3.14 -- "id": the id of the menu to look up function Get_Menubar (Self : not null access Gtk_Application_Record) return Glib.Menu_Model.Gmenu_Model; -- Returns the menu model that has been set with -- Gtk.Application.Set_Menubar. -- Since: gtk+ 3.4 procedure Set_Menubar (Self : not null access Gtk_Application_Record; Menubar : access Glib.Menu_Model.Gmenu_Model_Record'Class); -- Sets or unsets the menubar for windows of Application. -- This is a menubar in the traditional sense. -- This can only be done in the primary instance of the application, after -- it has been registered. Glib.Application.Gapplication::startup is a good -- place to call this. -- Depending on the desktop environment, this may appear at the top of -- each window, or at the top of the screen. In some environments, if both -- the application menu and the menubar are set, the application menu will -- be presented as if it were the first item of the menubar. Other -- environments treat the two as completely separate — for example, the -- application menu may be rendered by the desktop shell while the menubar -- (if set) remains in each individual window. -- Use the base Glib.Action_Map.Gaction_Map interface to add actions, to -- respond to the user selecting these menu items. -- Since: gtk+ 3.4 -- "menubar": a Glib.Menu_Model.Gmenu_Model, or null function Get_Window_By_Id (Self : not null access Gtk_Application_Record; Id : Guint) return Gtk.Window.Gtk_Window; -- Returns the Gtk.Application_Window.Gtk_Application_Window with the -- given ID. -- The ID of a Gtk.Application_Window.Gtk_Application_Window can be -- retrieved with Gtk.Application_Window.Get_Id. -- Since: gtk+ 3.6 -- "id": an identifier number function Get_Windows (Self : not null access Gtk_Application_Record) return Gtk.Widget.Widget_List.Glist; -- Gets a list of the Gtk_Windows associated with Application. -- The list is sorted by most recently focused window, such that the first -- element is the currently focused window. (Useful for choosing a parent -- for a transient window.) -- The list that is returned should not be modified in any way. It will -- only remain valid until the next focus change or window creation or -- deletion. -- Since: gtk+ 3.0 function Inhibit (Self : not null access Gtk_Application_Record; Window : access Gtk.Window.Gtk_Window_Record'Class; Flags : Gtk_Application_Inhibit_Flags; Reason : UTF8_String := "") return Guint; -- Inform the session manager that certain types of actions should be -- inhibited. This is not guaranteed to work on all platforms and for all -- types of actions. -- Applications should invoke this method when they begin an operation -- that should not be interrupted, such as creating a CD or DVD. The types -- of actions that may be blocked are specified by the Flags parameter. -- When the application completes the operation it should call -- Gtk.Application.Uninhibit to remove the inhibitor. Note that an -- application can have multiple inhibitors, and all of them must be -- individually removed. Inhibitors are also cleared when the application -- exits. -- Applications should not expect that they will always be able to block -- the action. In most cases, users will be given the option to force the -- action to take place. -- Reasons should be short and to the point. -- If Window is given, the session manager may point the user to this -- window to find out more about why the action is inhibited. -- Since: gtk+ 3.4 -- "window": a Gtk.Window.Gtk_Window, or null -- "flags": what types of actions should be inhibited -- "reason": a short, human-readable string that explains why these -- operations are inhibited function Is_Inhibited (Self : not null access Gtk_Application_Record; Flags : Gtk_Application_Inhibit_Flags) return Boolean; -- Determines if any of the actions specified in Flags are currently -- inhibited (possibly by another application). -- Note that this information may not be available (for example when the -- application is running in a sandbox). -- Since: gtk+ 3.4 -- "flags": what types of actions should be queried function List_Action_Descriptions (Self : not null access Gtk_Application_Record) return GNAT.Strings.String_List; -- Lists the detailed action names which have associated accelerators. See -- Gtk.Application.Set_Accels_For_Action. -- Since: gtk+ 3.12 function Prefers_App_Menu (Self : not null access Gtk_Application_Record) return Boolean; -- Determines if the desktop environment in which the application is -- running would prefer an application menu be shown. -- If this function returns True then the application should call -- Gtk.Application.Set_App_Menu with the contents of an application menu, -- which will be shown by the desktop environment. If it returns False then -- you should consider using an alternate approach, such as a menubar. -- The value returned by this function is purely advisory and you are free -- to ignore it. If you call Gtk.Application.Set_App_Menu even if the -- desktop environment doesn't support app menus, then a fallback will be -- provided. -- Applications are similarly free not to set an app menu even if the -- desktop environment wants to show one. In that case, a fallback will -- also be created by the desktop environment (GNOME, for example, uses a -- menu with only a "Quit" item in it). -- The value returned by this function never changes. Once it returns a -- particular value, it is guaranteed to always return the same value. -- You may only call this function after the application has been -- registered and after the base startup handler has run. You're most -- likely to want to use this from your own startup handler. It may also -- make sense to consult this function while constructing UI (in activate, -- open or an action activation handler) in order to determine if you -- should show a gear menu or not. -- This function will return False on Mac OS and a default app menu will -- be created automatically with the "usual" contents of that menu typical -- to most Mac OS applications. If you call Gtk.Application.Set_App_Menu -- anyway, then this menu will be replaced with your own. -- Since: gtk+ 3.14 procedure Remove_Accelerator (Self : not null access Gtk_Application_Record; Action_Name : UTF8_String; Parameter : Glib.Variant.Gvariant); pragma Obsolescent (Remove_Accelerator); -- Removes an accelerator that has been previously added with -- Gtk.Application.Add_Accelerator. -- Since: gtk+ 3.4 -- Deprecated since 3.14, 1 -- "action_name": the name of the action to activate -- "parameter": parameter to pass when activating the action, or null if -- the action does not accept an activation parameter procedure Remove_Window (Self : not null access Gtk_Application_Record; Window : not null access Gtk.Window.Gtk_Window_Record'Class); -- Remove a window from Application. -- If Window belongs to Application then this call is equivalent to -- setting the Gtk.Window.Gtk_Window:application property of Window to -- null. -- The application may stop running as a result of a call to this -- function. -- Since: gtk+ 3.0 -- "window": a Gtk.Window.Gtk_Window procedure Uninhibit (Self : not null access Gtk_Application_Record; Cookie : Guint); -- Removes an inhibitor that has been established with -- Gtk.Application.Inhibit. Inhibitors are also cleared when the -- application exits. -- Since: gtk+ 3.4 -- "cookie": a cookie that was returned by Gtk.Application.Inhibit --------------------------------------------- -- Inherited subprograms (from interfaces) -- --------------------------------------------- procedure Action_Added (Self : not null access Gtk_Application_Record; Action_Name : UTF8_String); procedure Action_Enabled_Changed (Self : not null access Gtk_Application_Record; Action_Name : UTF8_String; Enabled : Boolean); procedure Action_Removed (Self : not null access Gtk_Application_Record; Action_Name : UTF8_String); procedure Action_State_Changed (Self : not null access Gtk_Application_Record; Action_Name : UTF8_String; State : Glib.Variant.Gvariant); procedure Activate_Action (Self : not null access Gtk_Application_Record; Action_Name : UTF8_String; Parameter : Glib.Variant.Gvariant); procedure Change_Action_State (Self : not null access Gtk_Application_Record; Action_Name : UTF8_String; Value : Glib.Variant.Gvariant); function Get_Action_Enabled (Self : not null access Gtk_Application_Record; Action_Name : UTF8_String) return Boolean; function Get_Action_Parameter_Type (Self : not null access Gtk_Application_Record; Action_Name : UTF8_String) return Glib.Variant.Gvariant_Type; function Get_Action_State (Self : not null access Gtk_Application_Record; Action_Name : UTF8_String) return Glib.Variant.Gvariant; function Get_Action_State_Hint (Self : not null access Gtk_Application_Record; Action_Name : UTF8_String) return Glib.Variant.Gvariant; function Get_Action_State_Type (Self : not null access Gtk_Application_Record; Action_Name : UTF8_String) return Glib.Variant.Gvariant_Type; function Has_Action (Self : not null access Gtk_Application_Record; Action_Name : UTF8_String) return Boolean; function List_Actions (Self : not null access Gtk_Application_Record) return GNAT.Strings.String_List; function Query_Action (Self : not null access Gtk_Application_Record; Action_Name : UTF8_String; Enabled : access Boolean; Parameter_Type : access Glib.Variant.Gvariant_Type; State_Type : access Glib.Variant.Gvariant_Type; State_Hint : access Glib.Variant.Gvariant; State : access Glib.Variant.Gvariant) return Boolean; procedure Add_Action (Self : not null access Gtk_Application_Record; Action : Glib.Action.Gaction); procedure Add_Action_Entries (Self : not null access Gtk_Application_Record; Entries : GAction_Entry_Array; User_Data : System.Address := System.Null_Address); function Lookup_Action (Self : not null access Gtk_Application_Record; Action_Name : UTF8_String) return Glib.Action.Gaction; procedure Remove_Action (Self : not null access Gtk_Application_Record; Action_Name : UTF8_String); ---------------- -- Properties -- ---------------- -- The following properties are defined for this widget. See -- Glib.Properties for more information on properties) Active_Window_Property : constant Glib.Properties.Property_Object; -- Type: Gtk.Window.Gtk_Window App_Menu_Property : constant Glib.Properties.Property_Boxed; -- Type: Gio.Menu_Model Menubar_Property : constant Glib.Properties.Property_Boxed; -- Type: Gio.Menu_Model Register_Session_Property : constant Glib.Properties.Property_Boolean; -- Set this property to True to register with the session manager. Screensaver_Active_Property : constant Glib.Properties.Property_Boolean; -- This property is True if GTK+ believes that the screensaver is -- currently active. GTK+ only tracks session state (including this) when -- Gtk.Application.Gtk_Application::register-session is set to True. -- -- Tracking the screensaver state is supported on Linux. ------------- -- Signals -- ------------- type Cb_Gtk_Application_Void is not null access procedure (Self : access Gtk_Application_Record'Class); type Cb_GObject_Void is not null access procedure (Self : access Glib.Object.GObject_Record'Class); Signal_Query_End : constant Glib.Signal_Name := "query-end"; procedure On_Query_End (Self : not null access Gtk_Application_Record; Call : Cb_Gtk_Application_Void; After : Boolean := False); procedure On_Query_End (Self : not null access Gtk_Application_Record; Call : Cb_GObject_Void; Slot : not null access Glib.Object.GObject_Record'Class; After : Boolean := False); -- Emitted when the session manager is about to end the session, only if -- Gtk.Application.Gtk_Application::register-session is True. Applications -- can connect to this signal and call Gtk.Application.Inhibit with -- Gtk.Application.Application_Inhibit_Logout to delay the end of the -- session until state has been saved. type Cb_Gtk_Application_Gtk_Window_Void is not null access procedure (Self : access Gtk_Application_Record'Class; Window : not null access Gtk.Window.Gtk_Window_Record'Class); type Cb_GObject_Gtk_Window_Void is not null access procedure (Self : access Glib.Object.GObject_Record'Class; Window : not null access Gtk.Window.Gtk_Window_Record'Class); Signal_Window_Added : constant Glib.Signal_Name := "window-added"; procedure On_Window_Added (Self : not null access Gtk_Application_Record; Call : Cb_Gtk_Application_Gtk_Window_Void; After : Boolean := False); procedure On_Window_Added (Self : not null access Gtk_Application_Record; Call : Cb_GObject_Gtk_Window_Void; Slot : not null access Glib.Object.GObject_Record'Class; After : Boolean := False); -- Emitted when a Gtk.Window.Gtk_Window is added to Application through -- Gtk.Application.Add_Window. Signal_Window_Removed : constant Glib.Signal_Name := "window-removed"; procedure On_Window_Removed (Self : not null access Gtk_Application_Record; Call : Cb_Gtk_Application_Gtk_Window_Void; After : Boolean := False); procedure On_Window_Removed (Self : not null access Gtk_Application_Record; Call : Cb_GObject_Gtk_Window_Void; Slot : not null access Glib.Object.GObject_Record'Class; After : Boolean := False); -- Emitted when a Gtk.Window.Gtk_Window is removed from Application, -- either as a side-effect of being destroyed or explicitly through -- Gtk.Application.Remove_Window. ---------------- -- Interfaces -- ---------------- -- This class implements several interfaces. See Glib.Types -- -- - "Gio.ActionGroup" -- -- - "Gio.ActionMap" package Implements_Gaction_Group is new Glib.Types.Implements (Glib.Action_Group.Gaction_Group, Gtk_Application_Record, Gtk_Application); function "+" (Widget : access Gtk_Application_Record'Class) return Glib.Action_Group.Gaction_Group renames Implements_Gaction_Group.To_Interface; function "-" (Interf : Glib.Action_Group.Gaction_Group) return Gtk_Application renames Implements_Gaction_Group.To_Object; package Implements_Gaction_Map is new Glib.Types.Implements (Glib.Action_Map.Gaction_Map, Gtk_Application_Record, Gtk_Application); function "+" (Widget : access Gtk_Application_Record'Class) return Glib.Action_Map.Gaction_Map renames Implements_Gaction_Map.To_Interface; function "-" (Interf : Glib.Action_Map.Gaction_Map) return Gtk_Application renames Implements_Gaction_Map.To_Object; private Screensaver_Active_Property : constant Glib.Properties.Property_Boolean := Glib.Properties.Build ("screensaver-active"); Register_Session_Property : constant Glib.Properties.Property_Boolean := Glib.Properties.Build ("register-session"); Menubar_Property : constant Glib.Properties.Property_Boxed := Glib.Properties.Build ("menubar"); App_Menu_Property : constant Glib.Properties.Property_Boxed := Glib.Properties.Build ("app-menu"); Active_Window_Property : constant Glib.Properties.Property_Object := Glib.Properties.Build ("active-window"); end Gtk.Application; gtkada-24.0.0/src/generated/gtk-application_window.adb000066400000000000000000000466471446021174000227220ustar00rootroot00000000000000------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ pragma Style_Checks (Off); pragma Warnings (Off, "*is already use-visible*"); with Glib.Type_Conversion_Hooks; use Glib.Type_Conversion_Hooks; pragma Warnings(Off); -- might be unused with Gtkada.Bindings; use Gtkada.Bindings; with Gtkada.Types; use Gtkada.Types; pragma Warnings(On); package body Gtk.Application_Window is package Type_Conversion_Gtk_Application_Window is new Glib.Type_Conversion_Hooks.Hook_Registrator (Get_Type'Access, Gtk_Application_Window_Record); pragma Unreferenced (Type_Conversion_Gtk_Application_Window); -------------------------------- -- Gtk_Application_Window_New -- -------------------------------- function Gtk_Application_Window_New (Application : not null access Gtk.Application.Gtk_Application_Record'Class) return Gtk_Application_Window is Self : constant Gtk_Application_Window := new Gtk_Application_Window_Record; begin Gtk.Application_Window.Initialize (Self, Application); return Self; end Gtk_Application_Window_New; ------------- -- Gtk_New -- ------------- procedure Gtk_New (Self : out Gtk_Application_Window; Application : not null access Gtk.Application.Gtk_Application_Record'Class) is begin Self := new Gtk_Application_Window_Record; Gtk.Application_Window.Initialize (Self, Application); end Gtk_New; ---------------- -- Initialize -- ---------------- procedure Initialize (Self : not null access Gtk_Application_Window_Record'Class; Application : not null access Gtk.Application.Gtk_Application_Record'Class) is function Internal (Application : System.Address) return System.Address; pragma Import (C, Internal, "gtk_application_window_new"); begin if not Self.Is_Created then Set_Object (Self, Internal (Get_Object (Application))); end if; end Initialize; ---------------------- -- Get_Help_Overlay -- ---------------------- function Get_Help_Overlay (Self : not null access Gtk_Application_Window_Record) return Gtk.Shortcuts_Window.Gtk_Shortcuts_Window is function Internal (Self : System.Address) return System.Address; pragma Import (C, Internal, "gtk_application_window_get_help_overlay"); Stub_Gtk_Shortcuts_Window : Gtk.Shortcuts_Window.Gtk_Shortcuts_Window_Record; begin return Gtk.Shortcuts_Window.Gtk_Shortcuts_Window (Get_User_Data (Internal (Get_Object (Self)), Stub_Gtk_Shortcuts_Window)); end Get_Help_Overlay; ------------ -- Get_Id -- ------------ function Get_Id (Self : not null access Gtk_Application_Window_Record) return Guint is function Internal (Self : System.Address) return Guint; pragma Import (C, Internal, "gtk_application_window_get_id"); begin return Internal (Get_Object (Self)); end Get_Id; ---------------------- -- Get_Show_Menubar -- ---------------------- function Get_Show_Menubar (Self : not null access Gtk_Application_Window_Record) return Boolean is function Internal (Self : System.Address) return Glib.Gboolean; pragma Import (C, Internal, "gtk_application_window_get_show_menubar"); begin return Internal (Get_Object (Self)) /= 0; end Get_Show_Menubar; ---------------------- -- Set_Help_Overlay -- ---------------------- procedure Set_Help_Overlay (Self : not null access Gtk_Application_Window_Record; Help_Overlay : access Gtk.Shortcuts_Window.Gtk_Shortcuts_Window_Record'Class) is procedure Internal (Self : System.Address; Help_Overlay : System.Address); pragma Import (C, Internal, "gtk_application_window_set_help_overlay"); begin Internal (Get_Object (Self), Get_Object_Or_Null (GObject (Help_Overlay))); end Set_Help_Overlay; ---------------------- -- Set_Show_Menubar -- ---------------------- procedure Set_Show_Menubar (Self : not null access Gtk_Application_Window_Record; Show_Menubar : Boolean) is procedure Internal (Self : System.Address; Show_Menubar : Glib.Gboolean); pragma Import (C, Internal, "gtk_application_window_set_show_menubar"); begin Internal (Get_Object (Self), Boolean'Pos (Show_Menubar)); end Set_Show_Menubar; ------------------ -- Action_Added -- ------------------ procedure Action_Added (Self : not null access Gtk_Application_Window_Record; Action_Name : UTF8_String) is procedure Internal (Self : System.Address; Action_Name : Gtkada.Types.Chars_Ptr); pragma Import (C, Internal, "g_action_group_action_added"); Tmp_Action_Name : Gtkada.Types.Chars_Ptr := New_String (Action_Name); begin Internal (Get_Object (Self), Tmp_Action_Name); Free (Tmp_Action_Name); end Action_Added; ---------------------------- -- Action_Enabled_Changed -- ---------------------------- procedure Action_Enabled_Changed (Self : not null access Gtk_Application_Window_Record; Action_Name : UTF8_String; Enabled : Boolean) is procedure Internal (Self : System.Address; Action_Name : Gtkada.Types.Chars_Ptr; Enabled : Glib.Gboolean); pragma Import (C, Internal, "g_action_group_action_enabled_changed"); Tmp_Action_Name : Gtkada.Types.Chars_Ptr := New_String (Action_Name); begin Internal (Get_Object (Self), Tmp_Action_Name, Boolean'Pos (Enabled)); Free (Tmp_Action_Name); end Action_Enabled_Changed; -------------------- -- Action_Removed -- -------------------- procedure Action_Removed (Self : not null access Gtk_Application_Window_Record; Action_Name : UTF8_String) is procedure Internal (Self : System.Address; Action_Name : Gtkada.Types.Chars_Ptr); pragma Import (C, Internal, "g_action_group_action_removed"); Tmp_Action_Name : Gtkada.Types.Chars_Ptr := New_String (Action_Name); begin Internal (Get_Object (Self), Tmp_Action_Name); Free (Tmp_Action_Name); end Action_Removed; -------------------------- -- Action_State_Changed -- -------------------------- procedure Action_State_Changed (Self : not null access Gtk_Application_Window_Record; Action_Name : UTF8_String; State : Glib.Variant.Gvariant) is procedure Internal (Self : System.Address; Action_Name : Gtkada.Types.Chars_Ptr; State : System.Address); pragma Import (C, Internal, "g_action_group_action_state_changed"); Tmp_Action_Name : Gtkada.Types.Chars_Ptr := New_String (Action_Name); begin Internal (Get_Object (Self), Tmp_Action_Name, Get_Object (State)); Free (Tmp_Action_Name); end Action_State_Changed; --------------------- -- Activate_Action -- --------------------- procedure Activate_Action (Self : not null access Gtk_Application_Window_Record; Action_Name : UTF8_String; Parameter : Glib.Variant.Gvariant) is procedure Internal (Self : System.Address; Action_Name : Gtkada.Types.Chars_Ptr; Parameter : System.Address); pragma Import (C, Internal, "g_action_group_activate_action"); Tmp_Action_Name : Gtkada.Types.Chars_Ptr := New_String (Action_Name); begin Internal (Get_Object (Self), Tmp_Action_Name, Get_Object (Parameter)); Free (Tmp_Action_Name); end Activate_Action; ---------------- -- Add_Action -- ---------------- procedure Add_Action (Self : not null access Gtk_Application_Window_Record; Action : Glib.Action.Gaction) is procedure Internal (Self : System.Address; Action : Glib.Action.Gaction); pragma Import (C, Internal, "g_action_map_add_action"); begin Internal (Get_Object (Self), Action); end Add_Action; ------------------------ -- Add_Action_Entries -- ------------------------ procedure Add_Action_Entries (Self : not null access Gtk_Application_Window_Record; Entries : GAction_Entry_Array; User_Data : System.Address := System.Null_Address) is procedure Internal (Self : System.Address; Entries : GAction_Entry_Array; N_Entries : Glib.Gint; User_Data : System.Address); pragma Import (C, Internal, "g_action_map_add_action_entries"); begin Internal (Get_Object (Self), Entries, Entries'Length, User_Data); end Add_Action_Entries; ------------------------- -- Change_Action_State -- ------------------------- procedure Change_Action_State (Self : not null access Gtk_Application_Window_Record; Action_Name : UTF8_String; Value : Glib.Variant.Gvariant) is procedure Internal (Self : System.Address; Action_Name : Gtkada.Types.Chars_Ptr; Value : System.Address); pragma Import (C, Internal, "g_action_group_change_action_state"); Tmp_Action_Name : Gtkada.Types.Chars_Ptr := New_String (Action_Name); begin Internal (Get_Object (Self), Tmp_Action_Name, Get_Object (Value)); Free (Tmp_Action_Name); end Change_Action_State; ------------------------ -- Get_Action_Enabled -- ------------------------ function Get_Action_Enabled (Self : not null access Gtk_Application_Window_Record; Action_Name : UTF8_String) return Boolean is function Internal (Self : System.Address; Action_Name : Gtkada.Types.Chars_Ptr) return Glib.Gboolean; pragma Import (C, Internal, "g_action_group_get_action_enabled"); Tmp_Action_Name : Gtkada.Types.Chars_Ptr := New_String (Action_Name); Tmp_Return : Glib.Gboolean; begin Tmp_Return := Internal (Get_Object (Self), Tmp_Action_Name); Free (Tmp_Action_Name); return Tmp_Return /= 0; end Get_Action_Enabled; ------------------------------- -- Get_Action_Parameter_Type -- ------------------------------- function Get_Action_Parameter_Type (Self : not null access Gtk_Application_Window_Record; Action_Name : UTF8_String) return Glib.Variant.Gvariant_Type is function Internal (Self : System.Address; Action_Name : Gtkada.Types.Chars_Ptr) return Glib.Variant.Gvariant_Type; pragma Import (C, Internal, "g_action_group_get_action_parameter_type"); Tmp_Action_Name : Gtkada.Types.Chars_Ptr := New_String (Action_Name); Tmp_Return : Glib.Variant.Gvariant_Type; begin Tmp_Return := Internal (Get_Object (Self), Tmp_Action_Name); Free (Tmp_Action_Name); return Tmp_Return; end Get_Action_Parameter_Type; ---------------------- -- Get_Action_State -- ---------------------- function Get_Action_State (Self : not null access Gtk_Application_Window_Record; Action_Name : UTF8_String) return Glib.Variant.Gvariant is function Internal (Self : System.Address; Action_Name : Gtkada.Types.Chars_Ptr) return System.Address; pragma Import (C, Internal, "g_action_group_get_action_state"); Tmp_Action_Name : Gtkada.Types.Chars_Ptr := New_String (Action_Name); Tmp_Return : System.Address; begin Tmp_Return := Internal (Get_Object (Self), Tmp_Action_Name); Free (Tmp_Action_Name); return From_Object (Tmp_Return); end Get_Action_State; --------------------------- -- Get_Action_State_Hint -- --------------------------- function Get_Action_State_Hint (Self : not null access Gtk_Application_Window_Record; Action_Name : UTF8_String) return Glib.Variant.Gvariant is function Internal (Self : System.Address; Action_Name : Gtkada.Types.Chars_Ptr) return System.Address; pragma Import (C, Internal, "g_action_group_get_action_state_hint"); Tmp_Action_Name : Gtkada.Types.Chars_Ptr := New_String (Action_Name); Tmp_Return : System.Address; begin Tmp_Return := Internal (Get_Object (Self), Tmp_Action_Name); Free (Tmp_Action_Name); return From_Object (Tmp_Return); end Get_Action_State_Hint; --------------------------- -- Get_Action_State_Type -- --------------------------- function Get_Action_State_Type (Self : not null access Gtk_Application_Window_Record; Action_Name : UTF8_String) return Glib.Variant.Gvariant_Type is function Internal (Self : System.Address; Action_Name : Gtkada.Types.Chars_Ptr) return Glib.Variant.Gvariant_Type; pragma Import (C, Internal, "g_action_group_get_action_state_type"); Tmp_Action_Name : Gtkada.Types.Chars_Ptr := New_String (Action_Name); Tmp_Return : Glib.Variant.Gvariant_Type; begin Tmp_Return := Internal (Get_Object (Self), Tmp_Action_Name); Free (Tmp_Action_Name); return Tmp_Return; end Get_Action_State_Type; ---------------- -- Has_Action -- ---------------- function Has_Action (Self : not null access Gtk_Application_Window_Record; Action_Name : UTF8_String) return Boolean is function Internal (Self : System.Address; Action_Name : Gtkada.Types.Chars_Ptr) return Glib.Gboolean; pragma Import (C, Internal, "g_action_group_has_action"); Tmp_Action_Name : Gtkada.Types.Chars_Ptr := New_String (Action_Name); Tmp_Return : Glib.Gboolean; begin Tmp_Return := Internal (Get_Object (Self), Tmp_Action_Name); Free (Tmp_Action_Name); return Tmp_Return /= 0; end Has_Action; ------------------ -- List_Actions -- ------------------ function List_Actions (Self : not null access Gtk_Application_Window_Record) return GNAT.Strings.String_List is function Internal (Self : System.Address) return chars_ptr_array_access; pragma Import (C, Internal, "g_action_group_list_actions"); begin return To_String_List_And_Free (Internal (Get_Object (Self))); end List_Actions; ------------------- -- Lookup_Action -- ------------------- function Lookup_Action (Self : not null access Gtk_Application_Window_Record; Action_Name : UTF8_String) return Glib.Action.Gaction is function Internal (Self : System.Address; Action_Name : Gtkada.Types.Chars_Ptr) return Glib.Action.Gaction; pragma Import (C, Internal, "g_action_map_lookup_action"); Tmp_Action_Name : Gtkada.Types.Chars_Ptr := New_String (Action_Name); Tmp_Return : Glib.Action.Gaction; begin Tmp_Return := Internal (Get_Object (Self), Tmp_Action_Name); Free (Tmp_Action_Name); return Tmp_Return; end Lookup_Action; ------------------ -- Query_Action -- ------------------ function Query_Action (Self : not null access Gtk_Application_Window_Record; Action_Name : UTF8_String; Enabled : access Boolean; Parameter_Type : access Glib.Variant.Gvariant_Type; State_Type : access Glib.Variant.Gvariant_Type; State_Hint : access Glib.Variant.Gvariant; State : access Glib.Variant.Gvariant) return Boolean is function Internal (Self : System.Address; Action_Name : Gtkada.Types.Chars_Ptr; Acc_Enabled : access Glib.Gboolean; Acc_Parameter_Type : access Glib.Variant.Gvariant_Type; Acc_State_Type : access Glib.Variant.Gvariant_Type; Acc_State_Hint : access System.Address; Acc_State : access System.Address) return Glib.Gboolean; pragma Import (C, Internal, "g_action_group_query_action"); Acc_Enabled : aliased Boolean; Acc_Parameter_Type : aliased Glib.Variant.Gvariant_Type; Acc_State_Type : aliased Glib.Variant.Gvariant_Type; Acc_State_Hint : aliased Glib.Variant.Gvariant; Acc_State : aliased Glib.Variant.Gvariant; Tmp_Action_Name : Gtkada.Types.Chars_Ptr := New_String (Action_Name); Tmp_Acc_Enabled : aliased Glib.Gboolean; Tmp_Acc_State_Hint : aliased System.Address; Tmp_Acc_State : aliased System.Address; Tmp_Return : Glib.Gboolean; begin Tmp_Return := Internal (Get_Object (Self), Tmp_Action_Name, Tmp_Acc_Enabled'Access, Acc_Parameter_Type'Access, Acc_State_Type'Access, Tmp_Acc_State_Hint'Access, Tmp_Acc_State'Access); Acc_State := From_Object (Tmp_Acc_State); Acc_State_Hint := From_Object (Tmp_Acc_State_Hint); Acc_Enabled := Tmp_Acc_Enabled /= 0; Free (Tmp_Action_Name); Enabled.all := Acc_Enabled; if Parameter_Type /= null then Parameter_Type.all := Acc_Parameter_Type; end if; if State_Type /= null then State_Type.all := Acc_State_Type; end if; if State_Hint /= null then State_Hint.all := Acc_State_Hint; end if; if State /= null then State.all := Acc_State; end if; return Tmp_Return /= 0; end Query_Action; ------------------- -- Remove_Action -- ------------------- procedure Remove_Action (Self : not null access Gtk_Application_Window_Record; Action_Name : UTF8_String) is procedure Internal (Self : System.Address; Action_Name : Gtkada.Types.Chars_Ptr); pragma Import (C, Internal, "g_action_map_remove_action"); Tmp_Action_Name : Gtkada.Types.Chars_Ptr := New_String (Action_Name); begin Internal (Get_Object (Self), Tmp_Action_Name); Free (Tmp_Action_Name); end Remove_Action; end Gtk.Application_Window; gtkada-24.0.0/src/generated/gtk-application_window.ads000066400000000000000000000377001446021174000227310ustar00rootroot00000000000000------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ -- -- Gtk.Application_Window.Gtk_Application_Window is a Gtk.Window.Gtk_Window -- subclass that offers some extra functionality for better integration with -- Gtk.Application.Gtk_Application features. Notably, it can handle both the -- application menu as well as the menubar. See Gtk.Application.Set_App_Menu -- and Gtk.Application.Set_Menubar. -- -- This class implements the Glib.Action_Group.Gaction_Group and -- Glib.Action_Map.Gaction_Map interfaces, to let you add window-specific -- actions that will be exported by the associated -- Gtk.Application.Gtk_Application, together with its application-wide -- actions. Window-specific actions are prefixed with the "win." prefix and -- application-wide actions are prefixed with the "app." prefix. Actions must -- be addressed with the prefixed name when referring to them from a -- Glib.Menu_Model.Gmenu_Model. -- -- Note that widgets that are placed inside a -- Gtk.Application_Window.Gtk_Application_Window can also activate these -- actions, if they implement the Gtk.Actionable.Gtk_Actionable interface. -- -- As with Gtk.Application.Gtk_Application, the GDK lock will be acquired -- when processing actions arriving from other processes and should therefore -- be held when activating actions locally (if GDK threads are enabled). -- -- The settings Gtk.Settings.Gtk_Settings:gtk-shell-shows-app-menu and -- Gtk.Settings.Gtk_Settings:gtk-shell-shows-menubar tell GTK+ whether the -- desktop environment is showing the application menu and menubar models -- outside the application as part of the desktop shell. For instance, on OS -- X, both menus will be displayed remotely; on Windows neither will be. -- gnome-shell (starting with version 3.4) will display the application menu, -- but not the menubar. -- -- If the desktop environment does not display the menubar, then -- Gtk.Application_Window.Gtk_Application_Window will automatically show a -- Gtk.Menu_Bar.Gtk_Menu_Bar for it. This behaviour can be overridden with the -- Gtk.Application_Window.Gtk_Application_Window:show-menubar property. If the -- desktop environment does not display the application menu, then it will -- automatically be included in the menubar or in the windows client-side -- decorations. -- -- ## A GtkApplicationWindow with a menubar -- -- |[ GtkApplication *app = gtk_application_new -- ("org.gtk.test", 0); -- -- GtkBuilder *builder = gtk_builder_new_from_string ( "" " " " " " " " " " -- " " " "", -1); -- -- GMenuModel *menubar = G_MENU_MODEL (gtk_builder_get_object (builder, -- "menubar")); gtk_application_set_menubar (GTK_APPLICATION (app), menubar); -- g_object_unref (builder); -- -- // ... -- -- GtkWidget *window = gtk_application_window_new (app); ]| -- -- ## Handling fallback yourself -- -- [A simple -- example](https://git.gnome.org/browse/gtk+/tree/examples/sunny.c) -- -- The XML format understood by Gtk.Builder.Gtk_Builder for -- Glib.Menu_Model.Gmenu_Model consists of a toplevel `` element, which -- contains one or more `` elements. Each `` element contains -- `` and `` elements with a mandatory name attribute. -- `` elements have the same content model as ``. Instead of -- ``, you can use `` -- or `
    ` elements. -- -- Attribute values can be translated using gettext, like other -- Gtk.Builder.Gtk_Builder content. `` elements can be marked for -- translation with a `translatable="yes"` attribute. It is also possible to -- specify message context and translator comments, using the context and -- comments attributes. To make use of this, the Gtk.Builder.Gtk_Builder must -- have been given the gettext domain to use. -- -- The following attributes are used when constructing menu items: - "label": -- a user-visible string to display - "action": the prefixed name of the -- action to trigger - "target": the parameter to use when activating the -- action - "icon" and "verb-icon": names of icons that may be displayed - -- "submenu-action": name of an action that may be used to determine if a -- submenu can be opened - "hidden-when": a string used to determine when the -- item will be hidden. Possible values include "action-disabled", -- "action-missing", "macos-menubar". -- -- The following attributes are used when constructing sections: - "label": a -- user-visible string to use as section heading - "display-hint": a string -- used to determine special formatting for the section. Possible values -- include "horizontal-buttons". - "text-direction": a string used to -- determine the Gtk.Enums.Gtk_Text_Direction to use when "display-hint" is -- set to "horizontal-buttons". Possible values include "rtl", "ltr", and -- "none". -- -- The following attributes are used when constructing submenus: - "label": a -- user-visible string to display - "icon": icon name to display -- -- pragma Warnings (Off, "*is already use-visible*"); with GNAT.Strings; use GNAT.Strings; with Glib; use Glib; with Glib.Action; use Glib.Action; with Glib.Action_Group; use Glib.Action_Group; with Glib.Action_Map; use Glib.Action_Map; with Glib.Properties; use Glib.Properties; with Glib.Types; use Glib.Types; with Glib.Variant; use Glib.Variant; with Gtk.Application; use Gtk.Application; with Gtk.Buildable; use Gtk.Buildable; with Gtk.Shortcuts_Window; use Gtk.Shortcuts_Window; with Gtk.Window; use Gtk.Window; package Gtk.Application_Window is type Gtk_Application_Window_Record is new Gtk_Window_Record with null record; type Gtk_Application_Window is access all Gtk_Application_Window_Record'Class; ------------------ -- Constructors -- ------------------ procedure Gtk_New (Self : out Gtk_Application_Window; Application : not null access Gtk.Application.Gtk_Application_Record'Class); procedure Initialize (Self : not null access Gtk_Application_Window_Record'Class; Application : not null access Gtk.Application.Gtk_Application_Record'Class); -- Creates a new Gtk.Application_Window.Gtk_Application_Window. -- Since: gtk+ 3.4 -- Initialize does nothing if the object was already created with another -- call to Initialize* or G_New. -- "application": a Gtk.Application.Gtk_Application function Gtk_Application_Window_New (Application : not null access Gtk.Application.Gtk_Application_Record'Class) return Gtk_Application_Window; -- Creates a new Gtk.Application_Window.Gtk_Application_Window. -- Since: gtk+ 3.4 -- "application": a Gtk.Application.Gtk_Application function Get_Type return Glib.GType; pragma Import (C, Get_Type, "gtk_application_window_get_type"); ------------- -- Methods -- ------------- function Get_Help_Overlay (Self : not null access Gtk_Application_Window_Record) return Gtk.Shortcuts_Window.Gtk_Shortcuts_Window; -- Gets the Gtk.Shortcuts_Window.Gtk_Shortcuts_Window that has been set up -- with a prior call to Gtk.Application_Window.Set_Help_Overlay. -- Since: gtk+ 3.20 procedure Set_Help_Overlay (Self : not null access Gtk_Application_Window_Record; Help_Overlay : access Gtk.Shortcuts_Window.Gtk_Shortcuts_Window_Record'Class); -- Associates a shortcuts window with the application window, and sets up -- an action with the name win.show-help-overlay to present it. -- Window takes resposibility for destroying Help_Overlay. -- Since: gtk+ 3.20 -- "help_overlay": a Gtk.Shortcuts_Window.Gtk_Shortcuts_Window function Get_Id (Self : not null access Gtk_Application_Window_Record) return Guint; -- Returns the unique ID of the window. If the window has not yet been -- added to a Gtk.Application.Gtk_Application, returns `0`. -- Since: gtk+ 3.6 function Get_Show_Menubar (Self : not null access Gtk_Application_Window_Record) return Boolean; -- Returns whether the window will display a menubar for the app menu and -- menubar as needed. -- Since: gtk+ 3.4 procedure Set_Show_Menubar (Self : not null access Gtk_Application_Window_Record; Show_Menubar : Boolean); -- Sets whether the window will display a menubar for the app menu and -- menubar as needed. -- Since: gtk+ 3.4 -- "show_menubar": whether to show a menubar when needed --------------------------------------------- -- Inherited subprograms (from interfaces) -- --------------------------------------------- -- Methods inherited from the Buildable interface are not duplicated here -- since they are meant to be used by tools, mostly. If you need to call -- them, use an explicit cast through the "-" operator below. procedure Action_Added (Self : not null access Gtk_Application_Window_Record; Action_Name : UTF8_String); procedure Action_Enabled_Changed (Self : not null access Gtk_Application_Window_Record; Action_Name : UTF8_String; Enabled : Boolean); procedure Action_Removed (Self : not null access Gtk_Application_Window_Record; Action_Name : UTF8_String); procedure Action_State_Changed (Self : not null access Gtk_Application_Window_Record; Action_Name : UTF8_String; State : Glib.Variant.Gvariant); procedure Activate_Action (Self : not null access Gtk_Application_Window_Record; Action_Name : UTF8_String; Parameter : Glib.Variant.Gvariant); procedure Change_Action_State (Self : not null access Gtk_Application_Window_Record; Action_Name : UTF8_String; Value : Glib.Variant.Gvariant); function Get_Action_Enabled (Self : not null access Gtk_Application_Window_Record; Action_Name : UTF8_String) return Boolean; function Get_Action_Parameter_Type (Self : not null access Gtk_Application_Window_Record; Action_Name : UTF8_String) return Glib.Variant.Gvariant_Type; function Get_Action_State (Self : not null access Gtk_Application_Window_Record; Action_Name : UTF8_String) return Glib.Variant.Gvariant; function Get_Action_State_Hint (Self : not null access Gtk_Application_Window_Record; Action_Name : UTF8_String) return Glib.Variant.Gvariant; function Get_Action_State_Type (Self : not null access Gtk_Application_Window_Record; Action_Name : UTF8_String) return Glib.Variant.Gvariant_Type; function Has_Action (Self : not null access Gtk_Application_Window_Record; Action_Name : UTF8_String) return Boolean; function List_Actions (Self : not null access Gtk_Application_Window_Record) return GNAT.Strings.String_List; function Query_Action (Self : not null access Gtk_Application_Window_Record; Action_Name : UTF8_String; Enabled : access Boolean; Parameter_Type : access Glib.Variant.Gvariant_Type; State_Type : access Glib.Variant.Gvariant_Type; State_Hint : access Glib.Variant.Gvariant; State : access Glib.Variant.Gvariant) return Boolean; procedure Add_Action (Self : not null access Gtk_Application_Window_Record; Action : Glib.Action.Gaction); procedure Add_Action_Entries (Self : not null access Gtk_Application_Window_Record; Entries : GAction_Entry_Array; User_Data : System.Address := System.Null_Address); function Lookup_Action (Self : not null access Gtk_Application_Window_Record; Action_Name : UTF8_String) return Glib.Action.Gaction; procedure Remove_Action (Self : not null access Gtk_Application_Window_Record; Action_Name : UTF8_String); ---------------- -- Properties -- ---------------- -- The following properties are defined for this widget. See -- Glib.Properties for more information on properties) Show_Menubar_Property : constant Glib.Properties.Property_Boolean; -- If this property is True, the window will display a menubar that -- includes the app menu and menubar, unless these are shown by the desktop -- shell. See Gtk.Application.Set_App_Menu and Gtk.Application.Set_Menubar. -- -- If False, the window will not display a menubar, regardless of whether -- the desktop shell is showing the menus or not. ---------------- -- Interfaces -- ---------------- -- This class implements several interfaces. See Glib.Types -- -- - "Buildable" -- -- - "Gio.ActionGroup" -- -- - "Gio.ActionMap" package Implements_Gtk_Buildable is new Glib.Types.Implements (Gtk.Buildable.Gtk_Buildable, Gtk_Application_Window_Record, Gtk_Application_Window); function "+" (Widget : access Gtk_Application_Window_Record'Class) return Gtk.Buildable.Gtk_Buildable renames Implements_Gtk_Buildable.To_Interface; function "-" (Interf : Gtk.Buildable.Gtk_Buildable) return Gtk_Application_Window renames Implements_Gtk_Buildable.To_Object; package Implements_Gaction_Group is new Glib.Types.Implements (Glib.Action_Group.Gaction_Group, Gtk_Application_Window_Record, Gtk_Application_Window); function "+" (Widget : access Gtk_Application_Window_Record'Class) return Glib.Action_Group.Gaction_Group renames Implements_Gaction_Group.To_Interface; function "-" (Interf : Glib.Action_Group.Gaction_Group) return Gtk_Application_Window renames Implements_Gaction_Group.To_Object; package Implements_Gaction_Map is new Glib.Types.Implements (Glib.Action_Map.Gaction_Map, Gtk_Application_Window_Record, Gtk_Application_Window); function "+" (Widget : access Gtk_Application_Window_Record'Class) return Glib.Action_Map.Gaction_Map renames Implements_Gaction_Map.To_Interface; function "-" (Interf : Glib.Action_Map.Gaction_Map) return Gtk_Application_Window renames Implements_Gaction_Map.To_Object; private Show_Menubar_Property : constant Glib.Properties.Property_Boolean := Glib.Properties.Build ("show-menubar"); end Gtk.Application_Window; gtkada-24.0.0/src/generated/gtk-arrow.adb000066400000000000000000000075351446021174000201530ustar00rootroot00000000000000------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ pragma Style_Checks (Off); pragma Warnings (Off, "*is already use-visible*"); with Glib.Type_Conversion_Hooks; use Glib.Type_Conversion_Hooks; package body Gtk.Arrow is package Type_Conversion_Gtk_Arrow is new Glib.Type_Conversion_Hooks.Hook_Registrator (Get_Type'Access, Gtk_Arrow_Record); pragma Unreferenced (Type_Conversion_Gtk_Arrow); ------------------- -- Gtk_Arrow_New -- ------------------- function Gtk_Arrow_New (Arrow_Type : Gtk.Enums.Gtk_Arrow_Type; Shadow_Type : Gtk.Enums.Gtk_Shadow_Type) return Gtk_Arrow is Arrow : constant Gtk_Arrow := new Gtk_Arrow_Record; begin Gtk.Arrow.Initialize (Arrow, Arrow_Type, Shadow_Type); return Arrow; end Gtk_Arrow_New; ------------- -- Gtk_New -- ------------- procedure Gtk_New (Arrow : out Gtk_Arrow; Arrow_Type : Gtk.Enums.Gtk_Arrow_Type; Shadow_Type : Gtk.Enums.Gtk_Shadow_Type) is begin Arrow := new Gtk_Arrow_Record; Gtk.Arrow.Initialize (Arrow, Arrow_Type, Shadow_Type); end Gtk_New; ---------------- -- Initialize -- ---------------- procedure Initialize (Arrow : not null access Gtk_Arrow_Record'Class; Arrow_Type : Gtk.Enums.Gtk_Arrow_Type; Shadow_Type : Gtk.Enums.Gtk_Shadow_Type) is function Internal (Arrow_Type : Gtk.Enums.Gtk_Arrow_Type; Shadow_Type : Gtk.Enums.Gtk_Shadow_Type) return System.Address; pragma Import (C, Internal, "gtk_arrow_new"); begin if not Arrow.Is_Created then Set_Object (Arrow, Internal (Arrow_Type, Shadow_Type)); end if; end Initialize; --------- -- Set -- --------- procedure Set (Arrow : not null access Gtk_Arrow_Record; Arrow_Type : Gtk.Enums.Gtk_Arrow_Type; Shadow_Type : Gtk.Enums.Gtk_Shadow_Type) is procedure Internal (Arrow : System.Address; Arrow_Type : Gtk.Enums.Gtk_Arrow_Type; Shadow_Type : Gtk.Enums.Gtk_Shadow_Type); pragma Import (C, Internal, "gtk_arrow_set"); begin Internal (Get_Object (Arrow), Arrow_Type, Shadow_Type); end Set; end Gtk.Arrow; gtkada-24.0.0/src/generated/gtk-arrow.ads000066400000000000000000000136351446021174000201720ustar00rootroot00000000000000------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ -- -- GtkArrow should be used to draw simple arrows that need to point in one of -- the four cardinal directions (up, down, left, or right). The style of the -- arrow can be one of shadow in, shadow out, etched in, or etched out. Note -- that these directions and style types may be amended in versions of GTK+ to -- come. -- -- GtkArrow will fill any space alloted to it, but since it is inherited from -- Gtk.Misc.Gtk_Misc, it can be padded and/or aligned, to fill exactly the -- space the programmer desires. -- -- Arrows are created with a call to Gtk.Arrow.Gtk_New. The direction or -- style of an arrow can be changed after creation by using Gtk.Arrow.Set. -- -- GtkArrow has been deprecated; you can simply use a Gtk.Image.Gtk_Image -- with a suitable icon name, such as "pan-down-symbolic". When replacing -- GtkArrow by an image, pay attention to the fact that GtkArrow is doing -- automatic flipping between GTK_ARROW_LEFT and GTK_ARROW_RIGHT, depending on -- the text direction. To get the same effect with an image, use the icon -- names "pan-start-symbolic" and "pan-end-symbolic", which react to the text -- direction. -- -- -- gtk-arrow -- create_arrow.adb pragma Warnings (Off, "*is already use-visible*"); with Glib; use Glib; with Glib.Types; use Glib.Types; with Gtk.Buildable; use Gtk.Buildable; with Gtk.Enums; use Gtk.Enums; with Gtk.Misc; use Gtk.Misc; package Gtk.Arrow is type Gtk_Arrow_Record is new Gtk_Misc_Record with null record; type Gtk_Arrow is access all Gtk_Arrow_Record'Class; ------------------ -- Constructors -- ------------------ procedure Gtk_New (Arrow : out Gtk_Arrow; Arrow_Type : Gtk.Enums.Gtk_Arrow_Type; Shadow_Type : Gtk.Enums.Gtk_Shadow_Type); procedure Initialize (Arrow : not null access Gtk_Arrow_Record'Class; Arrow_Type : Gtk.Enums.Gtk_Arrow_Type; Shadow_Type : Gtk.Enums.Gtk_Shadow_Type); -- Creates a new Gtk.Arrow.Gtk_Arrow widget. -- Initialize does nothing if the object was already created with another -- call to Initialize* or G_New. -- "arrow_type": a valid Gtk.Enums.Gtk_Arrow_Type. -- "shadow_type": a valid Gtk.Enums.Gtk_Shadow_Type. function Gtk_Arrow_New (Arrow_Type : Gtk.Enums.Gtk_Arrow_Type; Shadow_Type : Gtk.Enums.Gtk_Shadow_Type) return Gtk_Arrow; -- Creates a new Gtk.Arrow.Gtk_Arrow widget. -- "arrow_type": a valid Gtk.Enums.Gtk_Arrow_Type. -- "shadow_type": a valid Gtk.Enums.Gtk_Shadow_Type. function Get_Type return Glib.GType; pragma Import (C, Get_Type, "gtk_arrow_get_type"); ------------- -- Methods -- ------------- procedure Set (Arrow : not null access Gtk_Arrow_Record; Arrow_Type : Gtk.Enums.Gtk_Arrow_Type; Shadow_Type : Gtk.Enums.Gtk_Shadow_Type); pragma Obsolescent (Set); -- Sets the direction and style of the Gtk.Arrow.Gtk_Arrow, Arrow. -- Deprecated since 3.14, 1 -- "arrow_type": a valid Gtk.Enums.Gtk_Arrow_Type. -- "shadow_type": a valid Gtk.Enums.Gtk_Shadow_Type. ---------------- -- Properties -- ---------------- -- The following properties are defined for this widget. See -- Glib.Properties for more information on properties) Arrow_Type_Property : constant Gtk.Enums.Property_Gtk_Arrow_Type; Shadow_Type_Property : constant Gtk.Enums.Property_Gtk_Shadow_Type; ---------------- -- Interfaces -- ---------------- -- This class implements several interfaces. See Glib.Types -- -- - "Buildable" package Implements_Gtk_Buildable is new Glib.Types.Implements (Gtk.Buildable.Gtk_Buildable, Gtk_Arrow_Record, Gtk_Arrow); function "+" (Widget : access Gtk_Arrow_Record'Class) return Gtk.Buildable.Gtk_Buildable renames Implements_Gtk_Buildable.To_Interface; function "-" (Interf : Gtk.Buildable.Gtk_Buildable) return Gtk_Arrow renames Implements_Gtk_Buildable.To_Object; private Shadow_Type_Property : constant Gtk.Enums.Property_Gtk_Shadow_Type := Gtk.Enums.Build ("shadow-type"); Arrow_Type_Property : constant Gtk.Enums.Property_Gtk_Arrow_Type := Gtk.Enums.Build ("arrow-type"); end Gtk.Arrow; gtkada-24.0.0/src/generated/gtk-aspect_frame.adb000066400000000000000000000115541446021174000214460ustar00rootroot00000000000000------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ pragma Style_Checks (Off); pragma Warnings (Off, "*is already use-visible*"); with Glib.Type_Conversion_Hooks; use Glib.Type_Conversion_Hooks; pragma Warnings(Off); -- might be unused with Gtkada.Types; use Gtkada.Types; pragma Warnings(On); package body Gtk.Aspect_Frame is package Type_Conversion_Gtk_Aspect_Frame is new Glib.Type_Conversion_Hooks.Hook_Registrator (Get_Type'Access, Gtk_Aspect_Frame_Record); pragma Unreferenced (Type_Conversion_Gtk_Aspect_Frame); -------------------------- -- Gtk_Aspect_Frame_New -- -------------------------- function Gtk_Aspect_Frame_New (Label : UTF8_String := ""; Xalign : Gfloat; Yalign : Gfloat; Ratio : Gfloat; Obey_Child : Boolean) return Gtk_Aspect_Frame is Aspect_Frame : constant Gtk_Aspect_Frame := new Gtk_Aspect_Frame_Record; begin Gtk.Aspect_Frame.Initialize (Aspect_Frame, Label, Xalign, Yalign, Ratio, Obey_Child); return Aspect_Frame; end Gtk_Aspect_Frame_New; ------------- -- Gtk_New -- ------------- procedure Gtk_New (Aspect_Frame : out Gtk_Aspect_Frame; Label : UTF8_String := ""; Xalign : Gfloat; Yalign : Gfloat; Ratio : Gfloat; Obey_Child : Boolean) is begin Aspect_Frame := new Gtk_Aspect_Frame_Record; Gtk.Aspect_Frame.Initialize (Aspect_Frame, Label, Xalign, Yalign, Ratio, Obey_Child); end Gtk_New; ---------------- -- Initialize -- ---------------- procedure Initialize (Aspect_Frame : not null access Gtk_Aspect_Frame_Record'Class; Label : UTF8_String := ""; Xalign : Gfloat; Yalign : Gfloat; Ratio : Gfloat; Obey_Child : Boolean) is function Internal (Label : Gtkada.Types.Chars_Ptr; Xalign : Gfloat; Yalign : Gfloat; Ratio : Gfloat; Obey_Child : Glib.Gboolean) return System.Address; pragma Import (C, Internal, "gtk_aspect_frame_new"); Tmp_Label : Gtkada.Types.Chars_Ptr; Tmp_Return : System.Address; begin if not Aspect_Frame.Is_Created then if Label = "" then Tmp_Label := Gtkada.Types.Null_Ptr; else Tmp_Label := New_String (Label); end if; Tmp_Return := Internal (Tmp_Label, Xalign, Yalign, Ratio, Boolean'Pos (Obey_Child)); Free (Tmp_Label); Set_Object (Aspect_Frame, Tmp_Return); end if; end Initialize; --------- -- Set -- --------- procedure Set (Aspect_Frame : not null access Gtk_Aspect_Frame_Record; Xalign : Gfloat; Yalign : Gfloat; Ratio : Gfloat; Obey_Child : Boolean) is procedure Internal (Aspect_Frame : System.Address; Xalign : Gfloat; Yalign : Gfloat; Ratio : Gfloat; Obey_Child : Glib.Gboolean); pragma Import (C, Internal, "gtk_aspect_frame_set"); begin Internal (Get_Object (Aspect_Frame), Xalign, Yalign, Ratio, Boolean'Pos (Obey_Child)); end Set; end Gtk.Aspect_Frame; gtkada-24.0.0/src/generated/gtk-aspect_frame.ads000066400000000000000000000162331446021174000214660ustar00rootroot00000000000000------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ -- -- The Gtk.Aspect_Frame.Gtk_Aspect_Frame is useful when you want pack a -- widget so that it can resize but always retains the same aspect ratio. For -- instance, one might be drawing a small preview of a larger image. -- Gtk.Aspect_Frame.Gtk_Aspect_Frame derives from Gtk.Frame.Gtk_Frame, so it -- can draw a label and a frame around the child. The frame will be -- "shrink-wrapped" to the size of the child. -- -- # CSS nodes -- -- GtkAspectFrame uses a CSS node with name frame. -- -- -- Layout Containers -- create_frame.adb pragma Warnings (Off, "*is already use-visible*"); with Glib; use Glib; with Glib.Properties; use Glib.Properties; with Glib.Types; use Glib.Types; with Gtk.Buildable; use Gtk.Buildable; with Gtk.Frame; use Gtk.Frame; package Gtk.Aspect_Frame is type Gtk_Aspect_Frame_Record is new Gtk_Frame_Record with null record; type Gtk_Aspect_Frame is access all Gtk_Aspect_Frame_Record'Class; ------------------ -- Constructors -- ------------------ procedure Gtk_New (Aspect_Frame : out Gtk_Aspect_Frame; Label : UTF8_String := ""; Xalign : Gfloat; Yalign : Gfloat; Ratio : Gfloat; Obey_Child : Boolean); procedure Initialize (Aspect_Frame : not null access Gtk_Aspect_Frame_Record'Class; Label : UTF8_String := ""; Xalign : Gfloat; Yalign : Gfloat; Ratio : Gfloat; Obey_Child : Boolean); -- Create a new Gtk.Aspect_Frame.Gtk_Aspect_Frame. -- Initialize does nothing if the object was already created with another -- call to Initialize* or G_New. -- "label": Label text. -- "xalign": Horizontal alignment of the child within the allocation of -- the Gtk.Aspect_Frame.Gtk_Aspect_Frame. This ranges from 0.0 (left -- aligned) to 1.0 (right aligned) -- "yalign": Vertical alignment of the child within the allocation of the -- Gtk.Aspect_Frame.Gtk_Aspect_Frame. This ranges from 0.0 (top aligned) to -- 1.0 (bottom aligned) -- "ratio": The desired aspect ratio. -- "obey_child": If True, Ratio is ignored, and the aspect ratio is taken -- from the requistion of the child. function Gtk_Aspect_Frame_New (Label : UTF8_String := ""; Xalign : Gfloat; Yalign : Gfloat; Ratio : Gfloat; Obey_Child : Boolean) return Gtk_Aspect_Frame; -- Create a new Gtk.Aspect_Frame.Gtk_Aspect_Frame. -- "label": Label text. -- "xalign": Horizontal alignment of the child within the allocation of -- the Gtk.Aspect_Frame.Gtk_Aspect_Frame. This ranges from 0.0 (left -- aligned) to 1.0 (right aligned) -- "yalign": Vertical alignment of the child within the allocation of the -- Gtk.Aspect_Frame.Gtk_Aspect_Frame. This ranges from 0.0 (top aligned) to -- 1.0 (bottom aligned) -- "ratio": The desired aspect ratio. -- "obey_child": If True, Ratio is ignored, and the aspect ratio is taken -- from the requistion of the child. function Get_Type return Glib.GType; pragma Import (C, Get_Type, "gtk_aspect_frame_get_type"); ------------- -- Methods -- ------------- procedure Set (Aspect_Frame : not null access Gtk_Aspect_Frame_Record; Xalign : Gfloat; Yalign : Gfloat; Ratio : Gfloat; Obey_Child : Boolean); -- Set parameters for an existing Gtk.Aspect_Frame.Gtk_Aspect_Frame. -- "xalign": Horizontal alignment of the child within the allocation of -- the Gtk.Aspect_Frame.Gtk_Aspect_Frame. This ranges from 0.0 (left -- aligned) to 1.0 (right aligned) -- "yalign": Vertical alignment of the child within the allocation of the -- Gtk.Aspect_Frame.Gtk_Aspect_Frame. This ranges from 0.0 (top aligned) to -- 1.0 (bottom aligned) -- "ratio": The desired aspect ratio. -- "obey_child": If True, Ratio is ignored, and the aspect ratio is taken -- from the requistion of the child. ---------------- -- Properties -- ---------------- -- The following properties are defined for this widget. See -- Glib.Properties for more information on properties) Obey_Child_Property : constant Glib.Properties.Property_Boolean; Ratio_Property : constant Glib.Properties.Property_Float; Xalign_Property : constant Glib.Properties.Property_Float; Yalign_Property : constant Glib.Properties.Property_Float; ---------------- -- Interfaces -- ---------------- -- This class implements several interfaces. See Glib.Types -- -- - "Buildable" package Implements_Gtk_Buildable is new Glib.Types.Implements (Gtk.Buildable.Gtk_Buildable, Gtk_Aspect_Frame_Record, Gtk_Aspect_Frame); function "+" (Widget : access Gtk_Aspect_Frame_Record'Class) return Gtk.Buildable.Gtk_Buildable renames Implements_Gtk_Buildable.To_Interface; function "-" (Interf : Gtk.Buildable.Gtk_Buildable) return Gtk_Aspect_Frame renames Implements_Gtk_Buildable.To_Object; private Yalign_Property : constant Glib.Properties.Property_Float := Glib.Properties.Build ("yalign"); Xalign_Property : constant Glib.Properties.Property_Float := Glib.Properties.Build ("xalign"); Ratio_Property : constant Glib.Properties.Property_Float := Glib.Properties.Build ("ratio"); Obey_Child_Property : constant Glib.Properties.Property_Boolean := Glib.Properties.Build ("obey-child"); end Gtk.Aspect_Frame; gtkada-24.0.0/src/generated/gtk-assistant.adb000066400000000000000000001017441446021174000210270ustar00rootroot00000000000000------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ pragma Style_Checks (Off); pragma Warnings (Off, "*is already use-visible*"); with Ada.Unchecked_Conversion; with Glib.Type_Conversion_Hooks; use Glib.Type_Conversion_Hooks; with Glib.Values; use Glib.Values; with Gtk.Arguments; use Gtk.Arguments; with Gtkada.Bindings; use Gtkada.Bindings; pragma Warnings(Off); -- might be unused with Gtkada.Types; use Gtkada.Types; pragma Warnings(On); package body Gtk.Assistant is procedure C_Gtk_Assistant_Set_Forward_Page_Func (Assistant : System.Address; Page_Func : System.Address; Data : System.Address; Destroy : System.Address); pragma Import (C, C_Gtk_Assistant_Set_Forward_Page_Func, "gtk_assistant_set_forward_page_func"); -- Sets the page forwarding function to be Page_Func. -- This function will be used to determine what will be the next page when -- the user presses the forward button. Setting Page_Func to null will make -- the assistant to use the default forward function, which just goes to -- the next visible page. -- Since: gtk+ 2.10 -- "page_func": the Gtk_Assistant_Page_Func, or null to use the default -- one -- "data": user data for Page_Func -- "destroy": destroy notifier for Data function To_Gtk_Assistant_Page_Func is new Ada.Unchecked_Conversion (System.Address, Gtk_Assistant_Page_Func); function To_Address is new Ada.Unchecked_Conversion (Gtk_Assistant_Page_Func, System.Address); function Internal_Gtk_Assistant_Page_Func (Current_Page : Glib.Gint; Data : System.Address) return Glib.Gint; pragma Convention (C, Internal_Gtk_Assistant_Page_Func); -- "current_page": The page number used to calculate the next page. -- "data": user data. -------------------------------------- -- Internal_Gtk_Assistant_Page_Func -- -------------------------------------- function Internal_Gtk_Assistant_Page_Func (Current_Page : Glib.Gint; Data : System.Address) return Glib.Gint is Func : constant Gtk_Assistant_Page_Func := To_Gtk_Assistant_Page_Func (Data); begin return Func (Current_Page); end Internal_Gtk_Assistant_Page_Func; package Type_Conversion_Gtk_Assistant is new Glib.Type_Conversion_Hooks.Hook_Registrator (Get_Type'Access, Gtk_Assistant_Record); pragma Unreferenced (Type_Conversion_Gtk_Assistant); ----------------------- -- Gtk_Assistant_New -- ----------------------- function Gtk_Assistant_New return Gtk_Assistant is Assistant : constant Gtk_Assistant := new Gtk_Assistant_Record; begin Gtk.Assistant.Initialize (Assistant); return Assistant; end Gtk_Assistant_New; ------------- -- Gtk_New -- ------------- procedure Gtk_New (Assistant : out Gtk_Assistant) is begin Assistant := new Gtk_Assistant_Record; Gtk.Assistant.Initialize (Assistant); end Gtk_New; ---------------- -- Initialize -- ---------------- procedure Initialize (Assistant : not null access Gtk_Assistant_Record'Class) is function Internal return System.Address; pragma Import (C, Internal, "gtk_assistant_new"); begin if not Assistant.Is_Created then Set_Object (Assistant, Internal); end if; end Initialize; ----------------------- -- Add_Action_Widget -- ----------------------- procedure Add_Action_Widget (Assistant : not null access Gtk_Assistant_Record; Child : not null access Gtk.Widget.Gtk_Widget_Record'Class) is procedure Internal (Assistant : System.Address; Child : System.Address); pragma Import (C, Internal, "gtk_assistant_add_action_widget"); begin Internal (Get_Object (Assistant), Get_Object (Child)); end Add_Action_Widget; ----------------- -- Append_Page -- ----------------- function Append_Page (Assistant : not null access Gtk_Assistant_Record; Page : not null access Gtk.Widget.Gtk_Widget_Record'Class) return Glib.Gint is function Internal (Assistant : System.Address; Page : System.Address) return Glib.Gint; pragma Import (C, Internal, "gtk_assistant_append_page"); begin return Internal (Get_Object (Assistant), Get_Object (Page)); end Append_Page; ------------ -- Commit -- ------------ procedure Commit (Assistant : not null access Gtk_Assistant_Record) is procedure Internal (Assistant : System.Address); pragma Import (C, Internal, "gtk_assistant_commit"); begin Internal (Get_Object (Assistant)); end Commit; ---------------------- -- Get_Current_Page -- ---------------------- function Get_Current_Page (Assistant : not null access Gtk_Assistant_Record) return Glib.Gint is function Internal (Assistant : System.Address) return Glib.Gint; pragma Import (C, Internal, "gtk_assistant_get_current_page"); begin return Internal (Get_Object (Assistant)); end Get_Current_Page; ----------------- -- Get_N_Pages -- ----------------- function Get_N_Pages (Assistant : not null access Gtk_Assistant_Record) return Glib.Gint is function Internal (Assistant : System.Address) return Glib.Gint; pragma Import (C, Internal, "gtk_assistant_get_n_pages"); begin return Internal (Get_Object (Assistant)); end Get_N_Pages; ------------------ -- Get_Nth_Page -- ------------------ function Get_Nth_Page (Assistant : not null access Gtk_Assistant_Record; Page_Num : Glib.Gint) return Gtk.Widget.Gtk_Widget is function Internal (Assistant : System.Address; Page_Num : Glib.Gint) return System.Address; pragma Import (C, Internal, "gtk_assistant_get_nth_page"); Stub_Gtk_Widget : Gtk.Widget.Gtk_Widget_Record; begin return Gtk.Widget.Gtk_Widget (Get_User_Data (Internal (Get_Object (Assistant), Page_Num), Stub_Gtk_Widget)); end Get_Nth_Page; ----------------------- -- Get_Page_Complete -- ----------------------- function Get_Page_Complete (Assistant : not null access Gtk_Assistant_Record; Page : not null access Gtk.Widget.Gtk_Widget_Record'Class) return Boolean is function Internal (Assistant : System.Address; Page : System.Address) return Glib.Gboolean; pragma Import (C, Internal, "gtk_assistant_get_page_complete"); begin return Internal (Get_Object (Assistant), Get_Object (Page)) /= 0; end Get_Page_Complete; -------------------------- -- Get_Page_Has_Padding -- -------------------------- function Get_Page_Has_Padding (Assistant : not null access Gtk_Assistant_Record; Page : not null access Gtk.Widget.Gtk_Widget_Record'Class) return Boolean is function Internal (Assistant : System.Address; Page : System.Address) return Glib.Gboolean; pragma Import (C, Internal, "gtk_assistant_get_page_has_padding"); begin return Internal (Get_Object (Assistant), Get_Object (Page)) /= 0; end Get_Page_Has_Padding; --------------------------- -- Get_Page_Header_Image -- --------------------------- function Get_Page_Header_Image (Assistant : not null access Gtk_Assistant_Record; Page : not null access Gtk.Widget.Gtk_Widget_Record'Class) return Gdk.Pixbuf.Gdk_Pixbuf is function Internal (Assistant : System.Address; Page : System.Address) return System.Address; pragma Import (C, Internal, "gtk_assistant_get_page_header_image"); Stub_Gdk_Pixbuf : Gdk.Pixbuf.Gdk_Pixbuf_Record; begin return Gdk.Pixbuf.Gdk_Pixbuf (Get_User_Data (Internal (Get_Object (Assistant), Get_Object (Page)), Stub_Gdk_Pixbuf)); end Get_Page_Header_Image; ------------------------- -- Get_Page_Side_Image -- ------------------------- function Get_Page_Side_Image (Assistant : not null access Gtk_Assistant_Record; Page : not null access Gtk.Widget.Gtk_Widget_Record'Class) return Gdk.Pixbuf.Gdk_Pixbuf is function Internal (Assistant : System.Address; Page : System.Address) return System.Address; pragma Import (C, Internal, "gtk_assistant_get_page_side_image"); Stub_Gdk_Pixbuf : Gdk.Pixbuf.Gdk_Pixbuf_Record; begin return Gdk.Pixbuf.Gdk_Pixbuf (Get_User_Data (Internal (Get_Object (Assistant), Get_Object (Page)), Stub_Gdk_Pixbuf)); end Get_Page_Side_Image; -------------------- -- Get_Page_Title -- -------------------- function Get_Page_Title (Assistant : not null access Gtk_Assistant_Record; Page : not null access Gtk.Widget.Gtk_Widget_Record'Class) return UTF8_String is function Internal (Assistant : System.Address; Page : System.Address) return Gtkada.Types.Chars_Ptr; pragma Import (C, Internal, "gtk_assistant_get_page_title"); begin return Gtkada.Bindings.Value_Allowing_Null (Internal (Get_Object (Assistant), Get_Object (Page))); end Get_Page_Title; ------------------- -- Get_Page_Type -- ------------------- function Get_Page_Type (Assistant : not null access Gtk_Assistant_Record; Page : not null access Gtk.Widget.Gtk_Widget_Record'Class) return Gtk_Assistant_Page_Type is function Internal (Assistant : System.Address; Page : System.Address) return Gtk_Assistant_Page_Type; pragma Import (C, Internal, "gtk_assistant_get_page_type"); begin return Internal (Get_Object (Assistant), Get_Object (Page)); end Get_Page_Type; ----------------- -- Insert_Page -- ----------------- function Insert_Page (Assistant : not null access Gtk_Assistant_Record; Page : not null access Gtk.Widget.Gtk_Widget_Record'Class; Position : Glib.Gint) return Glib.Gint is function Internal (Assistant : System.Address; Page : System.Address; Position : Glib.Gint) return Glib.Gint; pragma Import (C, Internal, "gtk_assistant_insert_page"); begin return Internal (Get_Object (Assistant), Get_Object (Page), Position); end Insert_Page; --------------- -- Next_Page -- --------------- procedure Next_Page (Assistant : not null access Gtk_Assistant_Record) is procedure Internal (Assistant : System.Address); pragma Import (C, Internal, "gtk_assistant_next_page"); begin Internal (Get_Object (Assistant)); end Next_Page; ------------------ -- Prepend_Page -- ------------------ function Prepend_Page (Assistant : not null access Gtk_Assistant_Record; Page : not null access Gtk.Widget.Gtk_Widget_Record'Class) return Glib.Gint is function Internal (Assistant : System.Address; Page : System.Address) return Glib.Gint; pragma Import (C, Internal, "gtk_assistant_prepend_page"); begin return Internal (Get_Object (Assistant), Get_Object (Page)); end Prepend_Page; ------------------- -- Previous_Page -- ------------------- procedure Previous_Page (Assistant : not null access Gtk_Assistant_Record) is procedure Internal (Assistant : System.Address); pragma Import (C, Internal, "gtk_assistant_previous_page"); begin Internal (Get_Object (Assistant)); end Previous_Page; -------------------------- -- Remove_Action_Widget -- -------------------------- procedure Remove_Action_Widget (Assistant : not null access Gtk_Assistant_Record; Child : not null access Gtk.Widget.Gtk_Widget_Record'Class) is procedure Internal (Assistant : System.Address; Child : System.Address); pragma Import (C, Internal, "gtk_assistant_remove_action_widget"); begin Internal (Get_Object (Assistant), Get_Object (Child)); end Remove_Action_Widget; ----------------- -- Remove_Page -- ----------------- procedure Remove_Page (Assistant : not null access Gtk_Assistant_Record; Page_Num : Glib.Gint) is procedure Internal (Assistant : System.Address; Page_Num : Glib.Gint); pragma Import (C, Internal, "gtk_assistant_remove_page"); begin Internal (Get_Object (Assistant), Page_Num); end Remove_Page; ---------------------- -- Set_Current_Page -- ---------------------- procedure Set_Current_Page (Assistant : not null access Gtk_Assistant_Record; Page_Num : Glib.Gint) is procedure Internal (Assistant : System.Address; Page_Num : Glib.Gint); pragma Import (C, Internal, "gtk_assistant_set_current_page"); begin Internal (Get_Object (Assistant), Page_Num); end Set_Current_Page; --------------------------- -- Set_Forward_Page_Func -- --------------------------- procedure Set_Forward_Page_Func (Assistant : not null access Gtk_Assistant_Record; Page_Func : Gtk_Assistant_Page_Func) is begin if Page_Func = null then C_Gtk_Assistant_Set_Forward_Page_Func (Get_Object (Assistant), System.Null_Address, System.Null_Address, System.Null_Address); else C_Gtk_Assistant_Set_Forward_Page_Func (Get_Object (Assistant), Internal_Gtk_Assistant_Page_Func'Address, To_Address (Page_Func), System.Null_Address); end if; end Set_Forward_Page_Func; package body Set_Forward_Page_Func_User_Data is package Users is new Glib.Object.User_Data_Closure (User_Data_Type, Destroy); function To_Gtk_Assistant_Page_Func is new Ada.Unchecked_Conversion (System.Address, Gtk_Assistant_Page_Func); function To_Address is new Ada.Unchecked_Conversion (Gtk_Assistant_Page_Func, System.Address); function Internal_Cb (Current_Page : Glib.Gint; Data : System.Address) return Glib.Gint; pragma Convention (C, Internal_Cb); -- A function used by Gtk.Assistant.Set_Forward_Page_Func to know which -- is the next page given a current one. It's called both for computing -- the next page when the user presses the "forward" button and for -- handling the behavior of the "last" button. -- "current_page": The page number used to calculate the next page. -- "data": user data. ----------------- -- Internal_Cb -- ----------------- function Internal_Cb (Current_Page : Glib.Gint; Data : System.Address) return Glib.Gint is D : constant Users.Internal_Data_Access := Users.Convert (Data); begin return To_Gtk_Assistant_Page_Func (D.Func) (Current_Page, D.Data.all); end Internal_Cb; --------------------------- -- Set_Forward_Page_Func -- --------------------------- procedure Set_Forward_Page_Func (Assistant : not null access Gtk.Assistant.Gtk_Assistant_Record'Class; Page_Func : Gtk_Assistant_Page_Func; Data : User_Data_Type) is D : System.Address; begin if Page_Func = null then C_Gtk_Assistant_Set_Forward_Page_Func (Get_Object (Assistant), System.Null_Address, System.Null_Address, Users.Free_Data'Address); else D := Users.Build (To_Address (Page_Func), Data); C_Gtk_Assistant_Set_Forward_Page_Func (Get_Object (Assistant), Internal_Cb'Address, D, Users.Free_Data'Address); end if; end Set_Forward_Page_Func; end Set_Forward_Page_Func_User_Data; ----------------------- -- Set_Page_Complete -- ----------------------- procedure Set_Page_Complete (Assistant : not null access Gtk_Assistant_Record; Page : not null access Gtk.Widget.Gtk_Widget_Record'Class; Complete : Boolean) is procedure Internal (Assistant : System.Address; Page : System.Address; Complete : Glib.Gboolean); pragma Import (C, Internal, "gtk_assistant_set_page_complete"); begin Internal (Get_Object (Assistant), Get_Object (Page), Boolean'Pos (Complete)); end Set_Page_Complete; -------------------------- -- Set_Page_Has_Padding -- -------------------------- procedure Set_Page_Has_Padding (Assistant : not null access Gtk_Assistant_Record; Page : not null access Gtk.Widget.Gtk_Widget_Record'Class; Has_Padding : Boolean) is procedure Internal (Assistant : System.Address; Page : System.Address; Has_Padding : Glib.Gboolean); pragma Import (C, Internal, "gtk_assistant_set_page_has_padding"); begin Internal (Get_Object (Assistant), Get_Object (Page), Boolean'Pos (Has_Padding)); end Set_Page_Has_Padding; --------------------------- -- Set_Page_Header_Image -- --------------------------- procedure Set_Page_Header_Image (Assistant : not null access Gtk_Assistant_Record; Page : not null access Gtk.Widget.Gtk_Widget_Record'Class; Pixbuf : access Gdk.Pixbuf.Gdk_Pixbuf_Record'Class) is procedure Internal (Assistant : System.Address; Page : System.Address; Pixbuf : System.Address); pragma Import (C, Internal, "gtk_assistant_set_page_header_image"); begin Internal (Get_Object (Assistant), Get_Object (Page), Get_Object_Or_Null (GObject (Pixbuf))); end Set_Page_Header_Image; ------------------------- -- Set_Page_Side_Image -- ------------------------- procedure Set_Page_Side_Image (Assistant : not null access Gtk_Assistant_Record; Page : not null access Gtk.Widget.Gtk_Widget_Record'Class; Pixbuf : access Gdk.Pixbuf.Gdk_Pixbuf_Record'Class) is procedure Internal (Assistant : System.Address; Page : System.Address; Pixbuf : System.Address); pragma Import (C, Internal, "gtk_assistant_set_page_side_image"); begin Internal (Get_Object (Assistant), Get_Object (Page), Get_Object_Or_Null (GObject (Pixbuf))); end Set_Page_Side_Image; -------------------- -- Set_Page_Title -- -------------------- procedure Set_Page_Title (Assistant : not null access Gtk_Assistant_Record; Page : not null access Gtk.Widget.Gtk_Widget_Record'Class; Title : UTF8_String) is procedure Internal (Assistant : System.Address; Page : System.Address; Title : Gtkada.Types.Chars_Ptr); pragma Import (C, Internal, "gtk_assistant_set_page_title"); Tmp_Title : Gtkada.Types.Chars_Ptr := New_String (Title); begin Internal (Get_Object (Assistant), Get_Object (Page), Tmp_Title); Free (Tmp_Title); end Set_Page_Title; ------------------- -- Set_Page_Type -- ------------------- procedure Set_Page_Type (Assistant : not null access Gtk_Assistant_Record; Page : not null access Gtk.Widget.Gtk_Widget_Record'Class; The_Type : Gtk_Assistant_Page_Type) is procedure Internal (Assistant : System.Address; Page : System.Address; The_Type : Gtk_Assistant_Page_Type); pragma Import (C, Internal, "gtk_assistant_set_page_type"); begin Internal (Get_Object (Assistant), Get_Object (Page), The_Type); end Set_Page_Type; -------------------------- -- Update_Buttons_State -- -------------------------- procedure Update_Buttons_State (Assistant : not null access Gtk_Assistant_Record) is procedure Internal (Assistant : System.Address); pragma Import (C, Internal, "gtk_assistant_update_buttons_state"); begin Internal (Get_Object (Assistant)); end Update_Buttons_State; use type System.Address; function Cb_To_Address is new Ada.Unchecked_Conversion (Cb_Gtk_Assistant_Void, System.Address); function Address_To_Cb is new Ada.Unchecked_Conversion (System.Address, Cb_Gtk_Assistant_Void); function Cb_To_Address is new Ada.Unchecked_Conversion (Cb_GObject_Void, System.Address); function Address_To_Cb is new Ada.Unchecked_Conversion (System.Address, Cb_GObject_Void); function Cb_To_Address is new Ada.Unchecked_Conversion (Cb_Gtk_Assistant_Gtk_Widget_Void, System.Address); function Address_To_Cb is new Ada.Unchecked_Conversion (System.Address, Cb_Gtk_Assistant_Gtk_Widget_Void); function Cb_To_Address is new Ada.Unchecked_Conversion (Cb_GObject_Gtk_Widget_Void, System.Address); function Address_To_Cb is new Ada.Unchecked_Conversion (System.Address, Cb_GObject_Gtk_Widget_Void); procedure Connect (Object : access Gtk_Assistant_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_Gtk_Assistant_Void; After : Boolean); procedure Connect (Object : access Gtk_Assistant_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_Gtk_Assistant_Gtk_Widget_Void; After : Boolean); procedure Connect_Slot (Object : access Gtk_Assistant_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_GObject_Void; After : Boolean; Slot : access Glib.Object.GObject_Record'Class := null); procedure Connect_Slot (Object : access Gtk_Assistant_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_GObject_Gtk_Widget_Void; After : Boolean; Slot : access Glib.Object.GObject_Record'Class := null); procedure Marsh_GObject_Gtk_Widget_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address); pragma Convention (C, Marsh_GObject_Gtk_Widget_Void); procedure Marsh_GObject_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address); pragma Convention (C, Marsh_GObject_Void); procedure Marsh_Gtk_Assistant_Gtk_Widget_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address); pragma Convention (C, Marsh_Gtk_Assistant_Gtk_Widget_Void); procedure Marsh_Gtk_Assistant_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address); pragma Convention (C, Marsh_Gtk_Assistant_Void); ------------- -- Connect -- ------------- procedure Connect (Object : access Gtk_Assistant_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_Gtk_Assistant_Void; After : Boolean) is begin Unchecked_Do_Signal_Connect (Object => Object, C_Name => C_Name, Marshaller => Marsh_Gtk_Assistant_Void'Access, Handler => Cb_To_Address (Handler),-- Set in the closure After => After); end Connect; ------------- -- Connect -- ------------- procedure Connect (Object : access Gtk_Assistant_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_Gtk_Assistant_Gtk_Widget_Void; After : Boolean) is begin Unchecked_Do_Signal_Connect (Object => Object, C_Name => C_Name, Marshaller => Marsh_Gtk_Assistant_Gtk_Widget_Void'Access, Handler => Cb_To_Address (Handler),-- Set in the closure After => After); end Connect; ------------------ -- Connect_Slot -- ------------------ procedure Connect_Slot (Object : access Gtk_Assistant_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_GObject_Void; After : Boolean; Slot : access Glib.Object.GObject_Record'Class := null) is begin Unchecked_Do_Signal_Connect (Object => Object, C_Name => C_Name, Marshaller => Marsh_GObject_Void'Access, Handler => Cb_To_Address (Handler),-- Set in the closure Slot_Object => Slot, After => After); end Connect_Slot; ------------------ -- Connect_Slot -- ------------------ procedure Connect_Slot (Object : access Gtk_Assistant_Record'Class; C_Name : Glib.Signal_Name; Handler : Cb_GObject_Gtk_Widget_Void; After : Boolean; Slot : access Glib.Object.GObject_Record'Class := null) is begin Unchecked_Do_Signal_Connect (Object => Object, C_Name => C_Name, Marshaller => Marsh_GObject_Gtk_Widget_Void'Access, Handler => Cb_To_Address (Handler),-- Set in the closure Slot_Object => Slot, After => After); end Connect_Slot; ----------------------------------- -- Marsh_GObject_Gtk_Widget_Void -- ----------------------------------- procedure Marsh_GObject_Gtk_Widget_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address) is pragma Unreferenced (Return_Value, N_Params, Invocation_Hint, User_Data); H : constant Cb_GObject_Gtk_Widget_Void := Address_To_Cb (Get_Callback (Closure)); Obj : constant Glib.Object.GObject := Glib.Object.Convert (Get_Data (Closure)); begin H (Obj, Gtk.Widget.Gtk_Widget (Unchecked_To_Object (Params, 1))); exception when E : others => Process_Exception (E); end Marsh_GObject_Gtk_Widget_Void; ------------------------ -- Marsh_GObject_Void -- ------------------------ procedure Marsh_GObject_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address) is pragma Unreferenced (Return_Value, N_Params, Params, Invocation_Hint, User_Data); H : constant Cb_GObject_Void := Address_To_Cb (Get_Callback (Closure)); Obj : constant Glib.Object.GObject := Glib.Object.Convert (Get_Data (Closure)); begin H (Obj); exception when E : others => Process_Exception (E); end Marsh_GObject_Void; ----------------------------------------- -- Marsh_Gtk_Assistant_Gtk_Widget_Void -- ----------------------------------------- procedure Marsh_Gtk_Assistant_Gtk_Widget_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address) is pragma Unreferenced (Return_Value, N_Params, Invocation_Hint, User_Data); H : constant Cb_Gtk_Assistant_Gtk_Widget_Void := Address_To_Cb (Get_Callback (Closure)); Obj : constant Gtk_Assistant := Gtk_Assistant (Unchecked_To_Object (Params, 0)); begin H (Obj, Gtk.Widget.Gtk_Widget (Unchecked_To_Object (Params, 1))); exception when E : others => Process_Exception (E); end Marsh_Gtk_Assistant_Gtk_Widget_Void; ------------------------------ -- Marsh_Gtk_Assistant_Void -- ------------------------------ procedure Marsh_Gtk_Assistant_Void (Closure : GClosure; Return_Value : Glib.Values.GValue; N_Params : Glib.Guint; Params : Glib.Values.C_GValues; Invocation_Hint : System.Address; User_Data : System.Address) is pragma Unreferenced (Return_Value, N_Params, Invocation_Hint, User_Data); H : constant Cb_Gtk_Assistant_Void := Address_To_Cb (Get_Callback (Closure)); Obj : constant Gtk_Assistant := Gtk_Assistant (Unchecked_To_Object (Params, 0)); begin H (Obj); exception when E : others => Process_Exception (E); end Marsh_Gtk_Assistant_Void; -------------- -- On_Apply -- -------------- procedure On_Apply (Self : not null access Gtk_Assistant_Record; Call : Cb_Gtk_Assistant_Void; After : Boolean := False) is begin Connect (Self, "apply" & ASCII.NUL, Call, After); end On_Apply; -------------- -- On_Apply -- -------------- procedure On_Apply (Self : not null access Gtk_Assistant_Record; Call : Cb_GObject_Void; Slot : not null access Glib.Object.GObject_Record'Class; After : Boolean := False) is begin Connect_Slot (Self, "apply" & ASCII.NUL, Call, After, Slot); end On_Apply; --------------- -- On_Cancel -- --------------- procedure On_Cancel (Self : not null access Gtk_Assistant_Record; Call : Cb_Gtk_Assistant_Void; After : Boolean := False) is begin Connect (Self, "cancel" & ASCII.NUL, Call, After); end On_Cancel; --------------- -- On_Cancel -- --------------- procedure On_Cancel (Self : not null access Gtk_Assistant_Record; Call : Cb_GObject_Void; Slot : not null access Glib.Object.GObject_Record'Class; After : Boolean := False) is begin Connect_Slot (Self, "cancel" & ASCII.NUL, Call, After, Slot); end On_Cancel; -------------- -- On_Close -- -------------- procedure On_Close (Self : not null access Gtk_Assistant_Record; Call : Cb_Gtk_Assistant_Void; After : Boolean := False) is begin Connect (Self, "close" & ASCII.NUL, Call, After); end On_Close; -------------- -- On_Close -- -------------- procedure On_Close (Self : not null access Gtk_Assistant_Record; Call : Cb_GObject_Void; Slot : not null access Glib.Object.GObject_Record'Class; After : Boolean := False) is begin Connect_Slot (Self, "close" & ASCII.NUL, Call, After, Slot); end On_Close; --------------- -- On_Escape -- --------------- procedure On_Escape (Self : not null access Gtk_Assistant_Record; Call : Cb_Gtk_Assistant_Void; After : Boolean := False) is begin Connect (Self, "escape" & ASCII.NUL, Call, After); end On_Escape; --------------- -- On_Escape -- --------------- procedure On_Escape (Self : not null access Gtk_Assistant_Record; Call : Cb_GObject_Void; Slot : not null access Glib.Object.GObject_Record'Class; After : Boolean := False) is begin Connect_Slot (Self, "escape" & ASCII.NUL, Call, After, Slot); end On_Escape; ---------------- -- On_Prepare -- ---------------- procedure On_Prepare (Self : not null access Gtk_Assistant_Record; Call : Cb_Gtk_Assistant_Gtk_Widget_Void; After : Boolean := False) is begin Connect (Self, "prepare" & ASCII.NUL, Call, After); end On_Prepare; ---------------- -- On_Prepare -- ---------------- procedure On_Prepare (Self : not null access Gtk_Assistant_Record; Call : Cb_GObject_Gtk_Widget_Void; Slot : not null access Glib.Object.GObject_Record'Class; After : Boolean := False) is begin Connect_Slot (Self, "prepare" & ASCII.NUL, Call, After, Slot); end On_Prepare; end Gtk.Assistant; gtkada-24.0.0/src/generated/gtk-assistant.ads000066400000000000000000000540621446021174000210500ustar00rootroot00000000000000------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ -- -- A Gtk.Assistant.Gtk_Assistant is a widget used to represent a generally -- complex operation splitted in several steps, guiding the user through its -- pages and controlling the page flow to collect the necessary data. -- -- The design of GtkAssistant is that it controls what buttons to show and to -- make sensitive, based on what it knows about the page sequence and the -- [type][GtkAssistantPageType] of each page, in addition to state information -- like the page [completion][gtk-assistant-set-page-complete] and -- [committed][gtk-assistant-commit] status. -- -- If you have a case that doesn't quite fit in Gtk_Assistants way of -- handling buttons, you can use the GTK_ASSISTANT_PAGE_CUSTOM page type and -- handle buttons yourself. -- -- # GtkAssistant as GtkBuildable -- -- The GtkAssistant implementation of the Gtk.Buildable.Gtk_Buildable -- interface exposes the Action_Area as internal children with the name -- "action_area". -- -- To add pages to an assistant in Gtk.Builder.Gtk_Builder, simply add it as -- a child to the GtkAssistant object, and set its child properties as -- necessary. -- -- # CSS nodes -- -- GtkAssistant has a single CSS node with the name assistant. -- -- -- Windows -- create_assistant.adb pragma Warnings (Off, "*is already use-visible*"); with Gdk.Pixbuf; use Gdk.Pixbuf; with Glib; use Glib; with Glib.Generic_Properties; use Glib.Generic_Properties; with Glib.Object; use Glib.Object; with Glib.Properties; use Glib.Properties; with Glib.Types; use Glib.Types; with Gtk.Buildable; use Gtk.Buildable; with Gtk.Widget; use Gtk.Widget; with Gtk.Window; use Gtk.Window; package Gtk.Assistant is type Gtk_Assistant_Record is new Gtk_Window_Record with null record; type Gtk_Assistant is access all Gtk_Assistant_Record'Class; type Gtk_Assistant_Page_Type is ( Gtk_Assistant_Page_Content, Gtk_Assistant_Page_Intro, Gtk_Assistant_Page_Confirm, Gtk_Assistant_Page_Summary, Gtk_Assistant_Page_Progress, Gtk_Assistant_Page_Custom); pragma Convention (C, Gtk_Assistant_Page_Type); -- An enum for determining the page role inside the -- Gtk.Assistant.Gtk_Assistant. It's used to handle buttons sensitivity and -- visibility. -- -- Note that an assistant needs to end its page flow with a page of type -- Gtk.Assistant.Gtk_Assistant_Page_Confirm, -- Gtk.Assistant.Gtk_Assistant_Page_Summary or -- Gtk.Assistant.Gtk_Assistant_Page_Progress to be correct. -- -- The Cancel button will only be shown if the page isn't "committed". See -- Gtk.Assistant.Commit for details. --------------- -- Callbacks -- --------------- type Gtk_Assistant_Page_Func is access function (Current_Page : Glib.Gint) return Glib.Gint; -- A function used by Gtk.Assistant.Set_Forward_Page_Func to know which is -- the next page given a current one. It's called both for computing the -- next page when the user presses the "forward" button and for handling -- the behavior of the "last" button. -- "current_page": The page number used to calculate the next page. ---------------------------- -- Enumeration Properties -- ---------------------------- package Gtk_Assistant_Page_Type_Properties is new Generic_Internal_Discrete_Property (Gtk_Assistant_Page_Type); type Property_Gtk_Assistant_Page_Type is new Gtk_Assistant_Page_Type_Properties.Property; ------------------ -- Constructors -- ------------------ procedure Gtk_New (Assistant : out Gtk_Assistant); procedure Initialize (Assistant : not null access Gtk_Assistant_Record'Class); -- Creates a new Gtk.Assistant.Gtk_Assistant. -- Since: gtk+ 2.10 -- Initialize does nothing if the object was already created with another -- call to Initialize* or G_New. function Gtk_Assistant_New return Gtk_Assistant; -- Creates a new Gtk.Assistant.Gtk_Assistant. -- Since: gtk+ 2.10 function Get_Type return Glib.GType; pragma Import (C, Get_Type, "gtk_assistant_get_type"); ------------- -- Methods -- ------------- procedure Add_Action_Widget (Assistant : not null access Gtk_Assistant_Record; Child : not null access Gtk.Widget.Gtk_Widget_Record'Class); -- Adds a widget to the action area of a Gtk.Assistant.Gtk_Assistant. -- Since: gtk+ 2.10 -- "child": a Gtk.Widget.Gtk_Widget function Append_Page (Assistant : not null access Gtk_Assistant_Record; Page : not null access Gtk.Widget.Gtk_Widget_Record'Class) return Glib.Gint; -- Appends a page to the Assistant. -- Since: gtk+ 2.10 -- "page": a Gtk.Widget.Gtk_Widget procedure Commit (Assistant : not null access Gtk_Assistant_Record); -- Erases the visited page history so the back button is not shown on the -- current page, and removes the cancel button from subsequent pages. -- Use this when the information provided up to the current page is -- hereafter deemed permanent and cannot be modified or undone. For -- example, showing a progress page to track a long-running, unreversible -- operation after the user has clicked apply on a confirmation page. -- Since: gtk+ 2.22 function Get_Current_Page (Assistant : not null access Gtk_Assistant_Record) return Glib.Gint; -- Returns the page number of the current page. -- Since: gtk+ 2.10 procedure Set_Current_Page (Assistant : not null access Gtk_Assistant_Record; Page_Num : Glib.Gint); -- Switches the page to Page_Num. -- Note that this will only be necessary in custom buttons, as the -- Assistant flow can be set with Gtk.Assistant.Set_Forward_Page_Func. -- Since: gtk+ 2.10 -- "page_num": index of the page to switch to, starting from 0. If -- negative, the last page will be used. If greater than the number of -- pages in the Assistant, nothing will be done. function Get_N_Pages (Assistant : not null access Gtk_Assistant_Record) return Glib.Gint; -- Returns the number of pages in the Assistant -- Since: gtk+ 2.10 function Get_Nth_Page (Assistant : not null access Gtk_Assistant_Record; Page_Num : Glib.Gint) return Gtk.Widget.Gtk_Widget; -- Returns the child widget contained in page number Page_Num. -- Since: gtk+ 2.10 -- "page_num": the index of a page in the Assistant, or -1 to get the last -- page function Get_Page_Complete (Assistant : not null access Gtk_Assistant_Record; Page : not null access Gtk.Widget.Gtk_Widget_Record'Class) return Boolean; -- Gets whether Page is complete. -- Since: gtk+ 2.10 -- "page": a page of Assistant procedure Set_Page_Complete (Assistant : not null access Gtk_Assistant_Record; Page : not null access Gtk.Widget.Gtk_Widget_Record'Class; Complete : Boolean); -- Sets whether Page contents are complete. -- This will make Assistant update the buttons state to be able to -- continue the task. -- Since: gtk+ 2.10 -- "page": a page of Assistant -- "complete": the completeness status of the page function Get_Page_Has_Padding (Assistant : not null access Gtk_Assistant_Record; Page : not null access Gtk.Widget.Gtk_Widget_Record'Class) return Boolean; -- Gets whether page has padding. -- Since: gtk+ 3.18 -- "page": a page of Assistant procedure Set_Page_Has_Padding (Assistant : not null access Gtk_Assistant_Record; Page : not null access Gtk.Widget.Gtk_Widget_Record'Class; Has_Padding : Boolean); -- Sets whether the assistant is adding padding around the page. -- Since: gtk+ 3.18 -- "page": a page of Assistant -- "has_padding": whether this page has padding function Get_Page_Header_Image (Assistant : not null access Gtk_Assistant_Record; Page : not null access Gtk.Widget.Gtk_Widget_Record'Class) return Gdk.Pixbuf.Gdk_Pixbuf; pragma Obsolescent (Get_Page_Header_Image); -- Gets the header image for Page. -- Since: gtk+ 2.10 -- Deprecated since 3.2, 1 -- "page": a page of Assistant procedure Set_Page_Header_Image (Assistant : not null access Gtk_Assistant_Record; Page : not null access Gtk.Widget.Gtk_Widget_Record'Class; Pixbuf : access Gdk.Pixbuf.Gdk_Pixbuf_Record'Class); pragma Obsolescent (Set_Page_Header_Image); -- Sets a header image for Page. -- Since: gtk+ 2.10 -- Deprecated since 3.2, 1 -- "page": a page of Assistant -- "pixbuf": the new header image Page function Get_Page_Side_Image (Assistant : not null access Gtk_Assistant_Record; Page : not null access Gtk.Widget.Gtk_Widget_Record'Class) return Gdk.Pixbuf.Gdk_Pixbuf; pragma Obsolescent (Get_Page_Side_Image); -- Gets the side image for Page. -- Since: gtk+ 2.10 -- Deprecated since 3.2, 1 -- "page": a page of Assistant procedure Set_Page_Side_Image (Assistant : not null access Gtk_Assistant_Record; Page : not null access Gtk.Widget.Gtk_Widget_Record'Class; Pixbuf : access Gdk.Pixbuf.Gdk_Pixbuf_Record'Class); pragma Obsolescent (Set_Page_Side_Image); -- Sets a side image for Page. -- This image used to be displayed in the side area of the assistant when -- Page is the current page. -- Since: gtk+ 2.10 -- Deprecated since 3.2, 1 -- "page": a page of Assistant -- "pixbuf": the new side image Page function Get_Page_Title (Assistant : not null access Gtk_Assistant_Record; Page : not null access Gtk.Widget.Gtk_Widget_Record'Class) return UTF8_String; -- Gets the title for Page. -- Since: gtk+ 2.10 -- "page": a page of Assistant procedure Set_Page_Title (Assistant : not null access Gtk_Assistant_Record; Page : not null access Gtk.Widget.Gtk_Widget_Record'Class; Title : UTF8_String); -- Sets a title for Page. -- The title is displayed in the header area of the assistant when Page is -- the current page. -- Since: gtk+ 2.10 -- "page": a page of Assistant -- "title": the new title for Page function Get_Page_Type (Assistant : not null access Gtk_Assistant_Record; Page : not null access Gtk.Widget.Gtk_Widget_Record'Class) return Gtk_Assistant_Page_Type; -- Gets the page type of Page. -- Since: gtk+ 2.10 -- "page": a page of Assistant procedure Set_Page_Type (Assistant : not null access Gtk_Assistant_Record; Page : not null access Gtk.Widget.Gtk_Widget_Record'Class; The_Type : Gtk_Assistant_Page_Type); -- Sets the page type for Page. -- The page type determines the page behavior in the Assistant. -- Since: gtk+ 2.10 -- "page": a page of Assistant -- "type": the new type for Page function Insert_Page (Assistant : not null access Gtk_Assistant_Record; Page : not null access Gtk.Widget.Gtk_Widget_Record'Class; Position : Glib.Gint) return Glib.Gint; -- Inserts a page in the Assistant at a given position. -- Since: gtk+ 2.10 -- "page": a Gtk.Widget.Gtk_Widget -- "position": the index (starting at 0) at which to insert the page, or -- -1 to append the page to the Assistant procedure Next_Page (Assistant : not null access Gtk_Assistant_Record); -- Navigate to the next page. -- It is a programming error to call this function when there is no next -- page. -- This function is for use when creating pages of the -- GTK_ASSISTANT_PAGE_CUSTOM type. -- Since: gtk+ 3.0 function Prepend_Page (Assistant : not null access Gtk_Assistant_Record; Page : not null access Gtk.Widget.Gtk_Widget_Record'Class) return Glib.Gint; -- Prepends a page to the Assistant. -- Since: gtk+ 2.10 -- "page": a Gtk.Widget.Gtk_Widget procedure Previous_Page (Assistant : not null access Gtk_Assistant_Record); -- Navigate to the previous visited page. -- It is a programming error to call this function when no previous page -- is available. -- This function is for use when creating pages of the -- GTK_ASSISTANT_PAGE_CUSTOM type. -- Since: gtk+ 3.0 procedure Remove_Action_Widget (Assistant : not null access Gtk_Assistant_Record; Child : not null access Gtk.Widget.Gtk_Widget_Record'Class); -- Removes a widget from the action area of a Gtk.Assistant.Gtk_Assistant. -- Since: gtk+ 2.10 -- "child": a Gtk.Widget.Gtk_Widget procedure Remove_Page (Assistant : not null access Gtk_Assistant_Record; Page_Num : Glib.Gint); -- Removes the Page_Num's page from Assistant. -- Since: gtk+ 3.2 -- "page_num": the index of a page in the Assistant, or -1 to remove the -- last page procedure Set_Forward_Page_Func (Assistant : not null access Gtk_Assistant_Record; Page_Func : Gtk_Assistant_Page_Func); -- Sets the page forwarding function to be Page_Func. -- This function will be used to determine what will be the next page when -- the user presses the forward button. Setting Page_Func to null will make -- the assistant to use the default forward function, which just goes to -- the next visible page. -- Since: gtk+ 2.10 -- "page_func": the Gtk_Assistant_Page_Func, or null to use the default -- one generic type User_Data_Type (<>) is private; with procedure Destroy (Data : in out User_Data_Type) is null; package Set_Forward_Page_Func_User_Data is type Gtk_Assistant_Page_Func is access function (Current_Page : Glib.Gint; Data : User_Data_Type) return Glib.Gint; -- A function used by Gtk.Assistant.Set_Forward_Page_Func to know which is -- the next page given a current one. It's called both for computing the -- next page when the user presses the "forward" button and for handling -- the behavior of the "last" button. -- "current_page": The page number used to calculate the next page. -- "data": user data. procedure Set_Forward_Page_Func (Assistant : not null access Gtk.Assistant.Gtk_Assistant_Record'Class; Page_Func : Gtk_Assistant_Page_Func; Data : User_Data_Type); -- Sets the page forwarding function to be Page_Func. -- This function will be used to determine what will be the next page -- when the user presses the forward button. Setting Page_Func to null -- will make the assistant to use the default forward function, which -- just goes to the next visible page. -- Since: gtk+ 2.10 -- "page_func": the Gtk_Assistant_Page_Func, or null to use the default -- one -- "data": user data for Page_Func end Set_Forward_Page_Func_User_Data; procedure Update_Buttons_State (Assistant : not null access Gtk_Assistant_Record); -- Forces Assistant to recompute the buttons state. -- GTK+ automatically takes care of this in most situations, e.g. when the -- user goes to a different page, or when the visibility or completeness of -- a page changes. -- One situation where it can be necessary to call this function is when -- changing a value on the current page affects the future page flow of the -- assistant. -- Since: gtk+ 2.10 ---------------- -- Properties -- ---------------- -- The following properties are defined for this widget. See -- Glib.Properties for more information on properties) Use_Header_Bar_Property : constant Glib.Properties.Property_Int; -- True if the assistant uses a Gtk.Header_Bar.Gtk_Header_Bar for action -- buttons instead of the action-area. -- -- For technical reasons, this property is declared as an integer -- property, but you should only set it to True or False. ------------- -- Signals -- ------------- type Cb_Gtk_Assistant_Void is not null access procedure (Self : access Gtk_Assistant_Record'Class); type Cb_GObject_Void is not null access procedure (Self : access Glib.Object.GObject_Record'Class); Signal_Apply : constant Glib.Signal_Name := "apply"; procedure On_Apply (Self : not null access Gtk_Assistant_Record; Call : Cb_Gtk_Assistant_Void; After : Boolean := False); procedure On_Apply (Self : not null access Gtk_Assistant_Record; Call : Cb_GObject_Void; Slot : not null access Glib.Object.GObject_Record'Class; After : Boolean := False); -- The ::apply signal is emitted when the apply button is clicked. -- -- The default behavior of the Gtk.Assistant.Gtk_Assistant is to switch to -- the page after the current page, unless the current page is the last -- one. -- -- A handler for the ::apply signal should carry out the actions for which -- the wizard has collected data. If the action takes a long time to -- complete, you might consider putting a page of type -- Gtk.Assistant.Gtk_Assistant_Page_Progress after the confirmation page -- and handle this operation within the -- Gtk.Assistant.Gtk_Assistant::prepare signal of the progress page. Signal_Cancel : constant Glib.Signal_Name := "cancel"; procedure On_Cancel (Self : not null access Gtk_Assistant_Record; Call : Cb_Gtk_Assistant_Void; After : Boolean := False); procedure On_Cancel (Self : not null access Gtk_Assistant_Record; Call : Cb_GObject_Void; Slot : not null access Glib.Object.GObject_Record'Class; After : Boolean := False); -- The ::cancel signal is emitted when then the cancel button is clicked. Signal_Close : constant Glib.Signal_Name := "close"; procedure On_Close (Self : not null access Gtk_Assistant_Record; Call : Cb_Gtk_Assistant_Void; After : Boolean := False); procedure On_Close (Self : not null access Gtk_Assistant_Record; Call : Cb_GObject_Void; Slot : not null access Glib.Object.GObject_Record'Class; After : Boolean := False); -- The ::close signal is emitted either when the close button of a summary -- page is clicked, or when the apply button in the last page in the flow -- (of type Gtk.Assistant.Gtk_Assistant_Page_Confirm) is clicked. Signal_Escape : constant Glib.Signal_Name := "escape"; procedure On_Escape (Self : not null access Gtk_Assistant_Record; Call : Cb_Gtk_Assistant_Void; After : Boolean := False); procedure On_Escape (Self : not null access Gtk_Assistant_Record; Call : Cb_GObject_Void; Slot : not null access Glib.Object.GObject_Record'Class; After : Boolean := False); type Cb_Gtk_Assistant_Gtk_Widget_Void is not null access procedure (Self : access Gtk_Assistant_Record'Class; Page : not null access Gtk.Widget.Gtk_Widget_Record'Class); type Cb_GObject_Gtk_Widget_Void is not null access procedure (Self : access Glib.Object.GObject_Record'Class; Page : not null access Gtk.Widget.Gtk_Widget_Record'Class); Signal_Prepare : constant Glib.Signal_Name := "prepare"; procedure On_Prepare (Self : not null access Gtk_Assistant_Record; Call : Cb_Gtk_Assistant_Gtk_Widget_Void; After : Boolean := False); procedure On_Prepare (Self : not null access Gtk_Assistant_Record; Call : Cb_GObject_Gtk_Widget_Void; Slot : not null access Glib.Object.GObject_Record'Class; After : Boolean := False); -- The ::prepare signal is emitted when a new page is set as the -- assistant's current page, before making the new page visible. -- -- A handler for this signal can do any preparations which are necessary -- before showing Page. ---------------- -- Interfaces -- ---------------- -- This class implements several interfaces. See Glib.Types -- -- - "Buildable" package Implements_Gtk_Buildable is new Glib.Types.Implements (Gtk.Buildable.Gtk_Buildable, Gtk_Assistant_Record, Gtk_Assistant); function "+" (Widget : access Gtk_Assistant_Record'Class) return Gtk.Buildable.Gtk_Buildable renames Implements_Gtk_Buildable.To_Interface; function "-" (Interf : Gtk.Buildable.Gtk_Buildable) return Gtk_Assistant renames Implements_Gtk_Buildable.To_Object; private Use_Header_Bar_Property : constant Glib.Properties.Property_Int := Glib.Properties.Build ("use-header-bar"); end Gtk.Assistant; gtkada-24.0.0/src/generated/gtk-bin.adb000066400000000000000000000050051446021174000175570ustar00rootroot00000000000000------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ pragma Style_Checks (Off); pragma Warnings (Off, "*is already use-visible*"); with Glib.Type_Conversion_Hooks; use Glib.Type_Conversion_Hooks; package body Gtk.Bin is package Type_Conversion_Gtk_Bin is new Glib.Type_Conversion_Hooks.Hook_Registrator (Get_Type'Access, Gtk_Bin_Record); pragma Unreferenced (Type_Conversion_Gtk_Bin); --------------- -- Get_Child -- --------------- function Get_Child (Bin : not null access Gtk_Bin_Record) return Gtk.Widget.Gtk_Widget is function Internal (Bin : System.Address) return System.Address; pragma Import (C, Internal, "gtk_bin_get_child"); Stub_Gtk_Widget : Gtk.Widget.Gtk_Widget_Record; begin return Gtk.Widget.Gtk_Widget (Get_User_Data (Internal (Get_Object (Bin)), Stub_Gtk_Widget)); end Get_Child; end Gtk.Bin; gtkada-24.0.0/src/generated/gtk-bin.ads000066400000000000000000000071631446021174000176070ustar00rootroot00000000000000------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ -- -- The Gtk.Bin.Gtk_Bin widget is a container with just one child. It is not -- very useful itself, but it is useful for deriving subclasses, since it -- provides common code needed for handling a single child widget. -- -- Many GTK+ widgets are subclasses of Gtk.Bin.Gtk_Bin, including -- Gtk.Window.Gtk_Window, Gtk.Button.Gtk_Button, Gtk.Frame.Gtk_Frame, -- Gtk.Handle_Box.Gtk_Handle_Box or Gtk.Scrolled_Window.Gtk_Scrolled_Window. -- -- -- Abstract base classes pragma Warnings (Off, "*is already use-visible*"); with Glib; use Glib; with Glib.Types; use Glib.Types; with Gtk.Buildable; use Gtk.Buildable; with Gtk.Container; use Gtk.Container; with Gtk.Widget; use Gtk.Widget; package Gtk.Bin is type Gtk_Bin_Record is new Gtk_Container_Record with null record; type Gtk_Bin is access all Gtk_Bin_Record'Class; ------------------ -- Constructors -- ------------------ function Get_Type return Glib.GType; pragma Import (C, Get_Type, "gtk_bin_get_type"); ------------- -- Methods -- ------------- function Get_Child (Bin : not null access Gtk_Bin_Record) return Gtk.Widget.Gtk_Widget; -- Gets the child of the Gtk.Bin.Gtk_Bin, or null if the bin contains no -- child widget. The returned widget does not have a reference added, so -- you do not need to unref it. ---------------- -- Interfaces -- ---------------- -- This class implements several interfaces. See Glib.Types -- -- - "Buildable" package Implements_Gtk_Buildable is new Glib.Types.Implements (Gtk.Buildable.Gtk_Buildable, Gtk_Bin_Record, Gtk_Bin); function "+" (Widget : access Gtk_Bin_Record'Class) return Gtk.Buildable.Gtk_Buildable renames Implements_Gtk_Buildable.To_Interface; function "-" (Interf : Gtk.Buildable.Gtk_Buildable) return Gtk_Bin renames Implements_Gtk_Buildable.To_Object; end Gtk.Bin; gtkada-24.0.0/src/generated/gtk-binding_set.adb000066400000000000000000000120341446021174000212740ustar00rootroot00000000000000------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ pragma Style_Checks (Off); pragma Warnings (Off, "*is already use-visible*"); package body Gtk.Binding_Set is function From_Object_Free (B : access Gtk_Binding_Set) return Gtk_Binding_Set is Result : constant Gtk_Binding_Set := B.all; begin Glib.g_free (B.all'Address); return Result; end From_Object_Free; ------------------------- -- Gtk_Binding_Set_New -- ------------------------- function Gtk_Binding_Set_New (Set_Name : UTF8_String) return Gtk_Binding_Set is function Internal (Set_Name : Gtkada.Types.Chars_Ptr) return Gtk_Binding_Set; pragma Import (C, Internal, "gtk_binding_set_new"); Tmp_Set_Name : Gtkada.Types.Chars_Ptr := New_String (Set_Name); Tmp_Return : Gtk_Binding_Set; Self : Gtk_Binding_Set; begin Tmp_Return := Internal (Tmp_Set_Name); Free (Tmp_Set_Name); Self := Tmp_Return; return Self; end Gtk_Binding_Set_New; ------------- -- Gtk_New -- ------------- procedure Gtk_New (Self : out Gtk_Binding_Set; Set_Name : UTF8_String) is function Internal (Set_Name : Gtkada.Types.Chars_Ptr) return Gtk_Binding_Set; pragma Import (C, Internal, "gtk_binding_set_new"); Tmp_Set_Name : Gtkada.Types.Chars_Ptr := New_String (Set_Name); Tmp_Return : Gtk_Binding_Set; begin Tmp_Return := Internal (Tmp_Set_Name); Free (Tmp_Set_Name); Self := Tmp_Return; end Gtk_New; -------------- -- Activate -- -------------- function Activate (Self : Gtk_Binding_Set; Keyval : Guint; Modifiers : Gdk.Types.Gdk_Modifier_Type; Object : not null access Glib.Object.GObject_Record'Class) return Boolean is function Internal (Self : Gtk_Binding_Set; Keyval : Guint; Modifiers : Gdk.Types.Gdk_Modifier_Type; Object : System.Address) return Glib.Gboolean; pragma Import (C, Internal, "gtk_binding_set_activate"); begin return Internal (Self, Keyval, Modifiers, Get_Object (Object)) /= 0; end Activate; -------------- -- Add_Path -- -------------- procedure Add_Path (Self : Gtk_Binding_Set; Path_Type : Gtk.Enums.Gtk_Path_Type; Path_Pattern : UTF8_String; Priority : Gtk.Enums.Gtk_Path_Priority_Type) is procedure Internal (Self : Gtk_Binding_Set; Path_Type : Gtk.Enums.Gtk_Path_Type; Path_Pattern : Gtkada.Types.Chars_Ptr; Priority : Gtk.Enums.Gtk_Path_Priority_Type); pragma Import (C, Internal, "gtk_binding_set_add_path"); Tmp_Path_Pattern : Gtkada.Types.Chars_Ptr := New_String (Path_Pattern); begin Internal (Self, Path_Type, Tmp_Path_Pattern, Priority); Free (Tmp_Path_Pattern); end Add_Path; ---------- -- Find -- ---------- function Find (Set_Name : UTF8_String) return Gtk_Binding_Set is function Internal (Set_Name : Gtkada.Types.Chars_Ptr) return access Gtk_Binding_Set; pragma Import (C, Internal, "gtk_binding_set_find"); Tmp_Set_Name : Gtkada.Types.Chars_Ptr := New_String (Set_Name); Tmp_Return : access Gtk_Binding_Set; begin Tmp_Return := Internal (Tmp_Set_Name); Free (Tmp_Set_Name); return Tmp_Return.all; end Find; end Gtk.Binding_Set; gtkada-24.0.0/src/generated/gtk-binding_set.ads000066400000000000000000000134711446021174000213230ustar00rootroot00000000000000------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ -- -- A binding set maintains a list of activatable key bindings. A single -- binding set can match multiple types of widgets. Similar to style contexts, -- can be matched by any information contained in a widgets -- Gtk.Widget.Gtk_Widget_Path. When a binding within a set is matched upon -- activation, an action signal is emitted on the target widget to carry out -- the actual activation. -- -- pragma Warnings (Off, "*is already use-visible*"); with Gdk.Types; use Gdk.Types; with Glib; use Glib; with Glib.Object; use Glib.Object; with Gtk.Enums; use Gtk.Enums; with Gtkada.Types; use Gtkada.Types; package Gtk.Binding_Set is type Gtk_Binding_Set is record Set_Name : Gtkada.Types.Chars_Ptr; Priority : Glib.Gint := 0; Widget_Path_Pspecs : System.Address := System.Null_Address; Widget_Class_Pspecs : System.Address := System.Null_Address; Class_Branch_Pspecs : System.Address := System.Null_Address; Entries : System.Address; Current : System.Address := System.Null_Address; Parsed : Guint; end record; pragma Convention (C, Gtk_Binding_Set); function From_Object_Free (B : access Gtk_Binding_Set) return Gtk_Binding_Set; pragma Inline (From_Object_Free); -- A binding set maintains a list of activatable key bindings. A single -- binding set can match multiple types of widgets. Similar to style -- contexts, can be matched by any information contained in a widgets -- Gtk.Widget.Gtk_Widget_Path. When a binding within a set is matched upon -- activation, an action signal is emitted on the target widget to carry -- out the actual activation. ------------------ -- Constructors -- ------------------ procedure Gtk_New (Self : out Gtk_Binding_Set; Set_Name : UTF8_String); -- GTK+ maintains a global list of binding sets. Each binding set has a -- unique name which needs to be specified upon creation. -- "set_name": unique name of this binding set function Gtk_Binding_Set_New (Set_Name : UTF8_String) return Gtk_Binding_Set; -- GTK+ maintains a global list of binding sets. Each binding set has a -- unique name which needs to be specified upon creation. -- "set_name": unique name of this binding set ------------- -- Methods -- ------------- function Activate (Self : Gtk_Binding_Set; Keyval : Guint; Modifiers : Gdk.Types.Gdk_Modifier_Type; Object : not null access Glib.Object.GObject_Record'Class) return Boolean; -- Find a key binding matching Keyval and Modifiers within Binding_Set and -- activate the binding on Object. -- "keyval": key value of the binding -- "modifiers": key modifier of the binding -- "object": object to activate when binding found procedure Add_Path (Self : Gtk_Binding_Set; Path_Type : Gtk.Enums.Gtk_Path_Type; Path_Pattern : UTF8_String; Priority : Gtk.Enums.Gtk_Path_Priority_Type); pragma Obsolescent (Add_Path); -- This function was used internally by the GtkRC parsing mechanism to -- assign match patterns to Gtk.Binding_Set.Gtk_Binding_Set structures. -- In GTK+ 3, these match patterns are unused. -- Deprecated since 3.0, 1 -- "path_type": path type the pattern applies to -- "path_pattern": the actual match pattern -- "priority": binding priority --------------- -- Functions -- --------------- function By_Class (Object_Class : System.Address) return Gtk_Binding_Set; pragma Import (C, By_Class, "gtk_binding_set_by_class"); -- This function returns the binding set named after the type name of the -- passed in class structure. New binding sets are created on demand by -- this function. -- "object_class": a valid Glib.Object.GObject class function Find (Set_Name : UTF8_String) return Gtk_Binding_Set; -- Find a binding set by its globally unique name. -- The Set_Name can either be a name used for Gtk.Binding_Set.Gtk_New or -- the type name of a class used in Gtk.Binding_Set.By_Class. -- "set_name": unique binding set name end Gtk.Binding_Set; gtkada-24.0.0/src/generated/gtk-box.adb000066400000000000000000000343001446021174000175770ustar00rootroot00000000000000------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ pragma Style_Checks (Off); pragma Warnings (Off, "*is already use-visible*"); with Glib.Type_Conversion_Hooks; use Glib.Type_Conversion_Hooks; package body Gtk.Box is package Type_Conversion_Gtk_Box is new Glib.Type_Conversion_Hooks.Hook_Registrator (Get_Type'Access, Gtk_Box_Record); pragma Unreferenced (Type_Conversion_Gtk_Box); ----------------- -- Gtk_Box_New -- ----------------- function Gtk_Box_New (Orientation : Gtk.Enums.Gtk_Orientation; Spacing : Glib.Gint) return Gtk_Box is Box : constant Gtk_Box := new Gtk_Box_Record; begin Gtk.Box.Initialize (Box, Orientation, Spacing); return Box; end Gtk_Box_New; ------------------ -- Gtk_Hbox_New -- ------------------ function Gtk_Hbox_New (Homogeneous : Boolean := False; Spacing : Glib.Gint := 0) return Gtk_Hbox is Box : constant Gtk_Hbox := new Gtk_Hbox_Record; begin Gtk.Box.Initialize_Hbox (Box, Homogeneous, Spacing); return Box; end Gtk_Hbox_New; ------------- -- Gtk_New -- ------------- procedure Gtk_New (Box : out Gtk_Box; Orientation : Gtk.Enums.Gtk_Orientation; Spacing : Glib.Gint) is begin Box := new Gtk_Box_Record; Gtk.Box.Initialize (Box, Orientation, Spacing); end Gtk_New; ------------------ -- Gtk_New_Hbox -- ------------------ procedure Gtk_New_Hbox (Box : out Gtk_Hbox; Homogeneous : Boolean := False; Spacing : Glib.Gint := 0) is begin Box := new Gtk_Hbox_Record; Gtk.Box.Initialize_Hbox (Box, Homogeneous, Spacing); end Gtk_New_Hbox; ------------------ -- Gtk_New_Vbox -- ------------------ procedure Gtk_New_Vbox (Box : out Gtk_Vbox; Homogeneous : Boolean := False; Spacing : Glib.Gint := 0) is begin Box := new Gtk_Vbox_Record; Gtk.Box.Initialize_Vbox (Box, Homogeneous, Spacing); end Gtk_New_Vbox; ------------------ -- Gtk_Vbox_New -- ------------------ function Gtk_Vbox_New (Homogeneous : Boolean := False; Spacing : Glib.Gint := 0) return Gtk_Vbox is Box : constant Gtk_Vbox := new Gtk_Vbox_Record; begin Gtk.Box.Initialize_Vbox (Box, Homogeneous, Spacing); return Box; end Gtk_Vbox_New; ---------------- -- Initialize -- ---------------- procedure Initialize (Box : not null access Gtk_Box_Record'Class; Orientation : Gtk.Enums.Gtk_Orientation; Spacing : Glib.Gint) is function Internal (Orientation : Gtk.Enums.Gtk_Orientation; Spacing : Glib.Gint) return System.Address; pragma Import (C, Internal, "gtk_box_new"); begin if not Box.Is_Created then Set_Object (Box, Internal (Orientation, Spacing)); end if; end Initialize; --------------------- -- Initialize_Hbox -- --------------------- procedure Initialize_Hbox (Box : not null access Gtk_Hbox_Record'Class; Homogeneous : Boolean := False; Spacing : Glib.Gint := 0) is function Internal (Homogeneous : Glib.Gboolean; Spacing : Glib.Gint) return System.Address; pragma Import (C, Internal, "gtk_hbox_new"); begin if not Box.Is_Created then Set_Object (Box, Internal (Boolean'Pos (Homogeneous), Spacing)); end if; end Initialize_Hbox; --------------------- -- Initialize_Vbox -- --------------------- procedure Initialize_Vbox (Box : not null access Gtk_Vbox_Record'Class; Homogeneous : Boolean := False; Spacing : Glib.Gint := 0) is function Internal (Homogeneous : Glib.Gboolean; Spacing : Glib.Gint) return System.Address; pragma Import (C, Internal, "gtk_vbox_new"); begin if not Box.Is_Created then Set_Object (Box, Internal (Boolean'Pos (Homogeneous), Spacing)); end if; end Initialize_Vbox; --------------------------- -- Get_Baseline_Position -- --------------------------- function Get_Baseline_Position (Box : not null access Gtk_Box_Record) return Gtk.Enums.Gtk_Baseline_Position is function Internal (Box : System.Address) return Gtk.Enums.Gtk_Baseline_Position; pragma Import (C, Internal, "gtk_box_get_baseline_position"); begin return Internal (Get_Object (Box)); end Get_Baseline_Position; ----------------------- -- Get_Center_Widget -- ----------------------- function Get_Center_Widget (Box : not null access Gtk_Box_Record) return Gtk.Widget.Gtk_Widget is function Internal (Box : System.Address) return System.Address; pragma Import (C, Internal, "gtk_box_get_center_widget"); Stub_Gtk_Widget : Gtk.Widget.Gtk_Widget_Record; begin return Gtk.Widget.Gtk_Widget (Get_User_Data (Internal (Get_Object (Box)), Stub_Gtk_Widget)); end Get_Center_Widget; --------------- -- Get_Child -- --------------- function Get_Child (Box : not null access Gtk_Box_Record; Num : Glib.Gint) return Gtk.Widget.Gtk_Widget is function Internal (Box : System.Address; Num : Glib.Gint) return System.Address; pragma Import (C, Internal, "ada_box_get_child"); Stub_Gtk_Widget : Gtk.Widget.Gtk_Widget_Record; begin return Gtk.Widget.Gtk_Widget (Get_User_Data (Internal (Get_Object (Box), Num), Stub_Gtk_Widget)); end Get_Child; --------------------- -- Get_Homogeneous -- --------------------- function Get_Homogeneous (Box : not null access Gtk_Box_Record) return Boolean is function Internal (Box : System.Address) return Glib.Gboolean; pragma Import (C, Internal, "gtk_box_get_homogeneous"); begin return Internal (Get_Object (Box)) /= 0; end Get_Homogeneous; ----------------- -- Get_Spacing -- ----------------- function Get_Spacing (Box : not null access Gtk_Box_Record) return Glib.Gint is function Internal (Box : System.Address) return Glib.Gint; pragma Import (C, Internal, "gtk_box_get_spacing"); begin return Internal (Get_Object (Box)); end Get_Spacing; -------------- -- Pack_End -- -------------- procedure Pack_End (In_Box : not null access Gtk_Box_Record; Child : not null access Gtk.Widget.Gtk_Widget_Record'Class; Expand : Boolean := True; Fill : Boolean := True; Padding : Guint := 0) is procedure Internal (In_Box : System.Address; Child : System.Address; Expand : Glib.Gboolean; Fill : Glib.Gboolean; Padding : Guint); pragma Import (C, Internal, "gtk_box_pack_end"); begin Internal (Get_Object (In_Box), Get_Object (Child), Boolean'Pos (Expand), Boolean'Pos (Fill), Padding); end Pack_End; ---------------- -- Pack_Start -- ---------------- procedure Pack_Start (In_Box : not null access Gtk_Box_Record; Child : not null access Gtk.Widget.Gtk_Widget_Record'Class; Expand : Boolean := True; Fill : Boolean := True; Padding : Guint := 0) is procedure Internal (In_Box : System.Address; Child : System.Address; Expand : Glib.Gboolean; Fill : Glib.Gboolean; Padding : Guint); pragma Import (C, Internal, "gtk_box_pack_start"); begin Internal (Get_Object (In_Box), Get_Object (Child), Boolean'Pos (Expand), Boolean'Pos (Fill), Padding); end Pack_Start; ------------------------- -- Query_Child_Packing -- ------------------------- procedure Query_Child_Packing (Box : not null access Gtk_Box_Record; Child : not null access Gtk.Widget.Gtk_Widget_Record'Class; Expand : out Boolean; Fill : out Boolean; Padding : out Guint; Pack_Type : out Gtk.Enums.Gtk_Pack_Type) is procedure Internal (Box : System.Address; Child : System.Address; Expand : out Glib.Gboolean; Fill : out Glib.Gboolean; Padding : out Guint; Pack_Type : out Gtk.Enums.Gtk_Pack_Type); pragma Import (C, Internal, "gtk_box_query_child_packing"); Tmp_Expand : aliased Glib.Gboolean; Tmp_Fill : aliased Glib.Gboolean; begin Internal (Get_Object (Box), Get_Object (Child), Tmp_Expand, Tmp_Fill, Padding, Pack_Type); Fill := Tmp_Fill /= 0; Expand := Tmp_Expand /= 0; end Query_Child_Packing; ------------------- -- Reorder_Child -- ------------------- procedure Reorder_Child (Box : not null access Gtk_Box_Record; Child : not null access Gtk.Widget.Gtk_Widget_Record'Class; Position : Glib.Gint) is procedure Internal (Box : System.Address; Child : System.Address; Position : Glib.Gint); pragma Import (C, Internal, "gtk_box_reorder_child"); begin Internal (Get_Object (Box), Get_Object (Child), Position); end Reorder_Child; --------------------------- -- Set_Baseline_Position -- --------------------------- procedure Set_Baseline_Position (Box : not null access Gtk_Box_Record; Position : Gtk.Enums.Gtk_Baseline_Position) is procedure Internal (Box : System.Address; Position : Gtk.Enums.Gtk_Baseline_Position); pragma Import (C, Internal, "gtk_box_set_baseline_position"); begin Internal (Get_Object (Box), Position); end Set_Baseline_Position; ----------------------- -- Set_Center_Widget -- ----------------------- procedure Set_Center_Widget (Box : not null access Gtk_Box_Record; Widget : access Gtk.Widget.Gtk_Widget_Record'Class) is procedure Internal (Box : System.Address; Widget : System.Address); pragma Import (C, Internal, "gtk_box_set_center_widget"); begin Internal (Get_Object (Box), Get_Object_Or_Null (GObject (Widget))); end Set_Center_Widget; ----------------------- -- Set_Child_Packing -- ----------------------- procedure Set_Child_Packing (Box : not null access Gtk_Box_Record; Child : not null access Gtk.Widget.Gtk_Widget_Record'Class; Expand : Boolean; Fill : Boolean; Padding : Guint; Pack_Type : Gtk.Enums.Gtk_Pack_Type) is procedure Internal (Box : System.Address; Child : System.Address; Expand : Glib.Gboolean; Fill : Glib.Gboolean; Padding : Guint; Pack_Type : Gtk.Enums.Gtk_Pack_Type); pragma Import (C, Internal, "gtk_box_set_child_packing"); begin Internal (Get_Object (Box), Get_Object (Child), Boolean'Pos (Expand), Boolean'Pos (Fill), Padding, Pack_Type); end Set_Child_Packing; --------------------- -- Set_Homogeneous -- --------------------- procedure Set_Homogeneous (Box : not null access Gtk_Box_Record; Homogeneous : Boolean) is procedure Internal (Box : System.Address; Homogeneous : Glib.Gboolean); pragma Import (C, Internal, "gtk_box_set_homogeneous"); begin Internal (Get_Object (Box), Boolean'Pos (Homogeneous)); end Set_Homogeneous; ----------------- -- Set_Spacing -- ----------------- procedure Set_Spacing (Box : not null access Gtk_Box_Record; Spacing : Glib.Gint) is procedure Internal (Box : System.Address; Spacing : Glib.Gint); pragma Import (C, Internal, "gtk_box_set_spacing"); begin Internal (Get_Object (Box), Spacing); end Set_Spacing; --------------------- -- Get_Orientation -- --------------------- function Get_Orientation (Self : not null access Gtk_Box_Record) return Gtk.Enums.Gtk_Orientation is function Internal (Self : System.Address) return Gtk.Enums.Gtk_Orientation; pragma Import (C, Internal, "gtk_orientable_get_orientation"); begin return Internal (Get_Object (Self)); end Get_Orientation; --------------------- -- Set_Orientation -- --------------------- procedure Set_Orientation (Self : not null access Gtk_Box_Record; Orientation : Gtk.Enums.Gtk_Orientation) is procedure Internal (Self : System.Address; Orientation : Gtk.Enums.Gtk_Orientation); pragma Import (C, Internal, "gtk_orientable_set_orientation"); begin Internal (Get_Object (Self), Orientation); end Set_Orientation; end Gtk.Box; gtkada-24.0.0/src/generated/gtk-box.ads000066400000000000000000000435171446021174000176320ustar00rootroot00000000000000------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ -- -- The GtkBox widget arranges child widgets into a single row or column, -- depending upon the value of its Gtk.Orientable.Gtk_Orientable:orientation -- property. Within the other dimension, all children are allocated the same -- size. Of course, the Gtk.Widget.Gtk_Widget:halign and -- Gtk.Widget.Gtk_Widget:valign properties can be used on the children to -- influence their allocation. -- -- GtkBox uses a notion of packing. Packing refers to adding widgets with -- reference to a particular position in a Gtk.Container.Gtk_Container. For a -- GtkBox, there are two reference positions: the start and the end of the -- box. For a vertical Gtk.Box.Gtk_Box, the start is defined as the top of the -- box and the end is defined as the bottom. For a horizontal Gtk.Box.Gtk_Box -- the start is defined as the left side and the end is defined as the right -- side. -- -- Use repeated calls to Gtk.Box.Pack_Start to pack widgets into a GtkBox -- from start to end. Use Gtk.Box.Pack_End to add widgets from end to start. -- You may intersperse these calls and add widgets from both ends of the same -- GtkBox. -- -- Because GtkBox is a Gtk.Container.Gtk_Container, you may also use -- Gtk.Container.Add to insert widgets into the box, and they will be packed -- with the default values for expand and fill child properties. Use -- Gtk.Container.Remove to remove widgets from the GtkBox. -- -- Use Gtk.Box.Set_Homogeneous to specify whether or not all children of the -- GtkBox are forced to get the same amount of space. -- -- Use Gtk.Box.Set_Spacing to determine how much space will be minimally -- placed between all children in the GtkBox. Note that spacing is added -- between the children, while padding added by Gtk.Box.Pack_Start or -- Gtk.Box.Pack_End is added on either side of the widget it belongs to. -- -- Use Gtk.Box.Reorder_Child to move a GtkBox child to a different place in -- the box. -- -- Use Gtk.Box.Set_Child_Packing to reset the expand, fill and padding child -- properties. Use Gtk.Box.Query_Child_Packing to query these fields. -- -- # CSS nodes -- -- GtkBox uses a single CSS node with name box. -- -- In horizontal orientation, the nodes of the children are always arranged -- from left to right. So :first-child will always select the leftmost child, -- regardless of text direction. -- -- -- -- See the testgtk example in the GtkAda distribution to see concrete -- examples on how all the parameters for the boxes work. -- -- -- gtk-box -- Layout containers -- create_box.adb pragma Warnings (Off, "*is already use-visible*"); with Glib; use Glib; with Glib.Properties; use Glib.Properties; with Glib.Types; use Glib.Types; with Gtk.Buildable; use Gtk.Buildable; with Gtk.Container; use Gtk.Container; with Gtk.Enums; use Gtk.Enums; with Gtk.Orientable; use Gtk.Orientable; with Gtk.Widget; use Gtk.Widget; package Gtk.Box is type Gtk_Box_Record is new Gtk_Container_Record with null record; type Gtk_Box is access all Gtk_Box_Record'Class; subtype Gtk_Hbox_Record is Gtk_Box_Record; subtype Gtk_Hbox is Gtk_Box; subtype Gtk_Vbox_Record is Gtk_Box_Record; subtype Gtk_Vbox is Gtk_Box; ------------------ -- Constructors -- ------------------ procedure Gtk_New (Box : out Gtk_Box; Orientation : Gtk.Enums.Gtk_Orientation; Spacing : Glib.Gint); procedure Initialize (Box : not null access Gtk_Box_Record'Class; Orientation : Gtk.Enums.Gtk_Orientation; Spacing : Glib.Gint); -- Creates a new Gtk.Box.Gtk_Box. -- Since: gtk+ 3.0 -- Initialize does nothing if the object was already created with another -- call to Initialize* or G_New. -- "orientation": the box's orientation. -- "spacing": the number of pixels to place by default between children. function Gtk_Box_New (Orientation : Gtk.Enums.Gtk_Orientation; Spacing : Glib.Gint) return Gtk_Box; -- Creates a new Gtk.Box.Gtk_Box. -- Since: gtk+ 3.0 -- "orientation": the box's orientation. -- "spacing": the number of pixels to place by default between children. function Get_Type return Glib.GType; pragma Import (C, Get_Type, "gtk_box_get_type"); -- Used with Glib.Object.G_New, this creates a horizontal box procedure Gtk_New_Hbox (Box : out Gtk_Hbox; Homogeneous : Boolean := False; Spacing : Glib.Gint := 0); procedure Initialize_Hbox (Box : not null access Gtk_Hbox_Record'Class; Homogeneous : Boolean := False; Spacing : Glib.Gint := 0); -- Creates a new Gtk.Box.Gtk_Hbox. -- Initialize_Hbox does nothing if the object was already created with -- another call to Initialize* or G_New. -- "homogeneous": True if all children are to be given equal space -- allotments. -- "spacing": the number of pixels to place by default between children. function Gtk_Hbox_New (Homogeneous : Boolean := False; Spacing : Glib.Gint := 0) return Gtk_Hbox; -- Creates a new Gtk.Box.Gtk_Hbox. -- "homogeneous": True if all children are to be given equal space -- allotments. -- "spacing": the number of pixels to place by default between children. function Get_Hbox_Type return Glib.GType; pragma Import (C, Get_Hbox_Type, "gtk_hbox_get_type"); procedure Gtk_New_Vbox (Box : out Gtk_Vbox; Homogeneous : Boolean := False; Spacing : Glib.Gint := 0); procedure Initialize_Vbox (Box : not null access Gtk_Vbox_Record'Class; Homogeneous : Boolean := False; Spacing : Glib.Gint := 0); -- Creates a new Gtk.Box.Gtk_Vbox. -- Initialize_Vbox does nothing if the object was already created with -- another call to Initialize* or G_New. -- "homogeneous": True if all children are to be given equal space -- allotments. -- "spacing": the number of pixels to place by default between children. function Gtk_Vbox_New (Homogeneous : Boolean := False; Spacing : Glib.Gint := 0) return Gtk_Vbox; -- Creates a new Gtk.Box.Gtk_Vbox. -- "homogeneous": True if all children are to be given equal space -- allotments. -- "spacing": the number of pixels to place by default between children. function Get_Vbox_Type return Glib.GType; pragma Import (C, Get_Vbox_Type, "gtk_vbox_get_type"); ------------- -- Methods -- ------------- function Get_Baseline_Position (Box : not null access Gtk_Box_Record) return Gtk.Enums.Gtk_Baseline_Position; -- Gets the value set by Gtk.Box.Set_Baseline_Position. -- Since: gtk+ 3.10 procedure Set_Baseline_Position (Box : not null access Gtk_Box_Record; Position : Gtk.Enums.Gtk_Baseline_Position); -- Sets the baseline position of a box. This affects only horizontal boxes -- with at least one baseline aligned child. If there is more vertical -- space available than requested, and the baseline is not allocated by the -- parent then Position is used to allocate the baseline wrt the extra -- space available. -- Since: gtk+ 3.10 -- "position": a Gtk.Enums.Gtk_Baseline_Position function Get_Center_Widget (Box : not null access Gtk_Box_Record) return Gtk.Widget.Gtk_Widget; -- Retrieves the center widget of the box. -- Since: gtk+ 3.12 procedure Set_Center_Widget (Box : not null access Gtk_Box_Record; Widget : access Gtk.Widget.Gtk_Widget_Record'Class); -- Sets a center widget; that is a child widget that will be centered with -- respect to the full width of the box, even if the children at either -- side take up different amounts of space. -- Since: gtk+ 3.12 -- "widget": the widget to center function Get_Homogeneous (Box : not null access Gtk_Box_Record) return Boolean; -- Returns whether the box is homogeneous (all children are the same -- size). See Gtk.Box.Set_Homogeneous. procedure Set_Homogeneous (Box : not null access Gtk_Box_Record; Homogeneous : Boolean); -- Sets the Gtk.Box.Gtk_Box:homogeneous property of Box, controlling -- whether or not all children of Box are given equal space in the box. -- "homogeneous": a boolean value, True to create equal allotments, False -- for variable allotments function Get_Spacing (Box : not null access Gtk_Box_Record) return Glib.Gint; -- Gets the value set by Gtk.Box.Set_Spacing. procedure Set_Spacing (Box : not null access Gtk_Box_Record; Spacing : Glib.Gint); -- Sets the Gtk.Box.Gtk_Box:spacing property of Box, which is the number -- of pixels to place between children of Box. -- "spacing": the number of pixels to put between children procedure Pack_End (In_Box : not null access Gtk_Box_Record; Child : not null access Gtk.Widget.Gtk_Widget_Record'Class; Expand : Boolean := True; Fill : Boolean := True; Padding : Guint := 0); -- Adds Child to Box, packed with reference to the end of Box. The Child -- is packed after (away from end of) any other child packed with reference -- to the end of Box. -- "child": the Gtk.Widget.Gtk_Widget to be added to Box -- "expand": True if the new child is to be given extra space allocated to -- Box. The extra space will be divided evenly between all children of Box -- that use this option -- "fill": True if space given to Child by the Expand option is actually -- allocated to Child, rather than just padding it. This parameter has no -- effect if Expand is set to False. A child is always allocated the full -- height of a horizontal Gtk.Box.Gtk_Box and the full width of a vertical -- Gtk.Box.Gtk_Box. This option affects the other dimension -- "padding": extra space in pixels to put between this child and its -- neighbors, over and above the global amount specified by -- Gtk.Box.Gtk_Box:spacing property. If Child is a widget at one of the -- reference ends of Box, then Padding pixels are also put between Child -- and the reference edge of Box procedure Pack_Start (In_Box : not null access Gtk_Box_Record; Child : not null access Gtk.Widget.Gtk_Widget_Record'Class; Expand : Boolean := True; Fill : Boolean := True; Padding : Guint := 0); -- Adds Child to Box, packed with reference to the start of Box. The Child -- is packed after any other child packed with reference to the start of -- Box. -- "child": the Gtk.Widget.Gtk_Widget to be added to Box -- "expand": True if the new child is to be given extra space allocated to -- Box. The extra space will be divided evenly between all children that -- use this option -- "fill": True if space given to Child by the Expand option is actually -- allocated to Child, rather than just padding it. This parameter has no -- effect if Expand is set to False. A child is always allocated the full -- height of a horizontal Gtk.Box.Gtk_Box and the full width of a vertical -- Gtk.Box.Gtk_Box. This option affects the other dimension -- "padding": extra space in pixels to put between this child and its -- neighbors, over and above the global amount specified by -- Gtk.Box.Gtk_Box:spacing property. If Child is a widget at one of the -- reference ends of Box, then Padding pixels are also put between Child -- and the reference edge of Box procedure Query_Child_Packing (Box : not null access Gtk_Box_Record; Child : not null access Gtk.Widget.Gtk_Widget_Record'Class; Expand : out Boolean; Fill : out Boolean; Padding : out Guint; Pack_Type : out Gtk.Enums.Gtk_Pack_Type); -- Obtains information about how Child is packed into Box. -- "child": the Gtk.Widget.Gtk_Widget of the child to query -- "expand": pointer to return location for expand child property -- "fill": pointer to return location for fill child property -- "padding": pointer to return location for padding child property -- "pack_type": pointer to return location for pack-type child property procedure Set_Child_Packing (Box : not null access Gtk_Box_Record; Child : not null access Gtk.Widget.Gtk_Widget_Record'Class; Expand : Boolean; Fill : Boolean; Padding : Guint; Pack_Type : Gtk.Enums.Gtk_Pack_Type); -- Sets the way Child is packed into Box. -- "child": the Gtk.Widget.Gtk_Widget of the child to set -- "expand": the new value of the expand child property -- "fill": the new value of the fill child property -- "padding": the new value of the padding child property -- "pack_type": the new value of the pack-type child property procedure Reorder_Child (Box : not null access Gtk_Box_Record; Child : not null access Gtk.Widget.Gtk_Widget_Record'Class; Position : Glib.Gint); -- Moves Child to a new Position in the list of Box children. The list -- contains widgets packed GTK_PACK_START as well as widgets packed -- GTK_PACK_END, in the order that these widgets were added to Box. -- A widget's position in the Box children list determines where the -- widget is packed into Box. A child widget at some position in the list -- will be packed just after all other widgets of the same packing type -- that appear earlier in the list. -- "child": the Gtk.Widget.Gtk_Widget to move -- "position": the new position for Child in the list of children of Box, -- starting from 0. If negative, indicates the end of the list function Get_Child (Box : not null access Gtk_Box_Record; Num : Glib.Gint) return Gtk.Widget.Gtk_Widget; -- Return the Num-th child of the box, or null if there is no such child -- Since: gtk+ GtkAda 1.0 --------------------------------------------- -- Inherited subprograms (from interfaces) -- --------------------------------------------- -- Methods inherited from the Buildable interface are not duplicated here -- since they are meant to be used by tools, mostly. If you need to call -- them, use an explicit cast through the "-" operator below. function Get_Orientation (Self : not null access Gtk_Box_Record) return Gtk.Enums.Gtk_Orientation; procedure Set_Orientation (Self : not null access Gtk_Box_Record; Orientation : Gtk.Enums.Gtk_Orientation); ---------------- -- Properties -- ---------------- -- The following properties are defined for this widget. See -- Glib.Properties for more information on properties) Baseline_Position_Property : constant Gtk.Enums.Property_Gtk_Baseline_Position; Homogeneous_Property : constant Glib.Properties.Property_Boolean; Spacing_Property : constant Glib.Properties.Property_Int; ---------------- -- Interfaces -- ---------------- -- This class implements several interfaces. See Glib.Types -- -- - "Buildable" -- -- - "Orientable" package Implements_Gtk_Buildable is new Glib.Types.Implements (Gtk.Buildable.Gtk_Buildable, Gtk_Box_Record, Gtk_Box); function "+" (Widget : access Gtk_Box_Record'Class) return Gtk.Buildable.Gtk_Buildable renames Implements_Gtk_Buildable.To_Interface; function "-" (Interf : Gtk.Buildable.Gtk_Buildable) return Gtk_Box renames Implements_Gtk_Buildable.To_Object; package Implements_Gtk_Orientable is new Glib.Types.Implements (Gtk.Orientable.Gtk_Orientable, Gtk_Box_Record, Gtk_Box); function "+" (Widget : access Gtk_Box_Record'Class) return Gtk.Orientable.Gtk_Orientable renames Implements_Gtk_Orientable.To_Interface; function "-" (Interf : Gtk.Orientable.Gtk_Orientable) return Gtk_Box renames Implements_Gtk_Orientable.To_Object; private Spacing_Property : constant Glib.Properties.Property_Int := Glib.Properties.Build ("spacing"); Homogeneous_Property : constant Glib.Properties.Property_Boolean := Glib.Properties.Build ("homogeneous"); Baseline_Position_Property : constant Gtk.Enums.Property_Gtk_Baseline_Position := Gtk.Enums.Build ("baseline-position"); end Gtk.Box; gtkada-24.0.0/src/generated/gtk-buildable.adb000066400000000000000000000204211446021174000207310ustar00rootroot00000000000000------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ pragma Style_Checks (Off); pragma Warnings (Off, "*is already use-visible*"); with Gtkada.Bindings; use Gtkada.Bindings; pragma Warnings(Off); -- might be unused with Gtkada.Types; use Gtkada.Types; pragma Warnings(On); package body Gtk.Buildable is --------------- -- Add_Child -- --------------- procedure Add_Child (Self : Gtk_Buildable; Builder : not null access Gtk.Builder.Gtk_Builder_Record'Class; Child : not null access Glib.Object.GObject_Record'Class; The_Type : UTF8_String := ""; Error : Glib.Error.GError) is procedure Internal (Self : Gtk_Buildable; Builder : System.Address; Child : System.Address; The_Type : Gtkada.Types.Chars_Ptr; Error : Glib.Error.GError); pragma Import (C, Internal, "gtk_buildable_add_child"); Tmp_The_Type : Gtkada.Types.Chars_Ptr; begin if The_Type = "" then Tmp_The_Type := Gtkada.Types.Null_Ptr; else Tmp_The_Type := New_String (The_Type); end if; Internal (Self, Get_Object (Builder), Get_Object (Child), Tmp_The_Type, Error); Free (Tmp_The_Type); end Add_Child; --------------------- -- Construct_Child -- --------------------- function Construct_Child (Self : Gtk_Buildable; Builder : not null access Gtk.Builder.Gtk_Builder_Record'Class; Name : UTF8_String) return Glib.Object.GObject is function Internal (Self : Gtk_Buildable; Builder : System.Address; Name : Gtkada.Types.Chars_Ptr) return System.Address; pragma Import (C, Internal, "gtk_buildable_construct_child"); Tmp_Name : Gtkada.Types.Chars_Ptr := New_String (Name); Stub_GObject : Glib.Object.GObject_Record; Tmp_Return : System.Address; begin Tmp_Return := Internal (Self, Get_Object (Builder), Tmp_Name); Free (Tmp_Name); return Get_User_Data (Tmp_Return, Stub_GObject); end Construct_Child; --------------------- -- Custom_Finished -- --------------------- procedure Custom_Finished (Self : Gtk_Buildable; Builder : not null access Gtk.Builder.Gtk_Builder_Record'Class; Child : access Glib.Object.GObject_Record'Class; Tagname : UTF8_String; Data : System.Address) is procedure Internal (Self : Gtk_Buildable; Builder : System.Address; Child : System.Address; Tagname : Gtkada.Types.Chars_Ptr; Data : System.Address); pragma Import (C, Internal, "gtk_buildable_custom_finished"); Tmp_Tagname : Gtkada.Types.Chars_Ptr := New_String (Tagname); begin Internal (Self, Get_Object (Builder), Get_Object_Or_Null (GObject (Child)), Tmp_Tagname, Data); Free (Tmp_Tagname); end Custom_Finished; -------------------- -- Custom_Tag_End -- -------------------- procedure Custom_Tag_End (Self : Gtk_Buildable; Builder : not null access Gtk.Builder.Gtk_Builder_Record'Class; Child : access Glib.Object.GObject_Record'Class; Tagname : UTF8_String; Data : in out System.Address) is procedure Internal (Self : Gtk_Buildable; Builder : System.Address; Child : System.Address; Tagname : Gtkada.Types.Chars_Ptr; Data : in out System.Address); pragma Import (C, Internal, "gtk_buildable_custom_tag_end"); Tmp_Tagname : Gtkada.Types.Chars_Ptr := New_String (Tagname); begin Internal (Self, Get_Object (Builder), Get_Object_Or_Null (GObject (Child)), Tmp_Tagname, Data); Free (Tmp_Tagname); end Custom_Tag_End; ------------------------ -- Get_Internal_Child -- ------------------------ function Get_Internal_Child (Self : Gtk_Buildable; Builder : not null access Gtk.Builder.Gtk_Builder_Record'Class; Childname : UTF8_String) return Glib.Object.GObject is function Internal (Self : Gtk_Buildable; Builder : System.Address; Childname : Gtkada.Types.Chars_Ptr) return System.Address; pragma Import (C, Internal, "gtk_buildable_get_internal_child"); Tmp_Childname : Gtkada.Types.Chars_Ptr := New_String (Childname); Stub_GObject : Glib.Object.GObject_Record; Tmp_Return : System.Address; begin Tmp_Return := Internal (Self, Get_Object (Builder), Tmp_Childname); Free (Tmp_Childname); return Get_User_Data (Tmp_Return, Stub_GObject); end Get_Internal_Child; -------------- -- Get_Name -- -------------- function Get_Name (Self : Gtk_Buildable) return UTF8_String is function Internal (Self : Gtk_Buildable) return Gtkada.Types.Chars_Ptr; pragma Import (C, Internal, "gtk_buildable_get_name"); begin return Gtkada.Bindings.Value_Allowing_Null (Internal (Self)); end Get_Name; --------------------- -- Parser_Finished -- --------------------- procedure Parser_Finished (Self : Gtk_Buildable; Builder : not null access Gtk.Builder.Gtk_Builder_Record'Class) is procedure Internal (Self : Gtk_Buildable; Builder : System.Address); pragma Import (C, Internal, "gtk_buildable_parser_finished"); begin Internal (Self, Get_Object (Builder)); end Parser_Finished; ---------------------------- -- Set_Buildable_Property -- ---------------------------- procedure Set_Buildable_Property (Self : Gtk_Buildable; Builder : not null access Gtk.Builder.Gtk_Builder_Record'Class; Name : UTF8_String; Value : in out Glib.Values.GValue) is procedure Internal (Self : Gtk_Buildable; Builder : System.Address; Name : Gtkada.Types.Chars_Ptr; Value : in out Glib.Values.GValue); pragma Import (C, Internal, "gtk_buildable_set_buildable_property"); Tmp_Name : Gtkada.Types.Chars_Ptr := New_String (Name); begin Internal (Self, Get_Object (Builder), Tmp_Name, Value); Free (Tmp_Name); end Set_Buildable_Property; -------------- -- Set_Name -- -------------- procedure Set_Name (Self : Gtk_Buildable; Name : UTF8_String) is procedure Internal (Self : Gtk_Buildable; Name : Gtkada.Types.Chars_Ptr); pragma Import (C, Internal, "gtk_buildable_set_name"); Tmp_Name : Gtkada.Types.Chars_Ptr := New_String (Name); begin Internal (Self, Tmp_Name); Free (Tmp_Name); end Set_Name; function "+" (W : Gtk_Buildable) return Gtk_Buildable is begin return W; end "+"; end Gtk.Buildable; gtkada-24.0.0/src/generated/gtk-buildable.ads000066400000000000000000000163051446021174000207600ustar00rootroot00000000000000------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ -- -- GtkBuildable allows objects to extend and customize their deserialization -- from [GtkBuilder UI descriptions][BUILDER-UI]. The interface includes -- methods for setting names and properties of objects, parsing custom tags -- and constructing child objects. -- -- The GtkBuildable interface is implemented by all widgets and many of the -- non-widget objects that are provided by GTK+. The main user of this -- interface is Gtk.Builder.Gtk_Builder. There should be very little need for -- applications to call any of these functions directly. -- -- An object only needs to implement this interface if it needs to extend the -- Gtk.Builder.Gtk_Builder format or run any extra routines at deserialization -- time. -- -- pragma Warnings (Off, "*is already use-visible*"); with Glib; use Glib; with Glib.Error; use Glib.Error; with Glib.Object; use Glib.Object; with Glib.Types; use Glib.Types; with Glib.Values; use Glib.Values; with Gtk.Builder; use Gtk.Builder; package Gtk.Buildable is type Gtk_Buildable is new Glib.Types.GType_Interface; Null_Gtk_Buildable : constant Gtk_Buildable; ------------------ -- Constructors -- ------------------ function Get_Type return Glib.GType; pragma Import (C, Get_Type, "gtk_buildable_get_type"); ------------- -- Methods -- ------------- procedure Add_Child (Self : Gtk_Buildable; Builder : not null access Gtk.Builder.Gtk_Builder_Record'Class; Child : not null access Glib.Object.GObject_Record'Class; The_Type : UTF8_String := ""; Error : Glib.Error.GError); -- Adds a child to Buildable. Type is an optional string describing how -- the child should be added. -- Since: gtk+ 2.12 -- "builder": a Gtk.Builder.Gtk_Builder -- "child": child to add -- "type": kind of child or null function Construct_Child (Self : Gtk_Buildable; Builder : not null access Gtk.Builder.Gtk_Builder_Record'Class; Name : UTF8_String) return Glib.Object.GObject; -- Constructs a child of Buildable with the name Name. -- Gtk.Builder.Gtk_Builder calls this function if a "constructor" has been -- specified in the UI definition. -- Since: gtk+ 2.12 -- "builder": Gtk.Builder.Gtk_Builder used to construct this object -- "name": name of child to construct procedure Custom_Finished (Self : Gtk_Buildable; Builder : not null access Gtk.Builder.Gtk_Builder_Record'Class; Child : access Glib.Object.GObject_Record'Class; Tagname : UTF8_String; Data : System.Address); -- This is similar to Gtk.Buildable.Parser_Finished but is called once for -- each custom tag handled by the Buildable. -- Since: gtk+ 2.12 -- "builder": a Gtk.Builder.Gtk_Builder -- "child": child object or null for non-child tags -- "tagname": the name of the tag -- "data": user data created in custom_tag_start procedure Custom_Tag_End (Self : Gtk_Buildable; Builder : not null access Gtk.Builder.Gtk_Builder_Record'Class; Child : access Glib.Object.GObject_Record'Class; Tagname : UTF8_String; Data : in out System.Address); -- This is called at the end of each custom element handled by the -- buildable. -- Since: gtk+ 2.12 -- "builder": Gtk.Builder.Gtk_Builder used to construct this object -- "child": child object or null for non-child tags -- "tagname": name of tag -- "data": user data that will be passed in to parser functions function Get_Internal_Child (Self : Gtk_Buildable; Builder : not null access Gtk.Builder.Gtk_Builder_Record'Class; Childname : UTF8_String) return Glib.Object.GObject; -- Get the internal child called Childname of the Buildable object. -- Since: gtk+ 2.12 -- "builder": a Gtk.Builder.Gtk_Builder -- "childname": name of child function Get_Name (Self : Gtk_Buildable) return UTF8_String; -- Gets the name of the Buildable object. -- Gtk.Builder.Gtk_Builder sets the name based on the [GtkBuilder UI -- definition][BUILDER-UI] used to construct the Buildable. -- Since: gtk+ 2.12 procedure Set_Name (Self : Gtk_Buildable; Name : UTF8_String); -- Sets the name of the Buildable object. -- Since: gtk+ 2.12 -- "name": name to set procedure Parser_Finished (Self : Gtk_Buildable; Builder : not null access Gtk.Builder.Gtk_Builder_Record'Class); -- Called when the builder finishes the parsing of a [GtkBuilder UI -- definition][BUILDER-UI]. Note that this will be called once for each -- time Gtk.Builder.Add_From_File or Gtk.Builder.Add_From_String is called -- on a builder. -- Since: gtk+ 2.12 -- "builder": a Gtk.Builder.Gtk_Builder procedure Set_Buildable_Property (Self : Gtk_Buildable; Builder : not null access Gtk.Builder.Gtk_Builder_Record'Class; Name : UTF8_String; Value : in out Glib.Values.GValue); -- Sets the property name Name to Value on the Buildable object. -- Since: gtk+ 2.12 -- "builder": a Gtk.Builder.Gtk_Builder -- "name": name of property -- "value": value of property ---------------- -- Interfaces -- ---------------- -- This class implements several interfaces. See Glib.Types -- -- - "Gtk_Buildable" function "+" (W : Gtk_Buildable) return Gtk_Buildable; pragma Inline ("+"); private Null_Gtk_Buildable : constant Gtk_Buildable := Gtk_Buildable (Glib.Types.Null_Interface); end Gtk.Buildable; gtkada-24.0.0/src/generated/gtk-builder.adb000066400000000000000000000565331446021174000204510ustar00rootroot00000000000000------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ pragma Style_Checks (Off); pragma Warnings (Off, "*is already use-visible*"); with Ada.Unchecked_Conversion; with Glib.Type_Conversion_Hooks; use Glib.Type_Conversion_Hooks; with Gtkada.Bindings; use Gtkada.Bindings; pragma Warnings(Off); -- might be unused with Gtkada.Types; use Gtkada.Types; pragma Warnings(On); package body Gtk.Builder is procedure C_Gtk_Builder_Connect_Signals_Full (Builder : System.Address; Func : System.Address; User_Data : System.Address); pragma Import (C, C_Gtk_Builder_Connect_Signals_Full, "gtk_builder_connect_signals_full"); -- This function can be thought of the interpreted language binding -- version of Gtk.Builder.Connect_Signals, except that it does not require -- GModule to function correctly. -- Since: gtk+ 2.12 -- "func": the function used to connect the signals -- "user_data": arbitrary data that will be passed to the connection -- function function To_Gtk_Builder_Connect_Func is new Ada.Unchecked_Conversion (System.Address, Gtk_Builder_Connect_Func); function To_Address is new Ada.Unchecked_Conversion (Gtk_Builder_Connect_Func, System.Address); procedure Internal_Gtk_Builder_Connect_Func (Builder : System.Address; Object : System.Address; Signal_Name : Gtkada.Types.Chars_Ptr; Handler_Name : Gtkada.Types.Chars_Ptr; Connect_Object : System.Address; Flags : Glib.G_Connect_Flags; User_Data : System.Address); pragma Convention (C, Internal_Gtk_Builder_Connect_Func); -- "builder": a Gtk.Builder.Gtk_Builder -- "object": object to connect a signal to -- "signal_name": name of the signal -- "handler_name": name of the handler -- "connect_object": a Glib.Object.GObject, if non-null, use -- g_signal_connect_object -- "flags": Glib.G_Connect_Flags to use -- "user_data": user data --------------------------------------- -- Internal_Gtk_Builder_Connect_Func -- --------------------------------------- procedure Internal_Gtk_Builder_Connect_Func (Builder : System.Address; Object : System.Address; Signal_Name : Gtkada.Types.Chars_Ptr; Handler_Name : Gtkada.Types.Chars_Ptr; Connect_Object : System.Address; Flags : Glib.G_Connect_Flags; User_Data : System.Address) is Func : constant Gtk_Builder_Connect_Func := To_Gtk_Builder_Connect_Func (User_Data); Stub_Gtk_Builder : Gtk_Builder_Record; Stub_GObject : Glib.Object.GObject_Record; begin Func (Gtk.Builder.Gtk_Builder (Get_User_Data (Builder, Stub_Gtk_Builder)), Get_User_Data (Object, Stub_GObject), Gtkada.Bindings.Value_Allowing_Null (Signal_Name), Gtkada.Bindings.Value_Allowing_Null (Handler_Name), Get_User_Data (Connect_Object, Stub_GObject), Flags); end Internal_Gtk_Builder_Connect_Func; package Type_Conversion_Gtk_Builder is new Glib.Type_Conversion_Hooks.Hook_Registrator (Get_Type'Access, Gtk_Builder_Record); pragma Unreferenced (Type_Conversion_Gtk_Builder); --------------------- -- Gtk_Builder_New -- --------------------- function Gtk_Builder_New return Gtk_Builder is Builder : constant Gtk_Builder := new Gtk_Builder_Record; begin Gtk.Builder.Initialize (Builder); return Builder; end Gtk_Builder_New; ------------------------------- -- Gtk_Builder_New_From_File -- ------------------------------- function Gtk_Builder_New_From_File (Filename : UTF8_String) return Gtk_Builder is Builder : constant Gtk_Builder := new Gtk_Builder_Record; begin Gtk.Builder.Initialize_From_File (Builder, Filename); return Builder; end Gtk_Builder_New_From_File; ----------------------------------- -- Gtk_Builder_New_From_Resource -- ----------------------------------- function Gtk_Builder_New_From_Resource (Resource_Path : UTF8_String) return Gtk_Builder is Builder : constant Gtk_Builder := new Gtk_Builder_Record; begin Gtk.Builder.Initialize_From_Resource (Builder, Resource_Path); return Builder; end Gtk_Builder_New_From_Resource; --------------------------------- -- Gtk_Builder_New_From_String -- --------------------------------- function Gtk_Builder_New_From_String (String : UTF8_String; Length : Gssize) return Gtk_Builder is Builder : constant Gtk_Builder := new Gtk_Builder_Record; begin Gtk.Builder.Initialize_From_String (Builder, String, Length); return Builder; end Gtk_Builder_New_From_String; ------------- -- Gtk_New -- ------------- procedure Gtk_New (Builder : out Gtk_Builder) is begin Builder := new Gtk_Builder_Record; Gtk.Builder.Initialize (Builder); end Gtk_New; ----------------------- -- Gtk_New_From_File -- ----------------------- procedure Gtk_New_From_File (Builder : out Gtk_Builder; Filename : UTF8_String) is begin Builder := new Gtk_Builder_Record; Gtk.Builder.Initialize_From_File (Builder, Filename); end Gtk_New_From_File; --------------------------- -- Gtk_New_From_Resource -- --------------------------- procedure Gtk_New_From_Resource (Builder : out Gtk_Builder; Resource_Path : UTF8_String) is begin Builder := new Gtk_Builder_Record; Gtk.Builder.Initialize_From_Resource (Builder, Resource_Path); end Gtk_New_From_Resource; ------------------------- -- Gtk_New_From_String -- ------------------------- procedure Gtk_New_From_String (Builder : out Gtk_Builder; String : UTF8_String; Length : Gssize) is begin Builder := new Gtk_Builder_Record; Gtk.Builder.Initialize_From_String (Builder, String, Length); end Gtk_New_From_String; ---------------- -- Initialize -- ---------------- procedure Initialize (Builder : not null access Gtk_Builder_Record'Class) is function Internal return System.Address; pragma Import (C, Internal, "gtk_builder_new"); begin if not Builder.Is_Created then Set_Object (Builder, Internal); end if; end Initialize; -------------------------- -- Initialize_From_File -- -------------------------- procedure Initialize_From_File (Builder : not null access Gtk_Builder_Record'Class; Filename : UTF8_String) is function Internal (Filename : Gtkada.Types.Chars_Ptr) return System.Address; pragma Import (C, Internal, "gtk_builder_new_from_file"); Tmp_Filename : Gtkada.Types.Chars_Ptr := New_String (Filename); Tmp_Return : System.Address; begin if not Builder.Is_Created then Tmp_Return := Internal (Tmp_Filename); Free (Tmp_Filename); Set_Object (Builder, Tmp_Return); end if; end Initialize_From_File; ------------------------------ -- Initialize_From_Resource -- ------------------------------ procedure Initialize_From_Resource (Builder : not null access Gtk_Builder_Record'Class; Resource_Path : UTF8_String) is function Internal (Resource_Path : Gtkada.Types.Chars_Ptr) return System.Address; pragma Import (C, Internal, "gtk_builder_new_from_resource"); Tmp_Resource_Path : Gtkada.Types.Chars_Ptr := New_String (Resource_Path); Tmp_Return : System.Address; begin if not Builder.Is_Created then Tmp_Return := Internal (Tmp_Resource_Path); Free (Tmp_Resource_Path); Set_Object (Builder, Tmp_Return); end if; end Initialize_From_Resource; ---------------------------- -- Initialize_From_String -- ---------------------------- procedure Initialize_From_String (Builder : not null access Gtk_Builder_Record'Class; String : UTF8_String; Length : Gssize) is function Internal (String : Gtkada.Types.Chars_Ptr; Length : Gssize) return System.Address; pragma Import (C, Internal, "gtk_builder_new_from_string"); Tmp_String : Gtkada.Types.Chars_Ptr := New_String (String); Tmp_Return : System.Address; begin if not Builder.Is_Created then Tmp_Return := Internal (Tmp_String, Length); Free (Tmp_String); Set_Object (Builder, Tmp_Return); end if; end Initialize_From_String; ------------------- -- Add_From_File -- ------------------- function Add_From_File (Builder : not null access Gtk_Builder_Record; Filename : UTF8_String; Error : access Glib.Error.GError) return Guint is function Internal (Builder : System.Address; Filename : Gtkada.Types.Chars_Ptr; Acc_Error : access Glib.Error.GError) return Guint; pragma Import (C, Internal, "gtk_builder_add_from_file"); Acc_Error : aliased Glib.Error.GError; Tmp_Filename : Gtkada.Types.Chars_Ptr := New_String (Filename); Tmp_Return : Guint; begin Tmp_Return := Internal (Get_Object (Builder), Tmp_Filename, Acc_Error'Access); Free (Tmp_Filename); if Error /= null then Error.all := Acc_Error; end if; return Tmp_Return; end Add_From_File; ----------------------- -- Add_From_Resource -- ----------------------- function Add_From_Resource (Builder : not null access Gtk_Builder_Record; Resource_Path : UTF8_String; Error : access Glib.Error.GError) return Guint is function Internal (Builder : System.Address; Resource_Path : Gtkada.Types.Chars_Ptr; Acc_Error : access Glib.Error.GError) return Guint; pragma Import (C, Internal, "gtk_builder_add_from_resource"); Acc_Error : aliased Glib.Error.GError; Tmp_Resource_Path : Gtkada.Types.Chars_Ptr := New_String (Resource_Path); Tmp_Return : Guint; begin Tmp_Return := Internal (Get_Object (Builder), Tmp_Resource_Path, Acc_Error'Access); Free (Tmp_Resource_Path); if Error /= null then Error.all := Acc_Error; end if; return Tmp_Return; end Add_From_Resource; --------------------- -- Add_From_String -- --------------------- function Add_From_String (Builder : not null access Gtk_Builder_Record; Buffer : UTF8_String; Error : access Glib.Error.GError) return Guint is function Internal (Builder : System.Address; Buffer : Gtkada.Types.Chars_Ptr; Length : Gsize; Acc_Error : access Glib.Error.GError) return Guint; pragma Import (C, Internal, "gtk_builder_add_from_string"); Acc_Error : aliased Glib.Error.GError; Tmp_Buffer : Gtkada.Types.Chars_Ptr := New_String (Buffer); Tmp_Return : Guint; begin Tmp_Return := Internal (Get_Object (Builder), Tmp_Buffer, -1, Acc_Error'Access); Free (Tmp_Buffer); Error.all := Acc_Error; return Tmp_Return; end Add_From_String; --------------------------- -- Add_Objects_From_File -- --------------------------- function Add_Objects_From_File (Builder : not null access Gtk_Builder_Record; Filename : UTF8_String; Object_Ids : GNAT.Strings.String_List; Error : access Glib.Error.GError) return Guint is function Internal (Builder : System.Address; Filename : Gtkada.Types.Chars_Ptr; Object_Ids : Gtkada.Types.chars_ptr_array; Acc_Error : access Glib.Error.GError) return Guint; pragma Import (C, Internal, "gtk_builder_add_objects_from_file"); Acc_Error : aliased Glib.Error.GError; Tmp_Filename : Gtkada.Types.Chars_Ptr := New_String (Filename); Tmp_Object_Ids : Gtkada.Types.chars_ptr_array := From_String_List (Object_Ids); Tmp_Return : Guint; begin Tmp_Return := Internal (Get_Object (Builder), Tmp_Filename, Tmp_Object_Ids, Acc_Error'Access); Gtkada.Types.Free (Tmp_Object_Ids); Free (Tmp_Filename); Error.all := Acc_Error; return Tmp_Return; end Add_Objects_From_File; ------------------------------- -- Add_Objects_From_Resource -- ------------------------------- function Add_Objects_From_Resource (Builder : not null access Gtk_Builder_Record; Resource_Path : UTF8_String; Object_Ids : GNAT.Strings.String_List; Error : access Glib.Error.GError) return Guint is function Internal (Builder : System.Address; Resource_Path : Gtkada.Types.Chars_Ptr; Object_Ids : Gtkada.Types.chars_ptr_array; Acc_Error : access Glib.Error.GError) return Guint; pragma Import (C, Internal, "gtk_builder_add_objects_from_resource"); Acc_Error : aliased Glib.Error.GError; Tmp_Resource_Path : Gtkada.Types.Chars_Ptr := New_String (Resource_Path); Tmp_Object_Ids : Gtkada.Types.chars_ptr_array := From_String_List (Object_Ids); Tmp_Return : Guint; begin Tmp_Return := Internal (Get_Object (Builder), Tmp_Resource_Path, Tmp_Object_Ids, Acc_Error'Access); Gtkada.Types.Free (Tmp_Object_Ids); Free (Tmp_Resource_Path); Error.all := Acc_Error; return Tmp_Return; end Add_Objects_From_Resource; ----------------------------- -- Add_Objects_From_String -- ----------------------------- function Add_Objects_From_String (Builder : not null access Gtk_Builder_Record; Buffer : UTF8_String; Length : Gsize; Object_Ids : GNAT.Strings.String_List; Error : access Glib.Error.GError) return Guint is function Internal (Builder : System.Address; Buffer : Gtkada.Types.Chars_Ptr; Length : Gsize; Object_Ids : Gtkada.Types.chars_ptr_array; Acc_Error : access Glib.Error.GError) return Guint; pragma Import (C, Internal, "gtk_builder_add_objects_from_string"); Acc_Error : aliased Glib.Error.GError; Tmp_Buffer : Gtkada.Types.Chars_Ptr := New_String (Buffer); Tmp_Object_Ids : Gtkada.Types.chars_ptr_array := From_String_List (Object_Ids); Tmp_Return : Guint; begin Tmp_Return := Internal (Get_Object (Builder), Tmp_Buffer, Length, Tmp_Object_Ids, Acc_Error'Access); Gtkada.Types.Free (Tmp_Object_Ids); Free (Tmp_Buffer); Error.all := Acc_Error; return Tmp_Return; end Add_Objects_From_String; --------------------- -- Connect_Signals -- --------------------- procedure Connect_Signals (Builder : not null access Gtk_Builder_Record; User_Data : System.Address) is procedure Internal (Builder : System.Address; User_Data : System.Address); pragma Import (C, Internal, "gtk_builder_connect_signals"); begin Internal (Get_Object (Builder), User_Data); end Connect_Signals; -------------------------- -- Connect_Signals_Full -- -------------------------- procedure Connect_Signals_Full (Builder : not null access Gtk_Builder_Record; Func : Gtk_Builder_Connect_Func) is begin if Func = null then C_Gtk_Builder_Connect_Signals_Full (Get_Object (Builder), System.Null_Address, System.Null_Address); else C_Gtk_Builder_Connect_Signals_Full (Get_Object (Builder), Internal_Gtk_Builder_Connect_Func'Address, To_Address (Func)); end if; end Connect_Signals_Full; ------------------- -- Expose_Object -- ------------------- procedure Expose_Object (Builder : not null access Gtk_Builder_Record; Name : UTF8_String; Object : not null access Glib.Object.GObject_Record'Class) is procedure Internal (Builder : System.Address; Name : Gtkada.Types.Chars_Ptr; Object : System.Address); pragma Import (C, Internal, "gtk_builder_expose_object"); Tmp_Name : Gtkada.Types.Chars_Ptr := New_String (Name); begin Internal (Get_Object (Builder), Tmp_Name, Get_Object (Object)); Free (Tmp_Name); end Expose_Object; ---------------- -- Get_Object -- ---------------- function Get_Object (Builder : not null access Gtk_Builder_Record; Name : UTF8_String) return Glib.Object.GObject is function Internal (Builder : System.Address; Name : Gtkada.Types.Chars_Ptr) return System.Address; pragma Import (C, Internal, "gtk_builder_get_object"); Tmp_Name : Gtkada.Types.Chars_Ptr := New_String (Name); Stub_GObject : Glib.Object.GObject_Record; Tmp_Return : System.Address; begin Tmp_Return := Internal (Get_Object (Builder), Tmp_Name); Free (Tmp_Name); return Get_User_Data (Tmp_Return, Stub_GObject); end Get_Object; ----------------- -- Get_Objects -- ----------------- function Get_Objects (Builder : not null access Gtk_Builder_Record) return Glib.Object.Object_List.GSlist is function Internal (Builder : System.Address) return System.Address; pragma Import (C, Internal, "gtk_builder_get_objects"); Tmp_Return : Glib.Object.Object_List.GSlist; begin Glib.Object.Object_List.Set_Object (Tmp_Return, Internal (Get_Object (Builder))); return Tmp_Return; end Get_Objects; ---------------------------- -- Get_Translation_Domain -- ---------------------------- function Get_Translation_Domain (Builder : not null access Gtk_Builder_Record) return UTF8_String is function Internal (Builder : System.Address) return Gtkada.Types.Chars_Ptr; pragma Import (C, Internal, "gtk_builder_get_translation_domain"); begin return Gtkada.Bindings.Value_Allowing_Null (Internal (Get_Object (Builder))); end Get_Translation_Domain; ------------------------ -- Get_Type_From_Name -- ------------------------ function Get_Type_From_Name (Builder : not null access Gtk_Builder_Record; Type_Name : UTF8_String) return GType is function Internal (Builder : System.Address; Type_Name : Gtkada.Types.Chars_Ptr) return GType; pragma Import (C, Internal, "gtk_builder_get_type_from_name"); Tmp_Type_Name : Gtkada.Types.Chars_Ptr := New_String (Type_Name); Tmp_Return : GType; begin Tmp_Return := Internal (Get_Object (Builder), Tmp_Type_Name); Free (Tmp_Type_Name); return Tmp_Return; end Get_Type_From_Name; ---------------------------- -- Lookup_Callback_Symbol -- ---------------------------- procedure Lookup_Callback_Symbol (Builder : not null access Gtk_Builder_Record; Callback_Name : UTF8_String) is procedure Internal (Builder : System.Address; Callback_Name : Gtkada.Types.Chars_Ptr); pragma Import (C, Internal, "gtk_builder_lookup_callback_symbol"); Tmp_Callback_Name : Gtkada.Types.Chars_Ptr := New_String (Callback_Name); begin Internal (Get_Object (Builder), Tmp_Callback_Name); Free (Tmp_Callback_Name); end Lookup_Callback_Symbol; ---------------------------- -- Set_Translation_Domain -- ---------------------------- procedure Set_Translation_Domain (Builder : not null access Gtk_Builder_Record; Domain : UTF8_String := "") is procedure Internal (Builder : System.Address; Domain : Gtkada.Types.Chars_Ptr); pragma Import (C, Internal, "gtk_builder_set_translation_domain"); Tmp_Domain : Gtkada.Types.Chars_Ptr; begin if Domain = "" then Tmp_Domain := Gtkada.Types.Null_Ptr; else Tmp_Domain := New_String (Domain); end if; Internal (Get_Object (Builder), Tmp_Domain); Free (Tmp_Domain); end Set_Translation_Domain; ----------------------- -- Value_From_String -- ----------------------- procedure Value_From_String (Builder : not null access Gtk_Builder_Record; Pspec : in out Glib.Param_Spec; String : UTF8_String; Value : out Glib.Values.GValue; Success : out Boolean) is function Internal (Builder : System.Address; Acc_Pspec : access Glib.Param_Spec; String : Gtkada.Types.Chars_Ptr; Acc_Value : access Glib.Values.GValue) return Glib.Gboolean; pragma Import (C, Internal, "gtk_builder_value_from_string"); Acc_Pspec : aliased Glib.Param_Spec := Pspec; Acc_Value : aliased Glib.Values.GValue; Tmp_String : Gtkada.Types.Chars_Ptr := New_String (String); Tmp_Return : Glib.Gboolean; begin Tmp_Return := Internal (Get_Object (Builder), Acc_Pspec'Access, Tmp_String, Acc_Value'Access); Free (Tmp_String); Pspec := Acc_Pspec; Value := Acc_Value; Success := Tmp_Return /= 0; end Value_From_String; ---------------------------- -- Value_From_String_Type -- ---------------------------- function Value_From_String_Type (Builder : not null access Gtk_Builder_Record; The_Type : GType; String : UTF8_String; Value : access Glib.Values.GValue) return Boolean is function Internal (Builder : System.Address; The_Type : GType; String : Gtkada.Types.Chars_Ptr; Acc_Value : access Glib.Values.GValue) return Glib.Gboolean; pragma Import (C, Internal, "gtk_builder_value_from_string_type"); Acc_Value : aliased Glib.Values.GValue; Tmp_String : Gtkada.Types.Chars_Ptr := New_String (String); Tmp_Return : Glib.Gboolean; begin Tmp_Return := Internal (Get_Object (Builder), The_Type, Tmp_String, Acc_Value'Access); Free (Tmp_String); Value.all := Acc_Value; return Tmp_Return /= 0; end Value_From_String_Type; end Gtk.Builder; gtkada-24.0.0/src/generated/gtk-builder.ads000066400000000000000000000744021446021174000204650ustar00rootroot00000000000000------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2022, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- . -- -- -- ------------------------------------------------------------------------------ -- -- A GtkBuilder is an auxiliary object that reads textual descriptions of a -- user interface and instantiates the described objects. To create a -- GtkBuilder from a user interface description, call -- Gtk.Builder.Gtk_New_From_File, Gtk.Builder.Gtk_New_From_Resource or -- Gtk.Builder.Gtk_New_From_String. -- -- In the (unusual) case that you want to add user interface descriptions -- from multiple sources to the same GtkBuilder you can call -- Gtk.Builder.Gtk_New to get an empty builder and populate it by (multiple) -- calls to Gtk.Builder.Add_From_File, Gtk.Builder.Add_From_Resource or -- Gtk.Builder.Add_From_String. -- -- A GtkBuilder holds a reference to all objects that it has constructed and -- drops these references when it is finalized. This finalization can cause -- the destruction of non-widget objects or widgets which are not contained in -- a toplevel window. For toplevel windows constructed by a builder, it is the -- responsibility of the user to call Gtk.Widget.Destroy to get rid of them -- and all the widgets they contain. -- -- The functions Gtk.Builder.Get_Object and Gtk.Builder.Get_Objects can be -- used to access the widgets in the interface by the names assigned to them -- inside the UI description. Toplevel windows returned by these functions -- will stay around until the user explicitly destroys them with -- Gtk.Widget.Destroy. Other widgets will either be part of a larger hierarchy -- constructed by the builder (in which case you should not have to worry -- about their lifecycle), or without a parent, in which case they have to be -- added to some container to make use of them. Non-widget objects need to be -- reffed with g_object_ref to keep them beyond the lifespan of the builder. -- -- The function Gtk.Builder.Connect_Signals and variants thereof can be used -- to connect handlers to the named signals in the description. -- -- # GtkBuilder UI Definitions # {BUILDER-UI} -- -- GtkBuilder parses textual descriptions of user interfaces which are -- specified in an XML format which can be roughly described by the RELAX NG -- schema below. We refer to these descriptions as "GtkBuilder UI definitions" -- or just "UI definitions" if the context is clear. Do not confuse GtkBuilder -- UI Definitions with [GtkUIManager UI Definitions][XML-UI], which are more -- limited in scope. It is common to use `.ui` as the filename extension for -- files containing GtkBuilder UI definitions. -- -- [RELAX NG Compact -- Syntax](https://gitlab.gnome.org/GNOME/gtk/-/blob/gtk-3-24/gtk/gtkbuilder.rnc) -- -- The toplevel element is . It optionally takes a "domain" -- attribute, which will make the builder look for translated strings using -- dgettext in the domain specified. This can also be done by calling -- Gtk.Builder.Set_Translation_Domain on the builder. Objects are described by -- elements, which can contain elements to set properties, -- elements which connect signals to handlers, and elements, -- which describe child objects (most often widgets inside a container, but -- also e.g. actions in an action group, or columns in a tree model). A -- element contains an element which describes the child -- object. The target toolkit version(s) are described by elements, -- the "lib" attribute specifies the widget library in question (currently the -- only supported value is "gtk+") and the "version" attribute specifies the -- target version in the form ".". The builder will error out if -- the version requirements are not met. -- -- Typically, the specific kind of object represented by an element -- is specified by the "class" attribute. If the type has not been loaded yet, -- GTK+ tries to find the get_type function from the class name by applying -- heuristics. This works in most cases, but if necessary, it is possible to -- specify the name of the get_type function explictly with the "type-func" -- attribute. As a special case, GtkBuilder allows to use an object that has -- been constructed by a Gtk.UI_Manager.Gtk_UI_Manager in another part of the -- UI definition by specifying the id of the Gtk.UI_Manager.Gtk_UI_Manager in -- the "constructor" attribute and the name of the object in the "id" -- attribute. -- -- Objects may be given a name with the "id" attribute, which allows the -- application to retrieve them from the builder with Gtk.Builder.Get_Object. -- An id is also necessary to use the object as property value in other parts -- of the UI definition. GTK+ reserves ids starting and ending with ___ (3 -- underscores) for its own purposes. -- -- Setting properties of objects is pretty straightforward with the -- element: the "name" attribute specifies the name of the -- property, and the content of the element specifies the value. If the -- "translatable" attribute is set to a true value, GTK+ uses gettext (or -- dgettext if the builder has a translation domain set) to find a translation -- for the value. This happens before the value is parsed, so it can be used -- for properties of any type, but it is probably most useful for string -- properties. It is also possible to specify a context to disambiguate short -- strings, and comments which may help the translators. -- -- GtkBuilder can parse textual representations for the most common property -- types: characters, strings, integers, floating-point numbers, booleans -- (strings like "TRUE", "t", "yes", "y", "1" are interpreted as True, strings -- like "FALSE", "f", "no", "n", "0" are interpreted as False), enumerations -- (can be specified by their name, nick or integer value), flags (can be -- specified by their name, nick, integer value, optionally combined with "|", -- e.g. "GTK_VISIBLE|GTK_REALIZED") and colors (in a format understood by -- Gdk.RGBA.Parse). -- -- GVariants can be specified in the format understood by Glib.Variant.Parse, -- and pixbufs can be specified as a filename of an image file to load. -- -- Objects can be referred to by their name and by default refer to objects -- declared in the local xml fragment and objects exposed via -- Gtk.Builder.Expose_Object. In general, GtkBuilder allows forward references -- to objects — declared in the local xml; an object doesn't have to be -- constructed before it can be referred to. The exception to this rule is -- that an object has to be constructed before it can be used as the value of -- a construct-only property. -- -- It is also possible to bind a property value to another object's property -- value using the attributes "bind-source" to specify the source object of -- the binding, "bind-property" to specify the source property and optionally -- "bind-flags" to specify the binding flags. Internally builder implements -- this using GBinding objects. For more information see -- g_object_bind_property -- -- Signal handlers are set up with the element. The "name" attribute -- specifies the name of the signal, and the "handler" attribute specifies the -- function to connect to the signal. By default, GTK+ tries to find the -- handler using g_module_symbol, but this can be changed by passing a custom -- Gtk_Builder_Connect_Func to Gtk.Builder.Connect_Signals_Full. The remaining -- attributes, "after", "swapped" and "object", have the same meaning as the -- corresponding parameters of the g_signal_connect_object or -- g_signal_connect_data functions. A "last_modification_time" attribute is -- also allowed, but it does not have a meaning to the builder. -- -- Sometimes it is necessary to refer to widgets which have implicitly been -- constructed by GTK+ as part of a composite widget, to set properties on -- them or to add further children (e.g. the Vbox of a Gtk.Dialog.Gtk_Dialog). -- This can be achieved by setting the "internal-child" property of the -- element to a true value. Note that GtkBuilder still requires an -- element for the internal child, even if it has already been -- constructed. -- -- A number of widgets have different places where a child can be added (e.g. -- tabs vs. page content in notebooks). This can be reflected in a UI -- definition by specifying the "type" attribute on a The possible -- values for the "type" attribute are described in the sections describing -- the widget-specific portions of UI definitions. -- -- # A GtkBuilder UI Definition -- -- |[ 10 -- 20 gtk-ok TRUE -- ]| -- -- Beyond this general structure, several object classes define their own XML -- DTD fragments for filling in the ANY placeholders in the DTD above. Note -- that a custom element in a element gets parsed by the custom tag -- handler of the parent object, while a custom element in an element -- gets parsed by the custom tag handler of the object. -- -- These XML fragments are explained in the documentation of the respective -- objects. -- -- Additionally, since 3.10 a special